@vellumai/assistant 0.3.5 → 0.3.7

package/src/__tests__/terminal-tools.test.ts

@@ -1,8 +1,10 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test';
 import { mkdtempSync, mkdirSync, rmSync, symlinkSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import type { Tool } from '../tools/types.js';
+import type { SandboxBackend } from '../tools/terminal/backends/types.js';
+import type { ShellOutputResult } from '../tools/shared/shell-output.js';
 
 // ── Mock modules ────────────────────────────────────────────────────────────
 
@@ -502,7 +504,7 @@ describe('wrapCommand', () => {
 describe('Native sandbox backend', () => {
   // We test NativeBackend directly rather than through wrapCommand to avoid
   // platform-dependent sandbox-exec/bwrap availability.
-  let NativeBackend: any;
+  let NativeBackend: new () => SandboxBackend;
 
   beforeEach(async () => {
     const mod = await import('../tools/terminal/backends/native.js');
@@ -546,8 +548,8 @@ describe('Native sandbox backend', () => {
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe('Docker sandbox backend', () => {
-  let DockerBackend: any;
-  let _resetDockerChecks: any;
+  let DockerBackend: new (sandboxRoot: string, config?: Record<string, unknown>, uid?: number, gid?: number) => SandboxBackend;
+  let _resetDockerChecks: () => void;
 
   const sandboxDir = join(testTmpDir, 'docker-sandbox');
 
@@ -628,7 +630,7 @@ describe('Docker sandbox backend', () => {
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe('Shell tool input validation', () => {
-  let shellTool: any;
+  let shellTool: Tool;
 
   beforeEach(async () => {
     const mod = await import('../tools/terminal/shell.js');
@@ -637,6 +639,7 @@ describe('Shell tool input validation', () => {
 
   const baseContext = {
     workingDir: testTmpDir,
+    sessionId: 'test-session-1',
     conversationId: 'test-conv-1',
     onOutput: () => {},
   };
@@ -700,13 +703,14 @@ describe('Shell tool input validation', () => {
 
   test('tool definition includes required schema fields', () => {
     const def = shellTool.getDefinition();
+    const schema = def.input_schema as { required: string[]; properties: Record<string, unknown> };
     expect(def.name).toBe('bash');
-    expect(def.input_schema.required).toContain('command');
-    expect(def.input_schema.required).toContain('reason');
-    expect(def.input_schema.properties.command).toBeDefined();
-    expect(def.input_schema.properties.timeout_seconds).toBeDefined();
-    expect(def.input_schema.properties.network_mode).toBeDefined();
-    expect(def.input_schema.properties.credential_ids).toBeDefined();
+    expect(schema.required).toContain('command');
+    expect(schema.required).toContain('reason');
+    expect(schema.properties.command).toBeDefined();
+    expect(schema.properties.timeout_seconds).toBeDefined();
+    expect(schema.properties.network_mode).toBeDefined();
+    expect(schema.properties.credential_ids).toBeDefined();
   });
 });
 
@@ -715,7 +719,7 @@ describe('Shell tool input validation', () => {
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe('formatShellOutput', () => {
-  let formatShellOutput: any;
+  let formatShellOutput: (stdout: string, stderr: string, code: number | null, timedOut: boolean, timeoutSec: number) => ShellOutputResult;
 
   beforeEach(async () => {
     const mod = await import('../tools/shared/shell-output.js');
@@ -775,7 +779,7 @@ describe('formatShellOutput', () => {
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe('EvaluateTypescriptTool input validation', () => {
-  let evalTool: any;
+  let evalTool: Tool;
 
   beforeEach(async () => {
     const mod = await import('../tools/terminal/evaluate-typescript.js');
@@ -784,6 +788,7 @@ describe('EvaluateTypescriptTool input validation', () => {
 
   const baseContext = {
     workingDir: testTmpDir,
+    sessionId: 'test-session-1',
     conversationId: 'test-conv-1',
     onOutput: () => {},
   };
@@ -829,12 +834,13 @@ describe('EvaluateTypescriptTool input validation', () => {
 
   test('tool definition has correct name and schema', () => {
     const def = evalTool.getDefinition();
+    const schema = def.input_schema as { required: string[]; properties: Record<string, unknown> };
     expect(def.name).toBe('evaluate_typescript_code');
-    expect(def.input_schema.required).toContain('code');
-    expect(def.input_schema.properties.code).toBeDefined();
-    expect(def.input_schema.properties.mock_input_json).toBeDefined();
-    expect(def.input_schema.properties.timeout_seconds).toBeDefined();
-    expect(def.input_schema.properties.filename).toBeDefined();
-    expect(def.input_schema.properties.entrypoint).toBeDefined();
+    expect(schema.required).toContain('code');
+    expect(schema.properties.code).toBeDefined();
+    expect(schema.properties.mock_input_json).toBeDefined();
+    expect(schema.properties.timeout_seconds).toBeDefined();
+    expect(schema.properties.filename).toBeDefined();
+    expect(schema.properties.entrypoint).toBeDefined();
   });
 });

package/src/__tests__/tool-execution-abort-cleanup.test.ts

@@ -0,0 +1,545 @@
+/**
+ * Tests verifying that resources are properly cleaned up when AbortSignal fires
+ * during tool execution: shell processes are killed, file operations respect
+ * pre-abort signals, and git operations abort via the signal.
+ */
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  existsSync,
+  writeFileSync,
+  realpathSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+// ── Shared mock setup ────────────────────────────────────────────────────────
+// Config mock must be declared before importing tool modules so that the
+// mock.module calls are hoisted above the dynamic imports.
+
+import { mock } from 'bun:test';
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({
+    provider: 'anthropic',
+    model: 'test',
+    apiKeys: {},
+    maxTokens: 4096,
+    dataDir: '/tmp',
+    timeouts: {
+      shellDefaultTimeoutSec: 120,
+      shellMaxTimeoutSec: 600,
+      permissionTimeoutSec: 300,
+    },
+    sandbox: { enabled: false, backend: 'native' as const },
+    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    secretDetection: { enabled: false, action: 'warn' as const, entropyThreshold: 4.0 },
+  }),
+  loadConfig: () => ({}),
+  invalidateConfigCache: () => {},
+  saveConfig: () => {},
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+// shell.ts requires the sandbox wrapper — provide a pass-through stub.
+mock.module('../tools/terminal/sandbox.js', () => ({
+  wrapCommand: (command: string, _cwd: string, _cfg: unknown, _opts?: unknown) => ({
+    command: 'bash',
+    args: ['-c', '--', command],
+    sandboxed: false,
+  }),
+}));
+
+// shell.ts uses the script proxy — stub it to avoid network side-effects.
+mock.module('../tools/network/script-proxy/index.js', () => ({
+  getOrStartSession: async () => ({
+    session: { id: 'mock-session' },
+  }),
+  getSessionEnv: () => ({}),
+}));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => '/tmp',
+  getSocketPath: () => '/tmp/vellum.sock',
+}));
+
+mock.module('../tools/credentials/resolve.js', () => ({
+  resolveCredentialRef: () => null,
+}));
+
+mock.module('../tools/network/script-proxy/logging.js', () => ({
+  buildCredentialRefTrace: () => ({}),
+}));
+
+mock.module('../security/secret-scanner.js', () => ({
+  redactSecrets: (s: string) => s,
+  scanText: () => [],
+}));
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+const testDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'abort-cleanup-test-')));
+  testDirs.push(dir);
+  return dir;
+}
+
+function makeToolContext(workingDir: string, signal?: AbortSignal) {
+  return {
+    workingDir,
+    sessionId: 'test-session',
+    conversationId: 'test-conv',
+    signal,
+  };
+}
+
+// Restore all module mocks before each test so that this suite is not
+// order-dependent. Without this, stubs installed by one test file can bleed
+// into subsequent files and produce false passes or failures.
+beforeEach(() => {
+  mock.restore();
+});
+
+afterEach(() => {
+  for (const dir of testDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ── 1. Shell process cleanup on AbortSignal ─────────────────────────────────
+
+describe('shell tool — process cleanup on AbortSignal', () => {
+  test('kills the child process when AbortSignal fires mid-execution', async () => {
+    const { hostShellTool } = await import('../tools/host-terminal/host-shell.js');
+    const dir = makeTempDir();
+    const ac = new AbortController();
+
+    const promise = hostShellTool.execute(
+      { command: 'sleep 30', reason: 'test' },
+      makeToolContext(dir, ac.signal),
+    );
+
+    // Allow the child process to start before aborting.
+    await new Promise((r) => setTimeout(r, 100));
+    ac.abort();
+
+    const result = await promise;
+
+    // The process was killed by SIGKILL, so it exits non-zero.
+    expect(result.isError).toBe(true);
+  });
+
+  test('kills the child process immediately when signal is already aborted', async () => {
+    const { hostShellTool } = await import('../tools/host-terminal/host-shell.js');
+    const dir = makeTempDir();
+    const ac = new AbortController();
+    ac.abort(); // pre-aborted
+
+    const result = await hostShellTool.execute(
+      { command: 'sleep 30', reason: 'test' },
+      makeToolContext(dir, ac.signal),
+    );
+
+    expect(result.isError).toBe(true);
+  });
+
+  test('completes normally when abort signal never fires', async () => {
+    const { hostShellTool } = await import('../tools/host-terminal/host-shell.js');
+    const dir = makeTempDir();
+    const ac = new AbortController();
+
+    const result = await hostShellTool.execute(
+      { command: 'echo completed', reason: 'test' },
+      makeToolContext(dir, ac.signal),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('completed');
+    // Ensure aborting after completion doesn't cause errors.
+    ac.abort();
+  });
+
+  test('removes the abort listener after process exits normally', async () => {
+    const { hostShellTool } = await import('../tools/host-terminal/host-shell.js');
+    const dir = makeTempDir();
+    const ac = new AbortController();
+
+    await hostShellTool.execute(
+      { command: 'echo done', reason: 'test' },
+      makeToolContext(dir, ac.signal),
+    );
+
+    // After the process exits the abort listener should be removed.
+    // AbortSignal.eventCounts is not universally available, but we can
+    // verify the listener doesn't hold a reference by aborting and
+    // confirming no error is thrown from a dangling handler.
+    expect(() => ac.abort()).not.toThrow();
+  });
+
+  test('abort during long-running output does not leave orphaned listeners', async () => {
+    const { hostShellTool } = await import('../tools/host-terminal/host-shell.js');
+    const dir = makeTempDir();
+    const ac = new AbortController();
+    const chunks: string[] = [];
+
+    const promise = hostShellTool.execute(
+      { command: 'for i in 1 2 3 4 5; do echo $i; sleep 2; done', reason: 'test' },
+      {
+        ...makeToolContext(dir, ac.signal),
+        onOutput: (c: string) => chunks.push(c),
+      },
+    );
+
+    // Wait for the first chunk to arrive before aborting.
+    await new Promise<void>((resolve) => {
+      const interval = setInterval(() => {
+        if (chunks.length > 0) {
+          clearInterval(interval);
+          resolve();
+        }
+      }, 50);
+    });
+
+    ac.abort();
+    const result = await promise;
+
+    // Process was killed.
+    expect(result.isError).toBe(true);
+  });
+});
+
+// ── 2. File operation abort handling ─────────────────────────────────────────
+//
+// File operations in this codebase use synchronous Node.js APIs
+// (readFileSync / writeFileSync), so there are no long-lived file handles
+// to close. Abort cancellation is handled at the executor level:
+// ToolExecutor.execute() checks signal.aborted before dispatching to the
+// tool and returns a 'Cancelled' error result immediately.
+// The tests below verify that contract at the tool level.
+
+describe('file tools — abort signal pre-check', () => {
+  test('file_write tool: execute still succeeds when context has no signal', async () => {
+    const { getTool } = await import('../tools/registry.js');
+    await import('../tools/filesystem/write.js');
+    const fileWriteTool = getTool('file_write')!;
+    const dir = makeTempDir();
+
+    const result = await fileWriteTool.execute(
+      { path: 'out.txt', content: 'hello', reason: 'test' },
+      makeToolContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, 'out.txt'))).toBe(true);
+  });
+
+  test('file_write tool: execute succeeds with a non-aborted signal', async () => {
+    const { getTool } = await import('../tools/registry.js');
+    await import('../tools/filesystem/write.js');
+    const fileWriteTool = getTool('file_write')!;
+    const dir = makeTempDir();
+    const ac = new AbortController();
+
+    const result = await fileWriteTool.execute(
+      { path: 'out2.txt', content: 'world', reason: 'test' },
+      makeToolContext(dir, ac.signal),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, 'out2.txt'))).toBe(true);
+  });
+
+  test('file_read tool: execute succeeds when context has no signal', async () => {
+    const { getTool } = await import('../tools/registry.js');
+    await import('../tools/filesystem/read.js');
+    const fileReadTool = getTool('file_read')!;
+    const dir = makeTempDir();
+    writeFileSync(join(dir, 'read-me.txt'), 'content to read');
+
+    const result = await fileReadTool.execute(
+      { path: 'read-me.txt' },
+      makeToolContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('content to read');
+  });
+
+  test('file_read tool: execute succeeds with a non-aborted signal', async () => {
+    const { getTool } = await import('../tools/registry.js');
+    await import('../tools/filesystem/read.js');
+    const fileReadTool = getTool('file_read')!;
+    const dir = makeTempDir();
+    writeFileSync(join(dir, 'read-me2.txt'), 'readable');
+    const ac = new AbortController();
+
+    const result = await fileReadTool.execute(
+      { path: 'read-me2.txt' },
+      makeToolContext(dir, ac.signal),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('readable');
+  });
+
+  test('file_write tool: synchronous write completes regardless of pre-aborted signal (abort checked at executor level)', async () => {
+    // The tool implementations use synchronous Node.js I/O, so they complete
+    // regardless of the signal. The ToolExecutor.execute() wrapper is
+    // responsible for checking signal.aborted before dispatching; the tool
+    // itself is not expected to check it. This test documents that contract.
+    const { getTool } = await import('../tools/registry.js');
+    await import('../tools/filesystem/write.js');
+
+    const dir = makeTempDir();
+    const ac = new AbortController();
+    ac.abort(); // pre-aborted
+
+    const fileWriteTool = getTool('file_write')!;
+
+    // When invoked directly (not through ToolExecutor), the sync write runs.
+    const result = await fileWriteTool.execute(
+      { path: 'should-write.txt', content: 'test', reason: 'test' },
+      makeToolContext(dir, ac.signal),
+    );
+    // Should succeed — the tool's own execute() doesn't check the signal.
+    expect(result.isError).toBe(false);
+  });
+});
+
+// ── 3. Git operation cleanup on AbortSignal ───────────────────────────────────
+
+describe('WorkspaceGitService — abort signal propagation', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(
+      tmpdir(),
+      `abort-git-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(testDir, { recursive: true });
+    testDirs.push(testDir);
+  });
+
+  test('writeNote: AbortSignal cancels the git notes operation', async () => {
+    const {
+      WorkspaceGitService,
+      _resetGitServiceRegistry,
+    } = await import('../workspace/git-service.js');
+
+    _resetGitServiceRegistry();
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    const headHash = await service.getHeadHash();
+
+    // Abort immediately — writeNote passes the signal to execFileAsync.
+    const ac = new AbortController();
+    ac.abort();
+
+    // The operation should throw (or resolve with an error) because the signal
+    // is already aborted when execFileAsync receives it.
+    let threw = false;
+    try {
+      await service.writeNote(headHash, 'should-be-cancelled', ac.signal);
+    } catch {
+      threw = true;
+    }
+
+    // With a pre-aborted signal, Node's execFileAsync rejects immediately.
+    expect(threw).toBe(true);
+  });
+
+  test('writeNote: completes normally without an abort signal', async () => {
+    const {
+      WorkspaceGitService,
+      _resetGitServiceRegistry,
+    } = await import('../workspace/git-service.js');
+
+    _resetGitServiceRegistry();
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    const headHash = await service.getHeadHash();
+
+    // Should not throw.
+    await service.writeNote(headHash, 'note content');
+  });
+
+  test('commitIfDirty: respects deadlineMs to avoid stale commits', async () => {
+    const {
+      WorkspaceGitService,
+      _resetGitServiceRegistry,
+    } = await import('../workspace/git-service.js');
+
+    _resetGitServiceRegistry();
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    writeFileSync(join(testDir, 'dirty.txt'), 'uncommitted');
+
+    // Deadline already expired.
+    const { committed } = await service.commitIfDirty(
+      () => ({ message: 'should not commit' }),
+      { deadlineMs: Date.now() - 1000 },
+    );
+
+    expect(committed).toBe(false);
+  });
+
+  test('commitIfDirty: commits when deadline has not expired', async () => {
+    const {
+      WorkspaceGitService,
+      _resetGitServiceRegistry,
+    } = await import('../workspace/git-service.js');
+
+    _resetGitServiceRegistry();
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    writeFileSync(join(testDir, 'commit-me.txt'), 'changes');
+
+    const { committed } = await service.commitIfDirty(
+      () => ({ message: 'test commit' }),
+      { deadlineMs: Date.now() + 30_000 },
+    );
+
+    expect(committed).toBe(true);
+  });
+
+  test('ensureInitialized: concurrent calls resolve without duplicate git inits', async () => {
+    const {
+      WorkspaceGitService,
+      _resetGitServiceRegistry,
+    } = await import('../workspace/git-service.js');
+
+    _resetGitServiceRegistry();
+    const service = new WorkspaceGitService(testDir);
+
+    // Fire multiple concurrent init calls — all should resolve without errors.
+    await Promise.all([
+      service.ensureInitialized(),
+      service.ensureInitialized(),
+      service.ensureInitialized(),
+    ]);
+
+    expect(service.isInitialized()).toBe(true);
+  });
+
+  test('commitChanges: interleaved with abort-signalled writeNote does not corrupt repo', async () => {
+    const {
+      WorkspaceGitService,
+      _resetGitServiceRegistry,
+    } = await import('../workspace/git-service.js');
+
+    _resetGitServiceRegistry();
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    writeFileSync(join(testDir, 'f.txt'), 'data');
+
+    // Commit the file.
+    await service.commitChanges('add file');
+
+    const headHash = await service.getHeadHash();
+
+    // Fire a pre-aborted writeNote alongside another commitChanges.
+    const ac = new AbortController();
+    ac.abort();
+
+    const [commitResult] = await Promise.allSettled([
+      service.commitChanges('second commit').then(() => 'committed'),
+      service.writeNote(headHash, 'note', ac.signal).catch(() => 'note-aborted'),
+    ]);
+
+    // The commit itself should succeed — the aborted note does not block it.
+    expect(commitResult.status).toBe('fulfilled');
+    if (commitResult.status === 'fulfilled') {
+      expect(commitResult.value).toBe('committed');
+    }
+
+    // Repo must still be in a clean, functional state.
+    const status = await service.getStatus();
+    expect(status.clean).toBe(true);
+  });
+});
+
+// ── 4. Shell tool (sandboxed) — abort signal ─────────────────────────────────
+//
+// The sandboxed `bash` tool mirrors the host_bash abort handling. Since the
+// sandbox stub is already mocked above, we can drive the sandboxed path too.
+
+describe('bash (sandboxed) shell tool — process cleanup on AbortSignal', () => {
+  test('kills child process when signal fires mid-execution', async () => {
+    // Import shell.ts (registered as 'bash') after mocks are in place.
+    const { getTool } = await import('../tools/registry.js');
+    await import('../tools/terminal/shell.js');
+
+    // Assert registration — a missing tool signals a real regression, not a skip.
+    expect(getTool('bash')).toBeDefined();
+    const bashTool = getTool('bash')!;
+
+    const dir = makeTempDir();
+    const ac = new AbortController();
+
+    const promise = bashTool.execute(
+      { command: 'sleep 30', reason: 'test' },
+      makeToolContext(dir, ac.signal),
+    );
+
+    await new Promise((r) => setTimeout(r, 100));
+    ac.abort();
+
+    const result = await promise;
+    expect(result.isError).toBe(true);
+  });
+
+  test('kills child process immediately when signal is pre-aborted', async () => {
+    const { getTool } = await import('../tools/registry.js');
+    await import('../tools/terminal/shell.js');
+
+    expect(getTool('bash')).toBeDefined();
+    const bashTool = getTool('bash')!;
+
+    const dir = makeTempDir();
+    const ac = new AbortController();
+    ac.abort();
+
+    const result = await bashTool.execute(
+      { command: 'sleep 30', reason: 'test' },
+      makeToolContext(dir, ac.signal),
+    );
+
+    expect(result.isError).toBe(true);
+  });
+
+  test('short command completes normally with a non-aborted signal attached', async () => {
+    const { getTool } = await import('../tools/registry.js');
+    await import('../tools/terminal/shell.js');
+
+    expect(getTool('bash')).toBeDefined();
+    const bashTool = getTool('bash')!;
+
+    const dir = makeTempDir();
+    const ac = new AbortController();
+
+    const result = await bashTool.execute(
+      { command: 'echo hello-world', reason: 'test' },
+      makeToolContext(dir, ac.signal),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('hello-world');
+    ac.abort(); // cleanup after success
+  });
+});