tmux-ide 2.9.2 → 2.9.4

package/packages/contracts/src/__tests__/workspace-config.test.ts

@@ -1,294 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { WorkspaceConfigV1SchemaZ } from "../workspace-config.ts";
-import type { WorkspaceAppLayoutNode } from "../workspace-config.ts";
-
-describe("WorkspaceConfigV1SchemaZ", () => {
-  it("accepts a minimal versioned workspace", () => {
-    expect(WorkspaceConfigV1SchemaZ.parse({ version: 1 })).toEqual({ version: 1 });
-  });
-
-  it("accepts unique workspace-safe pane ids and rejects duplicates", () => {
-    expect(
-      WorkspaceConfigV1SchemaZ.parse({
-        version: 1,
-        terminal: { rows: [{ panes: [{ id: "agent-1" }, { id: "shell" }] }] },
-      }).terminal?.rows[0]?.panes.map((pane) => pane.id),
-    ).toEqual(["agent-1", "shell"]);
-    expect(() =>
-      WorkspaceConfigV1SchemaZ.parse({
-        version: 1,
-        terminal: {
-          rows: [{ panes: [{ id: "duplicate" }] }, { panes: [{ id: "duplicate" }] }],
-        },
-      }),
-    ).toThrow(/Duplicate pane id/u);
-  });
-
-  it("keeps harnesses, adapters, commands, and models provider-neutral", () => {
-    const result = WorkspaceConfigV1SchemaZ.parse({
-      version: 1,
-      name: "Mixed agents",
-      terminal: {
-        rows: [
-          {
-            size: "70%",
-            panes: [{ title: "Lead", command: "claude", focus: true }],
-          },
-        ],
-        theme: { accent: "colour75" },
-      },
-      app: {
-        views: [
-          { id: "home", panel: "home" },
-          { id: "terminal", title: "IDE", panel: "terminals" },
-          { id: "mission-board", panel: "missions" },
-        ],
-      },
-      harnesses: {
-        claude: { adapter: "claude-code", command: ["claude"] },
-        codex: { adapter: "codex", command: ["codex", "--ask-for-approval", "never"] },
-        droid: { adapter: "droid", command: "droid" },
-        custom: {
-          adapter: "acme/custom-v4",
-          command: ["my-review-agent", "--interactive"],
-          env: { REVIEW_MODE: "strict" },
-        },
-      },
-      agents: {
-        lead: { harness: "claude", model: "claude-fable-5", role: "manager" },
-        worker: { harness: "codex", model: "gpt-5.5", role: "implementer" },
-        researcher: { harness: "droid", model: "anything/new", role: "researcher" },
-        reviewer: { harness: "custom", role: "reviewer" },
-      },
-      missions: {
-        manager: "lead",
-        workers: ["worker", "researcher"],
-        reviewer: "reviewer",
-        isolation: "worktree",
-        max_concurrent_tasks: 2,
-      },
-    });
-
-    expect(result.harnesses?.custom?.adapter).toBe("acme/custom-v4");
-    expect(result.agents?.researcher?.model).toBe("anything/new");
-  });
-
-  it("rejects unknown keys at every object boundary", () => {
-    expect(() => WorkspaceConfigV1SchemaZ.parse({ version: 1, versoin: 1 })).toThrow();
-    expect(() =>
-      WorkspaceConfigV1SchemaZ.parse({
-        version: 1,
-        harnesses: { custom: { adapter: "generic", command: ["agent"], typo: true } },
-      }),
-    ).toThrow();
-    expect(() =>
-      WorkspaceConfigV1SchemaZ.parse({
-        version: 1,
-        terminal: { rows: [{ panes: [{ command: "shell", task: "legacy metadata" }] }] },
-      }),
-    ).toThrow();
-  });
-
-  it("rejects invalid panel, role, isolation, and concurrency values", () => {
-    const invalidValues = [
-      { version: 1, app: { views: [{ id: "bad", panel: "unknown" }] } },
-      {
-        version: 1,
-        harnesses: { h: { adapter: "custom", command: "agent" } },
-        agents: { a: { harness: "h", role: "lead" } },
-      },
-      { version: 1, missions: { isolation: "container" } },
-      { version: 1, missions: { max_concurrent_tasks: 0 } },
-      { version: 1, missions: { max_concurrent_tasks: 1.5 } },
-    ];
-
-    for (const value of invalidValues) {
-      expect(WorkspaceConfigV1SchemaZ.safeParse(value).success).toBe(false);
-    }
-  });
-
-  it("rejects broken harness and mission agent references with useful paths", () => {
-    const result = WorkspaceConfigV1SchemaZ.safeParse({
-      version: 1,
-      agents: {
-        worker: { harness: "missing-harness", role: "implementer" },
-      },
-      missions: {
-        manager: "missing-manager",
-        workers: ["worker", "missing-worker"],
-        reviewer: "missing-reviewer",
-      },
-    });
-
-    expect(result.success).toBe(false);
-    if (result.success) return;
-    expect(result.error.issues.map((issue) => issue.path.join("."))).toEqual(
-      expect.arrayContaining([
-        "agents.worker.harness",
-        "missions.manager",
-        "missions.workers.1",
-        "missions.reviewer",
-      ]),
-    );
-  });
-
-  it("requires unique stable view IDs", () => {
-    const result = WorkspaceConfigV1SchemaZ.safeParse({
-      version: 1,
-      app: {
-        views: [
-          { id: "ide", panel: "terminals" },
-          { id: "ide", panel: "files" },
-        ],
-      },
-    });
-
-    expect(result.success).toBe(false);
-    if (result.success) return;
-    expect(result.error.issues[0]?.message).toContain("Duplicate view id");
-  });
-
-  it("accepts composite split/tab application views while preserving shorthand views", () => {
-    const result = WorkspaceConfigV1SchemaZ.parse({
-      version: 1,
-      app: {
-        views: [
-          { id: "home", panel: "home" },
-          {
-            id: "ide",
-            title: "IDE",
-            layout: {
-              type: "split",
-              id: "ide-root",
-              direction: "horizontal",
-              weights: [72, 28],
-              children: [
-                { type: "panel", id: "terminal-main", panel: "terminals", min_size: 40 },
-                {
-                  type: "tabs",
-                  id: "inspection-dock",
-                  active: "files-tab",
-                  children: [
-                    { type: "panel", id: "files-tab", panel: "files", min_size: 24 },
-                    { type: "panel", id: "diff-tab", panel: "diff", min_size: 24 },
-                  ],
-                },
-              ],
-            },
-          },
-        ],
-      },
-    });
-
-    expect(result.app?.views[0]).toEqual({ id: "home", panel: "home" });
-    expect(result.app?.views[1]).toMatchObject({ id: "ide", title: "IDE" });
-  });
-
-  it("rejects invalid composite layout trees with precise paths", () => {
-    const cases = [
-      {
-        value: {
-          version: 1,
-          app: {
-            views: [
-              {
-                id: "bad",
-                layout: {
-                  type: "split",
-                  id: "root",
-                  direction: "horizontal",
-                  weights: [1],
-                  children: [
-                    { type: "panel", id: "a", panel: "files" },
-                    { type: "panel", id: "b", panel: "diff" },
-                  ],
-                },
-              },
-            ],
-          },
-        },
-        path: "app.views.0.layout.weights",
-      },
-      {
-        value: {
-          version: 1,
-          app: {
-            views: [
-              {
-                id: "bad",
-                layout: {
-                  type: "tabs",
-                  id: "tabs",
-                  active: "missing",
-                  children: [{ type: "panel", id: "a", panel: "files" }],
-                },
-              },
-            ],
-          },
-        },
-        path: "app.views.0.layout.active",
-      },
-      {
-        value: {
-          version: 1,
-          app: {
-            views: [
-              {
-                id: "bad",
-                layout: {
-                  type: "split",
-                  id: "root",
-                  direction: "vertical",
-                  children: [
-                    { type: "panel", id: "dup", panel: "files" },
-                    { type: "panel", id: "dup", panel: "diff" },
-                  ],
-                },
-              },
-            ],
-          },
-        },
-        path: "app.views.0.layout.children.1.id",
-      },
-    ];
-
-    for (const item of cases) {
-      const result = WorkspaceConfigV1SchemaZ.safeParse(item.value);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues.map((issue) => issue.path.join("."))).toContain(item.path);
-      }
-    }
-  });
-
-  it("rejects composite layouts beyond the depth and node-count bounds", () => {
-    let deep: WorkspaceAppLayoutNode = { type: "panel", id: "deep-leaf", panel: "files" };
-    for (let index = 0; index < 8; index += 1) {
-      deep = { type: "tabs", id: `deep-${index}`, children: [deep] };
-    }
-
-    let nextId = 0;
-    const broad = (depth: number): WorkspaceAppLayoutNode => {
-      const id = `node-${nextId++}`;
-      if (depth === 0) return { type: "panel", id, panel: "files" };
-      return {
-        type: "split",
-        id,
-        direction: "horizontal",
-        children: Array.from({ length: 4 }, () => broad(depth - 1)),
-      };
-    };
-
-    const issuesFor = (layout: WorkspaceAppLayoutNode) => {
-      const result = WorkspaceConfigV1SchemaZ.safeParse({
-        version: 1,
-        app: { views: [{ id: "bounded", layout }] },
-      });
-      expect(result.success).toBe(false);
-      return result.success ? [] : result.error.issues.map((issue) => issue.message);
-    };
-
-    expect(issuesFor(deep)).toContain("Composite view layout must not be deeper than 8 nodes");
-    expect(issuesFor(broad(3))).toContain("Composite view layout must not exceed 64 nodes");
-  });
-});

