tmux-ide 2.9.2 → 2.9.3

package/packages/contracts/src/__tests__/automation-operations.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  AutomationExecuteRequestSchemaZ,
-  AutomationOperationStatusSchemaZ,
-  AutomationReserveRequestSchemaZ,
-} from "../automation-operations.ts";
-
-const id = "00000000-0000-4000-8000-000000000001";
-const target = {
-  kind: "pane",
-  environmentId: id,
-  serverScope: { serverId: `tmux-server.${"a".repeat(32)}`, generation: id },
-  paneLifetimeId: id,
-  workspaceName: "workspace.project",
-  semanticPaneId: "pane.editor",
-};
-const request = {
-  version: 1,
-  intent: { kind: "send", target, source: null, text: "hello", enter: true },
-};
-
-describe("automation boundary", () => {
-  it("requires resolved lifetime and explicit source absence", () => {
-    expect(AutomationReserveRequestSchemaZ.safeParse(request).success).toBe(true);
-    for (const changed of [
-      { ...request.intent, target: { ...target, paneLifetimeId: undefined } },
-      { ...request.intent, source: undefined },
-      { ...request.intent, target: { ...target, runtimePaneId: "%0" } },
-      { ...request.intent, origin: "tui" },
-      { ...request.intent, credential: "secret" },
-    ])
-      expect(
-        AutomationReserveRequestSchemaZ.safeParse({ ...request, intent: changed }).success,
-      ).toBe(false);
-  });
-
-  it("bounds UTF-8 bytes and excludes NUL rather than counting only JS characters", () => {
-    const parse = (text: string) =>
-      AutomationReserveRequestSchemaZ.safeParse({ ...request, intent: { ...request.intent, text } })
-        .success;
-    expect(parse("a".repeat(16384))).toBe(true);
-    expect(parse("a".repeat(16385))).toBe(false);
-    expect(parse("🙂".repeat(4096))).toBe(true);
-    expect(parse("🙂".repeat(4097))).toBe(false);
-    expect(parse("a\0b")).toBe(false);
-  });
-
-  it("requires a generation-fenced execution handle", () => {
-    expect(AutomationExecuteRequestSchemaZ.safeParse(request).success).toBe(false);
-    expect(
-      AutomationExecuteRequestSchemaZ.safeParse({
-        ...request,
-        handle: { generation: id, operationId: id },
-      }).success,
-    ).toBe(true);
-    expect(
-      AutomationExecuteRequestSchemaZ.safeParse({ ...request, handle: { operationId: id } })
-        .success,
-    ).toBe(false);
-  });
-
-  it("never admits sent or captured content to operation status", () => {
-    expect(
-      AutomationOperationStatusSchemaZ.safeParse({
-        status: "completed",
-        result: { kind: "read", capturedBytes: 12, returnedBytes: 12, truncated: false },
-      }).success,
-    ).toBe(true);
-    for (const key of ["text", "content", "snapshot", "credential"]) {
-      expect(
-        AutomationOperationStatusSchemaZ.safeParse({
-          status: "completed",
-          result: { kind: "send", submitted: true, [key]: "private" },
-        }).success,
-      ).toBe(false);
-    }
-  });
-});

