@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/permissions/question-prompter.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { setConfig } from "../__tests__/helpers/set-config.js";
 import type { QuestionRequestEvent } from "../api/events/question-request.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type {
@@ -7,20 +8,11 @@ import type {
   QuestionPromptResult,
 } from "./question-prompter.js";
 
-// Use a tiny timeout so the setTimeout branch fires quickly in tests
-const mockConfig = {
-  timeouts: { questionResponseTimeoutSec: 0.05 },
-};
-// Preserve every other export from the real config/loader so other
-// tests in the same `bun test` run (which share module-level mocks)
-// don't lose access to e.g. `setNestedValue`.
-const realConfigLoader = await import("../config/loader.js");
-mock.module("../config/loader.js", () => ({
-  ...realConfigLoader,
-  getConfig: () => mockConfig,
-  loadConfig: () => mockConfig,
-  invalidateConfigCache: () => {},
-}));
+// Use a tiny idle-timeout so the setTimeout backstop branch fires quickly in
+// tests (the schema only requires a positive number of seconds).
+function seedQuestionTimeout(): void {
+  setConfig("timeouts", { questionResponseTimeoutSec: 0.05 });
+}
 
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
@@ -182,6 +174,7 @@ const threeQuestionParams = {
 describe("QuestionPrompter", () => {
   beforeEach(() => {
     _piStore.clear();
+    seedQuestionTimeout();
   });
 
   test("happy path: option resolution via the shared batch helpers", async () => {

package/src/persistence/__tests__/bulk-write-gate.test.ts

@@ -1,15 +1,9 @@
 import { rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { describe, expect, mock, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 
 import { assertNotLiveDb } from "../../__tests__/assert-not-live-db.js";
-import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
-
-mock.module("../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 import { bulkWriteGateHolder, withBulkWriteGate } from "../bulk-write-gate.js";
 import { deleteConversationRowsInBatches } from "../conversation-row-batch-delete.js";
 import { copyForkMessagesViaSubprocess } from "../fork-message-copy.js";

package/src/persistence/__tests__/conversation-queries-search.test.ts

@@ -16,13 +16,6 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { MessageLexicalSearchResult } from "../embeddings/messages-lexical-index.js";
 
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // The lexical candidate source is the single seam this cutover swaps in. Mock
 // it directly (returning caller-controlled candidate ids/scores) and, per test,
 // override it to throw to exercise the Qdrant-error degrade path. Spreading the

package/src/persistence/__tests__/main-db-readonly-probe.ts

@@ -0,0 +1,80 @@
+/**
+ * Subprocess probe for the resource monitor's main-DB posture: telemetry
+ * queries route through the dedicated read-only connection, writes through
+ * it fail loudly, and the telemetry DB stays writable. Spawned by
+ * `main-db-readonly.test.ts` with VELLUM_WORKSPACE_DIR pointing at a fresh
+ * temp workspace, so the process-scoped posture and connection singletons
+ * never leak into the test runner process.
+ *
+ * Exits 0 and prints READONLY_PROBE_OK when every assertion holds; any
+ * failure throws and exits non-zero.
+ */
+
+import {
+  getFlushCheckpoint,
+  setFlushCheckpoint,
+} from "../../telemetry/flush-checkpoints.js";
+import { useReadOnlyMainDbForTelemetry } from "../../telemetry/telemetry-main-db.js";
+import {
+  getMainDbReadOnly,
+  getTelemetryDb,
+  resetDb,
+} from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import { queryUnreportedUsageEvents } from "../llm-usage-store.js";
+import { memoryCheckpoints, telemetryEvents } from "../schema/index.js";
+
+// Create the schema over the normal read-write connections, then reopen
+// with the monitor's posture: telemetry main-DB reads go through the
+// dedicated read-only connection; the telemetry DB stays read-write.
+await initializeDb();
+resetDb();
+useReadOnlyMainDbForTelemetry();
+
+// Telemetry store queries work over the read-only main connection.
+const rows = queryUnreportedUsageEvents(0, undefined, 10);
+if (!Array.isArray(rows) || rows.length !== 0) {
+  throw new Error(`expected empty usage query, got ${JSON.stringify(rows)}`);
+}
+
+// Writes through the read-only connection fail loudly.
+const readOnlyDb = getMainDbReadOnly();
+if (!readOnlyDb) {
+  throw new Error("read-only main DB connection unavailable");
+}
+let writeError: unknown;
+try {
+  readOnlyDb
+    .insert(memoryCheckpoints)
+    .values({ key: "readonly-probe", value: "1", updatedAt: Date.now() })
+    .run();
+} catch (err) {
+  writeError = err;
+}
+if (!writeError || !/readonly/i.test(String(writeError))) {
+  throw new Error(
+    `expected a readonly write failure, got: ${String(writeError)}`,
+  );
+}
+
+// The telemetry DB stays writable: flush state and event rows.
+setFlushCheckpoint("telemetry:readonly-probe:last_reported_at", "123");
+if (getFlushCheckpoint("telemetry:readonly-probe:last_reported_at") !== "123") {
+  throw new Error("flush checkpoint round-trip failed");
+}
+const telemetryDb = getTelemetryDb();
+if (!telemetryDb) {
+  throw new Error("telemetry DB unavailable");
+}
+telemetryDb
+  .insert(telemetryEvents)
+  .values({
+    id: "readonly-probe-row",
+    name: "config_setting",
+    createdAt: Date.now(),
+    conversationId: null,
+    payload: '{"type":"config_setting"}',
+  })
+  .run();
+
+console.log("READONLY_PROBE_OK");

package/src/persistence/__tests__/main-db-readonly.test.ts

@@ -0,0 +1,35 @@
+/**
+ * Tests the main DB's read-only connection mode — the resource monitor
+ * process's posture — via a spawned subprocess (`main-db-readonly-probe.ts`)
+ * with its own temp workspace. Read-only mode and the connection singletons
+ * are process-global, so exercising them in the shared test-runner process
+ * would poison every later test file in the same invocation.
+ */
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { assertNotLiveDb } from "../../__tests__/assert-not-live-db.js";
+
+describe("main DB read-only mode (resource monitor posture)", () => {
+  test("probe subprocess: reads work, main writes fail, telemetry stays writable", () => {
+    const workspaceDir = mkdtempSync(join(tmpdir(), "readonly-probe-"));
+    try {
+      const probePath = join(import.meta.dir, "main-db-readonly-probe.ts");
+      const result = Bun.spawnSync({
+        cmd: ["bun", probePath],
+        env: { ...process.env, VELLUM_WORKSPACE_DIR: workspaceDir },
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const stdout = result.stdout.toString();
+      const stderr = result.stderr.toString();
+      expect(`${stdout}\n${stderr}`).toContain("READONLY_PROBE_OK");
+      expect(result.exitCode).toBe(0);
+    } finally {
+      assertNotLiveDb(join(workspaceDir, "data", "db", "assistant.db"));
+      rmSync(workspaceDir, { recursive: true, force: true });
+    }
+  }, 60_000);
+});

package/src/persistence/__tests__/message-content-file.test.ts

@@ -1,8 +1,9 @@
 /**
  * Tests for the file-backed message content module: the JSONL delta fold
- * semantics, the append/fold roundtrip, and `resolveStoredMessageContent`'s
- * union handling (inline passthrough, ref resolution, missing-file and
- * workspace-escape fallbacks).
+ * semantics, the append/fold roundtrip, the reserved-path ref discriminator,
+ * and the `resolveMessageContentBlocks` resolver across inline content,
+ * ref resolution, legacy plain strings, missing-file and workspace-escape
+ * fallbacks.
  */
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -14,12 +15,12 @@ import {
   appendContentDeltas,
   foldContentDeltas,
   foldContentFile,
-  isMessageContentRef,
-  resolveStoredMessageContent,
+  messageContentRefSchema,
+  resolveMessageContentBlocks,
 } from "../message-content-file.js";
 
 function textBlock(text: string): ContentBlock {
-  return { type: "text", text } as ContentBlock;
+  return { type: "text", text };
 }
 
 describe("foldContentDeltas", () => {
@@ -45,10 +46,25 @@ describe("foldContentDeltas", () => {
       "not json\n" +
       JSON.stringify({ seq: 2, block: textBlock("missing index") }) +
       "\n" +
+      JSON.stringify({ i: 2, seq: 4, block: { typo: "no type field" } }) +
+      "\n" +
       '{"i": 1, "seq": 3, "block": {"type": "text", "te'; // truncated
     expect(foldContentDeltas(text)).toEqual([textBlock("kept")]);
   });
 
+  test("preserves internal rider fields on blocks (passthrough, not strip)", () => {
+    // Timing stamps like _startedAt ride inside persisted thinking blocks;
+    // the fold must round-trip them, not strip them as unknown keys.
+    const stamped = {
+      type: "thinking",
+      thinking: "hmm",
+      signature: "sig",
+      _startedAt: 123,
+    };
+    const text = JSON.stringify({ i: 0, seq: 1, block: stamped });
+    expect(foldContentDeltas(text)).toEqual([stamped as ContentBlock]);
+  });
+
   test("empty input folds to empty content", () => {
     expect(foldContentDeltas("")).toEqual([]);
   });
@@ -81,70 +97,163 @@ describe("appendContentDeltas + foldContentFile", () => {
   });
 });
 
-describe("isMessageContentRef", () => {
-  test("accepts exactly { ref: string }", () => {
-    expect(isMessageContentRef({ ref: "a/b.jsonl" })).toBe(true);
+describe("messageContentRefSchema", () => {
+  test("accepts exactly { ref } naming a reserved conversations/ .jsonl path", () => {
+    expect(
+      messageContentRefSchema.safeParse({
+        ref: "conversations/a/inflight/b.jsonl",
+      }).success,
+    ).toBe(true);
+  });
+
+  test("rejects non-reserved paths — the legacy-text discriminator", () => {
+    for (const ref of [
+      "a/b.jsonl",
+      "conversations/a/b.txt",
+      "/etc/passwd",
+      "../../../etc/passwd",
+    ]) {
+      expect(messageContentRefSchema.safeParse({ ref }).success).toBe(false);
+    }
+  });
+
+  test("strips unrecognized extra keys rather than rejecting them", () => {
+    const result = messageContentRefSchema.safeParse({
+      ref: "conversations/a/b.jsonl",
+      other: 1,
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data).toEqual({ ref: "conversations/a/b.jsonl" });
+    }
   });
 
-  test("rejects arrays, extra keys, empty and non-string refs", () => {
-    expect(isMessageContentRef([textBlock("x")])).toBe(false);
-    expect(isMessageContentRef({ ref: "a", other: 1 })).toBe(false);
-    expect(isMessageContentRef({ ref: "" })).toBe(false);
-    expect(isMessageContentRef({ ref: 42 })).toBe(false);
-    expect(isMessageContentRef(null)).toBe(false);
+  test("rejects arrays, empty and non-string refs", () => {
+    for (const value of [[textBlock("x")], { ref: "" }, { ref: 42 }, null]) {
+      expect(messageContentRefSchema.safeParse(value).success).toBe(false);
+    }
   });
 });
 
-describe("resolveStoredMessageContent", () => {
-  test("passes inline ContentBlock[] JSON through by identity", () => {
-    const inline = JSON.stringify([textBlock("hello")]);
-    expect(resolveStoredMessageContent(inline)).toBe(inline);
+function writeRefFixture(dir: string, file: string): string {
+  const rel = join("conversations", dir, "inflight", file);
+  mkdirSync(join(getWorkspaceDir(), "conversations", dir, "inflight"), {
+    recursive: true,
   });
+  writeFileSync(
+    join(getWorkspaceDir(), rel),
+    [
+      JSON.stringify({ i: 0, seq: 1, block: textBlock("partial") }),
+      JSON.stringify({ i: 0, seq: 2, block: textBlock("final") }),
+    ].join("\n") + "\n",
+  );
+  return rel;
+}
 
-  test("passes legacy plain strings through, including '{'-prefixed ones", () => {
-    expect(resolveStoredMessageContent("plain old text")).toBe(
-      "plain old text",
-    );
-    expect(resolveStoredMessageContent("{not json")).toBe("{not json");
-    const objectButNotRef = JSON.stringify({ some: "object" });
-    expect(resolveStoredMessageContent(objectButNotRef)).toBe(objectButNotRef);
+describe("resolveMessageContentBlocks", () => {
+  test("parses inline ContentBlock[] JSON to blocks", () => {
+    expect(
+      resolveMessageContentBlocks(JSON.stringify([textBlock("hello")])),
+    ).toEqual([textBlock("hello")]);
   });
 
-  test("resolves a ref to the folded file content", () => {
-    const rel = join("conversations", "test-resolve", "inflight", "m.jsonl");
-    const abs = join(getWorkspaceDir(), rel);
-    mkdirSync(
-      join(getWorkspaceDir(), "conversations", "test-resolve", "inflight"),
+  test("parses a nested tool_result with contentBlocks (recursive schema)", () => {
+    const blocks: ContentBlock[] = [
       {
-        recursive: true,
+        type: "tool_result",
+        tool_use_id: "tu-1",
+        content: "done",
+        contentBlocks: [textBlock("nested")],
       },
-    );
-    writeFileSync(
-      abs,
-      [
-        JSON.stringify({ i: 0, seq: 1, block: textBlock("partial") }),
-        JSON.stringify({ i: 0, seq: 2, block: textBlock("final") }),
-      ].join("\n") + "\n",
-    );
-    expect(resolveStoredMessageContent(JSON.stringify({ ref: rel }))).toBe(
-      JSON.stringify([textBlock("final")]),
+    ];
+    expect(resolveMessageContentBlocks(JSON.stringify(blocks))).toEqual(blocks);
+  });
+
+  test("passes typed blocks outside the union through untouched", () => {
+    // Persisted kinds like ui_surface live outside the provider union;
+    // their renderers own their shape, so repair must not rewrite them.
+    const historical = [
+      textBlock("kept as-is"),
+      { type: "ui_surface", surfaceType: "call_summary", data: { x: 1 } },
+      { type: "some_retired_block_kind", payload: 1 },
+    ];
+    expect(resolveMessageContentBlocks(JSON.stringify(historical))).toEqual(
+      historical as ContentBlock[],
     );
   });
 
-  test("resolves a ref to a missing file as empty content", () => {
-    expect(
-      resolveStoredMessageContent(JSON.stringify({ ref: "gone/m.jsonl" })),
-    ).toBe("[]");
+  test("wraps type-less values in a text block carrying the payload", () => {
+    const historical = [{ payload: 1 }, "bare string"];
+    expect(resolveMessageContentBlocks(JSON.stringify(historical))).toEqual([
+      textBlock('{"payload":1}'),
+      textBlock('"bare string"'),
+    ]);
+  });
+
+  test("repairs a web_search_tool_result with a missing tool_use_id", () => {
+    const historical = [
+      { type: "web_search_tool_result", content: { encrypted: "blob" } },
+    ];
+    expect(resolveMessageContentBlocks(JSON.stringify(historical))).toEqual([
+      {
+        type: "web_search_tool_result",
+        tool_use_id: "",
+        content: { encrypted: "blob" },
+      },
+    ]);
+  });
+
+  test("repairs a text block with missing or non-string text", () => {
+    const historical = [{ type: "text" }, { type: "text", text: 42 }];
+    expect(resolveMessageContentBlocks(JSON.stringify(historical))).toEqual([
+      textBlock(""),
+      textBlock("42"),
+    ]);
+  });
+
+  test("repairs a tool_result with object-valued content in place", () => {
+    const historical = [
+      { type: "tool_result", tool_use_id: "tu-1", content: { some: "obj" } },
+    ];
+    expect(resolveMessageContentBlocks(JSON.stringify(historical))).toEqual([
+      {
+        type: "tool_result",
+        tool_use_id: "tu-1",
+        content: '{"some":"obj"}',
+      },
+    ]);
   });
 
-  test("rejects refs that escape the workspace directory", () => {
+  test("folds a reserved-path ref to blocks", () => {
+    const rel = writeRefFixture("test-resolve-blocks", "m.jsonl");
+    expect(resolveMessageContentBlocks(JSON.stringify({ ref: rel }))).toEqual([
+      textBlock("final"),
+    ]);
+  });
+
+  test("wraps legacy plain strings in a single text block", () => {
+    expect(resolveMessageContentBlocks("plain old text")).toEqual([
+      textBlock("plain old text"),
+    ]);
+    const legacyRefLikeText = JSON.stringify({ ref: "missing.jsonl" });
+    expect(resolveMessageContentBlocks(legacyRefLikeText)).toEqual([
+      textBlock(legacyRefLikeText),
+    ]);
+  });
+
+  test("resolves a missing ref file to empty blocks", () => {
     expect(
-      resolveStoredMessageContent(
-        JSON.stringify({ ref: "../../../etc/passwd" }),
+      resolveMessageContentBlocks(
+        JSON.stringify({ ref: "conversations/gone/inflight/m.jsonl" }),
       ),
-    ).toBe("[]");
+    ).toEqual([]);
+  });
+
+  test("resolves a reserved-prefix ref that escapes the workspace to empty blocks", () => {
     expect(
-      resolveStoredMessageContent(JSON.stringify({ ref: "/etc/passwd" })),
-    ).toBe("[]");
+      resolveMessageContentBlocks(
+        JSON.stringify({ ref: "conversations/../../../etc/evil.jsonl" }),
+      ),
+    ).toEqual([]);
   });
 });

package/src/persistence/__tests__/raw-query-telemetry.test.ts

@@ -0,0 +1,74 @@
+/**
+ * Tests for {@link rawTelemetryRun} — the raw-write helper for the dedicated
+ * telemetry connection (`assistant-telemetry.db`), mirroring
+ * `rawMemoryRun`/`rawLogsRun`. Writes must land on the telemetry connection,
+ * not the main DB, and return the changed-row count.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { getSqlite, getTelemetrySqlite } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import { rawTelemetryRun } from "../raw-query.js";
+
+await initializeDb();
+
+const telemetry = getTelemetrySqlite();
+if (!telemetry) throw new Error("telemetry database unavailable in test");
+
+telemetry.exec(/*sql*/ `
+  CREATE TABLE IF NOT EXISTS raw_telemetry_run_test (
+    id TEXT PRIMARY KEY,
+    value INTEGER NOT NULL
+  )
+`);
+
+describe("rawTelemetryRun", () => {
+  test("inserts on the telemetry connection and returns the changed-row count", () => {
+    const changes = rawTelemetryRun(
+      "test:insert",
+      "INSERT INTO raw_telemetry_run_test (id, value) VALUES (?, ?)",
+      "row-1",
+      42,
+    );
+    expect(changes).toBe(1);
+
+    // The row is visible through the telemetry connection…
+    const row = telemetry
+      .query("SELECT id, value FROM raw_telemetry_run_test WHERE id = ?")
+      .get("row-1");
+    expect(row).toEqual({ id: "row-1", value: 42 });
+
+    // …and the table does not exist on the main connection at all.
+    const onMain = getSqlite()
+      .query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+      .get("raw_telemetry_run_test");
+    expect(onMain).toBeNull();
+  });
+
+  test("delete returns the changed-row count", () => {
+    rawTelemetryRun(
+      "test:insert",
+      "INSERT INTO raw_telemetry_run_test (id, value) VALUES (?, ?), (?, ?)",
+      "row-2",
+      1,
+      "row-3",
+      2,
+    );
+
+    const deleted = rawTelemetryRun(
+      "test:delete",
+      "DELETE FROM raw_telemetry_run_test WHERE id IN (?, ?)",
+      "row-2",
+      "row-3",
+    );
+    expect(deleted).toBe(2);
+
+    const noMatch = rawTelemetryRun(
+      "test:delete",
+      "DELETE FROM raw_telemetry_run_test WHERE id = ?",
+      "missing",
+    );
+    expect(noMatch).toBe(0);
+  });
+});