local pid_dir log_dir

pid_dir="$(dirname "$PID_FILE")"

log_dir="$(dirname "$LOG_FILE")"

mkdir -p "$pid_dir" "$log_dir"

chmod 0700 "$pid_dir"

chmod 0700 "$log_dir"

check_private_state_dir "$pid_dir" || return 1

check_private_state_dir "$log_dir" || return 1

local dir="$1" mode digits numeric

[[ -O "$dir" ]] || { err "State directory is not owned by this user: $dir"; return 1; }

mode="$(stat -c '%a' "$dir" 2>/dev/null || stat -f '%Lp' "$dir" 2>/dev/null)" || {

err "Cannot inspect state-directory permissions: $dir"; return 1;

}

digits="${mode: -3}"

[[ "$digits" =~ ^[0-7]{3}$ ]] || { err "Cannot inspect state-directory permissions: $dir"; return 1; }

numeric=$((8#$digits))

if (( numeric & 022 )); then

err "State directory is group/world-writable; choose a private location: $dir"

return 1

fi

local title="$1"

local body="$2"

err "$title"

# ${body//…} rather than `echo "$body" | sed 's/^/ /'` (shellcheck SC2001):

# the same two-space indent on every line, including empty ones, with no

# subprocess per call.

printf ' %s\n' "${body//$'\n'/$'\n '}" >&2

if is_gui_context; then

if command -v kdialog >/dev/null 2>&1; then kdialog --title "$APP_DISPLAY: $title" --error "$body" 2>/dev/null &

elif command -v zenity >/dev/null 2>&1; then zenity --error --title="$APP_DISPLAY: $title" --text="$body" --width=500 2>/dev/null &

elif command -v notify-send >/dev/null 2>&1; then notify-send --urgency=critical --icon=dialog-error "$APP_DISPLAY: $title" "$body" 2>/dev/null &

elif command -v xmessage >/dev/null 2>&1; then xmessage -center "$APP_DISPLAY: $title\n\n$body" 2>/dev/null &

fi

fi

case "$(uname -s)" in

Linux*) echo "linux" ;;

Darwin*) echo "macos" ;;

CYGWIN*|MINGW*|MSYS*|Windows_NT) echo "windows" ;;

*) echo "unknown" ;;

esac

local pid_dir

pid_dir="$(dirname "$PID_FILE")"

[ -d "$pid_dir" ] || return 0

check_private_state_dir "$pid_dir"

local pid

IFS= read -r pid < "$PID_FILE" || return 1

