vellum 0.0.16 → 0.2.0

package/src/__tests__/attachments.test.ts

@@ -0,0 +1,134 @@
+import { describe, test, expect } from 'bun:test';
+import { attachmentsToContentBlocks } from '../agent/attachments.js';
+import { createUserMessage } from '../agent/message-types.js';
+
+// ---------------------------------------------------------------------------
+// attachmentsToContentBlocks
+// ---------------------------------------------------------------------------
+
+describe('attachmentsToContentBlocks', () => {
+  test('creates image content block for image/jpeg', () => {
+    const blocks = attachmentsToContentBlocks([
+      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: 'base64data' },
+    ]);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('image');
+    const block = blocks[0] as { type: 'image'; source: { type: string; media_type: string; data: string } };
+    expect(block.source.type).toBe('base64');
+    expect(block.source.media_type).toBe('image/jpeg');
+    expect(block.source.data).toBe('base64data');
+  });
+
+  test('creates image content block for image/png', () => {
+    const blocks = attachmentsToContentBlocks([
+      { filename: 'screenshot.png', mimeType: 'image/png', data: 'pngdata' },
+    ]);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('image');
+  });
+
+  test('creates image content block for image/webp', () => {
+    const blocks = attachmentsToContentBlocks([
+      { filename: 'sticker.webp', mimeType: 'image/webp', data: 'webpdata' },
+    ]);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('image');
+  });
+
+  test('creates file content block for non-image mime types', () => {
+    const blocks = attachmentsToContentBlocks([
+      { filename: 'doc.pdf', mimeType: 'application/pdf', data: 'pdfdata' },
+    ]);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('file');
+    const block = blocks[0] as { type: 'file'; source: { filename: string; media_type: string; data: string } };
+    expect(block.source.filename).toBe('doc.pdf');
+    expect(block.source.media_type).toBe('application/pdf');
+  });
+
+  test('handles multiple attachments including mixed types', () => {
+    const blocks = attachmentsToContentBlocks([
+      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: 'imgdata' },
+      { filename: 'notes.txt', mimeType: 'text/plain', data: 'txtdata' },
+    ]);
+
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].type).toBe('image');
+    expect(blocks[1].type).toBe('file');
+  });
+
+  test('returns empty array for no attachments', () => {
+    const blocks = attachmentsToContentBlocks([]);
+    expect(blocks).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createUserMessage with image attachments
+// ---------------------------------------------------------------------------
+
+describe('createUserMessage with image attachments', () => {
+  test('includes both text and image blocks', () => {
+    const msg = createUserMessage('what is this?', [
+      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: 'base64img' },
+    ]);
+
+    expect(msg.role).toBe('user');
+    expect(msg.content).toHaveLength(2);
+    expect(msg.content[0].type).toBe('text');
+    expect((msg.content[0] as { type: 'text'; text: string }).text).toBe('what is this?');
+    expect(msg.content[1].type).toBe('image');
+  });
+
+  test('includes only image block when text is empty', () => {
+    const msg = createUserMessage('', [
+      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: 'base64img' },
+    ]);
+
+    expect(msg.role).toBe('user');
+    expect(msg.content).toHaveLength(1);
+    expect(msg.content[0].type).toBe('image');
+  });
+
+  test('includes only image block when text is whitespace', () => {
+    const msg = createUserMessage('   ', [
+      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: 'base64img' },
+    ]);
+
+    expect(msg.role).toBe('user');
+    expect(msg.content).toHaveLength(1);
+    expect(msg.content[0].type).toBe('image');
+  });
+
+  test('includes multiple image blocks', () => {
+    const msg = createUserMessage('compare these', [
+      { filename: 'a.jpg', mimeType: 'image/jpeg', data: 'img1' },
+      { filename: 'b.png', mimeType: 'image/png', data: 'img2' },
+    ]);
+
+    expect(msg.role).toBe('user');
+    expect(msg.content).toHaveLength(3);
+    expect(msg.content[0].type).toBe('text');
+    expect(msg.content[1].type).toBe('image');
+    expect(msg.content[2].type).toBe('image');
+  });
+
+  test('preserves base64 data in image content block', () => {
+    const base64 = 'dGVzdC1pbWFnZS1kYXRh';
+    const msg = createUserMessage('test', [
+      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: base64 },
+    ]);
+
+    const imageBlock = msg.content[1] as {
+      type: 'image';
+      source: { type: string; media_type: string; data: string };
+    };
+    expect(imageBlock.source.data).toBe(base64);
+    expect(imageBlock.source.media_type).toBe('image/jpeg');
+    expect(imageBlock.source.type).toBe('base64');
+  });
+});