package/packages/contracts/src/__tests__/causal-cell.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CausalCellProbeV1SchemaZ } from "../causal-cell.ts";
-import { TerminalReplicaCellSchemaZ } from "../terminal-replica.ts";
-
-const cell = TerminalReplicaCellSchemaZ.parse({
-  grapheme: " ",
-  width: 1,
-  foreground: { kind: "default" },
-  background: { kind: "default" },
-  attributes: 0,
-});
-
-function probe() {
-  return {
-    version: 1,
-    capability: "causal-cell-v1",
-    traceId: "00000000-0000-4000-8000-000000000099",
-    clientId: "client:test",
-    transportNonce: "00000000-0000-4000-8000-000000000010",
-    deliveryNonce: "00000000-0000-4000-8000-000000000011",
-    inputSequence: 1,
-    semanticPaneId: "pane.alpha",
-    generation: "11111111-1111-4111-8111-111111111111",
-    incarnation: "one",
-    baselineRevision: 7,
-    baselineStateHash: "0000000000000000",
-    geometry: { cols: 2, rows: 1, row: 0, column: 1 },
-    before: cell,
-    after: { ...cell, grapheme: "X" },
-  };
-}
-
-describe("causal-cell-v1 contracts", () => {
-  it("accepts an exact width-1 probe", () => {
-    expect(CausalCellProbeV1SchemaZ.safeParse(probe()).success).toBe(true);
-  });
-
-  it.each([0, 2])("rejects non-canonical width %s before/after cells", (width) => {
-    expect(
-      CausalCellProbeV1SchemaZ.safeParse({ ...probe(), before: { ...cell, width } }).success,
-    ).toBe(false);
-    expect(
-      CausalCellProbeV1SchemaZ.safeParse({ ...probe(), after: { ...cell, grapheme: "X", width } })
-        .success,
-    ).toBe(false);
-  });
-});

package/packages/contracts/src/__tests__/client-view-state.test.ts

@@ -1,115 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { AppWindowDocumentV1SchemaZ } from "../app-window-state.ts";
-import {
-  ClientViewStateV1SchemaZ,
-  createClientViewStateV1,
-  reconcileClientViewStateV1,
-} from "../client-view-state.ts";
-
-const shared = AppWindowDocumentV1SchemaZ.parse({
-  version: 1,
-  revision: 4,
-  updatedAt: "2026-08-07T08:00:00.000Z",
-  windows: {
-    "window.one": {
-      id: "window.one",
-      source: { kind: "terminal", terminalSourceId: "pane.one" },
-      title: "One",
-      placement: { mode: "docked", docked: { stackId: "stack.main", index: 0 }, floating: null },
-    },
-    "window.two": {
-      id: "window.two",
-      source: { kind: "terminal", terminalSourceId: "pane.two" },
-      title: "Two",
-      placement: { mode: "docked", docked: { stackId: "stack.main", index: 1 }, floating: null },
-    },
-  },
-  dockRoot: {
-    type: "stack",
-    id: "stack.main",
-    windowIds: ["window.one", "window.two"],
-    activeWindowId: "window.one",
-  },
-  dockState: { mode: "open", preferredHeight: 320, focusZone: "canvas" },
-  floatingOrder: [],
-  focusedWindowId: "window.one",
-  activeLayoutId: null,
-  layouts: {},
-});
-
-describe("ClientViewStateV1", () => {
-  it("lets two views retain different presentation over one shared layout", () => {
-    const first = ClientViewStateV1SchemaZ.parse({
-      ...createClientViewStateV1({
-        clientId: "client.browser",
-        viewId: "view.first",
-        workspaceId: "workspace.shared",
-        legacyDocument: shared,
-      }),
-      focusedWindowId: "window.one",
-      selectedWindowIds: ["window.one"],
-      activeWindowIdsByStack: { "stack.main": "window.one" },
-      dock: {
-        mode: "open",
-        preferredHeight: 320,
-        focusZone: "dock-body",
-        activeTabId: "changes",
-      },
-      viewport: { x: -100, y: 20, scale: 1.25 },
-    });
-    const second = ClientViewStateV1SchemaZ.parse({
-      ...first,
-      viewId: "view.second",
-      focusedWindowId: "window.two",
-      selectedWindowIds: ["window.two"],
-      activeWindowIdsByStack: { "stack.main": "window.two" },
-      dock: {
-        mode: "collapsed",
-        preferredHeight: 180,
-        focusZone: "canvas",
-        activeTabId: "activity",
-      },
-      viewport: { x: 40, y: -60, scale: 0.8 },
-    });
-
-    expect(first.focusedWindowId).toBe("window.one");
-    expect(second.focusedWindowId).toBe("window.two");
-    expect(first.dock).not.toEqual(second.dock);
-    expect(first.viewport).not.toEqual(second.viewport);
-    expect(shared.focusedWindowId).toBe("window.one");
-    expect(shared.dockRoot?.type === "stack" && shared.dockRoot.activeWindowId).toBe("window.one");
-  });
-
-  it("drops stale shared-layout references while retaining local presentation", () => {
-    const state = ClientViewStateV1SchemaZ.parse({
-      ...createClientViewStateV1({
-        clientId: "client.browser",
-        viewId: "view.first",
-        workspaceId: "workspace.shared",
-        legacyDocument: shared,
-      }),
-      focusedWindowId: "window.two",
-      selectedWindowIds: ["window.two"],
-      activeWindowIdsByStack: { "stack.main": "window.two" },
-      viewport: { x: 10, y: 20, scale: 1.5 },
-    });
-    const oneOnly = AppWindowDocumentV1SchemaZ.parse({
-      ...shared,
-      windows: { "window.one": shared.windows["window.one"] },
-      dockRoot: {
-        type: "stack",
-        id: "stack.main",
-        windowIds: ["window.one"],
-        activeWindowId: "window.one",
-      },
-    });
-
-    const reconciled = reconcileClientViewStateV1(state, oneOnly);
-
-    expect(reconciled.focusedWindowId).toBeNull();
-    expect(reconciled.selectedWindowIds).toEqual([]);
-    expect(reconciled.activeWindowIdsByStack).toEqual({});
-    expect(reconciled.viewport).toEqual({ x: 10, y: 20, scale: 1.5 });
-  });
-});

