@vellumai/assistant 0.5.2 → 0.5.3

package/src/__tests__/db-memory-reducer-checkpoints.test.ts

@@ -0,0 +1,273 @@
+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(), "memory-reducer-checkpoints-"));
+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: () => {},
+  getConversationsDir: () => join(testDir, "conversations"),
+}));
+
+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 { migrateMemoryReducerCheckpoints } from "../memory/migrations/187-memory-reducer-checkpoints.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(conversations)`).all() as Array<{
+    name: string;
+    notnull: number;
+  }>;
+}
+
+function bootstrapPreCheckpointConversations(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,
+      fork_parent_conversation_id TEXT,
+      fork_parent_message_id TEXT,
+      is_auto_title INTEGER NOT NULL DEFAULT 1,
+      schedule_job_id TEXT
+    )
+  `);
+}
+
+function removeTestDbFiles(): void {
+  rmSync(dbPath, { force: true });
+  rmSync(`${dbPath}-shm`, { force: true });
+  rmSync(`${dbPath}-wal`, { force: true });
+}
+
+describe("memory reducer checkpoint columns 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 nullable reducer checkpoint columns", () => {
+    initializeDb();
+
+    const raw = new Database(dbPath);
+    const columns = getColumnInfo(raw);
+
+    const checkpointColumns = columns.filter(
+      (c) =>
+        c.name === "memory_reduced_through_message_id" ||
+        c.name === "memory_dirty_tail_since_message_id" ||
+        c.name === "memory_last_reduced_at",
+    );
+
+    expect(checkpointColumns).toHaveLength(3);
+    expect(checkpointColumns.every((c) => c.notnull === 0)).toBe(true);
+
+    raw.close();
+  });
+
+  test("migration upgrades the pre-checkpoint schema without disturbing existing rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    const now = Date.now();
+
+    bootstrapPreCheckpointConversations(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
+      )
+    `);
+
+    migrateMemoryReducerCheckpoints(db);
+
+    const columnNames = getColumnInfo(raw).map((c) => c.name);
+    expect(columnNames).toContain("memory_reduced_through_message_id");
+    expect(columnNames).toContain("memory_dirty_tail_since_message_id");
+    expect(columnNames).toContain("memory_last_reduced_at");
+
+    const row = raw
+      .query(
+        `SELECT id, title, memory_reduced_through_message_id, memory_dirty_tail_since_message_id, memory_last_reduced_at
+         FROM conversations WHERE id = 'conv-upgrade'`,
+      )
+      .get() as {
+      id: string;
+      title: string | null;
+      memory_reduced_through_message_id: string | null;
+      memory_dirty_tail_since_message_id: string | null;
+      memory_last_reduced_at: number | null;
+    } | null;
+
+    expect(row).toEqual({
+      id: "conv-upgrade",
+      title: "Existing conversation",
+      memory_reduced_through_message_id: null,
+      memory_dirty_tail_since_message_id: null,
+      memory_last_reduced_at: null,
+    });
+
+    raw.close();
+  });
+
+  test("re-running the migration preserves populated checkpoint values", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    const now = Date.now();
+
+    bootstrapPreCheckpointConversations(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',
+        'Reduced conversation',
+        ${now},
+        ${now},
+        'standard',
+        'user',
+        'default',
+        1
+      )
+    `);
+
+    migrateMemoryReducerCheckpoints(db);
+    raw.exec(/*sql*/ `
+      UPDATE conversations
+      SET memory_reduced_through_message_id = 'msg-100',
+          memory_dirty_tail_since_message_id = 'msg-101',
+          memory_last_reduced_at = ${now}
+      WHERE id = 'conv-rerun'
+    `);
+
+    expect(() => migrateMemoryReducerCheckpoints(db)).not.toThrow();
+
+    const row = raw
+      .query(
+        `SELECT memory_reduced_through_message_id, memory_dirty_tail_since_message_id, memory_last_reduced_at
+         FROM conversations WHERE id = 'conv-rerun'`,
+      )
+      .get() as {
+      memory_reduced_through_message_id: string | null;
+      memory_dirty_tail_since_message_id: string | null;
+      memory_last_reduced_at: number | null;
+    } | null;
+
+    expect(row).toEqual({
+      memory_reduced_through_message_id: "msg-100",
+      memory_dirty_tail_since_message_id: "msg-101",
+      memory_last_reduced_at: now,
+    });
+
+    raw.close();
+  });
+
+  test("getConversation exposes the new checkpoint fields as null for new rows", async () => {
+    initializeDb();
+
+    // Dynamic import to avoid circular module init issues — conversation-crud
+    // depends on getDb being initialized which happens in initializeDb above.
+    const { createConversation, getConversation } =
+      await import("../memory/conversation-crud.js");
+
+    const created = createConversation("Test conversation");
+    const loaded = getConversation(created.id);
+
+    expect(loaded).not.toBeNull();
+    expect(loaded!.memoryReducedThroughMessageId).toBeNull();
+    expect(loaded!.memoryDirtyTailSinceMessageId).toBeNull();
+    expect(loaded!.memoryLastReducedAt).toBeNull();
+  });
+});

package/src/__tests__/inline-command-runner.test.ts

@@ -0,0 +1,311 @@
+import { describe, expect, mock, test } from "bun:test";
+
+import type { InlineCommandResult } from "../skills/inline-command-runner.js";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be declared before the module under test is imported
+// ---------------------------------------------------------------------------
+
+const mockConfig = {
+  provider: "anthropic",
+  model: "test",
+  maxTokens: 4096,
+  dataDir: "/tmp",
+  sandbox: { enabled: true },
+  timeouts: {
+    shellDefaultTimeoutSec: 120,
+    shellMaxTimeoutSec: 600,
+    permissionTimeoutSec: 300,
+  },
+  rateLimit: { maxRequestsPerMinute: 0 },
+  secretDetection: {
+    enabled: true,
+    action: "warn" as const,
+    entropyThreshold: 4.0,
+  },
+  auditLog: { retentionDays: 0 },
+};
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => mockConfig,
+  loadConfig: () => mockConfig,
+  invalidateConfigCache: () => {},
+  saveConfig: () => {},
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Track wrapCommand calls to verify sandbox-only execution
+let lastWrapCall: {
+  command: string;
+  workingDir: string;
+  config: { enabled: boolean };
+  options?: { networkMode?: string };
+} | null = null;
+
+mock.module("../tools/terminal/sandbox.js", () => ({
+  wrapCommand: (
+    command: string,
+    workingDir: string,
+    config: { enabled: boolean },
+    options?: { networkMode?: string },
+  ) => {
+    lastWrapCall = { command, workingDir, config, options };
+    return {
+      command: "bash",
+      args: ["-c", "--", command],
+      sandboxed: false,
+    };
+  },
+}));
+
+mock.module("../tools/terminal/safe-env.js", () => ({
+  buildSanitizedEnv: () => ({
+    PATH: process.env.PATH ?? "/usr/bin:/bin",
+    HOME: process.env.HOME ?? "/tmp",
+  }),
+}));
+
+import { runInlineCommand } from "../skills/inline-command-runner.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const CWD = process.cwd();
+
+function expectOk(result: InlineCommandResult): void {
+  expect(result.ok).toBe(true);
+  expect(result.failureReason).toBeUndefined();
+}
+
+function expectFailure(
+  result: InlineCommandResult,
+  reason: InlineCommandResult["failureReason"],
+): void {
+  expect(result.ok).toBe(false);
+  expect(result.failureReason).toBe(reason);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("runInlineCommand", () => {
+  // ── Sandbox enforcement ──────────────────────────────────────────────────
+
+  describe("sandbox enforcement", () => {
+    test("always passes sandbox config with enabled=true", async () => {
+      lastWrapCall = null;
+      await runInlineCommand("echo sandbox-check", CWD);
+
+      expect(lastWrapCall).not.toBeNull();
+      expect(lastWrapCall!.config.enabled).toBe(true);
+    });
+
+    test("always passes networkMode=off", async () => {
+      lastWrapCall = null;
+      await runInlineCommand("echo network-check", CWD);
+
+      expect(lastWrapCall).not.toBeNull();
+      expect(lastWrapCall!.options?.networkMode).toBe("off");
+    });
+
+    test("uses the provided workingDir as cwd", async () => {
+      lastWrapCall = null;
+      const customDir = "/tmp/my-project";
+      await runInlineCommand("echo cwd-check", customDir);
+
+      expect(lastWrapCall).not.toBeNull();
+      expect(lastWrapCall!.workingDir).toBe(customDir);
+    });
+
+    test("passes the literal command string to the sandbox", async () => {
+      lastWrapCall = null;
+      await runInlineCommand("git log --oneline -n 5", CWD);
+
+      expect(lastWrapCall).not.toBeNull();
+      expect(lastWrapCall!.command).toBe("git log --oneline -n 5");
+    });
+  });
+
+  // ── Successful execution ─────────────────────────────────────────────────
+
+  describe("successful execution", () => {
+    test("captures stdout from a simple echo", async () => {
+      const result = await runInlineCommand("echo hello-world", CWD);
+
+      expectOk(result);
+      expect(result.output).toBe("hello-world");
+    });
+
+    test("captures multi-line stdout", async () => {
+      const result = await runInlineCommand(
+        "printf 'line1\\nline2\\nline3'",
+        CWD,
+      );
+
+      expectOk(result);
+      expect(result.output).toContain("line1");
+      expect(result.output).toContain("line2");
+      expect(result.output).toContain("line3");
+    });
+
+    test("returns empty string for command with no output", async () => {
+      const result = await runInlineCommand("true", CWD);
+
+      expectOk(result);
+      expect(result.output).toBe("");
+    });
+  });
+
+  // ── ANSI stripping ──────────────────────────────────────────────────────
+
+  describe("ANSI stripping", () => {
+    test("strips SGR color codes from output", async () => {
+      const result = await runInlineCommand(
+        "printf '\\033[31mred\\033[0m normal'",
+        CWD,
+      );
+
+      expectOk(result);
+      expect(result.output).toBe("red normal");
+      expect(result.output).not.toContain("\x1b");
+    });
+
+    test("strips cursor movement sequences", async () => {
+      const result = await runInlineCommand("printf '\\033[2Ahello'", CWD);
+
+      expectOk(result);
+      expect(result.output).toBe("hello");
+    });
+  });
+
+  // ── Binary output rejection ──────────────────────────────────────────────
+
+  describe("binary output rejection", () => {
+    test("rejects binary-ish output", async () => {
+      // Generate output with >10% control characters
+      const result = await runInlineCommand(
+        "printf '\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07abc'",
+        CWD,
+      );
+
+      expectFailure(result, "binary_output");
+      expect(result.output).toBe("Inline command produced binary output.");
+    });
+  });
+
+  // ── Output clamping ──────────────────────────────────────────────────────
+
+  describe("output clamping", () => {
+    test("truncates output exceeding the cap", async () => {
+      // Generate output larger than a small cap
+      const result = await runInlineCommand("printf '%0.s-' {1..200}", CWD, {
+        maxOutputChars: 50,
+      });
+
+      expectOk(result);
+      expect(result.output.length).toBeLessThanOrEqual(
+        50 + "\n[output truncated]".length,
+      );
+      expect(result.output).toContain("[output truncated]");
+    });
+
+    test("does not truncate output under the cap", async () => {
+      const result = await runInlineCommand("echo short", CWD, {
+        maxOutputChars: 1000,
+      });
+
+      expectOk(result);
+      expect(result.output).toBe("short");
+      expect(result.output).not.toContain("[output truncated]");
+    });
+  });
+
+  // ── Timeout handling ─────────────────────────────────────────────────────
+
+  describe("timeout handling", () => {
+    test("produces deterministic timeout result", async () => {
+      const result = await runInlineCommand("sleep 60", CWD, {
+        timeoutMs: 200,
+      });
+
+      expectFailure(result, "timeout");
+      expect(result.output).toBe("Inline command timed out after 200ms.");
+    });
+  });
+
+  // ── Non-zero exit ────────────────────────────────────────────────────────
+
+  describe("non-zero exit", () => {
+    test("produces deterministic failure for exit code 1", async () => {
+      const result = await runInlineCommand("exit 1", CWD);
+
+      expectFailure(result, "non_zero_exit");
+      expect(result.output).toBe("Inline command failed (exit code 1).");
+    });
+
+    test("produces deterministic failure for exit code 127", async () => {
+      const result = await runInlineCommand(
+        "nonexistent_command_that_does_not_exist_xyz",
+        CWD,
+      );
+
+      expectFailure(result, "non_zero_exit");
+      expect(result.output).toMatch(
+        /Inline command failed \(exit code \d+\)\./,
+      );
+    });
+
+    test("does not expose stderr in the error result", async () => {
+      const result = await runInlineCommand("echo err-msg >&2 && exit 1", CWD);
+
+      expectFailure(result, "non_zero_exit");
+      expect(result.output).not.toContain("err-msg");
+      expect(result.output).toBe("Inline command failed (exit code 1).");
+    });
+  });
+
+  // ── Spawn failures ───────────────────────────────────────────────────────
+
+  describe("spawn failures", () => {
+    test("returns spawn_failure when cwd does not exist", async () => {
+      // When the working directory doesn't exist, the child process fails to
+      // start (ENOENT from posix_spawn). The runner should catch this and
+      // return a deterministic spawn_failure result.
+      const result = await runInlineCommand(
+        "echo hello",
+        "/nonexistent/path/that/does/not/exist",
+      );
+
+      expectFailure(result, "spawn_failure");
+      expect(result.output).toBe("Inline command could not be started.");
+    });
+  });
+
+  // ── stderr suppression ─────────────────────────────────────────────────
+
+  describe("stderr suppression", () => {
+    test("does not include stderr in successful output", async () => {
+      const result = await runInlineCommand(
+        "echo stdout-only && echo stderr-msg >&2",
+        CWD,
+      );
+
+      // Command may succeed (exit 0) — stderr should not leak into output
+      expectOk(result);
+      expect(result.output).toBe("stdout-only");
+      expect(result.output).not.toContain("stderr-msg");
+    });
+  });
+});