package/src/__tests__/audit-log-rotation.test.ts

@@ -0,0 +1,154 @@
+import { describe, test, expect, beforeAll, beforeEach, mock } from 'bun:test';
+import { mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+import { Database } from 'bun:sqlite';
+
+// ---------------------------------------------------------------------------
+// Test setup — temp directory and mock modules
+// ---------------------------------------------------------------------------
+
+const TEST_DIR = join(tmpdir(), `vellum-rotation-test-${randomBytes(4).toString('hex')}`);
+const DB_PATH = join(TEST_DIR, 'assistant.db');
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => TEST_DIR,
+  getDbPath: () => DB_PATH,
+  getLogPath: () => join(TEST_DIR, 'logs', 'vellum.log'),
+  ensureDataDir: () => {
+    if (!existsSync(TEST_DIR)) mkdirSync(TEST_DIR, { recursive: true });
+  },
+  isMacOS: () => false,
+  isLinux: () => false,
+  isWindows: () => false,
+}));
+
+import { initializeDb, resetDb } from '../memory/db.js';
+import {
+  getRecentInvocations,
+  rotateToolInvocations,
+} from '../memory/tool-usage-store.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function addInvocation(ageMs: number): void {
+  // Insert directly with a specific timestamp in the past
+  const db = new Database(DB_PATH);
+  const id = randomBytes(8).toString('hex');
+  const createdAt = Date.now() - ageMs;
+  db.prepare(
+    `INSERT INTO tool_invocations (id, conversation_id, tool_name, input, result, decision, risk_level, duration_ms, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(id, 'conv-1', 'bash', '{"command":"echo hi"}', 'hi', 'allow', 'Low', 100, createdAt);
+  db.close();
+}
+
+function clearTable(): void {
+  const db = new Database(DB_PATH);
+  db.run('DELETE FROM tool_invocations');
+  db.close();
+}
+
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('audit log rotation', () => {
+  beforeAll(() => {
+    mkdirSync(join(TEST_DIR, 'logs'), { recursive: true });
+    resetDb();
+    initializeDb();
+    // Insert a conversations row so FK-enforced ORM inserts succeed
+    const db = new Database(DB_PATH);
+    db.run(`INSERT INTO conversations (id, title, created_at, updated_at) VALUES ('conv-1', 'test', ${Date.now()}, ${Date.now()})`);
+    db.close();
+  });
+
+  beforeEach(() => {
+    clearTable();
+  });
+
+  // TEST_DIR is in os.tmpdir() — let the OS handle cleanup.
+  // Deleting it here would trigger ENOENT in other test files because
+  // the platform.js mock leaks getDataDir() → TEST_DIR globally.
+
+  test('returns 0 when retentionDays is 0 (retain forever)', () => {
+    addInvocation(100 * ONE_DAY_MS); // 100 days old
+    const deleted = rotateToolInvocations(0);
+    expect(deleted).toBe(0);
+    expect(getRecentInvocations(100).length).toBe(1);
+  });
+
+  test('returns 0 when retentionDays is negative', () => {
+    addInvocation(100 * ONE_DAY_MS);
+    const deleted = rotateToolInvocations(-5);
+    expect(deleted).toBe(0);
+    expect(getRecentInvocations(100).length).toBe(1);
+  });
+
+  test('deletes records older than retentionDays', () => {
+    addInvocation(10 * ONE_DAY_MS); // 10 days old — should be deleted with 7-day retention
+    addInvocation(3 * ONE_DAY_MS);  // 3 days old — should be kept
+    addInvocation(1 * ONE_DAY_MS);  // 1 day old — should be kept
+
+    const deleted = rotateToolInvocations(7);
+    expect(deleted).toBe(1);
+    expect(getRecentInvocations(100).length).toBe(2);
+  });
+
+  test('keeps all records when none exceed retention', () => {
+    addInvocation(1 * ONE_DAY_MS);
+    addInvocation(2 * ONE_DAY_MS);
+    addInvocation(3 * ONE_DAY_MS);
+
+    const deleted = rotateToolInvocations(30);
+    expect(deleted).toBe(0);
+    expect(getRecentInvocations(100).length).toBe(3);
+  });
+
+  test('deletes all records when all exceed retention', () => {
+    addInvocation(60 * ONE_DAY_MS);
+    addInvocation(90 * ONE_DAY_MS);
+    addInvocation(120 * ONE_DAY_MS);
+
+    const deleted = rotateToolInvocations(30);
+    expect(deleted).toBe(3);
+    expect(getRecentInvocations(100).length).toBe(0);
+  });
+
+  test('returns 0 when table is empty', () => {
+    const deleted = rotateToolInvocations(7);
+    expect(deleted).toBe(0);
+  });
+
+  test('handles 1-day retention (deletes everything older than 24h)', () => {
+    addInvocation(2 * ONE_DAY_MS);  // 2 days old — delete
+    addInvocation(12 * 60 * 60 * 1000); // 12 hours old — keep
+
+    const deleted = rotateToolInvocations(1);
+    expect(deleted).toBe(1);
+    expect(getRecentInvocations(100).length).toBe(1);
+  });
+
+  test('works with recordToolInvocation (via ORM)', () => {
+    // Use raw SQL to insert (avoids db singleton issues in parallel test runs)
+    // and verify the rotation/query functions work correctly with it
+    addInvocation(0); // just-created record
+
+    // This record was just created, so it should not be rotated
+    const deleted = rotateToolInvocations(1);
+    expect(deleted).toBe(0);
+    expect(getRecentInvocations(100).length).toBe(1);
+  });
+});

package/src/__tests__/browser-fill-credential.test.ts

@@ -0,0 +1,309 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+
+// ── Mocks ────────────────────────────────────────────────────────────
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => '/tmp/browser-fill-credential-test',
+}));
+
+let mockPage: {
+  click: ReturnType<typeof mock>;
+  fill: ReturnType<typeof mock>;
+  press: ReturnType<typeof mock>;
+  evaluate: ReturnType<typeof mock>;
+  title: ReturnType<typeof mock>;
+  url: ReturnType<typeof mock>;
+  goto: ReturnType<typeof mock>;
+  close: () => Promise<void>;
+  isClosed: () => boolean;
+};
+
+let snapshotMaps: Map<string, Map<string, string>>;
+
+mock.module('../tools/browser/browser-manager.js', () => {
+  snapshotMaps = new Map();
+  return {
+    browserManager: {
+      getOrCreateSessionPage: async () => mockPage,
+      closeSessionPage: async () => {},
+      closeAllPages: async () => {},
+      storeSnapshotMap: (sessionId: string, map: Map<string, string>) => {
+        snapshotMaps.set(sessionId, map);
+      },
+      resolveSnapshotSelector: (sessionId: string, elementId: string) => {
+        const map = snapshotMaps.get(sessionId);
+        if (!map) return null;
+        return map.get(elementId) ?? null;
+      },
+    },
+  };
+});
+
+mock.module('../tools/network/url-safety.js', () => ({
+  parseUrl: () => null,
+  isPrivateOrLocalHost: () => false,
+  resolveHostAddresses: async () => [],
+  resolveRequestAddress: async () => ({}),
+  sanitizeUrlForOutput: (url: URL) => url.href,
+}));
+
+let mockGetSecureKey: ReturnType<typeof mock>;
+let mockGetCredentialMetadata: ReturnType<typeof mock>;
+
+mock.module('../security/secure-keys.js', () => ({
+  getSecureKey: (...args: unknown[]) => mockGetSecureKey(...args),
+  setSecureKey: () => true,
+  deleteSecureKey: () => true,
+  listSecureKeys: () => [],
+  getBackendType: () => 'encrypted',
+  _resetBackend: () => {},
+  _setBackend: () => {},
+}));
+
+mock.module('../tools/credentials/metadata-store.js', () => ({
+  getCredentialMetadata: (...args: unknown[]) => mockGetCredentialMetadata(...args),
+  getCredentialMetadataById: () => undefined,
+  upsertCredentialMetadata: () => {},
+  deleteCredentialMetadata: () => {},
+  _setMetadataPath: () => {},
+}));
+
+import { executeBrowserFillCredential } from '../tools/browser/headless-browser.js';
+import type { ToolContext } from '../tools/types.js';
+
+const ctx: ToolContext = {
+  sessionId: 'test-session',
+  conversationId: 'test-conversation',
+  workingDir: '/tmp',
+};
+
+function resetMockPage() {
+  mockPage = {
+    click: mock(async () => {}),
+    fill: mock(async () => {}),
+    press: mock(async () => {}),
+    evaluate: mock(async () => ''),
+    title: mock(async () => 'Test Page'),
+    url: mock(() => 'https://example.com/'),
+    goto: mock(async () => ({ status: () => 200, url: () => 'https://example.com/' })),
+    close: async () => {},
+    isClosed: () => false,
+  };
+}
+
+function defaultMetadata(service: string, field: string) {
+  return {
+    credentialId: `${service}:${field}`,
+    service,
+    field,
+    allowedTools: ['browser_fill_credential'],
+    allowedDomains: [] as string[],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+}
+
+// ── browser_fill_credential ──────────────────────────────────────────
+
+describe('executeBrowserFillCredential', () => {
+  beforeEach(() => {
+    resetMockPage();
+    snapshotMaps.clear();
+    mockGetSecureKey = mock(() => 'super-secret-password');
+    mockGetCredentialMetadata = mock((service: string, field: string) => defaultMetadata(service, field));
+  });
+
+  test('fills credential into element by element_id', async () => {
+    snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+    const result = await executeBrowserFillCredential(
+      { service: 'gmail', field: 'password', element_id: 'e1' },
+      ctx,
+    );
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Filled password for gmail');
+    expect(mockPage.fill).toHaveBeenCalledWith('[data-vellum-eid="e1"]', 'super-secret-password');
+    expect(mockGetSecureKey).toHaveBeenCalledWith('credential:gmail:password');
+  });
+
+  test('fills credential by CSS selector', async () => {
+    const result = await executeBrowserFillCredential(
+      { service: 'github', field: 'token', selector: 'input[name="password"]' },
+      ctx,
+    );
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Filled token for github');
+    expect(mockPage.fill).toHaveBeenCalledWith('input[name="password"]', 'super-secret-password');
+  });
+
+  test('returns error when credential not found', async () => {
+    mockGetCredentialMetadata = mock(() => undefined);
+    snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+    const result = await executeBrowserFillCredential(
+      { service: 'slack', field: 'api_key', element_id: 'e1' },
+      ctx,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No credential stored for slack/api_key');
+    expect(result.content).toContain('credential_store');
+    expect(mockPage.fill).not.toHaveBeenCalled();
+  });
+
+  test('returns error when metadata exists but no stored value', async () => {
+    mockGetSecureKey = mock(() => undefined);
+    snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+    const result = await executeBrowserFillCredential(
+      { service: 'slack', field: 'api_key', element_id: 'e1' },
+      ctx,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No credential stored for slack/api_key');
+    expect(result.content).toContain('credential_store');
+    expect(mockPage.fill).not.toHaveBeenCalled();
+  });
+
+  test('returns error when element not found', async () => {
+    const result = await executeBrowserFillCredential(
+      { service: 'gmail', field: 'password', element_id: 'e99' },
+      ctx,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('element_id "e99" not found');
+    expect(result.content).toContain('browser_snapshot');
+  });
+
+  test('presses Enter after fill when press_enter is true', async () => {
+    snapshotMaps.set('test-session', new Map([['e2', '[data-vellum-eid="e2"]']]));
+    const result = await executeBrowserFillCredential(
+      { service: 'gmail', field: 'password', element_id: 'e2', press_enter: true },
+      ctx,
+    );
+    expect(result.isError).toBe(false);
+    expect(mockPage.fill).toHaveBeenCalledWith('[data-vellum-eid="e2"]', 'super-secret-password');
+    expect(mockPage.press).toHaveBeenCalledWith('[data-vellum-eid="e2"]', 'Enter');
+  });
+
+  test('credential value NEVER appears in result content', async () => {
+    snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+    const result = await executeBrowserFillCredential(
+      { service: 'gmail', field: 'password', element_id: 'e1' },
+      ctx,
+    );
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain('super-secret-password');
+  });
+
+  test('returns error when service is missing', async () => {
+    snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+    const result = await executeBrowserFillCredential(
+      { field: 'password', element_id: 'e1' },
+      ctx,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('service is required');
+  });
+
+  test('returns error when field is missing', async () => {
+    snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+    const result = await executeBrowserFillCredential(
+      { service: 'gmail', element_id: 'e1' },
+      ctx,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('field is required');
+  });
+
+  // -----------------------------------------------------------------------
+  // Broker-mediated credential access — verify broker path is used
+  // -----------------------------------------------------------------------
+  describe('broker integration', () => {
+    test('fill succeeds with no domain or tool-policy checks', async () => {
+      snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+      const result = await executeBrowserFillCredential(
+        { service: 'gmail', field: 'password', element_id: 'e1' },
+        ctx,
+      );
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain('Filled password for gmail');
+      expect(result.content).not.toContain('super-secret-password');
+    });
+
+    test('credential access goes through broker (metadata + value checked)', async () => {
+      snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+      await executeBrowserFillCredential(
+        { service: 'gmail', field: 'password', element_id: 'e1' },
+        ctx,
+      );
+      // Broker checks metadata first, then reads the value
+      expect(mockGetCredentialMetadata).toHaveBeenCalledWith('gmail', 'password');
+      expect(mockGetSecureKey).toHaveBeenCalledWith('credential:gmail:password');
+    });
+
+    test('returns tool policy denial with actionable message', async () => {
+      mockGetCredentialMetadata = mock((service: string, field: string) => ({
+        ...defaultMetadata(service, field),
+        allowedTools: ['some_other_tool'],
+      }));
+      snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+      const result = await executeBrowserFillCredential(
+        { service: 'gmail', field: 'password', element_id: 'e1' },
+        ctx,
+      );
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain('Policy denied');
+      expect(result.content).toContain('not allowed to use credential');
+      expect(result.content).toContain('credential_store');
+      expect(mockPage.fill).not.toHaveBeenCalled();
+    });
+
+    test('returns domain policy denial with actionable message', async () => {
+      mockGetCredentialMetadata = mock((service: string, field: string) => ({
+        ...defaultMetadata(service, field),
+        allowedDomains: ['other-site.com'],
+      }));
+      snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+      const result = await executeBrowserFillCredential(
+        { service: 'gmail', field: 'password', element_id: 'e1' },
+        ctx,
+      );
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain('Domain policy denied');
+      expect(result.content).toContain('Navigate to an allowed domain');
+      expect(mockPage.fill).not.toHaveBeenCalled();
+    });
+
+    test('passes current page domain to broker', async () => {
+      mockGetCredentialMetadata = mock((service: string, field: string) => ({
+        ...defaultMetadata(service, field),
+        allowedDomains: ['example.com'],
+      }));
+      snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+      const result = await executeBrowserFillCredential(
+        { service: 'gmail', field: 'password', element_id: 'e1' },
+        ctx,
+      );
+      // Page URL is https://example.com/ which matches allowedDomains
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain('Filled password for gmail');
+    });
+
+    test('policy denial errors never contain credential values', async () => {
+      mockGetCredentialMetadata = mock((service: string, field: string) => ({
+        ...defaultMetadata(service, field),
+        allowedTools: ['other_tool'],
+      }));
+      snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+      const result = await executeBrowserFillCredential(
+        { service: 'gmail', field: 'password', element_id: 'e1' },
+        ctx,
+      );
+      expect(result.isError).toBe(true);
+      expect(result.content).not.toContain('super-secret-password');
+    });
+  });
+});