vellum 0.2.0 → 0.2.2

package/scripts/test.sh

@@ -36,6 +36,11 @@ while IFS= read -r test_file; do
       continue
     fi
   fi
+  # Always exclude benchmark files — run them with `bun run test:bench` instead
+  if [[ "$(basename "${test_file}")" == *.benchmark.test.ts ]]; then
+    continue
+  fi
+
   test_files+=("${test_file}")
 done < <(find src/__tests__ -maxdepth 1 -type f -name '*.test.ts' | sort)
 

package/src/__tests__/__snapshots__/ipc-snapshot.test.ts.snap

@@ -87,6 +87,13 @@ exports[`IPC message snapshots ClientMessage types model_set serializes to expec
 }
 `;
 
+exports[`IPC message snapshots ClientMessage types image_gen_model_set serializes to expected JSON 1`] = `
+{
+  "model": "gemini-2.5-flash-image",
+  "type": "image_gen_model_set",
+}
+`;
+
 exports[`IPC message snapshots ClientMessage types history_request serializes to expected JSON 1`] = `
 {
   "sessionId": "sess-001",
@@ -530,6 +537,25 @@ exports[`IPC message snapshots ClientMessage types vercel_api_config serializes
 }
 `;
 
+exports[`IPC message snapshots ClientMessage types twitter_integration_config serializes to expected JSON 1`] = `
+{
+  "action": "get",
+  "type": "twitter_integration_config",
+}
+`;
+
+exports[`IPC message snapshots ClientMessage types twitter_auth_start serializes to expected JSON 1`] = `
+{
+  "type": "twitter_auth_start",
+}
+`;
+
+exports[`IPC message snapshots ClientMessage types twitter_auth_status serializes to expected JSON 1`] = `
+{
+  "type": "twitter_auth_status",
+}
+`;
+
 exports[`IPC message snapshots ClientMessage types link_open_request serializes to expected JSON 1`] = `
 {
   "type": "link_open_request",
@@ -661,17 +687,6 @@ exports[`IPC message snapshots ClientMessage types work_item_get serializes to e
 }
 `;
 
-exports[`IPC message snapshots ClientMessage types work_item_create serializes to expected JSON 1`] = `
-{
-  "notes": "High priority",
-  "priorityTier": 1,
-  "sortIndex": 0,
-  "taskId": "task-001",
-  "title": "Process report",
-  "type": "work_item_create",
-}
-`;
-
 exports[`IPC message snapshots ClientMessage types work_item_update serializes to expected JSON 1`] = `
 {
   "id": "wi-001",
@@ -688,6 +703,13 @@ exports[`IPC message snapshots ClientMessage types work_item_complete serializes
 }
 `;
 
+exports[`IPC message snapshots ClientMessage types work_item_delete serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "type": "work_item_delete",
+}
+`;
+
 exports[`IPC message snapshots ClientMessage types work_item_run_task serializes to expected JSON 1`] = `
 {
   "id": "wi-001",
@@ -695,6 +717,38 @@ exports[`IPC message snapshots ClientMessage types work_item_run_task serializes
 }
 `;
 
+exports[`IPC message snapshots ClientMessage types work_item_output serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "type": "work_item_output",
+}
+`;
+
+exports[`IPC message snapshots ClientMessage types work_item_preflight serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "type": "work_item_preflight",
+}
+`;
+
+exports[`IPC message snapshots ClientMessage types work_item_approve_permissions serializes to expected JSON 1`] = `
+{
+  "approvedTools": [
+    "bash",
+    "file_write",
+  ],
+  "id": "wi-001",
+  "type": "work_item_approve_permissions",
+}
+`;
+
+exports[`IPC message snapshots ClientMessage types work_item_cancel serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "type": "work_item_cancel",
+}
+`;
+
 exports[`IPC message snapshots ClientMessage types document_save serializes to expected JSON 1`] = `
 {
   "content": "# Hello",
@@ -729,7 +783,6 @@ exports[`IPC message snapshots ClientMessage types subagent_abort serializes to
 
 exports[`IPC message snapshots ClientMessage types subagent_status serializes to expected JSON 1`] = `
 {
-  "sessionId": "sess-001",
   "subagentId": "sub-001",
   "type": "subagent_status",
 }
@@ -1437,12 +1490,14 @@ exports[`IPC message snapshots ServerMessage types schedules_list_response seria
       "cronExpression": "0 9 * * 1-5",
       "description": "Every weekday at 9:00 AM",
       "enabled": true,
+      "expression": "0 9 * * 1-5",
       "id": "sched-001",
       "lastRunAt": 1700000000000,
       "lastStatus": "ok",
       "message": "Remind me about the standup",
       "name": "Daily standup reminder",
       "nextRunAt": 1700100000000,
+      "syntax": "cron",
       "timezone": "America/Los_Angeles",
     },
   ],
@@ -1723,6 +1778,34 @@ exports[`IPC message snapshots ServerMessage types vercel_api_config_response se
 }
 `;
 
+exports[`IPC message snapshots ServerMessage types twitter_integration_config_response serializes to expected JSON 1`] = `
+{
+  "connected": false,
+  "localClientConfigured": true,
+  "managedAvailable": false,
+  "mode": "local_byo",
+  "success": true,
+  "type": "twitter_integration_config_response",
+}
+`;
+
+exports[`IPC message snapshots ServerMessage types twitter_auth_result serializes to expected JSON 1`] = `
+{
+  "accountInfo": "@vellum_test",
+  "success": true,
+  "type": "twitter_auth_result",
+}
+`;
+
+exports[`IPC message snapshots ServerMessage types twitter_auth_status_response serializes to expected JSON 1`] = `
+{
+  "accountInfo": "@vellum_test",
+  "connected": true,
+  "mode": "local_byo",
+  "type": "twitter_auth_status_response",
+}
+`;
+
 exports[`IPC message snapshots ServerMessage types open_url serializes to expected JSON 1`] = `
 {
   "title": "Example",
@@ -1973,28 +2056,6 @@ exports[`IPC message snapshots ServerMessage types work_item_get_response serial
 }
 `;
 
-exports[`IPC message snapshots ServerMessage types work_item_create_response serializes to expected JSON 1`] = `
-{
-  "item": {
-    "createdAt": 1700000000,
-    "id": "wi-001",
-    "lastRunConversationId": null,
-    "lastRunId": null,
-    "lastRunStatus": null,
-    "notes": null,
-    "priorityTier": 1,
-    "sortIndex": null,
-    "sourceId": null,
-    "sourceType": null,
-    "status": "queued",
-    "taskId": "task-001",
-    "title": "Process report",
-    "updatedAt": 1700000000,
-  },
-  "type": "work_item_create_response",
-}
-`;
-
 exports[`IPC message snapshots ServerMessage types work_item_update_response serializes to expected JSON 1`] = `
 {
   "item": {
@@ -2017,6 +2078,14 @@ exports[`IPC message snapshots ServerMessage types work_item_update_response ser
 }
 `;
 
+exports[`IPC message snapshots ServerMessage types work_item_delete_response serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "success": true,
+  "type": "work_item_delete_response",
+}
+`;
+
 exports[`IPC message snapshots ServerMessage types work_item_run_task_response serializes to expected JSON 1`] = `
 {
   "id": "wi-001",
@@ -2026,6 +2095,58 @@ exports[`IPC message snapshots ServerMessage types work_item_run_task_response s
 }
 `;
 
+exports[`IPC message snapshots ServerMessage types work_item_output_response serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "output": {
+    "completedAt": 1700002000,
+    "conversationId": "conv-001",
+    "highlights": [
+      "- Key finding 1",
+      "- Key finding 2",
+    ],
+    "runId": "run-001",
+    "status": "completed",
+    "summary": "Report processed successfully.",
+    "title": "Process report",
+  },
+  "success": true,
+  "type": "work_item_output_response",
+}
+`;
+
+exports[`IPC message snapshots ServerMessage types work_item_preflight_response serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "permissions": [
+    {
+      "currentDecision": "prompt",
+      "description": "Run shell commands",
+      "riskLevel": "medium",
+      "tool": "bash",
+    },
+  ],
+  "success": true,
+  "type": "work_item_preflight_response",
+}
+`;
+
+exports[`IPC message snapshots ServerMessage types work_item_approve_permissions_response serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "success": true,
+  "type": "work_item_approve_permissions_response",
+}
+`;
+
+exports[`IPC message snapshots ServerMessage types work_item_cancel_response serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "success": true,
+  "type": "work_item_cancel_response",
+}
+`;
+
 exports[`IPC message snapshots ServerMessage types work_item_status_changed serializes to expected JSON 1`] = `
 {
   "item": {
@@ -2042,6 +2163,12 @@ exports[`IPC message snapshots ServerMessage types work_item_status_changed seri
 }
 `;
 
+exports[`IPC message snapshots ServerMessage types tasks_changed serializes to expected JSON 1`] = `
+{
+  "type": "tasks_changed",
+}
+`;
+
 exports[`IPC message snapshots ServerMessage types open_tasks_window serializes to expected JSON 1`] = `
 {
   "type": "open_tasks_window",

package/src/__tests__/account-registry.test.ts

@@ -28,7 +28,7 @@ mock.module('../tools/registry.js', () => ({
   registerTool: () => {},
 }));
 
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import {
   createAccount,
   listAccounts,
@@ -47,6 +47,7 @@ const _ctx: ToolContext = {
 };
 
 afterAll(() => {
+  resetDb();
   mock.restore();
   try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
 });

package/src/__tests__/agent-heartbeat-service.test.ts

@@ -0,0 +1,250 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+// Mock platform to use a temp workspace dir
+let testWorkspaceDir: string;
+
+mock.module('../util/platform.js', () => ({
+  getWorkspacePromptPath: (file: string) => join(testWorkspaceDir, file),
+}));
+
+// Mock config loader
+let mockConfig = {
+  agentHeartbeat: {
+    enabled: true,
+    intervalMs: 60_000,
+    activeHoursStart: undefined as number | undefined,
+    activeHoursEnd: undefined as number | undefined,
+  },
+};
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => mockConfig,
+  loadConfig: () => mockConfig,
+}));
+
+// Mock conversation store
+const createdConversations: Array<{ title: string; threadType: string }> = [];
+let conversationIdCounter = 0;
+
+mock.module('../memory/conversation-store.js', () => ({
+  createConversation: (opts: { title: string; threadType: string }) => {
+    createdConversations.push(opts);
+    return { id: `conv-${++conversationIdCounter}`, ...opts };
+  },
+}));
+
+// Mock logger
+mock.module('../util/logger.js', () => ({
+  getLogger: () => ({
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+}));
+
+// Import after mocks are set up
+const { AgentHeartbeatService } = await import('../agent-heartbeat/agent-heartbeat-service.js');
+
+describe('AgentHeartbeatService', () => {
+  let processMessageCalls: Array<{ conversationId: string; content: string }>;
+  let alerterCalls: Array<{ type: string; title: string; body: string }>;
+
+  beforeEach(() => {
+    testWorkspaceDir = join(tmpdir(), `vellum-agent-hb-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(testWorkspaceDir, { recursive: true });
+
+    processMessageCalls = [];
+    alerterCalls = [];
+    createdConversations.length = 0;
+    conversationIdCounter = 0;
+
+    mockConfig = {
+      agentHeartbeat: {
+        enabled: true,
+        intervalMs: 60_000,
+        activeHoursStart: undefined,
+        activeHoursEnd: undefined,
+      },
+    };
+  });
+
+  function createService(overrides?: {
+    processMessage?: (id: string, content: string) => Promise<{ messageId: string }>;
+    getCurrentHour?: () => number;
+  }) {
+    return new AgentHeartbeatService({
+      processMessage: overrides?.processMessage ?? (async (conversationId: string, content: string) => {
+        processMessageCalls.push({ conversationId, content });
+        return { messageId: 'msg-1' };
+      }),
+      alerter: (alert: { type: string; title: string; body: string }) => {
+        alerterCalls.push(alert);
+      },
+      getCurrentHour: overrides?.getCurrentHour,
+    });
+  }
+
+  test('runOnce() calls processMessage with correct prompt', async () => {
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].conversationId).toBe('conv-1');
+    expect(processMessageCalls[0].content).toContain('<heartbeat-checklist>');
+    expect(processMessageCalls[0].content).toContain('<heartbeat-disposition>');
+    expect(processMessageCalls[0].content).toContain('HEARTBEAT_OK');
+    expect(processMessageCalls[0].content).toContain('HEARTBEAT_ALERT');
+  });
+
+  test('HEARTBEAT.md content is embedded in prompt when file exists', async () => {
+    const customChecklist = '- Check the weather\n- Water the plants';
+    writeFileSync(join(testWorkspaceDir, 'HEARTBEAT.md'), customChecklist);
+
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].content).toContain('Check the weather');
+    expect(processMessageCalls[0].content).toContain('Water the plants');
+  });
+
+  test('default checklist used when no HEARTBEAT.md', async () => {
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].content).toContain('Check the current weather');
+  });
+
+  test('creates background conversation titled "Agent Heartbeat"', async () => {
+    const service = createService();
+    await service.runOnce();
+
+    expect(createdConversations).toHaveLength(1);
+    expect(createdConversations[0].title).toBe('Agent Heartbeat');
+    expect(createdConversations[0].threadType).toBe('background');
+  });
+
+  test('active hours guard skips outside window', async () => {
+    mockConfig.agentHeartbeat.activeHoursStart = 9;
+    mockConfig.agentHeartbeat.activeHoursEnd = 17;
+
+    const service = createService({ getCurrentHour: () => 3 });
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(0);
+  });
+
+  test('active hours guard allows within window', async () => {
+    mockConfig.agentHeartbeat.activeHoursStart = 9;
+    mockConfig.agentHeartbeat.activeHoursEnd = 17;
+
+    const service = createService({ getCurrentHour: () => 12 });
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+  });
+
+  test('active hours handles overnight window', async () => {
+    mockConfig.agentHeartbeat.activeHoursStart = 22;
+    mockConfig.agentHeartbeat.activeHoursEnd = 6;
+
+    // 23:00 should be within the window
+    const service = createService({ getCurrentHour: () => 23 });
+    await service.runOnce();
+    expect(processMessageCalls).toHaveLength(1);
+
+    // 10:00 should be outside the window
+    processMessageCalls.length = 0;
+    createdConversations.length = 0;
+    const service2 = createService({ getCurrentHour: () => 10 });
+    await service2.runOnce();
+    expect(processMessageCalls).toHaveLength(0);
+  });
+
+  test('overlap prevention works', async () => {
+    let resolveFirst: () => void;
+    const firstPromise = new Promise<void>((r) => { resolveFirst = r; });
+
+    const service = createService({
+      processMessage: async () => {
+        await firstPromise;
+        processMessageCalls.push({ conversationId: 'slow', content: 'slow' });
+        return { messageId: 'msg-1' };
+      },
+    });
+
+    // Start first run (will block)
+    const run1 = service.runOnce();
+    // Give the first run a tick to set activeRun
+    await new Promise((r) => setTimeout(r, 10));
+
+    // Second run should be skipped due to overlap
+    await service.runOnce();
+
+    // Resolve the first run
+    resolveFirst!();
+    await run1;
+
+    // Only the first run should have called processMessage
+    expect(processMessageCalls).toHaveLength(1);
+  });
+
+  test('disabled config prevents start', () => {
+    mockConfig.agentHeartbeat.enabled = false;
+    const service = createService();
+    service.start();
+    // No error, just a no-op. We can verify by calling stop which should also be a no-op.
+    // The key assertion is that no timer is set (verified by stop not hanging).
+    service.stop();
+  });
+
+  test('disabled config prevents runOnce', async () => {
+    mockConfig.agentHeartbeat.enabled = false;
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(0);
+  });
+
+  test('alerts on processMessage failure', async () => {
+    const service = createService({
+      processMessage: async () => {
+        throw new Error('LLM timeout');
+      },
+    });
+
+    await service.runOnce();
+
+    expect(alerterCalls).toHaveLength(1);
+    expect(alerterCalls[0].type).toBe('agent_heartbeat_alert');
+    expect(alerterCalls[0].title).toBe('Agent Heartbeat Failed');
+    expect(alerterCalls[0].body).toBe('LLM timeout');
+  });
+
+  test('alerts on conversation creation failure', async () => {
+    // Override createConversation to throw via a fresh import trick:
+    // Since createConversation is mocked at module level, we simulate
+    // this by having processMessage throw before it's called — but the
+    // real fix is that executeRun wraps createConversation in the try/catch.
+    // We verify by checking that any error in executeRun triggers the alert.
+    const service = createService({
+      processMessage: async () => {
+        throw new Error('DB locked');
+      },
+    });
+
+    await service.runOnce();
+
+    expect(alerterCalls).toHaveLength(1);
+    expect(alerterCalls[0].body).toBe('DB locked');
+  });
+
+  test('cleanup', () => {
+    try { rmSync(testWorkspaceDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+});

package/src/__tests__/app-bundler.test.ts

@@ -1,5 +1,4 @@
 import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test';
-import { createHash } from 'node:crypto';
 
 // Mock the logger before importing the module under test
 mock.module('../util/logger.js', () => ({
@@ -11,27 +10,6 @@ mock.module('../util/logger.js', () => ({
 
 import { extractRemoteUrls, materializeAssets } from '../bundler/app-bundler.js';
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Compute expected asset filename for a URL (mirrors the production logic). */
-function expectedFilename(url: string): string {
-  const hash = createHash('sha256').update(url).digest('hex').slice(0, 12);
-  let ext = '';
-  try {
-    const parsed = new URL(url);
-    const match = parsed.pathname.match(/\.\w+$/);
-    ext = match ? match[0] : '';
-  } catch {
-    // no extension
-  }
-  if (!ext || ext.length > 10 || !/^\.\w+$/.test(ext)) {
-    ext = '';
-  }
-  return `${hash}${ext}`;
-}
-
 // ---------------------------------------------------------------------------
 // extractRemoteUrls
 // ---------------------------------------------------------------------------
@@ -167,10 +145,9 @@ describe('materializeAssets', () => {
     const html = `<img src="${imageUrl}">`;
     const result = await materializeAssets(html);
 
-    const filename = expectedFilename(imageUrl);
-    expect(result.rewrittenHtml).toBe(`<img src="assets/${filename}">`);
+    expect(result.rewrittenHtml).toBe('<img src="assets/e724846245db.png">');
     expect(result.assets).toHaveLength(1);
-    expect(result.assets[0].archivePath).toBe(`assets/${filename}`);
+    expect(result.assets[0].archivePath).toBe('assets/e724846245db.png');
     expect(result.assets[0].data).toEqual(imageData);
   });
 
@@ -193,9 +170,14 @@ describe('materializeAssets', () => {
     const result = await materializeAssets(html);
 
     expect(result.assets).toHaveLength(3);
+
+    const expectedFilenames: Record<string, string> = {
+      'https://cdn.example.com/a.png': '6155f67efa62.png',
+      'https://cdn.example.com/b.css': '5e6d8d571910.css',
+      'https://cdn.example.com/c.js': '20fb1ea9b4c9.js',
+    };
     for (const url of urls) {
-      const filename = expectedFilename(url);
-      expect(result.rewrittenHtml).toContain(`assets/${filename}`);
+      expect(result.rewrittenHtml).toContain(`assets/${expectedFilenames[url]}`);
       expect(result.rewrittenHtml).not.toContain(url);
     }
   });
@@ -242,8 +224,7 @@ describe('materializeAssets', () => {
     const html = `<img src="${goodUrl}"><img src="${badUrl}">`;
     const result = await materializeAssets(html);
 
-    const goodFilename = expectedFilename(goodUrl);
-    expect(result.rewrittenHtml).toContain(`assets/${goodFilename}`);
+    expect(result.rewrittenHtml).toContain('assets/691e2a787421.png');
     expect(result.rewrittenHtml).toContain(badUrl);
     expect(result.assets).toHaveLength(1);
   });
@@ -265,9 +246,8 @@ describe('materializeAssets', () => {
     expect(result.assets).toHaveLength(1);
 
     // Both occurrences should be rewritten
-    const filename = expectedFilename(imageUrl);
     expect(result.rewrittenHtml).not.toContain(imageUrl);
-    const matches = result.rewrittenHtml.match(new RegExp(`assets/${filename}`, 'g'));
+    const matches = result.rewrittenHtml.match(/assets\/2f7fc0f99275\.png/g);
     expect(matches).toHaveLength(2);
   });
 
@@ -306,8 +286,7 @@ describe('materializeAssets', () => {
     const html = '<style>body { background: url("https://cdn.example.com/bg.jpg"); }</style>';
     const result = await materializeAssets(html);
 
-    const filename = expectedFilename(cssUrl);
-    expect(result.rewrittenHtml).toContain(`assets/${filename}`);
+    expect(result.rewrittenHtml).toContain('assets/8550eecd4975.jpg');
     expect(result.rewrittenHtml).not.toContain(cssUrl);
   });
 });