@vibelord/lanes 1.1.1 → 1.3.0

package/payload/lanes/client/ghostty/lanes-palette-light.conf

@@ -2,24 +2,24 @@
 # Optional: the cockpit palette regardless of your everyday Ghostty theme (install.sh --client --palette).
 # Slots 1-4 are the four tones, so 16-colour mode here equals truecolor mode. No font, padding or cursor keys.
 background = #f3f5f2
-foreground = #17241b
-cursor-color = #2f6b45
+foreground = #111a14
+cursor-color = #1f6f3f
 selection-background = #d5ded6
-selection-foreground = #17241b
-palette = 0=#3b4a42
-palette = 1=#b7322a
-palette = 2=#1b7142
-palette = 3=#8a5a00
-palette = 4=#2456a8
-palette = 5=#7a3fb8
-palette = 6=#0f7b7b
-palette = 7=#56616d
-palette = 8=#5f6d66
-palette = 9=#c2332a
-palette = 10=#1b7a38
-palette = 11=#8f5a00
-palette = 12=#2860c4
-palette = 13=#8a4dc8
-palette = 14=#0f7272
-palette = 15=#17241b
+selection-foreground = #111a14
+palette = 0=#2f3b34
+palette = 1=#c41c1c
+palette = 2=#0d7338
+palette = 3=#a04d00
+palette = 4=#1a56c4
+palette = 5=#8228c4
+palette = 6=#006f73
+palette = 7=#4a5661
+palette = 8=#55625b
+palette = 9=#d0221a
+palette = 10=#0e7a3a
+palette = 11=#a85200
+palette = 12=#1f5fd8
+palette = 13=#9133d0
+palette = 14=#00797c
+palette = 15=#111a14
 # END lanes tokens

package/payload/lanes/client/ghostty/lanes-palette.conf

@@ -2,24 +2,24 @@
 # Optional: the cockpit palette regardless of your everyday Ghostty theme (install.sh --client --palette).
 # Slots 1-4 are the four tones, so 16-colour mode here equals truecolor mode. No font, padding or cursor keys.
 background = #101318
-foreground = #edf1f5
-cursor-color = #b4e3bf
+foreground = #f2f5f8
+cursor-color = #8fe3a6
 selection-background = #2c333d
-selection-foreground = #edf1f5
-palette = 0=#7d8896
-palette = 1=#f28b7d
-palette = 2=#6fd39a
-palette = 3=#e5b84a
-palette = 4=#7fb3f2
-palette = 5=#c9a6ff
-palette = 6=#6fd6d0
-palette = 7=#9ca7b5
-palette = 8=#8a95a3
-palette = 9=#ff9d96
-palette = 10=#8fe0a3
-palette = 11=#f7cf7f
-palette = 12=#a5cbff
-palette = 13=#dcc6ff
-palette = 14=#9ae6e0
-palette = 15=#edf1f5
+selection-foreground = #f2f5f8
+palette = 0=#8792a0
+palette = 1=#ff7b6e
+palette = 2=#5fdc8a
+palette = 3=#ffc233
+palette = 4=#6fb6ff
+palette = 5=#c58bff
+palette = 6=#3fd9cf
+palette = 7=#a6b1be
+palette = 8=#97a3b1
+palette = 9=#ff9a8e
+palette = 10=#86f0ad
+palette = 11=#ffd866
+palette = 12=#98cbff
+palette = 13=#dcb2ff
+palette = 14=#7deee6
+palette = 15=#f2f5f8
 # END lanes tokens

package/payload/lanes/client/lanes-launch

@@ -3,17 +3,24 @@
 #   lanes-launch [device]        attach this terminal to the device's view session (default: see below)
 #   lanes-launch <workspace>     same, and bring that workspace's tab to the front (e.g. `coder-launch worlds`)
 #   lanes-launch <device> --viewports N   a wide view session: N (2-3) viewports side by side per workspace
-#   lanes-launch <device> [--ascii] [--theme dark|light|auto] [--glyphs M] [--color C]   the device's look (lanes attach)
+#   lanes-launch <device> [--ascii] [--theme T] [--glyphs M] [--color C] [--notify 1|0] [--dim 90|2] [--device-only]   look (lanes attach)
+#                [--editor micro|hx|nvim|vim|auto]   and the editor quick edit (Ctrl-Alt-e) starts (auto: none chosen)
 #   lanes-launch lane <lane-id>  attach straight to ONE lane, no multiplexer in between
 #   lanes-launch ls              list lanes with live status
