tmux-ide 2.9.0-beta.19 → 2.9.0-beta.21

package/packages/daemon/src/tui/team/wait-receipts.ts

@@ -2,12 +2,11 @@
  * Receipt-driven `wait agent-status` — the push twin of the polling loop in
  * `wait.ts`.
  *
- * When a canonical daemon is running, its agent-status watcher already
- * observes every `@agent_state` transition and emits a typed
- * `agent.turn-completed` receipt on the `/ws/events` bus. Waiting on that
- * receipt replaces the CLI's local poll (which re-scrapes the whole fleet
- * every 750 ms) with a single WebSocket that sits idle until the daemon
- * pushes the completion.
+ * Daemon completion receipts and session invalidations are wake-up hints, not
+ * proof that the whole session reached a status. Re-read the same aggregate
+ * session status as the polling path: another agent may still be working or
+ * blocked. Neither transport proves success of a submitted task. Bursts of
+ * hints share one read, with a persistent classification tracker.
  *
  * Honest degrade: this path only answers for the receipt-covered targets
  * (`done` / `idle` — the "turn finished" statuses). Every other case — no
@@ -16,7 +15,7 @@
  * existing polling implementation. A timeout is a real answer, not a fallback.
  *
  * Deps are injected (daemon record reader, liveness probe, socket factory,
- * one-shot status read, clock) so the waiting logic unit-tests without a
+ * aggregate status read, clock) so the waiting logic unit-tests without a
  * daemon; the exported defaults wire the real io.
  */
 
@@ -33,7 +32,7 @@ import { findSessionStatus } from "./report.ts";
 import { listTeamSessions } from "./sessions.ts";
 import { WAIT_DEFAULT_TIMEOUT_MS, type WaitAgentStatusResult } from "./wait.ts";
 
-/** How long to give the daemon socket to open before falling back to polling. */
+/** How long to allow socket open, hello and observer-install acknowledgement before falling back to polling. */
 export const RECEIPT_CONNECT_TIMEOUT_MS = 1_500;
 
 /** The statuses a turn-completed receipt can settle; all others need the poll. */
@@ -46,6 +45,7 @@ export interface ReceiptSocket {
   on(event: "open" | "close", listener: () => void): unknown;
   on(event: "error", listener: (err: Error) => void): unknown;
   on(event: "message", listener: (data: unknown) => void): unknown;
+  send(data: string): void;
   close(): void;
 }
 
