@zswarm/core 0.2.2 → 0.2.3

package/assets/host-install.sh

@@ -24,6 +24,8 @@ while [ $# -gt 0 ]; do
     *) echo "host-install: unknown argument $1" >&2; exit 2 ;;
   esac
 done
+case "$PREFIX" in /*) ;; *) PREFIX="$(pwd)/$PREFIX" ;; esac
+case "$BIN" in /*) ;; *) BIN="$(pwd)/$BIN" ;; esac
 
 step() { printf '%-10s %s\n' "$1" "$2"; }
 fetch() { curl -fsSL --retry 3 -o "$2" "$1"; }
@@ -95,8 +97,40 @@ if [ "$ZSWARM_VERSION" = latest ] || [ "$have" != "$ZSWARM_VERSION" ]; then
 else
   step zswarm "present $have"
 fi
-ln -sfn "$npm_prefix/bin/zswarm" "$BIN/zswarm"
-ln -sfn "$npm_prefix/bin/zswarm-mcp" "$BIN/zswarm-mcp"
+# The npm bin is `#!/usr/bin/env node`, which sshd, sudo, launchd and systemd
+# cannot run when no node is on PATH. Write a small POSIX sh launcher for each
+# command that execs the Node.js this script installed by absolute path.
+resolve() { # $1 path (possibly through symlinks) -> absolute target path
+  target="$1"
+  while [ -L "$target" ]; do
+    link="$(readlink "$target")"
+    case "$link" in
+      /*) target="$link" ;;
+      *) target="$(dirname "$target")/$link" ;;
+    esac
+  done
+  # npm links with a relative target, so fold away any `..` segments for a
+  # clean absolute path in the launcher. Logical pwd keeps the prefix as given
+  # (on macOS /var is a symlink to /private/var; -P would mix the two).
+  dir="$(cd "$(dirname "$target")" 2>/dev/null && pwd)" || dir="$(dirname "$target")"
+  printf '%s/%s\n' "$dir" "$(basename "$target")"
+}
+write_launcher() { # $1 command name, $2 npm bin symlink to the package script
+  pkg="$(resolve "$2")"
+  if [ ! -f "$pkg" ]; then
+    echo "host-install: cannot find the $1 script at $pkg" >&2
+    exit 1
+  fi
+  rm -f "$BIN/$1"
+  cat > "$BIN/$1" <<EOF
+#!/bin/sh
+# zswarm launcher: exec the Node.js host install pinned, whatever PATH says.
+exec "$node_dir/bin/node" "$pkg" "\$@"
+EOF
+  chmod 0755 "$BIN/$1"
+}
+write_launcher zswarm "$npm_prefix/bin/zswarm"
+write_launcher zswarm-mcp "$npm_prefix/bin/zswarm-mcp"
 
 # --- Zellij ------------------------------------------------------------------
 have_zellij="$("$BIN/zellij" --version 2>/dev/null | awk '{print $2}' || true)"

package/assets/host-report.sh

@@ -7,7 +7,18 @@ v() { "$@" 2>/dev/null | head -1; }
 echo "os=$(uname -s)"
 echo "arch=$(uname -m)"
 echo "user=$(id -un)"
-echo "node=$(v node --version | sed 's/^v//')"
+# node: the runtime zswarm actually uses. When zswarm is a host-install launcher,
+# read the Node.js it execs from the launcher, not the first node on PATH.
+node_bin=""
+zw="$(command -v zswarm 2>/dev/null || true)"
+if [ -n "$zw" ] && [ -f "$zw" ]; then
+  node_bin="$(sed -n 's/^exec "\([^"]*\)".*/\1/p' "$zw" | head -1)"
+fi
+if [ -n "$node_bin" ] && [ -x "$node_bin" ]; then
+  echo "node=$(v "$node_bin" --version | sed 's/^v//')"
+else
+  echo "node=$(v node --version | sed 's/^v//')"
+fi
 zv="$(v zswarm --version)"
 case "$zv" in
   [0-9]*) ;;
