@vellumai/assistant 0.8.8 → 0.8.9-staging.2

package/src/acp/__tests__/helpers/exec-file-stub.ts

@@ -0,0 +1,106 @@
+/**
+ * Shared test helper: stub `execFile` from `node:child_process` for ACP tests.
+ *
+ * Several ACP suites (the adapter auto-installer and the `/v1/acp/spawn`
+ * route) shell out via `execFileWithTimeout` (e.g. `bun add --global`). Each
+ * test file used to duplicate the same `mock.module("node:child_process",
+ * ...)` + scripted-responses boilerplate; this helper consolidates it,
+ * mirroring `which-stub.ts`.
+ *
+ * The mock records every call's args, INCLUDING the options object (cwd, env,
+ * ...) at `execFileMock.mock.calls[i][2]`, so tests can assert the installer's
+ * sandboxed cwd and sanitized env.
+ *
+ * Like the other helpers here, the hook is process-global by design (Bun's
+ * `mock.module` is process-global). Each test file should call
+ * `installExecFileStub()` once at the top level, script calls per test via
+ * `execScripts`, and clear state in `beforeEach` via `reset()`.
+ */
+
+import * as realChildProcess from "node:child_process";
+import { mock } from "bun:test";
+
+type ExecCallback = (
+  err: Error | null,
+  stdout: string | Buffer,
+  stderr: string | Buffer,
+) => void;
+
+export interface ExecScript {
+  /** When set, the call rejects with this error. */
+  error?: Error;
+  /** When set, the call resolves with this stdout. */
+  stdout?: string;
+  /** When set, runs as the call executes (e.g. flip a which-stub flag). */
+  onCall?: () => void;
+}
+
+type ExecFileMock = ReturnType<
+  typeof mock<
+    (
+      command: string,
+      args: string[],
+      options: unknown,
+      callback?: ExecCallback,
+    ) => ReturnType<typeof realChildProcess.execFile>
+  >
+>;
+
+export interface ExecFileStubHandle {
+  /**
+   * Per-call scripted responses, keyed by `${command} ${args[0]}` so tests
+   * can target distinct subcommands (e.g. `<bunPath> add`) independently.
+   * Calls with no script reject with a recognizable "No script for <key>"
+   * error.
+   */
+  execScripts: Map<string, ExecScript>;
+  execFileMock: ExecFileMock;
+  /** Clears scripts and recorded calls. Call from `beforeEach`. */
+  reset(): void;
+}
+
+/** Installs a process-global `execFile` mock. Returns handles to drive it. */
+export function installExecFileStub(): ExecFileStubHandle {
+  const execScripts: Map<string, ExecScript> = new Map();
+
+  const execFileMock: ExecFileMock = mock(
+    (
+      command: string,
+      args: string[],
+      _options: unknown,
+      callback?: ExecCallback,
+    ) => {
+      const key = `${command} ${args[0]}`;
+      const script = execScripts.get(key);
+      queueMicrotask(() => {
+        if (!callback) return;
+        if (!script) {
+          callback(new Error(`No script for ${key}`), "", "");
+          return;
+        }
+        script.onCall?.();
+        if (script.error) {
+          callback(script.error, "", "");
+          return;
+        }
+        callback(null, script.stdout ?? "", "");
+      });
+      // Return value is not used by execFileWithTimeout.
+      return {} as ReturnType<typeof realChildProcess.execFile>;
+    },
+  );
+
+  mock.module("node:child_process", () => ({
+    ...realChildProcess,
+    execFile: execFileMock,
+  }));
+
+  return {
+    execScripts,
+    execFileMock,
+    reset(): void {
+      execScripts.clear();
+      execFileMock.mockClear();
+    },
+  };
+}

package/src/acp/__tests__/prepare-agent-env.test.ts

@@ -234,6 +234,103 @@ describe("prepareAgentEnv — claude-agent-acp gating", () => {
   });
 });
 
