vellum 0.2.1 → 0.2.2

package/src/__tests__/turn-commit.test.ts

@@ -1,11 +1,14 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, test, expect, beforeEach, afterEach, afterAll, mock } from 'bun:test';
 import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { execFileSync } from 'node:child_process';
+import type { CommitMessageProvider, CommitContext, CommitMessageResult } from '../workspace/commit-message-provider.js';
+import type { GenerateCommitMessageResult } from '../workspace/provider-commit-message-generator.js';
+
 import { commitTurnChanges } from '../workspace/turn-commit.js';
 import { WorkspaceGitService, _resetGitServiceRegistry } from '../workspace/git-service.js';
-import type { CommitMessageProvider, CommitContext, CommitMessageResult } from '../workspace/commit-message-provider.js';
+import { _resetEnrichmentService, getEnrichmentService } from '../workspace/commit-message-enrichment-service.js';
 
 describe('commitTurnChanges', () => {
   let testDir: string;
@@ -16,12 +19,20 @@ describe('commitTurnChanges', () => {
     _resetGitServiceRegistry();
   });
 
-  afterEach(() => {
+  afterEach(async () => {
+    // Shut down any in-flight enrichment work before removing the test directory
+    try { await getEnrichmentService().shutdown(); } catch { /* ignore */ }
+    _resetEnrichmentService();
     if (existsSync(testDir)) {
       rmSync(testDir, { recursive: true, force: true });
     }
   });
 
+  afterAll(async () => {
+    try { await getEnrichmentService().shutdown(); } catch { /* ignore */ }
+    _resetEnrichmentService();
+  });
+
   test('turn with file edits creates a commit', async () => {
     // Initialize workspace git
     const service = new WorkspaceGitService(testDir);
@@ -273,3 +284,207 @@ describe('commitTurnChanges', () => {
     expect(fullMessage).toContain('source: "unit-test"');
   });
 });
+
+describe('LLM commit message integration', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `vellum-llm-commit-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(testDir, { recursive: true });
+    _resetGitServiceRegistry();
+  });
+
+  afterEach(async () => {
+    try { await getEnrichmentService().shutdown(); } catch { /* ignore */ }
+    _resetEnrichmentService();
+    mock.restore();
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  afterAll(async () => {
+    try { await getEnrichmentService().shutdown(); } catch { /* ignore */ }
+    _resetEnrichmentService();
+  });
+
+  test('success path uses LLM output as commit message', async () => {
+    const llmResult: GenerateCommitMessageResult = {
+      message: 'feat: add user authentication module',
+      source: 'llm',
+    };
+
+    mock.module('../workspace/provider-commit-message-generator.js', () => ({
+      getCommitMessageGenerator: () => ({
+        generateCommitMessage: async () => llmResult,
+      }),
+    }));
+
+    // Re-import to pick up the mock
+    const { commitTurnChanges: commit } = await import('../workspace/turn-commit.js');
+
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    writeFileSync(join(testDir, 'auth.ts'), 'export class Auth {}');
+
+    await commit(testDir, 'sess_llm_success', 1);
+
+    const fullMessage = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+      cwd: testDir,
+      encoding: 'utf-8',
+    });
+
+    expect(fullMessage).toContain('feat: add user authentication module');
+  });
+
+  test('uninitialized provider returns deterministic without attempting LLM', async () => {
+    const deterministicResult: GenerateCommitMessageResult = {
+      message: 'Turn: missing-key.txt',
+      source: 'deterministic',
+      reason: 'provider_not_initialized',
+    };
+
+    mock.module('../workspace/provider-commit-message-generator.js', () => ({
+      getCommitMessageGenerator: () => ({
+        generateCommitMessage: async () => deterministicResult,
+      }),
+    }));
+
+    const { commitTurnChanges: commit } = await import('../workspace/turn-commit.js');
+
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    writeFileSync(join(testDir, 'missing-key.txt'), 'content');
+
+    await commit(testDir, 'sess_no_key', 1);
+
+    const fullMessage = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+      cwd: testDir,
+      encoding: 'utf-8',
+    });
+
+    // Deterministic message is used — no LLM message in output
+    expect(fullMessage).toContain('Turn:');
+    expect(fullMessage).not.toContain('feat:');
+  });
+
+  test('provider error falls back to deterministic without propagating', async () => {
+    mock.module('../workspace/provider-commit-message-generator.js', () => ({
+      getCommitMessageGenerator: () => ({
+        generateCommitMessage: async () => {
+          throw new Error('Provider connection refused');
+        },
+      }),
+    }));
+
+    const { commitTurnChanges: commit } = await import('../workspace/turn-commit.js');
+
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    writeFileSync(join(testDir, 'error-test.txt'), 'content');
+
+    // Should NOT throw — errors are caught internally
+    await commit(testDir, 'sess_error', 1);
+
+    const fullMessage = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+      cwd: testDir,
+      encoding: 'utf-8',
+    });
+
+    // Deterministic message is used as fallback
+    expect(fullMessage).toContain('Turn:');
+  });
+
+  test('timeout returns deterministic fallback', async () => {
+    const timeoutResult: GenerateCommitMessageResult = {
+      message: 'Turn: timeout-test.txt',
+      source: 'deterministic',
+      reason: 'timeout',
+    };
+
+    mock.module('../workspace/provider-commit-message-generator.js', () => ({
+      getCommitMessageGenerator: () => ({
+        generateCommitMessage: async () => timeoutResult,
+      }),
+    }));
+
+    const { commitTurnChanges: commit } = await import('../workspace/turn-commit.js');
+
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    writeFileSync(join(testDir, 'timeout-test.txt'), 'content');
+
+    await commit(testDir, 'sess_timeout', 1);
+
+    const fullMessage = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+      cwd: testDir,
+      encoding: 'utf-8',
+    });
+
+    expect(fullMessage).toContain('Turn:');
+  });
+
+  test('invalid output returns deterministic fallback', async () => {
+    const invalidResult: GenerateCommitMessageResult = {
+      message: 'Turn: invalid-test.txt',
+      source: 'deterministic',
+      reason: 'invalid_output',
+    };
+
+    mock.module('../workspace/provider-commit-message-generator.js', () => ({
+      getCommitMessageGenerator: () => ({
+        generateCommitMessage: async () => invalidResult,
+      }),
+    }));
+
+    const { commitTurnChanges: commit } = await import('../workspace/turn-commit.js');
+
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    writeFileSync(join(testDir, 'invalid-test.txt'), 'content');
+
+    await commit(testDir, 'sess_invalid', 1);
+
+    const fullMessage = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+      cwd: testDir,
+      encoding: 'utf-8',
+    });
+
+    expect(fullMessage).toContain('Turn:');
+  });
+
+  test('breaker open skips LLM and uses deterministic', async () => {
+    const breakerResult: GenerateCommitMessageResult = {
+      message: 'Turn: breaker-test.txt',
+      source: 'deterministic',
+      reason: 'breaker_open',
+    };
+
+    mock.module('../workspace/provider-commit-message-generator.js', () => ({
+      getCommitMessageGenerator: () => ({
+        generateCommitMessage: async () => breakerResult,
+      }),
+    }));
+
+    const { commitTurnChanges: commit } = await import('../workspace/turn-commit.js');
+
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    writeFileSync(join(testDir, 'breaker-test.txt'), 'content');
+
+    await commit(testDir, 'sess_breaker', 1);
+
+    const fullMessage = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+      cwd: testDir,
+      encoding: 'utf-8',
+    });
+
+    expect(fullMessage).toContain('Turn:');
+  });
+});

package/src/__tests__/twilio-provider.test.ts

@@ -0,0 +1,143 @@
+/**
+ * Tests for TwilioConversationRelayProvider — signature validation and
+ * fail-closed auth token behavior.
+ */
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+import { createHmac } from 'node:crypto';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const testDir = mkdtempSync(join(tmpdir(), 'twilio-provider-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: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+// Start with a configured auth token
+let mockAuthToken: string | undefined = 'test-auth-token-secret';
+
+mock.module('../security/secure-keys.js', () => ({
+  getSecureKey: (account: string) => {
+    if (account === 'twilio_auth_token') return mockAuthToken;
+    return undefined;
+  },
+}));
+
+import { TwilioConversationRelayProvider } from '../calls/twilio-provider.js';
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+function computeValidSignature(
+  url: string,
+  params: Record<string, string>,
+  authToken: string,
+): string {
+  const sortedKeys = Object.keys(params).sort();
+  let data = url;
+  for (const key of sortedKeys) {
+    data += key + params[key];
+  }
+  return createHmac('sha1', authToken).update(data).digest('base64');
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────
+
+describe('TwilioConversationRelayProvider', () => {
+  beforeEach(() => {
+    mockAuthToken = 'test-auth-token-secret';
+  });
+
+  describe('verifyWebhookSignature', () => {
+    const testUrl = 'https://example.com/v1/calls/twilio/status';
+    const testParams = { CallSid: 'CA123', CallStatus: 'completed' };
+
+    test('returns true for a valid signature', () => {
+      const authToken = 'test-auth-token-secret';
+      const sig = computeValidSignature(testUrl, testParams, authToken);
+      const result = TwilioConversationRelayProvider.verifyWebhookSignature(
+        testUrl,
+        testParams,
+        sig,
+        authToken,
+      );
+      expect(result).toBe(true);
+    });
+
+    test('returns false for an invalid signature', () => {
+      const authToken = 'test-auth-token-secret';
+      const result = TwilioConversationRelayProvider.verifyWebhookSignature(
+        testUrl,
+        testParams,
+        'invalid-signature-base64',
+        authToken,
+      );
+      expect(result).toBe(false);
+    });
+
+    test('returns false when signature is computed with a different auth token', () => {
+      const authToken = 'test-auth-token-secret';
+      const wrongTokenSig = computeValidSignature(testUrl, testParams, 'wrong-token');
+      const result = TwilioConversationRelayProvider.verifyWebhookSignature(
+        testUrl,
+        testParams,
+        wrongTokenSig,
+        authToken,
+      );
+      expect(result).toBe(false);
+    });
+
+    test('handles empty params', () => {
+      const authToken = 'test-auth-token-secret';
+      const sig = computeValidSignature(testUrl, {}, authToken);
+      const result = TwilioConversationRelayProvider.verifyWebhookSignature(
+        testUrl,
+        {},
+        sig,
+        authToken,
+      );
+      expect(result).toBe(true);
+    });
+
+    test('sorts params alphabetically for signature computation', () => {
+      const authToken = 'test-auth-token-secret';
+      const params = { Zebra: '1', Alpha: '2', Middle: '3' };
+      const sig = computeValidSignature(testUrl, params, authToken);
+      const result = TwilioConversationRelayProvider.verifyWebhookSignature(
+        testUrl,
+        params,
+        sig,
+        authToken,
+      );
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('getAuthToken', () => {
+    test('returns the auth token when configured', () => {
+      mockAuthToken = 'my-secret-token';
+      const token = TwilioConversationRelayProvider.getAuthToken();
+      expect(token).toBe('my-secret-token');
+    });
+
+    test('returns null when auth token is not configured', () => {
+      mockAuthToken = undefined;
+      const token = TwilioConversationRelayProvider.getAuthToken();
+      expect(token).toBeNull();
+    });
+  });
+});