@zswarm/core 0.1.8 → 0.1.9

package/dist/exec.d.ts

@@ -21,7 +21,8 @@ export type ExecOptions = {
      * Stop as soon as the accumulated stdout satisfies this, instead of waiting
      * for the process to exit. `zellij pipe` answers in milliseconds but stays
      * resident when it has no terminal, so waiting for exit means waiting for the
-     * timeout.
+     * timeout. Replies are JSON lines, so this is only consulted when a chunk
+     * could have completed one (see `mayCompleteLine`).
      */
     until?: (stdout: string) => boolean;
     /** Kill the child when aborted (MCP cancellation). */

package/dist/exec.js

@@ -322,6 +322,14 @@ export function createSshExec(target, env, options = {}) {
     };
     return exec;
 }
+/**
+ * A JSON line is complete once its newline arrives, or once the stream ends on
+ * `}` (a last line written without one). Asking `until` about every chunk
+ * re-parses a multi-megabyte single-line scrollback reply once per 64KB read.
+ */
+function mayCompleteLine(chunk) {
+    return chunk.includes("\n") || chunk.trimEnd().endsWith("}");
+}
 /** Read stdout until the answer is in hand, then stop caring about the child. */
 function runUntil(binPath, args, env, options) {
     return new Promise((resolve) => {
@@ -361,13 +369,18 @@ function runUntil(binPath, args, env, options) {
         child.on("error", (err) => {
             finish(localSpawnResult(err, binPath));
         });
+        // Decode across reads: a multi-byte character split between two chunks
+        // must not come out as U+FFFD in the screen text.
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
         child.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
-            if (options.until(stdout))
+            stdout += chunk;
+            if (mayCompleteLine(chunk) && options.until(stdout)) {
                 finish({ code: 0, stdout, stderr });
+            }
         });
         child.stderr.on("data", (chunk) => {
-            stderr += chunk.toString();
+            stderr += chunk;
         });
         child.on("close", (code) => finish({ code: code ?? 0, stdout, stderr }));
     });

package/dist/ops/broadcast.d.ts

@@ -3,6 +3,12 @@ import type { StateStore } from "../state.js";
 import type { ZellijClient } from "../zellij/client.js";
 import type { ZellijPane } from "../zellij/panes.js";
 import type { Clock, OpsResult } from "./types.js";
