tmux-ide 2.9.2 → 2.9.4

package/packages/contracts/src/__tests__/terminal-attachments.test.ts

@@ -1,329 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  TERMINAL_ATTACHMENT_MAX_COLS,
-  TERMINAL_ATTACHMENT_MAX_ROWS,
-  TERMINAL_ATTACHMENT_MIN_COLS,
-  TERMINAL_ATTACHMENT_MIN_ROWS,
-  TERMINAL_ATTACHMENT_ISSUE_PATH,
-  TERMINAL_ATTACHMENT_PROTOCOL_VERSION,
-  TERMINAL_ATTACHMENT_REDEEM_PATH,
-  TERMINAL_ATTACHMENT_WEBSOCKET_SUBPROTOCOL,
-  TerminalAttachRequestSchemaZ,
-  TerminalAttachmentErrorSchemaZ,
-  TerminalAttachmentIssueDescriptorSchemaZ,
-  TerminalAttachmentIssueErrorSchemaZ,
-  TerminalAttachmentIssueMutationRequestSchemaZ,
-  TerminalAttachmentIssueResultSchemaZ,
-  TerminalAttachmentPlanResponseSchemaZ,
-  TerminalAttachmentSemanticPaneIdSchemaZ,
-  TerminalAttachmentSemanticWindowIdSchemaZ,
-} from "../terminal-attachments.ts";
-import { WORKSPACE_SEMANTIC_WINDOW_OPTION } from "../workspace-state.ts";
-
-const target = {
-  workspaceName: "workspace.alpha-2",
-  semanticPaneId: "pane.codex_worker-3",
-};
-
-function request() {
-  return {
-    protocolVersion: TERMINAL_ATTACHMENT_PROTOCOL_VERSION,
-    target,
-    viewerMode: "interactive" as const,
-    viewport: { cols: 120, rows: 40 },
-  };
-}
-
-describe("terminal attachment contracts", () => {
-  it("publishes one shared issue and redemption endpoint authority", () => {
-    expect(TERMINAL_ATTACHMENT_ISSUE_PATH).toBe("/api/v1/terminal/attachments/issue");
-    expect(TERMINAL_ATTACHMENT_REDEEM_PATH).toBe("/v1/terminal/attachments/redeem");
-  });
-
-  it("accepts alternate semantic ids and both viewer modes", () => {
-    expect(TerminalAttachRequestSchemaZ.parse(request()).target).toEqual(target);
-    expect(
-      TerminalAttachRequestSchemaZ.safeParse({ ...request(), viewerMode: "read-only" }).success,
-    ).toBe(true);
-  });
-
-  it("defaults an unstated geometry ownership to passive", () => {
-    /*
-     * Bug this catches: a caller that predates the field, or forgets it, starts
-     * driving the size of a tmux window that an ssh client or a colleague is
-     * also attached to. The unsafe direction has to be the one you ask for.
-     */
-    expect(TerminalAttachRequestSchemaZ.parse(request()).geometryOwnership).toBe("passive");
-    expect(
-      TerminalAttachRequestSchemaZ.parse({ ...request(), geometryOwnership: "owner" })
-        .geometryOwnership,
-    ).toBe("owner");
-  });
-
-  it("refuses a read-only attachment that asks to own geometry", () => {
-    /*
-     * `attach-session -r` implies `ignore-size`, so tmux would drop the request
-     * on the floor. Accepting it would leave a caller believing it owns a size
-     * it does not, with nothing anywhere saying otherwise.
-     */
-    expect(
-      TerminalAttachRequestSchemaZ.safeParse({
-        ...request(),
-        viewerMode: "read-only",
-        geometryOwnership: "owner",
-      }).success,
-    ).toBe(false);
-    expect(
-      TerminalAttachRequestSchemaZ.safeParse({
-        ...request(),
-        viewerMode: "read-only",
-        geometryOwnership: "passive",
-      }).success,
-    ).toBe(true);
-  });
-
-  it("reserves discovered fallback ids outside attachment authority", () => {
-    const reserved = "terminal.discovered.user-authored";
-    expect(TerminalAttachmentSemanticPaneIdSchemaZ.safeParse(reserved).success).toBe(false);
-    expect(
-      TerminalAttachRequestSchemaZ.safeParse({
-        ...request(),
-        target: { ...target, semanticPaneId: reserved },
-      }).success,
-    ).toBe(false);
-  });
-
-  it("shares the pane-stamp grammar for the durable window-id stamp", () => {
-    expect(WORKSPACE_SEMANTIC_WINDOW_OPTION).toBe("@tmux_ide_window_id");
-    expect(
-      TerminalAttachmentSemanticWindowIdSchemaZ.safeParse("window.workspace.alpha").success,
-    ).toBe(true);
-    expect(
-      TerminalAttachmentSemanticWindowIdSchemaZ.safeParse("window.promoted.abc123").success,
-    ).toBe(true);
-    for (const invalid of ["terminal.discovered.window", "window:colon", "__proto__", ".dot"]) {
-      expect(TerminalAttachmentSemanticWindowIdSchemaZ.safeParse(invalid).success).toBe(false);
-    }
-  });
-
-  it("uses the exact portable workspace-id grammar for semantic pane admission", () => {
-    for (const semanticPaneId of [
-      "pane:colon",
-      "constructor",
-      "__proto__",
-      ".leading-dot",
-      `pane.${"x".repeat(124)}`,
-    ]) {
-      expect(TerminalAttachmentSemanticPaneIdSchemaZ.safeParse(semanticPaneId).success).toBe(false);
-      expect(
-        TerminalAttachRequestSchemaZ.safeParse({
-          ...request(),
-          target: { ...target, semanticPaneId },
-        }).success,
-      ).toBe(false);
-    }
-  });
-
-  it("enforces fixed integer viewport limits", () => {
-    for (const viewport of [
-      { cols: TERMINAL_ATTACHMENT_MIN_COLS - 1, rows: 40 },
-      { cols: TERMINAL_ATTACHMENT_MAX_COLS + 1, rows: 40 },
-      { cols: 120, rows: TERMINAL_ATTACHMENT_MIN_ROWS - 1 },
-      { cols: 120, rows: TERMINAL_ATTACHMENT_MAX_ROWS + 1 },
-      { cols: 120.5, rows: 40 },
-    ]) {
-      expect(TerminalAttachRequestSchemaZ.safeParse({ ...request(), viewport }).success).toBe(
-        false,
-      );
-    }
-    expect(
-      TerminalAttachRequestSchemaZ.safeParse({
-        ...request(),
-        viewport: { cols: TERMINAL_ATTACHMENT_MAX_COLS, rows: TERMINAL_ATTACHMENT_MAX_ROWS },
-      }).success,
-    ).toBe(true);
-  });
-
-  it("rejects renderer-supplied execution, runtime-target, and credential fields", () => {
-    for (const forbidden of [
-      { cmd: "sh -c whoami" },
-      { command: "codex --yolo" },
-      { cwd: "/tmp" },
-      { paneId: "%7" },
-      { tmuxTarget: "owner:@9" },
-      { authToken: "secret" },
-    ]) {
-      expect(TerminalAttachRequestSchemaZ.safeParse({ ...request(), ...forbidden }).success).toBe(
-        false,
-      );
-    }
-    expect(
-      TerminalAttachRequestSchemaZ.safeParse({
-        ...request(),
-        target: { ...target, paneId: "%7" },
-      }).success,
-    ).toBe(false);
-  });
-
-  it("rejects protocol drift and hostile values instead of treating them as targets", () => {
-    expect(
-      TerminalAttachRequestSchemaZ.safeParse({ ...request(), protocolVersion: 2 }).success,
-    ).toBe(false);
-    for (const hostile of ["%7", "owner:@1", "$(touch-pwned)", "pane;kill-server"] as const) {
-      expect(
-        TerminalAttachRequestSchemaZ.safeParse({
-          ...request(),
-          target: { ...target, workspaceName: hostile },
-        }).success,
-      ).toBe(false);
-    }
-  });
-
-  it("keeps planning responses non-redeemable, strict, and renderer-safe", () => {
-    const response = {
-      ok: true as const,
-      protocolVersion: TERMINAL_ATTACHMENT_PROTOCOL_VERSION,
-      descriptor: {
-        attachmentId: "2ddc3f17-723b-4e16-a3d2-ad751fb01b2e",
-        target,
-        viewerMode: "interactive" as const,
-        geometryOwnership: "passive" as const,
-        viewport: { cols: 120, rows: 40 },
-        status: "planned" as const,
-      },
-      handle: {
-        requestId: "2a215cf2-547e-42a2-91c7-454df8e56121",
-      },
-    };
-    expect(TerminalAttachmentPlanResponseSchemaZ.parse(response)).toEqual(response);
-    for (const forbidden of [
-      { authToken: "secret" },
-      { tmuxTarget: "owner:@7" },
-      { paneId: "%7" },
-      { command: "tmux attach" },
-      { cwd: "/repo" },
-    ]) {
-      expect(
-        TerminalAttachmentPlanResponseSchemaZ.safeParse({
-          ...response,
-          descriptor: { ...response.descriptor, ...forbidden },
-        }).success,
-      ).toBe(false);
-    }
-
-    for (const forbidden of [
-      { ticket: "redeem-me" },
-      { ticketId: "2a215cf2-547e-42a2-91c7-454df8e56121" },
-      { token: "secret" },
-      { auth: "secret" },
-      { authToken: "secret" },
-    ]) {
-      expect(
-        TerminalAttachmentPlanResponseSchemaZ.safeParse({ ...response, ...forbidden }).success,
-      ).toBe(false);
-    }
-
-    expect(
-      TerminalAttachmentErrorSchemaZ.safeParse({
-        code: "pane-not-attachable",
-        message: "The pane belongs to a split window",
-        target,
-        reason: "not-single-pane-window",
-        retryable: false,
-      }).success,
-    ).toBe(true);
-    expect(
-      TerminalAttachmentErrorSchemaZ.safeParse({
-        code: "protocol-version-unsupported",
-        message: "Upgrade required",
-        receivedVersion: 2,
-        supportedVersions: [TERMINAL_ATTACHMENT_PROTOCOL_VERSION],
-        retryable: false,
-      }).success,
-    ).toBe(true);
-  });
-
-  it("accepts one strict, bounded, loopback-only issue descriptor", () => {
-    const descriptor = {
-      protocolVersion: TERMINAL_ATTACHMENT_PROTOCOL_VERSION,
-      webSocketUrl: "ws://127.0.0.1:6060/v1/terminal/attachments/redeem",
-      subprotocol: TERMINAL_ATTACHMENT_WEBSOCKET_SUBPROTOCOL,
-      redemptionTicket: `ta1_${"A".repeat(43)}`,
-      daemonInstanceId: "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-      requestId: "10000000-0000-4000-8000-000000000001",
-      expiresAt: 1_784_662_860_000,
-      effectiveViewerMode: "interactive" as const,
-      effectiveGeometryOwnership: "passive" as const,
-    };
-    expect(TerminalAttachmentIssueDescriptorSchemaZ.parse(descriptor)).toEqual(descriptor);
-    expect(TerminalAttachmentIssueResultSchemaZ.parse({ status: "issued", descriptor })).toEqual({
-      status: "issued",
-      descriptor,
-    });
-
-    for (const webSocketUrl of [
-      "wss://127.0.0.1:6060/v1/terminal/attachments/redeem",
-      "ws://192.0.2.1:6060/v1/terminal/attachments/redeem",
-      "ws://secret@127.0.0.1:6060/v1/terminal/attachments/redeem",
-      "ws://127.0.0.1/v1/terminal/attachments/redeem",
-      "ws://127.0.0.1:6060/v1/terminal/attachments/redeem?token=secret",
-      "ws://127.0.0.1:6060/another-path",
-    ]) {
-      expect(
-        TerminalAttachmentIssueDescriptorSchemaZ.safeParse({ ...descriptor, webSocketUrl }).success,
-      ).toBe(false);
-    }
-
-    for (const forbidden of [
-      { tmuxPaneId: "%7" },
-      { sessionName: "raw-session" },
-      { cwd: "/private/project" },
-      { argv: ["codex", "--yolo"] },
-      { env: { SECRET: "value" } },
-      { ownerToken: "secret" },
-    ]) {
-      expect(
-        TerminalAttachmentIssueDescriptorSchemaZ.safeParse({ ...descriptor, ...forbidden }).success,
-      ).toBe(false);
-    }
-  });
-
-  it("keeps host-authored issue metadata outside renderer intent", () => {
-    const mutation = TerminalAttachmentIssueMutationRequestSchemaZ.parse({
-      requestId: "10000000-0000-4000-8000-000000000001",
-      expectedDaemonInstanceId: "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-      attachment: request(),
-    });
-    expect(mutation.attachment).not.toHaveProperty("requestId");
-    expect(mutation.attachment).not.toHaveProperty("expectedDaemonInstanceId");
-    expect(
-      TerminalAttachmentIssueMutationRequestSchemaZ.safeParse({
-        ...mutation,
-        origin: "https://renderer.example",
-      }).success,
-    ).toBe(false);
-  });
-
-  it("rejects credential-bearing public error text", () => {
-    expect(
-      TerminalAttachmentIssueErrorSchemaZ.parse({
-        code: "attachment-unavailable",
-        reason: "The terminal attachment is unavailable.",
-        retryable: true,
-      }),
-    ).toMatchObject({ code: "attachment-unavailable" });
-    for (const reason of [
-      "Authorization was Bearer owner-secret",
-      `The redemptionTicket was ta1_${"A".repeat(43)}`,
-      "ownerToken=secret",
-    ]) {
-      expect(
-        TerminalAttachmentIssueErrorSchemaZ.safeParse({
-          code: "request-failed",
-          reason,
-          retryable: false,
-        }).success,
-      ).toBe(false);
-    }
-  });
-});