+#   lanes-launch here [device]   show here the lane you opened last on another device of yours (`lanes here`; default:
+#                                this machine's device); an open window follows, a closed one shows it when it attaches
 #   lanes-launch web phone|laptop|<device> [--desktop|--mobile] [--no-qr]
 #                                a browser view in one step: the server prepares it, prints its private URL and a QR
 #                                code of it (--no-qr: none), then a login token in THIS terminal. phone = <your
 #                                device>-phone (phone layout), laptop = <your device>-web (desktop layout); any other
 #                                name is that device
 #   lanes-launch update [install.sh options]   the newest client from npm, with your remembered install options
+#   lanes-launch --version       this client's release (the VERSION beside it; `dev` without one)
 #   lanes-launch --helper <device> [--service | --while-pid PID]   run only the upload helper
 #                                (--service: the per-machine background service that install.sh sets up)
+# Self-update: at most every 6 h a window (a device, a workspace or `lane <id>`) first asks the server whether this
+# client is older; then, once npm has that release, it installs exactly it with your remembered install options and
+# starts again as that client, once. LANES_NO_AUTOUPDATE=1: never. A client run from a checkout never does.
 # It never ends by itself: after network loss, sleep, or a server that dropped or refused it, it says so, waits and
 # reattaches (Enter = now). Closing the window (or Ctrl-C) ends it. Log: ~/.local/state/lanes-client/launch-<target>.log
 set -u
@@ -25,6 +32,15 @@ fallbacks=${LANES_FALLBACK_HOST:-lanes-ip lanes-public}
 remote='$HOME/.local/bin/lanes'
 config=${XDG_CONFIG_HOME:-$HOME/.config}/lanes
 state=${XDG_STATE_HOME:-$HOME/.local/state}/lanes-client     # logs and helper.alive; `install.sh --check` reads them
+nl='
+'
+# The command line exactly as given, each argument single-quoted for one `eval "set -- $argv"`: the parsing below
+# shifts the arguments away, and a self-update starts this client again with them (self_update).
+argv=
+for arg in "$@"; do
+    case "$arg" in *\'*) arg=$(printf '%s' "$arg" | sed "s/'/'\\\\''/g") ;; esac
+    argv="$argv '$arg'"
+done
 
 default_device() {
     if [ -r "$config/device" ]; then head -n 1 "$config/device"; return; fi
@@ -97,48 +113,193 @@ web_view() {
     exec ssh -t "$host" "sh -c 'wv_release=\$($remote hello 2>/dev/null); wv_release=\${wv_release##* version=}; wv_release=\${wv_release%% *}; case \$wv_release in 0.*|1.0.*) echo \"$wv_old\" >&2; exec $wv_view ;; *) exec $wv_view --default-device $wv_base$wv_qr ;; esac'"
 }
 
-# `lanes-launch update`: the newest client from npm with this machine's remembered choices. Every KEY=VALUE line of
-# ~/.config/lanes/install-options becomes its install.sh flag, checked as install.sh checks the file (a value it would
-# ignore is not passed; it names that one itself), so the update repeats the last install even where the new package
-# would resolve a default differently. Arguments given here follow the replayed ones: on install.sh's command line the
-# last flag wins.
+# A client linked to a checkout (install.sh --link, or ./install.sh in one): it is updated there with git pull, and
+# npm must never replace it with a copy. An installed copy has no install.sh beside its folder (install.sh drops it).
+from_checkout() { [ -r "$(self_dir)/../install.sh" ]; }
+
+# This machine's remembered choices as install.sh flags, one argument per line (no value holds a newline: the file is
+# read line by line). Every KEY=VALUE line of ~/.config/lanes/install-options becomes its flag, checked as install.sh
+# checks the file (a value it would ignore is not passed; it names that one itself), so an update repeats the last
+# install even where the new package would resolve a default differently. Nothing, and status 0, without a readable
+# file; nothing, and status 2, for a file a newer installer wrote (its SCHEMA is unknown here: not replayed).
+replay_options() {
+    ro_options=$config/install-options
+    [ -r "$ro_options" ] || return 0
+    case "$(sed -n 's/^SCHEMA=//p' "$ro_options" | tail -n 1)" in ''|1) ;; *) return 2 ;; esac
+    while IFS= read -r ro_line || [ -n "$ro_line" ]; do
+        ro_value=${ro_line#*=}
+        ro_flag=$(printf '%s' "${ro_line%%=*}" | tr 'A-Z_' 'a-z-')
+        case "$ro_line" in
+            DEVICE=*) case "$ro_value" in ''|*[!a-z0-9_.-]*|.*) ;; *) printf '%s\n' --device "$ro_value" ;; esac ;;
+            KEY=/*|KEY='~/'*) printf '%s\n' --key "$ro_value" ;;
+            SITE=/*) printf '%s\n' --site "$ro_value" ;;
+            SITE=*) case "$ro_value" in ''|.*|*/*|*[!A-Za-z0-9_.-]*) ;; *) printf '%s\n' --site "$ro_value" ;; esac ;;
+            DESKTOP=1|UPLOADS=1|PALETTE=1|CODER_LAUNCH=1) printf '%s\n' "--$ro_flag" ;;
+            DESKTOP=0|UPLOADS=0|PALETTE=0|CODER_LAUNCH=0) printf '%s\n' "--no-$ro_flag" ;;
+        esac                    # (SCHEMA, comments, unknown keys: install.sh does not read them either)
+    done < "$ro_options"
+    return 0
+}
+
+# `lanes-launch update`: the newest client from npm with this machine's remembered choices (replay_options).
+# Arguments given here follow the replayed ones: on install.sh's command line the last flag wins.
 update_client() {
     for uc_arg in "$@"; do
         case "$uc_arg" in --server) echo 'lanes-launch update updates this client; a server updates with: npx @vibelord/lanes@latest --server' >&2; exit 64 ;; esac
     done
