@zswarm/core 0.4.0 → 0.4.2

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/delivery.d.ts

@@ -21,8 +21,9 @@ export type SenderOrigin = {
 };
 /**
  * Clean one origin part for the `[zswarm from=…]` header: non-strings and
- * blanks become null, header-breaking characters become spaces, runs of
- * whitespace collapse, and the result is capped at 64 chars.
+ * blanks become null, header-breaking characters and whitespace runs become a
+ * single `_` (a value never holds a space, so `key=value` pairs stay
+ * splittable), and the result is capped at 64 chars.
  */
 export declare function sanitizeOriginPart(raw: unknown): string | null;
 /** The origin of the caller's own process, read from its environment. */
@@ -33,7 +34,10 @@ export declare function resolveSenderOrigin(env: NodeJS.ProcessEnv): SenderOrigi
  * client) keeps every part null but still records that serve carried it.
  */
 export declare function originFromServeRequest(raw: unknown): SenderOrigin;
-/** " @ session/pane on host via serve" (or the parts that are known). */
+/**
+ * " src=session/pane host=host via=serve" (only the parts that are known).
+ * `from=` stays the bare label, so a reader can split the header on spaces.
+ */
 export declare function originSuffix(origin: SenderOrigin | null | undefined): string;
 export type DeliveryResult = {
     to: string;

package/dist/ops/delivery.js

@@ -6,18 +6,19 @@ import { isTrue, numberArg, optionalString } from "./util.js";
 const ORIGIN_PART_MAX = 64;
 /**
  * Clean one origin part for the `[zswarm from=…]` header: non-strings and
- * blanks become null, header-breaking characters become spaces, runs of
- * whitespace collapse, and the result is capped at 64 chars.
+ * blanks become null, header-breaking characters and whitespace runs become a
+ * single `_` (a value never holds a space, so `key=value` pairs stay
+ * splittable), and the result is capped at 64 chars.
  */
 export function sanitizeOriginPart(raw) {
     if (typeof raw !== "string")
         return null;
-    const cleaned = raw.replace(/[\r\n[\]]+/g, " ").replace(/\s+/g, " ").trim();
+    const cleaned = raw.replace(/[\r\n[\]\s]+/g, " ").trim().replace(/ /g, "_");
     if (!cleaned)
         return null;
     return cleaned.length <= ORIGIN_PART_MAX
         ? cleaned
-        : cleaned.slice(0, ORIGIN_PART_MAX).trimEnd();
+        : cleaned.slice(0, ORIGIN_PART_MAX).replace(/_+$/, "");
 }
 /** The origin of the caller's own process, read from its environment. */
 export function resolveSenderOrigin(env) {
@@ -50,15 +51,18 @@ export function originFromServeRequest(raw) {
         via: "serve",
     };
 }
-/** " @ session/pane on host via serve" (or the parts that are known). */
+/**
+ * " src=session/pane host=host via=serve" (only the parts that are known).
+ * `from=` stays the bare label, so a reader can split the header on spaces.
+ */
 export function originSuffix(origin) {
     if (!origin)
         return "";
     const { session, pane, host, via } = origin;
-    const loc = session && pane ? `${session}/${pane}` : (pane ?? session ?? null);
-    return ((loc ? " @ " + loc : "") +
-        (host ? " on " + host : "") +
-        (via === "serve" ? " via serve" : ""));
+    const src = session && pane ? `${session}/${pane}` : (pane ?? session ?? null);
+    return ((src ? " src=" + src : "") +
+        (host ? " host=" + host : "") +
+        (via === "serve" ? " via=serve" : ""));
 }
 /**
  * An args-supplied origin, cleaned again (a direct caller may skip dispatch),

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/schema.js

@@ -281,7 +281,7 @@ export const PARAMS = [
         type: "string",
         flags: ["--from", "-f"],
         ops: ["send", "broadcast"],
-        description: "send: sender label in the [zswarm from=…] prefix (default: ZSWARM_FROM, else the sending pane's title, else swarm). zswarm appends the sender's session/pane, host (ZSWARM_HOST) and `via serve`",
+        description: "send: sender label in the [zswarm from=…] prefix (default: ZSWARM_FROM, else the sending pane's title, else swarm). zswarm appends src=<session>/<pane>, host=<host> (ZSWARM_HOST) and via=serve",
     },
     {
         name: "raw",

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.0",
+  "version": "0.4.2",
   "type": "module",
   "description": "zSwarm Zellij client and shared ops dispatch",
   "exports": {