@zswarm/core 0.1.2 → 0.1.4

package/dist/exec.d.ts

@@ -7,6 +7,8 @@ export type ExecResult = {
 export type ExecOptions = {
     timeoutMs: number;
     cwd?: string;
+    /** Overlay on the runner's env (e.g. GIT_INDEX_FILE for a scratch index). */
+    env?: NodeJS.ProcessEnv;
     /**
      * Stop as soon as the accumulated stdout satisfies this, instead of waiting
      * for the process to exit. `zellij pipe` answers in milliseconds but stays

package/dist/exec.js

@@ -70,10 +70,12 @@ export function createSshExec(target, env) {
         if (requested.toLowerCase() !== "auto") {
             return { tmp: requested, socketDir: "" };
         }
-        if (cached !== undefined)
-            return cached ?? undefined;
-        cached = (await discoverRemoteIpc(runner, target, timeoutMs)) ?? null;
-        return cached ?? undefined;
+        if (cached)
+            return cached;
+        const dirs = await discoverRemoteIpc(runner, target, timeoutMs);
+        if (dirs)
+            cached = dirs;
+        return dirs;
     }
     return async (args, options) => {
         const ipc = await resolveIpc(options.timeoutMs);
@@ -85,7 +87,7 @@ export function createSshExec(target, env) {
 function runUntil(binPath, args, env, options) {
     return new Promise((resolve) => {
         const child = spawn(binPath, args, {
-            env,
+            env: options.env ? { ...env, ...options.env } : env,
             cwd: options.cwd,
             windowsHide: true,
             stdio: ["ignore", "pipe", "pipe"],
@@ -136,7 +138,7 @@ function runToExit(binPath, args, env, options) {
             cwd: options.cwd,
             maxBuffer: 8 * 1024 * 1024,
             windowsHide: true,
-            env,
+            env: options.env ? { ...env, ...options.env } : env,
         }, (error, stdout, stderr) => {
             const failure = error;
             if (failure && typeof failure.code === "string") {

package/dist/git.js

@@ -1,4 +1,6 @@
-import { basename, dirname, join } from "node:path";
+import { copyFileSync, rmSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { basename, dirname, isAbsolute, join } from "node:path";
 import { ZellijError } from "./errors.js";
 import { createExec, NOT_FOUND_EXIT } from "./exec.js";
 const DEFAULT_TIMEOUT_MS = 20_000;
@@ -77,8 +79,8 @@ export function createGitClient(options = {}) {
     const gitPath = options.gitPath ?? env.ZSWARM_GIT_BIN?.trim() ?? "git";
     const exec = options.exec ?? createExec(gitPath, env);
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    async function run(args, cwd, label) {
-        const result = await exec(args, { timeoutMs, cwd });
+    async function run(args, cwd, label, extraEnv) {
+        const result = await exec(args, { timeoutMs, cwd, env: extraEnv });
         if (result.code === NOT_FOUND_EXIT) {
             throw new ZellijError("git_missing", `git not found (${gitPath}); install git or set ZSWARM_GIT_BIN`);
         }
@@ -136,32 +138,54 @@ export function createGitClient(options = {}) {
         return result.stdout.trim().length > 0;
     }
     /**
-     * Stage untracked paths as intent-to-add so they appear in `git diff`
-     * (without copying blob contents into the object database).
+     * Stage untracked paths as intent-to-add in a scratch index so they appear
+     * in `git diff` without mutating the real `.git/index`.
      */
-    async function intentAddUntracked(path) {
-        await run(["add", "-A", "--intent-to-add"], path, "git add --intent-to-add");
+    async function withScratchIndex(path, fn) {
+        const located = await run(["rev-parse", "--git-path", "index"], path, "git rev-parse --git-path index");
+        const indexRel = located.stdout.trim();
+        const indexAbs = isAbsolute(indexRel) ? indexRel : join(path, indexRel);
+        const scratch = `${indexAbs}.zswarm-${process.pid}-${randomBytes(4).toString("hex")}`;
+        try {
+            copyFileSync(indexAbs, scratch);
+        }
+        catch {
+            // No index yet (empty repo / new worktree).
+        }
+        try {
+            return await fn({ GIT_INDEX_FILE: scratch });
+        }
+        finally {
+            rmSync(scratch, { force: true });
+        }
     }
-    /** `git diff --stat HEAD`, including untracked via `--intent-to-add`. */
+    async function intentAddUntracked(path, indexEnv) {
+        await run(["add", "-A", "--intent-to-add"], path, "git add --intent-to-add", indexEnv);
+    }
+    /** `git diff --stat HEAD`, including untracked via a scratch intent-to-add. */
     async function diffStat(path) {
-        await intentAddUntracked(path);
-        const result = await run(["diff", "--stat", "HEAD"], path, "git diff --stat");
-        return result.stdout;
+        return withScratchIndex(path, async (indexEnv) => {
+            await intentAddUntracked(path, indexEnv);
+            const result = await run(["diff", "--stat", "HEAD"], path, "git diff --stat", indexEnv);
+            return result.stdout;
+        });
     }
     /**
-     * `git diff HEAD`, including untracked via `--intent-to-add`.
+     * `git diff HEAD`, including untracked via a scratch intent-to-add.
      * When `maxChars > 0` and the patch is longer, keep the head and set
      * `truncated`. `chars` is always the full patch length before truncating.
      */
     async function diffPatch(path, maxChars) {
-        await intentAddUntracked(path);
-        const result = await run(["diff", "HEAD"], path, "git diff");
-        const full = result.stdout;
-        const chars = full.length;
-        if (maxChars <= 0 || chars <= maxChars) {
-            return { patch: full, truncated: false, chars };
-        }
-        return { patch: full.slice(0, maxChars), truncated: true, chars };
+        return withScratchIndex(path, async (indexEnv) => {
+            await intentAddUntracked(path, indexEnv);
+            const result = await run(["diff", "HEAD"], path, "git diff", indexEnv);
+            const full = result.stdout;
+            const chars = full.length;
+            if (maxChars <= 0 || chars <= maxChars) {
+                return { patch: full, truncated: false, chars };
+            }
+            return { patch: full.slice(0, maxChars), truncated: true, chars };
+        });
     }
     /** `git add -A` then `git commit -m`; returns the new short HEAD sha. */
     async function commitAll(path, message) {

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, type Policy,
 export { buildSshRemoteCommand, createSshExec, quoteRemoteArg, shellQuote, type SshTarget, } from "./exec.js";
 export { resolveSshTarget } from "./zellij/binary.js";
 export { applyIpcTmpEnv, cmdQuote, concreteTmp, encodePowerShellCommand, inferRemoteShell, parseZellijServerPaths, pickIpcDirs, pickIpcTmp, socketDirFromServerPath, tmpFromServerPath, unixDiscoverRemote, windowsDiscoverRemote, windowsInteractiveRemote, wrapWithTmpEnv, } from "./zellij/ipc.js";
-export { callServe, DEFAULT_SERVE_LISTEN, installServeLogon, parseListenAddress, SERVE_TASK_NAME, serveCallTimeout, serveChildEnv, serveLogonCommand, startServe, uninstallServeLogon, } from "./ops/serve.js";
+export { callServe, DEFAULT_SERVE_LISTEN, installServeLogon, isLoopbackHost, parseListenAddress, SERVE_CALL_TIMEOUT_CAP_MS, SERVE_MAX_REQUEST_BYTES, SERVE_TASK_NAME, serveCallTimeout, serveChildEnv, serveLogonCommand, startServe, uninstallServeLogon, } from "./ops/serve.js";
 export { parseTabList, resolveTab, type ZellijTab } from "./zellij/tabs.js";
 export { selectTargets } from "./ops/broadcast.js";
 export { diffScreens, cursorKey } from "./ops/tail.js";

package/dist/index.js

@@ -14,7 +14,7 @@ export { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, } from "./po
 export { buildSshRemoteCommand, createSshExec, quoteRemoteArg, shellQuote, } from "./exec.js";
 export { resolveSshTarget } from "./zellij/binary.js";
 export { applyIpcTmpEnv, cmdQuote, concreteTmp, encodePowerShellCommand, inferRemoteShell, parseZellijServerPaths, pickIpcDirs, pickIpcTmp, socketDirFromServerPath, tmpFromServerPath, unixDiscoverRemote, windowsDiscoverRemote, windowsInteractiveRemote, wrapWithTmpEnv, } from "./zellij/ipc.js";
-export { callServe, DEFAULT_SERVE_LISTEN, installServeLogon, parseListenAddress, SERVE_TASK_NAME, serveCallTimeout, serveChildEnv, serveLogonCommand, startServe, uninstallServeLogon, } from "./ops/serve.js";
+export { callServe, DEFAULT_SERVE_LISTEN, installServeLogon, isLoopbackHost, parseListenAddress, SERVE_CALL_TIMEOUT_CAP_MS, SERVE_MAX_REQUEST_BYTES, SERVE_TASK_NAME, serveCallTimeout, serveChildEnv, serveLogonCommand, startServe, uninstallServeLogon, } from "./ops/serve.js";
 export { parseTabList, resolveTab } from "./zellij/tabs.js";
 export { selectTargets } from "./ops/broadcast.js";
 export { diffScreens, cursorKey } from "./ops/tail.js";

package/dist/ops/broadcast.d.ts

@@ -16,4 +16,4 @@ export declare function selectTargets(client: ZellijClient, panes: ZellijPane[],
     skipped: Skipped[];
 };
 /** Send one body to many panes, reporting per-pane outcomes. */
-export declare function broadcast(client: ZellijClient, state: StateStore, args: Record<string, unknown>, clock: Clock, policy?: Policy): Promise<OpsResult>;
+export declare function broadcast(client: ZellijClient, state: StateStore, args: Record<string, unknown>, clock: Clock, policy?: Policy, env?: NodeJS.ProcessEnv): Promise<OpsResult>;

package/dist/ops/broadcast.js

@@ -1,6 +1,6 @@
 import { ZellijError } from "../errors.js";
 import { assertPaneAllowed } from "../policy.js";
-import { deliverTo } from "./delivery.js";
+import { deliverTo, selfPaneTitle, withSenderLabel } from "./delivery.js";
 import { isTrue, optionalString } from "./util.js";
 /**
  * Pick the panes a broadcast should reach: an explicit comma list, a tab, or
@@ -65,13 +65,17 @@ export function selectTargets(client, panes, args) {
     return { targets, skipped };
 }
 /** Send one body to many panes, reporting per-pane outcomes. */
-export async function broadcast(client, state, args, clock, policy) {
+export async function broadcast(client, state, args, clock, policy, env = process.env) {
     const body = String(args.body ?? args.text ?? "");
     if (!body.trim())
         throw new ZellijError("missing_body", "body required");
     const { session } = await client.resolveSession(typeof args.session === "string" ? args.session : undefined);
     const panes = await client.listPanes(session);
-    const { targets: selected, skipped } = selectTargets(client, panes, args);
+    const labeled = withSenderLabel(args, {
+        env,
+        selfTitle: selfPaneTitle(client, panes),
+    });
+    const { targets: selected, skipped } = selectTargets(client, panes, labeled);
     // Policy narrows the selection rather than failing the whole broadcast.
     const targets = selected.filter((pane) => {
         if (!policy)
@@ -90,7 +94,7 @@ export async function broadcast(client, state, args, clock, policy) {
     }
     const results = [];
     for (const pane of targets) {
-        results.push(await deliverTo(client, state, args, {
+        results.push(await deliverTo(client, state, labeled, {
             session,
             pane,
             body,
@@ -104,7 +108,7 @@ export async function broadcast(client, state, args, clock, policy) {
         ok: true,
         data: {
             session,
-            from: (typeof args.from === "string" && args.from.trim()) || "swarm",
+            from: labeled.from,
             delivered: delivered.map((r) => r.to),
             failed: results.filter((r) => !r.ok),
             skipped,

package/dist/ops/delivery.d.ts

@@ -14,7 +14,37 @@ export type DeliveryResult = {
     };
 };
 export type SubmitMode = "auto" | "double-enter" | "none";
-export declare function senderLabel(args: Record<string, unknown>): string;
+export type SenderSource = "arg" | "env" | "title" | "default";
+export type SenderLabel = {
+    label: string;
+    source: SenderSource;
+};
+/** Drop characters that would break `[zswarm from=…]` or wrap the prefix. */
+export declare function sanitizeSenderLabel(raw: string): string;
+export declare function selfPaneTitle(client: Pick<ZellijClient, "selfPaneId">, panes: ZellijPane[]): string | null;
+/**
+ * Label for `[zswarm from=…]`. Explicit `from` wins, then `ZSWARM_FROM`,
+ * then the sending pane's title when we know that pane, else `swarm`.
+ */
+export declare function resolveSender(args: Record<string, unknown>, opts?: {
+    env?: NodeJS.ProcessEnv;
+    selfTitle?: string | null;
+}): SenderLabel;
+export declare function senderLabel(args: Record<string, unknown>, opts?: {
+    env?: NodeJS.ProcessEnv;
+    selfTitle?: string | null;
+}): string;
+/** Stamp `from` so deliverTo and the op result use the same resolved label. */
+export declare function withSenderLabel(args: Record<string, unknown>, opts?: {
+    env?: NodeJS.ProcessEnv;
+    selfTitle?: string | null;
+}): Record<string, unknown>;
+/**
+ * Before forwarding over `ZSWARM_SERVE`, keep a caller-chosen label and
+ * leave `from` unset when it would default, so the Zellij-side process can
+ * still fill in its own pane title.
+ */
+export declare function attachKnownSender(args: Record<string, unknown>, env: NodeJS.ProcessEnv): Record<string, unknown>;
 export declare function bodyText(client: ZellijClient, args: Record<string, unknown>, body: string): string;
 /**
  * Caller `submit=` always wins. With none given, the pane's harness picks

package/dist/ops/delivery.js

@@ -2,8 +2,62 @@ import { resolveHarness } from "../harness.js";
 import { isTrue, numberArg } from "./util.js";
 /** Cursor / Claude leave this in scrollback after a successful submit. */
 const PASTE_MARKER = "[Pasted text";
-export function senderLabel(args) {
-    return (typeof args.from === "string" && args.from.trim()) || "swarm";
+const SENDER_LABEL_MAX = 48;
+/** Drop characters that would break `[zswarm from=…]` or wrap the prefix. */
+export function sanitizeSenderLabel(raw) {
+    const cleaned = raw.replace(/[\r\n[\]]+/g, " ").replace(/\s+/g, " ").trim();
+    if (!cleaned)
+        return "";
+    return cleaned.length <= SENDER_LABEL_MAX
+        ? cleaned
+        : cleaned.slice(0, SENDER_LABEL_MAX).trimEnd();
+}
+export function selfPaneTitle(client, panes) {
+    const id = client.selfPaneId;
+    if (!id)
+        return null;
+    const title = panes.find((p) => p.id === id)?.title;
+    return title?.trim() ? title : null;
+}
+/**
+ * Label for `[zswarm from=…]`. Explicit `from` wins, then `ZSWARM_FROM`,
+ * then the sending pane's title when we know that pane, else `swarm`.
+ */
+export function resolveSender(args, opts = {}) {
+    if (typeof args.from === "string") {
+        const explicit = sanitizeSenderLabel(args.from);
+        if (explicit)
+            return { label: explicit, source: "arg" };
+    }
+    const envFrom = sanitizeSenderLabel(opts.env?.ZSWARM_FROM ?? "");
+    if (envFrom)
+        return { label: envFrom, source: "env" };
+    const title = sanitizeSenderLabel(opts.selfTitle ?? "");
+    if (title)
+        return { label: title, source: "title" };
+    return { label: "swarm", source: "default" };
+}
+export function senderLabel(args, opts = {}) {
+    return resolveSender(args, opts).label;
+}
+/** Stamp `from` so deliverTo and the op result use the same resolved label. */
+export function withSenderLabel(args, opts = {}) {
+    return { ...args, from: senderLabel(args, opts) };
+}
+/**
+ * Before forwarding over `ZSWARM_SERVE`, keep a caller-chosen label and
+ * leave `from` unset when it would default, so the Zellij-side process can
+ * still fill in its own pane title.
+ */
+export function attachKnownSender(args, env) {
+    const op = String(args.op ?? "");
+    if (op !== "send" && op !== "broadcast")
+        return args;
+    const sender = resolveSender(args, { env });
+    if (sender.source === "arg" || sender.source === "env") {
+        return { ...args, from: sender.label };
+    }
+    return args;
 }
 export function bodyText(client, args, body) {
     return isTrue(args.raw) ? body : client.formatPeerMessage(senderLabel(args), body);

package/dist/ops/dispatch.js

@@ -9,7 +9,7 @@ import { broadcast } from "./broadcast.js";
 import { busChanged, busOp, busScreens, busSnapshot, busWait } from "./bus.js";
 import { dumpLayoutOp, focusTarget, listTabsOp, renameTarget, stackTargets, } from "./panes.js";
 import { peerCheckpoint, peerDiff } from "./review.js";
-import { deliverTo } from "./delivery.js";
+import { attachKnownSender, deliverTo, withSenderLabel, selfPaneTitle } from "./delivery.js";
 import { assertNotPlugin, assertNotSelf, assertPaneExpects, assertWritable, } from "./guards.js";
 import { readDeliveryLog } from "./log.js";
 import { awaitSignal, listSignals, postSignal } from "./signals.js";
@@ -17,7 +17,7 @@ import { spawnPane } from "./spawn.js";
 import { peerStatus } from "./status.js";
 import { tailPane } from "./tail.js";
 import { OP_NAMES } from "../schema.js";
-import { dumpMaxChars, fail, isTrue, isVerbose, paneViewBus, paneViewFull, paneViewSlim, truncateDumpText, } from "./util.js";
+import { dumpMaxChars, fail, isTrue, isVerbose, optionalString, paneViewBus, paneViewFull, paneViewSlim, truncateDumpText, } from "./util.js";
 import { waitForPane } from "./wait.js";
 import { listPeerWorktrees, removePeerWorktree } from "./worktree.js";
 import { callServe, installServeLogon, serveCallTimeout, uninstallServeLogon, } from "./serve.js";
@@ -29,6 +29,30 @@ function waitMode(args) {
     }
     return typeof args.match === "string" && args.match ? "match" : "idle";
 }
+const SSH_GIT_OPS = new Set([
+    "worktrees",
+    "unworktree",
+    "diff",
+    "checkpoint",
+]);
+const SSH_LOCAL_BARRIER_OPS = new Set(["signal", "signals", "await"]);
+/**
+ * SSH only forwards Zellij. Git worktrees, diffs, and checkpoints stay on this
+ * machine, so mixing them with a remote pane cwd is how you delete the wrong tree.
+ * Client-local signal barriers cannot rendezvous with a remote crew either.
+ */
+function assertSshGitAllowed(env, op, args) {
+    if (!env.ZSWARM_SSH?.trim() || env.ZSWARM_SERVE?.trim())
+        return;
+    const worktreeSpawn = op === "spawn" && optionalString(args.worktree);
+    if (!worktreeSpawn && !SSH_GIT_OPS.has(op) && !SSH_LOCAL_BARRIER_OPS.has(op)) {
+        return;
+    }
+    const why = SSH_LOCAL_BARRIER_OPS.has(op)
+        ? "is a client-local barrier"
+        : "uses local git";
+    throw new ZellijError("ssh_git_unsupported", `${op} ${why}; ZSWARM_SSH only forwards Zellij. Run zswarm serve on the host that owns the session`);
+}
 async function resolveTarget(client, args, state, clock, env, policy, op) {
     const to = String(args.to ?? "").trim();
     if (!to)
@@ -76,6 +100,7 @@ export async function dispatchZswarm(args, injected, deps = {}) {
     try {
         // Policy gates the op before anything touches the session.
         assertOpAllowed(policy, op);
+        assertSshGitAllowed(env, op, args);
         if (op === "serve") {
             if (isTrue(args.clear)) {
                 const cleared = await uninstallServeLogon({
@@ -94,7 +119,7 @@ export async function dispatchZswarm(args, injected, deps = {}) {
         // An injected client is a unit-test (or in-process) Zellij; do not skip it
         // just because the host env has ZSWARM_SERVE set.
         if (!injected && env.ZSWARM_SERVE?.trim()) {
-            return await callServe(env.ZSWARM_SERVE.trim(), args, serveCallTimeout(args));
+            return await callServe(env.ZSWARM_SERVE.trim(), attachKnownSender(args, env), serveCallTimeout(args), env.ZSWARM_SERVE_TOKEN);
         }
         const client = injected ?? createZellijClient({ env: deps.env });
         switch (op) {
@@ -127,7 +152,7 @@ export async function dispatchZswarm(args, injected, deps = {}) {
                 const body = String(args.body ?? args.text ?? "");
                 if (!body.trim())
                     throw new ZellijError("missing_body", "body required");
-                const { session, pane } = await resolveTarget(client, args, state(), clock, deps.env, policy, op);
+                const { session, pane, panes } = await resolveTarget(client, args, state(), clock, deps.env, policy, op);
                 assertWritable(client, pane, args, "send");
                 // A pane that dropped back to a shell will *run* the message. There is
                 // no reliable way to tell an agent from a prompt, so the caller names
@@ -137,7 +162,11 @@ export async function dispatchZswarm(args, injected, deps = {}) {
                     const screen = await client.dumpPane({ session, paneId: pane.id });
                     assertPaneExpects(screen.text, expect, pane.id);
                 }
-                const result = await deliverTo(client, state(), args, {
+                const labeled = withSenderLabel(args, {
+                    env,
+                    selfTitle: selfPaneTitle(client, panes),
+                });
+                const result = await deliverTo(client, state(), labeled, {
                     session,
                     pane,
                     body,
@@ -152,7 +181,7 @@ export async function dispatchZswarm(args, injected, deps = {}) {
                     delivery: result.delivery,
                     session,
                     to: result.to,
-                    from: (typeof args.from === "string" && args.from.trim()) || "swarm",
+                    from: labeled.from,
                     submitted: result.submitted,
                 };
                 if (verbose)
@@ -160,7 +189,7 @@ export async function dispatchZswarm(args, injected, deps = {}) {
                 return { ok: true, data };
             }
             case "broadcast":
-                return await broadcast(client, state(), args, clock, policy);
+                return await broadcast(client, state(), args, clock, policy, env);
             case "keys":
             case "interrupt": {
                 const { session, pane } = await resolveTarget(client, args, state(), clock, deps.env, policy, op);
@@ -307,15 +336,15 @@ export async function dispatchZswarm(args, injected, deps = {}) {
             case "log":
                 return readDeliveryLog(state(), args);
             case "rename":
-                return await renameTarget(client, args);
+                return await renameTarget(client, args, policy);
             case "focus":
-                return await focusTarget(client, args);
+                return await focusTarget(client, args, policy);
             case "tabs":
                 return await listTabsOp(client, args);
             case "layout":
                 return await dumpLayoutOp(client, args);
             case "stack":
-                return await stackTargets(client, args);
+                return await stackTargets(client, args, policy);
             case "diff":
                 return await peerDiff(git(), args);
             case "checkpoint":

package/dist/ops/panes.d.ts

@@ -1,13 +1,14 @@
+import { type Policy } from "../policy.js";
 import type { ZellijClient } from "../zellij/client.js";
 import type { OpsResult } from "./types.js";
 /**
  * Give a pane (or its tab) a stable name, so peers can be addressed as
  * `reviewer` instead of whatever id Zellij handed out.
  */
-export declare function renameTarget(client: ZellijClient, args: Record<string, unknown>): Promise<OpsResult>;
-export declare function focusTarget(client: ZellijClient, args: Record<string, unknown>): Promise<OpsResult>;
+export declare function renameTarget(client: ZellijClient, args: Record<string, unknown>, policy?: Policy): Promise<OpsResult>;
+export declare function focusTarget(client: ZellijClient, args: Record<string, unknown>, policy?: Policy): Promise<OpsResult>;
 export declare function listTabsOp(client: ZellijClient, args: Record<string, unknown>): Promise<OpsResult>;
 /** The session's current layout as KDL — a spawnable description of the crew. */
 export declare function dumpLayoutOp(client: ZellijClient, args: Record<string, unknown>): Promise<OpsResult>;
 /** Collapse several peers into one stack so a big crew stays readable. */
-export declare function stackTargets(client: ZellijClient, args: Record<string, unknown>): Promise<OpsResult>;
+export declare function stackTargets(client: ZellijClient, args: Record<string, unknown>, policy?: Policy): Promise<OpsResult>;

package/dist/ops/panes.js

@@ -1,4 +1,5 @@
 import { ZellijError } from "../errors.js";
+import { assertPaneAllowed } from "../policy.js";
 import { dumpMaxChars, optionalString, truncateDumpText } from "./util.js";
 async function session(client, args) {
     const resolved = await client.resolveSession(typeof args.session === "string" ? args.session : undefined);
@@ -8,7 +9,7 @@ async function session(client, args) {
  * Give a pane (or its tab) a stable name, so peers can be addressed as
  * `reviewer` instead of whatever id Zellij handed out.
  */
-export async function renameTarget(client, args) {
+export async function renameTarget(client, args, policy) {
     const name = optionalString(args.name);
     if (!name)
         throw new ZellijError("missing_name", "name required");
@@ -30,18 +31,22 @@ export async function renameTarget(client, args) {
     if (!to)
         throw new ZellijError("missing_peer", "to (or tab) required");
     const pane = client.resolvePane(await client.listPanes(sess), to);
+    if (policy)
+        assertPaneAllowed(policy, pane, "rename");
     await client.renamePane({ session: sess, paneId: pane.id, name });
     return {
         ok: true,
         data: { session: sess, to: pane.id, was: pane.title, name },
     };
 }
-export async function focusTarget(client, args) {
+export async function focusTarget(client, args, policy) {
     const to = optionalString(args.to);
     if (!to)
         throw new ZellijError("missing_peer", "to required");
     const sess = await session(client, args);
     const pane = client.resolvePane(await client.listPanes(sess), to);
+    if (policy)
+        assertPaneAllowed(policy, pane, "focus");
     // Zellij exits non-zero when asked to focus the already-focused pane.
     if (pane.focused) {
         return {
@@ -94,7 +99,7 @@ export async function dumpLayoutOp(client, args) {
     };
 }
 /** Collapse several peers into one stack so a big crew stays readable. */
-export async function stackTargets(client, args) {
+export async function stackTargets(client, args, policy) {
     const list = optionalString(args.to);
     if (!list)
         throw new ZellijError("missing_peer", "to (comma list) required");
@@ -104,7 +109,12 @@ export async function stackTargets(client, args) {
         .split(",")
         .map((k) => k.trim())
         .filter(Boolean)
-        .map((key) => client.resolvePane(panes, key).id);
+        .map((key) => {
+        const pane = client.resolvePane(panes, key);
+        if (policy)
+            assertPaneAllowed(policy, pane, "stack");
+        return pane.id;
+    });
     const unique = [...new Set(ids)];
     const stacked = await client.stackPanes({ session: sess, paneIds: unique });
     return { ok: true, data: { session: sess, stacked: stacked.paneIds } };

package/dist/ops/serve.d.ts

@@ -1,17 +1,33 @@
 import type { OpsResult } from "./types.js";
 export declare const DEFAULT_SERVE_LISTEN = "127.0.0.1:9419";
 export declare const SERVE_TASK_NAME = "zswarm-serve";
+/** One JSONL request; a client that never sends newline cannot grow forever. */
+export declare const SERVE_MAX_REQUEST_BYTES: number;
+/** Drop a socket that never finishes a JSONL line. */
+export declare const SERVE_IDLE_TIMEOUT_MS = 30000;
+/** Concurrent TCP clients, including in-flight wait ops. */
+export declare const SERVE_MAX_CONNECTIONS = 32;
+/** Wait/await allow 15 minutes; this is that plus slack. */
+export declare const SERVE_CALL_TIMEOUT_CAP_MS: number;
+export declare function isLoopbackHost(host: string): boolean;
+export declare function formatListenLabel(host: string, port: number): string;
 export declare function parseListenAddress(raw: string | undefined): {
     host: string;
     port: number;
     label: string;
 };
-/** Client-side wait: the op's own timeout plus slack, capped at ten minutes. */
+/** Client-side wait: the op's own timeout plus slack. */
 export declare function serveCallTimeout(args: Record<string, unknown>): number;
 /** Env for a serve worker: talk to the local Zellij, never loop back into serve/ssh. */
 export declare function serveChildEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export type ServeDispatch = (args: Record<string, unknown>) => Promise<OpsResult>;
-export declare function startServe(listen: string | undefined, dispatch: ServeDispatch): Promise<{
+export type StartServeOptions = {
+    token?: string;
+    maxRequestBytes?: number;
+    idleTimeoutMs?: number;
+    maxConnections?: number;
+};
+export declare function startServe(listen: string | undefined, dispatch: ServeDispatch, options?: StartServeOptions): Promise<{
     label: string;
     close: () => Promise<void>;
 }>;
@@ -19,13 +35,15 @@ export declare function parseServeTarget(raw: string): {
     host: string;
     port: number;
 };
-export declare function callServe(target: string, args: Record<string, unknown>, timeoutMs?: number): Promise<OpsResult>;
-export declare function serveLogonCommand(execPath: string, scriptPath: string, listen: string): string;
+export declare function callServe(target: string, args: Record<string, unknown>, timeoutMs?: number, token?: string): Promise<OpsResult>;
+export declare function serveLogonCommand(execPath: string, scriptPath: string, listen: string, token?: string): string;
 export declare function installServeLogon(input: {
     listen?: string;
     execPath?: string;
     scriptPath?: string;
     platform?: NodeJS.Platform;
+    token?: string;
+    env?: NodeJS.ProcessEnv;
 }): Promise<{
     task: string;
     listen: string;