package/packages/contracts/src/__tests__/terminal-delivery.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  TerminalDeliveryEnvelopeSchemaZ,
-  TerminalDeliveryNegotiatedSchemaZ,
-  TerminalDeliveryOfferSchemaZ,
-} from "../terminal-delivery.ts";
-
-const address = {
-  workspaceName: "workspace",
-  semanticPaneId: "pane-a",
-  generation: "00000000-0000-4000-8000-000000000001",
-  incarnation: "incarnation:1",
-  deliveryNonce: "00000000-0000-4000-8000-000000000002",
-} as const;
-
-describe("terminal delivery contracts", () => {
-  it("rejects duplicate negotiation offers and impossible capabilities", () => {
-    expect(() =>
-      TerminalDeliveryOfferSchemaZ.parse({
-        protocolVersions: [1, 1],
-        encodings: ["semantic-v1"],
-        richPlacements: false,
-      }),
-    ).toThrow();
-    expect(() =>
-      TerminalDeliveryNegotiatedSchemaZ.parse({
-        protocolVersion: 1,
-        encoding: "ansi-diff-v1",
-        richPlacements: true,
-        generation: address.generation,
-        deliveryNonce: address.deliveryNonce,
-      }),
-    ).toThrow();
-  });
-
-  it("binds chunk count, base revision, equivalence, history and rich claims", () => {
-    const valid = {
-      type: "terminal.delivery",
-      ...address,
-      transactionId: "00000000-0000-4000-8000-000000000003",
-      performanceTraceId: "00000000-0000-4000-8000-000000000004",
-      protocolVersion: 1,
-      encoding: "semantic-v1",
-      frame: "seed",
-      baseRevision: null,
-      canonicalRevision: 0,
-      canonicalStateHash: "0000000000000000",
-      representationHash: "0000000000000000",
-      representationBytes: 0,
-      chunkCount: 1,
-      canonicalEquivalent: true,
-      history: "complete",
-      richPlacements: false,
-    } as const;
-    expect(TerminalDeliveryEnvelopeSchemaZ.parse(valid)).toEqual(valid);
-    expect(() =>
-      TerminalDeliveryEnvelopeSchemaZ.parse({ ...valid, performanceTraceId: "not-a-uuid" }),
-    ).toThrow();
-    for (const mutation of [
-      { chunkCount: 2 },
-      { baseRevision: 0 },
-      { canonicalEquivalent: false },
-      { history: "truncated" },
-    ])
-      expect(() => TerminalDeliveryEnvelopeSchemaZ.parse({ ...valid, ...mutation })).toThrow();
-  });
-
-  it("allows canonical tombstones only with no history", () => {
-    const tombstone = {
-      type: "terminal.delivery",
-      ...address,
-      transactionId: "00000000-0000-4000-8000-000000000003",
-      protocolVersion: 1,
-      encoding: "semantic-v1",
-      frame: "tombstone",
-      baseRevision: 0,
-      canonicalRevision: 1,
-      canonicalStateHash: "0000000000000000",
-      representationHash: "0000000000000000",
-      representationBytes: 0,
-      chunkCount: 1,
-      canonicalEquivalent: true,
-      history: "not-applicable",
-      richPlacements: false,
-    } as const;
-    expect(TerminalDeliveryEnvelopeSchemaZ.parse(tombstone).history).toBe("not-applicable");
-  });
-});