-    uc_dir=$(self_dir)
-    if [ -r "$uc_dir/../install.sh" ]; then
-        # (a linked or checkout client: npm would replace it with a copy)
-        echo "lanes-launch update: this client runs from a checkout ($(dirname "$uc_dir")): update it there with git pull, then ./install.sh" >&2
+    if from_checkout; then
+        echo "lanes-launch update: this client runs from a checkout ($(dirname "$(self_dir)")): update it there with git pull, then ./install.sh" >&2
         exit 64
     fi
     command -v npx >/dev/null 2>&1 || { echo 'lanes-launch update: needs Node.js 18 or newer (npx), https://nodejs.org' >&2; exit 69; }
-    uc_given=$#
-    uc_options=$config/install-options
-    if [ -r "$uc_options" ]; then
-        case "$(sed -n 's/^SCHEMA=//p' "$uc_options" | tail -n 1)" in
-            ''|1)
-                while IFS= read -r uc_line || [ -n "$uc_line" ]; do
-                    uc_value=${uc_line#*=}
-                    uc_flag=$(printf '%s' "${uc_line%%=*}" | tr 'A-Z_' 'a-z-')
-                    case "$uc_line" in
-                        DEVICE=*) case "$uc_value" in ''|*[!a-z0-9_.-]*|.*) ;; *) set -- "$@" --device "$uc_value" ;; esac ;;
-                        KEY=/*|KEY='~/'*) set -- "$@" --key "$uc_value" ;;
-                        SITE=/*) set -- "$@" --site "$uc_value" ;;
-                        SITE=*) case "$uc_value" in ''|.*|*/*|*[!A-Za-z0-9_.-]*) ;; *) set -- "$@" --site "$uc_value" ;; esac ;;
-                        DESKTOP=1|UPLOADS=1|PALETTE=1|CODER_LAUNCH=1) set -- "$@" "--$uc_flag" ;;
-                        DESKTOP=0|UPLOADS=0|PALETTE=0|CODER_LAUNCH=0) set -- "$@" "--no-$uc_flag" ;;
-                    esac                    # (SCHEMA, comments, unknown keys: install.sh does not read them either)
-                done < "$uc_options" ;;
-            *) echo "lanes-launch update: $uc_options was written by a newer installer: not replayed" >&2 ;;
-        esac
-    fi
-    # The arguments given here go last: move them behind the replayed flags.
-    while [ "$uc_given" -gt 0 ]; do set -- "$@" "$1"; shift; uc_given=$((uc_given - 1)); done
+    uc_replayed=$(replay_options) || echo "lanes-launch update: $config/install-options was written by a newer installer: not replayed" >&2
+    # One argument per line, the replayed ones first (set -f: a value is never a glob pattern; IFS unset: the default).
+    set -f; IFS=$nl; set -- $uc_replayed "$@"; unset IFS; set +f
     printf 'lanes-launch update: npx --yes @vibelord/lanes@latest %s\n' "$*" >&2
     exec npx --yes @vibelord/lanes@latest "$@"
 }
 