+/**
+ * Deliveries in flight at once. Each one is a dump, paste, Enter, settle sleep
+ * and re-dump against its own `--pane-id`, so panes do not wait on each other;
+ * the cap keeps a large crew from launching a burst of zellij (or ssh) clients.
+ */
+export declare const BROADCAST_CONCURRENCY = 3;
 export type Skipped = {
     id: string;
     reason: string;

package/dist/ops/broadcast.js

@@ -1,7 +1,14 @@
 import { ZellijError } from "../errors.js";
 import { assertPaneAllowed } from "../policy.js";
 import { deliverTo, selfPaneTitle, withSenderLabel } from "./delivery.js";
+import { mapPool } from "./status.js";
 import { isTrue, optionalString } from "./util.js";
+/**
+ * Deliveries in flight at once. Each one is a dump, paste, Enter, settle sleep
+ * and re-dump against its own `--pane-id`, so panes do not wait on each other;
+ * the cap keeps a large crew from launching a burst of zellij (or ssh) clients.
+ */
+export const BROADCAST_CONCURRENCY = 3;
 /**
  * Pick the panes a broadcast should reach: an explicit comma list, a tab, or
  * every terminal pane — then drop the ones it must not write to.
@@ -92,17 +99,14 @@ export async function broadcast(client, state, args, clock, policy, env = proces
     if (targets.length === 0) {
         throw new ZellijError("no_targets", `nothing to broadcast to${skipped.length > 0 ? ` (skipped ${skipped.map((s) => `${s.id}:${s.reason}`).join(", ")})` : ""}`);
     }
-    const results = [];
-    for (const pane of targets) {
-        results.push(await deliverTo(client, state, labeled, {
-            session,
-            pane,
-            body,
-            op: "broadcast",
-            at: clock.now(),
-            clock,
-        }));
-    }
+    const results = await mapPool(targets, BROADCAST_CONCURRENCY, (pane) => deliverTo(client, state, labeled, {
+        session,
+        pane,
+        body,
+        op: "broadcast",
+        at: clock.now(),
+        clock,
+    }));
     const delivered = results.filter((r) => r.ok);
     return {
         ok: true,

package/dist/ops/status.d.ts

@@ -40,12 +40,13 @@ export declare function statusTabs(peers: Record<string, unknown>[]): {
     panes: number;
     states: Record<string, number>;
 }[];
-export declare function classify(input: {
+type ScreenPair = {
     exited: boolean;
     before: string;
     after: string;
     profile?: HarnessProfile | null;
-}): PeerState;
+};
+export declare function classify(input: ScreenPair): PeerState;
 /** Run `fn` over items with at most `limit` in flight. */
 export declare function mapPool<T, R>(items: readonly T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
 /**
@@ -59,3 +60,4 @@ export declare function peerStatus(client: ZellijClient, args: Record<string, un
     deadlineAt?: number;
     signal?: AbortSignal;
 }): Promise<OpsResult>;
+export {};

package/dist/ops/status.js

@@ -53,9 +53,6 @@ export function waitingPrompt(screen, profile) {
     const last = lines[lines.length - 1] ?? "";
     return QUESTION.test(last) ? { reason: "prompt", evidence: last.slice(0, 320), source: "screen" } : null;
 }
-function promptHolds(screen, profile) {
-    return waitingPrompt(screen, profile) !== null;
-}
 /** Compact summary of the selected terminal peers, including inactive tabs. */
 export function statusTabs(peers) {
     const tabs = new Map();
@@ -69,12 +66,17 @@ export function statusTabs(peers) {
     }
     return [...tabs.values()];
 }
-export function classify(input) {
+/** The verdict and, for `waiting`, the prompt behind it — one screen scan. */
+function classifyWithEvidence(input) {
     if (input.exited)
-        return "exited";
+        return { state: "exited", waiting: null };
     if (input.before !== input.after)
-        return "busy";
-    return promptHolds(input.after, input.profile) ? "waiting" : "idle";
+        return { state: "busy", waiting: null };
+    const waiting = waitingPrompt(input.after, input.profile);
+    return { state: waiting ? "waiting" : "idle", waiting };
+}
+export function classify(input) {
+    return classifyWithEvidence(input).state;
 }
 /** Run `fn` over items with at most `limit` in flight. */
 export async function mapPool(items, limit, fn) {
@@ -96,6 +98,7 @@ function isCancelledError(err) {
     return ((err instanceof ZellijError && err.code === "cancelled") ||
         (err instanceof Error && /cancelled/i.test(err.message)));
 }
+/** A `waiting` peer carries its evidence in `extra`, found when it was classified. */
 function peerEntry(pane, state, screen, verbose, extra) {
     const entry = {
         id: pane.id,
@@ -106,8 +109,6 @@ function peerEntry(pane, state, screen, verbose, extra) {
         lastLine: lastLine(screen).slice(0, 160),
         ...extra,
     };
-    if (state === "waiting")
-        entry.waiting = waitingPrompt(screen, resolveHarness(pane));
     if (verbose) {
         entry.command = pane.command ?? null;
         entry.cwd = pane.cwd ?? null;
@@ -185,11 +186,13 @@ export async function peerStatus(client, args, clock, supplied, opts = {}) {
                     return peerEntry(pane, "exited", "", verbose);
                 }
                 const row = changed.get(pane.id);
+                const waiting = row ? waitingPrompt(row.screen, resolveHarness(pane)) : null;
                 const state = !row ? "unknown"
-                    : promptHolds(row.screen, resolveHarness(pane)) ? "waiting"
+                    : waiting ? "waiting"
                         : row.first ? "unknown" : row.changed ? "busy" : "idle";
                 return peerEntry(pane, state, row?.screen ?? "", verbose, {
                     ...(row?.first ? { first: true } : {}),
+                    ...(waiting ? { waiting } : {}),
                 });
             })
                 .sort((a, b) => String(a.id).localeCompare(String(b.id)));
@@ -315,13 +318,13 @@ export async function peerStatus(client, args, clock, supplied, opts = {}) {
             peers.push(peerEntry(pane, "unknown", after ?? first ?? "", verbose));
             continue;
         }
-        const state = classify({
+        const { state, waiting } = classifyWithEvidence({
             exited: false,
             before: first,
             after,
             profile: resolveHarness(pane),
         });
-        peers.push(peerEntry(pane, state, after, verbose));
+        peers.push(peerEntry(pane, state, after, verbose, waiting ? { waiting } : undefined));
     }
     peers.sort((a, b) => String(a.id).localeCompare(String(b.id)));
     const free = peers.filter((p) => p.state === "idle").map((p) => p.id);

package/dist/ops/wait.js

@@ -1,4 +1,5 @@
 import { ZellijError } from "../errors.js";
+import { DEFAULT_TIMEOUT_MS } from "../zellij/binary.js";
 import { DEFAULT_WAIT_MAX_CHARS, dumpMaxChars, isTrue, normalizeScreen, numberArg, optionalString, throwIfAborted, truncateDumpText, } from "./util.js";
 const WAIT_DEFAULTS = {
     idleMs: 2_000,
@@ -10,6 +11,11 @@ const WAIT_LIMITS = {
     pollMs: { min: 50, max: 30_000 },
     timeoutMs: { min: 1_000, max: 900_000 },
 };
+/**
+ * A poll at the deadline still gets this long, so `timeout` reports the screen
+ * at the deadline; a hung dump there overruns the wait by at most this much.
+ */
+const FINAL_DUMP_MS = 1_000;
 export function buildMatcher(args) {
     const match = optionalString(args.match);
     if (!match)
@@ -98,15 +104,29 @@ export async function waitForPane(client, target, args, clock, waitViaBus, signa
     let lastChangeAt = started;
     let polls = 0;
     let changes = 0;
+    let last = null;
     for (;;) {
         throwIfAborted(signal);
-        const dumped = await client.dumpPane({
-            session,
-            paneId: pane.id,
-            full: isTrue(args.full),
-        });
+        const left = timeoutMs - (clock.now() - started);
+        let text;
+        try {
+            const dumped = await client.dumpPane({
+                session,
+                paneId: pane.id,
+                full,
+                timeoutMs: Math.max(FINAL_DUMP_MS, Math.min(left, DEFAULT_TIMEOUT_MS)),
+            });
+            text = dumped.text;
+        }
+        catch (err) {
+            throwIfAborted(signal);
+            // Out of time with a screen in hand: the wait timed out, it did not fail.
+            if (last && clock.now() - started >= timeoutMs) {
+                return waitResult("timeout", { ...last, at: clock.now() });
+            }
+            throw err;
+        }
         polls++;
-        const text = dumped.text;
         const screen = normalizeScreen(text);
         const at = clock.now();
         const ctx = {
@@ -137,6 +157,8 @@ export async function waitForPane(client, target, args, clock, waitViaBus, signa
         }
         if (at - started >= timeoutMs)
             return waitResult("timeout", ctx);
-        await clock.sleep(pollMs);
+        last = ctx;
+        // The last poll lands on the deadline, not up to a whole pollMs past it.
+        await clock.sleep(Math.min(pollMs, timeoutMs - (at - started)));
     }
 }

package/dist/state.d.ts

@@ -29,6 +29,13 @@ export type BusMarkerRecord = {
     configKey: string;
     installedAt: number;
 };
+/** How much of the end of the log `readLog` reads; older entries are not shown. */
+export declare const LOG_TAIL_BYTES: number;
+/**
+ * Past this, the append that crossed it trims the file back to its readable
+ * tail. Keeps the log bounded without needing a rotation daemon.
+ */
+export declare const LOG_MAX_BYTES: number;
 export declare function defaultStateDir(env?: NodeJS.ProcessEnv): string;
 export type StateStoreOptions = {
     dir?: string;

package/dist/state.js

@@ -1,4 +1,4 @@
-import { appendFileSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, closeSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 const LOG_FILE = "log.jsonl";
@@ -7,8 +7,13 @@ 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;
+/** How much of the end of the log `readLog` reads; older entries are not shown. */
+export const LOG_TAIL_BYTES = 512 * 1024;
+/**
+ * Past this, the append that crossed it trims the file back to its readable
+ * tail. Keeps the log bounded without needing a rotation daemon.
+ */
+export const LOG_MAX_BYTES = 4 * 1024 * 1024;
 /** Bound for waiting on a *live* lock holder before failing. */
 const LOCK_WAIT_MS = 5_000;
 /**
@@ -16,6 +21,45 @@ const LOCK_WAIT_MS = 5_000;
  * exclusive create (wait), not as abandoned debris (refuse).
  */
 const LOCK_PENDING_MS = LOCK_WAIT_MS;
+/**
+ * The last `bytes` of a file, starting at its first whole line. Reads only
+ * that window, so a long-lived log does not cost a full read per `log` call.
+ */
+function readFileTail(path, bytes) {
+    const fd = openSync(path, "r");
+    try {
+        const size = fstatSync(fd).size;
+        // One byte of lead-in says whether the window already starts a line.
+        const start = Math.max(0, size - bytes - 1);
+        const buf = Buffer.alloc(size - start);
+        let read = 0;
+        while (read < buf.length) {
+            const n = readSync(fd, buf, read, buf.length - read, start + read);
+            if (n === 0)
+                break;
+            read += n;
+        }
+        const text = buf.toString("utf8", 0, read);
+        return start === 0 ? text : text.slice(text.indexOf("\n") + 1);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Keep only a file's readable tail. Everything before it is already invisible
+ * to `readLog`; an append racing the rename can be lost, and the log is an aid.
+ */
+function trimToTail(path, bytes) {
+    const tmp = `${path}.${process.pid}.tmp`;
+    try {
+        writeFileSync(tmp, readFileTail(path, bytes), "utf8");
+        renameSync(tmp, path);
+    }
+    catch {
+        rmSync(tmp, { force: true });
+    }
+}
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
@@ -53,7 +97,10 @@ export function createStateStore(options = {}) {
             return;
         try {
             ensureDir();
-            appendFileSync(join(dir, LOG_FILE), `${JSON.stringify(entry)}\n`, "utf8");
+            const path = join(dir, LOG_FILE);
+            appendFileSync(path, `${JSON.stringify(entry)}\n`, "utf8");
+            if (statSync(path).size > LOG_MAX_BYTES)
+                trimToTail(path, LOG_TAIL_BYTES);
         }
         catch {
             // The log is an aid, never a reason to fail an op.
@@ -62,15 +109,11 @@ export function createStateStore(options = {}) {
     function readLog() {
         let raw;
         try {
-            raw = readFileSync(join(dir, LOG_FILE), "utf8");
+            raw = readFileTail(join(dir, LOG_FILE), LOG_TAIL_BYTES);
         }
         catch {
             return [];
         }
-        if (raw.length > LOG_TAIL_BYTES) {
-            raw = raw.slice(raw.length - LOG_TAIL_BYTES);
-            raw = raw.slice(raw.indexOf("\n") + 1);
-        }
         const out = [];
         for (const line of raw.split("\n")) {
             if (!line.trim())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zswarm/core",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "type": "module",
   "description": "zSwarm Zellij client and shared ops dispatch",
   "exports": {