package/packages/contracts/src/__tests__/workspace-files-resource.test.ts

@@ -1,261 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  WORKSPACE_FILE_PREVIEW_RESOURCE_VERSION,
-  WORKSPACE_FILES_CATALOG_RESOURCE_VERSION,
-  WorkspaceFileEntrySchemaZ,
-  WorkspaceFilePreviewEnvelopeV1SchemaZ,
-  WorkspaceFilesCatalogEnvelopeV1SchemaZ,
-  WorkspaceFilesCatalogResourceV1SchemaZ,
-} from "../workspace-files-resource.ts";
-
-const daemon = {
-  protocolVersion: 1,
-  productVersion: "2.8.0",
-  instanceId: "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-  startedAt: "2026-07-21T12:00:00.000Z",
-};
-
-const fileId = (token: string) => `file.${token.padEnd(16, "0")}`;
-const filesRev = (token: string) => `files-rev.${token.padEnd(16, "0")}`;
-
-const rootId = fileId("root");
-const srcId = fileId("src");
-const readmeId = fileId("readme");
-
-const srcEntry = {
-  id: srcId,
-  parentId: rootId,
-  name: "src",
-  relativePath: "src",
-  kind: "directory" as const,
-  hidden: false,
-  ignored: false,
-  hasChildren: true,
-  gitStatus: null,
-};
-
-const readmeEntry = {
-  id: readmeId,
-  parentId: rootId,
-  name: "README.md",
-  relativePath: "README.md",
-  kind: "file" as const,
-  hidden: false,
-  ignored: false,
-  hasChildren: false,
-  gitStatus: "modified" as const,
-};
-
-const rootCatalog = {
-  status: "ready" as const,
-  workspaceName: "tmux-ide",
-  revision: filesRev("gen1"),
-  rootId,
-  directory: { id: rootId, name: "tmux-ide", relativePath: null, parentId: null },
-  breadcrumbs: [{ id: rootId, label: "tmux-ide" }],
-  entries: [srcEntry, readmeEntry],
-  totalEntries: 2,
-  truncated: false,
-};
-
-describe("workspace files catalog resource", () => {
-  it("accepts a well-formed root listing and its envelope", () => {
-    expect(WorkspaceFilesCatalogResourceV1SchemaZ.safeParse(rootCatalog).success).toBe(true);
-    expect(
-      WorkspaceFilesCatalogEnvelopeV1SchemaZ.safeParse({
-        version: WORKSPACE_FILES_CATALOG_RESOURCE_VERSION,
-        daemon,
-        resource: rootCatalog,
-      }).success,
-    ).toBe(true);
-  });
-
-  it("accepts a nested directory listing with canonical child paths", () => {
-    const nested = {
-      ...rootCatalog,
-      rootId,
-      directory: { id: srcId, name: "src", relativePath: "src", parentId: rootId },
-      breadcrumbs: [
-        { id: rootId, label: "tmux-ide" },
-        { id: srcId, label: "src" },
-      ],
-      entries: [
-        {
-          id: fileId("index"),
-          parentId: srcId,
-          name: "index.ts",
-          relativePath: "src/index.ts",
-          kind: "file" as const,
-          hidden: false,
-          ignored: false,
-          hasChildren: false,
-          gitStatus: null,
-        },
-      ],
-      totalEntries: 1,
-    };
-    expect(WorkspaceFilesCatalogResourceV1SchemaZ.safeParse(nested).success).toBe(true);
-  });
-
-  it("rejects entries that lie about their path, parent, or children", () => {
-    expect(
-      WorkspaceFileEntrySchemaZ.safeParse({ ...readmeEntry, relativePath: "docs/OTHER.md" })
-        .success,
-    ).toBe(false);
-    expect(WorkspaceFileEntrySchemaZ.safeParse({ ...readmeEntry, hasChildren: true }).success).toBe(
-      false,
-    );
-    // A file cannot advertise children even when its path and name agree.
-    expect(
-      WorkspaceFileEntrySchemaZ.safeParse({ ...readmeEntry, kind: "file", hasChildren: true })
-        .success,
-    ).toBe(false);
-    // Extra keys — including a reserved record key held as an own property — are
-    // refused by the strict object. A computed key avoids the prototype-setter form.
-    expect(
-      WorkspaceFileEntrySchemaZ.safeParse({ ...readmeEntry, ["__proto__"]: "polluted" }).success,
-    ).toBe(false);
-  });
-
-  it("enforces catalog-wide invariants", () => {
-    // A child that is not parented by the listed directory.
-    expect(
-      WorkspaceFilesCatalogResourceV1SchemaZ.safeParse({
-        ...rootCatalog,
-        entries: [{ ...readmeEntry, parentId: fileId("other") }],
-        totalEntries: 1,
-      }).success,
-    ).toBe(false);
-    // Duplicate ids.
-    expect(
-      WorkspaceFilesCatalogResourceV1SchemaZ.safeParse({
-        ...rootCatalog,
-        entries: [srcEntry, { ...readmeEntry, id: srcId }],
-      }).success,
-    ).toBe(false);
-    // truncated must describe the omission implied by totalEntries.
-    expect(
-      WorkspaceFilesCatalogResourceV1SchemaZ.safeParse({
-        ...rootCatalog,
-        totalEntries: 9,
-        truncated: false,
-      }).success,
-    ).toBe(false);
-    // The first breadcrumb must be the workspace root.
-    expect(
-      WorkspaceFilesCatalogResourceV1SchemaZ.safeParse({
-        ...rootCatalog,
-        breadcrumbs: [{ id: srcId, label: "src" }],
-      }).success,
-    ).toBe(false);
-    // Only the root may omit relative path and parent identity.
-    expect(
-      WorkspaceFilesCatalogResourceV1SchemaZ.safeParse({
-        ...rootCatalog,
-        directory: { id: srcId, name: "src", relativePath: null, parentId: null },
-      }).success,
-    ).toBe(false);
-  });
-
-  it("rejects an unavailable catalog missing its reason", () => {
-    expect(
-      WorkspaceFilesCatalogResourceV1SchemaZ.safeParse({
-        status: "unavailable",
-        workspaceName: "tmux-ide",
-        reason: "directory-not-found",
-        message: "gone",
-        retryable: true,
-      }).success,
-    ).toBe(true);
-    expect(
-      WorkspaceFilesCatalogResourceV1SchemaZ.safeParse({
-        status: "unavailable",
-        workspaceName: "tmux-ide",
-        reason: "not-a-real-reason",
-        message: "gone",
-        retryable: true,
-      }).success,
-    ).toBe(false);
-  });
-});
-
-describe("workspace file preview resource", () => {
-  const base = {
-    workspaceName: "tmux-ide",
-    catalogRevision: filesRev("gen1"),
-    fileId: readmeId,
-    name: "README.md",
-    relativePath: "README.md",
-  };
-
-  it("accepts a complete text preview whose line count matches its content", () => {
-    const preview = {
-      status: "ready" as const,
-      ...base,
-      encoding: "utf-8" as const,
-      languageHint: "markdown",
-      content: "line one\nline two\nline three",
-      totalBytes: 28,
-      totalLines: 3,
-      truncated: false,
-    };
-    expect(
-      WorkspaceFilePreviewEnvelopeV1SchemaZ.safeParse({
-        version: WORKSPACE_FILE_PREVIEW_RESOURCE_VERSION,
-        daemon,
-        resource: preview,
-      }).success,
-    ).toBe(true);
-
-    // A complete preview must report its rendered line count honestly.
-    expect(
-      WorkspaceFilePreviewEnvelopeV1SchemaZ.safeParse({
-        version: WORKSPACE_FILE_PREVIEW_RESOURCE_VERSION,
-        daemon,
-        resource: { ...preview, totalLines: 99 },
-      }).success,
-    ).toBe(false);
-  });
-
-  it("rejects NUL bytes inside a text preview", () => {
-    const preview = {
-      status: "ready" as const,
-      ...base,
-      encoding: "utf-8" as const,
-      languageHint: null,
-      content: `has${String.fromCharCode(0)}nul`,
-      totalBytes: 7,
-      totalLines: 1,
-      truncated: false,
-    };
-    expect(
-      WorkspaceFilePreviewEnvelopeV1SchemaZ.safeParse({
-        version: WORKSPACE_FILE_PREVIEW_RESOURCE_VERSION,
-        daemon,
-        resource: preview,
-      }).success,
-    ).toBe(false);
-  });
-
-  it("accepts binary and too-large previews", () => {
-    expect(
-      WorkspaceFilePreviewEnvelopeV1SchemaZ.safeParse({
-        version: WORKSPACE_FILE_PREVIEW_RESOURCE_VERSION,
-        daemon,
-        resource: { status: "binary", ...base, totalBytes: 4096, mediaType: "image/png" },
-      }).success,
-    ).toBe(true);
-    expect(
-      WorkspaceFilePreviewEnvelopeV1SchemaZ.safeParse({
-        version: WORKSPACE_FILE_PREVIEW_RESOURCE_VERSION,
-        daemon,
-        resource: {
-          status: "too-large",
-          ...base,
-          totalBytes: 5_000_000,
-          limitBytes: 524_288,
-        },
-      }).success,
-    ).toBe(true);
-  });
-});

