vellum 0.2.1 → 0.2.7

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

@@ -0,0 +1,303 @@
+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';
+
+const testDir = mkdtempSync(join(tmpdir(), 'followup-tools-test-'));
+
+mock.module('../util/platform.js', () => ({
+  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: () => {},
+  migrateToDataLayout: () => {},
+  migrateToWorkspaceLayout: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({ memory: {} }),
+}));
+
+import type { Database } from 'bun:sqlite';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
+import type { ToolContext } from '../tools/types.js';
+import { executeFollowupCreate } from '../tools/followups/followup_create.js';
+import { executeFollowupList } from '../tools/followups/followup_list.js';
+import { executeFollowupResolve } from '../tools/followups/followup_resolve.js';
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+});
+
+function getRawDb(): Database {
+  return (getDb() as unknown as { $client: Database }).$client;
+}
+
+const ctx: ToolContext = {
+  workingDir: '/tmp',
+  sessionId: 'test-session',
+  conversationId: 'test-conversation',
+};
+
+function clearFollowups(): void {
+  getRawDb().run('DELETE FROM followups');
+}
+
+function extractFollowupId(content: string): string {
+  const match = content.match(/Follow-up (\S+)/);
+  expect(match).not.toBeNull();
+  return match![1];
+}
+
+// ── followup_create ─────────────────────────────────────────────────
+
+describe('followup_create tool', () => {
+  beforeEach(clearFollowups);
+
+  test('creates a follow-up with required fields', async () => {
+    const result = await executeFollowupCreate({
+      channel: 'email',
+      thread_id: 'thread-123',
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Created follow-up');
+    expect(result.content).toContain('email');
+    expect(result.content).toContain('thread-123');
+    expect(result.content).toContain('Status: pending');
+  });
+
+  test('creates a follow-up with expected response deadline', async () => {
+    const result = await executeFollowupCreate({
+      channel: 'slack',
+      thread_id: 'slack-thread-1',
+      expected_response_hours: 24,
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Expected response by');
+  });
+
+  test('creates a follow-up with reminder_schedule_id (canonical)', async () => {
+    const result = await executeFollowupCreate({
+      channel: 'email',
+      thread_id: 'thread-456',
+      reminder_schedule_id: 'sched-abc',
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Reminder schedule: sched-abc');
+  });
+
+  test('creates a follow-up with deprecated reminder_cron_id alias', async () => {
+    const result = await executeFollowupCreate({
+      channel: 'email',
+      thread_id: 'thread-789',
+      reminder_cron_id: 'cron-abc',
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Reminder schedule: cron-abc');
+  });
+
+  test('reminder_schedule_id takes precedence over reminder_cron_id', async () => {
+    const result = await executeFollowupCreate({
+      channel: 'email',
+      thread_id: 'thread-prio',
+      reminder_schedule_id: 'sched-wins',
+      reminder_cron_id: 'cron-loses',
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Reminder schedule: sched-wins');
+    expect(result.content).not.toContain('cron-loses');
+  });
+
+  test('rejects missing channel', async () => {
+    const result = await executeFollowupCreate({
+      thread_id: 'thread-123',
+    }, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('channel is required');
+  });
+
+  test('rejects empty channel', async () => {
+    const result = await executeFollowupCreate({
+      channel: '   ',
+      thread_id: 'thread-123',
+    }, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('channel is required');
+  });
+
+  test('rejects missing thread_id', async () => {
+    const result = await executeFollowupCreate({
+      channel: 'email',
+    }, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('thread_id is required');
+  });
+
+  test('rejects non-positive expected_response_hours', async () => {
+    const result = await executeFollowupCreate({
+      channel: 'email',
+      thread_id: 'thread-123',
+      expected_response_hours: -1,
+    }, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('expected_response_hours must be a positive number');
+  });
+
+  test('rejects nonexistent contact_id', async () => {
+    const result = await executeFollowupCreate({
+      channel: 'email',
+      thread_id: 'thread-123',
+      contact_id: 'nonexistent-contact',
+    }, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Contact "nonexistent-contact" not found');
+  });
+});
+
+// ── followup_list ───────────────────────────────────────────────────
+
+describe('followup_list tool', () => {
+  beforeEach(clearFollowups);
+
+  test('returns empty message when no follow-ups exist', async () => {
+    const result = await executeFollowupList({}, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('No follow-ups found');
+  });
+
+  test('lists all follow-ups', async () => {
+    await executeFollowupCreate({ channel: 'email', thread_id: 'thread-1' }, ctx);
+    await executeFollowupCreate({ channel: 'slack', thread_id: 'thread-2' }, ctx);
+
+    const result = await executeFollowupList({}, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Found 2 follow-up(s)');
+    expect(result.content).toContain('email');
+    expect(result.content).toContain('slack');
+  });
+
+  test('filters by status', async () => {
+    await executeFollowupCreate({ channel: 'email', thread_id: 'thread-1' }, ctx);
+
+    const result = await executeFollowupList({ status: 'pending' }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Found 1 follow-up(s)');
+  });
+
+  test('filters by channel', async () => {
+    await executeFollowupCreate({ channel: 'email', thread_id: 'thread-1' }, ctx);
+    await executeFollowupCreate({ channel: 'slack', thread_id: 'thread-2' }, ctx);
+
+    const result = await executeFollowupList({ channel: 'email' }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('email');
+    expect(result.content).not.toContain('**slack**');
+  });
+
+  test('returns error for invalid status', async () => {
+    const result = await executeFollowupList({ status: 'invalid' }, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid status');
+  });
+});
+
+// ── followup_resolve ────────────────────────────────────────────────
+
+describe('followup_resolve tool', () => {
+  beforeEach(clearFollowups);
+
+  test('resolves a follow-up by ID', async () => {
+    const createResult = await executeFollowupCreate({
+      channel: 'email',
+      thread_id: 'thread-1',
+    }, ctx);
+    const id = extractFollowupId(createResult.content);
+
+    const result = await executeFollowupResolve({ id }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Resolved follow-up');
+    expect(result.content).toContain('Status: resolved');
+  });
+
+  test('resolves by channel and thread_id', async () => {
+    await executeFollowupCreate({
+      channel: 'email',
+      thread_id: 'thread-1',
+    }, ctx);
+
+    const result = await executeFollowupResolve({
+      channel: 'email',
+      thread_id: 'thread-1',
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Resolved 1 follow-up(s)');
+  });
+
+  test('resolves multiple follow-ups by thread', async () => {
+    await executeFollowupCreate({ channel: 'email', thread_id: 'shared-thread' }, ctx);
+    await executeFollowupCreate({ channel: 'email', thread_id: 'shared-thread' }, ctx);
+
+    const result = await executeFollowupResolve({
+      channel: 'email',
+      thread_id: 'shared-thread',
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Resolved 2 follow-up(s)');
+  });
+
+  test('returns no-match message for nonexistent thread', async () => {
+    const result = await executeFollowupResolve({
+      channel: 'email',
+      thread_id: 'nonexistent',
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('No pending follow-up found');
+  });
+
+  test('returns error when resolving nonexistent ID', async () => {
+    const result = await executeFollowupResolve({ id: 'bad-id' }, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('not found');
+  });
+
+  test('rejects when neither id nor channel+thread_id provided', async () => {
+    const result = await executeFollowupResolve({}, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Either id or both channel and thread_id are required');
+  });
+});

package/src/__tests__/handlers-twilio-config.test.ts

@@ -0,0 +1,221 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import * as net from 'node:net';
+
+const testDir = mkdtempSync(join(tmpdir(), 'handlers-twilio-cfg-test-'));
+
+let rawConfigStore: Record<string, unknown> = {};
+const saveRawConfigCalls: Record<string, unknown>[] = [];
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({}),
+  loadConfig: () => ({}),
+  loadRawConfig: () => ({ ...rawConfigStore }),
+  saveRawConfig: (cfg: Record<string, unknown>) => {
+    saveRawConfigCalls.push(cfg);
+    rawConfigStore = { ...cfg };
+  },
+  saveConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module('../util/platform.js', () => ({
+  getRootDir: () => testDir,
+  getDataDir: () => testDir,
+  getIpcBlobDir: () => join(testDir, 'ipc-blobs'),
+  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: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+    trace: () => {},
+    fatal: () => {},
+    child: () => ({
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      debug: () => {},
+    }),
+  }),
+}));
+
+mock.module('../memory/app-store.js', () => ({
+  queryAppRecords: () => [],
+  createAppRecord: () => {},
+  updateAppRecord: () => {},
+  deleteAppRecord: () => {},
+  listApps: () => [],
+  getApp: () => undefined,
+  createApp: () => {},
+  updateApp: () => {},
+}));
+
+mock.module('../slack/slack-webhook.js', () => ({
+  postToSlackWebhook: async () => {},
+}));
+
+import { handleMessage, type HandlerContext } from '../daemon/handlers.js';
+import type {
+  TwilioWebhookConfigRequest,
+  ServerMessage,
+} from '../daemon/ipc-contract.js';
+
+function createTestContext(): { ctx: HandlerContext; sent: ServerMessage[] } {
+  const sent: ServerMessage[] = [];
+  const ctx: HandlerContext = {
+    sessions: new Map(),
+    socketToSession: new Map(),
+    cuSessions: new Map(),
+    socketToCuSession: new Map(),
+    cuObservationParseSequence: new Map(),
+    socketSandboxOverride: new Map(),
+    sharedRequestTimestamps: [],
+    debounceTimers: new Map(),
+    suppressConfigReload: false,
+    setSuppressConfigReload: () => {},
+    updateConfigFingerprint: () => {},
+    send: (_socket, msg) => { sent.push(msg); },
+    broadcast: () => {},
+    clearAllSessions: () => 0,
+    getOrCreateSession: () => { throw new Error('not implemented'); },
+    touchSession: () => {},
+  };
+  return { ctx, sent };
+}
+
+describe('Twilio webhook config handler', () => {
+  beforeEach(() => {
+    rawConfigStore = {};
+    saveRawConfigCalls.length = 0;
+  });
+
+  test('get returns empty string when no config set', () => {
+    rawConfigStore = {};
+
+    const msg: TwilioWebhookConfigRequest = {
+      type: 'twilio_webhook_config',
+      action: 'get',
+    };
+
+    const { ctx, sent } = createTestContext();
+    handleMessage(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; webhookBaseUrl: string; success: boolean };
+    expect(res.type).toBe('twilio_webhook_config_response');
+    expect(res.success).toBe(true);
+    expect(res.webhookBaseUrl).toBe('');
+  });
+
+  test('set persists value and returns it', () => {
+    rawConfigStore = {};
+
+    const msg: TwilioWebhookConfigRequest = {
+      type: 'twilio_webhook_config',
+      action: 'set',
+      webhookBaseUrl: 'https://example.com/twilio',
+    };
+
+    const { ctx, sent } = createTestContext();
+    handleMessage(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; webhookBaseUrl: string; success: boolean };
+    expect(res.type).toBe('twilio_webhook_config_response');
+    expect(res.success).toBe(true);
+    expect(res.webhookBaseUrl).toBe('https://example.com/twilio');
+
+    expect(saveRawConfigCalls).toHaveLength(1);
+    const saved = saveRawConfigCalls[0] as { calls?: { webhookBaseUrl?: string } };
+    expect(saved.calls?.webhookBaseUrl).toBe('https://example.com/twilio');
+  });
+
+  test('set normalizes trailing slashes', () => {
+    rawConfigStore = {};
+
+    const msg: TwilioWebhookConfigRequest = {
+      type: 'twilio_webhook_config',
+      action: 'set',
+      webhookBaseUrl: 'https://example.com/twilio///',
+    };
+
+    const { ctx, sent } = createTestContext();
+    handleMessage(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; webhookBaseUrl: string; success: boolean };
+    expect(res.webhookBaseUrl).toBe('https://example.com/twilio');
+
+    const saved = saveRawConfigCalls[0] as { calls?: { webhookBaseUrl?: string } };
+    expect(saved.calls?.webhookBaseUrl).toBe('https://example.com/twilio');
+  });
+
+  test('set treats empty string as unset', () => {
+    rawConfigStore = { calls: { webhookBaseUrl: 'https://example.com/twilio' } };
+    saveRawConfigCalls.length = 0;
+
+    const msg: TwilioWebhookConfigRequest = {
+      type: 'twilio_webhook_config',
+      action: 'set',
+      webhookBaseUrl: '',
+    };
+
+    const { ctx, sent } = createTestContext();
+    handleMessage(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; webhookBaseUrl: string; success: boolean };
+    expect(res.success).toBe(true);
+    expect(res.webhookBaseUrl).toBe('');
+
+    const saved = saveRawConfigCalls[0] as { calls?: { webhookBaseUrl?: string } };
+    expect(saved.calls?.webhookBaseUrl).toBeUndefined();
+  });
+
+  test('get after set roundtrip works', () => {
+    rawConfigStore = {};
+
+    // Set
+    const setMsg: TwilioWebhookConfigRequest = {
+      type: 'twilio_webhook_config',
+      action: 'set',
+      webhookBaseUrl: 'https://my-server.ngrok.io',
+    };
+
+    const { ctx: setCtx, sent: setSent } = createTestContext();
+    handleMessage(setMsg, {} as net.Socket, setCtx);
+
+    expect(setSent).toHaveLength(1);
+    const setRes = setSent[0] as { type: string; webhookBaseUrl: string; success: boolean };
+    expect(setRes.success).toBe(true);
+    expect(setRes.webhookBaseUrl).toBe('https://my-server.ngrok.io');
+
+    // Get (rawConfigStore was updated by the mock saveRawConfig)
+    const getMsg: TwilioWebhookConfigRequest = {
+      type: 'twilio_webhook_config',
+      action: 'get',
+    };
+
+    const { ctx: getCtx, sent: getSent } = createTestContext();
+    handleMessage(getMsg, {} as net.Socket, getCtx);
+
+    expect(getSent).toHaveLength(1);
+    const getRes = getSent[0] as { type: string; webhookBaseUrl: string; success: boolean };
+    expect(getRes.type).toBe('twilio_webhook_config_response');
+    expect(getRes.success).toBe(true);
+    expect(getRes.webhookBaseUrl).toBe('https://my-server.ngrok.io');
+  });
+});