+# ---- self-update (W9 K2) --------------------------------------------------------------------------------------------
+# Before a window connects (attach and `lane <id>`; never the helper, `ls`, `web`, `update` or --version), at most
+# once every 6 h: ask the server whether this client is older (`lanes hello --client-version <this release>`, which
+# then ends its greeting with ` update=<release>`, W9 K1). If it is, and npm has that release, install EXACTLY it,
+# never @latest, with the remembered install options, as `lanes-launch update` would, and start again as the new
+# client with the same command line — once: the restarted client carries LANES_AUTOUPDATED=1 and never updates itself
+# again. LANES_NO_AUTOUPDATE (any value) turns it off; a client run from a checkout, or one without a release, never
+# asks. Nothing here keeps a window from connecting: an update that fails says so in one dim line, and the window goes
+# on with this client. A question that gets no answer (no server, an older one that takes the flag for a device name,
+# a busy one) is only logged: the connection that follows says what is wrong with the path. So is a release npm does
+# not have (yet): a server run from a checkout says its VERSION as soon as it is pulled, which can be before the
+# publish, and no machine can act on that — the next question, 6 h later, asks npm again.
+checked=$state/checked          # its time: when a window of this machine last asked (touched on every question)
+claim=$state/checking           # the folder of the one window asking right now (mkdir is atomic); the answers land in it
+claimed=
+# Whether a question is due: no stamp, one 6 h old or older, or one from the future (a clock that was wrong).
+update_due() {
+    ud_seen=$(mtime "$checked") || return 0
+    [ -n "$ud_seen" ] || return 0
+    ud_age=$(( $(date +%s) - ud_seen ))
+    [ "$ud_age" -ge 21600 ] || [ "$ud_age" -lt 0 ]
+}
+# Windows that open together (a restored session) ask once between them: the first takes the claim, the others go
+# on. A claim older than 10 min was left by a window that closed while it asked; it is taken over.
+take_claim() {
+    mkdir -p "$state" 2>/dev/null || return 1
+    if ! mkdir "$claim" 2>/dev/null; then
+        tc_since=$(mtime "$claim") || return 1
+        [ $(( $(date +%s) - tc_since )) -ge 600 ] || return 1
+        rm -rf "$claim"; mkdir "$claim" 2>/dev/null || return 1
+    fi
+    claimed=1
+}
+drop_claim() {
+    [ -n "$claimed" ] || return 0
+    rm -f "$claim/reply" "$claim/npm.err"; rmdir "$claim" 2>/dev/null || :
+    claimed=
+}
+# npx -> $npx_path and the npm beside it -> $npm_path, both absolute: npx on this PATH, else where the login shell
+# finds it — a window a desktop app opened has the system's minimal PATH (macOS: no Homebrew, no Node.js installer
+# folder), as install.sh knows of an ssh session. Node.js puts npm and npx in one folder. Status 1 without both.
+find_npx() {
+    npx_path=$(command -v npx 2>/dev/null) || npx_path=
+    case "$npx_path" in /*) ;; *)
+        limit=10; tree=1
+        run "${SHELL:-/bin/sh}" -lc 'command -v npx' </dev/null >"$claim/reply" 2>/dev/null || :
+        limit= tree=
+        npx_path=$(tail -n 1 "$claim/reply" 2>/dev/null) ;;        # (a talkative profile prints before it)
+    esac
+    npm_path=$(dirname "$npx_path")/npm
+    case "$npx_path" in /*) [ -x "$npx_path" ] && [ -x "$npm_path" ] ;; *) return 1 ;; esac
+}
+# on_npm <release>: whether npm has that release of the package, asked as npx would fetch it (the same npm, its config
+# and registry). 0: `npm view` printed it. 1: not published (yet) — npm 10 and later end with code E404 ("No match
+# found for version"), earlier ones print nothing. 2: no answer (offline, a proxy or the registry failing, 15 s), with
+# npm's error code, when it gave one, in $npm_code ([A-Z0-9_] only: it is shown). --fetch-retries=0: the window waits
+# for this, and npm's own retries kept a refused registry going past 60 s (MEASURED, npm 11.6.2: 0.3 s without them);
+# the next question, 6 h later, is the retry.
+on_npm() {
+    npm_code=
+    limit=15; tree=1
+    run env PATH="$(dirname "$npx_path"):$PATH" "$npm_path" view "@vibelord/lanes@$1" version --fetch-retries=0 </dev/null >"$claim/reply" 2>"$claim/npm.err" || :
+    limit= tree=
+    if grep -qxF -- "$1" "$claim/reply" 2>/dev/null; then return 0; fi
+    npm_code=$(sed -n 's/.*code \(E[A-Z0-9_]*\).*/\1/p' "$claim/npm.err" 2>/dev/null | head -n 1)
+    if [ "$rc" = 0 ] && [ ! -s "$claim/reply" ]; then return 1; fi
+    [ "$npm_code" = E404 ] && return 1
+    return 2
+}
+# One dim line on the screen, and the same in the log.
+say_dim() { printf '\033[2mlanes: %s\033[0m\r\n' "$1"; log "self-update: $1"; }
+self_update() {
+    [ -z "${LANES_NO_AUTOUPDATE:-}" ] && [ -z "${LANES_AUTOUPDATED:-}" ] && [ -n "$release" ] || return 0
+    ! from_checkout || return 0
+    update_due || return 0
+    take_claim || return 0
+    # (looked at again under the claim: another window may have asked between the first look and the claim)
+    if ! update_due || ! touch "$checked" 2>/dev/null; then drop_claim; return 0; fi
+    # Said while it asks (a busy server needs seconds for banner and key exchange); wiped once it has the answer.
+    printf '\033[2mlanes %s: asking %s for a newer client…\033[0m' "$release" "$host"
+    limit=10
+    run ssh -n -o RequestTTY=no -o BatchMode=yes -o ConnectTimeout=5 "$host" "$remote hello$version" >"$claim/reply" 2>/dev/null || :
+    limit=
+    printf '\r\033[K'
+    su_to=$(awk '$1 == "ok" { for (i = 2; i <= NF; i++) if (substr($i, 1, 7) == "update=") print substr($i, 8); exit }' "$claim/reply" 2>/dev/null)
+    # An exact release only: digits first, nothing npm could read as a tag, a range, a path or a URL (and such text is
+    # never echoed, not even into the log).
+    su_ok=
+    case "$su_to" in
+        ''|"$release") log "self-update: asked $host (exit $rc): no update"; drop_claim; return 0 ;;
+        *[!A-Za-z0-9.+-]*) ;;
+        [0-9]*.[0-9]*.[0-9]*) su_ok=1 ;;
+    esac
+    if [ -z "$su_ok" ]; then log "self-update: asked $host: ignored an update= that names no release"; drop_claim; return 0; fi
+    if ! su_replayed=$(replay_options); then
+        drop_claim
+        say_dim "the server runs $su_to; not updating by itself: $config/install-options was written by a newer installer — run lanes-launch update"
+        return 0
+    fi
+    if ! find_npx; then
+        drop_claim
+        say_dim "the server runs $su_to; no npx and npm (Node.js 18 or newer) on this machine to update with — this window goes on with $release"
+        return 0
+    fi
+    # Only a release npm has is installed: npx would fail on any other one only after its own registry round trip, the
+    # same way on every machine and every 6 h, with nothing the person at this window can do about it (DEF-1786).
+    printf '\033[2mlanes %s: the server runs %s; asking npm for it…\033[0m' "$release" "$su_to"
+    on_npm "$su_to"; su_npm=$?
+    printf '\r\033[K'
+    case "$su_npm" in
+        1) log "self-update: the server runs $su_to, which npm does not have (yet): not installed; asked again in 6 h"
+           drop_claim; return 0 ;;
+        2) drop_claim
+           say_dim "the server runs $su_to; asking npm for it failed (exit $rc${npm_code:+, $npm_code}) — this window goes on with $release; windows try again in 6 h"
+           return 0 ;;
+    esac
+    set -f; IFS=$nl; set -- $su_replayed; unset IFS; set +f
+    say_dim "the server runs $su_to — updating this client from $release: npx --yes @vibelord/lanes@$su_to $*"
+    # The terminal stays this command's (install.sh may ask something; closing the window or Ctrl-C ends both). npx's
+    # folder goes first on its PATH: npx is `#!/usr/bin/env node`, and node lives beside it. tree: npx is the first of a
+    # chain (npm, its shell, the npm wrapper's node, install.sh, its ssh), each waiting for the next; the watchdog and
+    # a closed window end all of it, not only npx, so nothing of the install goes on under the view (DEF-1818).
+    limit=600; tree=1
+    run env PATH="$(dirname "$npx_path"):$PATH" "$npx_path" --yes "@vibelord/lanes@$su_to" "$@" || :
+    limit= tree=
+    drop_claim
+    # install.sh: 0 ready · 3 and 4 installed, but the key or the server is not ready (it said so) · anything else:
+    # npm, the wrapper or the installer failed, or the watchdog ended them, and this client's own files may still be
+    # the old ones. The remedy is this release (npm has it): `lanes-launch update` would install @latest instead.
+    case "$rc" in
+        0|3|4) ;;
+        *) say_dim "the update to $su_to did not finish (exit $rc) — this window goes on with $release; windows try again in 6 h, or now: npx @vibelord/lanes@$su_to"; return 0 ;;
+    esac
+    log "self-update: installed $su_to (exit $rc); starting it"
+    eval "set -- $argv"
+    LANES_AUTOUPDATED=1; export LANES_AUTOUPDATED
+    # (the installed copy is executable; a copy run as `sh <file>` may not be)
+    if [ -x "$0" ]; then exec "$0" "$@"; fi
+    exec /bin/sh "$0" "$@"
+}
+
 while_pid=
 service=
 extra=
