tmux-ide 2.9.2 → 2.9.4

package/packages/daemon/src/tui/mirror/workspace/__snapshots__/workbench-shell-renderer.test.tsx.snap

@@ -1,134 +0,0 @@
-// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
-
-exports[`WorkbenchShell OpenTUI renderer renders the %sx%s compact agent canvas and bottom dock 1`] = `
-"▌● Agent canvas                                               compact · 3 agents
- › Fable · project manager                                               working
- ○ Codex implementer 1 · terminal %7                                  task M31.3
- ○ Codex implementer 2 · ready                                           gpt-5.5
-
-
-
-
-
-
-
-
-
-
-  ▤ Files   ± Changes  ●◆ Missions  !◷ Activity                           ▾   □
-│● missions dock                                        open · preferred 10 rows
- ○ Full application parity                                          7 / 20 cards
- ● Workbench dock projection                                         in progress
-
-
-
-
-
-"
-`;
-
-exports[`WorkbenchShell OpenTUI renderer renders the %sx%s standard agent canvas and bottom dock 1`] = `
-"▌● Agent canvas                                                                                      standard · 3 agents
- › Fable · project manager                                                                                       working
- ○ Codex implementer 1 · terminal %7                                                                          task M31.3
- ○ Codex implementer 2 · ready                                                                                   gpt-5.5
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-   tools   ▤ Files   ± Changes  ●◆ Missions  !◷ Activity                                                ▾ close   □ max
-│● missions dock                                                                                open · preferred 14 rows
- ○ Full application parity                                                                                  7 / 20 cards
- ● Workbench dock projection                                                                                 in progress
-
-
-
-
-
-
-
-
-
-"
-`;
-
-exports[`WorkbenchShell OpenTUI renderer renders the %sx%s wide agent canvas and bottom dock 1`] = `
-"▌● Agent canvas                                                                                                                                                                          wide · 3 agents
- › Fable · project manager                                                                                                                                                                       working
- ○ Codex implementer 1 · terminal %7                                                                                                                                                          task M31.3
- ○ Codex implementer 2 · ready                                                                                                                                                                   gpt-5.5
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-   tools  F3  ▤ Files  F4  ± Changes  F6 ●◆ Missions  F9 !◷ Activity                                                                                                                    ▾ close   □ max
-│● missions dock                                                                                                                                                                open · preferred 20 rows
- ○ Full application parity                                                                                                                                                                  7 / 20 cards
- ● Workbench dock projection                                                                                                                                                                 in progress
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-"
-`;

package/packages/daemon-client/src/application-shell-session.test.ts

