@vellumai/assistant 0.5.1 → 0.5.2

package/src/__tests__/db-conversation-fork-lineage-migration.test.ts

@@ -0,0 +1,241 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+const testDir = mkdtempSync(join(tmpdir(), "conversation-fork-lineage-"));
+const dbPath = join(testDir, "test.db");
+const originalBunTest = process.env.BUN_TEST;
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => dbPath,
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { initializeDb, resetDb } from "../memory/db.js";
+import { getSqliteFrom } from "../memory/db-connection.js";
+import { migrateConversationForkLineage } from "../memory/migrations/183-add-conversation-fork-lineage.js";
+import * as schema from "../memory/schema.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function getColumnNames(raw: Database): string[] {
+  return (
+    raw.query(`PRAGMA table_info(conversations)`).all() as Array<{ name: string }>
+  ).map((column) => column.name);
+}
+
+function hasIndex(raw: Database, indexName: string): boolean {
+  const row = raw
+    .query(`SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = ?`)
+    .get(indexName);
+  return row != null;
+}
+
+function bootstrapPreLineageConversations(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      total_input_tokens INTEGER NOT NULL DEFAULT 0,
+      total_output_tokens INTEGER NOT NULL DEFAULT 0,
+      total_estimated_cost REAL NOT NULL DEFAULT 0,
+      context_summary TEXT,
+      context_compacted_message_count INTEGER NOT NULL DEFAULT 0,
+      context_compacted_at INTEGER,
+      conversation_type TEXT NOT NULL DEFAULT 'standard',
+      source TEXT NOT NULL DEFAULT 'user',
+      memory_scope_id TEXT NOT NULL DEFAULT 'default',
+      origin_channel TEXT,
+      origin_interface TEXT,
+      is_auto_title INTEGER NOT NULL DEFAULT 1,
+      schedule_job_id TEXT
+    )
+  `);
+}
+
+function removeTestDbFiles(): void {
+  resetDb();
+  rmSync(dbPath, { force: true });
+  rmSync(`${dbPath}-shm`, { force: true });
+  rmSync(`${dbPath}-wal`, { force: true });
+}
+
+describe("conversation fork lineage migration", () => {
+  beforeEach(() => {
+    process.env.BUN_TEST = "0";
+    removeTestDbFiles();
+  });
+
+  afterAll(() => {
+    process.env.BUN_TEST = originalBunTest;
+    removeTestDbFiles();
+    try {
+      rmSync(testDir, { recursive: true });
+    } catch {
+      /* best effort */
+    }
+  });
+
+  test("fresh DB initialization includes nullable lineage columns and parent lookup index", () => {
+    initializeDb();
+
+    const raw = new Database(dbPath);
+    const columns = getColumnNames(raw);
+
+    expect(columns).toContain("fork_parent_conversation_id");
+    expect(columns).toContain("fork_parent_message_id");
+    expect(hasIndex(raw, "idx_conversations_fork_parent_conversation_id")).toBe(
+      true,
+    );
+
+    const forkColumns = (
+      raw.query(`PRAGMA table_info(conversations)`).all() as Array<{
+        name: string;
+        notnull: number;
+      }>
+    ).filter(
+      (column) =>
+        column.name === "fork_parent_conversation_id" ||
+        column.name === "fork_parent_message_id",
+    );
+
+    expect(forkColumns).toHaveLength(2);
+    expect(forkColumns.every((column) => column.notnull === 0)).toBe(true);
+    raw.close();
+  });
+
+  test("migration upgrades the previous schema without disturbing existing conversation rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    const now = Date.now();
+
+    bootstrapPreLineageConversations(raw);
+    raw.exec(/*sql*/ `
+      INSERT INTO conversations (
+        id,
+        title,
+        created_at,
+        updated_at,
+        conversation_type,
+        source,
+        memory_scope_id,
+        is_auto_title
+      ) VALUES (
+        'conv-upgrade',
+        'Existing conversation',
+        ${now},
+        ${now},
+        'standard',
+        'user',
+        'default',
+        1
+      )
+    `);
+
+    migrateConversationForkLineage(db);
+
+    expect(getColumnNames(raw)).toContain("fork_parent_conversation_id");
+    expect(getColumnNames(raw)).toContain("fork_parent_message_id");
+    expect(hasIndex(raw, "idx_conversations_fork_parent_conversation_id")).toBe(
+      true,
+    );
+
+    const row = raw
+      .query(
+        `SELECT id, title, fork_parent_conversation_id, fork_parent_message_id FROM conversations WHERE id = 'conv-upgrade'`,
+      )
+      .get() as {
+      id: string;
+      title: string | null;
+      fork_parent_conversation_id: string | null;
+      fork_parent_message_id: string | null;
+    } | null;
+
+    expect(row).toEqual({
+      id: "conv-upgrade",
+      title: "Existing conversation",
+      fork_parent_conversation_id: null,
+      fork_parent_message_id: null,
+    });
+  });
+
+  test("re-running the migration preserves existing lineage data", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    const now = Date.now();
+
+    bootstrapPreLineageConversations(raw);
+    raw.exec(/*sql*/ `
+      INSERT INTO conversations (
+        id,
+        title,
+        created_at,
+        updated_at,
+        conversation_type,
+        source,
+        memory_scope_id,
+        is_auto_title
+      ) VALUES (
+        'conv-rerun',
+        'Forked conversation',
+        ${now},
+        ${now},
+        'standard',
+        'user',
+        'default',
+        1
+      )
+    `);
+
+    migrateConversationForkLineage(db);
+    raw.exec(/*sql*/ `
+      UPDATE conversations
+      SET fork_parent_conversation_id = 'conv-parent',
+          fork_parent_message_id = 'msg-parent'
+      WHERE id = 'conv-rerun'
+    `);
+
+    expect(() => migrateConversationForkLineage(db)).not.toThrow();
+
+    const row = raw
+      .query(
+        `SELECT fork_parent_conversation_id, fork_parent_message_id FROM conversations WHERE id = 'conv-rerun'`,
+      )
+      .get() as {
+      fork_parent_conversation_id: string | null;
+      fork_parent_message_id: string | null;
+    } | null;
+
+    expect(row).toEqual({
+      fork_parent_conversation_id: "conv-parent",
+      fork_parent_message_id: "msg-parent",
+    });
+    expect(hasIndex(raw, "idx_conversations_fork_parent_conversation_id")).toBe(
+      true,
+    );
+  });
+});

package/src/__tests__/db-llm-request-log-provider-migration.test.ts

@@ -0,0 +1,214 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterAll, afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+const testDir = mkdtempSync(join(tmpdir(), "llm-request-log-provider-"));
+const dbPath = join(testDir, "test.db");
+const originalBunTest = process.env.BUN_TEST;
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => dbPath,
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { initializeDb, resetDb } from "../memory/db.js";
+import { getSqliteFrom } from "../memory/db-connection.js";
+import { migrateLlmRequestLogProvider } from "../memory/migrations/184-llm-request-log-provider.js";
+import * as schema from "../memory/schema.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function getColumnInfo(raw: Database): Array<{ name: string; notnull: number }> {
+  return raw.query(`PRAGMA table_info(llm_request_logs)`).all() as Array<{
+    name: string;
+    notnull: number;
+  }>;
+}
+
+function bootstrapPreProviderLlmRequestLogs(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE llm_request_logs (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL,
+      message_id TEXT,
+      request_payload TEXT NOT NULL,
+      response_payload TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+}
+
+function removeTestDbFiles(): void {
+  rmSync(dbPath, { force: true });
+  rmSync(`${dbPath}-shm`, { force: true });
+  rmSync(`${dbPath}-wal`, { force: true });
+}
+
+describe("llm_request_logs provider migration", () => {
+  beforeEach(() => {
+    process.env.BUN_TEST = "0";
+    resetDb();
+    removeTestDbFiles();
+  });
+
+  afterEach(() => {
+    resetDb();
+    removeTestDbFiles();
+  });
+
+  afterAll(() => {
+    if (originalBunTest === undefined) {
+      delete process.env.BUN_TEST;
+    } else {
+      process.env.BUN_TEST = originalBunTest;
+    }
+    resetDb();
+    removeTestDbFiles();
+    try {
+      rmSync(testDir, { recursive: true });
+    } catch {
+      /* best effort */
+    }
+  });
+
+  test("fresh DB initialization includes llm_request_logs.provider", () => {
+    initializeDb();
+
+    const raw = new Database(dbPath);
+    const columns = getColumnInfo(raw);
+
+    expect(columns.some((column) => column.name === "provider")).toBe(true);
+    expect(columns.find((column) => column.name === "provider")?.notnull).toBe(
+      0,
+    );
+
+    raw.close();
+  });
+
+  test("migration upgrades the pre-provider schema without disturbing rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    bootstrapPreProviderLlmRequestLogs(raw);
+    raw.exec(/*sql*/ `
+      INSERT INTO llm_request_logs (
+        id,
+        conversation_id,
+        message_id,
+        request_payload,
+        response_payload,
+        created_at
+      ) VALUES (
+        'log-upgrade',
+        'conv-1',
+        'msg-1',
+        '{}',
+        '{"ok":true}',
+        1000
+      )
+    `);
+
+    migrateLlmRequestLogProvider(db);
+
+    expect(getColumnInfo(raw).some((column) => column.name === "provider")).toBe(
+      true,
+    );
+
+    const row = raw
+      .query(
+        `SELECT id, conversation_id, message_id, provider, request_payload, response_payload, created_at
+         FROM llm_request_logs
+         WHERE id = 'log-upgrade'`,
+      )
+      .get() as
+      | {
+          id: string;
+          conversation_id: string;
+          message_id: string | null;
+          provider: string | null;
+          request_payload: string;
+          response_payload: string;
+          created_at: number;
+        }
+      | null;
+
+    expect(row).toEqual({
+      id: "log-upgrade",
+      conversation_id: "conv-1",
+      message_id: "msg-1",
+      provider: null,
+      request_payload: "{}",
+      response_payload: '{"ok":true}',
+      created_at: 1000,
+    });
+
+    raw.close();
+  });
+
+  test("re-running the migration preserves populated provider values", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    bootstrapPreProviderLlmRequestLogs(raw);
+    raw.exec(/*sql*/ `
+      INSERT INTO llm_request_logs (
+        id,
+        conversation_id,
+        message_id,
+        request_payload,
+        response_payload,
+        created_at
+      ) VALUES (
+        'log-rerun',
+        'conv-2',
+        'msg-2',
+        '{}',
+        '{"ok":true}',
+        2000
+      )
+    `);
+
+    migrateLlmRequestLogProvider(db);
+    raw.exec(/*sql*/ `
+      UPDATE llm_request_logs
+      SET provider = 'anthropic'
+      WHERE id = 'log-rerun'
+    `);
+
+    expect(() => migrateLlmRequestLogProvider(db)).not.toThrow();
+
+    const row = raw
+      .query(
+        `SELECT provider FROM llm_request_logs WHERE id = 'log-rerun'`,
+      )
+      .get() as { provider: string | null } | null;
+
+    expect(row).toEqual({
+      provider: "anthropic",
+    });
+
+    raw.close();
+  });
+});

package/src/__tests__/diagnostics-export.test.ts

@@ -5,11 +5,13 @@
  * (specific ID → most recent assistant → any message → empty conversation).
  */
 
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import JSZip from "jszip";
+
 const testDir = mkdtempSync(join(tmpdir(), "diagnostics-export-test-"));
 
 mock.module("../util/platform.js", () => ({
@@ -90,6 +92,27 @@ function seedMessage(
   );
 }
 
+function seedLlmRequestLog(
+  id: string,
+  conversationId: string,
+  provider: string | null,
+  requestPayload: unknown,
+  responsePayload: unknown,
+  createdAt: number,
+): void {
+  db().run(
+    "INSERT INTO llm_request_logs (id, conversation_id, provider, request_payload, response_payload, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+    [
+      id,
+      conversationId,
+      provider,
+      JSON.stringify(requestPayload),
+      JSON.stringify(responsePayload),
+      createdAt,
+    ],
+  );
+}
+
 function seedConversationKey(
   conversationKey: string,
   conversationId: string,
@@ -102,6 +125,7 @@ function seedConversationKey(
 
 function cleanDb(): void {
   db().run("DELETE FROM messages");
+  db().run("DELETE FROM llm_request_logs");
   db().run("DELETE FROM conversation_keys");
   db().run("DELETE FROM conversations");
 }
@@ -216,4 +240,49 @@ describe("diagnostics export", () => {
     const json = (await res.json()) as { success: boolean };
     expect(json.success).toBe(true);
   });
+
+  test("preserves llm request provider identity in the exported JSONL", async () => {
+    const convId = "conv-7";
+    const now = Date.now();
+
+    seedConversation(convId);
+    seedMessage("msg-user-7", convId, "user", "hello", now - 1000);
+    seedMessage("msg-assistant-7", convId, "assistant", "world", now);
+    seedLlmRequestLog(
+      "log-7",
+      convId,
+      "openrouter",
+      { model: "openai/gpt-4.1-mini", input: "hello" },
+      { output: "world" },
+      now,
+    );
+
+    const res = await callExport({ conversationId: convId });
+    expect(res.status).toBe(200);
+    const json = (await res.json()) as { success: boolean; filePath: string };
+    expect(json.success).toBe(true);
+
+    const zip = await JSZip.loadAsync(readFileSync(json.filePath));
+    const llmRequests = zip.file("llm_requests.jsonl");
+    expect(llmRequests).not.toBeNull();
+
+    const lines = (await llmRequests!.async("string")).trim().split("\n");
+    expect(lines).toHaveLength(1);
+
+    const row = JSON.parse(lines[0]) as {
+      id: string;
+      conversationId: string;
+      provider?: string | null;
+      request: unknown;
+      response: unknown;
+    };
+
+    expect(row).toMatchObject({
+      id: "log-7",
+      conversationId: convId,
+      provider: "openrouter",
+    });
+
+    rmSync(json.filePath, { force: true });
+  });
 });

package/src/__tests__/first-greeting.test.ts

@@ -0,0 +1,80 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+
+let tempDir: string;
+
+mock.module("../util/platform.js", () => ({
+  getWorkspacePromptPath: mock((file: string) => join(tempDir, file)),
+  getWorkspaceDir: () => tempDir,
+  getRootDir: () => tempDir,
+  getDataDir: () => join(tempDir, "data"),
+  getPlatformName: () => "darwin",
+  isMacOS: () => false,
+  isLinux: () => false,
+  isWindows: () => false,
+  ensureDataDir: () => {},
+  getDbPath: () => "",
+  getLogPath: () => "",
+  getHistoryPath: () => "",
+  getHooksDir: () => "",
+  getSessionTokenPath: () => "",
+  getPlatformTokenPath: () => "",
+  getPidPath: () => "",
+}));
+
+const { isWakeUpGreeting, getCannedFirstGreeting, CANNED_FIRST_GREETING } =
+  await import("../daemon/first-greeting.js");
+
+describe("first-greeting", () => {
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `first-greeting-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe("isWakeUpGreeting", () => {
+    it("returns true for wake-up greeting with 0 messages and BOOTSTRAP.md present", () => {
+      writeFileSync(join(tempDir, "BOOTSTRAP.md"), "bootstrap content");
+      expect(isWakeUpGreeting("Wake up, my friend.", 0)).toBe(true);
+    });
+
+    it("returns true for case variations", () => {
+      writeFileSync(join(tempDir, "BOOTSTRAP.md"), "bootstrap content");
+      expect(isWakeUpGreeting("wake up, my friend.", 0)).toBe(true);
+      expect(isWakeUpGreeting("WAKE UP, MY FRIEND.", 0)).toBe(true);
+      expect(isWakeUpGreeting("Wake Up, My Friend.", 0)).toBe(true);
+    });
+
+    it("returns false when content doesn't match wake-up greeting", () => {
+      writeFileSync(join(tempDir, "BOOTSTRAP.md"), "bootstrap content");
+      expect(isWakeUpGreeting("Hello", 0)).toBe(false);
+      expect(isWakeUpGreeting("Hey there", 0)).toBe(false);
+      expect(isWakeUpGreeting("Wake up", 0)).toBe(false);
+    });
+
+    it("returns false when conversationMessageCount > 0", () => {
+      writeFileSync(join(tempDir, "BOOTSTRAP.md"), "bootstrap content");
+      expect(isWakeUpGreeting("Wake up, my friend.", 1)).toBe(false);
+      expect(isWakeUpGreeting("Wake up, my friend.", 5)).toBe(false);
+    });
+
+    it("returns false when BOOTSTRAP.md doesn't exist", () => {
+      expect(existsSync(join(tempDir, "BOOTSTRAP.md"))).toBe(false);
+      expect(isWakeUpGreeting("Wake up, my friend.", 0)).toBe(false);
+    });
+  });
+
+  describe("getCannedFirstGreeting", () => {
+    it("returns the expected greeting string", () => {
+      const greeting = getCannedFirstGreeting();
+      expect(greeting).toBe(CANNED_FIRST_GREETING);
+      expect(greeting).toContain("brand new");
+      expect(greeting).toContain("no name, no memories");
+    });
+  });
+});

