@zswarm/core 0.1.5 → 0.1.7

package/dist/ops/bus.js

@@ -1,8 +1,9 @@
 import { existsSync } from "node:fs";
 import { ZellijError } from "../errors.js";
 import { loadPolicy } from "../policy.js";
-import { DEFAULT_BUS_KEY, busPluginUrl, isBusPluginPane, parseBusReply, parseChangedReply, parseScrollbackReply, parseWaitReply, resolveBusPlugin, scrollbackToScreen, } from "../zellij/bus.js";
-import { isTrue } from "./util.js";
+import { DEFAULT_BUS_KEY, DEFAULT_BUS_TIMEOUT_MS, busPluginUrl, isBusPluginPane, parseBusReply, parseChangedReply, parseScrollbackReply, parseWaitReply, resolveBusPlugin, scrollbackToScreen, } from "../zellij/bus.js";
+import { DEFAULT_TIMEOUT_MS } from "../zellij/binary.js";
+import { isTrue, throwIfAborted } from "./util.js";
 /**
  * Whether to ask the event-bus plugin, and what to do when it does not answer.
  *
@@ -18,15 +19,18 @@ const COLD_RETRY_MS = 200;
  * copies.
  */
 const INSTALL_IN_FLIGHT_MS = 10_000;
-/** Set once a pipe has failed, so one dead plugin costs one timeout, not many. */
-let processDisabled = null;
+/** Back off failed pipes briefly, isolated to their transport/session/plugin. */
+const busFailures = new Map();
 /** The key that actually answered, per session, for the life of this process. */
 const answeredWith = new Map();
 /** Tests share a module instance; this drops what a previous case cached. */
 export function resetBusCache() {
-    processDisabled = null;
+    busFailures.clear();
     answeredWith.clear();
 }
+function busScope(client, session, plan) {
+    return JSON.stringify([client.contextKey(), session, plan.url, plan.configKey]);
+}
 function affirmative(raw) {
     const v = (raw ?? "").trim().toLowerCase();
     return v === "1" || v === "true" || v === "yes" || v === "on";
@@ -61,8 +65,12 @@ export function planBus(client, state, env = process.env, session = "") {
             reason: "no plugin wasm found; run pnpm build:plugin or set ZSWARM_BUS_PLUGIN",
         };
     }
-    if (processDisabled)
-        return { ...base, reason: processDisabled };
+    const scope = busScope(client, session, base);
+    const failed = busFailures.get(scope);
+    if (failed && Date.now() < failed.until)
+        return { ...base, reason: failed.reason };
+    if (failed)
+        busFailures.delete(scope);
     if (affirmative(env.ZSWARM_BUS)) {
         return { ...base, enabled: true, reason: "ZSWARM_BUS=1" };
     }
@@ -70,8 +78,10 @@ export function planBus(client, state, env = process.env, session = "") {
         return { ...base, enabled: true, reason: "installed" };
     return { ...base, reason: 'not installed; run zswarm({op:"bus", install:true})' };
 }
