@vellumai/assistant 0.4.48 → 0.4.49

package/src/__tests__/computer-use-session-working-dir.test.ts

@@ -1,166 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { CuObservation } from "../daemon/message-protocol.js";
-import type { Provider } from "../providers/types.js";
-
-let capturedWorkingDir: string | undefined;
-
-const noopLogger = new Proxy({} as Record<string, unknown>, {
-  get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
-});
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realLogger = require("../util/logger.js");
-mock.module("../util/logger.js", () => ({
-  ...realLogger,
-  getLogger: () => noopLogger,
-  getCliLogger: () => noopLogger,
-  isDebug: () => false,
-  truncateForLog: (value: string, maxLen = 500) =>
-    value.length > maxLen ? value.slice(0, maxLen) + "..." : value,
-  initLogger: () => {},
-  pruneOldLogFiles: () => 0,
-}));
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realPlatform = require("../util/platform.js");
-mock.module("../util/platform.js", () => ({
-  ...realPlatform,
-  getRootDir: () => "/tmp",
-  getDataDir: () => "/tmp/data",
-
-  getSandboxRootDir: () => "/tmp/sandbox",
-  getSandboxWorkingDir: () => "/tmp/workspace",
-  getInterfacesDir: () => "/tmp/interfaces",
-  getWorkspaceDir: () => "/tmp/workspace",
-  getWorkspaceConfigPath: () => "/tmp/workspace/config.json",
-  getWorkspaceSkillsDir: () => "/tmp/workspace/skills",
-  getWorkspaceHooksDir: () => "/tmp/workspace/hooks",
-  getWorkspacePromptPath: (file: string) => `/tmp/workspace/${file}`,
-  getPlatformName: () => "linux",
-  getClipboardCommand: () => null,
-  getPidPath: () => "/tmp/test.pid",
-  getDbPath: () => "/tmp/data/db/assistant.db",
-  getLogPath: () => "/tmp/test.log",
-  getHistoryPath: () => "/tmp/data/history",
-  getHooksDir: () => "/tmp/hooks",
-  readSessionToken: () => null,
-  ensureDataDir: () => {},
-  isMacOS: () => false,
-  isLinux: () => true,
-  isWindows: () => false,
-  normalizeAssistantId: (id: string) => id,
-  readLockfile: () => null,
-  writeLockfile: () => {},
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    daemon: { standaloneRecording: false },
-    provider: "mock-provider",
-    model: "mock-model",
-    permissions: { mode: "workspace" },
-    apiKeys: {},
-    sandbox: { enabled: false, backend: "native" },
-    timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },
-    skills: { load: { extraDirs: [] } },
-    secretDetection: {
-      enabled: false,
-      allowOneTimeSend: false,
-      customPatterns: [],
-      entropyThreshold: 3.5,
-    },
-    contextWindow: {
-      enabled: true,
-      maxInputTokens: 180000,
-      targetBudgetRatio: 0.30,
-      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
-    },
-    assistantFeatureFlagValues: {},
-  }),
-  loadConfig: () => ({}),
-  loadRawConfig: () => ({}),
-  saveConfig: () => {},
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  applyNestedDefaults: (config: unknown) => config,
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  syncConfigToLockfile: () => {},
-  API_KEY_PROVIDERS: [],
-}));
-
-const { ToolExecutor } = await import("../tools/executor.js");
-const { ComputerUseSession } =
-  await import("../daemon/computer-use-session.js");
-
-const originalExecute = ToolExecutor.prototype.execute;
-
-describe("ComputerUseSession working directory", () => {
-  beforeEach(() => {
-    capturedWorkingDir = undefined;
-    ToolExecutor.prototype.execute = async function (
-      _name: string,
-      _input: Record<string, unknown>,
-      context: { workingDir: string },
-    ) {
-      capturedWorkingDir = context.workingDir;
-      return { content: "ok", isError: false };
-    } as typeof ToolExecutor.prototype.execute;
-  });
-
-  afterEach(() => {
-    ToolExecutor.prototype.execute = originalExecute;
-  });
-
-  test("uses sandbox working directory for tool execution context", async () => {
-    let providerCalls = 0;
-    const provider: Provider = {
-      name: "mock-provider",
-      async sendMessage() {
-        const calls = providerCalls++;
-        if (calls === 0) {
-          return {
-            content: [
-              {
-                type: "tool_use",
-                id: "toolu_1",
-                name: "computer_use_click",
-                input: { element_id: 1 },
-              },
-            ],
-            model: "mock-model",
-            usage: { inputTokens: 1, outputTokens: 1 },
-            stopReason: "tool_use",
-          };
-        }
-        return {
-          content: [{ type: "text", text: "unused" }],
-          model: "mock-model",
-          usage: { inputTokens: 1, outputTokens: 1 },
-          stopReason: "end_turn",
-        };
-      },
-    };
-
-    const session = new ComputerUseSession(
-      "cu-sandbox-1",
-      "test task",
-      1440,
-      900,
-      provider,
-      () => {},
-    );
-
-    const observation: CuObservation = {
-      type: "cu_observation",
-      sessionId: "cu-sandbox-1",
-      axTree: 'Window "Test" [1]',
-    };
-
-    await session.handleObservation(observation);
-
-    expect(capturedWorkingDir).toBe("/tmp/workspace");
-  });
-});