package/src/__tests__/gateway-only-guard.test.ts

@@ -24,6 +24,7 @@ const ALLOWLIST = new Set([
   // --- Intentional local daemon-control paths ---
   "assistant/src/cli/commands/conversations.ts", // CLI wipe talks to runtime directly
   "clients/shared/Network/DaemonClient.swift",
+  "clients/shared/App/Auth/PlatformOAuthService.swift", // comment explaining runtimeUrl vs platformUrl
   "clients/macos/vellum-assistant/App/AppDelegate.swift",
   "clients/macos/vellum-assistant/Features/Settings/SettingsConnectTab.swift",
   ".claude/skills/update/SKILL.md", // daemon health check script

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -268,13 +268,9 @@ describe("handleConfirmationResponse canonical status sync", () => {
       undefined,
       { source: "button" },
     ]);
-    expect(resolveCanonicalGuardianRequestMock).toHaveBeenCalledWith(
-      "req-confirm-allow",
-      "pending",
-      {
-        status: "approved",
-      },
-    );
+    // Canonical status sync is now handled inside Conversation.handleConfirmationResponse,
+    // which this test mocks out — so the handler itself no longer calls resolveCanonicalGuardianRequest.
+    expect(resolveCanonicalGuardianRequestMock).not.toHaveBeenCalled();
     expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow");
   });
 });