package/packages/contracts/src/__tests__/workspace-files-tree.test.ts

@@ -1,147 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { WorkspaceFileEntry } from "../workspace-files-resource.ts";
-import {
-  flattenWorkspaceFileTree,
-  moveWorkspaceFileSelection,
-  sortWorkspaceFileEntries,
-  toggleWorkspaceFileExpansion,
-  type WorkspaceFileTreeCatalog,
-} from "../workspace-files-tree.ts";
-
-const fileId = (token: string) => `file.${token.padEnd(16, "0")}`;
-const rootId = fileId("root");
-const srcId = fileId("src");
-const assetsId = fileId("assets");
-
-const entry = (
-  over: Partial<WorkspaceFileEntry> & Pick<WorkspaceFileEntry, "id" | "name">,
-): WorkspaceFileEntry => ({
-  parentId: rootId,
-  relativePath: over.name,
-  kind: "file",
-  hidden: false,
-  ignored: false,
-  hasChildren: false,
-  gitStatus: null,
-  ...over,
-});
-
-const rootEntries: WorkspaceFileEntry[] = [
-  entry({ id: srcId, name: "src", kind: "directory", hasChildren: true, relativePath: "src" }),
-  entry({
-    id: assetsId,
-    name: "Assets",
-    kind: "directory",
-    hasChildren: true,
-    relativePath: "Assets",
-  }),
-  entry({ id: fileId("readme"), name: "README.md", relativePath: "README.md" }),
-  entry({ id: fileId("app"), name: "app.ts", relativePath: "app.ts" }),
-];
-
-const srcCatalog: WorkspaceFileTreeCatalog = {
-  directoryId: srcId,
-  entries: [
-    entry({
-      id: fileId("index"),
-      parentId: srcId,
-      name: "index.ts",
-      relativePath: "src/index.ts",
-    }),
-  ],
-};
-
-const catalogs: WorkspaceFileTreeCatalog[] = [
-  { directoryId: rootId, entries: rootEntries },
-  srcCatalog,
-];
-
-describe("workspace file tree projection", () => {
-  it("orders directories before files, case-insensitively", () => {
-    const names = sortWorkspaceFileEntries(rootEntries).map((e) => e.name);
-    expect(names).toEqual(["Assets", "src", "app.ts", "README.md"]);
-  });
-
-  it("flattens only expanded, loaded directories", () => {
-    const collapsed = flattenWorkspaceFileTree({ rootId, catalogs });
-    expect(collapsed.rows.map((r) => r.name)).toEqual(["Assets", "src", "app.ts", "README.md"]);
-    const srcRow = collapsed.rows.find((r) => r.id === srcId)!;
-    expect(srcRow.expandable).toBe(true);
-    expect(srcRow.expanded).toBe(false);
-    expect(srcRow.childrenLoaded).toBe(true);
-    // The Assets directory has no loaded catalog yet.
-    expect(collapsed.rows.find((r) => r.id === assetsId)!.childrenLoaded).toBe(false);
-
-    const expanded = flattenWorkspaceFileTree({ rootId, catalogs, expandedIds: [srcId] });
-    const indexRow = expanded.rows.find((r) => r.name === "index.ts");
-    expect(indexRow?.depth).toBe(1);
-    expect(expanded.rows.find((r) => r.id === srcId)!.expanded).toBe(true);
-  });
-
-  it("reports and preserves the selection through the flatten", () => {
-    const view = flattenWorkspaceFileTree({ rootId, catalogs, selectedId: srcId });
-    expect(view.selectedId).toBe(srcId);
-    expect(view.rows[view.selectedIndex]!.id).toBe(srcId);
-    // A selection that is not visible collapses to none.
-    const gone = flattenWorkspaceFileTree({ rootId, catalogs, selectedId: fileId("ghost") });
-    expect(gone.selectedId).toBeNull();
-    expect(gone.selectedIndex).toBe(-1);
-  });
-
-  it("guards against a catalog cycle instead of looping forever", () => {
-    const loopId = fileId("loop");
-    const cyclic: WorkspaceFileTreeCatalog[] = [
-      {
-        directoryId: rootId,
-        entries: [
-          entry({
-            id: loopId,
-            name: "loop",
-            kind: "directory",
-            hasChildren: true,
-            relativePath: "loop",
-          }),
-        ],
-      },
-      {
-        directoryId: loopId,
-        entries: [
-          entry({
-            id: rootId,
-            parentId: loopId,
-            name: "back",
-            kind: "directory",
-            hasChildren: true,
-            relativePath: "loop/back",
-          }),
-        ],
-      },
-    ];
-    const view = flattenWorkspaceFileTree({
-      rootId,
-      catalogs: cyclic,
-      expandedIds: [loopId, rootId],
-    });
-    expect(view.truncated).toBe(true);
-    // The walk stops when it revisits the root rather than recursing endlessly.
-    expect(view.rows.length).toBeLessThan(5);
-  });
-
-  it("toggles expansion immutably", () => {
-    const source = new Set([srcId]);
-    const expanded = toggleWorkspaceFileExpansion(source, assetsId);
-    expect(expanded.has(assetsId)).toBe(true);
-    expect(source.has(assetsId)).toBe(false);
-    expect(toggleWorkspaceFileExpansion(expanded, srcId, false).has(srcId)).toBe(false);
-    expect(toggleWorkspaceFileExpansion(source, srcId).has(srcId)).toBe(false);
-  });
-
-  it("moves the selection and clamps at the ends", () => {
-    const rows = flattenWorkspaceFileTree({ rootId, catalogs }).rows;
-    const first = rows[0]!.id;
-    expect(moveWorkspaceFileSelection(rows, null, "down")).toBe(first);
-    expect(moveWorkspaceFileSelection(rows, first, "up")).toBe(first);
-    expect(moveWorkspaceFileSelection(rows, first, "down")).toBe(rows[1]!.id);
-    expect(moveWorkspaceFileSelection([], null, "down")).toBeNull();
-  });
-});