@@ -19,6 +30,9 @@ echo "python3=$(v python3 -c 'import platform; print(platform.python_version())'
 echo "disk_home_gb=$(df -Pk "$HOME" 2>/dev/null | awk 'NR==2 {printf "%d", $4/1048576}')"
 echo "disk_tmp_gb=$(df -Pk "${TMPDIR:-/tmp}" 2>/dev/null | awk 'NR==2 {printf "%d", $4/1048576}')"
 echo "sessions=$(zellij list-sessions --no-formatting 2>/dev/null | grep -v EXITED | awk '{print $1}' | tr '\n' ' ')"
+exited_names="$(zellij list-sessions --no-formatting 2>/dev/null | awk '/EXITED/ {print $1}' | tr '\n' ' ')"
+echo "exited_sessions=$(printf '%s' "$exited_names" | wc -w | tr -d ' ')"
+echo "exited_session_names=$exited_names"
 if [ "$(uname -s)" = Linux ]; then
   echo "linger=$(loginctl show-user "$(id -un)" -p Linger --value 2>/dev/null)"
   systemctl --user list-units --all --plain --no-legend 'zswarm-*' 2>/dev/null | awk '{print "service=" $1 " " $3 " " $4}'

package/dist/harness.d.ts

@@ -9,6 +9,11 @@ export type HarnessProfile = {
      * against the trailing lines; a hit means the pane wants input, not time.
      */
     waiting: readonly RegExp[];
+    /**
+     * A hint that the harness accepted the paste but queued it behind a running
+     * turn. `send` matches these against the trailing lines after the paste.
+     */
+    queued: readonly RegExp[];
 };
 /**
  * Identify the harness from a pane's command and title, case-insensitively.
@@ -19,3 +24,8 @@ export declare function resolveHarness(pane: {
     command?: string | null;
     title?: string | null;
 }): HarnessProfile;
+/**
+ * Does this screen's trailing lines show the harness's queued-message hint?
+ * Only the last few lines count: a quoted marker in scrollback is not a queue.
+ */
+export declare function queuedPrompt(screen: string, profile: HarnessProfile): boolean;

package/dist/harness.js

@@ -51,10 +51,29 @@ const WAITING = {
     ],
     pi: GENERIC_WAITING,
 };
+/**
+ * Queued-message hints seen live. Claude Code prints
+ * "Press up to edit queued messages" while a turn runs and the pasted body is
+ * held above the prompt. No other harness shows an equally clear marker yet,
+ * so every profile carries only this base set.
+ */
+const GENERIC_QUEUED = [/press up to edit queued messages/i];
+/**
+ * Queued lines per harness. Every observed harness currently carries only the
+ * generic Claude Code hint; add harness-specific patterns here when seen.
+ */
+const QUEUED = {
+    codex: GENERIC_QUEUED,
+    cursor: GENERIC_QUEUED,
+    opencode: GENERIC_QUEUED,
+    gemini: GENERIC_QUEUED,
+    pi: GENERIC_QUEUED,
+};
 const UNKNOWN = {
     name: "unknown",
     submit: "auto",
     waiting: GENERIC_WAITING,
+    queued: GENERIC_QUEUED,
 };
 function escapeRegExp(text) {
     return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -99,5 +118,18 @@ export function resolveHarness(pane) {
     const name = matchCommand(pane.command) ?? matchTitle(pane.title) ?? "unknown";
     if (name === "unknown")
         return UNKNOWN;
-    return { name, submit: SUBMIT[name], waiting: WAITING[name] };
+    return { name, submit: SUBMIT[name], waiting: WAITING[name], queued: QUEUED[name] };
+}
+/**
+ * Does this screen's trailing lines show the harness's queued-message hint?
+ * Only the last few lines count: a quoted marker in scrollback is not a queue.
+ */
+export function queuedPrompt(screen, profile) {
+    const lines = screen
+        .replace(/\r/g, "")
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length > 0)
+        .slice(-6);
+    return profile.queued.some((re) => lines.some((line) => re.test(line)));
 }

package/dist/host/cli.js

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import { ZellijError } from "../errors.js";
 import { crewCheck, crewDown, crewStart, crewStatus, crewUp } from "./crew.js";
 import { hostDoctor, hostInstall, hostInstallArgs, hostScriptPath } from "./host.js";