package/src/__tests__/computer-use-skill-baseline.test.ts

@@ -1,78 +0,0 @@
-import { afterAll, describe, expect, test } from "bun:test";
-
-import { buildToolDefinitions } from "../daemon/session-tool-setup.js";
-import {
-  __resetRegistryForTesting,
-  getAllToolDefinitions,
-  getAllTools,
-  getTool,
-  initializeTools,
-} from "../tools/registry.js";
-import {
-  assertComputerUseToolsAbsent,
-  COMPUTER_USE_TOOL_NAMES,
-} from "./test-support/computer-use-skill-harness.js";
-
-afterAll(() => {
-  __resetRegistryForTesting();
-});
-
-describe("computer-use skill baseline: registry tool surfaces", () => {
-  test("no computer_use_* action tools are registered after initializeTools() (migrated to skill)", async () => {
-    await initializeTools();
-
-    for (const name of COMPUTER_USE_TOOL_NAMES) {
-      const tool = getTool(name);
-      expect(tool).toBeUndefined();
-    }
-  });
-
-  test("computer_use_request_control is registered in core after initializeTools()", async () => {
-    await initializeTools();
-
-    const tool = getTool("computer_use_request_control");
-    expect(tool).toBeDefined();
-  });
-
-  test("getAllToolDefinitions() excludes all computer_use_* tools (proxy exclusion)", async () => {
-    await initializeTools();
-
-    const defNames = getAllToolDefinitions().map((d) => d.name);
-    assertComputerUseToolsAbsent(defNames);
-  });
-
-  test("getAllToolDefinitions() excludes computer_use_request_control (proxy exclusion)", async () => {
-    await initializeTools();
-
-    const defNames = getAllToolDefinitions().map((d) => d.name);
-    expect(defNames).not.toContain("computer_use_request_control");
-  });
-
-  test("buildToolDefinitions() includes computer_use_request_control for text sessions", async () => {
-    await initializeTools();
-
-    const defNames = buildToolDefinitions().map((d) => d.name);
-    expect(defNames).toContain("computer_use_request_control");
-  });
-
-  test("buildToolDefinitions() excludes all computer_use_* action tools from text sessions", async () => {
-    await initializeTools();
-
-    const defNames = buildToolDefinitions().map((d) => d.name);
-    // The only computer_use_* tool in text sessions is the escalation tool
-    const cuActionTools = defNames.filter(
-      (n) =>
-        n.startsWith("computer_use_") && n !== "computer_use_request_control",
-    );
-    expect(cuActionTools).toHaveLength(0);
-  });
-
-  test("post-cutover count: 1 computer_use_* tool in core registry (escalation only)", async () => {
-    await initializeTools();
-
-    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");
-  });
-});

