@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/__tests__/mcp-config-secret-boundary.test.ts

@@ -1,4 +1,4 @@
-import { mkdirSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { readFileSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -14,6 +14,14 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string, maxLen = 500) => value.slice(0, maxLen),
 }));
 
+// The config routes under test read and write the workspace config.json via
+// the real loader (`loadRawConfig`/`saveRawConfig`). Tests seed the raw file
+// directly (the fixtures are raw-file shapes, including deliberately
+// malformed trees, so the whole file is replaced rather than composed via
+// `setConfig`) and detect commits by comparing the on-disk text against the
+// seeded snapshot — `saveRawConfig` pretty-prints, so any commit changes the
+// text.
+let rawConfig: Record<string, unknown> = {};
 let seededRawText = "";
 let mtimeSeq = 0;
 
@@ -21,23 +29,19 @@ function configJsonPath(): string {
   return join(process.env.VELLUM_WORKSPACE_DIR!, "config.json");
 }
 
-function mcpJsonPath(): string {
-  return join(process.env.VELLUM_WORKSPACE_DIR!, "mcp.json");
-}
-
+/** Write `raw` to the workspace config.json as the seeded pre-test state. */
 function seedRawConfig(raw: Record<string, unknown>): void {
+  rawConfig = raw;
   seededRawText = JSON.stringify(raw);
-  mkdirSync(process.env.VELLUM_WORKSPACE_DIR!, { recursive: true });
   writeFileSync(configJsonPath(), seededRawText);
+  // Distinct mtime per write so the loader's file-signature cache can never
+  // read two consecutive seeds as identical.
   mtimeSeq += 1;
   const stamp = new Date(Date.now() + mtimeSeq);
   utimesSync(configJsonPath(), stamp, stamp);
 }
 
