@vibelord/lanes 1.0.0

package/payload/lanes/client/ghostty/common.conf

@@ -0,0 +1,22 @@
+# lanes window — shared by macOS and Omarchy. Loaded by a SEPARATE Ghostty instance
+# (`--config-default-files=false --config-file=…`), so the everyday Ghostty config is never modified.
+# The everyday config is inherited first (fonts, theme, padding); `?` = optional include.
+config-file = ?~/.config/ghostty/config.ghostty
+config-file = ?~/.config/ghostty/config
+
+# The window IS the client: closing it just detaches; nothing on the server stops.
+confirm-close-surface = false
+shell-integration = none
+window-save-state = never
+quit-after-last-window-closed = true
+# Last backstop. lanes-launch holds and reattaches by itself and never ends; should it end anyway (killed, a usage
+# error), the window stays open with the reason on screen — a window that vanishes reads as "my lanes are gone".
+wait-after-command = true
+
+# zellij on the server owns copy/paste through OSC 52; tmux/zmx own lane history.
+clipboard-write = allow
+clipboard-read = ask
+copy-on-select = clipboard
+mouse-shift-capture = never
+scrollback-limit = 10000000
+link-url = true

package/payload/lanes/client/ghostty/macos.conf

@@ -0,0 +1,6 @@
+# macOS specifics for the lanes window.
+# Ghostty 1.3.1: CVDisplayLink init failures surface as OutOfMemory; keep the proven workaround.
+window-vsync = false
+macos-titlebar-style = transparent
+# Left Option is Alt for the Ctrl-Alt zellij scheme; right Option still types special characters.
+macos-option-as-alt = left

package/payload/lanes/client/ghostty/omarchy.conf

@@ -0,0 +1,19 @@
+# Omarchy / Hyprland specifics for the lanes window (Ghostty GTK, dedicated instance).
+# Look & feel is inherited from ~/.config/ghostty/config (Omarchy's default: theme include, JetBrainsMono Nerd
+# Font, shift+enter as CSI-u, control+insert / shift+insert copy & paste), so Omarchy theme switches follow.
+# Do NOT include the theme file here as well: Ghostty reports a second include of the same file as
+# "config-file …: cycle detected" and opens its configuration-errors window.
+
+# org.omarchy.* is matched by Omarchy's `+terminal` window tag (default/hypr/apps/terminals.lua), so Super+C /
+# Super+V send Ctrl+Insert / Shift+Insert here. Without the tag Omarchy would send Ctrl+C — into an agent.
+class = org.omarchy.lanes
+# A dedicated instance must load its own config: single-instance mode would reuse a running Ghostty's config.
+gtk-single-instance = false
+window-decoration = none
+
+# GTK defaults bind ctrl+alt+arrows to goto_split:* (performable, so they pass through without splits);
+# unbinding keeps the zellij scheme deterministic: Ctrl-Alt-←/→ = workspace, Ctrl-Alt-↑/↓ = lane.
+keybind = ctrl+alt+up=unbind
+keybind = ctrl+alt+down=unbind
+keybind = ctrl+alt+left=unbind
+keybind = ctrl+alt+right=unbind

package/payload/lanes/client/install.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+# Former entry point, kept for muscle memory and old notes. The installer now lives one level up: ../install.sh
+#   client/install.sh [--parallel] [device]  ->  ../install.sh --link [--device device]
+#   client/install.sh --switch               ->  ../install.sh --link --coder-launch
+#   client/install.sh --rollback             ->  put a previous coder-launch back
+set -eu
+root=$(cd "$(dirname "$0")/.." && pwd)
+case "${1:-}" in
+    --switch) exec "$root/install.sh" --link --coder-launch ;;
+    --rollback)
+        bin=$HOME/.local/bin
+        if [ -e "$bin/coder-launch-legacy" ]; then rm -f "$bin/coder-launch"; mv "$bin/coder-launch-legacy" "$bin/coder-launch"; echo '  coder-launch is the previous client again'
+        else echo '  nothing to roll back'; fi ;;
+    --parallel) shift; exec "$root/install.sh" --link ${1:+--device "$1"} ;;
+    *) exec "$root/install.sh" --link ${1:+--device "$1"} ;;
+esac

package/payload/lanes/client/lanes-launch