package/packages/contracts/src/__tests__/cohesion-fixture.test.ts

@@ -1,106 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { COHESION_FIXTURE_V1, CohesionFixtureV1SchemaZ } from "../cohesion-fixture.ts";
-import { resolvePaneAppearance } from "../pane-appearance.ts";
-import { resolveSemanticInputLayer } from "../focus-overlay.ts";
-import { resolveVisualTheme } from "../visual-tokens.ts";
-
-describe("CohesionFixtureV1", () => {
-  it("round-trips as strict serialized cross-host acceptance input", () => {
-    expect(CohesionFixtureV1SchemaZ.parse(JSON.parse(JSON.stringify(COHESION_FIXTURE_V1)))).toEqual(
-      COHESION_FIXTURE_V1,
-    );
-  });
-
-  it("exercises every dock tool and orthogonal composed pane states", () => {
-    expect(COHESION_FIXTURE_V1.dock.tools.map(({ id }) => id)).toEqual([
-      "files",
-      "changes",
-      "missions",
-      "activity",
-    ]);
-    const appearances = COHESION_FIXTURE_V1.panes.map(({ state }) => resolvePaneAppearance(state));
-    expect(appearances).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          border: expect.objectContaining({ role: "focused" }),
-          status: expect.objectContaining({ attentionTone: "info" }),
-        }),
-        expect.objectContaining({
-          outerOutline: expect.objectContaining({ role: "selected" }),
-        }),
-        expect.objectContaining({
-          status: expect.objectContaining({ domainStatus: "recovering", tone: "danger" }),
-          action: expect.objectContaining({ disabled: true, loading: true }),
-        }),
-      ]),
-    );
-    expect(resolveSemanticInputLayer(COHESION_FIXTURE_V1.focus)).toEqual({
-      kind: "command-palette",
-      overlayId: "overlay.palette",
-    });
-    expect(
-      resolveVisualTheme({
-        userTheme: COHESION_FIXTURE_V1.theme.user,
-        projectTheme: COHESION_FIXTURE_V1.theme.project ?? undefined,
-        accessibility: COHESION_FIXTURE_V1.theme.accessibility,
-      }).appearance,
-    ).toBe("dark");
-  });
-
-  it("rejects broken cross-field identity and state ownership", () => {
-    const copy = JSON.parse(JSON.stringify(COHESION_FIXTURE_V1)) as Record<string, unknown>;
-    const focus = copy.focus as Record<string, unknown>;
-    focus.appFocusedPaneId = "pane.unknown";
-    expect(CohesionFixtureV1SchemaZ.safeParse(copy).success).toBe(false);
-  });
-
-  it("contains no renderer geometry or live transport handles", () => {
-    const forbiddenKeys = new Set([
-      "x",
-      "y",
-      "width",
-      "height",
-      "rect",
-      "bounds",
-      "tmuxPaneId",
-      "ptyId",
-      "xtermId",
-      "electronWindowId",
-      "nativeHandle",
-    ]);
-    const forbiddenUnits = new Set(["px", "rem", "em", "cell", "row", "column"]);
-    const findings: string[] = [];
-    const walk = (value: unknown, path = "fixture"): void => {
-      if (Array.isArray(value))
-        return value.forEach((child, index) => walk(child, `${path}.${index}`));
-      if (!value || typeof value !== "object") return;
-      for (const [key, child] of Object.entries(value)) {
-        if (forbiddenKeys.has(key)) findings.push(`${path}.${key}`);
-        if (key === "unit" && typeof child === "string" && forbiddenUnits.has(child)) {
-          findings.push(`${path}.${key}:${child}`);
-        }
-        walk(child, `${path}.${key}`);
-      }
-    };
-    walk(COHESION_FIXTURE_V1);
-    expect(findings).toEqual([]);
-  });
-
-  it("is deeply frozen so adapters cannot decorate shared input with host measurements", () => {
-    const mutableObjects: string[] = [];
-    const walk = (value: unknown, path = "fixture"): void => {
-      if (!value || typeof value !== "object") return;
-      if (!Object.isFrozen(value)) mutableObjects.push(path);
-      if (Array.isArray(value)) {
-        value.forEach((child, index) => walk(child, `${path}.${index}`));
-        return;
-      }
-      for (const [key, child] of Object.entries(value)) walk(child, `${path}.${key}`);
-    };
-
-    walk(COHESION_FIXTURE_V1);
-    expect(mutableObjects).toEqual([]);
-    expect(Reflect.set(COHESION_FIXTURE_V1.project, "name", "host-decorated")).toBe(false);
-    expect(COHESION_FIXTURE_V1.project.name).toBe("tmux-ide");
-  });
-});