-import { pruneRelays, runRelayDir, startRelay, waitForRelay } from "./relay.js";
+import { cancelAllTo, cancelRelay, listRelays, pruneRelays, runRelayDir, startRelay, waitForRelay } from "./relay.js";
 import { runSlot } from "./slot.js";
 /**
  * Host commands: CLI-only (not MCP ops), because they run long, pass argv
@@ -78,8 +78,23 @@ async function crew(argv) {
             return 2;
     }
 }
+/** A plain-text table for `relay --list`, one row per relay. */
+function relayTable(rows) {
+    const header = ["ID", "STATE", "TO", "SESSION", "AGE", "LAST CHECK", "JOB"];
+    const body = rows.map((r) => [
+        r.id,
+        r.state,
+        r.to,
+        r.session ?? "-",
+        `${r.age}s`,
+        r.lastCheck === undefined ? "-" : String(r.lastCheck),
+        r.job ?? "-",
+    ]);
+    const widths = header.map((h, i) => Math.max(h.length, ...body.map((row) => row[i].length)));
+    return [header, ...body].map((row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd()).join("\n");
+}
 async function relay(argv) {
-    const { flags } = parseHostArgs(argv, ["--foreground", "--prune"]);
+    const { flags } = parseHostArgs(argv, ["--foreground", "--prune", "--list", "--cancel-all", "--json"]);
     const run = str(flags["--run"]);
     if (run)
         return runRelayDir(run);
@@ -93,6 +108,33 @@ async function relay(argv) {
         process.stdout.write(message);
         return 0;
     }
+    if (flags["--list"] === true) {
+        const rows = listRelays();
+        if (flags["--json"] === true)
+            return json(() => ({ relays: rows }));
+        process.stdout.write(`${relayTable(rows)}\n`);
+        return 0;
+    }
+    const cancelId = str(flags["--cancel"]);
+    if (cancelId) {
+        const res = cancelRelay(cancelId);
+        if (flags["--json"] === true)
+            return json(() => res);
+        process.stdout.write(`${res.reason}\n`);
+        for (const line of res.actions)
+            process.stdout.write(`${line}\n`);
+        return 0;
+    }
+    if (flags["--cancel-all"] === true) {
+        const to = str(flags["--to"]);
+        if (!to)
+            throw new ZellijError("usage", "relay --cancel-all needs --to PANE");
+        const results = cancelAllTo(to);
+        if (flags["--json"] === true)
+            return json(() => ({ cancelled: results }));
+        process.stdout.write(results.length === 0 ? `no running relays to ${to}\n` : `${results.map((r) => r.reason).join("\n")}\n`);
+        return 0;
+    }
     if (flags["--prune"]) {
         return json(() => ({ removed: pruneRelays(Number(str(flags["--days"]) ?? 14)) }));
     }
@@ -109,6 +151,7 @@ async function relay(argv) {
         check: str(flags["--check"]),
         message: str(flags["--message"]),
         timeoutMin: flags["--timeout-min"] ? Number(str(flags["--timeout-min"])) : undefined,
+        maxAgeMin: flags["--max-age"] ? Number(str(flags["--max-age"])) : undefined,
         foreground: flags["--foreground"] === true,
     }));
 }