if [[ ! "$pid" =~ ^[0-9]{1,10}$ ]] || (( 10#$pid < 2 )); then

err "Invalid PID value in $PID_FILE"

return 1

fi

printf '%s' "$pid"

[ -f "$PID_FILE" ] || return 1

pid_directory_is_safe || return 1

local pid

pid="$(read_pid)" || return 1

kill -0 "$pid" 2>/dev/null

if [ -f "$PID_FILE" ] && ! is_running; then

warn "Removing stale or invalid PID file"

rm -f "$PID_FILE"

fi

local max_wait=${1:-15}

local waited=0

while [ "$waited" -lt "$max_wait" ]; do

if command -v curl >/dev/null 2>&1 && curl -fsS "$URL" >/dev/null 2>&1; then

return 0

fi

sleep 1

waited=$((waited + 1))

done

return 1

ensure_state_dirs || return 1

clear_stale_pid

if is_running; then

log "Already running (PID $(read_pid))"

return 0

fi

if [ -z "${START_COMMAND:-}" ] || { [ ! "${START_COMMAND:0:1}" = "(" ] && [ ! -x "${START_COMMAND%% *}" ] && ! command -v "${START_COMMAND%% *}" >/dev/null 2>&1; }; then

if [ -z "${START_COMMAND:-}" ]; then

gui_error "No startup command found" \

return 1

fi

fi

log "Starting $APP_DISPLAY..."

cd "$REPO_DIR" 2>/dev/null || true

nohup "${START_COMMAND[@]}" >"$LOG_FILE" 2>&1 &

echo $! > "$PID_FILE"

sleep 0.2

local started_pid

started_pid="$(read_pid)" || { rm -f "$PID_FILE"; return 1; }

if ! kill -0 "$started_pid" 2>/dev/null; then

gui_error "Process exited immediately" "Check $LOG_FILE"

rm -f "$PID_FILE"

return 1

fi

if ! wait_for_url "$WAIT_SECONDS"; then

gui_error "Server did not start" \

if command -v feedback-o-tron >/dev/null 2>&1; then

feedback-o-tron --event "launcher:start_failed" \

--app "$APP_NAME" --url "$URL" --log "$LOG_FILE" \

--error "Timeout after $WAIT_SECONDS seconds" 2>/dev/null || true

fi

return 1

fi

log "Server started (PID $(read_pid)) — $URL"

return 0

if ! is_running; then

log "No running instance found"

return 0

fi

log "Stopping $APP_DISPLAY..."

pid_directory_is_safe || return 1

local pid

pid="$(read_pid)" || return 1

kill "$pid" 2>/dev/null || true

rm -f "$PID_FILE"

log "Stopped"

if [ -z "$URL" ]; then

log "No URL configured for $APP_DISPLAY"

return 1

fi

if ! is_running; then

err "Server is not running — use --start or --auto first"

return 1

fi

log "Opening $URL..."

case "$PLATFORM" in

linux)

if command -v xdg-open >/dev/null 2>&1; then xdg-open "$URL" &

elif command -v firefox >/dev/null 2>&1; then firefox "$URL" &

elif command -v chromium >/dev/null 2>&1; then chromium "$URL" &

else warn "No browser found — open manually: $URL"; fi ;;

macos) open "$URL" 2>/dev/null || warn "Open manually: $URL" ;;

windows)

if command -v start >/dev/null 2>&1; then start "$URL"

elif command -v cygstart >/dev/null 2>&1; then cygstart "$URL"

else warn "Open manually: $URL"; fi ;;

*) warn "Unknown platform — open manually: $URL" ;;

esac

local found_marker="false" target

local marker_targets=("$LAUNCHER_TARGET" "$DESKTOP_FILE_TARGET" "$DESKTOP_SHORTCUT_TARGET")

for target in "${marker_targets[@]}"; do

if ! path_exists "$target"; then

continue

fi

if [ "$target" = "$LAUNCHER_TARGET" ]; then

if [ ! -f "$target" ] || ! grep -Eq '^# GENERATED by launch-scaffolder from .+' "$target" 2>/dev/null; then

return 1

fi

else

if [ ! -f "$target" ] || ! grep -Fxq '# X-Launch-Scaffolder=launch-scaffolder' "$target" 2>/dev/null; then

return 1

fi

fi

found_marker="true"

done

if path_exists "$ICON_TARGET"; then

if [ ! -f "$ICON_MARKER_TARGET" ] || ! grep -Fxq 'launch-scaffolder managed icon' "$ICON_MARKER_TARGET" 2>/dev/null; then

return 1

fi

found_marker="true"

fi

if path_exists "$ICON_MARKER_TARGET"; then

if [ ! -f "$ICON_MARKER_TARGET" ] || ! grep -Fxq 'launch-scaffolder managed icon' "$ICON_MARKER_TARGET" 2>/dev/null; then

return 1

fi

found_marker="true"

fi

[ "$found_marker" = "true" ]

local temp

if ! temp="$(mktemp "${ICON_MARKER_TARGET}.tmp.XXXXXX")"; then

err "cannot create temporary icon ownership marker"

return 1

fi

if ! printf '%s\n' 'launch-scaffolder managed icon' >"$temp" || \

! chmod 0644 "$temp" || ! mv -f "$temp" "$ICON_MARKER_TARGET"; then

rm -f "$temp"

err "cannot atomically write icon ownership marker"

return 1

fi

local source="$1" class="pl-s">"$2" mode="$3" temp