-function seedWorkspaceMcp(document: unknown): void {
-  writeFileSync(mcpJsonPath(), JSON.stringify(document, null, 2) + "\n");
-}
-
+/** The raw config a route commit persisted, or null when nothing was saved. */
 function committedRaw(): Record<string, unknown> | null {
   const text = readFileSync(configJsonPath(), "utf8");
   if (text === seededRawText) {
@@ -115,6 +119,11 @@ const configGetRoute = findRoute("config_get");
 const configPatchRoute = findRoute("config_patch");
 const configSetRoute = findRoute("config_set");
 
+/**
+ * Config responses inject the code-catalog default profiles into
+ * `llm.profiles` (the effective wire view). These tests pin the MCP secret
+ * boundary, so drop the injected block before whole-response comparisons.
+ */
 function withoutWireProfiles(
   result: Record<string, unknown>,
 ): Record<string, unknown> {
@@ -125,18 +134,21 @@ function withoutWireProfiles(
 describe("MCP config secret boundary", () => {
   beforeEach(() => {
     seedRawConfig({});
-    rmSync(mcpJsonPath(), { force: true });
   });
 
-  test("config_get omits MCP headers from the mcp.json overlay", () => {
-    seedWorkspaceMcp({
-      mcpServers: {
-        remote: {
-          type: "streamable-http",
-          url: "https://mcp.example.com",
-          headers: {
-            Authorization: "Bearer mcp-secret",
-            "X-API-Key": "mcp-api-secret",
+  test("config_get omits legacy MCP transport headers from settings-read responses", () => {
+    seedRawConfig({
+      mcp: {
+        servers: {
+          remote: {
+            transport: {
+              type: "streamable-http",
+              url: "https://mcp.example.com",
+              headers: {
+                Authorization: "Bearer mcp-secret",
+                "X-API-Key": "mcp-api-secret",
+              },
+            },
           },
         },
       },
@@ -155,61 +167,64 @@ describe("MCP config secret boundary", () => {
     });
   });
 
-  test("config_get ignores leftover config.json mcp so its headers cannot leak", () => {
+  test("config_get omits headers inside malformed MCP server trees", () => {
     seedRawConfig({
       mcp: {
-        servers: {
-          remote: {
+        servers: [
+          {
             transport: {
-              type: "streamable-http",
-              url: "https://mcp.example.com",
-              headers: { Authorization: "Bearer leftover-secret" },
+              headers: { Authorization: "Bearer malformed-secret" },
             },
           },
-        },
+        ],
       },
     });
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(JSON.stringify(result)).not.toContain("leftover-secret");
-    expect(
-      (result.mcp as { servers: Record<string, unknown> }).servers,
-    ).toEqual({});
+    expect(JSON.stringify(result)).not.toContain("malformed-secret");
+    expect(withoutWireProfiles(result)).toEqual({
+      mcp: {
+        servers: [
+          {
+            transport: {},
+          },
+        ],
+      },
+    });
   });
 
   test("config_get preserves an MCP server named headers", () => {
-    seedWorkspaceMcp({
-      mcpServers: {
-        headers: {
-          type: "streamable-http",
-          url: "https://mcp.example.com",
+    seedRawConfig({
+      mcp: {
+        servers: {
+          headers: {
+            transport: {
+              type: "streamable-http",
+              url: "https://mcp.example.com",
+            },
+          },
         },
       },
     });
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(withoutWireProfiles(result).mcp).toEqual({
-      servers: {
-        headers: {
-          transport: {
-            type: "streamable-http",
-            url: "https://mcp.example.com",
-          },
-        },
-      },
-    });
+    expect(withoutWireProfiles(result)).toEqual(rawConfig);
   });
 
   test("config_get preserves non-credential headers env vars", () => {
-    seedWorkspaceMcp({
-      mcpServers: {
-        local: {
-          type: "stdio",
-          command: "npx",
-          env: {
-            headers: "not-a-transport-header",
+    seedRawConfig({
+      mcp: {
+        servers: {
+          local: {
+            transport: {
+              type: "stdio",
+              command: "npx",
+              env: {
+                headers: "not-a-transport-header",
+              },
+            },
           },
         },
       },
@@ -217,20 +232,7 @@ describe("MCP config secret boundary", () => {
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(withoutWireProfiles(result).mcp).toEqual({
-      servers: {
-        local: {
-          transport: {
-            type: "stdio",
-            command: "npx",
-            args: [],
-            env: {
-              headers: "not-a-transport-header",
-            },
-          },
-        },
-      },
-    });
+    expect(withoutWireProfiles(result)).toEqual(rawConfig);
   });
 
   test("config_patch rejects MCP transport headers so generic writes cannot reintroduce plaintext credentials", async () => {
@@ -254,7 +256,7 @@ describe("MCP config secret boundary", () => {
     expect(committedRaw()).toBeNull();
   });
 
-  test("config_patch strips mcp so a full-config round trip cannot write it back", async () => {
+  test("config_patch allows an MCP server named headers when its value has no header credentials", async () => {
     const result = await configPatchRoute.handler({
       body: {
         mcp: {
@@ -270,25 +272,68 @@ describe("MCP config secret boundary", () => {
       },
     });
 
-    expect(committedRaw()?.mcp).toBeUndefined();
-    expect(
-      (result as { mcp: { servers: Record<string, unknown> } }).mcp.servers,
-    ).toEqual({});
+    expect(withoutWireProfiles(result as Record<string, unknown>)).toEqual({
+      mcp: {
+        servers: {
+          headers: {
+            transport: {
+              type: "streamable-http",
+              url: "https://mcp.example.com",
+            },
+          },
+        },
+      },
+    });
+  });
+
+  test("config_patch allows non-credential headers env vars", async () => {
+    const result = await configPatchRoute.handler({
+      body: {
+        mcp: {
+          servers: {
+            local: {
+              transport: {
+                type: "stdio",
+                command: "npx",
+                env: {
+                  headers: "not-a-transport-header",
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    expect(withoutWireProfiles(result as Record<string, unknown>)).toEqual({
+      mcp: {
+        servers: {
+          local: {
+            transport: {
+              type: "stdio",
+              command: "npx",
+              env: {
+                headers: "not-a-transport-header",
+              },
+            },
+          },
+        },
+      },
+    });
   });
 
-  test("config_set rejects MCP server writes", async () => {
+  test("config_set rejects malformed MCP server trees containing headers", async () => {
     await expect(
       configSetRoute.handler({
         body: {
           path: "mcp.servers",
-          value: {
-            remote: {
+          value: [
+            {
               transport: {
-                type: "streamable-http",
-                url: "https://mcp.example.com",
+                headers: { Authorization: "Bearer malformed-secret" },
               },
             },
-          },
+          ],
         },
       }),
     ).rejects.toThrow(BadRequestError);
@@ -296,6 +341,19 @@ describe("MCP config secret boundary", () => {
   });
 
   test("config_set rejects direct MCP transport header paths", async () => {
+    seedRawConfig({
+      mcp: {
+        servers: {
+          remote: {
+            transport: {
+              type: "streamable-http",
+              url: "https://mcp.example.com",
+            },
+          },
+        },
+      },
+    });
+
     await expect(
       configSetRoute.handler({
         body: {

package/src/__tests__/mcp-health-check.test.ts

@@ -18,14 +18,17 @@ mock.module("../mcp/client.js", () => ({
   },
 }));
 
-import { setWorkspaceMcp } from "./helpers/set-workspace-mcp.js";
-
-// Seed the MCP server the list route reads from workspace mcp.json.
-setWorkspaceMcp({
-  test: {
-    transport: {
-      type: "streamable-http",
-      url: "https://example.com/mcp",
+import { setConfig } from "./helpers/set-config.js";
+
+// Seed the MCP server the list route reads via `loadRawConfig()` into the
+// workspace config for real.
+setConfig("mcp", {
+  servers: {
+    test: {
+      transport: {
+        type: "streamable-http",
+        url: "https://example.com/mcp",
+      },
     },
   },
 });

package/src/__tests__/mcp-list-plugin-servers.test.ts

@@ -68,15 +68,17 @@ mock.module("../daemon/mcp-reload-service.js", () => ({
   reloadMcpServers: async () => {},
 }));
 
-import { setWorkspaceMcp } from "./helpers/set-workspace-mcp.js";
+import { setConfig } from "./helpers/set-config.js";
 
-setWorkspaceMcp({
-  "from-workspace": {
-    transport: { type: "streamable-http", url: "https://config.example/mcp" },
-  },
-  // Deliberately shares an id with the `shadowed` plugin below.
-  shadowed: {
-    transport: { type: "streamable-http", url: "https://wins.example/mcp" },
+setConfig("mcp", {
+  servers: {
+    "from-workspace": {
+      transport: { type: "streamable-http", url: "https://config.example/mcp" },
+    },
+    // Deliberately shares an id with the `shadowed` plugin below.
+    shadowed: {
+      transport: { type: "streamable-http", url: "https://wins.example/mcp" },
+    },
   },
 });
 

package/src/{calls/__tests__ → __tests__}/media-stream-audio-transcode.test.ts

@@ -4,7 +4,7 @@ import {
   mulawToPcm16,
   pcm16ToMulaw,
   resamplePcm16,
-} from "../media-stream-audio-transcode.js";
+} from "../calls/media-stream-audio-transcode.js";
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/{calls/__tests__ → __tests__}/media-stream-output.test.ts

@@ -12,7 +12,7 @@ const mockProvider = {
   synthesize: mockSynthesize,
 };
 
-mock.module("../resolve-call-tts-provider.js", () => ({
+mock.module("../calls/resolve-call-tts-provider.js", () => ({
   resolveCallTtsProvider: jest.fn(() => ({
     provider: mockProvider,
     useSynthesizedPath: false,
@@ -20,10 +20,13 @@ mock.module("../resolve-call-tts-provider.js", () => ({
   })),
 }));
 
-import { setConfig } from "../../__tests__/helpers/set-config.js";
-import { mulawToPcm16, pcm16ToMulaw } from "../media-stream-audio-transcode.js";
-import { MediaStreamOutput } from "../media-stream-output.js";
-import { resolveCallTtsProvider } from "../resolve-call-tts-provider.js";
+import {
+  mulawToPcm16,
+  pcm16ToMulaw,
+} from "../calls/media-stream-audio-transcode.js";
+import { MediaStreamOutput } from "../calls/media-stream-output.js";
+import { resolveCallTtsProvider } from "../calls/resolve-call-tts-provider.js";
+import { setConfig } from "./helpers/set-config.js";
 
 const mockResolveCallTtsProvider = resolveCallTtsProvider as ReturnType<
   typeof jest.fn
@@ -854,38 +857,6 @@ describe("MediaStreamOutput", () => {
       // Initially empty
       expect(output.getPlaybackQueueLength()).toBe(0);
     });
-
-    test("isPlaybackIdle tracks buffered text, the queue, and the sent-audio tail", async () => {
-      const samples = Array.from({ length: 4000 }, (_, i) =>
-        Math.round(Math.sin(i * 0.1) * 10000),
-      );
-      mockSynthesize.mockResolvedValue({
-        audio: makeWavBuffer(samples),
-        contentType: "audio/wav",
-      });
-
-      const { ws, sent } = createMockWs();
-      const output = makeOutput(ws, "stream-1");
-      expect(output.isPlaybackIdle()).toBe(true);
-      expect(output.playbackTailUntilMs()).toBe(0);
-
-      // Text buffered toward a sentence boundary is pending speech.
-      output.sendTextToken("Still thinking", false);
-      expect(output.isPlaybackIdle()).toBe(false);
-
-      output.sendTextToken(" about it.", true);
-      await drain(() => countEvents(sent, "mark") > 0);
-
-      // Frames left faster than real time: the tail estimate still covers
-      // the audio Twilio is playing out.
-      expect(output.playbackTailUntilMs()).toBeGreaterThan(Date.now());
-      expect(output.isPlaybackIdle()).toBe(false);
-
-      // A barge-in clear drops Twilio's buffer, so nothing is audible.
-      output.clearAudio();
-      expect(output.playbackTailUntilMs()).toBe(0);
-      expect(output.isPlaybackIdle()).toBe(true);
-    });
   });
 
   // ---------------------------------------------------------------------------

package/src/{calls/__tests__ → __tests__}/media-stream-parser.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { parseMediaStreamFrame } from "../media-stream-parser.js";
+import { parseMediaStreamFrame } from "../calls/media-stream-parser.js";
 
 // ---------------------------------------------------------------------------
 // Fixture factories