@@ -170,9 +213,12 @@ const COMMANDS = {
         usage: [
             "zswarm relay --to PANE --done REGEX --reply-to PANE [--serve TARGET] [--session S] [--body-file F]",
             "             [--reply-session S] [--from NAME] [--check SCRIPT] [--message TEMPLATE] [--id ID]",
-            "             [--timeout-min 240] [--foreground]",
+            "             [--timeout-min 240] [--max-age MIN] [--foreground]",
             "      send the body to PANE over serve (ZSWARM_SERVE / ZSWARM_SERVE_TOKEN), then a detached relay",
-            "      waits for REGEX (and SCRIPT exit 0) and pastes a message into the local --reply-to pane",
+            "      waits for REGEX (and SCRIPT exit 0) and pastes a message into the local --reply-to pane;",
+            "      --max-age (default --timeout-min + 60) is a hard end that always yields a final status",
+            "zswarm relay --list [--json]   id, state, target, session, age, last check and job per relay dir",
+            "zswarm relay --cancel ID | --cancel-all --to PANE   stop the job, mark it CANCELLED, paste nothing",
             "zswarm relay --wait ID [--timeout-min 240]   block until relay ID has its message, print it (pull path)",
             "zswarm relay --prune [--days 14]   remove old relay dirs and undelivered messages",
         ].join("\n"),

package/dist/host/crew.d.ts

@@ -12,6 +12,8 @@ export type CrewDeps = {
     };
     /** Live session names; injected in tests. */
     sessions?: (env: NodeJS.ProcessEnv) => Promise<string[]>;
+    /** Exited (resurrectable) session names; injected in tests. */
+    exitedSessions?: (env: NodeJS.ProcessEnv) => Promise<string[]>;
     /** Pane titles (with exited flags) of a session; injected in tests. */
     panes?: (session: string, env: NodeJS.ProcessEnv) => Promise<Array<{
         title: string;

package/dist/host/crew.js

@@ -83,6 +83,14 @@ async function defaultSessions(env) {
         return [];
     return (res.data.sessions ?? []).map((s) => s.name ?? "");
 }
+async function defaultExitedSessions(env) {
+    const res = await dispatchZswarm({ op: "sessions", all: true }, undefined, { env });
+    if (!res.ok)
+        return [];
+    return (res.data.sessions ?? [])
+        .filter((s) => s.exited === true)
+        .map((s) => s.name ?? "");
+}
 async function defaultPanes(session, env) {
     const res = await dispatchZswarm({ op: "list", session }, undefined, { env });
     if (!res.ok)
@@ -252,12 +260,17 @@ export async function crewStatus(input) {
         ? readCrewFiles(crewDir(account, session, env))
         : undefined;
     const live = (await (input.deps?.sessions ?? defaultSessions)(env)).includes(session);
+    const exited = (await (input.deps?.exitedSessions ?? defaultExitedSessions)(env)).includes(session);
     const panes = live ? await (input.deps?.panes ?? defaultPanes)(session, { ...env, ZSWARM_BUS: "0" }) : [];
     out.live = live;
+    out.exited = exited;
     out.firstPane = files?.first ?? null;
     out.layoutTook = files ? panes.some((p) => p.title === files.first) : null;
     out.panes = panes;
     out.healthy = services.every((s) => s.active) && live && out.layoutTook !== false && panes.every((p) => !p.exited);
+    if (live && exited) {
+        out.note = `an exited session named ${session} is also listed (resurrectable); remove it with zswarm sessions --prune-exited`;
+    }
     return out;
 }
 export function crewDown(input) {

package/dist/host/host.js

@@ -90,6 +90,19 @@ export function hostChecks(facts, services, session) {
     tool("zswarm", true, "zswarm host install");
     tool("zellij", true, "zswarm host install");
     tool("python3", false, "zswarm slot needs Python 3.9+");
+    // Exited sessions are resurrectable leftovers; a pile of them is a warning.
+    if (facts.exited_sessions !== undefined && facts.exited_sessions !== "") {
+        const exited = Number(facts.exited_sessions);
+        if (Number.isFinite(exited)) {
+            checks.push({
+                id: "exited_sessions",
+                state: exited > 10 ? "warn" : "pass",
+                detail: exited > 10
+                    ? `${exited} exited (resurrectable) sessions; prune with zswarm sessions --prune-exited`
+                    : `${exited} exited`,
+            });
+        }
+    }
     for (const id of ["disk_home_gb", "disk_tmp_gb"]) {
         const gb = Number(facts[id]);
         if (!Number.isFinite(gb) || facts[id] === "")

package/dist/host/relay.d.ts

@@ -16,7 +16,14 @@ import type { OpsResult } from "../ops/types.js";
  * message.txt. It reads nothing else, so moving or updating the caller's files
  * while it waits cannot break it.
  */
-export type RelayStatus = "DONE" | "TIMEOUT" | "PANE_DIED" | "SERVE_DOWN" | "UNCONFIRMED";
+export type RelayStatus = "DONE" | "TIMEOUT" | "MAX_AGE" | "CHECK_BROKEN" | "CANCELLED" | "PANE_DIED" | "SERVE_DOWN" | "UNCONFIRMED";
+/** How a detached relay can be stopped: the launchd label, systemd unit, or pid. */
+export type RelayJob = {
+    kind: "launchd" | "systemd" | "pid";
+    label?: string;
+    unit?: string;
+    pid?: number;
+};
 export type RelayConfig = {
     id: string;
     serve: string;
@@ -28,6 +35,8 @@ export type RelayConfig = {
     replySession?: string;
     from: string;
     timeoutMin: number;
+    /** Hard cap on the relay's age; defaults to `timeoutMin` plus 60 minutes. */
+    maxAgeMin?: number;
     check?: string;
     message?: string;
     /**
@@ -35,6 +44,13 @@ export type RelayConfig = {
      * pasted body, an earlier task's done line). Only a line beyond these counts.
      */
     seen?: string[];
+    /** Recorded by launchRelay so `--cancel` can stop the detached job. */
+    job?: RelayJob;
+    /** Final status once the loop ends; absent while the relay runs. */
+    status?: RelayStatus;
+    /** Set by `--cancel`; a late loop must not overwrite it. */
+    cancelled?: boolean;
+    cancelledAt?: number;
 };
 export type RelayDeps = {
     /** dispatchZswarm with an env; injected in tests. */
@@ -82,6 +98,8 @@ export type RelayStartInput = {
     check?: string;
     message?: string;
     timeoutMin?: number;
+    /** Hard cap on the relay's age; defaults to `timeoutMin` plus 60 minutes. */
+    maxAgeMin?: number;
     foreground?: boolean;
     env?: NodeJS.ProcessEnv;
     deps?: RelayDeps;
@@ -112,5 +130,49 @@ export declare function waitForRelay(id: string, opts?: {
     sleep?: (ms: number) => Promise<void>;
     now?: () => number;
 }): Promise<string | null>;
+export type RelayJobRunner = (cmd: string, args: string[]) => {
+    status: number;
+    stdout: string;
+    stderr?: string;
+};
+export type RelayAdminDeps = {
+    env?: NodeJS.ProcessEnv;
+    now?: () => number;
+    /** Runs launchctl/systemctl; injected in tests. */
+    run?: RelayJobRunner;
+    /** Liveness probe for a plain detached pid; injected in tests. */
+    alive?: (pid: number) => boolean;
+    /** Sends SIGTERM to a plain detached pid; injected in tests. */
+    kill?: (pid: number) => void;
+    /** A pid's command line (undefined when unknown); injected in tests. */
+    commandLine?: (pid: number) => string | undefined;
+};
+export type RelayRow = {
+    id: string;
+    dir: string;
+    to: string;
+    session?: string;
+    /** Epoch milliseconds the run started (the `<ts>` in its directory name). */
+    started: number;
+    /** Seconds since it started. */
+    age: number;
+    state: string;
+    lastCheck?: number;
+    /** The launchd label / systemd unit / pid, when the job is still loaded. */
+    job?: string;
+};
+export type RelayCancelResult = {
+    id: string;
+    cancelled: boolean;
+    state: string;
+    reason: string;
+    actions: string[];
+};
+/** One row per relay run directory; newest first. */
+export declare function listRelays(deps?: RelayAdminDeps): RelayRow[];
+/** Stop a running relay's job, mark its directory CANCELLED and scrub its token. */
+export declare function cancelRelay(id: string, deps?: RelayAdminDeps): RelayCancelResult;
+/** Cancel every running relay that targets `to`. */
+export declare function cancelAllTo(to: string, deps?: RelayAdminDeps): RelayCancelResult[];
 /** Remove relay directories and undelivered messages older than `days`. */
 export declare function pruneRelays(days?: number, env?: NodeJS.ProcessEnv): string[];