if ! temp="$(mktemp "${target}.tmp.XXXXXX")"; then

err "cannot create temporary file beside $target"

return 1

fi

if ! cp "$source" "$temp" || ! chmod "$mode" "$temp" || ! mv -f "$temp" "$target"; then

rm -f "$temp"

err "cannot atomically install $target"

return 1

fi

local value="$1"

value="${value//\\/\\\\}"

value="${value//$'\n'/\\n}"

value="${value//$'\r'/\\r}"

value="${value//$'\t'/\\t}"

printf '%s' "$value"

local value="$1"

value="${value//\\/\\\\\\\\}"

value="${value//\"/\\\"}"

value="${value//\`/\\\`}"

value="${value//\$/\\\$}"

value="${value//%/%%}"

printf '"%s"\n' "$value"

local keepopen="/var/mnt/eclipse/repos/.desktop-tools/keepopen.sh"

if [ ! -f "$keepopen" ] || [ ! -x "$keepopen" ]; then

err "Required desktop helper is missing or not executable: $keepopen"

return 1

fi

printf '%s\n' "$keepopen"

local class="pl-s">"$1" temp

local icon_name

if [ -f "$ICON_TARGET" ]; then

icon_name="$APP_NAME"

else

icon_name="package-x-generic"

fi

# keepopen.sh implements the standard fallback ladder: GUI → TUI →

# bash-at-repo-root. See launcher-standard.adoc §Fallback Ladder.

local keepopen

keepopen="$(require_keepopen)" || return 1

local gui_cmd tui_cmd quoted_launcher quoted_log

printf -v quoted_launcher '%q' "$LAUNCHER_TARGET"

printf -v quoted_log '%q' "$LOG_FILE"

# stays open); TUI = start-only + follow log; Shell = repo root.

gui_cmd="$quoted_launcher --auto && tail -f $quoted_log"

tui_cmd="$quoted_launcher --start && tail -f $quoted_log"

if ! temp="$(mktemp "${target}.tmp.XXXXXX")"; then

err "cannot create temporary desktop file beside $target"

return 1

fi

if ! cat > "$temp" <<EOF

then

rm -f "$temp"

err "cannot write desktop file $target"

return 1

fi

if ! chmod 0644 "$temp" || ! mv -f "$temp" "$target"; then

rm -f "$temp"

err "cannot atomically install desktop file $target"

return 1

fi

# Check the desktop helper before any target is written (no partial install).

require_keepopen >/dev/null || return 1

mkdir -p "$APPS_DIR" "$ICON_DIR" "$BIN_DIR" "$DESKTOP_SHORTCUT_DIR"

# Declared and assigned separately (shellcheck SC2155). `local x="$(cmd)"`

# takes its exit status from `local`, so a failed `cd` was swallowed and the

# next line copied this script to $LAUNCHER_TARGET from a path assembled out

# of nothing — the one finding of the three with real failure-masking.

local script_dir

local script_path

if ! script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"; then

err "cannot resolve this script's own directory"

return 1

fi

script_path="$script_dir/$(basename "${BASH_SOURCE[0]}")"

atomic_copy "$script_path" "$LAUNCHER_TARGET" 0755 || return 1

log " + launcher: $LAUNCHER_TARGET"

if [ -n "$ICON_SOURCE" ] && [ -f "$ICON_SOURCE" ]; then

atomic_copy "$ICON_SOURCE" "$ICON_TARGET" 0644 || return 1

atomic_write_icon_marker || return 1

log " + icon: $ICON_TARGET"

else

log " · no custom icon — using system fallback (package-x-generic)"

fi

write_linux_desktop_file "$DESKTOP_FILE_TARGET" || return 1

log " + menu: $DESKTOP_FILE_TARGET"

write_linux_desktop_file "$DESKTOP_SHORTCUT_TARGET" || return 1

log " + desktop: $DESKTOP_SHORTCUT_TARGET"

command -v update-desktop-database >/dev/null 2>&1 && \

update-desktop-database "$APPS_DIR" 2>/dev/null || true