@@ -154,12 +315,20 @@ case "${1:-}" in
             esac
         done ;;
     ls) exec ssh -o RequestTTY=no "$host" "$remote ls" ;;
+    here)
+        # `lanes here <device>` on the server: one connection without a terminal (it opens no view; the device's running
+        # window follows). The name is spliced into the remote command line, so it is checked before any connection.
+        [ $# -le 2 ] || { echo 'usage: lanes-launch here [device]' >&2; exit 64; }
+        here_device=${2:-$(default_device)}
+        case "$here_device" in ''|-*|*[!A-Za-z0-9_.-]*) echo "invalid name: $here_device" >&2; exit 64 ;; esac
+        exec ssh -o RequestTTY=no "$host" "$remote here $here_device" ;;
     web) shift; web_view "$@" ;;
     update) shift; update_client "$@" ;;
     lane)
         [ -n "${2:-}" ] || { echo 'usage: lanes-launch lane <lane-id>' >&2; exit 64; }
         mode=open target=$2 ;;
-    -h|--help) sed -n '2,18p' "$0"; exit 0 ;;
+    -h|--help) sed -n '1d;/^#/!q;p' "$0"; exit 0 ;;          # the comment header, however long it grows
+    --version) cv=$(client_version); printf 'lanes-launch %s\n' "${cv:-dev}"; exit 0 ;;
     *) mode=attach target=${1:-$(default_device)} ;;
 esac
 if [ "$mode" = attach ] && [ $# -gt 1 ]; then
@@ -172,7 +341,13 @@ if [ "$mode" = attach ] && [ $# -gt 1 ]; then
             --ascii) extra="$extra --ascii" ;;
             --theme) case "${2:-}" in dark|light|auto) extra="$extra --theme $2"; shift ;; *) echo '--theme takes dark, light or auto' >&2; exit 64 ;; esac ;;
             --glyphs) case "${2:-}" in unicode|ascii|emoji) extra="$extra --glyphs $2"; shift ;; *) echo '--glyphs takes unicode, ascii or emoji' >&2; exit 64 ;; esac ;;