@@ -1,196 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  ApplicationShellProjectionInputV3SchemaZ,
-  COHESION_FIXTURE_V1,
-  DAEMON_WIRE_PROTOCOL_VERSION,
-  DesktopApplicationShellTargetSchemaZ,
-  type ApplicationShellProjectionInputV1,
-  type DesktopApplicationShellTarget,
-} from "@tmux-ide/contracts";
-
-import {
-  createApplicationShellSession,
-  type ApplicationShellEventHandlers,
-  type ApplicationShellTransport,
-} from "./application-shell-session.ts";
-
-const daemon = {
-  protocolVersion: DAEMON_WIRE_PROTOCOL_VERSION,
-  productVersion: "2.8.0",
-  instanceId: "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-  startedAt: "2026-08-09T12:00:00.000Z",
-};
-
-function target(workspaceName: string): DesktopApplicationShellTarget {
-  return { daemon, workspaceName };
-}
-
-function resource(name: string): ApplicationShellProjectionInputV1 {
-  return ApplicationShellProjectionInputV3SchemaZ.parse({
-    project: { ...COHESION_FIXTURE_V1.project, name },
-    workspace: {
-      ...COHESION_FIXTURE_V1.workspace,
-      sidebar: {
-        ...COHESION_FIXTURE_V1.workspace.sidebar,
-        agents: COHESION_FIXTURE_V1.workspace.sidebar.agents.map((agent) => ({
-          ...agent,
-          paneId: null,
-        })),
-      },
-    },
-    dock: COHESION_FIXTURE_V1.dock,
-    focus: { ...COHESION_FIXTURE_V1.focus, overlays: [] },
-    connection: COHESION_FIXTURE_V1.connection,
-    terminalInventory: { activeResourceId: null, resources: [] },
-    appWindows: {
-      version: 1,
-      revision: 0,
-      updatedAt: "2026-08-09T12:00:00.000Z",
-      windows: {},
-      dockRoot: null,
-      dockState: { mode: "collapsed", preferredHeight: null, focusZone: "canvas" },
-      floatingOrder: [],
-      focusedWindowId: null,
-      activeLayoutId: null,
-      layouts: {},
-    },
-  });
-}
-
-async function settle(): Promise<void> {
-  await Promise.resolve();
-  await Promise.resolve();
-}
-
-function deferred<T>() {
-  let resolve!: (value: T) => void;
-  const promise = new Promise<T>((resolvePromise) => {
-    resolve = resolvePromise;
-  });
-  return { promise, resolve };
-}
-
-interface ConnectionRecord {
-  readonly target: DesktopApplicationShellTarget;
-  readonly handlers: ApplicationShellEventHandlers;
-  closed: boolean;
-}
-
-function broker(initial: Readonly<Record<string, ApplicationShellProjectionInputV1>>) {
-  const resources = new Map(Object.entries(initial));
-  const fetches: string[] = [];
-  const connections: ConnectionRecord[] = [];
-  const transport: ApplicationShellTransport = {
-    validateTarget: (value) => DesktopApplicationShellTargetSchemaZ.parse(value),
-    fetchApplicationShell: async (applicationTarget) => {
-      fetches.push(applicationTarget.workspaceName);
-      const snapshot = resources.get(applicationTarget.workspaceName);
-      if (!snapshot) throw new Error(`missing ${applicationTarget.workspaceName}`);
-      return snapshot;
-    },
-    connectEvents: (applicationTarget, handlers) => {
-      const connection = { target: applicationTarget, handlers, closed: false };
-      connections.push(connection);
-      return { close: () => (connection.closed = true) };
-    },
-  };
-  return { resources, fetches, connections, transport };
-}
-
-describe("shared application-shell session", () => {
-  it("keeps multiple clients isolated while converging invalidated authority", async () => {
-    const runtime = broker({ alpha: resource("alpha-1"), beta: resource("beta-1") });
-    const alphaReceipts: string[] = [];
-    const betaReceipts: string[] = [];
-    const alpha = createApplicationShellSession({
-      target: target("alpha"),
-      transport: runtime.transport,
-      onOperationAcknowledged: (receipt) => alphaReceipts.push(receipt.operationId),
-    });
-    const beta = createApplicationShellSession({
-      target: target("beta"),
-      transport: runtime.transport,
-      onOperationAcknowledged: (receipt) => betaReceipts.push(receipt.operationId),
-    });
-    runtime.connections[0]!.handlers.onVerifiedOpen();
-    runtime.connections[1]!.handlers.onVerifiedOpen();
-    await settle();
-
-    expect(alpha.getState()).toMatchObject({
-      status: "live",
-      data: { project: { name: "alpha-1" } },
-    });
-    expect(beta.getState()).toMatchObject({
-      status: "live",
-      data: { project: { name: "beta-1" } },
-    });
-
-    runtime.resources.set("alpha", resource("alpha-2"));
-    runtime.connections[0]!.handlers.onInvalidate();
-    runtime.connections[0]!.handlers.onOperationAcknowledged?.({
-      daemonInstanceId: daemon.instanceId,
-      operationId: "op-alpha",
-      sequence: 7,
-      revision: 3,
-    });
-    await settle();
-    await settle();
-
-    expect(alpha.getState()).toMatchObject({ data: { project: { name: "alpha-2" } } });
-    expect(beta.getState()).toMatchObject({ data: { project: { name: "beta-1" } } });
-    expect(runtime.fetches).toEqual(["alpha", "beta", "alpha"]);
-    expect(alphaReceipts).toEqual(["op-alpha"]);
-    expect(betaReceipts).toEqual([]);
-    expect(alpha.getMetrics()).toMatchObject({
-      idleWakeups: 0,
-      activeInterests: 1,
-      fetchesStarted: 2,
-      fetchesSettled: 2,
-      invalidationsObserved: 1,
-      subscriptionsOpened: 1,
-    });
-    alpha.dispose();
-    beta.dispose();
-  });
-
-  it("retires the old request and event connection across target generations", async () => {
-    const requests: Array<ReturnType<typeof deferred<ApplicationShellProjectionInputV1>>> = [];
-    const signals: AbortSignal[] = [];
-    const connections: ConnectionRecord[] = [];
-    const transport: ApplicationShellTransport = {
-      validateTarget: (value) => DesktopApplicationShellTargetSchemaZ.parse(value),
-      fetchApplicationShell: (_applicationTarget, signal) => {
-        const request = deferred<ApplicationShellProjectionInputV1>();
-        requests.push(request);
-        signals.push(signal);
-        return request.promise;
-      },
-      connectEvents: (applicationTarget, handlers) => {
-        const connection = { target: applicationTarget, handlers, closed: false };
-        connections.push(connection);
-        return { close: () => (connection.closed = true) };
-      },
-    };
-    const session = createApplicationShellSession({ target: target("alpha"), transport });
-    const firstGeneration = session.getState().generation;
-
-    session.setTarget(target("beta"));
-    expect(signals[0]?.aborted).toBe(true);
-    expect(connections[0]?.closed).toBe(true);
-    requests[0]!.resolve(resource("stale-alpha"));
-    connections[0]!.handlers.onVerifiedOpen();
-    connections[0]!.handlers.onInvalidate();
-    requests[1]!.resolve(resource("current-beta"));
-    connections[1]!.handlers.onVerifiedOpen();
-    await settle();
-
-    expect(session.getState()).toMatchObject({
-      status: "live",
-      generation: firstGeneration + 1,
-      target: { workspaceName: "beta" },
-      data: { project: { name: "current-beta" } },
-    });
-    session.dispose();
-    expect(connections[1]?.closed).toBe(true);
-  });
-});

