@zswarm/core 0.4.1 → 0.5.0

package/dist/host/crew.js

@@ -116,6 +116,10 @@ function foreignLayoutHint(session) {
         `(on Windows often a renamed session whose server kept its old name). Stop the server that holds it ` +
         `(a zellij.exe --server process), run \`zellij delete-session ${session}\`, then \`zswarm crew start ${session}\``);
 }
+function liveSessionHint(session) {
+    return (`If that session should go, stop it yourself (\`zellij kill-session ${session}\`; on Windows a renamed ` +
+        `session's server may have to be stopped by its PID), then run \`zswarm crew start ${session}\` again.`);
+}
 function crewRecorder(deps, env) {
     const record = deps.record ?? ((entry) => createStateStore({ env }).appendLog(entry));
     return (session, ok, detail) => {
@@ -205,25 +209,39 @@ export async function crewStart(session, deps = {}) {
     const record = crewRecorder(deps, env0);
     const names = layoutPaneNames(readFileSync(crewFile(dir, files.layout), "utf8"));
     const config = files.config ? ["--config", crewFile(dir, files.config)] : [];
+    // One shared pre-check for both platforms: a live session that already has
+    // the crew's layout is the crew — keep it, never rebuild or kill it. A live
+    // session with another layout is not ours to stop; refuse and stop nothing.
+    const client = account.platform === "win32" ? windowsClient(deps, env) : null;
+    if ((await sessions(env)).includes(session)) {
+        const live = checkLayout(await panes(session, env), files.first, names);
+        if (live.state === "ok") {
+            if (client) {
+                const opened = await client.ensure(session);
+                log(`session ${session} already up; client window ${opened.opened ? "opened" : "already open"}`);
+            }
+            else {
+                log(`session ${session} already up with its layout`);
+            }
+            return 0;
+        }
+        // Live but not the crew's layout (state "foreign" or "missing"): refuse.
+        const why = `refused: a live session named ${session} is already running (${live.seen}) without this crew's layout; nothing was stopped. ${liveSessionHint(session)}`;
+        log(`session ${session} ${why}`);
+        record(session, false, why);
+        return 1;
+    }
     if (account.platform === "win32") {
         // Windows: a session created with `attach --create-background` renders
         // empty panes and drops pasted input, so the session is created BY an
         // attached client instead — a minimized console window running
         // `zellij --layout ... attach --create`, which `crew client` starts. That
         // window is what `crew start` reopens when it is gone.
-        const client = windowsClient(deps, env);
-        // A live session that already has its layout is the crew: keep it and only
-        // make sure its window is there. Rebuilding would restart every pane.
-        if ((await sessions(env)).includes(session)
-            && checkLayout(await panes(session, env), files.first, names).state === "ok") {
-            const opened = await client.ensure(session);
-            log(`session ${session} already up; client window ${opened.opened ? "opened" : "already open"}`);
-            return 0;
-        }
+        const winClient = client ?? windowsClient(deps, env);
         for (let attempt = 1; attempt <= 3; attempt++) {
             zellij(["delete-session", session], env); // clears only a dead session of this name
-            await client.close(session); // a window left over from the previous attempt
-            const opened = await client.ensure(session);
+            await winClient.close(session); // a window left over from the previous attempt
+            const opened = await winClient.ensure(session);
             log(`client window ${opened.opened ? "opened" : "already open"} for ${session}`);
             for (let i = 0; i < 30 && !(await sessions(env)).includes(session); i++)
                 await sleep(1_000);
@@ -234,7 +252,7 @@ export async function crewStart(session, deps = {}) {
                 return 0;
             }
             zellij(["kill-session", session], env);
-            await client.close(session);
+            await winClient.close(session);
             if (check.state === "foreign") {
                 const why = `stopped: came up with ${check.seen}, none from its layout. ${foreignLayoutHint(session)}`;
                 log(`session ${session} ${why}`);

package/dist/ops/dispatch.js

@@ -646,7 +646,7 @@ async function dispatchOperation(args, injected, deps, context, env) {
             case "signal":
                 return postSignal(state(), args, clock);
             case "signals":
-                return listSignals(state());
+                return listSignals(state(), args);
             case "await":
                 return await awaitSignal(state(), args, clock);
             case "log":

package/dist/ops/restart.js

@@ -174,6 +174,10 @@ async function waitForExit(client, session, pane, kind, profile, budgetMs, clock
             const live = panes.find((p) => p.id === pane.id);
             if (live?.exited)
                 return { exited: true, reason: "pane_exited" };
+            // A held command pane is Zellij's "exited, press Enter to re-run" state;
+            // the relaunch step already presses Enter for command panes.
+            if (kind === "command" && live?.held)
+                return { exited: true, reason: "pane_held" };
         }
         catch {
             // A transient listing failure is not evidence the pane is gone.

package/dist/ops/signals.d.ts

@@ -5,6 +5,6 @@ import type { Clock, OpsResult } from "./types.js";
  * crew can rendezvous without any of them staying resident.
  */
 export declare function postSignal(state: StateStore, args: Record<string, unknown>, clock: Clock): OpsResult;
-export declare function listSignals(state: StateStore): OpsResult;
+export declare function listSignals(state: StateStore, args?: Record<string, unknown>): OpsResult;
 /** Block until a channel reaches `count` posts, or the deadline passes. */
 export declare function awaitSignal(state: StateStore, args: Record<string, unknown>, clock: Clock): Promise<OpsResult>;

package/dist/ops/signals.js

@@ -28,20 +28,33 @@ export function postSignal(state, args, clock) {
         data: { channel, count: posted.count, at: posted.at, payload: posted.last },
     };
 }
-export function listSignals(state) {
+export function listSignals(state, args = {}) {
     const all = state.readSignals();
+    const total = Object.keys(all).length;
+    const channel = optionalString(args.channel);
+    const since = optionalString(args.since);
+    const sinceAt = since ? Number(since) : null;
+    const hasLimit = args.limit !== undefined && args.limit !== null && args.limit !== "";
+    let matched = Object.entries(all).map(([name, v]) => ({
+        channel: name,
+        count: v.count,
+        at: v.at,
+        last: v.last ?? null,
+    }));
+    if (channel)
+        matched = matched.filter((c) => c.channel.startsWith(channel));
+    if (sinceAt !== null && Number.isFinite(sinceAt)) {
+        matched = matched.filter((c) => c.at >= sinceAt);
+    }
+    const matchedCount = matched.length;
+    const channels = hasLimit
+        ? matched
+            .sort((a, b) => b.at - a.at)
+            .slice(0, numberArg(args, "limit", 1, { min: 1, max: 1_000 }))
+        : matched.sort((a, b) => a.channel.localeCompare(b.channel));
     return {
         ok: true,
-        data: {
-            channels: Object.entries(all)
-                .map(([channel, v]) => ({
-                channel,
-                count: v.count,
-                at: v.at,
-                last: v.last ?? null,
-            }))
-                .sort((a, b) => a.channel.localeCompare(b.channel)),
-        },
+        data: { total, matched: matchedCount, channels },
     };
 }
 /** Block until a channel reaches `count` posts, or the deadline passes. */

package/dist/schema.js

@@ -141,8 +141,8 @@ export const PARAMS = [
         name: "channel",
         type: "string",
         flags: ["--channel"],
-        ops: ["signal", "await"],
-        description: "signal/await: channel name",
+        ops: ["signal", "await", "signals"],
+        description: "signal/await: channel name; signals: only channels whose name starts with this",
     },
     {
         name: "payload",
@@ -216,15 +216,15 @@ export const PARAMS = [
         name: "limit",
         type: "number",
         flags: ["--limit"],
-        ops: ["log"],
-        description: "log: how many entries to return (default 20)",
+        ops: ["log", "signals"],
+        description: "log: how many entries to return (default 20); signals: the N most recently updated channels",
     },
     {
         name: "since",
         type: "string",
         flags: ["--since"],
-        ops: ["log"],
-        description: "log: only entries at or after this epoch millisecond",
+        ops: ["log", "signals"],
+        description: "log: only entries at or after this epoch millisecond; signals: only channels updated at or after this epoch millisecond",
     },
     {
         name: "failed",

package/dist/zellij/bus.js

@@ -294,6 +294,7 @@ export function busToPanes(snapshot) {
             tabId: snapshot.tabIds?.[pane.tab] ?? null,
             focused: pane.focused,
             exited: pane.exited,
+            held: false,
             floating: false,
             contentColumns: null,
         };

package/dist/zellij/panes.d.ts

@@ -9,6 +9,8 @@ export type ZellijPane = {
     tabId?: number | null;
     focused: boolean;
     exited: boolean;
+    /** Zellij's "exited, press Enter to re-run" command-pane state. */
+    held: boolean;
     floating: boolean;
     contentColumns: number | null;
 };

package/dist/zellij/panes.js

@@ -31,6 +31,7 @@ function parsePaneRow(row) {
         tabId: typeof row.tab_id === "number" ? row.tab_id : null,
         focused: row.is_focused === true,
         exited: row.exited === true,
+        held: row.is_held === true,
         floating: row.is_floating === true,
         contentColumns: typeof row.pane_content_columns === "number"
             ? row.pane_content_columns

package/package.json

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