@zswarm/core 0.2.1 → 0.2.3

package/dist/host/relay.js

@@ -11,6 +11,10 @@ const DEFAULT_DELAYS = [0, 30, 60, 120, 300, 600, 900, 1500];
 /** Consecutive matches of the done regex without a passing check before UNCONFIRMED. */
 const CONFIRM_TRIES = 3;
 const SERVE_DOWN_TRIES = 3;
+/** Consecutive identical failing checks before CHECK_BROKEN: a check that can never pass. */
+const CHECK_BROKEN_TRIES = 10;
+/** How long a relay may outlive `--timeout-min` when `--max-age` is not given. */
+const DEFAULT_MAX_AGE_EXTRA_MIN = 60;
 /** A wait that only finds `seen` lines returns at once; poll no faster than this. */
 const STALE_MATCH_POLL_MS = 15_000;
 export function relaysDir(env = process.env) {
@@ -78,6 +82,9 @@ export function fillMessage(template, fields) {
 const DEFAULT_TEMPLATE = "RELAY {id} STATUS {status} pane {pane}\n{output}{note}\n";
 const NOTES = {
     TIMEOUT: "no done line or passing check before the deadline; dump the pane once, do not resend blindly.",
+    MAX_AGE: "the relay reached --max-age without its done line; check the target pane and --done before resending.",
+    CHECK_BROKEN: "the check script failed the same way ten times in a row; fix the check (or --done) before resending.",
+    CANCELLED: "the relay was cancelled before it finished; nothing was pasted.",
     PANE_DIED: "the target pane is gone or exited; check the crew (zswarm crew status) before resending.",
     SERVE_DOWN: "serve was unreachable for three checks in a row; run zswarm doctor against it.",
     UNCONFIRMED: "the pane printed the done line but the check never passed; dump the pane once for the error.",
@@ -130,12 +137,20 @@ export async function relayLoop(dir, deps = {}) {
         ZSWARM_RELAY_PANE: cfg.to,
         ZSWARM_RELAY_DIR: dir,
     });
-    const deadline = now() + cfg.timeoutMin * 60_000;
+    // The timeout is the normal end; --max-age (default timeout + 60 min) is the
+    // hard cap that still ends the relay when a wait or the serve-down backoff
+    // overruns the timeout.
+    const startedAtMs = now();
+    const timeoutAt = startedAtMs + cfg.timeoutMin * 60_000;
+    const maxAgeAt = startedAtMs + (cfg.maxAgeMin ?? cfg.timeoutMin + DEFAULT_MAX_AGE_EXTRA_MIN) * 60_000;
+    const deadline = Math.min(timeoutAt, maxAgeAt);
     let status = "TIMEOUT";
     let output = "";
     let match = "";
     let confirmTries = 0;
     let serveDown = 0;
+    let lastCheckFail;
+    let sameCheckFails = 0;
     log(`relay start id=${cfg.id} to=${cfg.to} serve=${cfg.serve} done=${cfg.done}`);
     while (now() < deadline) {
         const started = now();
@@ -163,6 +178,20 @@ export async function relayLoop(dir, deps = {}) {
                 output = r.stdout;
                 break;
             }
+            // The same failure over and over means the check can never pass for this
+            // pane: end as CHECK_BROKEN rather than polling to the timeout.
+            const sig = `${r.status}:${r.stdout}`;
+            if (sig === lastCheckFail)
+                sameCheckFails += 1;
+            else {
+                lastCheckFail = sig;
+                sameCheckFails = 1;
+            }
+            if (sameCheckFails >= CHECK_BROKEN_TRIES) {
+                status = "CHECK_BROKEN";
+                output = r.stdout;
+                break;
+            }
         }
         else {
             log(`wait ok=${res.ok} matched=${matched}${stale ? " (seen before start)" : ""}`);
@@ -207,6 +236,9 @@ export async function relayLoop(dir, deps = {}) {
         if (matched)
             await sleep(30_000); // the done line stays on screen; give the check time
     }
+    if (status === "TIMEOUT" && maxAgeAt <= timeoutAt && now() >= maxAgeAt)
+        status = "MAX_AGE";
+    writeFinalStatus(dir, status);
     let body;
     if (status !== "DONE" && check) {
         const r = runCheck(check, checkEnv(status, match));
@@ -269,6 +301,18 @@ function updateConfig(dir, patch) {
     const cfg = { ...JSON.parse(readFileSync(path, "utf8")), ...patch };
     writePrivate(path, `${JSON.stringify(cfg, null, 1)}\n`);
 }
+/** Persist the final status unless `--cancel` already marked the relay. */
+function writeFinalStatus(dir, status) {
+    try {
+        const cfg = JSON.parse(readFileSync(join(dir, "config.json"), "utf8"));
+        if (cfg.cancelled || cfg.status === "CANCELLED")
+            return;
+        updateConfig(dir, { status });
+    }
+    catch {
+        // the directory is gone; nothing to record
+    }
+}
 /** Remove the token copy once the relay no longer needs it. */
 export function scrubRelayToken(dir) {
     const path = join(dir, "config.json");
@@ -293,10 +337,12 @@ export function launchRelay(dir, env = process.env) {
             "submit", "-l", label, "-o", log, "-e", log, "--",
             "/usr/bin/env", `PATH=${env.PATH ?? "/usr/bin:/bin"}`, `HOME=${env.HOME ?? ""}`,
             ...(env.ZSWARM_STATE_DIR ? [`ZSWARM_STATE_DIR=${env.ZSWARM_STATE_DIR}`] : []),
+            ...(env.ZSWARM_RELAY_DELAYS ? [`ZSWARM_RELAY_DELAYS=${env.ZSWARM_RELAY_DELAYS}`] : []),
             `ZSWARM_RELAY_LABEL=${label}`, ...argv,
         ], { encoding: "utf8" });
         if (res.status !== 0)
             throw new ZellijError("failed", `launchctl submit failed: ${(res.stderr ?? "").trim().slice(0, 200)}`);
+        updateConfig(dir, { job: { kind: "launchd", label } });
         return `launchd job ${label}`;
     }
     if (process.platform === "linux" && spawnSync("systemctl", ["--user", "is-system-running"], { encoding: "utf8" }).status !== null) {
@@ -304,13 +350,18 @@ export function launchRelay(dir, env = process.env) {
         const res = spawnSync("systemd-run", ["--user", "--collect", "--quiet", `--unit=${unit}`,
             `--setenv=PATH=${env.PATH ?? "/usr/bin:/bin"}`,
             ...(env.ZSWARM_STATE_DIR ? [`--setenv=ZSWARM_STATE_DIR=${env.ZSWARM_STATE_DIR}`] : []),
+            ...(env.ZSWARM_RELAY_DELAYS ? [`--setenv=ZSWARM_RELAY_DELAYS=${env.ZSWARM_RELAY_DELAYS}`] : []),
             ...argv], { encoding: "utf8" });
-        if (res.status === 0)
+        if (res.status === 0) {
+            updateConfig(dir, { job: { kind: "systemd", unit } });
             return `systemd unit ${unit}`;
+        }
     }
     const out = openLog(log);
     const child = spawn(argv[0], argv.slice(1), { detached: true, stdio: ["ignore", out, out], env, windowsHide: true });
     child.unref();
+    if (child.pid)
+        updateConfig(dir, { job: { kind: "pid", pid: child.pid } });
     return `pid ${child.pid}`;
 }
 /** A file descriptor the detached child can inherit. */
@@ -338,6 +389,7 @@ export async function startRelay(input) {
         replySession: input.replySession?.trim() || env.ZSWARM_SESSION?.trim() || env.ZELLIJ_SESSION_NAME?.trim() || undefined,
         from: input.from?.trim() || "zswarm-relay",
         timeoutMin: input.timeoutMin ?? 240,
+        maxAgeMin: input.maxAgeMin ?? (input.timeoutMin ?? 240) + DEFAULT_MAX_AGE_EXTRA_MIN,
     };
     // Read the body before the relay directory (and its token copy) exists.
     const body = input.bodyFile ? readFileSync(input.bodyFile, "utf8") : undefined;
@@ -452,6 +504,193 @@ export async function waitForRelay(id, opts = {}) {
         await sleep(opts.pollMs ?? 15_000);
     }
 }
+/** A pid's command line: `ps` on POSIX, CIM on Windows. */
+function defaultCommandLine(pid) {
+    const res = process.platform === "win32"
+        ? spawnSync("powershell.exe", ["-NoProfile", "-Command",
+            `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CommandLine`], { encoding: "utf8", windowsHide: true })
+        : spawnSync("ps", ["-o", "command=", "-p", String(pid)], { encoding: "utf8" });
+    const text = res.status === 0 ? (res.stdout ?? "").trim() : "";
+    return text || undefined;
+}
+const defaultJobRunner = (cmd, args) => {
+    const res = spawnSync(cmd, args, { encoding: "utf8" });
+    return { status: res.status ?? 1, stdout: res.stdout ?? "", stderr: res.stderr ?? (res.error?.message ?? "") };
+};
+/** The run directories under relaysDir, with the start time from each name. */
+function runDirs(root) {
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    for (const name of readdirSync(root)) {
+        if (name === "undelivered")
+            continue;
+        const path = join(root, name);
+        let isDir = false;
+        try {
+            isDir = statSync(path).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (!isDir)
+            continue;
+        const m = /^(.*)-(\d+)$/.exec(name);
+        out.push({
+            id: m ? m[1] : name,
+            dir: path,
+            started: (m ? Number(m[2]) : Math.floor(statSync(path).mtimeMs / 1000)) * 1000,
+        });
+    }
+    return out;
+}
+function readRelayConfig(dir) {
+    try {
+        return JSON.parse(readFileSync(join(dir, "config.json"), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The state a relay dir already records: a cancel marker, a final status, a message, else running. */
+function relayState(dir, cfg) {
+    if (cfg?.cancelled || cfg?.status === "CANCELLED")
+        return "cancelled";
+    if (cfg?.status)
+        return cfg.status.toLowerCase();
+    const message = join(dir, "message.txt");
+    if (existsSync(message)) {
+        const m = /^\s*RELAY \S+ STATUS (\S+)/m.exec(readFileSync(message, "utf8"));
+        return (m?.[1] ?? "done").toLowerCase();
+    }
+    return "running";
+}
+/** The last `check=<n>` a relay logged, if any. */
+function lastCheckResult(dir) {
+    try {
+        const matches = [...readFileSync(join(dir, "relay.log"), "utf8").matchAll(/check=(-?\d+)/g)];
+        const last = matches.at(-1)?.[1];
+        return last === undefined ? undefined : Number(last);
+    }
+    catch {
+        return undefined;
+    }
+}
+function jobLabelText(job) {
+    if (job.kind === "launchd")
+        return `launchd job ${job.label}`;
+    if (job.kind === "systemd")
+        return `systemd unit ${job.unit}`;
+    return `pid ${job.pid}`;
+}
+/**
+ * True while the recorded job is still loaded (launchd/systemd), or while the
+ * pid is alive and its command line still names this relay's directory (a
+ * relay that died without a final status leaves a pid another process may reuse).
+ */
+function jobLoaded(job, deps, dir) {
+    const run = deps.run ?? defaultJobRunner;
+    if (job.kind === "launchd" && job.label)
+        return run("launchctl", ["list", job.label]).status === 0;
+    if (job.kind === "systemd" && job.unit) {
+        const res = run("systemctl", ["--user", "is-active", job.unit]);
+        return res.status === 0 && /^(active|activating|reloading)$/.test(res.stdout.trim());
+    }
+    if (job.kind === "pid" && job.pid) {
+        const alive = deps.alive ?? ((pid) => (process.kill(pid, 0), true));
+        try {
+            if (!alive(job.pid))
+                return false;
+        }
+        catch {
+            return false;
+        }
+        return (deps.commandLine ?? defaultCommandLine)(job.pid)?.includes(dir) ?? false;
+    }
+    return false;
+}
+/** One row per relay run directory; newest first. */
+export function listRelays(deps = {}) {
+    const env = deps.env ?? process.env;
+    const now = deps.now ?? Date.now;
+    const rows = [];
+    for (const run of runDirs(relaysDir(env))) {
+        const cfg = readRelayConfig(run.dir);
+        if (!cfg)
+            continue;
+        const loaded = cfg.job ? jobLoaded(cfg.job, deps, run.dir) : false;
+        rows.push({
+            id: cfg.id || run.id,
+            dir: run.dir,
+            to: cfg.to,
+            session: cfg.session,
+            started: run.started,
+            age: Math.max(0, Math.floor((now() - run.started) / 1000)),
+            state: relayState(run.dir, cfg),
+            lastCheck: lastCheckResult(run.dir),
+            ...(loaded && cfg.job ? { job: jobLabelText(cfg.job) } : {}),
+        });
+    }
+    return rows.sort((a, b) => b.started - a.started);
+}
+function stopJob(job, deps) {
+    const run = deps.run ?? defaultJobRunner;
+    if (job.kind === "launchd" && job.label) {
+        const res = run("launchctl", ["remove", job.label]);
+        if (res.status !== 0)
+            throw new ZellijError("failed", `launchctl remove ${job.label} failed: ${(res.stderr || res.stdout).trim().slice(0, 200)}`);
+    }
+    else if (job.kind === "systemd" && job.unit) {
+        const res = run("systemctl", ["--user", "stop", job.unit]);
+        if (res.status !== 0)
+            throw new ZellijError("failed", `systemctl --user stop ${job.unit} failed: ${(res.stderr || res.stdout).trim().slice(0, 200)}`);
+    }
+    else if (job.kind === "pid" && job.pid) {
+        const kill = deps.kill ?? ((pid) => { process.kill(pid, "SIGTERM"); });
+        kill(job.pid);
+    }
+    else {
+        return "no job recorded; nothing to stop";
+    }
+    return `stopped ${jobLabelText(job)}`;
+}
+/** Stop a running relay's job, mark its directory CANCELLED and scrub its token. */
+export function cancelRelay(id, deps = {}) {
+    const env = deps.env ?? process.env;
+    const now = deps.now ?? Date.now;
+    const match = runDirs(relaysDir(env))
+        .filter((r) => r.id === id)
+        .sort((a, b) => b.started - a.started)[0];
+    if (!match)
+        throw new ZellijError("usage", `no relay ${id}`);
+    const cfg = readRelayConfig(match.dir);
+    if (!cfg)
+        throw new ZellijError("failed", `relay ${id} has no config.json`);
+    const state = relayState(match.dir, cfg);
+    if (state !== "running") {
+        return { id, cancelled: false, state, reason: `relay ${id} is already ${state}; nothing to cancel`, actions: [] };
+    }
+    // Stop only a job that is still this relay's: a crashed relay's label may be
+    // gone and its pid reused. Either way the directory is marked cancelled.
+    const actions = [
+        !cfg.job
+            ? "no job recorded; nothing to stop"
+            : jobLoaded(cfg.job, deps, match.dir)
+                ? stopJob(cfg.job, deps)
+                : `${jobLabelText(cfg.job)} is no longer running this relay; nothing to stop`,
+    ];
+    updateConfig(match.dir, { cancelled: true, status: "CANCELLED", cancelledAt: now() });
+    scrubRelayToken(match.dir);
+    actions.push(`${id} marked CANCELLED (nothing pasted)`);
+    return { id, cancelled: true, state: "cancelled", reason: `cancelled relay ${id}`, actions };
+}
+/** Cancel every running relay that targets `to`. */
+export function cancelAllTo(to, deps = {}) {
+    const env = deps.env ?? process.env;
+    return listRelays({ ...deps, env })
+        .filter((row) => row.to === to && row.state === "running")
+        .map((row) => cancelRelay(row.id, { ...deps, env }));
+}
 /** Remove relay directories and undelivered messages older than `days`. */
 export function pruneRelays(days = 14, env = process.env) {
     const root = relaysDir(env);

package/dist/host/services.d.ts

@@ -48,8 +48,13 @@ export type Runner = (cmd: string, args: string[]) => RunResult;
 export type ServiceState = {
     name: string;
     unit: string;
+    /** Human summary: `running (pid 42)`, `timer every 120 s, loaded`, `not loaded`. */
     state: string;
     active: boolean;
+    /** Main pid when the platform reports one (daemons). */
+    pid?: number;
+    /** Last exit status when the platform reports one. */
+    lastExit?: number;
 };
 export type ServiceHost = {
     account: ServiceAccount;
@@ -61,6 +66,8 @@ export type ServiceHost = {
         exists(path: string): boolean;
         mkdir(path: string): void;
     };
+    /** Synchronous sleep; injected in tests so the launchd wait is instant. */
+    sleep?: (ms: number) => void;
 };
 export declare const defaultRunner: Runner;
 /** The account services are installed for: the current user, or `runAs` when root. */
@@ -87,7 +94,7 @@ export declare function ensureLinger(host: ServiceHost): {
     note?: string;
 };
 export declare function launchdLabel(account: ServiceAccount, name: string): string;
-export declare function launchdPlist(account: ServiceAccount, spec: ServiceSpec): string;
+export declare function launchdPlist(account: ServiceAccount, spec: ServiceSpec, run?: Runner): string;
 /** Write, (re)load and start the services. Returns what it did, one line per unit. */
 export declare function installServices(host: ServiceHost, specs: ServiceSpec[]): {
     lines: string[];
@@ -95,7 +102,7 @@ export declare function installServices(host: ServiceHost, specs: ServiceSpec[])
 };
 /** Stop and delete the services; missing ones are fine. */
 export declare function removeServices(host: ServiceHost, specs: Array<Pick<ServiceSpec, "name" | "kind">>): string[];
-export declare function serviceStates(host: ServiceHost, specs: Array<Pick<ServiceSpec, "name" | "kind">>): ServiceState[];
+export declare function serviceStates(host: ServiceHost, specs: Array<Pick<ServiceSpec, "name" | "kind" | "intervalSec">>): ServiceState[];
 /** Create dir and any missing parents, owned by the account when installing for it. */
 export declare function ensureAccountDir(account: ServiceAccount, dir: string, mode?: number): void;
 /** Write a mode-600 file for the account, creating its directory (700) as needed. */

package/dist/host/services.js

@@ -11,6 +11,14 @@ export const defaultRunner = (cmd, args) => {
     const res = spawnSync(cmd, args, { encoding: "utf8" });
     return { status: res.status ?? 1, stdout: res.stdout ?? "", stderr: res.stderr ?? (res.error?.message ?? "") };
 };
+/** A synchronous sleep for install paths (Node allows Atomics.wait on its main thread). */
+function defaultSleep(ms) {
+    if (ms > 0)
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function hostSleep(host, ms) {
+    (host.sleep ?? defaultSleep)(ms);
+}
 /** The account services are installed for: the current user, or `runAs` when root. */
 export function serviceAccount(runAs, run = defaultRunner) {
     const platform = process.platform;
@@ -181,11 +189,30 @@ function launchdPlistPath(account, label) {
 function xml(text) {
     return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-export function launchdPlist(account, spec) {
+/**
+ * The account's per-user temp dir. launchd gives daemons no TMPDIR, so Zellij
+ * would fall back to it anyway; naming it explicitly lets every caller (an SSH
+ * shell, a script that sets TMPDIR) agree on one Zellij socket dir. Resolved as
+ * the account so root writing a foreign LaunchDaemon gets that account's dir.
+ */
+function darwinUserTempDir(account, run) {
+    const argv = [...(account.foreign ? accountArgv(account) : []), "getconf", "DARWIN_USER_TEMP_DIR"];
+    const [cmd, ...args] = argv;
+    if (!cmd)
+        return undefined;
+    const res = run(cmd, args);
+    const dir = res.status === 0 ? res.stdout.trim() : "";
+    return dir || undefined;
+}
+export function launchdPlist(account, spec, run = defaultRunner) {
     checkName(spec.name);
     const label = launchdLabel(account, spec.name);
     const log = join(account.home, "Library", "Logs", "zswarm", `${spec.name}.log`);
-    const env = { HOME: account.home, USER: account.user, ...(spec.env ?? {}) };
+    const env = { HOME: account.home, USER: account.user };
+    const tmpdir = darwinUserTempDir(account, run);
+    if (tmpdir)
+        env.TMPDIR = tmpdir;
+    Object.assign(env, spec.env ?? {});
     const lines = [
         '<?xml version="1.0" encoding="UTF-8"?>',
         '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
@@ -217,6 +244,36 @@ function launchdDomain(host) {
     const gui = `gui/${a.uid}`;
     return host.run("launchctl", ["print", gui]).status === 0 ? gui : `user/${a.uid}`;
 }
+/** launchd removes a booted-out job asynchronously; wait until print stops seeing it. */
+const BOOTOUT_WAIT_MS = 10_000;
+const BOOTOUT_POLL_MS = 250;
+/** bootstrap racing that teardown fails with EIO (5) or 37; retry a couple of times. */
+const BOOTSTRAP_RETRIES = 2;
+const BOOTSTRAP_RETRY_MS = 1_000;
+function waitForBootout(host, domain, label) {
+    const deadline = Date.now() + BOOTOUT_WAIT_MS;
+    for (;;) {
+        if (host.run("launchctl", ["print", `${domain}/${label}`]).status !== 0)
+            return;
+        const left = deadline - Date.now();
+        if (left <= 0)
+            return;
+        hostSleep(host, Math.min(BOOTOUT_POLL_MS, left));
+    }
+}
+function bootstrapLaunchd(host, domain, path, label) {
+    let last;
+    for (let attempt = 0; attempt <= BOOTSTRAP_RETRIES; attempt++) {
+        const res = host.run("launchctl", ["bootstrap", domain, path]);
+        if (res.status === 0)
+            return;
+        last = res;
+        if (!/Bootstrap failed: (5|37):/.test(res.stderr || res.stdout) || attempt === BOOTSTRAP_RETRIES)
+            break;
+        hostSleep(host, BOOTSTRAP_RETRY_MS);
+    }
+    must(last, `launchctl bootstrap ${domain} ${label}`);
+}
 // ------------------------------------------------------------------ common
 /** Write, (re)load and start the services. Returns what it did, one line per unit. */
 export function installServices(host, specs) {
@@ -257,9 +314,10 @@ export function installServices(host, specs) {
     for (const spec of specs) {
         const label = launchdLabel(a, spec.name);
         const path = launchdPlistPath(a, label);
-        fs.write(path, launchdPlist(a, spec), 0o644);
+        fs.write(path, launchdPlist(a, spec, host.run), 0o644);
         host.run("launchctl", ["bootout", `${domain}/${label}`]);
-        must(host.run("launchctl", ["bootstrap", domain, path]), `launchctl bootstrap ${domain} ${label}`);
+        waitForBootout(host, domain, label);
+        bootstrapLaunchd(host, domain, path, label);
         lines.push(`${label} loaded in ${domain}`);
     }
     return { lines, notes };
@@ -298,7 +356,16 @@ export function serviceStates(host, specs) {
         return specs.map((spec) => {
             const unit = systemdUnitName(spec.name, spec.kind);
             const state = systemctl(host, ["is-active", unit]).stdout.trim() || "unknown";
-            return { name: spec.name, unit, state, active: state === "active" };
+            const props = systemctl(host, ["show", unit, "-p", "MainPID", "-p", "ExecMainStatus"]).stdout;
+            const pid = Number(/^MainPID=(\d+)$/m.exec(props)?.[1] ?? NaN);
+            const exit = /^ExecMainStatus=(-?\d+)$/m.exec(props)?.[1];
+            const lastExit = exit === undefined ? undefined : Number(exit);
+            return {
+                name: spec.name,
+                unit,
+                active: state === "active",
+                ...describeJob(spec, state, Number.isFinite(pid) && pid > 0 ? pid : undefined, lastExit),
+            };
         });
     }
     const domain = launchdDomain(host);
@@ -307,12 +374,41 @@ export function serviceStates(host, specs) {
         const res = host.run("launchctl", ["print", `${domain}/${label}`]);
         if (res.status !== 0)
             return { name: spec.name, unit: label, state: "not loaded", active: false };
-        const state = /^\s*state = (.+)$/m.exec(res.stdout)?.[1]?.trim() ?? "loaded";
-        // Oneshot and interval jobs sit "not running" between runs; loaded is up for them.
-        const active = spec.kind === "daemon" ? state === "running" : true;
-        return { name: spec.name, unit: label, state, active };
+        const raw = /^\s*state = (.+)$/m.exec(res.stdout)?.[1]?.trim() ?? "loaded";
+        const pid = Number(/^\s*pid = (\d+)$/m.exec(res.stdout)?.[1] ?? NaN);
+        const exit = /last exit code = (-?\d+)/.exec(res.stdout)?.[1];
+        const lastExit = exit === undefined ? undefined : Number(exit);
+        const pidOrUndef = Number.isFinite(pid) && pid > 0 ? pid : undefined;
+        // Oneshot and interval jobs sit "not running" between runs; being loaded is up for them.
+        const active = spec.kind === "daemon" ? raw === "running" : true;
+        return {
+            name: spec.name,
+            unit: label,
+            active,
+            ...describeJob(spec, spec.kind === "daemon" ? raw : "loaded", pidOrUndef, lastExit),
+        };
     });
 }
+/**
+ * Word a service by what it is: a daemon is running with a pid, an interval
+ * job is a timer and a oneshot has run; the raw platform state reads like a
+ * failure between timer runs.
+ */
+function describeJob(spec, healthy, pid, lastExit) {
+    const parts = [];
+    if (spec.kind === "daemon") {
+        parts.push(pid === undefined ? healthy : `running (pid ${pid})`);
+    }
+    else if (spec.kind === "interval") {
+        parts.push(`timer every ${Math.max(30, Math.floor(spec.intervalSec ?? 120))} s`, healthy);
+    }
+    else {
+        parts.push("oneshot", healthy);
+    }
+    if (lastExit !== undefined)
+        parts.push(`last exit ${lastExit}`);
+    return { state: parts.join(", "), pid, lastExit };
+}
 function must(res, what) {
     if (res.status !== 0) {
         throw new ZellijError("failed", `${what} failed: ${(res.stderr || res.stdout).trim().slice(0, 300)}`);

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { createExec, NOT_FOUND_EXIT, type ExecFn, type ExecOptions, type ExecRes
 export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeList, worktreeDirName, type GitClient, type GitClientOptions, type Worktree, } from "./git.js";
 export { expandHomePath, looksLikeZswarmBinary, isZellijVersionOutput, resolveZellijBinary, resetZellijIdentityCache, sanitizeZellijEnv, validateSshDestination, validateSshMode, type ZellijExecFn, type ZellijExecResult, } from "./zellij/binary.js";
 export { normalizePaneId, parsePaneList, resolvePane, type ZellijPane, } from "./zellij/panes.js";
-export { liveSessionNames, parseSessionList, resolveSelfPaneId, type ZellijSession, type ZellijSessionResolve, } from "./zellij/session.js";
+export { liveSessionNames, parseCreatedAge, parseSessionList, resolveSelfPaneId, type ZellijSession, type ZellijSessionResolve, } from "./zellij/session.js";
 export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, waitPayload, type LaunchPluginInput, type NewPaneInput, type NewTabInput, type PaneDirection, type PipeInput, type ScrollbackRequest, type WaitRequest, } from "./zellij/args.js";
 export { busPluginUrl, busToPanes, isBusPluginPane, nextConfigKey, parseBusReply, parseScrollbackReply, resolveBusPlugin, scrollbackToScreen, BUS_PIPE_NAME, DEFAULT_BUS_KEY, DEFAULT_BUS_TIMEOUT_MS, type BusMarker, type BusPane, type BusScrollback, type BusScrollbackPane, type BusSnapshot, } from "./zellij/bus.js";
 export { busSnapshot, closeBusPluginPanes, planBus, resetBusCache, type BusPlan, } from "./ops/bus.js";
@@ -34,5 +34,5 @@ export { findPython, runSlot, slotScriptPath } from "./host/slot.js";
 export { installServeService, serveServiceName, serveServiceSpec, serveTokenFromEnv, serveTokenPath, uninstallServeService, SERVE_AWAIT_SESSION_ENV, SERVE_TOKEN_FILE_ENV, type ServeServiceInput, } from "./host/serve-service.js";
 export { accountArgv, installServices, launchdLabel, launchdPlist, removeServices, serviceAccount, serviceStates, systemdUnitName, systemdUnits, writeAccountFile, type Runner, type ServiceAccount, type ServiceHost, type ServiceKind, type ServiceSpec, type ServiceState, } from "./host/services.js";
 export { crewCheck, crewDir, crewDown, crewServiceSpecs, crewStart, crewStatus, crewUp, firstLayoutPane, parseEnvFile, CREW_UNIT_ENV, CREW_WATCH_SEC, type CrewDeps, type CrewUpInput, } from "./host/crew.js";
-export { deliverMessage, doneLines, fillMessage, freshDoneLine, launchRelay, prepareRelay, pruneRelays, relayLoop, relaysDir, runRelayDir, scrubRelayToken, startRelay, waitForRelay, type RelayConfig, type RelayDeps, type RelayStartInput, type RelayStatus, } from "./host/relay.js";
+export { cancelAllTo, cancelRelay, deliverMessage, doneLines, fillMessage, freshDoneLine, launchRelay, listRelays, prepareRelay, pruneRelays, relayLoop, relaysDir, runRelayDir, scrubRelayToken, startRelay, waitForRelay, type RelayAdminDeps, type RelayCancelResult, type RelayConfig, type RelayDeps, type RelayJob, type RelayJobRunner, type RelayRow, type RelayStartInput, type RelayStatus, } from "./host/relay.js";
 export { hostChecks, hostDoctor, hostInstall, hostInstallArgs, hostScriptPath, parseHostReport, type HostCheck, type HostDoctorInput, type HostInstallInput, type SshRunner, } from "./host/host.js";

package/dist/index.js

@@ -4,7 +4,7 @@ export { createExec, NOT_FOUND_EXIT, } from "./exec.js";
 export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeList, worktreeDirName, } from "./git.js";
 export { expandHomePath, looksLikeZswarmBinary, isZellijVersionOutput, resolveZellijBinary, resetZellijIdentityCache, sanitizeZellijEnv, validateSshDestination, validateSshMode, } from "./zellij/binary.js";
 export { normalizePaneId, parsePaneList, resolvePane, } from "./zellij/panes.js";
-export { liveSessionNames, parseSessionList, resolveSelfPaneId, } from "./zellij/session.js";
+export { liveSessionNames, parseCreatedAge, parseSessionList, resolveSelfPaneId, } from "./zellij/session.js";
 export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, waitPayload, } from "./zellij/args.js";
 export { busPluginUrl, busToPanes, isBusPluginPane, nextConfigKey, parseBusReply, parseScrollbackReply, resolveBusPlugin, scrollbackToScreen, BUS_PIPE_NAME, DEFAULT_BUS_KEY, DEFAULT_BUS_TIMEOUT_MS, } from "./zellij/bus.js";
 export { busSnapshot, closeBusPluginPanes, planBus, resetBusCache, } from "./ops/bus.js";
@@ -32,5 +32,5 @@ export { findPython, runSlot, slotScriptPath } from "./host/slot.js";
 export { installServeService, serveServiceName, serveServiceSpec, serveTokenFromEnv, serveTokenPath, uninstallServeService, SERVE_AWAIT_SESSION_ENV, SERVE_TOKEN_FILE_ENV, } from "./host/serve-service.js";
 export { accountArgv, installServices, launchdLabel, launchdPlist, removeServices, serviceAccount, serviceStates, systemdUnitName, systemdUnits, writeAccountFile, } from "./host/services.js";
 export { crewCheck, crewDir, crewDown, crewServiceSpecs, crewStart, crewStatus, crewUp, firstLayoutPane, parseEnvFile, CREW_UNIT_ENV, CREW_WATCH_SEC, } from "./host/crew.js";
-export { deliverMessage, doneLines, fillMessage, freshDoneLine, launchRelay, prepareRelay, pruneRelays, relayLoop, relaysDir, runRelayDir, scrubRelayToken, startRelay, waitForRelay, } from "./host/relay.js";
+export { cancelAllTo, cancelRelay, deliverMessage, doneLines, fillMessage, freshDoneLine, launchRelay, listRelays, prepareRelay, pruneRelays, relayLoop, relaysDir, runRelayDir, scrubRelayToken, startRelay, waitForRelay, } from "./host/relay.js";
 export { hostChecks, hostDoctor, hostInstall, hostInstallArgs, hostScriptPath, parseHostReport, } from "./host/host.js";

package/dist/ops/delivery.d.ts

@@ -2,7 +2,7 @@ import type { StateStore } from "../state.js";
 import type { ZellijClient } from "../zellij/client.js";
 import type { ZellijPane } from "../zellij/panes.js";
 import type { Clock } from "./types.js";
-export type Submitted = boolean | "unverified";
+export type Submitted = boolean | "queued" | "unverified" | "not-delivered";
 export type DeliveryResult = {
     to: string;
     ok: boolean;
@@ -14,6 +14,36 @@ export type DeliveryResult = {
     };
 };
 export type SubmitMode = "auto" | "double-enter" | "none";
+/** Fixed send windows before adaptive scaling; explicit flags always win. */
+export declare const SEND_BUDGETS: {
+    /** Pause before checking the paste landed. */
+    readonly settleMs: 300;
+    /** Pane-lookup retry window for an absent pane. */
+    readonly observeMs: 1000;
+    /** The scaled window never exceeds this multiple of the default. */
+    readonly maxScale: 5;
+    /** A first Zellij call at or under this many ms is not "slow". */
+    readonly slowMs: 1000;
+    readonly settleMaxMs: 5000;
+    readonly observeMaxMs: 30000;
+};
+/**
+ * Scale the fixed settle/observe windows by how slow the send's first Zellij
+ * call was. A call under `slowMs` keeps the defaults; five seconds or more pins
+ * the 5x cap. Explicit `--settle-ms` / `--observe-ms` are returned as given,
+ * and a scaled value is capped by the call's own timeout so it cannot outlast
+ * the observation budget.
+ */
+export declare function scaleBudgets(input: {
+    firstCallMs: number;
+    timeoutMs: number;
+    settleMs?: number;
+    observeMs?: number;
+}): {
+    settleMs: number;
+    observeMs: number;
+    scale: number;
+};
 export type SenderSource = "arg" | "env" | "title" | "default";
 export type SenderLabel = {
     label: string;
@@ -54,14 +84,29 @@ export declare function resolveSubmitMode(args: Record<string, unknown>, pane: {
     command?: string | null;
     title?: string | null;
 }): SubmitMode;
+/**
+ * The body text to look for on screen: its first non-empty line, trimmed to 40
+ * chars. A prefix of the whole body (`body.slice(0, 40)`) can span a newline and
+ * then never matches any single screen line. A leading `[zswarm from=…]` header
+ * is skipped so we look for the caller's own first line.
+ */
+export declare function bodyNeedle(body: string): string;
 /** True when the paste still sits in the composer (bottom of the screen). */
 export declare function composerHolds(screen: string, body: string): boolean;
 /**
  * Compare the pane before vs after the paste.
  * Composer clearing (pasted text left the bottom input region) is submission.
  * `[Pasted text` in scrollback is not evidence.
+ *
+ * `not-delivered` is deliberately conservative: only when the screen is
+ * unchanged once the paste/composer itself is discounted and nothing is queued.
+ * A screen that changed while the body is gone is `unverified` — the pane may
+ * have taken the message and scrolled it away, and a false `not-delivered`
+ * makes the caller resend the whole message.
  */
-export declare function classifySubmit(before: string, after: string, body: string): Submitted;
+export declare function classifySubmit(before: string, after: string, body: string, opts?: {
+    queued?: (screen: string) => boolean;
+}): Submitted;
 /** Paste a body into one pane and record the attempt. */
 export declare function deliverTo(client: ZellijClient, state: StateStore, args: Record<string, unknown>, input: {
     session: string;
@@ -70,4 +115,8 @@ export declare function deliverTo(client: ZellijClient, state: StateStore, args:
     op: string;
     at: number;
     clock: Clock;
+    /** How long the send's first Zellij call took, for adaptive budgets. */
+    firstCallMs?: number;
+    /** The observation timeout the scaled windows are capped by. */
+    timeoutMs?: number;
 }): Promise<DeliveryResult>;