package/packages/daemon-client/src/automation-client.test.ts

@@ -1,214 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { AutomationOperationIntent } from "@tmux-ide/contracts";
-import { createAutomationClient, AutomationInvocationError } from "./automation-client.ts";
-
-const id = "00000000-0000-4000-8000-000000000001";
-const other = "00000000-0000-4000-8000-000000000002";
-const handle = { generation: id, operationId: other };
-const intent: AutomationOperationIntent = {
-  kind: "send",
-  source: null,
-  text: "private input",
-  enter: true,
-  target: {
-    kind: "pane",
-    environmentId: id,
-    paneLifetimeId: id,
-    serverScope: { serverId: `tmux-server.${"a".repeat(32)}`, generation: id },
-    workspaceName: "workspace.project",
-    semanticPaneId: "pane.editor",
-  },
-};
-const sent = { version: 1, handle, result: { kind: "send", submitted: true } };
-function client(fetcher: typeof fetch) {
-  return createAutomationClient({
-    baseUrl: "http://localhost/",
-    ownerToken: "owner",
-    sourceCredential: "source",
-    fetch: fetcher,
-  });
-}
-
-describe("shared automation transport", () => {
-  it("uses the declared adapter origin for both reservation and execution", async () => {
-    const bodies: Record<string, unknown>[] = [];
-    const api = createAutomationClient({
-      baseUrl: "http://localhost",
-      ownerToken: "owner",
-      origin: "mcp",
-      fetch: (async (url, init) => {
-        bodies.push(JSON.parse(String(init?.body)));
-        return Response.json(String(url).endsWith("/reserve") ? { version: 1, handle } : sent);
-      }) as typeof fetch,
-    });
-    await api.reserve(intent);
-    await api.execute(handle, intent);
-    expect(bodies.map((body) => body.origin)).toEqual(["mcp", "mcp"]);
-  });
-  it("retries uncertain execution with the exact handle/body and never reserves", async () => {
-    const requests: { path: string; init?: RequestInit }[] = [];
-    const api = client((async (input, init) => {
-      requests.push({ path: String(input), init });
-      if (requests.length === 1) throw new Error("lost response after effect");
-      return Response.json(sent);
-    }) as typeof fetch);
-    expect(await api.execute(handle, intent)).toEqual(sent);
-    expect(requests).toHaveLength(2);
-    expect(requests[0]!.init?.body).toBe(requests[1]!.init?.body);
-    expect(
-      requests.every(({ path }) => path === "http://localhost/api/v1/automation/execute"),
-    ).toBe(true);
-    expect(requests[0]!.init?.redirect).toBe("error");
-    expect(requests[0]!.init?.headers).toEqual({
-      Authorization: "Bearer owner",
-      "Content-Type": "application/json",
-      "X-Tmux-Ide-Pane-Source-Credential": "source",
-    });
-  });
-
-  it("treats a daemon refusal as terminal", async () => {
-    let calls = 0;
-    const api = client((async () => {
-      calls++;
-      return Response.json({ error: { code: "operation-unavailable" } }, { status: 409 });
-    }) as typeof fetch);
-    await expect(api.execute(handle, intent)).rejects.toMatchObject({
-      code: "operation-unavailable",
-      handle,
-    });
-    expect(calls).toBe(1);
-  });
-
-  it("returns uncertain execution with its original handle and no private input", async () => {
-    let calls = 0;
-    const api = client((async () => {
-      calls++;
-      throw Error("private input");
-    }) as typeof fetch);
-    const error = await api.execute(handle, intent).catch((reason: unknown) => reason);
-    expect(error).toBeInstanceOf(AutomationInvocationError);
-    expect(error).toMatchObject({ code: "response-unconfirmed", handle });
-    expect(String(error)).not.toContain(intent.text);
-    expect(calls).toBe(2);
-  });
-
-  it("does not replay a lost reservation automatically", async () => {
-    let calls = 0;
-    const api = client((async () => {
-      calls++;
-      throw Error("lost");
-    }) as typeof fetch);
-    await expect(api.reserve(intent)).rejects.toMatchObject({
-      code: "response-unconfirmed",
-      handle: null,
-    });
-    expect(calls).toBe(1);
-  });
-
-  it("rejects response identity substitution", async () => {
-    const api = client((async () =>
-      Response.json({ ...sent, handle: { ...handle, generation: other } })) as typeof fetch);
-    await expect(api.execute(handle, intent)).rejects.toMatchObject({
-      code: "response-unconfirmed",
-    });
-  });
-
-  it("rejects content in status and byte-count mismatches in snapshots", async () => {
-    const api = client((async () =>
-      Response.json({
-        version: 1,
-        handle,
-        status: "completed",
-        result: { kind: "send", submitted: true, text: "private" },
-      })) as typeof fetch);
-    await expect(api.status(handle)).rejects.toMatchObject({ code: "response-unconfirmed" });
-    const badRead = client((async () =>
-      Response.json({
-        version: 1,
-        handle,
-        result: { kind: "read", capturedBytes: 1, returnedBytes: 1, truncated: false },
-        read: { availability: "available", text: "not one byte" },
-      })) as typeof fetch);
-    await expect(
-      badRead.execute(handle, { kind: "read", target: intent.target, source: null }),
-    ).rejects.toMatchObject({ code: "response-unconfirmed" });
-  });
-
-  it("validates before transport and snapshots mutable request values", async () => {
-    const bodies: unknown[] = [];
-    const mutable = { ...intent };
-    const api = client((async (_input, init) => {
-      bodies.push(JSON.parse(String(init?.body)));
-      return Response.json(sent);
-    }) as typeof fetch);
-    const pending = api.execute(handle, mutable);
-    mutable.text = "changed";
-    await pending;
-    expect((bodies[0] as { intent: { text: string } }).intent.text).toBe("private input");
-    await expect(api.execute({ ...handle, operationId: "invalid" }, intent)).rejects.toThrow();
-    expect(bodies).toHaveLength(1);
-  });
-});
-
-describe("automation cancellation", () => {
-  it("prevents dispatch when already cancelled", async () => {
-    let calls = 0;
-    const controller = new AbortController();
-    controller.abort();
-    const api = client((async () => {
-      calls++;
-      return Response.json(sent);
-    }) as typeof fetch);
-    await expect(api.execute(handle, intent, { signal: controller.signal })).rejects.toMatchObject({
-      code: "request-cancelled",
-      handle,
-    });
-    expect(calls).toBe(0);
-  });
-  it("keeps the original handle and never retries cancellation after dispatch", async () => {
-    let calls = 0;
-    const controller = new AbortController();
-    const api = client((async (_input, init) => {
-      calls++;
-      controller.abort();
-      init?.signal?.throwIfAborted();
-      return Response.json(sent);
-    }) as typeof fetch);
-    await expect(api.execute(handle, intent, { signal: controller.signal })).rejects.toMatchObject({
-      code: "response-unconfirmed",
-      handle,
-    });
-    expect(calls).toBe(1);
-  });
-  it("cancels a stalled response body without retaining or exposing received chunks", async () => {
-    const controller = new AbortController();
-    let cancelCount = 0;
-    let connected!: () => void;
-    const ready = new Promise<void>((resolve) => {
-      connected = resolve;
-    });
-    let calls = 0;
-    const api = client((async () => {
-      calls++;
-      return new Response(
-        new ReadableStream({
-          start(stream) {
-            stream.enqueue(new TextEncoder().encode("private partial content"));
-            connected();
-          },
-          cancel() {
-            cancelCount++;
-          },
-        }),
-      );
-    }) as typeof fetch);
-    const execution = api.execute(handle, intent, { signal: controller.signal });
-    await ready;
-    controller.abort();
-    const error = await execution.catch((reason: unknown) => reason);
-    expect(error).toMatchObject({ code: "response-unconfirmed", handle });
-    expect(String(error)).not.toContain("private partial content");
-    expect(calls).toBe(1);
-    expect(cancelCount).toBe(1);
-  });
-});

