@vellumai/assistant 0.12.0 → 0.12.1-dev.202609141913.5e16607

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

@@ -1,4 +1,4 @@
-import { readFileSync, utimesSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -14,14 +14,6 @@ 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;
 
@@ -29,19 +21,23 @@ function configJsonPath(): string {
   return join(process.env.VELLUM_WORKSPACE_DIR!, "config.json");
 }
 
-/** Write `raw` to the workspace config.json as the seeded pre-test state. */
+function mcpJsonPath(): string {
+  return join(process.env.VELLUM_WORKSPACE_DIR!, "mcp.json");
+}
+
 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);
 }
 
-/** The raw config a route commit persisted, or null when nothing was saved. */
+function seedWorkspaceMcp(document: unknown): void {
+  writeFileSync(mcpJsonPath(), JSON.stringify(document, null, 2) + "\n");
+}
+
 function committedRaw(): Record<string, unknown> | null {
   const text = readFileSync(configJsonPath(), "utf8");
   if (text === seededRawText) {
@@ -119,11 +115,6 @@ 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> {
@@ -134,21 +125,18 @@ function withoutWireProfiles(
 describe("MCP config secret boundary", () => {
   beforeEach(() => {
     seedRawConfig({});
+    rmSync(mcpJsonPath(), { force: true });
   });
 
-  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",
-              },
-            },
+  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",
           },
         },
       },
@@ -167,64 +155,61 @@ describe("MCP config secret boundary", () => {
     });
   });
 