-            --color) case "${2:-}" in truecolor|16|none) extra="$extra --color $2"; shift ;; *) echo '--color takes truecolor, 16 or none' >&2; exit 64 ;; esac ;;
+            --color) case "${2:-}" in truecolor|256|16|none) extra="$extra --color $2"; shift ;; *) echo '--color takes truecolor, 256, 16 or none' >&2; exit 64 ;; esac ;;
+            --notify) case "${2:-}" in 1|0) extra="$extra --notify $2"; shift ;; *) echo '--notify takes 1 or 0' >&2; exit 64 ;; esac ;;
+            --dim) case "${2:-}" in 90|2) extra="$extra --dim $2"; shift ;; *) echo '--dim takes 90 or 2' >&2; exit 64 ;; esac ;;
+            --device-only) extra="$extra --device-only" ;;
+            # Quick edit's editor (Ctrl-Alt-e, W9 E2): the server's own five values. A server older than `lanes edit`
+            # takes it as an unknown flag and records nothing, which costs nothing there: it has no quick edit.
+            --editor) case "${2:-}" in micro|hx|nvim|vim|auto) extra="$extra --editor $2"; shift ;; *) echo '--editor takes micro, hx, nvim, vim or auto' >&2; exit 64 ;; esac ;;
             *) echo "lanes-launch: ignoring unknown option $1" >&2 ;;
         esac
         shift
@@ -182,9 +357,11 @@ fi
 case "$target" in ''|-*|*[!A-Za-z0-9_.-]*) echo "invalid name: $target" >&2; exit 64 ;; esac
 client="$(hostname -s 2>/dev/null || echo client)-$$"
 client=$(printf '%s' "$client" | tr -c 'A-Za-z0-9_.-' '-')
-# Told to `lanes attach`, which says in one line when this client is older than the server (`lanes-launch update`).
-version=$(client_version)
-[ -z "$version" ] || version=" --client-version $version"
+# Told to `lanes attach`, which says in one line when this client is older than the server (`lanes-launch update`),
+# and shown in the connecting line below.
+release=$(client_version)
+version=
+[ -z "$release" ] || version=" --client-version $release"
 
 # ---- log: what a window that showed nothing never left behind ------------------------------------------------------
 # One line per connection event, rotated to .1 at 256 KiB. The service writes to stderr instead: launchd / journald
@@ -208,14 +385,21 @@ reader=
 holding=
 now=
 limit=
+tree=           # set: a timeout or a signal ends the child's whole process tree (kill_tree), not only the child
 helper_pid=
 stop() {
     trap - HUP TERM INT
     exec 2>/dev/null        # bash reports every child it sees die of a signal: noise in a terminal that stays open
-    if [ -n "$child" ]; then kill -TERM "$child" 2>/dev/null || :; fi
+    if [ -n "$child" ] && [ -n "$tree" ]; then
+        # (no second signal may cut the walk short: it stops each process before it ends them all)
+        trap '' HUP TERM INT; kill_tree "$child"
+    elif [ -n "$child" ]; then
+        kill -TERM "$child" 2>/dev/null || :
+    fi
     cancel_watchdog
     if [ -n "$reader" ]; then kill -TERM "$reader" 2>/dev/null || :; fi
     end_helper
+    drop_claim
     log 'stopped: window closed, or a signal'
     exit 0
 }