@@ -59,10 +59,10 @@ export interface WaitReceiptsOpts {
   /** Socket factory (defaults to `ws` against the daemon's `/ws/events`). */
   openSocket?: (url: string) => ReceiptSocket;
   /**
-   * One-shot status read run AFTER the socket opens, so a turn that completed
+   * Aggregate session status read after observer acknowledgement and on coalesced hints. A turn completed
    * before this process launched is answered immediately instead of waiting
    * for a receipt that already fired. Defaults to the same fleet read the
-   * polling loop uses (a single iteration, not a loop).
+   * polling loop uses, with a tracker retained for the entire wait.
    */
   currentStatus?: () => AgentStatus | null;
   now?: () => number;
@@ -89,6 +89,17 @@ export async function waitForAgentStatusViaReceipts(
 ): Promise<WaitAgentStatusResult | null> {
   if (!isReceiptCoveredStatus(want)) return null;
 
+  const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
+  const now = opts.now ?? Date.now;
+  const started = now();
+  const timedOut = (): WaitAgentStatusResult => ({
+    ok: false,
+    session,
+    want,
+    status: null,
+    timedOutAfterMs: timeoutMs,
+  });
+  const remaining = (): number => Math.max(0, timeoutMs - (now() - started));
   const readInfo = opts.readDaemonInfo ?? readCanonicalDaemonInfo;
   let info: CanonicalDaemonInfo | null;
   try {
@@ -98,9 +109,23 @@ export async function waitForAgentStatusViaReceipts(
   }
   if (!info) return null;
   const probeAlive = opts.probeAlive ?? isCanonicalDaemonAlive;
-  if (!(await probeAlive(info))) return null;
+  let probeTimer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const alive = await Promise.race([
+      probeAlive(info),
+      new Promise<null>((resolve) => {
+        probeTimer = setTimeout(() => resolve(null), remaining());
+        probeTimer.unref?.();
+      }),
+    ]);
+    if (alive === null || remaining() === 0) return timedOut();
+    if (!alive) return null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(probeTimer);
+  }
 
-  const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
   const connectTimeoutMs = opts.connectTimeoutMs ?? RECEIPT_CONNECT_TIMEOUT_MS;
   // A loopback-bound daemon admits same-machine upgrades without a token; a
   // remote-bound daemon enforces its token even locally, so present the one
@@ -113,9 +138,9 @@ export async function waitForAgentStatusViaReceipts(
         url,
         authToken ? { headers: { Authorization: `Bearer ${authToken}` } } : undefined,
       ) as unknown as ReceiptSocket);
+  const tracker = createStatusTracker();
   const currentStatus =
-    opts.currentStatus ??
-    (() => findSessionStatus(listTeamSessions(createStatusTracker()), session));
+    opts.currentStatus ?? (() => findSessionStatus(listTeamSessions(tracker), session));
 
   const url = canonicalDaemonUrl("ws", info.bindHostname, info.port, "/ws/events");
   let socket: ReceiptSocket;
@@ -127,15 +152,19 @@ export async function waitForAgentStatusViaReceipts(
 
   return new Promise<WaitAgentStatusResult | null>((resolve) => {
     let settled = false;
+    let subscribed = false;
+    let ready = false;
     let lastStatus: AgentStatus | null = null;
     let deadlineTimer: ReturnType<typeof setTimeout> | null = null;
     let connectTimer: ReturnType<typeof setTimeout> | null = null;
+    let refreshTimer: ReturnType<typeof setTimeout> | null = null;
 
     const settle = (result: WaitAgentStatusResult | null): void => {
       if (settled) return;
       settled = true;
       if (connectTimer !== null) clearTimeout(connectTimer);
       if (deadlineTimer !== null) clearTimeout(deadlineTimer);
+      if (refreshTimer !== null) clearTimeout(refreshTimer);
       try {
         socket.close();
       } catch {
@@ -144,32 +173,25 @@ export async function waitForAgentStatusViaReceipts(
       resolve(result);
     };
 
-    connectTimer = setTimeout(() => settle(null), connectTimeoutMs);
-    connectTimer.unref?.();
-
-    socket.on("error", () => settle(null));
-    socket.on("close", () => settle(null));
-
-    socket.on("open", () => {
+    const refreshStatus = (): void => {
       if (settled) return;
-      if (connectTimer !== null) clearTimeout(connectTimer);
-      deadlineTimer = setTimeout(
-        () => settle({ ok: false, session, want, status: lastStatus, timedOutAfterMs: timeoutMs }),
-        timeoutMs,
-      );
-      deadlineTimer.unref?.();
-      // The watcher baselines when the first client connects, so a receipt can
-      // only describe a transition AFTER this socket exists. Answer the
-      // already-finished case with one direct read.
       try {
         lastStatus = currentStatus();
       } catch {
-        lastStatus = null;
+        // This transport cannot establish aggregate status; use the fallback.
+        settle(null);
+        return;
       }
-      if (lastStatus === want) {
-        settle({ ok: true, session, want, status: want });
-      }
-    });
+      if (lastStatus === want) settle({ ok: true, session, want, status: want });
+    };
+
+    deadlineTimer = setTimeout(() => settle({ ...timedOut(), status: lastStatus }), remaining());
+    deadlineTimer.unref?.();
+    connectTimer = setTimeout(() => settle(null), connectTimeoutMs);
+    connectTimer.unref?.();
+
+    socket.on("error", () => settle(null));
+    socket.on("close", () => settle(null));
 
     socket.on("message", (data) => {
       if (settled) return;
@@ -180,13 +202,66 @@ export async function waitForAgentStatusViaReceipts(
         return; // not a protocol frame — ignore
       }
       const parsed = DaemonEventServerFrameSchemaZ.safeParse(raw);
-      if (!parsed.success) return;
+      if (!parsed.success) {
+        if (!ready) settle(null); // incompatible handshake/protocol
+        return;
+      }
       const frame = parsed.data;
-      if (frame.type !== "agent.turn-completed" || frame.sessionName !== session) return;
-      lastStatus = frame.toStatus;
-      if (frame.toStatus === want) {
-        settle({ ok: true, session, want, status: want });
+      if (frame.type === "protocol.error") {
+        settle(null);
+        return;
       }
+      if (frame.type === "hello") {
+        if (subscribed) return;
+        if (
+          frame.daemon.protocolVersion !== info.protocolVersion ||
+          frame.daemon.instanceId !== info.instanceId
+        ) {
+          settle(null);
+          return;
+        }
+        subscribed = true;
+        try {
+          socket.send(
+            JSON.stringify({
+              type: "subscribe",
+              sessions: [],
+              legacyEvents: true,
+              interests: [{ resource: "fleet-catalog", workspaceName: null }],
+              interestRevision: 1,
+            }),
+          );
+        } catch {
+          settle(null);
+        }
+        return;
+      }
+      if (frame.type === "resource.interests-ack") {
+        if (!subscribed || ready || frame.interestRevision !== 1) return;
+        if (frame.unavailableInterests.length > 0) {
+          settle(null);
+          return;
+        }
+        ready = true;
+        if (connectTimer !== null) clearTimeout(connectTimer);
+        // Observation is installed and baselined before this read. Hints that
+        // arrived before the barrier are covered by this current snapshot.
+        refreshStatus();
+        return;
+      }
+      if (!ready) return;
+
+      if (
+        (frame.type !== "agent.turn-completed" && frame.type !== "agent-status.changed") ||
+        frame.sessionName !== session
+      )
+        return;
+      if (refreshTimer !== null) return;
+      refreshTimer = setTimeout(() => {
+        refreshTimer = null;
+        refreshStatus();
+      }, 0);
+      refreshTimer.unref?.();
     });
   });
 }

package/packages/daemon-client/src/terminal-fast-lane.test.ts

@@ -648,6 +648,24 @@ describe("terminal fast lane", () => {
     });
   });
 
+  it("keeps equal-sized scoped targets distinct across an in-flight resize", async () => {
+    const { lane, control } = rig();
+    control.owned.add("geometry");
+    const gate = deferred<void>();
+    control.resizeGates.push(gate.promise, Promise.resolve());
+    const first = lane.resize({ semanticWindowId: "window.a", cols: 80, rows: 24 });
+    const second = lane.resize({ semanticWindowId: "window.b", cols: 80, rows: 24 });
+    gate.resolve();
+    await settle();
+    expect(await first).toEqual({ status: "applied" });
+    expect(await second).toEqual({ status: "applied" });
+    expect(control.resizes.map(({ viewport }) => viewport.semanticWindowId)).toEqual([
+      "window.a",
+      "window.b",
+    ]);
+    lane.dispose();
+  });
+
   it("preserves an exact geometry authority conflict without treating it as applied", async () => {
     const { lane, control } = rig();
     control.owned.add("geometry");

package/packages/daemon-client/src/terminal-fast-lane.ts

@@ -73,6 +73,7 @@ export interface TerminalFastLaneControlPort {
 }
 
 export interface TerminalFastLaneViewport {
+  readonly semanticWindowId?: string;
   readonly cols: number;
   readonly rows: number;
 }
@@ -225,7 +226,11 @@ function validViewport(viewport: TerminalFastLaneViewport): boolean {
     Number.isInteger(viewport.cols) &&
     Number.isInteger(viewport.rows) &&
     viewport.cols > 0 &&
-    viewport.rows > 0
+    viewport.rows > 0 &&
+    (viewport.semanticWindowId === undefined ||
+      (typeof viewport.semanticWindowId === "string" &&
+        viewport.semanticWindowId.length > 0 &&
+        viewport.semanticWindowId.length <= 256))
   );
 }
 
@@ -744,7 +749,7 @@ export function createTerminalFastLane(options: TerminalFastLaneOptions): Termin
         return Promise.resolve({ status: "failed", error: new TypeError("invalid viewport") });
       }
       const retained = Object.freeze({ ...viewport });
-      const key = `${retained.cols}x${retained.rows}`;
+      const key = JSON.stringify([retained.semanticWindowId ?? null, retained.cols, retained.rows]);
       const epoch = generationEpoch;
       mutableCounters.resizeAccepted += 1;
       return new Promise((resolve) => {

package/packages/tmux-bridge/src/index.ts

@@ -2,6 +2,8 @@ export { TmuxError } from "./errors.ts";
 export {
   runTmux,
   runTmuxBinary,
+  runTmuxBinaryAsync,
+  classifyTmuxError,
   sanitizeTmuxClientEnvironment,
   _setExecutor,
   _setSpawner,

package/packages/tmux-bridge/src/runner.test.ts

@@ -23,6 +23,7 @@ import {
   runSessionCommand,
   runTmux,
   runTmuxBinary,
+  runTmuxBinaryAsync,
 } from "./index.ts";
 
 let mockExec;
@@ -571,3 +572,43 @@ describe("error classification", () => {
     expect(result).toEqual({ running: false, reason: "SESSION_NOT_FOUND" });
   });
 });
+
+// --- Async pinned runner (real child processes; no executor mock) ---
+
+describe("runTmuxBinaryAsync", () => {
+  it("resolves stdout of a pinned executable off the event loop", async () => {
+    await expect(runTmuxBinaryAsync("/bin/sh", ["-c", "printf ok"])).resolves.toBe("ok");
+  });
+
+  it("classifies a missing target exactly like the sync runner, keeping the cause", async () => {
+    let caught;
+    try {
+      await runTmuxBinaryAsync("/bin/sh", ["-c", 'echo "can\'t find session: nope" >&2; exit 1']);
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).toBeInstanceOf(TmuxError);
+    expect(caught.code).toBe("SESSION_NOT_FOUND");
+    expect(caught.cause).toBeInstanceOf(Error);
+  });
+
+  it("classifies an unreachable server as TMUX_UNAVAILABLE", async () => {
+    let caught;
+    try {
+      await runTmuxBinaryAsync("/bin/sh", ["-c", "echo 'no server running on /x' >&2; exit 1"]);
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).toBeInstanceOf(TmuxError);
+    expect(caught.code).toBe("TMUX_UNAVAILABLE");
+  });
+
+  it("sanitizes the client environment it hands the child", async () => {
+    const output = await runTmuxBinaryAsync(
+      "/bin/sh",
+      ["-c", 'printf "%s|%s" "$COLORTERM" "$NO_COLOR"'],
+      { env: { PATH: "/usr/bin:/bin", NO_COLOR: "1" } },
+    );
+    expect(output).toBe("truecolor|");
+  });
+});

package/packages/tmux-bridge/src/runner.ts

@@ -1,4 +1,10 @@
-import { execFileSync, spawn, type ExecFileSyncOptions } from "node:child_process";
+import {
+  execFile,
+  execFileSync,
+  spawn,
+  type ExecFileOptions,
+  type ExecFileSyncOptions,
+} from "node:child_process";
 import { TmuxError } from "./errors.ts";
 
 const DEBUG = process.env.TMUX_IDE_DEBUG === "1";
@@ -99,7 +105,40 @@ export function runTmuxBinary(
   }
 }
 
-function classifyTmuxError(error: unknown): TmuxError {
+/**
+ * Async twin of {@link runTmuxBinary}: the same pinned-executable contract and
+ * the same `TmuxError` classification, but the child runs off the event loop so
+ * a daemon mutation path never stalls other connected clients while tmux
+ * answers. The classified error keeps the raw execFile error as `cause`.
+ */
+export function runTmuxBinaryAsync(
+  executable: string,
+  args: string[],
+  options: ExecFileOptions & { readonly signal?: AbortSignal } = {},
+): Promise<string> {
+  if (DEBUG || globalThis.__tmuxIdeVerbose) {
+    console.error(`  [tmux] ${args.join(" ")}`);
+  }
+  return new Promise<string>((resolve, reject) => {
+    execFile(
+      executable,
+      args,
+      {
+        windowsHide: true,
+        ...options,
+        encoding: "utf8",
+        env: sanitizeTmuxClientEnvironment(options.env ?? process.env),
+      },
+      (error, stdout) => {
+        if (error) reject(classifyTmuxError(error));
+        else resolve(stdout);
+      },
+    );
+  });
+}
+
+/** Map a raw child-process failure to the shared `TmuxError` code taxonomy. */
+export function classifyTmuxError(error: unknown): TmuxError {
   const detail = getErrorDetail(error).toLowerCase();
 
   if (SESSION_NOT_FOUND_PATTERNS.some((pattern) => detail.includes(pattern))) {