@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/telemetry/watchdog-direct-emit.ts

@@ -0,0 +1,89 @@
+/**
+ * Direct (unbuffered) emit of a single `watchdog` telemetry event.
+ *
+ * The usual watchdog path persists to the SQLite `watchdog_events` table and
+ * lets {@link ./usage-telemetry-reporter} batch and upload it later. That
+ * durable buffer is the right default — it survives restarts and dedupes on
+ * `daemon_event_id`. But it is the wrong tool for a check that fires *because*
+ * SQLite is unusable: recording a corruption event into SQLite can hit the very
+ * damage it is reporting, and the store's `recordWatchdogEvent` drags the whole
+ * `db-connection` graph in behind it.
+ *
+ * This helper POSTs the event straight to the platform ingest instead. It is
+ * best-effort: opt-out, missing credentials (early boot, before the CES
+ * handshake), platform-disabled, and HTTP failures all no-op. No retry — a lost
+ * event is acceptable for a rare, high-signal check. Deduped downstream on
+ * `daemon_event_id` like every other telemetry event.
+ */
+
+import { v4 as uuid } from "uuid";
+
+import { getPlatformOrganizationId, getPlatformUserId } from "../config/env.js";
+import { VellumPlatformClient } from "../platform/client.js";
+import { getCachedShareAnalytics } from "../platform/consent-cache.js";
+import { arePlatformFeaturesEnabled } from "../platform/feature-gate.js";
+import { getDeviceId } from "../util/device-id.js";
+import { getLogger } from "../util/logger.js";
+import { APP_VERSION } from "../version.js";
+import type { WatchdogTelemetryEvent } from "./types.js";
+
+const log = getLogger("watchdog-direct-emit");
+
+/** Platform telemetry ingest endpoint (same one the batched reporter POSTs to). */
+const TELEMETRY_INGEST_PATH = "/v1/telemetry/ingest/";
+
+/**
+ * POST one `watchdog` event directly to the platform, bypassing the SQLite
+ * buffer. Honors the `share_analytics` opt-out and the platform-features gate,
+ * matching the batched reporter. Never throws — the caller is on a query hot
+ * path.
+ */
+export async function emitWatchdogEventDirect(
+  checkName: string,
+  detail: Record<string, unknown> | null,
+  value: number | null = null,
+): Promise<void> {
+  try {
+    // Opt-out and deployment gates, mirroring the batched reporter's flush.
+    if (!getCachedShareAnalytics()) return;
+    if (!arePlatformFeaturesEnabled()) return;
+
+    // Authenticated-only. Null before the CES handshake resolves credentials;
+    // the event is simply dropped (no durable backlog to retry from).
+    const client = await VellumPlatformClient.create();
+    if (!client) return;
+
+    const event: WatchdogTelemetryEvent = {
+      type: "watchdog",
+      daemon_event_id: uuid(),
+      recorded_at: Date.now(),
+      check_name: checkName,
+      value,
+      detail,
+      assistant_version: APP_VERSION,
+    };
+    const organizationId = getPlatformOrganizationId() || undefined;
+    const userId = getPlatformUserId() || undefined;
+    const resp = await client.fetch(TELEMETRY_INGEST_PATH, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        device_id: getDeviceId(),
+        assistant_version: APP_VERSION,
+        ...(organizationId ? { organization_id: organizationId } : {}),
+        ...(userId ? { user_id: userId } : {}),
+        events: [event],
+      }),
+    });
+    // Consume the body to release the connection, mirroring the reporter.
+    await resp.text();
+    if (!resp.ok) {
+      log.warn(
+        { status: resp.status, checkName },
+        "Direct watchdog telemetry POST failed (non-fatal)",
+      );
+    }
+  } catch (err) {
+    log.warn({ err, checkName }, "Direct watchdog telemetry emit failed");
+  }
+}

package/src/tools/acp/list-agents.test.ts

