@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/workspace/migrations/__tests__/155-move-front-model-config-to-voice.test.ts

@@ -0,0 +1,102 @@
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { moveFrontModelConfigToVoiceMigration } from "../155-move-front-model-config-to-voice.js";
+
+function workspaceWith(config: unknown): string {
+  const dir = mkdtempSync(join(tmpdir(), "move-front-model-"));
+  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2));
+  return dir;
+}
+
+function readConfig(dir: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(dir, "config.json"), "utf8")) as Record<
+    string,
+    unknown
+  >;
+}
+
+describe("155-move-front-model-config-to-voice", () => {
+  test("moves liveVoice.frontModel under voice and leaves the rest of liveVoice", () => {
+    const dir = workspaceWith({
+      liveVoice: {
+        vad: { silenceThresholdMs: 900 },
+        frontModel: {
+          endpointDecisionTimeoutMs: 300,
+          progress: { idleIntervalMs: 4_000 },
+        },
+      },
+    });
+
+    moveFrontModelConfigToVoiceMigration.run(dir);
+
+    expect(readConfig(dir)).toEqual({
+      liveVoice: { vad: { silenceThresholdMs: 900 } },
+      voice: {
+        frontModel: {
+          endpointDecisionTimeoutMs: 300,
+          progress: { idleIntervalMs: 4_000 },
+        },
+      },
+    });
+  });
+
+  test("an existing voice.frontModel wins field by field", () => {
+    const dir = workspaceWith({
+      liveVoice: {
+        frontModel: {
+          endpointDecisionTimeoutMs: 300,
+          endpointMaxExtensions: 1,
+          progress: { idleIntervalMs: 4_000, minGapMs: 2_000 },
+        },
+      },
+      voice: {
+        frontModel: {
+          endpointDecisionTimeoutMs: 800,
+          progress: { idleIntervalMs: 7_000 },
+        },
+      },
+    });
+
+    moveFrontModelConfigToVoiceMigration.run(dir);
+
+    expect(readConfig(dir)).toEqual({
+      liveVoice: {},
+      voice: {
+        frontModel: {
+          endpointDecisionTimeoutMs: 800,
+          endpointMaxExtensions: 1,
+          progress: { idleIntervalMs: 7_000, minGapMs: 2_000 },
+        },
+      },
+    });
+  });
+
+  test("a config without the old key is left untouched", () => {
+    const dir = workspaceWith({ liveVoice: { archiveAudio: true } });
+    const before = readFileSync(join(dir, "config.json"), "utf8");
+
+    moveFrontModelConfigToVoiceMigration.run(dir);
+
+    expect(readFileSync(join(dir, "config.json"), "utf8")).toBe(before);
+  });
+
+  test("is idempotent", () => {
+    const dir = workspaceWith({
+      liveVoice: { frontModel: { endpointExtensionMs: 2_000 } },
+    });
+
+    moveFrontModelConfigToVoiceMigration.run(dir);
+    const once = readConfig(dir);
+    moveFrontModelConfigToVoiceMigration.run(dir);
+
+    expect(readConfig(dir)).toEqual(once);
+  });
+
+  test("a missing config file is a no-op", () => {
+    const dir = mkdtempSync(join(tmpdir(), "move-front-model-empty-"));
+    expect(() => moveFrontModelConfigToVoiceMigration.run(dir)).not.toThrow();
+  });
+});

package/src/workspace/migrations/__tests__/156-extract-workspace-mcp-json.test.ts

