vellum 0.2.0 → 0.2.2

package/src/__tests__/view-image-tool.test.ts

@@ -0,0 +1,217 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, test, expect, afterAll, mock } from 'bun:test';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const testDir = realpathSync(mkdtempSync(join(tmpdir(), 'view-image-test-')));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  getRootDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+  migrateToDataLayout: () => {},
+  migrateToWorkspaceLayout: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({ memory: {} }),
+}));
+
+await import('../tools/filesystem/view-image.js');
+
+import { getTool } from '../tools/registry.js';
+import type { ToolContext } from '../tools/types.js';
+
+afterAll(() => {
+  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+});
+
+const tool = getTool('view_image')!;
+
+function makeContext(workingDir: string = testDir): ToolContext {
+  return {
+    workingDir,
+    sessionId: 'test-session',
+    conversationId: 'test-conversation',
+  };
+}
+
+// Minimal valid JPEG: FF D8 FF E0 header + enough bytes
+const JPEG_HEADER = Buffer.from([
+  0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46,
+  0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01,
+  0x00, 0x01, 0x00, 0x00,
+]);
+
+// Minimal valid PNG header
+const PNG_HEADER = Buffer.from([
+  0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
+  0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,
+]);
+
+// Minimal valid GIF header
+const GIF_HEADER = Buffer.from([
+  0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+]);
+
+// Minimal valid WebP header (RIFF....WEBP)
+const WEBP_HEADER = Buffer.from([
+  0x52, 0x49, 0x46, 0x46, 0x24, 0x00, 0x00, 0x00,
+  0x57, 0x45, 0x42, 0x50, 0x56, 0x50, 0x38, 0x20,
+]);
+
+// ── Success cases ───────────────────────────────────────────────────
+
+describe('view_image tool', () => {
+  test('loads a JPEG file', async () => {
+    const imgPath = join(testDir, 'test.jpg');
+    writeFileSync(imgPath, JPEG_HEADER);
+
+    const result = await tool.execute({ path: 'test.jpg' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Image loaded');
+    expect(result.content).toContain('image/jpeg');
+    expect((result as any).contentBlocks).toBeDefined();
+    expect((result as any).contentBlocks[0].type).toBe('image');
+    expect((result as any).contentBlocks[0].source.media_type).toBe('image/jpeg');
+  });
+
+  test('loads a PNG file', async () => {
+    const imgPath = join(testDir, 'test.png');
+    writeFileSync(imgPath, PNG_HEADER);
+
+    const result = await tool.execute({ path: 'test.png' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('image/png');
+  });
+
+  test('loads a GIF file', async () => {
+    const imgPath = join(testDir, 'test.gif');
+    writeFileSync(imgPath, GIF_HEADER);
+
+    const result = await tool.execute({ path: 'test.gif' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('image/gif');
+  });
+
+  test('loads a WebP file', async () => {
+    const imgPath = join(testDir, 'test.webp');
+    writeFileSync(imgPath, WEBP_HEADER);
+
+    const result = await tool.execute({ path: 'test.webp' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('image/webp');
+  });
+
+  test('loads image with absolute path', async () => {
+    const imgPath = join(testDir, 'absolute.jpg');
+    writeFileSync(imgPath, JPEG_HEADER);
+
+    const result = await tool.execute({ path: imgPath }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Image loaded');
+  });
+
+  test('returns base64-encoded data in content blocks', async () => {
+    const imgPath = join(testDir, 'base64.jpg');
+    writeFileSync(imgPath, JPEG_HEADER);
+
+    const result = await tool.execute({ path: 'base64.jpg' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    const blocks = (result as any).contentBlocks;
+    expect(blocks[0].source.type).toBe('base64');
+    expect(blocks[0].source.data.length).toBeGreaterThan(0);
+  });
+});
+
+// ── Error cases ─────────────────────────────────────────────────────
+
+describe('view_image error handling', () => {
+  test('rejects missing path', async () => {
+    const result = await tool.execute({}, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('path is required');
+  });
+
+  test('rejects unsupported file extension', async () => {
+    const txtPath = join(testDir, 'readme.txt');
+    writeFileSync(txtPath, 'not an image');
+
+    const result = await tool.execute({ path: 'readme.txt' }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('unsupported image format');
+    expect(result.content).toContain('.txt');
+  });
+
+  test('rejects nonexistent file', async () => {
+    const result = await tool.execute({ path: 'nonexistent.jpg' }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('file not found');
+  });
+
+  test('rejects directory path', async () => {
+    const dirPath = join(testDir, 'subdir');
+    mkdirSync(dirPath, { recursive: true });
+    // Create a .jpg-named directory
+    const fakePath = join(testDir, 'fakedir.jpg');
+    mkdirSync(fakePath, { recursive: true });
+
+    const result = await tool.execute({ path: 'fakedir.jpg' }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('is not a file');
+  });
+
+  test('blocks path traversal outside working directory', async () => {
+    const result = await tool.execute({ path: '../../etc/passwd.jpg' }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('outside the working directory');
+  });
+
+  test('rejects file with unrecognizable magic bytes', async () => {
+    const imgPath = join(testDir, 'corrupt.jpg');
+    writeFileSync(imgPath, Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]));
+
+    const result = await tool.execute({ path: 'corrupt.jpg' }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('could not detect image format');
+  });
+
+  test('detects JPEG format from magic bytes regardless of extension', async () => {
+    // Write JPEG magic bytes to a .png file
+    const imgPath = join(testDir, 'misnamed.png');
+    writeFileSync(imgPath, JPEG_HEADER);
+
+    const result = await tool.execute({ path: 'misnamed.png' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    // Should detect as JPEG from magic bytes, not PNG from extension
+    expect(result.content).toContain('image/jpeg');
+  });
+});

package/src/__tests__/workspace-git-service.test.ts

@@ -7,6 +7,11 @@ import {
   WorkspaceGitService,
   getWorkspaceGitService,
   _resetGitServiceRegistry,
+  _resetBreaker,
+  _getConsecutiveFailures,
+  _resetInitBreaker,
+  _getInitConsecutiveFailures,
+  isDeadlineExpired,
 } from '../workspace/git-service.js';
 
 describe('WorkspaceGitService', () => {
@@ -747,4 +752,402 @@ describe('WorkspaceGitService', () => {
       expect(status.untracked).toContain('README.md');
     });
   });
+
+  describe('deadline-aware commitIfDirty', () => {
+    test('deadline expired before lock acquisition skips commit quickly', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      // Create a file so the workspace is dirty
+      writeFileSync(join(testDir, 'test.txt'), 'content');
+
+      // Use a deadline that has already passed
+      const pastDeadline = Date.now() - 1000;
+      const result = await service.commitIfDirty(
+        () => ({ message: 'should not commit' }),
+        { deadlineMs: pastDeadline },
+      );
+
+      expect(result.committed).toBe(false);
+
+      // File should still be uncommitted
+      const status = await service.getStatus();
+      expect(status.clean).toBe(false);
+      expect(status.untracked).toContain('test.txt');
+    });
+
+    test('deadline far in the future allows commit to proceed', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      writeFileSync(join(testDir, 'test.txt'), 'content');
+
+      // Use a deadline far in the future
+      const futureDeadline = Date.now() + 60_000;
+      const result = await service.commitIfDirty(
+        () => ({ message: 'deadline commit' }),
+        { deadlineMs: futureDeadline },
+      );
+
+      expect(result.committed).toBe(true);
+
+      // Verify the commit was actually created
+      const log = execFileSync('git', ['log', '--oneline', '-n', '1'], {
+        cwd: testDir,
+        encoding: 'utf-8',
+      });
+      expect(log).toContain('deadline commit');
+    });
+
+    test('no deadline option allows commit as normal', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      writeFileSync(join(testDir, 'test.txt'), 'content');
+
+      // No deadline option at all
+      const result = await service.commitIfDirty(
+        () => ({ message: 'no deadline commit' }),
+      );
+
+      expect(result.committed).toBe(true);
+    });
+  });
+
+  describe('breaker re-check under lock', () => {
+    test('queued call that acquires lock after breaker opens skips commit', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      writeFileSync(join(testDir, 'test.txt'), 'content');
+
+      // Simulate a breaker that opened between the pre-lock check and lock acquisition.
+      // We do this by:
+      // 1. Starting a commitIfDirty call (which passes the pre-lock breaker check)
+      // 2. Forcing the breaker open while the call is in progress
+
+      // First, force the breaker open by setting internal state directly.
+      // Since commitIfDirty re-checks the breaker after acquiring the lock,
+      // a call that passes the pre-lock check but finds the breaker open
+      // after acquiring the lock should bail out.
+      const internal = service as unknown as {
+        consecutiveFailures: number;
+        nextAllowedAttemptMs: number;
+      };
+      internal.consecutiveFailures = 5;
+      internal.nextAllowedAttemptMs = Date.now() + 60_000; // far in the future
+
+      // With breaker open, commitIfDirty should skip (pre-lock check)
+      const result = await service.commitIfDirty(
+        () => ({ message: 'should not commit' }),
+      );
+      expect(result.committed).toBe(false);
+
+      // Reset breaker
+      _resetBreaker(service);
+
+      // Now the commit should proceed normally
+      const result2 = await service.commitIfDirty(
+        () => ({ message: 'after breaker reset' }),
+      );
+      expect(result2.committed).toBe(true);
+    });
+
+    test('breaker early return inside lock does not reset breaker via recordSuccess', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      writeFileSync(join(testDir, 'test.txt'), 'content');
+
+      // Force breaker open with known failure count
+      const internal = service as unknown as {
+        consecutiveFailures: number;
+        nextAllowedAttemptMs: number;
+      };
+      internal.consecutiveFailures = 5;
+      internal.nextAllowedAttemptMs = Date.now() + 60_000;
+
+      // Pre-lock check catches the open breaker and returns early.
+      // Verify that consecutiveFailures is NOT reset to 0.
+      const result = await service.commitIfDirty(
+        () => ({ message: 'should not commit' }),
+      );
+      expect(result.committed).toBe(false);
+      expect(_getConsecutiveFailures(service)).toBe(5);
+    });
+
+    test('deadline early return inside lock does not reset breaker via recordSuccess', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      writeFileSync(join(testDir, 'test.txt'), 'content');
+
+      // Set up prior failures (breaker closed but failures recorded)
+      const internal = service as unknown as {
+        consecutiveFailures: number;
+        nextAllowedAttemptMs: number;
+      };
+      internal.consecutiveFailures = 3;
+      // Set nextAllowedAttemptMs in the past so the breaker check passes
+      // but consecutiveFailures is non-zero
+      internal.nextAllowedAttemptMs = Date.now() - 1000;
+
+      // Use a deadline that has already passed — this triggers the pre-lock
+      // deadline fast-path. consecutiveFailures should NOT be reset.
+      const result = await service.commitIfDirty(
+        () => ({ message: 'should not commit' }),
+        { deadlineMs: Date.now() - 1000 },
+      );
+      expect(result.committed).toBe(false);
+      expect(_getConsecutiveFailures(service)).toBe(3);
+    });
+
+    test('successful git operation after failures resets breaker', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      writeFileSync(join(testDir, 'test.txt'), 'content');
+
+      // Set up prior failures with breaker closed (backoff expired)
+      const internal = service as unknown as {
+        consecutiveFailures: number;
+        nextAllowedAttemptMs: number;
+      };
+      internal.consecutiveFailures = 3;
+      internal.nextAllowedAttemptMs = Date.now() - 1000;
+
+      // Commit should succeed and reset the breaker
+      const result = await service.commitIfDirty(
+        () => ({ message: 'recovery commit' }),
+      );
+      expect(result.committed).toBe(true);
+      expect(_getConsecutiveFailures(service)).toBe(0);
+    });
+
+    test('bypassBreaker ignores breaker state', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      writeFileSync(join(testDir, 'test.txt'), 'content');
+
+      // Force breaker open
+      const internal = service as unknown as {
+        consecutiveFailures: number;
+        nextAllowedAttemptMs: number;
+      };
+      internal.consecutiveFailures = 5;
+      internal.nextAllowedAttemptMs = Date.now() + 60_000;
+
+      // With bypassBreaker, commit should succeed despite open breaker
+      const result = await service.commitIfDirty(
+        () => ({ message: 'bypass breaker commit' }),
+        { bypassBreaker: true },
+      );
+      expect(result.committed).toBe(true);
+    });
+  });
+
+  describe('commitIfDirty diff error handling', () => {
+    test('non-1 exit code from git diff --cached --quiet is treated as an error', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      // Create a file so the workspace is dirty and commitIfDirty will
+      // proceed past the "clean" early-return.
+      writeFileSync(join(testDir, 'test.txt'), 'content');
+
+      // Access the private execGit method and wrap it so that
+      // 'git diff --cached --quiet' throws with exit code 2 (simulating
+      // a real git error rather than the expected exit code 1 for
+      // "staged changes exist").
+      const proto = Object.getPrototypeOf(service);
+      const originalExecGit = proto.execGit;
+      proto.execGit = async function (this: unknown, args: string[]) {
+        if (args[0] === 'diff' && args[1] === '--cached' && args[2] === '--quiet') {
+          const err = new Error(
+            'Git command failed: git diff --cached --quiet\nError: simulated error\nStderr: ',
+          ) as Error & { code?: number };
+          err.code = 2;
+          throw err;
+        }
+        return originalExecGit.call(this, args);
+      };
+
+      try {
+        // commitIfDirty should propagate the error (not treat code 2 as
+        // "staged changes exist")
+        await expect(
+          service.commitIfDirty(() => ({ message: 'should not commit' })),
+        ).rejects.toThrow();
+      } finally {
+        // Restore the original method
+        proto.execGit = originalExecGit;
+      }
+    });
+  });
+
+  describe('init circuit breaker', () => {
+    test('init breaker opens after consecutive failures', async () => {
+      // Use a directory that doesn't exist so init fails
+      const badDir = '/nonexistent/path/that/does/not/exist';
+      const service = new WorkspaceGitService(badDir);
+
+      // First failure — breaker does NOT open (requires 2+ failures)
+      await expect(service.ensureInitialized()).rejects.toThrow();
+      expect(_getInitConsecutiveFailures(service)).toBe(1);
+
+      // Second failure — expire the backoff window from the first failure
+      // so the attempt actually runs (not blocked by breaker).
+      const internal = service as unknown as {
+        initNextAllowedAttemptMs: number;
+      };
+      internal.initNextAllowedAttemptMs = Date.now() - 1;
+
+      await expect(service.ensureInitialized()).rejects.toThrow();
+      expect(_getInitConsecutiveFailures(service)).toBe(2);
+
+      // Third attempt within the backoff window — breaker is now open
+      // (2+ consecutive failures) so the attempt is skipped.
+      await expect(service.ensureInitialized()).rejects.toThrow(
+        'Init circuit breaker open: backing off after repeated failures',
+      );
+      // Failure count should NOT increase (the breaker prevented the attempt)
+      expect(_getInitConsecutiveFailures(service)).toBe(2);
+    });
+
+    test('init breaker skips init attempts during backoff window', async () => {
+      const service = new WorkspaceGitService(testDir);
+
+      // Force the init breaker open
+      const internal = service as unknown as {
+        initConsecutiveFailures: number;
+        initNextAllowedAttemptMs: number;
+      };
+      internal.initConsecutiveFailures = 3;
+      internal.initNextAllowedAttemptMs = Date.now() + 60_000; // far in the future
+
+      // ensureInitialized should throw with circuit breaker message
+      await expect(service.ensureInitialized()).rejects.toThrow(
+        'Init circuit breaker open: backing off after repeated failures',
+      );
+
+      // Failure count should NOT increase (the breaker prevented the attempt)
+      expect(_getInitConsecutiveFailures(service)).toBe(3);
+    });
+
+    test('init breaker resets on success', async () => {
+      const service = new WorkspaceGitService(testDir);
+
+      // Simulate prior init failures
+      const internal = service as unknown as {
+        initConsecutiveFailures: number;
+        initNextAllowedAttemptMs: number;
+      };
+      internal.initConsecutiveFailures = 3;
+      // Set backoff in the past so the breaker is closed and allows retry
+      internal.initNextAllowedAttemptMs = Date.now() - 1;
+
+      // This should succeed and reset the init breaker
+      await service.ensureInitialized();
+
+      expect(_getInitConsecutiveFailures(service)).toBe(0);
+      expect(service.isInitialized()).toBe(true);
+    });
+
+    test('init breaker allows retry after backoff window expires', async () => {
+      const service = new WorkspaceGitService(testDir);
+
+      // Simulate prior init failures with expired backoff
+      const internal = service as unknown as {
+        initConsecutiveFailures: number;
+        initNextAllowedAttemptMs: number;
+      };
+      internal.initConsecutiveFailures = 5;
+      internal.initNextAllowedAttemptMs = Date.now() - 1; // expired
+
+      // Breaker should be closed (backoff expired), allowing init to proceed
+      await service.ensureInitialized();
+
+      expect(_getInitConsecutiveFailures(service)).toBe(0);
+      expect(service.isInitialized()).toBe(true);
+    });
+
+    test('init breaker is independent from commit breaker', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      // Force commit breaker open
+      const internal = service as unknown as {
+        consecutiveFailures: number;
+        nextAllowedAttemptMs: number;
+      };
+      internal.consecutiveFailures = 5;
+      internal.nextAllowedAttemptMs = Date.now() + 60_000;
+
+      // Init breaker should still be clean
+      expect(_getInitConsecutiveFailures(service)).toBe(0);
+
+      // Commit breaker should be open
+      expect(_getConsecutiveFailures(service)).toBe(5);
+
+      // Reset commit breaker
+      _resetBreaker(service);
+
+      // Force init breaker open
+      const internal2 = service as unknown as {
+        initConsecutiveFailures: number;
+        initNextAllowedAttemptMs: number;
+      };
+      internal2.initConsecutiveFailures = 3;
+      internal2.initNextAllowedAttemptMs = Date.now() + 60_000;
+
+      // Commit breaker should be clean
+      expect(_getConsecutiveFailures(service)).toBe(0);
+
+      // Init breaker should be open
+      expect(_getInitConsecutiveFailures(service)).toBe(3);
+
+      // Reset init breaker
+      _resetInitBreaker(service);
+      expect(_getInitConsecutiveFailures(service)).toBe(0);
+    });
+
+    test('already initialized service bypasses init breaker check', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+      expect(service.isInitialized()).toBe(true);
+
+      // Force init breaker open
+      const internal = service as unknown as {
+        initConsecutiveFailures: number;
+        initNextAllowedAttemptMs: number;
+      };
+      internal.initConsecutiveFailures = 5;
+      internal.initNextAllowedAttemptMs = Date.now() + 60_000;
+
+      // ensureInitialized should succeed via the fast path (already initialized)
+      // without hitting the breaker
+      await service.ensureInitialized();
+    });
+  });
+
+  describe('isDeadlineExpired helper', () => {
+    test('returns false when deadlineMs is undefined', () => {
+      expect(isDeadlineExpired(undefined)).toBe(false);
+    });
+
+    test('returns false when deadline is in the future', () => {
+      expect(isDeadlineExpired(Date.now() + 60_000)).toBe(false);
+    });
+
+    test('returns true when deadline is in the past', () => {
+      expect(isDeadlineExpired(Date.now() - 1000)).toBe(true);
+    });
+
+    test('returns true when deadline equals current time', () => {
+      const now = Date.now();
+      // Use a deadline slightly in the past to avoid timing flakes
+      expect(isDeadlineExpired(now - 1)).toBe(true);
+    });
+  });
 });