@vellumai/assistant 0.4.46 → 0.4.49

package/src/__tests__/computer-use-skill-lifecycle-cleanup.test.ts

@@ -1,249 +0,0 @@
-import { beforeAll, describe, expect, mock, test } from "bun:test";
-
-// Mock config before importing modules that depend on it.
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    provider: "mock-provider",
-    permissions: { mode: "workspace" },
-    apiKeys: {},
-    sandbox: { enabled: false },
-    timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },
-    skills: { load: { extraDirs: [] } },
-    secretDetection: { enabled: false },
-    contextWindow: {
-      enabled: true,
-      maxInputTokens: 180000,
-      targetBudgetRatio: 0.30,
-      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
-    },
-  }),
-  invalidateConfigCache: () => {},
-}));
-
-import { ComputerUseSession } from "../daemon/computer-use-session.js";
-import type { CuObservation } from "../daemon/message-protocol.js";
-import type { Provider, ProviderResponse } from "../providers/types.js";
-import {
-  __resetRegistryForTesting,
-  getAllTools,
-  getSkillRefCount,
-  initializeTools,
-} from "../tools/registry.js";
-
-function createProvider(responses: ProviderResponse[]): Provider {
-  let calls = 0;
-  return {
-    name: "mock",
-    async sendMessage() {
-      const response = responses[calls] ?? responses[responses.length - 1];
-      calls++;
-      return response;
-    },
-  };
-}
-
-const doneResponse: ProviderResponse = {
-  content: [
-    {
-      type: "tool_use",
-      id: "tu-cleanup",
-      name: "computer_use_done",
-      input: { summary: "Done" },
-    },
-  ],
-  model: "mock-model",
-  usage: { inputTokens: 10, outputTokens: 5 },
-  stopReason: "tool_use",
-};
-
-const observation: CuObservation = {
-  type: "cu_observation",
-  sessionId: "cleanup-test",
-  axTree: 'Window "Test" [1]',
-};
-
-describe("CU session skill tool lifecycle cleanup", () => {
-  beforeAll(async () => {
-    __resetRegistryForTesting();
-    await initializeTools();
-  });
-
-  test("computer-use skill refcount is 0 after session completes via computer_use_done", async () => {
-    const provider = createProvider([doneResponse]);
-    const session = new ComputerUseSession(
-      "cleanup-done",
-      "test cleanup",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-    );
-
-    expect(getSkillRefCount("computer-use")).toBe(0);
-
-    await session.handleObservation({
-      ...observation,
-      sessionId: "cleanup-done",
-    });
-
-    expect(session.getState()).toBe("complete");
-    expect(getSkillRefCount("computer-use")).toBe(0);
-  });
-
-  test("computer-use skill refcount is 0 after session is aborted", async () => {
-    // Use a provider that hangs until the abort signal fires, keeping the
-    // session active long enough to abort after skill projection has occurred.
-    const hangingProvider: Provider = {
-      name: "mock",
-      sendMessage: (_msgs, _tools, _sys, opts) =>
-        new Promise<ProviderResponse>((_, reject) => {
-          if (opts?.signal?.aborted) {
-            reject(new DOMException("Aborted", "AbortError"));
-            return;
-          }
-          opts?.signal?.addEventListener(
-            "abort",
-            () => reject(new DOMException("Aborted", "AbortError")),
-            { once: true },
-          );
-        }),
-    };
-
-    const session = new ComputerUseSession(
-      "cleanup-abort",
-      "test abort cleanup",
-      1440,
-      900,
-      hangingProvider,
-      () => {},
-      "computer_use",
-    );
-
-    expect(getSkillRefCount("computer-use")).toBe(0);
-
-    // Start the session (don't await — it will hang on the provider call).
-    // Skill projection happens synchronously at the start of runAgentLoop,
-    // so by the time sendMessage is called the refcount has been incremented.
-    const sessionPromise = session.handleObservation({
-      ...observation,
-      sessionId: "cleanup-abort",
-    });
-
-    // Yield to let runAgentLoop start and reach the provider call
-    await new Promise((r) => setTimeout(r, 50));
-
-    session.abort();
-
-    // Let the session finish its cleanup
-    await sessionPromise;
-
-    expect(session.getState()).toBe("error");
-    expect(getSkillRefCount("computer-use")).toBe(0);
-  });
-
-  test("computer-use skill refcount is 0 after session completes via computer_use_respond", async () => {
-    const provider = createProvider([
-      {
-        content: [
-          {
-            type: "tool_use",
-            id: "tu-respond-cleanup",
-            name: "computer_use_respond",
-            input: { answer: "Test answer", reasoning: "Test reasoning" },
-          },
-        ],
-        model: "mock-model",
-        usage: { inputTokens: 10, outputTokens: 5 },
-        stopReason: "tool_use",
-      },
-    ]);
-
-    const session = new ComputerUseSession(
-      "cleanup-respond",
-      "test respond cleanup",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-    );
-
-    await session.handleObservation({
-      ...observation,
-      sessionId: "cleanup-respond",
-    });
-
-    expect(session.getState()).toBe("complete");
-    expect(getSkillRefCount("computer-use")).toBe(0);
-  });
-
-  test("only escalation tool remains in registry after session cleanup", async () => {
-    const provider = createProvider([doneResponse]);
-    const session = new ComputerUseSession(
-      "cleanup-registry-check",
-      "test registry cleanup",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-    );
-
-    await session.handleObservation({
-      ...observation,
-      sessionId: "cleanup-registry-check",
-    });
-
-    expect(session.getState()).toBe("complete");
-
-    const allTools = getAllTools();
-    const cuTools = allTools.filter((t) => t.name.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(1);
-    expect(cuTools[0].name).toBe("computer_use_request_control");
-  });
-
-  test("multiple sequential CU sessions do not leak refcounts", async () => {
-    for (let i = 0; i < 3; i++) {
-      const provider = createProvider([doneResponse]);
-      const session = new ComputerUseSession(
-        `cleanup-sequential-${i}`,
-        "test sequential cleanup",
-        1440,
-        900,
-        provider,
-        () => {},
-        "computer_use",
-      );
-
-      await session.handleObservation({
-        ...observation,
-        sessionId: `cleanup-sequential-${i}`,
-      });
-      expect(session.getState()).toBe("complete");
-    }
-
-    expect(getSkillRefCount("computer-use")).toBe(0);
-
-    const allTools = getAllTools();
-    const cuTools = allTools.filter((t) => t.name.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(1);
-    expect(cuTools[0].name).toBe("computer_use_request_control");
-  });
-
-  // Cross-suite regression: after CU sessions complete, core registry invariants hold
-  test("core registry has 1 computer_use_* tool after CU session lifecycle (escalation only)", () => {
-    const allTools = getAllTools();
-    const cuTools = allTools.filter((t) => t.name.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(1);
-    expect(cuTools[0].name).toBe("computer_use_request_control");
-  });
-
-  test("computer_use_request_control is in core registry after CU session lifecycle", async () => {
-    const { getTool } = await import("../tools/registry.js");
-    const tool = getTool("computer_use_request_control");
-    expect(tool).toBeDefined();
-  });
-});

package/src/__tests__/ride-shotgun-handler.test.ts

@@ -1,452 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { HandlerContext } from "../daemon/handlers/shared.js";
-
-// ── Mocks ──────────────────────────────────────────────────────────
-
-let mockEnsureChromeResult = {
-  baseUrl: "http://localhost:9222",
-  launchedByUs: false,
-  userDataDir: "/tmp/cdp-test",
-};
-let mockEnsureChromeShouldThrow = false;
-let mockMinimizeCalled = false;
-let mockMinimizeBaseUrl: string | undefined;
-
-mock.module("../tools/browser/chrome-cdp.js", () => ({
-  ensureChromeWithCdp: async () => {
-    if (mockEnsureChromeShouldThrow) {
-      throw new Error("Chrome launch failed");
-    }
-    return { ...mockEnsureChromeResult };
-  },
-  minimizeChromeWindow: async (baseUrl: string) => {
-    mockMinimizeCalled = true;
-    mockMinimizeBaseUrl = baseUrl;
-  },
-  isCdpReady: async () => true,
-  restoreChromeWindow: async () => {},
-}));
-
-let mockRecorderStartCalls = 0;
-let mockRecorderStartShouldThrow = false;
-let mockRecorderStartThrowCount = 0;
-let mockRecorderConstructorCdpBaseUrl: string | undefined;
-
-mock.module("../tools/browser/network-recorder.js", () => ({
-  NetworkRecorder: class MockNetworkRecorder {
-    loginSignals: string[] = [];
-    onLoginDetected?: () => void;
-    get entryCount() {
-      return 0;
-    }
-
-    constructor(_targetDomain?: string, cdpBaseUrl?: string) {
-      mockRecorderConstructorCdpBaseUrl = cdpBaseUrl;
-    }
-
-    async startDirect() {
-      mockRecorderStartCalls++;
-      if (
-        mockRecorderStartShouldThrow &&
-        mockRecorderStartCalls <= mockRecorderStartThrowCount
-      ) {
-        throw new Error("CDP not ready");
-      }
-    }
-
-    async stop() {
-      return [];
-    }
-
-    async extractCookies() {
-      return [];
-    }
-  },
-}));
-
-mock.module("../tools/browser/recording-store.js", () => ({
-  saveRecording: () => "/tmp/test-recording.json",
-}));
-
-mock.module("../tools/browser/auto-navigate.js", () => ({
-  autoNavigate: async () => [],
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    debug: () => {},
-    warn: () => {},
-    error: () => {},
-  }),
-}));
-
-const mockLastSummaryBySession = new Map<string, string>();
-mock.module("../daemon/watch-handler.js", () => ({
-  generateSummary: async () => {},
-  lastSummaryBySession: mockLastSummaryBySession,
-}));
-
-// ── Import under test (after mocks) ───────────────────────────────
-
-const { handleRideShotgunStart, handleRideShotgunStop } =
-  await import("../daemon/ride-shotgun-handler.js");
-const { watchSessions } = await import("../tools/watch/watch-state.js");
-
-// ── Helpers ────────────────────────────────────────────────────────
-
-function makeMockCtx() {
-  const sent: unknown[] = [];
-  return {
-    send: (msg: unknown) => sent.push(msg),
-    sent,
-  } as unknown as HandlerContext & { sent: unknown[] };
-}
-
-function waitForRecorderStart(timeoutMs = 3000): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const start = Date.now();
-    const poll = setInterval(() => {
-      if (mockRecorderStartCalls > 0) {
-        clearInterval(poll);
-        resolve();
-      } else if (Date.now() - start > timeoutMs) {
-        clearInterval(poll);
-        reject(new Error("Timed out waiting for recorder start"));
-      }
-    }, 50);
-  });
-}
-
-// ── Tests ──────────────────────────────────────────────────────────
-
-describe("ride-shotgun-handler", () => {
-  beforeEach(() => {
-    mockRecorderStartCalls = 0;
-    mockRecorderStartShouldThrow = false;
-    mockRecorderStartThrowCount = 0;
-    mockRecorderConstructorCdpBaseUrl = undefined;
-    mockMinimizeCalled = false;
-    mockMinimizeBaseUrl = undefined;
-    mockEnsureChromeShouldThrow = false;
-    mockEnsureChromeResult = {
-      baseUrl: "http://localhost:9222",
-      launchedByUs: false,
-      userDataDir: "/tmp/cdp-test",
-    };
-    mockLastSummaryBySession.clear();
-    watchSessions.clear();
-  });
-
-  afterEach(() => {
-    // Clean up any dangling sessions
-    for (const [, session] of watchSessions) {
-      if (session.timeoutHandle) clearTimeout(session.timeoutHandle);
-    }
-    watchSessions.clear();
-  });
-
-  test("learn mode calls ensureChromeWithCdp before starting recorder", async () => {
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 60,
-        intervalSeconds: 5,
-        mode: "learn",
-        targetDomain: "example.com",
-        autoNavigate: false,
-      },
-      ctx,
-    );
-
-    // Background recording start — wait for it
-    await waitForRecorderStart();
-
-    expect(mockRecorderStartCalls).toBe(1);
-    // The recorder should receive the CDP base URL from the session
-    expect(mockRecorderConstructorCdpBaseUrl).toBe("http://localhost:9222");
-  });
-
-  test("learn mode passes CDP base URL to NetworkRecorder constructor", async () => {
-    mockEnsureChromeResult = {
-      baseUrl: "http://localhost:9333",
-      launchedByUs: true,
-      userDataDir: "/tmp/cdp-custom",
-    };
-
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 60,
-        intervalSeconds: 5,
-        mode: "learn",
-        targetDomain: "example.com",
-        autoNavigate: false,
-      },
-      ctx,
-    );
-
-    await waitForRecorderStart();
-
-    expect(mockRecorderConstructorCdpBaseUrl).toBe("http://localhost:9333");
-  });
-
-  test("learn mode does not start recorder when ensureChromeWithCdp fails", async () => {
-    mockEnsureChromeShouldThrow = true;
-
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 60,
-        intervalSeconds: 5,
-        mode: "learn",
-        targetDomain: "example.com",
-        autoNavigate: false,
-      },
-      ctx,
-    );
-
-    // Give background task time to execute
-    await new Promise((r) => setTimeout(r, 200));
-
-    expect(mockRecorderStartCalls).toBe(0);
-  });
-
-  test("learn mode minimizes Chrome on completion when assistant launched it", async () => {
-    mockEnsureChromeResult = {
-      baseUrl: "http://localhost:9222",
-      launchedByUs: true,
-      userDataDir: "/tmp/cdp-test",
-    };
-
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 60,
-        intervalSeconds: 5,
-        mode: "learn",
-        targetDomain: "example.com",
-        autoNavigate: false,
-      },
-      ctx,
-    );
-
-    await waitForRecorderStart();
-
-    // Find the session and stop it
-    const watchId = [...watchSessions.keys()][0]!;
-    await handleRideShotgunStop({ type: "ride_shotgun_stop", watchId }, ctx);
-
-    expect(mockMinimizeCalled).toBe(true);
-    expect(mockMinimizeBaseUrl).toBe("http://localhost:9222");
-  });
-
-  test("learn mode does not minimize Chrome on completion when user launched it", async () => {
-    mockEnsureChromeResult = {
-      baseUrl: "http://localhost:9222",
-      launchedByUs: false,
-      userDataDir: "/tmp/cdp-test",
-    };
-
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 60,
-        intervalSeconds: 5,
-        mode: "learn",
-        targetDomain: "example.com",
-        autoNavigate: false,
-      },
-      ctx,
-    );
-
-    await waitForRecorderStart();
-
-    // Find the session and stop it
-    const watchId = [...watchSessions.keys()][0]!;
-    await handleRideShotgunStop({ type: "ride_shotgun_stop", watchId }, ctx);
-
-    expect(mockMinimizeCalled).toBe(false);
-  });
-
-  test("observe mode does not call ensureChromeWithCdp", async () => {
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 60,
-        intervalSeconds: 5,
-        mode: "observe",
-      },
-      ctx,
-    );
-
-    // Give time for any background tasks
-    await new Promise((r) => setTimeout(r, 200));
-
-    // In observe mode, no recorder should be started
-    expect(mockRecorderStartCalls).toBe(0);
-
-    // Clean up
-    const watchId = [...watchSessions.keys()][0]!;
-    await handleRideShotgunStop({ type: "ride_shotgun_stop", watchId }, ctx);
-  });
-
-  test("sends watch_started message with session IDs", async () => {
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 30,
-        intervalSeconds: 5,
-        mode: "learn",
-        targetDomain: "example.com",
-        autoNavigate: false,
-      },
-      ctx,
-    );
-
-    const startMsg = ctx.sent.find(
-      (m: any) => m.type === "watch_started",
-    ) as any;
-    expect(startMsg).toBeDefined();
-    expect(startMsg.sessionId).toBeDefined();
-    expect(startMsg.watchId).toBeDefined();
-    expect(startMsg.durationSeconds).toBe(30);
-
-    // Clean up
-    const watchId = startMsg.watchId;
-    await handleRideShotgunStop({ type: "ride_shotgun_stop", watchId }, ctx);
-  });
-
-  test("sends ride_shotgun_error when ensureChromeWithCdp fails", async () => {
-    mockEnsureChromeShouldThrow = true;
-
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 60,
-        intervalSeconds: 5,
-        mode: "learn",
-        targetDomain: "example.com",
-        autoNavigate: false,
-      },
-      ctx,
-    );
-
-    // Give background task time to execute and complete session
-    await new Promise((r) => setTimeout(r, 500));
-
-    const errorMsg = ctx.sent.find(
-      (m: any) => m.type === "ride_shotgun_error",
-    ) as any;
-    expect(errorMsg).toBeDefined();
-    expect(errorMsg.watchId).toBeDefined();
-    expect(errorMsg.sessionId).toBeDefined();
-    expect(errorMsg.message).toContain("Chrome CDP");
-  });
-
-  test("cleans up session when ensureChromeWithCdp fails", async () => {
-    mockEnsureChromeShouldThrow = true;
-
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 60,
-        intervalSeconds: 5,
-        mode: "learn",
-        targetDomain: "example.com",
-        autoNavigate: false,
-      },
-      ctx,
-    );
-
-    // Give background task time to execute
-    await new Promise((r) => setTimeout(r, 500));
-
-    // Session should be completed (not left hanging for the full duration)
-    const session = [...watchSessions.values()][0];
-    expect(session?.status).toBe("completed");
-  });
-
-  test("reports failure summary when no recorder ever started", async () => {
-    mockEnsureChromeShouldThrow = true;
-
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 60,
-        intervalSeconds: 5,
-        mode: "learn",
-        targetDomain: "example.com",
-        autoNavigate: false,
-      },
-      ctx,
-    );
-
-    // Give background task time to execute
-    await new Promise((r) => setTimeout(r, 500));
-
-    // The result message should indicate the specific CDP failure
-    const resultMsg = ctx.sent.find(
-      (m: any) => m.type === "ride_shotgun_result",
-    ) as any;
-    expect(resultMsg).toBeDefined();
-    expect(resultMsg.summary).toContain("failed");
-    expect(resultMsg.summary).toContain("browser could not be started");
-    expect(resultMsg.summary).not.toContain("recording saved");
-  });
-
-  test("sends ride_shotgun_error when all 10 recorder retries fail", async () => {
-    mockRecorderStartShouldThrow = true;
-    mockRecorderStartThrowCount = 10;
-
-    const ctx = makeMockCtx();
-
-    await handleRideShotgunStart(
-      {
-        type: "ride_shotgun_start",
-        durationSeconds: 60,
-        intervalSeconds: 5,
-        mode: "learn",
-        targetDomain: "example.com",
-        autoNavigate: false,
-      },
-      ctx,
-    );
-
-    // Wait for all 10 retry attempts (each has a 2s delay except the last)
-    // 9 retries * 2s = 18s, but mock doesn't actually wait — it should complete quickly
-    // The mock delays are real setTimeout calls, so we need enough time
-    await new Promise((r) => setTimeout(r, 25000));
-
-    const errorMsg = ctx.sent.find(
-      (m: any) => m.type === "ride_shotgun_error",
-    ) as any;
-    expect(errorMsg).toBeDefined();
-    expect(errorMsg.message).toContain("10 attempts");
-
-    // Session should be completed
-    const session = [...watchSessions.values()][0];
-    expect(session?.status).toBe("completed");
-  }, 30000); // Extended timeout for retry delays
-});