package/packages/contracts/src/__tests__/commands.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  APPLICATION_SHELL_COMMAND_IDS,
-  COMMAND_PROTOCOL_VERSION,
-  CommandAvailabilitySchemaZ,
-  CommandDescriptorSchemaZ,
-  CommandInvocationSchemaZ,
-  WORKSPACE_WINDOW_MODE_COMMAND_IDS,
-  type CommandDescriptor,
-  type CommandInvocation,
-} from "../commands.ts";
-
-const descriptor: CommandDescriptor = {
-  version: COMMAND_PROTOCOL_VERSION,
-  id: "workspace.view.activate",
-  owner: "renderer",
-  label: "Activate view",
-  category: "workspace",
-  schemas: { input: "workspace.view.activate.input.v1" },
-  dangerous: false,
-  confirmation: "none",
-};
-
-const invocation: CommandInvocation = {
-  version: COMMAND_PROTOCOL_VERSION,
-  id: descriptor.id,
-  source: { kind: "keyboard", surface: "workbench" },
-  args: { viewId: "terminals", nested: { selected: true }, rows: [1, 2] },
-};
-
-describe("command protocol", () => {
-  it("round-trips serializable descriptors and invocations", () => {
-    expect(CommandDescriptorSchemaZ.parse(JSON.parse(JSON.stringify(descriptor)))).toEqual(
-      descriptor,
-    );
-    expect(CommandInvocationSchemaZ.parse(JSON.parse(JSON.stringify(invocation)))).toEqual(
-      invocation,
-    );
-  });
-
-  it("rejects non-namespaced ids and non-JSON arguments", () => {
-    expect(CommandDescriptorSchemaZ.safeParse({ ...descriptor, id: "quit" }).success).toBe(false);
-    expect(
-      CommandInvocationSchemaZ.safeParse({
-        ...invocation,
-        args: { callback: () => undefined },
-      }).success,
-    ).toBe(false);
-    expect(
-      CommandInvocationSchemaZ.safeParse({
-        ...invocation,
-        args: { count: Number.NaN },
-      }).success,
-    ).toBe(false);
-  });
-
-  it("keeps availability outcomes serializable and explicit", () => {
-    expect(CommandAvailabilitySchemaZ.parse({ available: true })).toEqual({ available: true });
-    expect(
-      CommandAvailabilitySchemaZ.parse({ available: false, reason: "no active view" }),
-    ).toEqual({ available: false, reason: "no active view" });
-  });
-
-  it("reserves valid window-mode ids without registering behavior", () => {
-    expect(WORKSPACE_WINDOW_MODE_COMMAND_IDS).toEqual([
-      "workspace.windowMode.enter",
-      "workspace.windowMode.exit",
-      "workspace.windowMode.cancel",
-      "workspace.windowMode.focus",
-      "workspace.windowMode.move",
-      "workspace.windowMode.resize",
-      "workspace.windowMode.float.toggle",
-      "workspace.windowMode.maximize.toggle",
-      "workspace.windowMode.close",
-    ]);
-    for (const id of WORKSPACE_WINDOW_MODE_COMMAND_IDS) {
-      expect(CommandDescriptorSchemaZ.safeParse({ ...descriptor, id }).success).toBe(true);
-    }
-  });
-
-  it("keeps application-shell ids immutable and isolated from live renderer ids", () => {
-    expect(Object.isFrozen(APPLICATION_SHELL_COMMAND_IDS)).toBe(true);
-    expect(Object.values(APPLICATION_SHELL_COMMAND_IDS)).not.toContain("app.palette.open");
-    expect(Object.values(APPLICATION_SHELL_COMMAND_IDS)).not.toContain("workspace.dock.activate");
-  });
-});