@@ -43,7 +43,6 @@ describe("executeAcpListAgents", () => {
     expect(parsed.agents.map((a: { id: string }) => a.id)).toEqual([
       "claude",
       "codex",
-      "gemini",
     ]);
     for (const entry of parsed.agents) {
       expect(entry.source).toBe("default");
@@ -93,11 +92,6 @@ describe("executeAcpListAgents", () => {
     expect(codex.unavailableReason).toBe("'codex-acp' is not on PATH");
     expect(codex.setupHint).toBe("bun add -g @zed-industries/codex-acp");
 
-    const gemini = parsed.agents.find((a: { id: string }) => a.id === "gemini");
-    expect(gemini.available).toBe(false);
-    expect(gemini.unavailableReason).toBe("'gemini' is not on PATH");
-    expect(gemini.setupHint).toBe("bun add -g @google/gemini-cli");
-
     const claude = parsed.agents.find((a: { id: string }) => a.id === "claude");
     expect(claude.available).toBe(true);
     expect(claude.setupHint).toBeUndefined();

package/src/tools/background-tool-registry.ts

@@ -22,11 +22,38 @@ export interface BackgroundTool {
   cancel: (reason?: string) => void;
 }
 
+/**
+ * A finished background tool, retained briefly so a client that missed the live
+ * `background_tool_completed` event (chat route unmounted, or opened on another
+ * conversation) can recover the authoritative terminal status on rehydration
+ * instead of wrongly retiring the entry as cancelled. Mirrors the ACP-run
+ * snapshot route, which likewise reports recently-completed runs.
+ */
+export interface CompletedBackgroundTool {
+  id: string;
+  toolName: string;
+  conversationId: string;
+  command: string;
+  startedAt: number;
+  status: "completed" | "failed" | "cancelled";
+  exitCode: number | null;
+  output: string;
+  completedAt: number;
+}
+
 /** Maximum number of concurrent background tools allowed. */
 export const MAX_BACKGROUND_TOOLS = 20;
 
+/** How many recently-completed tools to retain for rehydration recovery. */
+export const MAX_COMPLETED_BACKGROUND_TOOLS = 50;
+
 const registry = new Map<string, BackgroundTool>();
 
+// FIFO ring of recently-completed tools, oldest first. Bounded by
+// MAX_COMPLETED_BACKGROUND_TOOLS so a long-lived daemon can't accumulate
+// unbounded captured output.
+const completedRing: CompletedBackgroundTool[] = [];
+
 /**
  * Registers a background tool in the in-memory store.
  * Throws if the registry would exceed {@link MAX_BACKGROUND_TOOLS}.
@@ -45,6 +72,39 @@ export function removeBackgroundTool(id: string): void {
   registry.delete(id);
 }
 
+/**
+ * Records a finished background tool in the recently-completed ring so the
+ * client can recover its terminal status on rehydration. Idempotent per id —
+ * a re-record (e.g. a racing close/error pair) replaces the existing entry
+ * rather than duplicating it. Does not touch the active registry; callers still
+ * {@link removeBackgroundTool} as before.
+ */
+export function recordCompletedBackgroundTool(
+  completion: CompletedBackgroundTool,
+): void {
+  const existingIdx = completedRing.findIndex((c) => c.id === completion.id);
+  if (existingIdx !== -1) {
+    completedRing[existingIdx] = completion;
+    return;
+  }
+  completedRing.push(completion);
+  if (completedRing.length > MAX_COMPLETED_BACKGROUND_TOOLS) {
+    completedRing.shift();
+  }
+}
+
+/**
+ * Returns the recently-completed tools, optionally filtered by
+ * `conversationId`, oldest first.
+ */
+export function listCompletedBackgroundTools(
+  conversationId?: string,
+): CompletedBackgroundTool[] {
+  const all = completedRing.slice();
+  if (conversationId === undefined) return all;
+  return all.filter((t) => t.conversationId === conversationId);
+}
+
 /**
  * Returns all registered background tools, optionally filtered by
  * `conversationId`.
@@ -109,4 +169,5 @@ export function isBackgroundToolLimitReached(): boolean {
  */
 export function _clearRegistryForTesting(): void {
   registry.clear();
+  completedRing.length = 0;
 }

package/src/tools/document/document-comment-tool.test.ts

@@ -49,12 +49,14 @@ function seedDocument(
 ): void {
   const now = Date.now();
   rawRun(
+    "test:seedConversation",
     /*sql*/ `INSERT OR IGNORE INTO conversations (id, created_at, updated_at) VALUES (?, ?, ?)`,
     conversationId,
     now,
     now,
   );
   rawRun(
+    "test:seedDocument",
     /*sql*/ `INSERT OR IGNORE INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at)
      VALUES (?, ?, 'Test Doc', 'body', 2, ?, ?)`,
     surfaceId,
@@ -63,6 +65,7 @@ function seedDocument(
     now,
   );
   rawRun(
+    "test:seedDocConversation",
     /*sql*/ `INSERT OR IGNORE INTO document_conversations (surface_id, conversation_id, created_at) VALUES (?, ?, ?)`,
     surfaceId,
     conversationId,
@@ -100,6 +103,7 @@ describe("executeCommentList", () => {
     });
     // Resolve one directly via the store
     rawRun(
+      "test:resolveComment",
       /*sql*/ `UPDATE document_comments SET status = 'resolved', resolved_by = 'user1', resolved_at = ? WHERE id = ?`,
       Date.now(),
       c2.id,

package/src/tools/host-terminal/host-shell.test.ts

@@ -0,0 +1,397 @@
+import { EventEmitter } from "node:events";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module mocks — must be declared before importing the tool under test.
+// ---------------------------------------------------------------------------
+
+const mockWakeAgentForOpportunity = mock(() => Promise.resolve());
+
+mock.module("../../runtime/agent-wake.js", () => ({
+  wakeAgentForOpportunity: mockWakeAgentForOpportunity,
+}));
+
+// Capture every broadcastMessage call so tests can assert lifecycle events.
+type Broadcast = Record<string, unknown> & { type: string };
+const broadcasts: Broadcast[] = [];
+const mockBroadcastMessage = mock((msg: Broadcast) => {
+  broadcasts.push(msg);
+});
+
+mock.module("../../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    listClientsByCapability: () => [],
+  },
+  broadcastMessage: mockBroadcastMessage,
+}));
+
+type RegisteredTool = {
+  id: string;
+  toolName: string;
+  conversationId: string;
+  command: string;
+  startedAt: number;
+  cancel: (reason?: string) => void;
+};
+
+let latestRegistered: RegisteredTool | undefined;
+const mockRegisterBackgroundTool = mock((entry: RegisteredTool) => {
+  latestRegistered = entry;
+});
+const mockRemoveBackgroundTool = mock(() => {});
+let bgIdCounter = 0;
+const mockGenerateBackgroundToolId = mock(
+  () => `bg-test-${String(++bgIdCounter).padStart(4, "0")}`,
+);
+const mockIsBackgroundToolLimitReached = mock(() => false);
+
+mock.module("../background-tool-registry.js", () => ({
+  registerBackgroundTool: mockRegisterBackgroundTool,
+  removeBackgroundTool: mockRemoveBackgroundTool,
+  recordCompletedBackgroundTool: () => {},
+  generateBackgroundToolId: mockGenerateBackgroundToolId,
+  isBackgroundToolLimitReached: mockIsBackgroundToolLimitReached,
+  MAX_BACKGROUND_TOOLS: 20,
+}));
+
+// Stub child_process.spawn so we don't actually run commands. The test
+// creates a fake ChildProcess (EventEmitter) and drives it manually.
+type FakeChild = EventEmitter & {
+  pid: number | undefined;
+  stdout: EventEmitter;
+  stderr: EventEmitter;
+  kill: ReturnType<typeof mock>;
+};
+
+let latestChild: FakeChild | undefined;
+
+function makeFakeChild(): FakeChild {
+  const child = new EventEmitter() as FakeChild;
+  child.pid = 12345;
+  child.stdout = new EventEmitter();
+  child.stderr = new EventEmitter();
+  child.kill = mock(() => {});
+  latestChild = child;
+  return child;
+}
+
+mock.module("node:child_process", () => ({
+  spawn: mock(() => makeFakeChild()),
+}));
+
+const mockConfig = {
+  provider: "anthropic",
+  model: "test",
+  maxTokens: 4096,
+  dataDir: "/tmp",
+  timeouts: {
+    shellDefaultTimeoutSec: 120,
+    shellMaxTimeoutSec: 600,
+    permissionTimeoutSec: 300,
+  },
+  rateLimit: { maxRequestsPerMinute: 0 },
+  secretDetection: { enabled: true },
+  auditLog: { retentionDays: 0 },
+};
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => mockConfig,
+  loadConfig: () => mockConfig,
+  invalidateConfigCache: () => {},
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+}));
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Mock HostBashProxy singleton — proxy delegation tests configure this.
+let mockProxyAvailable = false;
+let mockProxyRequestImpl: (
+  input: { command: string },
+  conversationId: string,
+  signal?: AbortSignal,
+) => Promise<ToolExecutionResult> = () =>
+  Promise.resolve({ content: "", isError: false });
+
+mock.module("../../daemon/host-bash-proxy.js", () => ({
+  HostBashProxy: {
+    get instance() {
+      return {
+        isAvailable: () => mockProxyAvailable,
+        request: (...args: Parameters<typeof mockProxyRequestImpl>) =>
+          mockProxyRequestImpl(...args),
+      };
+    },
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Import under test — MUST come after mock.module calls.
+// ---------------------------------------------------------------------------
+
+import type { ToolContext, ToolExecutionResult } from "../types.js";
+import { hostShellTool } from "./host-shell.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
+  return {
+    workingDir: "/tmp",
+    conversationId: "conv-xyz",
+    trustClass: "guardian",
+    ...overrides,
+  };
+}
+
+const flush = () => new Promise((r) => setTimeout(r, 10));
+
+function startedEvents(): Broadcast[] {
+  return broadcasts.filter((b) => b.type === "background_tool_started");
+}
+
+function completedEvents(): Broadcast[] {
+  return broadcasts.filter((b) => b.type === "background_tool_completed");
+}
+
+/** Controllable promise so cancel can fire before the proxy resolves. */
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (err: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+// ---------------------------------------------------------------------------
+// Test setup / teardown
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  bgIdCounter = 0;
+  broadcasts.length = 0;
+  latestRegistered = undefined;
+  mockWakeAgentForOpportunity.mockClear();
+  mockBroadcastMessage.mockClear();
+  mockRegisterBackgroundTool.mockClear();
+  mockRemoveBackgroundTool.mockClear();
+  mockGenerateBackgroundToolId.mockClear();
+  mockIsBackgroundToolLimitReached.mockClear();
+  mockIsBackgroundToolLimitReached.mockReturnValue(false);
+  latestChild = undefined;
+  mockProxyAvailable = false;
+  mockProxyRequestImpl = () => Promise.resolve({ content: "", isError: false });
+});
+
+afterEach(() => {
+  latestChild = undefined;
+  mockProxyAvailable = false;
+});
+
+// ---------------------------------------------------------------------------
+// Proxy path — background: true
+// ---------------------------------------------------------------------------
+
+describe("host_bash background lifecycle events — proxy path", () => {
+  test("broadcasts started then completed on success", async () => {
+    mockProxyAvailable = true;
+    mockProxyRequestImpl = () =>
+      Promise.resolve({ content: "proxy output", isError: false });
+
+    await hostShellTool.execute(
+      { command: "echo bg-proxy", background: true },
+      makeContext(),
+    );
+    await flush();
+
+    const started = startedEvents();
+    expect(started).toHaveLength(1);
+    expect(started[0]).toMatchObject({
+      type: "background_tool_started",
+      id: "bg-test-0001",
+      toolName: "host_bash",
+      conversationId: "conv-xyz",
+      command: "echo bg-proxy",
+    });
+    expect(typeof started[0]!.startedAt).toBe("number");
+
+    const completed = completedEvents();
+    expect(completed).toHaveLength(1);
+    expect(completed[0]).toMatchObject({
+      type: "background_tool_completed",
+      id: "bg-test-0001",
+      conversationId: "conv-xyz",
+      status: "completed",
+      output: "proxy output",
+    });
+    expect(typeof completed[0]!.completedAt).toBe("number");
+  });
+
+  test("completed status is failed on proxy error result", async () => {
+    mockProxyAvailable = true;
+    mockProxyRequestImpl = () =>
+      Promise.resolve({ content: "command not found", isError: true });
+
+    await hostShellTool.execute(
+      { command: "bad-command", background: true },
+      makeContext(),
+    );
+    await flush();
+
+    const completed = completedEvents();
+    expect(completed).toHaveLength(1);
+    expect(completed[0]).toMatchObject({
+      status: "failed",
+      output: "command not found",
+    });
+  });
+
+  test("completed status is failed on proxy rejection", async () => {
+    mockProxyAvailable = true;
+    mockProxyRequestImpl = () =>
+      Promise.reject(new Error("proxy transport error"));
+
+    await hostShellTool.execute(
+      { command: "echo fail", background: true },
+      makeContext(),
+    );
+    await flush();
+
+    const completed = completedEvents();
+    expect(completed).toHaveLength(1);
+    expect(completed[0]).toMatchObject({ status: "failed" });
+    expect(completed[0]!.output).toContain("proxy transport error");
+  });
+
+  test("cancelling an in-flight proxy command reports cancelled", async () => {
+    mockProxyAvailable = true;
+    const d = deferred<ToolExecutionResult>();
+    // request() swallows the aborted rejection and resolves with an "Aborted"
+    // result; the tripped signal is what marks the command as cancelled.
+    mockProxyRequestImpl = () => d.promise;
+
+    await hostShellTool.execute(
+      { command: "sleep 100", background: true },
+      makeContext(),
+    );
+
+    // started fired synchronously; not yet completed.
+    expect(startedEvents()).toHaveLength(1);
+    expect(completedEvents()).toHaveLength(0);
+
+    // Cancel via the registry callback, then let request() resolve.
+    expect(latestRegistered).toBeDefined();
+    latestRegistered!.cancel("user cancelled");
+    d.resolve({ content: "Aborted", isError: true });
+    await flush();
+
+    const completed = completedEvents();
+    expect(completed).toHaveLength(1);
+    expect(completed[0]).toMatchObject({ status: "cancelled" });
+    // Cancellation must surface a cancellation message, not "failed" framing.
+    expect(completed[0]!.output).toContain("cancelled");
+    expect(completed[0]!.output).not.toContain("failed");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Direct execution path — background: true
+// ---------------------------------------------------------------------------
+
+describe("host_bash background lifecycle events — direct spawn path", () => {
+  test("broadcasts started then completed on clean exit", async () => {
+    await hostShellTool.execute(
+      { command: "echo bg-local", background: true },
+      makeContext(),
+    );
+
+    const started = startedEvents();
+    expect(started).toHaveLength(1);
+    expect(started[0]).toMatchObject({
+      type: "background_tool_started",
+      id: "bg-test-0001",
+      toolName: "host_bash",
+      conversationId: "conv-xyz",
+      command: "echo bg-local",
+    });
+
+    expect(latestChild).toBeDefined();
+    latestChild!.stdout.emit("data", Buffer.from("hello world\n"));
+    latestChild!.emit("close", 0);
+    await flush();
+
+    const completed = completedEvents();
+    expect(completed).toHaveLength(1);
+    expect(completed[0]).toMatchObject({
+      type: "background_tool_completed",
+      id: "bg-test-0001",
+      status: "completed",
+      exitCode: 0,
+    });
+    expect(completed[0]!.output).toContain("hello world");
+  });
+
+  test("completed status is failed on non-zero exit", async () => {
+    await hostShellTool.execute(
+      { command: "false", background: true },
+      makeContext(),
+    );
+
+    latestChild!.stderr.emit("data", Buffer.from("boom\n"));
+    latestChild!.emit("close", 1);
+    await flush();
+
+    const completed = completedEvents();
+    expect(completed).toHaveLength(1);
+    expect(completed[0]).toMatchObject({ status: "failed", exitCode: 1 });
+  });
+
+  test("completed status is failed on spawn error", async () => {
+    await hostShellTool.execute(
+      { command: "echo bg-error", background: true },
+      makeContext(),
+    );
+
+    latestChild!.emit("error", new Error("spawn ENOENT"));
+    await flush();
+
+    const completed = completedEvents();
+    expect(completed).toHaveLength(1);
+    expect(completed[0]).toMatchObject({ status: "failed" });
+    expect(completed[0]!.output).toContain("spawn ENOENT");
+  });
+
+  test("cancelling a direct background command reports cancelled", async () => {
+    await hostShellTool.execute(
+      { command: "sleep 100", background: true },
+      makeContext(),
+    );
+
+    expect(startedEvents()).toHaveLength(1);
+    expect(latestRegistered).toBeDefined();
+
+    // Avoid signalling a real process group; force the child.kill() fallback.
+    latestChild!.pid = undefined;
+    latestRegistered!.cancel("user cancelled");
+    // A cancel SIGKILLs the child, which then closes with a null exit code.
+    latestChild!.emit("close", null);
+    await flush();
+
+    const completed = completedEvents();
+    expect(completed).toHaveLength(1);
+    expect(completed[0]).toMatchObject({ status: "cancelled" });
+    // Cancellation must surface a cancellation message, not "failed" framing.
+    expect(completed[0]!.output).toContain("cancelled");
+    expect(completed[0]!.output).not.toContain("failed");
+  });
+});