+describe("prepareAgentEnv - gemini gating", () => {
+  function seedVaultGeminiKey(key: string): void {
+    vaultStore.set("acp/gemini_api_key", key);
+  }
+
+  test("injects GEMINI_API_KEY from the vault via the broker when agent.env has no override", async () => {
+    seedVaultGeminiKey("vault-gem-AAA");
+
+    const prepared = await prepareAgentEnv({
+      command: "gemini",
+      args: ["--acp"],
+    });
+
+    expect(prepared.env?.GEMINI_API_KEY).toBe("vault-gem-AAA");
+  });
+
+  test("auto-registers metadata with acp_spawn in allowedTools when none exists", async () => {
+    seedVaultGeminiKey("vault-gem-auto-meta");
+
+    await prepareAgentEnv({ command: "gemini", args: ["--acp"] });
+
+    const meta = metadataStore.get("acp/gemini_api_key");
+    expect(meta).toBeDefined();
+    expect(meta!.allowedTools).toContain("acp_spawn");
+  });
+
+  test("a vault miss does NOT throw and spawns without GEMINI_API_KEY (key is optional)", async () => {
+    const prepared = await prepareAgentEnv({
+      command: "gemini",
+      args: ["--acp"],
+    });
+
+    expect(prepared.env).not.toHaveProperty("GEMINI_API_KEY");
+  });
+
+  test("respects explicit tool policy that excludes acp_spawn without failing the spawn", async () => {
+    metadataStore.set("acp/gemini_api_key", {
+      allowedTools: ["other_tool"],
+    });
+    seedVaultGeminiKey("vault-gem-restricted");
+
+    const prepared = await prepareAgentEnv({
+      command: "gemini",
+      args: ["--acp"],
+    });
+
+    expect(prepared.env).not.toHaveProperty("GEMINI_API_KEY");
+    const meta = metadataStore.get("acp/gemini_api_key");
+    expect(meta!.allowedTools).toEqual(["other_tool"]);
+  });
+
+  test("agent.env override wins over the vault entry and skips the broker (precedence pin)", async () => {
+    // Seed a vault value but no metadata: if the override path consulted the
+    // broker anyway, ensureAcpCredentialPolicy would create metadata here.
+    seedVaultGeminiKey("vault-gem-CCC");
+
+    const prepared = await prepareAgentEnv({
+      command: "gemini",
+      args: ["--acp"],
+      env: { GEMINI_API_KEY: "config-gem-DDD" },
+    });
+
+    expect(prepared.env?.GEMINI_API_KEY).toBe("config-gem-DDD");
+    expect(metadataStore.has("acp/gemini_api_key")).toBe(false);
+  });
+
+  test("preserves unrelated env vars on agent.env when injecting from the vault", async () => {
+    seedVaultGeminiKey("vault-gem-EEE");
+
+    const prepared = await prepareAgentEnv({
+      command: "gemini",
+      args: ["--acp"],
+      env: { NO_COLOR: "1" },
+    });
+
+    expect(prepared.env?.GEMINI_API_KEY).toBe("vault-gem-EEE");
+    expect(prepared.env?.NO_COLOR).toBe("1");
+  });
+
+  test("does NOT mutate the caller's agentConfig", async () => {
+    seedVaultGeminiKey("vault-gem-GGG");
+    const original = {
+      command: "gemini",
+      args: ["--acp"],
+      env: { OTHER: "keep" },
+    };
+    const beforeEnv = { ...original.env };
+
+    const prepared = await prepareAgentEnv(original);
+
+    expect(prepared).not.toBe(original);
+    expect(prepared.env).not.toBe(original.env);
+    expect(original.env).toEqual(beforeEnv);
+    expect(original.env).not.toHaveProperty("GEMINI_API_KEY");
+  });
+});
+
 describe("prepareAgentEnv — non-claude commands", () => {
   test("returns the config unchanged for codex-acp (no required env vars today)", async () => {
     const prepared = await prepareAgentEnv({

package/src/acp/__tests__/session-manager-persistence.test.ts

@@ -23,35 +23,13 @@ import type { ServerMessage } from "../../daemon/message-protocol.js";
 import type { AcpSessionUpdate } from "../../daemon/message-types/acp.js";
 import { getSqlite } from "../../memory/db-connection.js";
 import { initializeDb } from "../../memory/db-init.js";
+import {
+  clearHistory,
+  insertHistoryRow,
+  readHistoryRow,
+} from "./helpers/acp-history-db.js";
 initializeDb();
 
-function clearHistory() {
-  getSqlite().run("DELETE FROM acp_session_history");
-}
-
-interface HistoryRow {
-  id: string;
-  agent_id: string;
-  acp_session_id: string;
-  parent_conversation_id: string;
-  started_at: number;
-  completed_at: number | null;
-  status: string;
-  stop_reason: string | null;
-  error: string | null;
-  event_log_json: string;
-}
-
-function readHistoryRow(id: string): HistoryRow | null {
-  return getSqlite()
-    .query(
-      `SELECT id, agent_id, acp_session_id, parent_conversation_id,
-              started_at, completed_at, status, stop_reason, error, event_log_json
-       FROM acp_session_history WHERE id = ?`,
-    )
-    .get(id) as HistoryRow | null;
-}
-
 /**
  * Builds a manager with a fake session pre-injected and returns the handles
  * needed to drive terminal transitions in tests.
@@ -61,6 +39,7 @@ function buildSessionWithFakeProcess(opts: {
   agentId: string;
   protocolSessionId: string;
   parentConversationId: string;
+  cwd?: string;
 }): {
   manager: AcpSessionManager;
   resolvePrompt: (v: { stopReason: string }) => void;
@@ -126,7 +105,7 @@ function buildSessionWithFakeProcess(opts: {
     sendToVellum: wrappedSend,
     currentPrompt: null as Promise<unknown> | null,
     parentConversationId: opts.parentConversationId,
-    cwd: "/tmp",
+    cwd: opts.cwd ?? "/tmp",
     command: "claude-agent-acp",
   };
   sessions.set(opts.id, entry);
@@ -345,6 +324,94 @@ describe("AcpSessionManager — terminal persistence", () => {
     expect(row!.event_log_json.length).toBeLessThan(256 * 1024 + 1024);
   });
 
+  test("persists the spawn cwd on terminal transition", async () => {
+    const id = "session-cwd-1";
+    const handles = buildSessionWithFakeProcess({
+      id,
+      agentId: "agent-cwd",
+      protocolSessionId: "proto-cwd",
+      parentConversationId: "conv-cwd",
+      cwd: "/Users/me/projects/widget",
+    });
+
+    handles.resolvePrompt({ stopReason: "end_turn" });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const row = readHistoryRow(id);
+    expect(row).not.toBeNull();
+    expect(row!.cwd).toBe("/Users/me/projects/widget");
+  });
+
+  test("legacy rows without a cwd read back as null", () => {
+    insertHistoryRow({
+      id: "legacy-row-1",
+      agentId: "agent-legacy",
+      acpSessionId: "proto-legacy",
+      parentConversationId: "conv-legacy",
+      startedAt: 1000,
+      completedAt: null,
+      status: "completed",
+      stopReason: null,
+      cwd: null,
+    });
+
+    const row = readHistoryRow("legacy-row-1");
+    expect(row).not.toBeNull();
+    expect(row!.cwd).toBeNull();
+  });
+
+  test("upserts over a pre-existing row with the same id (resumed runs)", async () => {
+    const id = "session-upsert-1";
+    // Simulate the row left behind by the original run that a resumed run
+    // reuses the id of.
+    insertHistoryRow({
+      id,
+      agentId: "agent-up",
+      acpSessionId: "proto-up",
+      parentConversationId: "conv-up",
+      startedAt: 1000,
+      completedAt: 2000,
+      status: "cancelled",
+      stopReason: "daemon_restarted",
+      eventLogJson: '[{"old":true}]',
+      cwd: "/old/cwd",
+    });
+
+    const handles = buildSessionWithFakeProcess({
+      id,
+      agentId: "agent-up",
+      protocolSessionId: "proto-up",
+      parentConversationId: "conv-up",
+      cwd: "/new/cwd",
+    });
+
+    handles.emitUpdate({
+      type: "acp_session_update",
+      acpSessionId: id,
+      updateType: "agent_message_chunk",
+      content: "from the resumed run",
+    });
+
+    handles.resolvePrompt({ stopReason: "end_turn" });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const count = getSqlite()
+      .query(`SELECT COUNT(*) AS n FROM acp_session_history WHERE id = ?`)
+      .get(id) as { n: number };
+    expect(count.n).toBe(1);
+
+    const row = readHistoryRow(id);
+    expect(row).not.toBeNull();
+    expect(row!.status).toBe("completed");
+    expect(row!.stop_reason).toBe("end_turn");
+    expect(row!.cwd).toBe("/new/cwd");
+    const log = JSON.parse(row!.event_log_json) as AcpSessionUpdate[];
+    expect(log).toHaveLength(1);
+    expect(log[0]).toMatchObject({ content: "from the resumed run" });
+  });
+
   test("persists empty event log when no updates were emitted", async () => {
     const id = "session-empty-1";
     const handles = buildSessionWithFakeProcess({