package/packages/contracts/src/__tests__/terminal-runtime-inventory.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  TerminalRuntimeInventoryProjectionV1SchemaZ,
-  TerminalRuntimeInventoryResourceV1SchemaZ,
-} from "../terminal-runtime-inventory.ts";
-import { DAEMON_WIRE_PROTOCOL_VERSION } from "../daemon-wire.ts";
-
-const daemon = {
-  protocolVersion: DAEMON_WIRE_PROTOCOL_VERSION,
-  productVersion: "1.0.0",
-  instanceId: "123e4567-e89b-42d3-a456-426614174000",
-  startedAt: "2026-08-17T10:00:00.000Z",
-};
-
-describe("terminal runtime inventory contract", () => {
-  it("accepts only sorted semantic topology with opaque product/session identities", () => {
-    expect(
-      TerminalRuntimeInventoryResourceV1SchemaZ.parse({
-        version: 1,
-        daemon,
-        resource: {
-          workspaceName: "alpha",
-          workspaceId: "workspace.0123456789abcdefabcd",
-          sessionId: "session.0123456789abcdefabcd",
-          resourceRevision: 4,
-          semanticPaneIds: ["pane.a", "pane.b"],
-        },
-      }).resource.semanticPaneIds,
-    ).toEqual(["pane.a", "pane.b"]);
-  });
-
-  it.each(["$3", "/Users/person/project", "session\nsecret", "plain-session"])(
-    "rejects raw/control/path session identity %j",
-    (sessionId) => {
-      expect(
-        TerminalRuntimeInventoryProjectionV1SchemaZ.safeParse({
-          workspaceName: "alpha",
-          workspaceId: "workspace.0123456789abcdefabcd",
-          sessionId,
-          resourceRevision: 0,
-          semanticPaneIds: [],
-        }).success,
-      ).toBe(false);
-    },
-  );
-
-  it("rejects duplicate or unsorted pane identities", () => {
-    const base = {
-      workspaceName: "alpha",
-      workspaceId: "workspace.0123456789abcdefabcd",
-      sessionId: "session.0123456789abcdefabcd",
-      resourceRevision: 0,
-    };
-    expect(
-      TerminalRuntimeInventoryProjectionV1SchemaZ.safeParse({
-        ...base,
-        semanticPaneIds: ["pane.b", "pane.a"],
-      }).success,
-    ).toBe(false);
-    expect(
-      TerminalRuntimeInventoryProjectionV1SchemaZ.safeParse({
-        ...base,
-        semanticPaneIds: ["pane.a", "pane.a"],
-      }).success,
-    ).toBe(false);
-  });
-});

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

