@zswarm/core 0.1.3 → 0.1.5

package/dist/state.js

@@ -1,14 +1,17 @@
-import { appendFileSync, closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { appendFileSync, closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 const LOG_FILE = "log.jsonl";
 const SIGNALS_FILE = "signals.json";
 const SIGNALS_LOCK = "signals.lock";
 const CURSORS_FILE = "cursors.json";
+const CURSORS_LOCK = "cursors.lock";
 const BUS_FILE = "bus.json";
 /** Keeps the log bounded without needing a rotation daemon. */
 const LOG_TAIL_BYTES = 512 * 1024;
 const LOCK_WAIT_MS = 5_000;
+/** A live pid older than this is treated as a recycle of a crashed holder. */
+const LOCK_STALE_MS = 30_000;
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
@@ -77,32 +80,112 @@ export function createStateStore(options = {}) {
         }
         return out;
     }
-    function withSignalsLock(fn) {
+    function pidAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (err) {
+            // ESRCH: gone. EPERM: exists, just unsignalable — still a live holder.
+            return err.code === "EPERM";
+        }
+    }
+    /** Owner recorded in the lock file so a crash can be distinguished from a live holder. */
+    function readLockOwner(lockPath) {
+        try {
+            const rec = JSON.parse(readFileSync(lockPath, "utf8"));
+            if (typeof rec.pid !== "number" || !Number.isInteger(rec.pid) || rec.pid <= 0)
+                return null;
+            const at = typeof rec.at === "number" ? rec.at : 0;
+            return { pid: rec.pid, at };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Dead pid → steal now. This process's own leftover (unlink failed, or a
+     * non-reentrant re-entry) → steal now. A live pid whose `at` is older than
+     * LOCK_STALE_MS is a recycled pid, not a holder still inside fn().
+     * Empty leftover from older writers (wx with no owner bytes) → steal once
+     * mtime is older than the wait, so an in-flight create is not yanked out
+     * from under the holder.
+     * Owner is read once: a second read can see a pid that appeared after an
+     * empty snapshot and would steal a live lock.
+     */
+    function lockIsStale(lockPath) {
+        const owner = readLockOwner(lockPath);
+        if (owner) {
+            if (owner.pid === process.pid)
+                return true;
+            if (!pidAlive(owner.pid))
+                return true;
+            return Date.now() - owner.at >= LOCK_STALE_MS;
+        }
+        try {
+            return Date.now() - statSync(lockPath).mtimeMs >= LOCK_WAIT_MS;
+        }
+        catch {
+            return false;
+        }
+    }
+    function lockBusy(code) {
+        // Unix: O_EXCL on an existing file is EEXIST. Windows: a holder that still
+        // has the handle open (or a delete-pending name) is EPERM / EACCES / EBUSY.
+        return (code === "EEXIST" ||
+            code === "EPERM" ||
+            code === "EACCES" ||
+            code === "EBUSY");
+    }
+    function unlinkLock(lockPath) {
+        const until = Date.now() + 500;
+        while (true) {
+            try {
+                rmSync(lockPath, { force: true });
+                return;
+            }
+            catch (err) {
+                if (!lockBusy(err.code) || Date.now() >= until) {
+                    return;
+                }
+                sleepSync(10);
+            }
+        }
+    }
+    function withFileLock(lockName, fn) {
         ensureDir();
-        const lockPath = join(dir, SIGNALS_LOCK);
+        const lockPath = join(dir, lockName);
         const deadline = Date.now() + LOCK_WAIT_MS;
         while (true) {
             try {
                 const fd = openSync(lockPath, "wx");
                 try {
+                    writeFileSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
                     return fn();
                 }
                 finally {
                     closeSync(fd);
-                    rmSync(lockPath, { force: true });
+                    unlinkLock(lockPath);
                 }
             }
             catch (err) {
                 const code = err.code;
-                if (code !== "EEXIST")
+                if (!lockBusy(code))
                     throw err;
+                if (lockIsStale(lockPath)) {
+                    unlinkLock(lockPath);
+                    continue;
+                }
                 if (Date.now() >= deadline) {
-                    throw new Error(`timed out waiting for ${SIGNALS_LOCK}`);
+                    throw new Error(`timed out waiting for ${lockName}`);
                 }
                 sleepSync(10);
             }
         }
     }
+    function withSignalsLock(fn) {
+        return withFileLock(SIGNALS_LOCK, fn);
+    }
     function readSignals() {
         return readJson(SIGNALS_FILE, {});
     }
@@ -136,31 +219,85 @@ export function createStateStore(options = {}) {
         return all[key] ?? null;
     }
     function writeCursor(key, text) {
-        const all = readJson(CURSORS_FILE, {});
-        all[key] = text;
-        writeJson(CURSORS_FILE, all);
+        withFileLock(CURSORS_LOCK, () => {
+            const all = readJson(CURSORS_FILE, {});
+            all[key] = text;
+            writeJson(CURSORS_FILE, all);
+        });
     }
     function clearCursor(key) {
-        const all = readJson(CURSORS_FILE, {});
-        delete all[key];
-        writeJson(CURSORS_FILE, all);
+        withFileLock(CURSORS_LOCK, () => {
+            const all = readJson(CURSORS_FILE, {});
+            delete all[key];
+            writeJson(CURSORS_FILE, all);
+        });
     }
-    function readBus() {
-        const value = readJson(BUS_FILE, null);
-        if (!value || typeof value.plugin !== "string" || !value.plugin)
+    function asMarker(value) {
+        if (!value || typeof value !== "object")
+            return null;
+        const rec = value;
+        if (typeof rec.plugin !== "string" || !rec.plugin)
             return null;
-        return value;
+        if (typeof rec.configKey !== "string" || !rec.configKey)
+            return null;
+        return {
+            plugin: rec.plugin,
+            configKey: rec.configKey,
+            installedAt: typeof rec.installedAt === "number" ? rec.installedAt : 0,
+        };
     }
-    function writeBus(marker) {
-        writeJson(BUS_FILE, marker);
+    /**
+     * Current `{ sessions: { <name>: marker } }` plus the pre-0.1.6 flat file
+     * `{ plugin, configKey, installedAt }`, which any session may inherit until
+     * the next write namespaces it.
+     */
+    function readBusFile() {
+        const raw = readJson(BUS_FILE, null);
+        if (!raw || typeof raw !== "object")
+            return { sessions: {}, legacy: null };
+        const sessions = {};
+        if (raw.sessions && typeof raw.sessions === "object") {
+            for (const [name, marker] of Object.entries(raw.sessions)) {
+                const parsed = asMarker(marker);
+                if (parsed)
+                    sessions[name] = parsed;
+            }
+        }
+        return { sessions, legacy: asMarker(raw) };
     }
-    function clearBus() {
-        try {
-            rmSync(join(dir, BUS_FILE), { force: true });
+    function readBus(session) {
+        if (!session)
+            return null;
+        const { sessions, legacy } = readBusFile();
+        return sessions[session] ?? legacy;
+    }
+    function writeBus(session, marker) {
+        const { sessions } = readBusFile();
+        sessions[session] = marker;
+        writeJson(BUS_FILE, { sessions });
+    }
+    function clearBus(session) {
+        if (!session) {
+            try {
+                rmSync(join(dir, BUS_FILE), { force: true });
+            }
+            catch {
+                // Nothing to forget.
+            }
+            return;
         }
-        catch {
-            // Nothing to forget.
+        const { sessions } = readBusFile();
+        delete sessions[session];
+        if (Object.keys(sessions).length === 0) {
+            try {
+                rmSync(join(dir, BUS_FILE), { force: true });
+            }
+            catch {
+                // Nothing to forget.
+            }
+            return;
         }
+        writeJson(BUS_FILE, { sessions });
     }
     /** Test helper: drop everything this store wrote. */
     function reset() {

package/dist/zellij/args.d.ts

@@ -47,6 +47,8 @@ export type WaitRequest = {
     idleMs?: number;
     timeoutMs?: number;
     pollMs?: number;
+    /** Read scrollback above the viewport, matching dump --full. */
+    full?: boolean;
 };
 /**
  * `regex` is deliberately absent: the plugin has no regex engine, refuses such

package/dist/zellij/args.js

@@ -35,6 +35,7 @@ export function waitPayload(req) {
         idleMs: req.idleMs ?? 2000,
         timeoutMs: req.timeoutMs ?? 60000,
         pollMs: req.pollMs ?? 50,
+        full: req.full === true,
     });
 }
 /** Screens plus "did this move since you last asked", so status needs no gap. */

package/dist/zellij/binary.d.ts

@@ -10,10 +10,12 @@ export declare function resolveZellijBinary(env?: NodeJS.ProcessEnv): string;
 export declare function sanitizeZellijEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /**
  * Remote crew: `ZSWARM_SSH=user@host` routes every zellij call over ssh.
- * `ZSWARM_SSH_OPTS` is split on whitespace; `BatchMode` keeps it non-interactive.
+ * `ZSWARM_SSH_OPTS` is split like a shell so quoted paths stay one arg;
+ * `BatchMode` keeps it non-interactive.
  * `ZSWARM_TMP` points at the interactive session's temp (or `auto` to discover).
  * `ZSWARM_SSH_MODE=interactive` runs each call in the Windows desktop session.
  */
+export declare function parseSshOpts(raw: string): string[];
 export declare function resolveSshTarget(env?: NodeJS.ProcessEnv): SshTarget | null;
 /** Runner bound to the resolved zellij binary and a cleaned environment. */
 export declare function defaultExec(zellijPath: string, env: NodeJS.ProcessEnv): ZellijExecFn;

package/dist/zellij/binary.js

@@ -75,15 +75,47 @@ export function sanitizeZellijEnv(env) {
 }
 /**
  * Remote crew: `ZSWARM_SSH=user@host` routes every zellij call over ssh.
- * `ZSWARM_SSH_OPTS` is split on whitespace; `BatchMode` keeps it non-interactive.
+ * `ZSWARM_SSH_OPTS` is split like a shell so quoted paths stay one arg;
+ * `BatchMode` keeps it non-interactive.
  * `ZSWARM_TMP` points at the interactive session's temp (or `auto` to discover).
  * `ZSWARM_SSH_MODE=interactive` runs each call in the Windows desktop session.
  */
+export function parseSshOpts(raw) {
+    const out = [];
+    let cur = "";
+    let quote = null;
+    for (let i = 0; i < raw.length; i++) {
+        const ch = raw[i];
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                cur += ch;
+            }
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+        }
+        else if (/\s/.test(ch)) {
+            if (cur.length > 0) {
+                out.push(cur);
+                cur = "";
+            }
+        }
+        else {
+            cur += ch;
+        }
+    }
+    if (cur.length > 0)
+        out.push(cur);
+    return out;
+}
 export function resolveSshTarget(env = process.env) {
     const host = env.ZSWARM_SSH?.trim();
     if (!host)
         return null;
-    const options = (env.ZSWARM_SSH_OPTS ?? "").trim().split(/\s+/).filter(Boolean);
+    const options = parseSshOpts(env.ZSWARM_SSH_OPTS ?? "");
     if (!options.some((o) => o.startsWith("BatchMode"))) {
         options.unshift("-o", "BatchMode=yes");
     }

package/dist/zellij/bus.d.ts

@@ -67,6 +67,15 @@ export declare function resolveBusPlugin(env?: NodeJS.ProcessEnv): string | null
 export declare function busPluginUrl(pluginPath: string): string;
 /** zswarm-bus → zswarm-bus-2 → zswarm-bus-3: a fresh pipe destination each time. */
 export declare function nextConfigKey(key: string): string;
+/**
+ * Plugin panes belonging to this bus — never tab-bar / status-bar / room.
+ * Titles are the `file:` URL (or the wasm basename) Zellij shows for the pane.
+ */
+export declare function isBusPluginPane(pane: {
+    isPlugin?: boolean;
+    title?: string;
+    command?: string | null;
+}, pluginPath?: string | null): boolean;
 /**
  * Pull the plugin's answer out of the pipe. Zellij interleaves its own notices
  * ("Action CliPipe did not complete within 1s timeout" shows up on successful

package/dist/zellij/bus.js

@@ -140,6 +140,26 @@ export function nextConfigKey(key) {
         return `${key}-2`;
     return `${match[1]}-${Number(match[2]) + 1}`;
 }
+/**
+ * Plugin panes belonging to this bus — never tab-bar / status-bar / room.
+ * Titles are the `file:` URL (or the wasm basename) Zellij shows for the pane.
+ */
+export function isBusPluginPane(pane, pluginPath) {
+    if (!pane.isPlugin)
+        return false;
+    const hay = `${pane.title ?? ""}\n${pane.command ?? ""}`
+        .replace(/\\/g, "/")
+        .toLowerCase();
+    if (hay.includes("zswarm-bus") || hay.includes("zswarm-events"))
+        return true;
+    if (!pluginPath)
+        return false;
+    const normalized = pluginPath.replace(/\\/g, "/").toLowerCase();
+    if (normalized && hay.includes(normalized))
+        return true;
+    const base = normalized.split("/").pop();
+    return Boolean(base && hay.includes(base));
+}
 function toSnapshot(value) {
     if (value.ok !== true || !Array.isArray(value.panes))
         return null;

package/dist/zellij/client.d.ts

@@ -8,6 +8,7 @@ export type ZellijClientOptions = {
     zellijPath?: string;
     timeoutMs?: number;
     env?: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
 };
 /** Thin, stateless wrapper over the `zellij` binary. */
 export declare function createZellijClient(options?: ZellijClientOptions): {

package/dist/zellij/client.js

@@ -5,7 +5,7 @@ import { parseTabList, resolveTab } from "./tabs.js";
 import { createSshExec } from "../exec.js";
 import { DEFAULT_TIMEOUT_MS, NOT_FOUND_EXIT, defaultExec, resolveSshTarget, resolveZellijBinary, sanitizeZellijEnv, } from "./binary.js";
 import { normalizePaneId, parsePaneList, resolvePane, } from "./panes.js";
-import { parseSessionList, resolveSelfPaneId, sessionFromEnv, sessionFromList, } from "./session.js";
+import { isZellijNoSessionsOutput, parseSessionList, resolveSelfPaneId, sessionFromEnv, sessionFromList, } from "./session.js";
 /** Thin, stateless wrapper over the `zellij` binary. */
 export function createZellijClient(options = {}) {
     const env = options.env ?? process.env;
@@ -13,10 +13,11 @@ export function createZellijClient(options = {}) {
     const ssh = options.exec ? null : resolveSshTarget(env);
     const zellijPath = options.zellijPath ??
         (ssh ? `ssh://${ssh.host}/${ssh.remoteBin}` : resolveZellijBinary(env));
-    const exec = options.exec ??
+    const rawExec = options.exec ??
         (ssh
             ? createSshExec(ssh, sanitizeZellijEnv(env))
             : defaultExec(zellijPath, env));
+    const exec = (args, opts) => rawExec(args, { ...opts, signal: opts.signal ?? options.signal });
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const selfPaneId = resolveSelfPaneId(env);
     async function run(args, label) {
@@ -30,7 +31,20 @@ export function createZellijClient(options = {}) {
         return result;
     }
     async function listSessions() {
-        const result = await run(["list-sessions", "--short", "--no-formatting"], "zellij list-sessions");
+        const result = await exec(["list-sessions", "--short", "--no-formatting"], {
+            timeoutMs,
+        });
+        if (result.code === NOT_FOUND_EXIT) {
+            throw new ZellijError("zellij_missing", `zellij binary not found (${zellijPath}); install Zellij ≥ 0.42, add it to PATH, or set ZSWARM_BIN / ZSWARM_PATH`);
+        }
+        if (result.code !== 0) {
+            // Nonzero here is Zellij's normal "none running", not a crash. Empty
+            // lets resolveSession throw zellij_no_session so unworktree can treat
+            // it as no occupants instead of zellij_failed.
+            if (isZellijNoSessionsOutput(result.stdout, result.stderr))
+                return [];
+            throw new ZellijError("zellij_failed", `zellij list-sessions failed (exit ${result.code}): ${result.stderr.trim() || result.stdout.trim() || "no output"}`);
+        }
         return parseSessionList(result.stdout);
     }
     async function resolveSession(explicit) {

package/dist/zellij/session.d.ts

@@ -8,6 +8,8 @@ export type ZellijSessionResolve = {
  */
 export declare function resolveSelfPaneId(env?: NodeJS.ProcessEnv): string | null;
 export declare function parseSessionList(stdout: string): string[];
+/** Zellij exits 1 and prints this when the machine simply has no sessions. */
+export declare function isZellijNoSessionsOutput(stdout: string, stderr: string): boolean;
 /** Session from an explicit argument or the environment, before asking Zellij. */
 export declare function sessionFromEnv(env: NodeJS.ProcessEnv, explicit?: string | null): ZellijSessionResolve | null;
 /** Pick a session when the environment gave no answer. */

package/dist/zellij/session.js

@@ -19,6 +19,10 @@ export function parseSessionList(stdout) {
         .map((l) => l.trim())
         .filter(Boolean);
 }
+/** Zellij exits 1 and prints this when the machine simply has no sessions. */
+export function isZellijNoSessionsOutput(stdout, stderr) {
+    return /no active zellij sessions found/i.test(`${stderr}\n${stdout}`);
+}
 /** Session from an explicit argument or the environment, before asking Zellij. */
 export function sessionFromEnv(env, explicit) {
     const arg = explicit?.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zswarm/core",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "zSwarm Zellij client and shared ops dispatch",
   "exports": {
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@zswarm/wasm": "0.1.1"
+    "@zswarm/wasm": "0.1.2"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",