-async function askOnce(client, session, url, configKey, payload) {
-    const result = await client.pipePlugin({ session, url, configKey, payload });
+async function askOnce(client, session, url, configKey, payload, timeoutMs) {
+    const result = await client.pipePlugin({
+        session, url, configKey, payload, timeoutMs,
+    });
     return parseBusReply(result.stdout);
 }
 /**
@@ -80,14 +90,25 @@ async function askOnce(client, session, url, configKey, payload) {
  * blind (ready:false, paneUpdates:0) until something moves. Renaming a pane
  * to the title it already has is an invisible change that forces the push.
  */
-async function nudgeManifest(client, session, env) {
+async function nudgeManifest(client, session, env, remaining) {
     if (loadPolicy(env).readOnly)
         return;
-    const panes = await client.listPanes(session);
+    const listBudget = Math.min(DEFAULT_TIMEOUT_MS, remaining());
+    if (listBudget <= 0)
+        return;
+    const panes = await client.listPanes(session, listBudget, { fresh: true });
     const pane = panes.find((p) => !p.isPlugin && !p.exited && p.title.trim());
     if (!pane)
         return;
-    await client.renamePane({ session, paneId: pane.id, name: pane.title });
+    const renameBudget = Math.min(DEFAULT_TIMEOUT_MS, remaining());
+    if (renameBudget <= 0)
+        return;
+    await client.renamePane({
+        session,
+        paneId: pane.id,
+        name: pane.title,
+        timeoutMs: renameBudget,
+    });
 }
 /**
  * One pipe, one answer — or null, and the caller polls instead.
@@ -99,35 +120,61 @@ async function nudgeManifest(client, session, env) {
  * --plugin` loads a new copy for each key — that is how a dead bus became
  * dozens of WASM panes. One remembered key, then polling.
  */
-export async function busSnapshot(client, state, session, clock, env = process.env, payload = "status") {
+export async function busSnapshot(client, state, session, clock, env = process.env, payload = "status", opts = {}) {
+    const remaining = () => {
+        throwIfAborted(opts.signal);
+        return opts.deadlineAt === undefined
+            ? Infinity
+            : Math.max(0, opts.deadlineAt - clock.now());
+    };
+    if (remaining() <= 0)
+        return null;
     const plan = planBus(client, state, env, session);
     const pluginPath = plan.plugin;
-    if (!plan.enabled || !plan.url || !pluginPath)
+    const url = plan.url;
+    if (!plan.enabled || !url || !pluginPath)
         return null;
-    const configKey = answeredWith.get(session) ?? plan.configKey;
-    let snapshot = await askOnce(client, session, plan.url, configKey, payload);
-    if (snapshot && !snapshot.ready) {
-        await clock.sleep(COLD_RETRY_MS);
-        snapshot =
-            (await askOnce(client, session, plan.url, configKey, payload)) ??
-                snapshot;
+    const scope = busScope(client, session, plan);
+    const configKey = answeredWith.get(scope) ?? plan.configKey;
+    const ask = async () => {
+        const budget = Math.min(DEFAULT_BUS_TIMEOUT_MS, remaining());
+        if (budget <= 0)
+            return null;
+        const snapshot = await askOnce(client, session, url, configKey, payload, budget);
+        throwIfAborted(opts.signal);
+        return snapshot;
+    };
+    let snapshot = await ask();
+    if (snapshot && !snapshot.ready && remaining() > 0) {
+        await clock.sleep(Math.min(COLD_RETRY_MS, remaining()));
+        snapshot = (await ask()) ?? snapshot;
     }
-    if (snapshot && !snapshot.ready) {
+    if (snapshot && !snapshot.ready && remaining() > 0) {
         try {
-            await nudgeManifest(client, session, env);
-            snapshot =
-                (await askOnce(client, session, plan.url, configKey, payload)) ??
-                    snapshot;
+            await nudgeManifest(client, session, env, remaining);
+            snapshot = (await ask()) ?? snapshot;
         }
         catch {
+            throwIfAborted(opts.signal);
             // A failed nudge must not fail the op — the caller polls instead.
         }
     }
+    // An expired request says nothing about bus health or an empty cold manifest.
+    if (remaining() <= 0 && !snapshot?.ready)
+        return null;
     if (snapshot) {
-        answeredWith.set(session, configKey);
+        answeredWith.set(scope, configKey);
+        if (answeredWith.size > 256)
+            answeredWith.delete(answeredWith.keys().next().value);
+        if (snapshot.ready)
+            client.observeManifest(session, JSON.stringify([
+                scope, snapshot.paneUpdates, snapshot.tabUpdates, snapshot.panes, snapshot.tabs, snapshot.tabIds,
+            ]));
         return { snapshot, configKey };
     }
-    processDisabled = "plugin did not answer; using zellij polling for this run";
+    busFailures.set(scope, { reason: "plugin did not answer; using zellij polling for 5s", until: Date.now() + 5000 });
+    if (busFailures.size > 256)
+        busFailures.delete(busFailures.keys().next().value);
     return null;
 }
 /**
@@ -141,18 +188,19 @@ export async function busSnapshot(client, state, session, clock, env = process.e
  * `dump-screen` returns them ragged. `normalizeScreen` erases exactly that
  * difference, and every caller here already normalizes before comparing.
  */
-export async function busScreens(client, state, session, paneIds, clock, env = process.env) {
+export async function busScreens(client, state, session, paneIds, clock, env = process.env, timeoutMs) {
     if (paneIds.length < 2)
         return null;
     const plan = planBus(client, state, env, session);
     if (!plan.enabled || !plan.url)
         return null;
-    const configKey = answeredWith.get(session) ?? plan.configKey;
+    const configKey = answeredWith.get(busScope(client, session, plan)) ?? plan.configKey;
     const reply = await client.scrollbackPlugin({
         session,
         url: plan.url,
         configKey,
         panes: paneIds,
+        timeoutMs,
     });
     const parsed = parseScrollbackReply(reply.stdout);
     if (!parsed || !parsed.ready)
@@ -177,7 +225,7 @@ export async function busWait(client, state, session, request, env = process.env
     const plan = planBus(client, state, env, session);
     if (!plan.enabled || !plan.url)
         return null;
-    const configKey = answeredWith.get(session) ?? plan.configKey;
+    const configKey = answeredWith.get(busScope(client, session, plan)) ?? plan.configKey;
     const reply = await client.waitPlugin({
         session,
         url: plan.url,
@@ -194,23 +242,25 @@ export async function busWait(client, state, session, request, env = process.env
  * `status` answers by sampling twice, without the gap between samples — but
  * relative to the previous call rather than a fixed window.
  */
-export async function busChanged(client, state, session, paneIds, env = process.env) {
+export async function busChanged(client, state, session, paneIds, env = process.env, timeoutMs) {
     if (paneIds.length === 0)
         return null;
     const plan = planBus(client, state, env, session);
     if (!plan.enabled || !plan.url)
         return null;
-    const configKey = answeredWith.get(session) ?? plan.configKey;
+    const configKey = answeredWith.get(busScope(client, session, plan)) ?? plan.configKey;
     const reply = await client.changedPlugin({
         session,
         url: plan.url,
         configKey,
         panes: paneIds,
+        timeoutMs,
     });
     const parsed = parseChangedReply(reply.stdout);
     if (!parsed || !parsed.ready)
         return null;
-    return parsed.panes.length === paneIds.length ? parsed : null;
+    const received = new Set([...parsed.panes.map((pane) => pane.id), ...parsed.missing]);
+    return paneIds.every((id) => received.has(id)) ? parsed : null;
 }
 function installedReply(session, plugin, configKey, ready, panes, extra = {}) {
     return {
@@ -228,7 +278,7 @@ function installedReply(session, plugin, configKey, ready, panes, extra = {}) {
     };
 }
 async function listBusPluginPanes(client, session, pluginPath) {
-    const panes = await client.listPanes(session);
+    const panes = await client.listPanes(session, undefined, { fresh: true });
     return panes.filter((pane) => isBusPluginPane(pane, pluginPath));
 }
 /** Close every zswarm-bus plugin pane in this session. Best-effort per pane. */

package/dist/ops/dispatch.d.ts

@@ -1,4 +1,10 @@
 import { type ZellijClient } from "../zellij/client.js";
 import type { DispatchDeps, OpsResult } from "./types.js";
-/** Shared MCP/CLI dispatch for zswarm ops. */
+/**
+ * Per-invocation routing from `--local` / `--ssh`. `--local` clears both SSH
+ * and serve (and remote IPC). `--ssh` sets the destination for this call and
+ * clears serve so the flag wins over a sticky ZSWARM_SERVE.
+ */
+export declare function resolveInvocationEnv(args: Record<string, unknown>, base: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** Shared MCP/CLI dispatch, with invocation routing on successes and failures. */
 export declare function dispatchZswarm(args: Record<string, unknown>, injected?: ZellijClient, deps?: DispatchDeps): Promise<OpsResult>;