vellum 0.0.16 → 0.2.0

package/src/__tests__/reminder.test.ts

@@ -0,0 +1,263 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { initializeDb } from '../memory/db.js';
+import { getDb } from '../memory/db.js';
+import { reminders } from '../memory/schema.js';
+import { reminderTool } from '../tools/reminder/reminder.js';
+import { claimDueReminders } from '../tools/reminder/reminder-store.js';
+
+initializeDb();
+
+const dummyContext = {
+  workingDir: '/tmp',
+  sessionId: 'test-session',
+  conversationId: 'test-conversation',
+};
+
+function clearReminders() {
+  getDb().delete(reminders).run();
+}
+
+describe('reminder tool', () => {
+  beforeEach(() => {
+    clearReminders();
+  });
+
+  // ── action validation ───────────────────────────────────────────────
+
+  test('rejects missing action', async () => {
+    const result = await reminderTool.execute({}, dummyContext);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('action is required');
+  });
+
+  test('rejects unknown action', async () => {
+    const result = await reminderTool.execute({ action: 'explode' }, dummyContext);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Unknown action');
+  });
+
+  // ── create ──────────────────────────────────────────────────────────
+
+  test('create with valid future ISO timestamp succeeds', async () => {
+    const future = new Date(Date.now() + 60_000).toISOString();
+    const result = await reminderTool.execute({
+      action: 'create',
+      fire_at: future,
+      label: 'Call Sidd',
+      message: 'Remember to call Sidd',
+    }, dummyContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Reminder created');
+    expect(result.content).toContain('Call Sidd');
+    expect(result.content).toContain('notify');
+  });
+
+  test('create with past timestamp returns error', async () => {
+    const past = new Date(Date.now() - 60_000).toISOString();
+    const result = await reminderTool.execute({
+      action: 'create',
+      fire_at: past,
+      label: 'Too late',
+      message: 'This is in the past',
+    }, dummyContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('must be in the future');
+  });
+
+  test('create with invalid timestamp string returns error', async () => {
+    const result = await reminderTool.execute({
+      action: 'create',
+      fire_at: 'not-a-date',
+      label: 'Bad date',
+      message: 'This has a bad date',
+    }, dummyContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid timestamp');
+  });
+
+  test('create rejects non-ISO date formats like MM/DD/YYYY', async () => {
+    const result = await reminderTool.execute({
+      action: 'create',
+      fire_at: '03/04/2027',
+      label: 'Ambiguous date',
+      message: 'This format is locale-dependent',
+    }, dummyContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid timestamp');
+  });
+
+  test('create rejects ISO timestamp without timezone', async () => {
+    const result = await reminderTool.execute({
+      action: 'create',
+      fire_at: '2027-03-15T09:00:00',
+      label: 'No timezone',
+      message: 'Missing timezone offset',
+    }, dummyContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid timestamp');
+  });
+
+  test('create accepts ISO timestamp with timezone offset', async () => {
+    const future = new Date(Date.now() + 120_000);
+    const offset = '-05:00';
+    const isoWithOffset = future.toISOString().replace('Z', offset);
+    const result = await reminderTool.execute({
+      action: 'create',
+      fire_at: isoWithOffset,
+      label: 'With offset',
+      message: 'Has explicit timezone',
+    }, dummyContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Reminder created');
+  });
+
+  test('create defaults mode to notify', async () => {
+    const future = new Date(Date.now() + 60_000).toISOString();
+    const result = await reminderTool.execute({
+      action: 'create',
+      fire_at: future,
+      label: 'Default mode',
+      message: 'Should be notify',
+    }, dummyContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Mode: notify');
+  });
+
+  test('create with mode execute sets mode correctly', async () => {
+    const future = new Date(Date.now() + 60_000).toISOString();
+    const result = await reminderTool.execute({
+      action: 'create',
+      fire_at: future,
+      label: 'Execute mode',
+      message: 'Should be execute',
+      mode: 'execute',
+    }, dummyContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Mode: execute');
+  });
+
+  test('create requires fire_at', async () => {
+    const result = await reminderTool.execute({
+      action: 'create',
+      label: 'No fire_at',
+      message: 'Missing fire_at',
+    }, dummyContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('fire_at is required');
+  });
+
+  test('create requires label', async () => {
+    const future = new Date(Date.now() + 60_000).toISOString();
+    const result = await reminderTool.execute({
+      action: 'create',
+      fire_at: future,
+      message: 'Missing label',
+    }, dummyContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('label is required');
+  });
+
+  test('create requires message', async () => {
+    const future = new Date(Date.now() + 60_000).toISOString();
+    const result = await reminderTool.execute({
+      action: 'create',
+      fire_at: future,
+      label: 'No message',
+    }, dummyContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('message is required');
+  });
+
+  // ── list ────────────────────────────────────────────────────────────
+
+  test('list returns "No reminders found" when empty', async () => {
+    const result = await reminderTool.execute({ action: 'list' }, dummyContext);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('No reminders found');
+  });
+
+  test('list returns formatted reminders', async () => {
+    const future = new Date(Date.now() + 60_000).toISOString();
+    await reminderTool.execute({
+      action: 'create',
+      fire_at: future,
+      label: 'Test reminder',
+      message: 'Test message',
+    }, dummyContext);
+
+    const result = await reminderTool.execute({ action: 'list' }, dummyContext);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Test reminder');
+    expect(result.content).toContain('pending');
+  });
+
+  // ── cancel ──────────────────────────────────────────────────────────
+
+  test('cancel with valid pending reminder succeeds', async () => {
+    const future = new Date(Date.now() + 60_000).toISOString();
+    const createResult = await reminderTool.execute({
+      action: 'create',
+      fire_at: future,
+      label: 'Cancel me',
+      message: 'To be cancelled',
+    }, dummyContext);
+
+    // Extract ID from the create result
+    const idMatch = createResult.content.match(/ID: (.+)/);
+    expect(idMatch).not.toBeNull();
+    const id = idMatch![1].trim();
+
+    const result = await reminderTool.execute({
+      action: 'cancel',
+      reminder_id: id,
+    }, dummyContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('cancelled');
+  });
+
+  test('cancel with nonexistent ID returns error', async () => {
+    const result = await reminderTool.execute({
+      action: 'cancel',
+      reminder_id: 'nonexistent',
+    }, dummyContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('not found');
+  });
+
+  test('cancel with already-fired reminder returns error', async () => {
+    const future = new Date(Date.now() + 60_000).toISOString();
+    const createResult = await reminderTool.execute({
+      action: 'create',
+      fire_at: future,
+      label: 'Fire then cancel',
+      message: 'x',
+    }, dummyContext);
+
+    const idMatch = createResult.content.match(/ID: (.+)/);
+    const id = idMatch![1].trim();
+
+    // Force-fire by claiming with a future timestamp
+    claimDueReminders(Date.now() + 120_000);
+
+    const result = await reminderTool.execute({
+      action: 'cancel',
+      reminder_id: id,
+    }, dummyContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('not found or already fired');
+  });
+});

package/src/__tests__/request-file-tool.test.ts

@@ -0,0 +1,158 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  INTERACTIVE_SURFACE_TYPES,
+} from '../daemon/ipc-protocol.js';
+import type {
+  FileUploadSurfaceData,
+  UiSurfaceShowFileUpload,
+} from '../daemon/ipc-protocol.js';
+import { requestFileTool, uiShowTool } from '../tools/ui-surface/definitions.js';
+
+// ---------------------------------------------------------------------------
+// request_file tool definition
+// ---------------------------------------------------------------------------
+
+describe('requestFileTool definition', () => {
+  test('has the correct name and category', () => {
+    expect(requestFileTool.name).toBe('request_file');
+    expect(requestFileTool.category).toBe('ui-surface');
+    expect(requestFileTool.executionMode).toBe('proxy');
+  });
+
+  test('getDefinition returns correct input_schema', () => {
+    const definition = requestFileTool.getDefinition();
+
+    expect(definition.name).toBe('request_file');
+    expect(definition.description).toContain('file');
+
+    const schema = definition.input_schema as {
+      type: string;
+      properties: Record<string, unknown>;
+      required: string[];
+    };
+
+    expect(schema.type).toBe('object');
+    expect(schema.required).toEqual(['prompt']);
+    expect(schema.properties).toHaveProperty('prompt');
+    expect(schema.properties).toHaveProperty('accepted_types');
+    expect(schema.properties).toHaveProperty('max_files');
+  });
+
+  test('prompt property is a string type', () => {
+    const definition = requestFileTool.getDefinition();
+    const props = (definition.input_schema as {
+      properties: Record<string, { type: string }>;
+    }).properties;
+
+    expect(props.prompt.type).toBe('string');
+  });
+
+  test('accepted_types property is an array of strings', () => {
+    const definition = requestFileTool.getDefinition();
+    const props = (definition.input_schema as {
+      properties: Record<string, { type: string; items?: { type: string } }>;
+    }).properties;
+
+    expect(props.accepted_types.type).toBe('array');
+    expect(props.accepted_types.items).toEqual({ type: 'string' });
+  });
+
+  test('max_files property is a number type', () => {
+    const definition = requestFileTool.getDefinition();
+    const props = (definition.input_schema as {
+      properties: Record<string, { type: string }>;
+    }).properties;
+
+    expect(props.max_files.type).toBe('number');
+  });
+
+  test('execute throws proxy error', () => {
+    expect(() => requestFileTool.execute({}, {} as never)).toThrow(
+      'Proxy tool: execution must be forwarded to the connected client',
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// FileUploadSurfaceData shape
+// ---------------------------------------------------------------------------
+
+describe('FileUploadSurfaceData shape', () => {
+  test('accepts an object with prompt, acceptedTypes, and maxFiles', () => {
+    const data: FileUploadSurfaceData = {
+      prompt: 'Please share the design file',
+      acceptedTypes: ['image/*', 'application/pdf'],
+      maxFiles: 3,
+    };
+
+    expect(data.prompt).toBe('Please share the design file');
+    expect(data.acceptedTypes).toEqual(['image/*', 'application/pdf']);
+    expect(data.maxFiles).toBe(3);
+  });
+
+  test('acceptedTypes and maxFiles are optional', () => {
+    const data: FileUploadSurfaceData = {
+      prompt: 'Upload a file',
+    };
+
+    expect(data.prompt).toBe('Upload a file');
+    expect(data.acceptedTypes).toBeUndefined();
+    expect(data.maxFiles).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// UiSurfaceShowFileUpload structure
+// ---------------------------------------------------------------------------
+
+describe('UiSurfaceShowFileUpload structure', () => {
+  test('can construct a well-typed UiSurfaceShowFileUpload object', () => {
+    const msg: UiSurfaceShowFileUpload = {
+      type: 'ui_surface_show',
+      sessionId: 'session-abc',
+      surfaceId: 'surface-123',
+      surfaceType: 'file_upload',
+      title: 'File Request',
+      data: { prompt: 'Share a screenshot' },
+    };
+
+    expect(msg.type).toBe('ui_surface_show');
+    expect(msg.surfaceType).toBe('file_upload');
+    expect(msg.data.prompt).toBe('Share a screenshot');
+    expect(msg.title).toBe('File Request');
+    expect(msg.sessionId).toBe('session-abc');
+    expect(msg.surfaceId).toBe('surface-123');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Interactivity
+// ---------------------------------------------------------------------------
+
+describe('file_upload interactivity', () => {
+  test('file_upload is in the interactive surface types list', () => {
+    expect(INTERACTIVE_SURFACE_TYPES).toContain('file_upload');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ui_show tool includes file_upload in surface_type enum
+// ---------------------------------------------------------------------------
+
+describe('ui_show tool includes file_upload', () => {
+  test('input_schema surface_type enum includes file_upload', () => {
+    const definition = uiShowTool.getDefinition();
+    const surfaceTypeEnum = (
+      definition.input_schema as {
+        properties: { surface_type: { enum: string[] } };
+      }
+    ).properties.surface_type.enum;
+
+    expect(surfaceTypeEnum).toContain('file_upload');
+  });
+
+  test('description mentions file_upload', () => {
+    const definition = uiShowTool.getDefinition();
+    expect(definition.description).toContain('file_upload');
+  });
+});

package/src/__tests__/run-orchestrator.test.ts

@@ -0,0 +1,200 @@
+import { describe, test, expect, beforeEach, afterAll, mock } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { ServerMessage } from '../daemon/ipc-protocol.js';
+import type { Session } from '../daemon/session.js';
+
+const testDir = mkdtempSync(join(tmpdir(), 'run-orchestrator-test-'));
+
+mock.module('../util/platform.js', () => ({
+  getRootDir: () => testDir,
+  getDataDir: () => 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: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
+import { createConversation } from '../memory/conversation-store.js';
+import { createRun, getRun, setRunConfirmation } from '../memory/runs-store.js';
+import { RunOrchestrator } from '../runtime/run-orchestrator.js';
+
+initializeDb();
+
+function makeSessionWithConfirmation(message: ServerMessage): Session {
+  let clientHandler: (msg: ServerMessage) => void = () => {};
+  return {
+    isProcessing: () => false,
+    // Return undefined so createRun stores messageId as null and avoids
+    // a foreign-key dependency on the conversation-store message table.
+    persistUserMessage: () => undefined as unknown as string,
+    setAssistantId: () => {},
+    updateClient: (handler: (msg: ServerMessage) => void) => {
+      clientHandler = handler;
+    },
+    runAgentLoop: async () => {
+      clientHandler(message);
+      return await new Promise<void>(() => {});
+    },
+    handleConfirmationResponse: () => {},
+  } as unknown as Session;
+}
+
+/**
+ * Build a session whose runAgentLoop emits the given message via the onEvent
+ * callback and then resolves (simulating a completed agent loop).
+ */
+function makeSessionWithEvent(message: ServerMessage): Session {
+  return {
+    isProcessing: () => false,
+    persistUserMessage: () => undefined as unknown as string,
+    setAssistantId: () => {},
+    updateClient: () => {},
+    runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
+      onEvent(message);
+    },
+    handleConfirmationResponse: () => {},
+  } as unknown as Session;
+}
+
+describe('run failure detection', () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run('DELETE FROM message_runs');
+    db.run('DELETE FROM messages');
+    db.run('DELETE FROM conversations');
+  });
+
+  test('session_error event marks the run as failed', async () => {
+    const conversation = createConversation('session error test');
+    const session = makeSessionWithEvent({
+      type: 'session_error',
+      sessionId: conversation.id,
+      code: 'PROVIDER_NETWORK',
+      userMessage: 'Unable to reach the AI provider.',
+      retryable: true,
+    });
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+    });
+
+    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Hello');
+
+    // The agent loop fires asynchronously; give it a tick to settle.
+    await new Promise((r) => setTimeout(r, 50));
+
+    const stored = orchestrator.getRun(run.id);
+    expect(stored?.status).toBe('failed');
+    expect(stored?.error).toBe('Unable to reach the AI provider.');
+  });
+
+  test('generic error event still marks the run as failed', async () => {
+    const conversation = createConversation('generic error test');
+    const session = makeSessionWithEvent({
+      type: 'error',
+      message: 'Something went wrong',
+    });
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+    });
+
+    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Hello');
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    const stored = orchestrator.getRun(run.id);
+    expect(stored?.status).toBe('failed');
+    expect(stored?.error).toBe('Something went wrong');
+  });
+});
+
+describe('run approval state executionTarget', () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run('DELETE FROM message_runs');
+    db.run('DELETE FROM messages');
+    db.run('DELETE FROM conversations');
+  });
+
+  afterAll(() => {
+    resetDb();
+    try { rmSync(testDir, { recursive: true, force: true }); } catch { /* best effort */ }
+  });
+
+  test('stores pending confirmation executionTarget when provided', () => {
+    const conversation = createConversation('run test');
+    const run = createRun('assistant-1', conversation.id);
+
+    setRunConfirmation(run.id, {
+      toolName: 'host_file_read',
+      toolUseId: 'req-1',
+      input: { path: '/etc/hosts' },
+      riskLevel: 'medium',
+      executionTarget: 'host',
+      allowlistOptions: [{ label: '/etc/hosts', pattern: 'host_file_read:/etc/hosts' }],
+      scopeOptions: [{ label: 'everywhere', scope: 'everywhere' }],
+    });
+
+    const stored = getRun(run.id);
+    expect(stored?.status).toBe('needs_confirmation');
+    expect(stored?.pendingConfirmation?.executionTarget).toBe('host');
+  });
+
+  test('parses pending confirmations without executionTarget for legacy rows', () => {
+    const conversation = createConversation('legacy run test');
+    const run = createRun('assistant-1', conversation.id);
+
+    setRunConfirmation(run.id, {
+      toolName: 'bash',
+      toolUseId: 'req-legacy',
+      input: { command: 'ls' },
+      riskLevel: 'medium',
+      allowlistOptions: [{ label: 'ls', pattern: 'ls' }],
+      scopeOptions: [{ label: '/tmp', scope: '/tmp' }],
+    });
+
+    const stored = getRun(run.id);
+    expect(stored?.status).toBe('needs_confirmation');
+    expect(stored?.pendingConfirmation?.executionTarget).toBeUndefined();
+  });
+
+  test('run orchestrator persists executionTarget from confirmation_request', async () => {
+    const conversation = createConversation('orchestrator run test');
+    const session = makeSessionWithConfirmation({
+      type: 'confirmation_request',
+      requestId: 'req-2',
+      toolName: 'host_bash',
+      input: { command: 'pwd' },
+      riskLevel: 'medium',
+      executionTarget: 'host',
+      allowlistOptions: [{ label: 'pwd', description: 'This exact command', pattern: 'pwd' }],
+      scopeOptions: [{ label: 'everywhere', scope: 'everywhere' }],
+    });
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+    });
+
+    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Run host command');
+    const stored = orchestrator.getRun(run.id);
+    expect(stored?.status).toBe('needs_confirmation');
+    expect(stored?.pendingConfirmation?.executionTarget).toBe('host');
+  });
+});