if command -v gio >/dev/null 2>&1; then

gio set "$DESKTOP_FILE_TARGET" "metadata::trusted" true 2>/dev/null || true

gio set "$DESKTOP_SHORTCUT_TARGET" "metadata::trusted" true 2>/dev/null || true

fi

if [ -x "/var/mnt/eclipse/repos/.desktop-tools/verify-desktop-integrity.sh" ]; then

# if/else, not `cmd && log || log`: in that form a FAILING log on the

# success branch also fires the failure branch, so a run that worked

# reports both "generated" and "generation failed". The command's own

# status is what should choose the message.

if /var/mnt/eclipse/repos/.desktop-tools/verify-desktop-integrity.sh --generate 2>/dev/null; then

log " + integrity hashes generated"

else

log " · integrity hash generation failed (non-fatal)"

fi

fi

# Fast path: delegate to `launch-scaffolder provision` when it's on

# $PATH and the source config is still where it was at mint time.

# Keeps one authoritative implementation instead of drifting between

# this template and the Rust binary. Falls through to the shell

# implementation if either condition fails.

if command -v launch-scaffolder >/dev/null 2>&1 && [ -n "$CONFIG_FILE" ] && [ -f "$CONFIG_FILE" ]; then

local forward=(launch-scaffolder provision --integ "$CONFIG_FILE" --no-confirm)

[ "$FORCE" = "true" ] && forward+=(--force)

log "Delegating to launch-scaffolder provision..."

exec "${forward[@]}"

fi

if already_integrated; then

if ! is_managed_install; then

err "refusing to overwrite unmarked integration files for $APP_NAME"

return 1

fi

if [ "$FORCE" != "true" ]; then

warn "$APP_DISPLAY is already integrated."

read -rp "Reinstall? [y/N] " confirm

[[ ! "$confirm" =~ ^[Yy]$ ]] && { log "Nothing changed."; return 0; }

fi

fi

log "Integrating $APP_DISPLAY with the $PLATFORM desktop..."

case "$PLATFORM" in

linux) do_integ_linux || return 1 ;;

*) err "Only Linux integration is implemented in the generated template so far."; return 1 ;;

esac

log "✓ $APP_DISPLAY is now in your menu and on your Desktop."

ensure_state_dirs || return 1

# Fast path: delegate to `launch-scaffolder provision --disinteg`

# when available. Stop any running process first so the binary

# doesn't have to re-implement the process-management arm.

if is_running; then

log " • stopping running server"

stop_server

fi

if command -v launch-scaffolder >/dev/null 2>&1 && [ -n "$CONFIG_FILE" ] && [ -f "$CONFIG_FILE" ]; then

log "Delegating to launch-scaffolder provision..."

exec launch-scaffolder provision --disinteg "$CONFIG_FILE" --no-confirm

fi

if already_integrated && ! is_managed_install; then

err "refusing to remove unmarked integration files for $APP_NAME"

return 1

fi

log "Removing $APP_DISPLAY system integration..."

local removed_anything="false"

local targets=(

"$DESKTOP_FILE_TARGET"

"$DESKTOP_SHORTCUT_TARGET"

"$ICON_TARGET"

"$ICON_MARKER_TARGET"

"$LAUNCHER_TARGET"

)

for t in "${targets[@]}"; do

[ -z "$t" ] && continue

if [ -e "$t" ] || [ -L "$t" ]; then

rm -f "$t"

log " - removed $t"

removed_anything="true"

fi

done

[ "$PLATFORM" = "linux" ] && command -v update-desktop-database >/dev/null 2>&1 && \

update-desktop-database "$APPS_DIR" 2>/dev/null || true

rm -f "$PID_FILE"

if [ "$removed_anything" = "true" ]; then

log "✓ $APP_DISPLAY removed from your system."

else

log "Nothing to remove — $APP_DISPLAY was not integrated here."

fi

cat <<EOF

local arch

arch="$(uname -m)"

printf '%s-%s' "$PLATFORM" "$arch"