package/src/__tests__/computer-use-skill-endstate.test.ts

@@ -1,105 +0,0 @@
-import { join } from "node:path";
-import { beforeAll, describe, expect, test } from "bun:test";
-
-import { getBundledSkillsDir } from "../config/skills.js";
-import { buildToolDefinitions } from "../daemon/session-tool-setup.js";
-import { parseToolManifestFile } from "../skills/tool-manifest.js";
-import {
-  __resetRegistryForTesting,
-  getAllToolDefinitions,
-  getAllTools,
-  getTool,
-  initializeTools,
-} from "../tools/registry.js";
-import {
-  COMPUTER_USE_TOOL_COUNT,
-  COMPUTER_USE_TOOL_NAMES,
-} from "./test-support/computer-use-skill-harness.js";
-
-beforeAll(async () => {
-  __resetRegistryForTesting();
-  await initializeTools();
-});
-
-describe("computer-use skill end-state", () => {
-  // ── Core Registry ──────────────────────────────────────────────────
-
-  test("core registry contains 1 computer_use_* tool (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 resolvable from core registry", () => {
-    expect(getTool("computer_use_request_control")).toBeDefined();
-  });
-
-  test("no action tool from COMPUTER_USE_TOOL_NAMES is resolvable from core registry", () => {
-    for (const name of COMPUTER_USE_TOOL_NAMES) {
-      expect(getTool(name)).toBeUndefined();
-    }
-  });
-
-  // ── getAllToolDefinitions (excludes proxy & skill tools) ──────────
-
-  test("getAllToolDefinitions() excludes computer_use_* tools", () => {
-    const defs = getAllToolDefinitions();
-    const cuDefs = defs.filter((d) => d.name.startsWith("computer_use_"));
-    expect(cuDefs).toHaveLength(0);
-  });
-
-  test("getAllToolDefinitions() excludes computer_use_request_control (proxy exclusion)", () => {
-    const defs = getAllToolDefinitions();
-    const found = defs.find((d) => d.name === "computer_use_request_control");
-    expect(found).toBeUndefined();
-  });
-
-  // ── buildToolDefinitions (text session tool set) ─────────────────
-
-  test("buildToolDefinitions() includes computer_use_request_control", () => {
-    const defs = buildToolDefinitions();
-    const found = defs.find((d) => d.name === "computer_use_request_control");
-    expect(found).toBeDefined();
-  });
-
-  test("buildToolDefinitions() excludes computer_use_* action tools", () => {
-    const defs = buildToolDefinitions();
-    const cuDefs = defs.filter(
-      (d) =>
-        d.name.startsWith("computer_use_") &&
-        d.name !== "computer_use_request_control",
-    );
-    expect(cuDefs).toHaveLength(0);
-  });
-
-  // ── Bundled Skill Catalog ────────────────────────────────────────
-
-  test(
-    "computer-use skill has exactly " +
-      COMPUTER_USE_TOOL_COUNT +
-      " tools in TOOLS.json",
-    () => {
-      const manifestPath = join(
-        getBundledSkillsDir(),
-        "computer-use",
-        "TOOLS.json",
-      );
-      const manifest = parseToolManifestFile(manifestPath);
-      expect(manifest.tools).toHaveLength(COMPUTER_USE_TOOL_COUNT);
-    },
-  );
-
-  test("bundled skill tool names match expected computer_use_* names", () => {
-    const manifestPath = join(
-      getBundledSkillsDir(),
-      "computer-use",
-      "TOOLS.json",
-    );
-    const manifest = parseToolManifestFile(manifestPath);
-    const toolNames = new Set(manifest.tools.map((t) => t.name));
-    for (const name of COMPUTER_USE_TOOL_NAMES) {
-      expect(toolNames.has(name)).toBe(true);
-    }
-  });
-});

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();
-  });
-});