package/packages/daemon-client/src/bootstrap-coordinator.test.ts

@@ -1,145 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { DaemonBootstrapCoordinator, type DaemonBootstrapPhase } from "./bootstrap-coordinator.ts";
-
-interface Candidate {
-  readonly generation: string;
-}
-
-describe("DaemonBootstrapCoordinator", () => {
-  it("returns an already compatible generation without spawning", async () => {
-    const candidate = { generation: "existing" };
-    let starts = 0;
-    const phases: DaemonBootstrapPhase[] = [];
-    const coordinator = new DaemonBootstrapCoordinator<Candidate>({
-      probe: () => ({ status: "compatible", candidate }),
-      spawn: () => {
-        starts += 1;
-      },
-      onPhaseChanged: ({ phase }) => phases.push(phase),
-    });
-    const result = await coordinator.ensure();
-    expect(result).toMatchObject({ candidate, source: "existing" });
-    expect(result.timings.controlReadyAt).not.toBeNull();
-    expect(starts).toBe(0);
-    expect(phases).toEqual(["probing", "control-ready", "ready"]);
-  });
-
-  it("single-flights concurrent starters through control and empty inventory", async () => {
-    let candidate: Candidate | null = null;
-    let starts = 0;
-    let release!: () => void;
-    const barrier = new Promise<void>((resolve) => {
-      release = resolve;
-    });
-    const phases: DaemonBootstrapPhase[] = [];
-    const coordinator = new DaemonBootstrapCoordinator<Candidate, string[]>({
-      probe: () =>
-        candidate ? { status: "compatible", candidate } : { status: "absent-or-stale" },
-      spawn: async () => {
-        starts += 1;
-        await barrier;
-        candidate = { generation: "winner" };
-      },
-      reconcileInventory: () => ({ status: "empty", inventory: [] }),
-      onPhaseChanged: ({ phase }) => phases.push(phase),
-    });
-    const first = coordinator.ensure();
-    const second = coordinator.ensure();
-    expect(first).toBe(second);
-    release();
-    await expect(first).resolves.toMatchObject({ source: "started", inventory: [] });
-    expect(starts).toBe(1);
-    expect(phases).toEqual([
-      "probing",
-      "spawning",
-      "control-ready",
-      "inventory-reconciling",
-      "ready",
-    ]);
-  });
-
-  it("preserves an incompatible probe reason without spawning", async () => {
-    let starts = 0;
-    const coordinator = new DaemonBootstrapCoordinator<Candidate, never, "protocol-mismatch">({
-      probe: () => ({ status: "incompatible", reason: "protocol-mismatch" }),
-      spawn: () => {
-        starts += 1;
-      },
-    });
-    await expect(coordinator.ensure()).rejects.toMatchObject({
-      code: "incompatible",
-      reason: "protocol-mismatch",
-    });
-    expect(starts).toBe(0);
-    expect(coordinator.snapshot()).toMatchObject({
-      phase: "incompatible",
-      reason: "protocol-mismatch",
-    });
-  });
-
-  it("waits on a living published generation without spawning a contender", async () => {
-    const candidate = { generation: "elected" };
-    let probes = 0;
-    let starts = 0;
-    const coordinator = new DaemonBootstrapCoordinator<Candidate>({
-      probe: () =>
-        ++probes === 1
-          ? { status: "control-pending", candidate }
-          : { status: "compatible", candidate },
-      spawn: () => {
-        starts += 1;
-      },
-      sleep: async () => undefined,
-    });
-    await expect(coordinator.ensure()).resolves.toMatchObject({
-      source: "existing",
-      candidate,
-    });
-    expect(starts).toBe(0);
-  });
-
-  it("times out deterministically and permits a later retry", async () => {
-    let clock = 0;
-    let starts = 0;
-    const coordinator = new DaemonBootstrapCoordinator<Candidate>({
-      probe: () => ({ status: "absent-or-stale" }),
-      spawn: () => {
-        starts += 1;
-      },
-      timeoutMs: 3,
-      pollMs: () => 1,
-      now: () => clock,
-      sleep: async (milliseconds) => {
-        clock += milliseconds;
-      },
-    });
-    await expect(coordinator.ensure()).rejects.toMatchObject({ code: "control-timeout" });
-    await expect(coordinator.ensure()).rejects.toMatchObject({ code: "control-timeout" });
-    expect(starts).toBe(2);
-    expect(coordinator.snapshot()).toMatchObject({ phase: "failed", attempt: 2 });
-  });
-});
-
-it("waits for an externally owned startup without inventing a candidate or spawning", async () => {
-  let now = 0;
-  let spawns = 0;
-  const coordinator = new DaemonBootstrapCoordinator<Candidate, never, string>({
-    probe: () =>
-      now >= 25
-        ? { status: "compatible", candidate: { generation: "supervised" } }
-        : { status: "owner-pending" },
-    spawn: () => {
-      spawns++;
-    },
-    now: () => now,
-    sleep: async (ms) => {
-      now += ms;
-    },
-    timeoutMs: 100,
-  });
-  const result = await coordinator.ensure();
-  expect(result.candidate.generation).toBe("supervised");
-  expect(result.source).toBe("existing");
-  expect(spawns).toBe(0);
-});