@@ -0,0 +1,315 @@
+#!/bin/sh
+# lanes-launch — client for the lanes workspace server (macOS and Linux; POSIX sh, no dependencies).
+#   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 lane <lane-id>  attach straight to ONE lane, no multiplexer in between
+#   lanes-launch ls              list lanes with live status
+#   lanes-launch --helper <device> [--service | --while-pid PID]   run only the upload helper
+#                                (--service: the per-machine background service that install.sh sets up)
+# 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
+host=${LANES_HOST:-lanes}
+primary=$host
+fallback=${LANES_FALLBACK_HOST:-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
+
+default_device() {
+    if [ -r "$config/device" ]; then head -n 1 "$config/device"; return; fi
+    name=$(hostname -s 2>/dev/null || hostname)
+    printf '%s' "$name" | tr 'A-Z' 'a-z' | tr -c 'a-z0-9_.-' '-' | sed 's/-*$//'
+}
+
+while_pid=
+service=
+extra=
+case "${1:-}" in
+    --helper)
+        mode=helper target=${2:?device}; shift 2
+        while [ $# -gt 0 ]; do
+            case "$1" in
+                --service) service=1; shift ;;
+                --while-pid) while_pid=${2:?pid}; shift 2 ;;
+                # Said out loud: an option that is dropped silently is how a client ran "as a service" without being one.
+                *) echo "lanes-launch: ignoring unknown helper option $1" >&2; shift ;;
+            esac
+        done ;;
+    ls) exec ssh -o RequestTTY=no "$host" "$remote ls" ;;
+    lane)
+        [ -n "${2:-}" ] || { echo 'usage: lanes-launch lane <lane-id>' >&2; exit 64; }
+        mode=open target=$2 ;;
+    -h|--help) sed -n '2,11p' "$0"; exit 0 ;;
+    *) mode=attach target=${1:-$(default_device)} ;;
+esac
+if [ "$mode" = attach ] && [ "${2:-}" = --viewports ]; then
+    case "${3:-}" in 1|2|3) extra="--viewports $3" ;; *) echo '--viewports takes 1, 2 or 3' >&2; exit 64 ;; esac
+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_.-' '-')
+
+# ---- 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
+# keep that, and `install.sh --check` points there. Logging must never be the reason an attach fails.
+logfile=
+mkdir -p "$state" 2>/dev/null && logfile=$state/launch-$target.log
+log() {
+    if [ -n "$service" ]; then printf '%s %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$*" >&2; return 0; fi
+    [ -n "$logfile" ] || return 0
+    size=0; [ ! -f "$logfile" ] || size=$(wc -c < "$logfile")
+    if [ "$((size))" -gt 262144 ]; then mv -f "$logfile" "$logfile.1" 2>/dev/null || :; fi
+    printf '%s [%s] %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$$" "$*" >> "$logfile" 2>/dev/null || :
+}
+
+# Run ssh as an async child so HUP/TERM (window closed, logout) end it immediately; a foreground child
+# would defer the trap until ssh returned. Keep the terminal on fd 9: dash gives async jobs /dev/null.
+child=
+reader=
+holding=
+now=
+limit=
+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 "$reader" ]; then kill -TERM "$reader" 2>/dev/null || :; fi
+    end_helper
+    log 'stopped: window closed, or a signal'
+    exit 0
+}
+end_helper() {
+    [ -n "${helper_pid:-}" ] || return 0
+    pkill -TERM -P "$helper_pid" 2>/dev/null || :
+    kill -TERM "$helper_pid" 2>/dev/null || :
+}
+# INT too: in a plain terminal Ctrl-C is the way out, now that nothing else ends the client.
+trap stop HUP TERM INT
+# With $limit set, a watchdog ends a child that the server leaves hanging (macOS has no timeout(1)).
+run() {
+    exec 9<&0
+    "$@" <&9 9<&- &
+    child=$!
+    exec 9<&-
+    dog=
+    if [ -n "$limit" ]; then ( sleep "$limit"; kill -TERM "$child" ) >/dev/null 2>&1 & dog=$!; fi
+    rc=0
+    wait "$child" || rc=$?
+    child=
+    if [ -n "$dog" ]; then kill -TERM "$dog" 2>/dev/null || :; wait "$dog" 2>/dev/null || :; fi
+    return "$rc"
+}
+# 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
+hold() {
+    now=; holding=1
+    exec 9<&0
+    ( IFS= read -r line <&9 && kill -USR1 "$$" ) 2>/dev/null &
+    reader=$!
+    exec 9<&-
+    run sleep "$1" || :
+    # Jitter is a second sleep: should its number ever be malformed, the whole wait is still served — no tight loop.
+    if [ -z "$now" ] && [ -n "${2:-}" ]; then run sleep "$2" || :; fi
+    holding=
+    kill -TERM "$reader" 2>/dev/null || :
+    wait "$reader" 2>/dev/null || :
+    reader=
+}
+# The fallback host counts only if the ssh config really defines it (an undefined alias resolves to itself).
+fallback_defined() {
+    resolved=$(ssh -G "$fallback" 2>/dev/null | awk '$1 == "hostname" { print $2; exit }')
+    [ -n "$resolved" ] && [ "$resolved" != "$fallback" ]
+}
+# ---- upload helper: serves the sidebar's upload box ------------------------------------------------------------
+# A drop on the terminal only gives the SERVER a local path string; the file lives here. This helper waits for
+# such requests and uploads the files with lanes-upload. It is the security boundary: it reads ONLY from folders
+# listed in ~/.config/lanes/upload-allow (asks once per new folder on macOS) and never from credential folders.
+allowed_path() {
+    real=$(cd "$(dirname "$1")" 2>/dev/null && pwd -P)/$(basename "$1")
+    case "$real" in
+        "$HOME"/.ssh/*|"$HOME"/.gnupg/*|"$HOME"/.aws/*|"$HOME"/.kube/*|"$HOME"/.config/*|"$HOME"/.docker/*|\
+        "$HOME"/Library/Keychains/*|"$HOME"/Library/Application\ Support/*[Kk]eychain*|*/.git/*|/etc/*|/private/etc/*) return 1 ;;
+    esac
+    [ -e "$real" ] || return 1
+    while IFS= read -r dir; do
+        [ -n "$dir" ] || continue
+        case "$real" in "$dir"/*) return 0 ;; esac
+    done < "$config/upload-allow" 2>/dev/null
+    folder=$(dirname "$real")
+    if [ "$(uname -s)" = Darwin ]; then
+        answer=$(/usr/bin/osascript -e "display dialog \"The lanes upload box wants to send a file from:\n\n$folder\n\nAllow uploads from this folder?\" with title \"Lanes upload\" buttons {\"Deny\", \"Allow once\", \"Always allow\"} default button \"Allow once\" giving up after 60" -e 'button returned of result' 2>/dev/null)
+        case "$answer" in
+            'Always allow') printf '%s\n' "$folder" >> "$config/upload-allow"; return 0 ;;
+            'Allow once') return 0 ;;
+        esac
+    fi
+    return 1
+}
+# Epoch mtime. GNU form first: GNU `stat -f` means "file system" and prints that before failing; BSD rejects -c silently.
+mtime() { stat -c %Y "$1" 2>/dev/null || stat -f %m "$1" 2>/dev/null; }
+# The machine's helper SERVICE touches helper.alive on every READY/PING line (one every 5 s): serving = under 90 s old.
+service_serving() {
+    seen=$(mtime "$state/helper.alive") || return 1
+    [ -n "$seen" ] && [ $(( $(date +%s) - seen )) -lt 90 ]
+}
+upload_helper() {
+    [ -x "$HOME/.local/bin/lanes-upload" ] || return 0
+    dflt=$(default_device)
+    # One helper serves the machine: the server spools the requests of a suffixed view (mac-2, mac-w2) under the BASE
+    # device and remembers the asking view itself, so the line protocol and `--device` below need nothing new.
+    case "$1" in "$dflt"-*) helper_target=$dflt ;; *) helper_target=$1 ;; esac
+    mkdir -p "$config"
+    [ -e "$config/upload-allow" ] || for dir in "$HOME/Desktop" "$HOME/Downloads" "$HOME/Pictures" "$HOME/Documents" "$HOME/Lanes Uploads" \
+        /var/folders /private/var/folders /tmp /private/tmp; do [ -d "$dir" ] && (cd "$dir" && pwd -P) >> "$config/upload-allow"; done
+    errfile=/dev/null; [ ! -d "$state" ] || errfile=$state/helper.err     # ssh's last complaint only: bounded by design
+    up=         # '' unknown, 1 serving, 0 down: only the transitions are logged (nobody rotates the launchd log)
+    pause=3
+    while :; do
+        if [ -n "$while_pid" ] && ! kill -0 "$while_pid" 2>/dev/null; then exit 0; fi   # the window it serves is gone
+        # A window's own helper is the fallback only. While the service serves this machine it opens no connection
+        # (each one is a long-lived process on the server); when the service goes quiet it takes over within ~2 min.
+        if [ -z "$service" ] && [ "$helper_target" = "$dflt" ] && service_serving; then sleep 30; continue; fi
+        if ssh -o RequestTTY=no -o BatchMode=yes -o ServerAliveInterval=15 -o ServerAliveCountMax=4 "$primary" "$remote upload-requests $helper_target --default-device $dflt" 2>"$errfile" |
+        (   heard=1
+            while IFS= read -r line; do
+                case "$line" in
+                    READY|PING)
+                        heard=0
+                        [ -z "$service" ] || touch "$state/helper.alive" 2>/dev/null
+                        [ "$up" = 1 ] || { up=1; log "upload helper: serving '$helper_target' via $primary"; } ;;
+                    BEGIN\ *) set -- $line; req=$2; req_board=$3; req_paste=$4; list=$(mktemp) ;;
+                    P\ *) printf '%s\n' "${line#P }" >> "$list" ;;
+                    END)
+                        refused=; set --
+                        while IFS= read -r path; do
+                            if allowed_path "$path"; then set -- "$@" "$path"; else refused="$refused $(basename "$path")"; fi
+                        done < "$list"
+                        rm -f "$list"
+                        if [ $# -gt 0 ] && [ -z "$refused" ]; then
+                            flag=; [ "$req_paste" = 1 ] && flag=--paste
+                            upload_err=$(mktemp)
+                            log "upload $req: sending $# item(s) to $req_board"
+                            LANES_DEFAULT_DEVICE=$dflt "$HOME/.local/bin/lanes-upload" -w "$req_board" $flag --device "$helper_target" --request "$req" "$@" </dev/null >/dev/null 2>"$upload_err" &
+                            upload_pid=$!
+                            while kill -0 "$upload_pid" 2>/dev/null; do
+                                # A large transfer (or a macOS access prompt) must not make a serving helper look dead.
+                                [ -z "$service" ] || touch "$state/helper.alive" 2>/dev/null
+                                sleep 1
+                            done
+                            if wait "$upload_pid"; then
+                                log "upload $req: complete"
+                            else
+                                detail=$(head -n 1 "$upload_err")
+                                [ -n "$detail" ] || detail='upload failed on the client'
+                                log "upload $req failed: $detail"
+                                case "$detail" in
+                                    *'Operation not permitted'*) detail='macOS denied folder access: allow Lanes Helper in System Settings > Privacy & Security > Files and Folders' ;;
+                                esac
+                                # Diagnostics contain filenames: quote them as one remote argument, never shell code.
+                                quoted=$(printf '%s' "$detail" | sed "s/'/'\\\\''/g; s/^/'/; s/\$/'/")
+                                ssh -n -o RequestTTY=no -o BatchMode=yes "$primary" "$remote upload-result $helper_target $req $quoted --default-device $dflt" 2>/dev/null
+                            fi
+                            rm -f "$upload_err"
+                        else
+                            quoted=$(printf '%s' "not allowed on this machine:$refused - run: lanes-upload --allow FOLDER" | sed "s/'/'\\\\''/g; s/^/'/; s/\$/'/")
+                            ssh -n -o RequestTTY=no -o BatchMode=yes "$primary" "$remote upload-result $helper_target $req $quoted --default-device $dflt" 2>/dev/null
+                        fi ;;
+                esac
+            done
+            exit "$heard"
+        ); then
+            up=1; pause=3       # the server ends every stream after 15 min by design: come straight back
+        else
+            [ "$up" = 0 ] || log "upload helper: no connection to $primary ($(head -n 1 "$errfile" 2>/dev/null)); retrying, at most once a minute"
+            up=0
+        fi
+        sleep "$pause"
+        # Back off while the server never answers. As a service this loop runs around the clock, also against a key
+        # that is refused or an sshd that is thrashing: 3 s forever would be load on exactly the host that is in trouble.
+        if [ "$up" = 0 ]; then pause=$((pause * 2)); [ "$pause" -le 60 ] || pause=60; fi
+    done
+}
+
+# Real jitter. awk's bare srand() seeds from the clock's SECOND, so windows that woke together all drew the same
+# number; the pid differs per window. Up to 1 s + 25 % of the wait. (LC_ALL=C: `sleep` does not take a decimal comma.)
+jitter() {
+    LC_ALL=C awk -v seed="$(( $$ + $(date +%s) ))" -v d="$1" 'BEGIN { srand(seed); rand(); printf "%.1f", rand() * (1 + d / 4) }' 2>/dev/null || :
+}
+
+fails=0
+delay=1
+if [ "$mode" = helper ]; then
+    # Default signal handling: a trap would wait for the foreground ssh pipeline (up to 15 min), and launchd kills a
+    # job that sits on TERM for 20 s — a reinstall would find the old job still loaded. Nothing here needs cleanup:
+    # launchd (process group) and systemd (control group) take the ssh child along.
+    trap - HUP TERM INT
+    upload_helper "$target"; exit 0
+fi
+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 &
+    helper_pid=$!
+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"
+    log "connecting: $mode $target via $host"
+    started=$(date +%s)
+    if [ "$mode" = attach ]; then
+        run ssh "$host" "$remote attach $target --client $client --default-device $(default_device) $extra" || :
+    else
+        run ssh "$host" "$remote open $target" || :
+    fi
+    lasted=$(( $(date +%s) - started ))
+    log "ended: exit $rc after ${lasted}s via $host"
+    if [ "$lasted" -ge 30 ]; then delay=1; fails=0; host=$primary; fi
+    # NOTHING below exits: a client that ends closes its window, and a closed window reads as "my lanes are gone".
+    if [ "$rc" = 0 ]; then
+        # 0 is not proof of a deliberate detach: zellij also ends a client it found too slow with 0 (a thrashing host
+        # did that after 24 s). Say what happened first — the question to the server below can take seconds itself.
+        fails=0
+        printf '\r\n\033[2mlanes: the view ended (detached, or dropped by a busy server). Your lanes keep running.\033[0m\r\n'
+        if [ "$mode" = attach ] && [ "$lasted" -ge 3 ]; then
+            # The server just rebuilt this view session (new layout)? That also ends the client with 0: come straight back.
+            limit=10; rebuilt=
+            run ssh -n -o RequestTTY=no -o BatchMode=yes -o ConnectTimeout=10 "$host" "$remote rebuilt $target --default-device $(default_device)" 2>/dev/null && rebuilt=1
+            limit=
+            if [ -n "$rebuilt" ]; then
+                printf '\033[2mlanes: the view session was rebuilt; reattaching…\033[0m\r\n'
+                run sleep 2 || :
+                continue
+            fi
+        fi
+        pause=$delay; [ "$pause" -ge 10 ] || pause=10
+        what=reattaching
+    elif [ "$rc" -ge 64 ] && [ "$rc" -le 78 ]; then
+        # 64-78 = the server refused the request (bad name, unknown lane). Retrying soon cannot help; its message
+        # stays on screen, and the slow retry picks up a fix made on the server.
+        fails=0
+        printf '\r\n\033[2mlanes: the server refused this (exit %s, see above).\033[0m\r\n' "$rc"
+        pause=60
+        what='trying again'
+    else
+        # Two transport failures in a row on the primary path: try the fallback path once it exists. (25 s: a connect
+        # that times out takes ConnectTimeout 20 — it must count, or a dead tailnet never reaches the fallback.)
+        if [ "$rc" = 255 ] && [ "$lasted" -lt 25 ]; then fails=$((fails + 1)); else fails=0; fi
+        if [ "$fails" -ge 2 ] && [ "$host" = "$primary" ] && fallback_defined; then
+            host=$fallback; fails=0; delay=1
+            printf '\r\n\033[2mlanes: %s unreachable, using %s\033[0m\r\n' "$primary" "$fallback"
+        elif [ "$fails" -ge 2 ] && [ "$host" = "$fallback" ]; then
+            host=$primary; fails=0
+        fi
+        printf '\r\n\033[2mlanes: connection ended (%s).\033[0m\r\n' "$rc"
+        pause=$delay
+        what=reconnecting
+    fi
+    printf '\033[2mlanes: %s in about %ss — Enter = now; closing the window (or Ctrl-C) = quit\033[0m\r\n' "$what" "$pause"
+    hold "$pause" "$(jitter "$pause")"
+    delay=$((delay * 2)); if [ "$delay" -gt 60 ]; then delay=60; fi
+done

package/payload/lanes/client/lanes-upload

@@ -0,0 +1,147 @@
+#!/bin/sh
+# lanes-upload — put local files into a board's uploads/ folder on the workspace server (the same folder Cursor
+# users drop files into), over the direct `lanes` SSH path. macOS and Linux; POSIX sh, no dependencies.
+#
+#   lanes-upload [-w <board>] [--paste] <file|dir>...   upload; default board = the one this device's view shows
+#   lanes-upload --clipboard [-w <board>] [--paste]     upload the image (or copied files) on the clipboard
+#   lanes-upload --watch-run                            process the watch folder once (run by launchd / systemd)
+#   lanes-upload --allow <dir> | --allowed              folders the in-window upload box may read from on THIS machine
+#
+#   --paste   also type the uploaded path(s) into the lane you are looking at, ready for the agent
+# Afterwards the in-container path(s) are on your clipboard and shown in a notification.
+# Watch folder: ~/Lanes Uploads/            -> the board your view is showing
+#               ~/Lanes Uploads/<board>/    -> that board              (sent files move to .sent/<date>/)
+set -u
+host=${LANES_HOST:-lanes}
+config=${XDG_CONFIG_HOME:-$HOME/.config}/lanes
+watch_root=$(cat "$config/uploads-dir" 2>/dev/null || echo "$HOME/Lanes Uploads")
+device=$(head -n 1 "$config/device" 2>/dev/null || echo mac)
+os=$(uname -s)
+PATH=/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/opt/homebrew/bin:$PATH
+
+notify() {
+    if [ "$os" = Darwin ]; then
+        /usr/bin/osascript -e "display notification \"$2\" with title \"$1\"" >/dev/null 2>&1 || :
+    elif command -v notify-send >/dev/null 2>&1; then notify-send -a Lanes "$1" "$2" 2>/dev/null || :; fi
+}
+to_clipboard() {
+    if [ "$os" = Darwin ]; then printf '%s' "$1" | /usr/bin/pbcopy
+    elif command -v wl-copy >/dev/null 2>&1; then printf '%s' "$1" | wl-copy 2>/dev/null || :; fi
+}
+
+# send <board-or-empty> <paste:0|1> <path>...   -> prints the remote paths
+send() (
+    board=$1; paste=$2; shift 2
+    target="--active $device"; [ -n "$board" ] && target="$board --device $device"
+    flags=; [ "$paste" = 1 ] && flags=--paste
+    [ -n "${request:-}" ] && flags="$flags --request $request"
+    [ -n "${LANES_DEFAULT_DEVICE:-}" ] && flags="$flags --default-device $LANES_DEFAULT_DEVICE"
+    set -- "$@"
+    args=
+    for item in "$@"; do
+        [ -e "$item" ] || { echo "lanes-upload: no such file: $item" >&2; return 66; }
+        dir=$(cd "$(dirname "$item")" && pwd); base=$(basename "$item")
+        args="$args -C $(printf '%s' "$dir" | sed "s/'/'\\\\''/g; s/^/'/; s/\$/'/") $(printf '%s' "./$base" | sed "s/'/'\\\\''/g; s/^/'/; s/\$/'/")"
+    done
+    # COPYFILE_DISABLE / --no-mac-metadata: no AppleDouble ._ files in the archive.
+    extra=; [ "$os" = Darwin ] && extra=--no-mac-metadata
+    # POSIX sh only returns the last pipeline command's status. Keep tar's status separately: a denied file
+    # otherwise produces a valid empty/partial archive, and a watch-folder upload can be marked sent anyway.
+    transfer=$(mktemp -d) || return 1
+    trap 'rm -rf "$transfer"' EXIT
+    ( eval "COPYFILE_DISABLE=1 tar $extra -cf - $args"; echo "$?" > "$transfer/tar-status" ) |
+        ssh -o RequestTTY=no -o BatchMode=yes "$host" "\$HOME/.local/bin/lanes upload $target $flags"
+    ssh_status=$?
+    tar_status=$(cat "$transfer/tar-status" 2>/dev/null || echo 1)
+    [ "$tar_status" = 0 ] || { echo "lanes-upload: could not read every file (tar exit $tar_status)" >&2; return 1; }
+    return "$ssh_status"
+)
+
+finish() {  # remote paths on stdin
+    paths=$(cat)
+    [ -n "$paths" ] || return 1
+    printf '%s\n' "$paths"
+    to_clipboard "$(printf '%s' "$paths" | tr '\n' ' ' | sed 's/ $//')"
+    notify 'Uploaded to lanes' "$(printf '%s' "$paths" | head -n 3 | tr '\n' ' ')"
+}
+
+clipboard_to_files() {  # writes into $1, prints the file paths to upload
+    out=$1; stamp=$(date +%Y%m%d-%H%M%S)
+    if [ "$os" = Darwin ]; then
+        copied=$(/usr/bin/osascript -e 'try' -e 'POSIX path of (the clipboard as «class furl»)' -e 'end try' 2>/dev/null)
+        if [ -n "$copied" ] && [ -e "$copied" ]; then printf '%s\n' "$copied"; return 0; fi
+        /usr/bin/osascript -e 'try' -e "set png to the clipboard as «class PNGf»" \
+            -e "set f to open for access POSIX file \"$out/clip-$stamp.png\" with write permission" \
+            -e 'write png to f' -e 'close access f' -e 'end try' >/dev/null 2>&1
+    elif command -v wl-paste >/dev/null 2>&1; then
+        if wl-paste --list-types 2>/dev/null | grep -q '^image/png'; then wl-paste -t image/png > "$out/clip-$stamp.png"
+        elif wl-paste --list-types 2>/dev/null | grep -q '^text/uri-list'; then
+            wl-paste -t text/uri-list | sed -n 's|^file://||p' | while IFS= read -r p; do printf '%b\n' "$(printf '%s' "$p" | sed 's/%\([0-9A-Fa-f][0-9A-Fa-f]\)/\\x\1/g')"; done
+            return 0
+        fi
+    fi
+    if [ -s "$out/clip-$stamp.png" ]; then printf '%s\n' "$out/clip-$stamp.png"; else return 1; fi
+}
+
+watch_run() {
+    mkdir -p "$watch_root"
+    lock=$watch_root/.lock
+    mkdir "$lock" 2>/dev/null || { [ -n "$(find "$lock" -maxdepth 0 -mmin +5 2>/dev/null)" ] && rmdir "$lock" 2>/dev/null; exit 0; }
+    trap 'rmdir "$lock" 2>/dev/null' EXIT INT TERM
+    sleep 1   # let the writer finish
+    for dir in "$watch_root" "$watch_root"/*/; do
+        [ -d "$dir" ] || continue
+        dir=${dir%/}
+        board=; [ "$dir" != "$watch_root" ] && board=$(basename "$dir")
+        for item in "$dir"/*; do
+            [ -e "$item" ] || continue
+            [ "$dir" = "$watch_root" ] && [ -d "$item" ] && continue   # board folders themselves
+            case "$(basename "$item")" in .*|README.txt|*.crdownload|*.part|*.download) continue ;; esac
+            # still being written? wait until its size is stable
+            a=$(du -sk "$item" 2>/dev/null | cut -f1); sleep 1; b=$(du -sk "$item" 2>/dev/null | cut -f1)
+            [ "$a" = "$b" ] || continue
+            if result=$(send "$board" 0 "$item"); then
+                sent=$dir/.sent/$(date +%Y-%m-%d); mkdir -p "$sent"; mv "$item" "$sent/" 2>/dev/null
+                printf '%s\n' "$result" | finish >/dev/null
+            else
+                notify 'Lanes upload failed' "$(basename "$item") — it stays in the folder and is retried on the next change"
+            fi
+        done
+    done
+}
+
+board=; paste=0; clip=0; request=
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --request) request=${2:?id}; shift 2 ;;
+        --device) device=${2:?device}; shift 2 ;;
+        --allow) dir=$(cd "${2:?dir}" && pwd -P) || exit 66; mkdir -p "$config"; grep -qxF "$dir" "$config/upload-allow" 2>/dev/null || printf '%s\n' "$dir" >> "$config/upload-allow"; echo "allowed: $dir"; exit 0 ;;
+        --allowed) cat "$config/upload-allow" 2>/dev/null; exit 0 ;;
+        -w|--workspace) board=${2:?board id}; shift 2 ;;
+        --paste) paste=1; shift ;;
+        --clipboard) clip=1; shift ;;
+        --watch-run) watch_run; exit 0 ;;
+        -h|--help) sed -n '2,13p' "$0"; exit 0 ;;
+        --) shift; break ;;
+        -*) echo "lanes-upload: unknown option $1" >&2; exit 64 ;;
+        *) break ;;
+    esac
+done
+case "$board" in *[!A-Za-z0-9_.-]*) echo 'lanes-upload: invalid board id' >&2; exit 64 ;; esac
+case "$request" in *[!0-9-]*) echo 'lanes-upload: invalid request id' >&2; exit 64 ;; esac
+
+if [ "$clip" = 1 ]; then
+    tmp=$(mktemp -d); trap 'rm -rf "$tmp"' EXIT
+    files=$(clipboard_to_files "$tmp") || { echo 'lanes-upload: the clipboard holds no image or copied file' >&2; notify 'Lanes upload' 'Clipboard holds no image or file'; exit 66; }
+    old_ifs=$IFS; IFS='
+'
+    # shellcheck disable=SC2086
+    set -- $files
+    IFS=$old_ifs
+fi
+[ $# -gt 0 ] || { sed -n '2,13p' "$0"; exit 64; }
+if result=$(send "$board" "$paste" "$@"); then
+    printf '%s\n' "$result" | finish
+else
+    exit "$?"
+fi

package/payload/lanes/client/lanes-window

@@ -0,0 +1,36 @@
+#!/bin/sh
+# Open the lanes window in its own terminal instance. usage: lanes-window [suffix]
+#   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).
+# macOS: Ghostty. Linux: Ghostty when installed, otherwise Foot with the same window class.
+set -u
+config=${XDG_CONFIG_HOME:-$HOME/.config}/lanes
+launch=$HOME/.local/bin/lanes-launch
+class=org.omarchy.lanes
+device=
+file=$config/ghostty.conf
+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"
+    case "$1" in w2) device="$device --viewports 2" ;; w3) device="$device --viewports 3" ;; esac
+    file=$config/ghostty.$1.conf
+    sed "s|^command = .*|command = $launch $device|" "$config/ghostty.conf" > "$file"
+fi
+case "$(uname -s)" in
+    Darwin)
+        if ! open -Ra Ghostty.app 2>/dev/null; then
+            echo 'lanes-window: Ghostty is not installed (brew install --cask ghostty). Meanwhile: run lanes-launch in any terminal.' >&2
+            exit 69
+        fi
+        exec open -na Ghostty.app --args --config-default-files=false "--config-file=$file" ;;
+esac
+if command -v ghostty >/dev/null 2>&1; then
+    exec ghostty --config-default-files=false "--config-file=$file"
+elif command -v foot >/dev/null 2>&1; then
+    # Same class, so Omarchy's terminal tag, the launch-or-focus bind and window rules behave identically.
+    # --hold = Ghostty's wait-after-command (common.conf): should the client ever end, the window stays, reason on screen.
+    # shellcheck disable=SC2086
+    exec foot --hold --app-id="$class" --title=lanes -e "$launch" $device
+fi
+echo 'lanes-window: install Ghostty (omarchy-pkg-add ghostty) or Foot' >&2
+exit 69

package/payload/lanes/client/macos-helper.applescript

@@ -0,0 +1,14 @@
+-- A real app identity lets macOS ask for Downloads/Desktop/Documents access for the upload helper.
+-- An anonymous /bin/sh launched directly by launchd is silently denied those folders.
+on run
+    set userHome to POSIX path of (path to home folder)
+    set configRoot to do shell script "printf '%s' \"${XDG_CONFIG_HOME:-$HOME/.config}\""
+    set stateRoot to do shell script "printf '%s' \"${XDG_STATE_HOME:-$HOME/.local/state}\""
+    set deviceName to do shell script "/usr/bin/head -n 1 " & quoted form of (configRoot & "/lanes/device")
+    set launcher to userHome & ".local/bin/lanes-launch"
+    set logPath to stateRoot & "/lanes-client/helper-service.log"
+    -- launchd owns this app and its children; closing a terminal does not stop the helper.
+    try
+        do shell script "exec /bin/sh " & quoted form of launcher & " --helper " & quoted form of deviceName & " --service </dev/null >/dev/null 2>>" & quoted form of logPath
+    end try
+end run