-  test("config_get omits headers inside malformed MCP server trees", () => {
+  test("config_get ignores leftover config.json mcp so its headers cannot leak", () => {
     seedRawConfig({
       mcp: {
-        servers: [
-          {
+        servers: {
+          remote: {
             transport: {
-              headers: { Authorization: "Bearer malformed-secret" },
+              type: "streamable-http",
+              url: "https://mcp.example.com",
+              headers: { Authorization: "Bearer leftover-secret" },
             },
           },
-        ],
+        },
       },
     });
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(JSON.stringify(result)).not.toContain("malformed-secret");
-    expect(withoutWireProfiles(result)).toEqual({
-      mcp: {
-        servers: [
-          {
-            transport: {},
-          },
-        ],
-      },
-    });
+    expect(JSON.stringify(result)).not.toContain("leftover-secret");
+    expect(
+      (result.mcp as { servers: Record<string, unknown> }).servers,
+    ).toEqual({});
   });
 
   test("config_get preserves an MCP server named headers", () => {
-    seedRawConfig({
-      mcp: {
-        servers: {
-          headers: {
-            transport: {
-              type: "streamable-http",
-              url: "https://mcp.example.com",
-            },
-          },
+    seedWorkspaceMcp({
+      mcpServers: {
+        headers: {
+          type: "streamable-http",
+          url: "https://mcp.example.com",
         },
       },
     });
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(withoutWireProfiles(result)).toEqual(rawConfig);
+    expect(withoutWireProfiles(result).mcp).toEqual({
+      servers: {
+        headers: {
+          transport: {
+            type: "streamable-http",
+            url: "https://mcp.example.com",
+          },
+        },
+      },
+    });
   });
 
   test("config_get preserves non-credential headers env vars", () => {
-    seedRawConfig({
-      mcp: {
-        servers: {
-          local: {
-            transport: {
-              type: "stdio",
-              command: "npx",
-              env: {
-                headers: "not-a-transport-header",
-              },
-            },
+    seedWorkspaceMcp({
+      mcpServers: {
+        local: {
+          type: "stdio",
+          command: "npx",
+          env: {
+            headers: "not-a-transport-header",
           },
         },
       },
@@ -232,7 +217,20 @@ describe("MCP config secret boundary", () => {
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(withoutWireProfiles(result)).toEqual(rawConfig);
+    expect(withoutWireProfiles(result).mcp).toEqual({
+      servers: {
+        local: {
+          transport: {
+            type: "stdio",
+            command: "npx",
+            args: [],
+            env: {
+              headers: "not-a-transport-header",
+            },
+          },
+        },
+      },
+    });
   });
 
   test("config_patch rejects MCP transport headers so generic writes cannot reintroduce plaintext credentials", async () => {
@@ -256,7 +254,7 @@ describe("MCP config secret boundary", () => {
     expect(committedRaw()).toBeNull();
   });
 
-  test("config_patch allows an MCP server named headers when its value has no header credentials", async () => {
+  test("config_patch strips mcp so a full-config round trip cannot write it back", async () => {
     const result = await configPatchRoute.handler({
       body: {
         mcp: {
@@ -272,68 +270,25 @@ describe("MCP config secret boundary", () => {
       },
     });
 
-    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",
-              },
-            },
-          },
-        },
-      },
-    });
+    expect(committedRaw()?.mcp).toBeUndefined();
+    expect(
+      (result as { mcp: { servers: Record<string, unknown> } }).mcp.servers,
+    ).toEqual({});
   });
 
-  test("config_set rejects malformed MCP server trees containing headers", async () => {
+  test("config_set rejects MCP server writes", async () => {
     await expect(
       configSetRoute.handler({
         body: {
           path: "mcp.servers",
-          value: [
-            {
+          value: {
+            remote: {
               transport: {
-                headers: { Authorization: "Bearer malformed-secret" },
+                type: "streamable-http",
+                url: "https://mcp.example.com",
               },
             },
-          ],
+          },
         },
       }),
     ).rejects.toThrow(BadRequestError);
@@ -341,19 +296,6 @@ 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,17 +18,14 @@ mock.module("../mcp/client.js", () => ({
   },
 }));
 
-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",
-      },
+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",
     },
   },
 });

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

@@ -68,17 +68,15 @@ mock.module("../daemon/mcp-reload-service.js", () => ({
   reloadMcpServers: async () => {},
 }));
 
-import { setConfig } from "./helpers/set-config.js";
+import { setWorkspaceMcp } from "./helpers/set-workspace-mcp.js";
 
-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" },
-    },
+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" },
   },
 });
 

package/src/__tests__/message-deleted-hook-dispatch.test.ts

@@ -0,0 +1,119 @@
+/**
+ * The `message-deleted` hook is dispatched by every primitive that removes
+ * individual message rows, carrying each row's `(createdAt, id)`, so a plugin
+ * keeping a cursor on a row learns where it sat once the row is gone.
+ * DB-backed: exercises the real delete primitives against the test database.
+ */
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { registerPluginHooks } from "../hooks/registry.js";
+import type { MessageDeletedContext } from "../hooks/types.js";
+import {
+  addMessage,
+  deleteLastExchange,
+  deleteMessageById,
+  getMessages,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { conversations, messages } from "../persistence/schema/index.js";
+import type { PluginHooks } from "../plugins/types.js";
+
+await initializeDb();
+
+const CONV_ID = "conv-message-deleted-hook";
+
+const received: Array<{
+  conversationId: string;
+  messageId: string;
+  createdAt: number;
+}> = [];
+registerPluginHooks("test-message-deleted-spy", {
+  "message-deleted": async (ctx: MessageDeletedContext) => {
+    received.push({
+      conversationId: ctx.conversationId,
+      messageId: ctx.messageId,
+      createdAt: ctx.createdAt,
+    });
+  },
+} as PluginHooks);
+
+/** Poll until the fire-and-forget hook chain has delivered `count` calls. */
+async function waitForCalls(count: number): Promise<void> {
+  const deadline = Date.now() + 2_000;
+  while (received.length < count && Date.now() < deadline) {
+    await Bun.sleep(10);
+  }
+}
+
+const text = (t: string) => JSON.stringify([{ type: "text", text: t }]);
+
+beforeEach(() => {
+  received.length = 0;
+  getDb().delete(messages).run();
+  getDb().delete(conversations).run();
+  const now = Date.now();
+  getDb()
+    .insert(conversations)
+    .values({
+      id: CONV_ID,
+      title: "message-deleted hook",
+      createdAt: now,
+      updatedAt: now,
+      source: "test",
+      conversationType: "standard",
+    })
+    .run();
+});
+
+describe("message-deleted hook dispatch", () => {
+  test("deleteMessageById dispatches once with the row's position", async () => {
+    await addMessage(CONV_ID, "user", text("hello"));
+    const reply = await addMessage(CONV_ID, "assistant", text("hi"));
+    const replyCreatedAt = getMessages(CONV_ID).find(
+      (m) => m.id === reply.id,
+    )!.createdAt;
+
+    deleteMessageById(reply.id);
+    await waitForCalls(1);
+
+    expect(received).toEqual([
+      {
+        conversationId: CONV_ID,
+        messageId: reply.id,
+        createdAt: replyCreatedAt,
+      },
+    ]);
+  });
+
+  test("deleteLastExchange dispatches for every row of the undone tail", async () => {
+    await addMessage(CONV_ID, "user", text("first"));
+    await addMessage(CONV_ID, "assistant", text("one"));
+    const user2 = await addMessage(CONV_ID, "user", text("second"));
+    const reply2 = await addMessage(CONV_ID, "assistant", text("two"));
+    const byId = new Map(getMessages(CONV_ID).map((m) => [m.id, m.createdAt]));
+
+    expect(deleteLastExchange(CONV_ID)).toBe(2);
+    await waitForCalls(2);
+
+    expect([...received].sort((a, b) => a.createdAt - b.createdAt)).toEqual([
+      {
+        conversationId: CONV_ID,
+        messageId: user2.id,
+        createdAt: byId.get(user2.id)!,
+      },
+      {
+        conversationId: CONV_ID,
+        messageId: reply2.id,
+        createdAt: byId.get(reply2.id)!,
+      },
+    ]);
+  });
+
+  test("a delete of a missing row dispatches nothing", async () => {
+    deleteMessageById("no-such-row");
+    await Bun.sleep(50);
+
+    expect(received).toEqual([]);
+  });
+});

package/src/__tests__/messages-after-tiebreaker.test.ts

@@ -1,11 +1,14 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import { eq } from "drizzle-orm";
+
 import {
   countMessagesAfter,
   getMessagesAfter,
 } from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { resolveMessagesAfterBound } from "../persistence/message-cursor.js";
 import { conversations, messages } from "../persistence/schema/index.js";
 
 await initializeDb();
@@ -113,3 +116,91 @@ describe("countMessagesAfter / getMessagesAfter — millisecond-collision tie-br
     expect(getMessagesAfter(CONV_ID, "")).toHaveLength(2);
   });
 });
+
+describe("countMessagesAfter / getMessagesAfter: a cursor survives its row's deletion", () => {
+  beforeEach(() => {
+    clearDb();
+    seedConversation();
+  });
+
+  test("a cursor carrying createdAt keeps bounding the read after its row is deleted", () => {
+    const ts = 1_700_000_000_000;
+    insertMessage("a", ts);
+    // The row the cursor points at: a reply the user then regenerates.
+    insertMessage("b", ts + 1);
+    insertMessage("c", ts + 2);
+    getDb().delete(messages).where(eq(messages.id, "b")).run();
+    // The regenerated reply.
+    insertMessage("d", ts + 3);
+
+    const cursor = { id: "b", createdAt: ts + 1 };
+    expect(countMessagesAfter(CONV_ID, cursor)).toBe(2);
+    expect(getMessagesAfter(CONV_ID, cursor).map((m) => m.id)).toEqual([
+      "c",
+      "d",
+    ]);
+  });
+
+  test("a cursor without createdAt keeps the conservative id-only semantics once its row is gone", () => {
+    insertMessage("a", 1_700_000_000_000);
+
+    const cursor = { id: "nonexistent", createdAt: null };
+    expect(countMessagesAfter(CONV_ID, cursor)).toBe(0);
+    expect(getMessagesAfter(CONV_ID, cursor)).toEqual([]);
+  });
+
+  test("the live row wins over the timestamp the cursor carries", () => {
+    const ts = 1_700_000_000_000;
+    insertMessage("a", ts);
+    insertMessage("b", ts + 10);
+
+    // A stale cursor timestamp must not pull processed rows back in, nor
+    // hide unprocessed ones, while the row itself can still be read.
+    expect(countMessagesAfter(CONV_ID, { id: "b", createdAt: ts - 100 })).toBe(
+      0,
+    );
+    expect(countMessagesAfter(CONV_ID, { id: "a", createdAt: ts + 999 })).toBe(
+      1,
+    );
+  });
+
+  test("a cursor with an empty id reads everything, like null and the empty string", () => {
+    insertMessage("a", 1_700_000_000_000);
+
+    expect(countMessagesAfter(CONV_ID, { id: "", createdAt: 5 })).toBe(1);
+    expect(getMessagesAfter(CONV_ID, { id: "", createdAt: 5 })).toHaveLength(1);
+  });
+});
+
+describe("resolveMessagesAfterBound", () => {
+  beforeEach(() => {
+    clearDb();
+    seedConversation();
+  });
+
+  test("resolves the unbounded, live-row, stored-timestamp, and vanished cases", () => {
+    insertMessage("a", 1_000);
+
+    expect(resolveMessagesAfterBound(null)).toEqual({ kind: "all" });
+    expect(resolveMessagesAfterBound("")).toEqual({ kind: "all" });
+    expect(resolveMessagesAfterBound({ id: "", createdAt: 3 })).toEqual({
+      kind: "all",
+    });
+    expect(resolveMessagesAfterBound("a")).toEqual({
+      kind: "after",
+      bound: { createdAt: 1_000, id: "a" },
+    });
+    expect(resolveMessagesAfterBound({ id: "a", createdAt: 99 })).toEqual({
+      kind: "after",
+      bound: { createdAt: 1_000, id: "a" },
+    });
+    expect(resolveMessagesAfterBound("gone")).toEqual({ kind: "vanished" });
+    expect(resolveMessagesAfterBound({ id: "gone", createdAt: null })).toEqual({
+      kind: "vanished",
+    });
+    expect(resolveMessagesAfterBound({ id: "gone", createdAt: 7 })).toEqual({
+      kind: "after",
+      bound: { createdAt: 7, id: "gone" },
+    });
+  });
+});

package/src/__tests__/messages-read-boundary-guard.test.ts

@@ -52,7 +52,7 @@ const BASELINE: Readonly<Record<string, number>> = {
   "src/plugins/defaults/memory/context-search/sources/conversations.ts": 1,
   "src/plugins/defaults/memory/graph/image-ref-utils.ts": 1,
   "src/plugins/defaults/memory/indexer.ts": 2,
-  "src/plugins/defaults/memory/memory-retrospective-accounting.ts": 4,
+  "src/plugins/defaults/memory/memory-retrospective-accounting.ts": 2,
   "src/plugins/defaults/memory/substrate/sweep-job.ts": 1,
   "src/plugins/defaults/memory/v1/graph/extraction.ts": 3,
   "src/plugins/defaults/memory/v1/job-handlers/backfill.ts": 1,