@@ -1,87 +0,0 @@
-/**
- * `createScriptTerminalId` determinism tests (G20-P1).
- *
- * The whole point of the script-derived id is determinism — two
- * callers asking for "the run script for project X, scope Y, script
- * Z" must collapse to one bridge. These tests pin that contract.
- */
-
-import { describe, expect, it } from "vitest";
-import { createScriptTerminalId } from "../terminals";
-
-describe("createScriptTerminalId", () => {
-  it("is deterministic for the same input", async () => {
-    const a = await createScriptTerminalId({
-      projectId: "proj",
-      scopeId: "feat-x",
-      kind: "run",
-      script: "pnpm dev",
-    });
-    const b = await createScriptTerminalId({
-      projectId: "proj",
-      scopeId: "feat-x",
-      kind: "run",
-      script: "pnpm dev",
-    });
-    expect(a).toBe(b);
-    expect(a).toHaveLength(32);
-  });
-
-  it("changes when scopeId changes (same project + script)", async () => {
-    const a = await createScriptTerminalId({
-      projectId: "proj",
-      scopeId: "feat-x",
-      kind: "run",
-      script: "pnpm dev",
-    });
-    const b = await createScriptTerminalId({
-      projectId: "proj",
-      scopeId: "feat-y",
-      kind: "run",
-      script: "pnpm dev",
-    });
-    expect(a).not.toBe(b);
-  });
-
-  it("changes when kind changes", async () => {
-    const run = await createScriptTerminalId({
-      projectId: "proj",
-      scopeId: "feat-x",
-      kind: "run",
-      script: "pnpm dev",
-    });
-    const setup = await createScriptTerminalId({
-      projectId: "proj",
-      scopeId: "feat-x",
-      kind: "setup",
-      script: "pnpm dev",
-    });
-    expect(run).not.toBe(setup);
-  });
-
-  it("accepts taskId as a backward-compat alias for scopeId", async () => {
-    const viaScope = await createScriptTerminalId({
-      projectId: "proj",
-      scopeId: "feat-x",
-      kind: "run",
-      script: "pnpm dev",
-    });
-    const viaTask = await createScriptTerminalId({
-      projectId: "proj",
-      taskId: "feat-x",
-      kind: "run",
-      script: "pnpm dev",
-    });
-    expect(viaScope).toBe(viaTask);
-  });
-
-  it("rejects calls without scope or task", async () => {
-    await expect(
-      createScriptTerminalId({
-        projectId: "proj",
-        kind: "run",
-        script: "pnpm dev",
-      }),
-    ).rejects.toThrow(/scopeId/);
-  });
-});