@@ -0,0 +1,199 @@
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { extractWorkspaceMcpJsonMigration } from "../156-extract-workspace-mcp-json.js";
+import { WORKSPACE_MIGRATIONS } from "../registry.js";
+
+const MIGRATION_156_SCHEMA_URL =
+  "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+
+function workspaceWith(config: unknown): string {
+  const dir = mkdtempSync(join(tmpdir(), "extract-workspace-mcp-"));
+  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2));
+  return dir;
+}
+
+function readJson(dir: string, name: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(dir, name), "utf8")) as Record<
+    string,
+    unknown
+  >;
+}
+
+describe("156-extract-workspace-mcp-json", () => {
+  test("has the next migration id and is registered last", () => {
+    expect(extractWorkspaceMcpJsonMigration.id).toBe(
+      "156-extract-workspace-mcp-json",
+    );
+    expect(WORKSPACE_MIGRATIONS.at(-1)?.id).toBe(
+      "156-extract-workspace-mcp-json",
+    );
+  });
+
+  test("moves servers into a spec-pure mcp.json and drops mcp from config", () => {
+    const dir = workspaceWith({
+      llm: { activeProfile: "balanced" },
+      mcp: {
+        servers: {
+          remote: {
+            transport: {
+              type: "streamable-http",
+              url: "https://example.com/mcp",
+            },
+          },
+          local: {
+            transport: {
+              type: "stdio",
+              command: "npx",
+              args: ["-y", "srv"],
+              env: { DATA_DIR: "/tmp" },
+            },
+          },
+        },
+      },
+    });
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readJson(dir, "config.json")).toEqual({
+      llm: { activeProfile: "balanced" },
+    });
+    expect(readJson(dir, "mcp.json")).toEqual({
+      $schema: MIGRATION_156_SCHEMA_URL,
+      mcpServers: {
+        remote: {
+          type: "streamable-http",
+          url: "https://example.com/mcp",
+        },
+        local: {
+          type: "stdio",
+          command: "npx",
+          args: ["-y", "srv"],
+          env: { DATA_DIR: "/tmp" },
+        },
+      },
+    });
+  });
+
+  test("copies leftover transport headers onto the spec entry", () => {
+    const dir = workspaceWith({
+      mcp: {
+        servers: {
+          remote: {
+            transport: {
+              type: "sse",
+              url: "https://example.com/sse",
+              headers: { Authorization: "Bearer leftover" },
+            },
+          },
+        },
+      },
+    });
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readJson(dir, "mcp.json")).toEqual({
+      $schema: MIGRATION_156_SCHEMA_URL,
+      mcpServers: {
+        remote: {
+          type: "sse",
+          url: "https://example.com/sse",
+          headers: { Authorization: "Bearer leftover" },
+        },
+      },
+    });
+  });
+
+  test("keeps existing mcp.json ids and fills only the missing ones", () => {
+    const dir = workspaceWith({
+      mcp: {
+        servers: {
+          fromConfig: {
+            transport: {
+              type: "streamable-http",
+              url: "https://config.example/mcp",
+            },
+          },
+          shared: {
+            transport: {
+              type: "streamable-http",
+              url: "https://config-loses.example/mcp",
+            },
+          },
+        },
+      },
+    });
+    writeFileSync(
+      join(dir, "mcp.json"),
+      JSON.stringify({
+        $schema: MIGRATION_156_SCHEMA_URL,
+        mcpServers: {
+          shared: {
+            type: "streamable-http",
+            url: "https://file-wins.example/mcp",
+          },
+        },
+      }),
+    );
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readJson(dir, "mcp.json")).toEqual({
+      $schema: MIGRATION_156_SCHEMA_URL,
+      mcpServers: {
+        fromConfig: {
+          type: "streamable-http",
+          url: "https://config.example/mcp",
+        },
+        shared: {
+          type: "streamable-http",
+          url: "https://file-wins.example/mcp",
+        },
+      },
+    });
+    expect(readJson(dir, "config.json")).toEqual({});
+  });
+
+  test("extracts a leftover array of servers", () => {
+    const dir = workspaceWith({
+      mcp: {
+        servers: [
+          {
+            name: "legacy",
+            transport: { type: "sse", url: "https://example.com/sse" },
+          },
+        ],
+      },
+    });
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readJson(dir, "mcp.json")).toEqual({
+      $schema: MIGRATION_156_SCHEMA_URL,
+      mcpServers: {
+        legacy: { type: "sse", url: "https://example.com/sse" },
+      },
+    });
+  });
+
+  test("is a no-op when mcp is already gone", () => {
+    const dir = workspaceWith({ llm: {} });
+    const before = readFileSync(join(dir, "config.json"), "utf8");
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readFileSync(join(dir, "config.json"), "utf8")).toBe(before);
+    expect(existsSync(join(dir, "mcp.json"))).toBe(false);
+  });
+
+  test("drops an empty mcp key without creating mcp.json", () => {
+    const dir = workspaceWith({ mcp: { servers: {} } });
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readJson(dir, "config.json")).toEqual({});
+    expect(existsSync(join(dir, "mcp.json"))).toBe(false);
+  });
+});

package/src/workspace/migrations/registry.ts

@@ -151,6 +151,9 @@ import { sttFluxProviderToModelFamilyMigration } from "./150-stt-flux-provider-t
 import { repairRenamedFireworksDeepseekProModelIdMigration } from "./151-repair-renamed-fireworks-deepseek-pro-model-id.js";
 import { repairRetiredFireworksMinimaxM2p7ModelIdMigration } from "./152-repair-retired-fireworks-minimax-m2p7-model-id.js";
 import { stripMcpPolicyFieldsMigration } from "./153-strip-mcp-policy-fields.js";