package/packages/contracts/src/__tests__/control.test.ts

@@ -1,154 +0,0 @@
-/**
- * Schema tests for the control-socket protocol (M23.3): the versioned
- * envelope and the per-verb params. These pin the WIRE contract — a change
- * that breaks one of these breaks every connected agent loop.
- */
-import { describe, expect, it } from "vitest";
-import {
-  CONTROL_PROTOCOL_VERSION,
-  CONTROL_WAIT_MAX_TIMEOUT_MS,
-  agentStatusEventSchema,
-  controlEventSchema,
-  controlRequestSchema,
-  controlResponseSchema,
-  restartAgentParamsSchema,
-  sendParamsSchema,
-  spawnParamsSchema,
-  waitParamsSchema,
-} from "../control";
-
-describe("controlRequestSchema", () => {
-  it("accepts a minimal request (params optional)", () => {
-    const r = controlRequestSchema.parse({ v: 1, id: 1, verb: "fleet" });
-    expect(r.verb).toBe("fleet");
-    expect(r.params).toBeUndefined();
-  });
-
-  it("accepts string ids and object params", () => {
-    const r = controlRequestSchema.parse({
-      v: 1,
-      id: "req-7",
-      verb: "send",
-      params: { session: "s", target: "%1", message: "hi" },
-    });
-    expect(r.id).toBe("req-7");
-  });
-
-  it("keeps verb an OPEN string — unknown verbs parse (dispatch answers them)", () => {
-    expect(controlRequestSchema.parse({ v: 1, id: 1, verb: "verb-from-the-future" }).verb).toBe(
-      "verb-from-the-future",
-    );
-  });
-
-  it("rejects a wrong or missing version", () => {
-    expect(() => controlRequestSchema.parse({ v: 2, id: 1, verb: "fleet" })).toThrow();
-    expect(() => controlRequestSchema.parse({ id: 1, verb: "fleet" })).toThrow();
-  });
-
-  it("rejects a missing id or empty verb", () => {
-    expect(() => controlRequestSchema.parse({ v: 1, verb: "fleet" })).toThrow();
-    expect(() => controlRequestSchema.parse({ v: 1, id: 1, verb: "" })).toThrow();
-  });
-});
-
-describe("controlResponseSchema", () => {
-  it("accepts an ok response with arbitrary data", () => {
-    const r = controlResponseSchema.parse({ v: 1, id: 3, ok: true, data: { projects: [] } });
-    expect(r.ok).toBe(true);
-  });
-
-  it("accepts an error response with a null id (uncorrelatable frame)", () => {
-    const r = controlResponseSchema.parse({
-      v: 1,
-      id: null,
-      ok: false,
-      error: { code: "bad-request", message: "unparseable frame" },
-    });
-    expect(r.ok).toBe(false);
-  });
-
-  it("rejects an error response without the error object", () => {
-    expect(() => controlResponseSchema.parse({ v: 1, id: 1, ok: false })).toThrow();
-  });
-});
-
-describe("controlEventSchema + agentStatusEventSchema", () => {
-  it("accepts an event frame and its agent-status payload", () => {
-    const frame = controlEventSchema.parse({
-      v: CONTROL_PROTOCOL_VERSION,
-      event: "agent-status",
-      data: { ts: "2026-07-10T12:00:00Z", session: "zz-x", from: null, to: "working" },
-    });
-    const ev = agentStatusEventSchema.parse(frame.data);
-    expect(ev.from).toBeNull();
-    expect(ev.to).toBe("working");
-  });
-
-  it("rejects an unknown status in the payload", () => {
-    expect(() =>
-      agentStatusEventSchema.parse({ ts: "t", session: "s", from: null, to: "sleeping" }),
-    ).toThrow();
-  });
-});
-
-describe("waitParamsSchema", () => {
-  it("accepts both kinds", () => {
-    expect(
-      waitParamsSchema.parse({ kind: "agent-status", session: "s", status: "done" }).kind,
-    ).toBe("agent-status");
-    expect(waitParamsSchema.parse({ kind: "output", target: "%1", match: "ok" }).kind).toBe(
-      "output",
-    );
-  });
-
-  it("caps timeoutMs", () => {
-    expect(() =>
-      waitParamsSchema.parse({
-        kind: "output",
-        target: "%1",
-        match: "ok",
-        timeoutMs: CONTROL_WAIT_MAX_TIMEOUT_MS + 1,
-      }),
-    ).toThrow();
-  });
-});
-
-describe("spawnParamsSchema", () => {
-  it("requires exactly one of kind/command", () => {
-    expect(() => spawnParamsSchema.parse({ session: "s" })).toThrow();
-    expect(() => spawnParamsSchema.parse({ session: "s", kind: "claude", command: "x" })).toThrow();
-    expect(spawnParamsSchema.parse({ session: "s", kind: "claude" }).kind).toBe("claude");
-  });
-
-  it("requires a session or a sessionName", () => {
-    expect(() => spawnParamsSchema.parse({ kind: "claude" })).toThrow();
-    expect(spawnParamsSchema.parse({ sessionName: "zz-new", kind: "claude" }).sessionName).toBe(
-      "zz-new",
-    );
-  });
-
-  it("requires paneId for split placements only", () => {
-    expect(() =>
-      spawnParamsSchema.parse({ session: "s", kind: "claude", placement: "split-h" }),
-    ).toThrow();
-    expect(
-      spawnParamsSchema.parse({ session: "s", kind: "claude", placement: "window" }).placement,
-    ).toBe("window");
-  });
-});
-
-describe("sendParamsSchema / restartAgentParamsSchema", () => {
-  it("send requires session, target and a non-empty message", () => {
-    expect(() => sendParamsSchema.parse({ session: "s", target: "%1", message: "" })).toThrow();
-    expect(sendParamsSchema.parse({ session: "s", target: "%1", message: "go" }).noEnter).toBe(
-      undefined,
-    );
-  });
-
-  it("restart requires kind or command", () => {
-    expect(() => restartAgentParamsSchema.parse({ paneId: "%1" })).toThrow();
-    expect(restartAgentParamsSchema.parse({ paneId: "%1", command: "claude" }).command).toBe(
-      "claude",
-    );
-  });
-});