@@ -267,6 +451,14 @@ run() {
             wait "$timer" 2>/dev/null || :
             if [ -n "$cancelled" ]; then
                 wait "$timer" 2>/dev/null || :
+            elif [ -n "$tree" ]; then
+                # (the timer has ended and is reaped: a cancellation during the walk must not signal its old pid)
+                timer=
+                # Nor run the trap: bash that runs a trap between a pipeline's first and last command never starts the
+                # last one and waits for the first, whose output then fills a pipe bash itself holds — for ever
+                # (DEF-1791). run() cancels as soon as the child ends, mid-walk; there is nothing left to cancel.
+                trap '' HUP TERM INT
+                kill_tree "$child"
             else
                 kill -TERM "$child" 2>/dev/null || :
             fi
@@ -279,6 +471,61 @@ run() {
     cancel_watchdog
     return "$rc"
 }
+# ---- process trees: an installer is more than one process --------------------------------------------------------
+# `npx` runs npm, npm a shell, that shell node (the npm wrapper), node install.sh, install.sh ssh — each waiting in the
+# foreground for the next. Ending the first leaves the rest on this terminal: npm passes TERM to its own child only,
+# node's spawnSync child outlives node, and a command this script starts in the background ignores Ctrl-C (POSIX, for
+# a shell without job control). Its own process group is no way out either: a background group that reads the
+# terminal is stopped (install.sh may ask something). So with $tree set, the watchdog and stop() end the whole tree.
+# children <pid>…: the pids whose parent is one of them, from one `ps` listing (macOS and Linux print the same columns).
+children() { ps -A -o pid= -o ppid= 2>/dev/null | awk -v of=" $* " 'index(of, " " $2 " ") { print $1 }'; }
+# running <pid>…: whether any of them still runs (a zombie has ended; its new parent reaps it).
+running() { ps -A -o pid= -o stat= 2>/dev/null | awk -v of=" $* " 'index(of, " " $1 " ") && $2 !~ /^Z/ { up = 1 } END { exit !up }'; }
+# kill_tree <pid>: TERM to it and to every process under it. Each generation is stopped before its children are
+# listed: a stopped process starts nothing, and no child can be re-parented out of reach (its parent ended) mid-walk.
+# Then TERM and CONT for all, 2 s by the clock for TERM traps (install.sh puts the terminal back), KILL for what is
+# left, and up to 2 s more by the clock until no listing shows it — so a caller goes on only once the whole install has
+# ended. Its callers ignore HUP, TERM and INT first: no trap may run during its pipelines (bash, DEF-1791).
+kill_tree() {
+    unset IFS
+    # Only from a child of this shell ($$ in the watchdog too): one that ended and was reaped may have left its pid to
+    # an unrelated process by now. No answer from ps (gone, or a ps without -p): the child alone, as before.
+    case "$(ps -o ppid= -p "$1" 2>/dev/null | tr -d ' ')" in
+        "$$") ;;
+        '') kill -TERM "$1" 2>/dev/null; return 0 ;;
+        *) return 0 ;;
+    esac
+    kt_all= kt_gen=$1 kt_n=0
+    while [ -n "$kt_gen" ] && [ "$kt_n" -lt 32 ]; do
+        kill -STOP $kt_gen 2>/dev/null
+        kt_all="$kt_all $kt_gen"
+        kt_gen=$(children $kt_gen)
+        kt_n=$((kt_n + 1))
+    done
+    kill -TERM $kt_all 2>/dev/null
+    kill -CONT $kt_all 2>/dev/null
+    # A timer, not a count of polls: each poll lists every process (MEASURED 0.18 s for 3335 processes at load 25),
+    # and 20 polls of `sleep .1` had made the 2 s 6 s (DEF-1790). The shell reaps the ended timer during its next
+    # command (the listing or the sleep; dash and bash alike), so kill -0 fails from then on.
+    sleep 2 >/dev/null 2>&1 &
+    kt_timer=$! kt_killed=
+    while running $kt_all; do
+        if ! kill -0 "$kt_timer" 2>/dev/null; then
+            # A KILLed process ends only once it runs again: once it gets a CPU, or once a disk wait it sleeps in
+            # uninterruptibly ends. So the walk goes on listing after the KILL, on a second 2 s timer (DEF-1776). What
+            # still runs after that is held in the kernel, and the caller goes on without it.
+            if [ -n "$kt_killed" ]; then kt_timer=; break; fi
+            kill -KILL $kt_all 2>/dev/null
+            kt_killed=1
+            sleep 2 >/dev/null 2>&1 &
+            kt_timer=$!
+        fi
+        sleep .1
+    done
+    # (the tree ended within a timer's 2 s: the timer, this shell's own child, still ran one poll ago)
+    if [ -n "$kt_timer" ]; then kill -KILL "$kt_timer" 2>/dev/null; wait "$kt_timer" 2>/dev/null; fi
+    return 0
+}
 # hold <seconds> [jitter]: wait, but Enter continues at once. No raw mode, so there is no terminal state to restore
 # when the window closes mid-wait: a line reader signals this shell instead. End of input (no terminal) is no Enter.
 trap 'if [ -n "$holding" ]; then now=1; [ -z "$child" ] || { kill -TERM "$child"; wait "$child"; } 2>/dev/null; fi' USR1