+import { repairRetiredCodexGpt54ModelIdsMigration } from "./154-repair-retired-codex-gpt-5-4-model-ids.js";
+import { moveFrontModelConfigToVoiceMigration } from "./155-move-front-model-config-to-voice.js";
+import { extractWorkspaceMcpJsonMigration } from "./156-extract-workspace-mcp-json.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -317,4 +320,7 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   repairRenamedFireworksDeepseekProModelIdMigration,
   repairRetiredFireworksMinimaxM2p7ModelIdMigration,
   stripMcpPolicyFieldsMigration,
+  repairRetiredCodexGpt54ModelIdsMigration,
+  moveFrontModelConfigToVoiceMigration,
+  extractWorkspaceMcpJsonMigration,
 ];

package/src/__tests__/app-source-watcher.test.ts

@@ -1,218 +0,0 @@
-/**
- * Tests for AppSourceWatcher — filesystem watcher that detects app source
- * file changes and triggers debounced recompile + surface refresh.
- */
-
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mocks — must be set up before importing the module under test
-// ---------------------------------------------------------------------------
-
-const TEST_APPS_DIR = "/tmp/test-apps";
-const testDirNameMap = new Map<string, string>([["my-app", "app-id-1"]]);
-
-let capturedWatchCallback:
-  | ((eventType: string, filename: string | null) => void)
-  | null = null;
-let capturedErrorHandler: ((err: unknown) => void) | null = null;
-const mockWatcher = {
-  close: mock(() => {}),
-  on: mock((event: string, handler: (err: unknown) => void) => {
-    if (event === "error") {
-      capturedErrorHandler = handler;
-    }
-  }),
-};
-const mockExistsSync = mock((p: string): boolean => p === TEST_APPS_DIR);
-const mockWatch = mock(
-  (
-    _path: string,
-    _opts: Record<string, unknown>,
-    callback: (eventType: string, filename: string | null) => void,
-  ) => {
-    capturedWatchCallback = callback;
-    return mockWatcher;
-  },
-);
-
-mock.module("node:fs", () => {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const actualFs = require("node:fs");
-  return {
-    ...actualFs,
-    existsSync: mockExistsSync,
-    watch: mockWatch,
-  };
-});
-
-mock.module("../apps/app-store.js", () => ({
-  getAppsDir: mock(() => TEST_APPS_DIR),
-  resolveAppIdByDirName: mock(
-    (dirName: string) => testDirNameMap.get(dirName) ?? null,
-  ),
-}));
-
-// ---------------------------------------------------------------------------
-// Import after mocks
-// ---------------------------------------------------------------------------
-
-import { AppSourceWatcher } from "../daemon/app-source-watcher.js";
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("AppSourceWatcher", () => {
-  let watcher: AppSourceWatcher;
-  let onChangeSpy: ReturnType<typeof mock>;
-
-  beforeEach(() => {
-    watcher = new AppSourceWatcher();
-    onChangeSpy = mock(() => {});
-    capturedWatchCallback = null;
-    capturedErrorHandler = null;
-    mockWatcher.close.mockClear();
-    mockWatcher.on.mockClear();
-    // Reset existsSync to default behavior for each test
-    mockExistsSync.mockImplementation((p: string) => p === TEST_APPS_DIR);
-  });
-
-  afterEach(() => {
-    watcher.stop();
-  });
-
-  test("start() creates a recursive watcher on the apps directory", () => {
-    watcher.start(onChangeSpy);
-    expect(capturedWatchCallback).not.toBeNull();
-  });
-
-  test("source file change triggers callback with resolved appId", async () => {
-    watcher.start(onChangeSpy);
-    capturedWatchCallback!("change", "my-app/src/main.tsx");
-
-    // Wait for debounce (500ms + margin)
-    await new Promise((r) => setTimeout(r, 600));
-    expect(onChangeSpy).toHaveBeenCalledTimes(1);
-    expect(onChangeSpy).toHaveBeenCalledWith("app-id-1");
-  });
-
-  test("root-level app file triggers callback", async () => {
-    watcher.start(onChangeSpy);
-    capturedWatchCallback!("change", "my-app/index.html");
-
-    await new Promise((r) => setTimeout(r, 600));
-    expect(onChangeSpy).toHaveBeenCalledTimes(1);
-    expect(onChangeSpy).toHaveBeenCalledWith("app-id-1");
-  });
-
-  test("dist/ files are filtered out", async () => {
-    watcher.start(onChangeSpy);
-    capturedWatchCallback!("change", "my-app/dist/index.html");
-
-    await new Promise((r) => setTimeout(r, 600));
-    expect(onChangeSpy).not.toHaveBeenCalled();
-  });
-
-  test("records/ files are filtered out", async () => {
-    watcher.start(onChangeSpy);
-    capturedWatchCallback!("change", "my-app/records/rec-1.json");
-
-    await new Promise((r) => setTimeout(r, 600));
-    expect(onChangeSpy).not.toHaveBeenCalled();
-  });
-
-  test(".git/ files are filtered out (apps-directory git repo churn)", async () => {
-    watcher.start(onChangeSpy);
-    capturedWatchCallback!("change", ".git/objects/ab/cdef");
-    capturedWatchCallback!("change", ".git/index");
-    capturedWatchCallback!("change", ".git/refs/heads/main");
-    capturedWatchCallback!("change", ".git/logs/HEAD");
-
-    await new Promise((r) => setTimeout(r, 600));
-    expect(onChangeSpy).not.toHaveBeenCalled();
-  });
-
-  test("files directly in apps/ (no subdirectory) are filtered out", async () => {
-    watcher.start(onChangeSpy);
-    capturedWatchCallback!("change", "my-app.json");
-
-    await new Promise((r) => setTimeout(r, 600));
-    expect(onChangeSpy).not.toHaveBeenCalled();
-  });
-
-  test("unknown app directory is filtered out", async () => {
-    watcher.start(onChangeSpy);
-    capturedWatchCallback!("change", "unknown-app/src/main.tsx");
-
-    await new Promise((r) => setTimeout(r, 600));
-    expect(onChangeSpy).not.toHaveBeenCalled();
-  });
-
-  test("null filename is ignored", async () => {
-    watcher.start(onChangeSpy);
-    capturedWatchCallback!("change", null);
-
-    await new Promise((r) => setTimeout(r, 600));
-    expect(onChangeSpy).not.toHaveBeenCalled();
-  });
-
-  test("rapid changes to same app are debounced into single callback", async () => {
-    watcher.start(onChangeSpy);
-
-    capturedWatchCallback!("change", "my-app/src/main.tsx");
-    capturedWatchCallback!("change", "my-app/src/styles.css");
-    capturedWatchCallback!("change", "my-app/src/utils.ts");
-
-    await new Promise((r) => setTimeout(r, 600));
-    expect(onChangeSpy).toHaveBeenCalledTimes(1);
-  });
-
-  test("stop() closes watcher and cancels pending timers", () => {
-    watcher.start(onChangeSpy);
-    capturedWatchCallback!("change", "my-app/src/main.tsx");
-
-    watcher.stop();
-
-    expect(mockWatcher.close).toHaveBeenCalledTimes(1);
-  });
-
-  test("ensureStarted() initializes watcher after apps directory is created", () => {
-    // Simulate apps dir not existing at start time
-    mockExistsSync.mockImplementation((_p: string) => false);
-
-    watcher.start(onChangeSpy);
-    expect(capturedWatchCallback).toBeNull(); // watcher didn't start
-
-    // Simulate apps dir now existing (e.g. after app_create)
-    mockExistsSync.mockImplementation((p: string) => p === TEST_APPS_DIR);
-
-    watcher.ensureStarted();
-    expect(capturedWatchCallback).not.toBeNull(); // watcher started
-  });
-
-  test("ensureStarted() is a no-op when watcher is already running", () => {
-    watcher.start(onChangeSpy);
-    const callCountAfterStart = mockWatch.mock.calls.length;
-
-    watcher.ensureStarted();
-    expect(mockWatch.mock.calls.length).toBe(callCountAfterStart); // no extra watch call
-  });
-
-  /**
-   * REGRESSION: a recursive watch over a large app tree (node_modules) can
-   * exhaust the inotify watch limit and emit ENOSPC asynchronously as an
-   * 'error' event. Without an 'error' listener that rethrows as an
-   * uncaughtException and crashes the daemon. The watcher must swallow it.
-   */
-  test("attaches an 'error' handler that does not rethrow on async ENOSPC", () => {
-    watcher.start(onChangeSpy);
-
-    expect(capturedErrorHandler).not.toBeNull();
-    const enospc = Object.assign(
-      new Error("ENOSPC: no space left on device, watch"),
-      { code: "ENOSPC", errno: -28, syscall: "watch" },
-    );
-    expect(() => capturedErrorHandler!(enospc)).not.toThrow();
-  });
-});