@@ -450,6 +697,8 @@ if [ "$mode" = helper ]; then
     trap - HUP TERM INT
     upload_helper "$target"; exit 0
 fi
+# A window (attach, or `lane <id>`) checks for a newer client first: a restart then leaves no helper of this one behind.
+self_update
 if [ "$mode" = attach ]; then
     while_pid=$$        # ends the helper also when this client is killed without a chance to clean up
     upload_helper "$target" </dev/null >/dev/null 2>&1 &
@@ -458,8 +707,8 @@ fi
 while :; do
     printf '\033]0;lanes · %s\007' "$target"
     # Said before ssh draws anything: a server under pressure needs many seconds for banner and key exchange, and a
-    # window that stays blank meanwhile reads as dead.
-    printf '\033[2mlanes: connecting to %s…\033[0m\r\n' "$host"
+    # window that stays blank meanwhile reads as dead. It names this client's release (client_version's charset).
+    printf '\033[2mlanes%s: connecting to %s…\033[0m\r\n' "${release:+ $release}" "$host"
     log "connecting: $mode $target via $host"
     started=$(date +%s)
     if [ "$mode" = attach ]; then

package/payload/lanes/client/lanes-window

@@ -1,9 +1,13 @@
 #!/bin/sh
-# Open the lanes window in its own terminal instance. usage: lanes-window [--ascii] [--light|--dark] [suffix]
+# Open the lanes window in its own terminal instance.
+# usage: lanes-window [--ascii] [--light|--dark] [--device-only] [suffix]      (-h / --help: this text)
 #   suffix: an independent view session "<device>-<suffix>" (second monitor / other half of an ultrawide).
 #   w2 / w3: a WIDE view session with 2 / 3 viewports side by side per workspace (for a full-width window).
-#   --ascii / --light / --dark: the cockpit's look for this device (`lanes attach … --ascii|--theme`), remembered on
-#   the server in devices/<device>.json and picked up by a running sidebar and its status screens.
+#   --ascii / --light / --dark: the cockpit's look, remembered on the server as `lanes attach … --ascii|--theme` does.
+#   On a device with an owner (enrolled with an owner, a window of such a machine, or `lanes device claim`) it goes to
+#   that person's profile, shared by all their devices: every running sidebar of theirs paints it within a tick.
+#   --device-only keeps it in devices/<device>.json for this device alone, where it wins over the profile and a
+#   running sidebar and its status screens pick it up within a tick — as for every look on a device without an owner.
 # macOS: Ghostty. Linux: Ghostty when installed, otherwise Foot with the same window class.
 set -u
 config=${XDG_CONFIG_HOME:-$HOME/.config}/lanes
@@ -12,13 +16,21 @@ class=org.omarchy.lanes
 device=
 file=$config/ghostty.conf
 look=
+only=
 while [ $# -gt 0 ]; do
     case "$1" in
+        -h|--help) sed -n '2,/^[^#]/{/^#/p;}' "$0"; exit 0 ;;
         --ascii) look="$look --ascii"; shift ;;
         --light|--dark) look="$look --theme ${1#--}"; shift ;;
+        --device-only) only=' --device-only'; shift ;;
         *) break ;;
     esac
 done
+if [ -n "$only" ]; then
+    # Alone it would record nothing: say so instead of opening a window that looks like it did.
+    [ -n "$look" ] || { echo 'lanes-window: --device-only goes with --ascii, --light or --dark' >&2; exit 64; }
+    look="$look$only"
+fi
 if [ -n "${1:-}" ]; then
     case "$1" in *[!A-Za-z0-9_.-]*) echo 'invalid suffix' >&2; exit 64 ;; esac
     device="$(head -n 1 "$config/device")-$1"

package/payload/lanes/container/hooks/claude-settings.json

@@ -1,5 +1,6 @@
 {"hooks": {
   "UserPromptSubmit": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event UserPromptSubmit --harness claude", "timeout": 2}]}],
+  "PreToolUse": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event PreToolUse --harness claude", "timeout": 2}]}],
   "PostToolUse": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event PostToolUse --harness claude", "timeout": 2}]}],
   "Stop": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_input --event Stop --harness claude", "timeout": 2}]}],
   "Notification": [{"matcher": "permission_prompt", "hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_approval --event Notification --harness claude", "timeout": 2}]},