@vibescope/mcp-server 0.0.1 → 0.2.0

package/dist/cli.test.js

@@ -1,367 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { createHash } from 'crypto';
-// Mock child_process before importing cli module
-vi.mock('child_process', () => ({
-    execSync: vi.fn(),
-}));
-// Mock @supabase/supabase-js
-vi.mock('@supabase/supabase-js', () => ({
-    createClient: vi.fn(),
-}));
-import { execSync } from 'child_process';
-import { hashApiKey, detectGitUrl, validateApiKey, } from './cli.js';
-describe('CLI verification logic', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('hashApiKey', () => {
-        it('should return SHA256 hash of the key', () => {
-            const key = 'test-api-key';
-            const expected = createHash('sha256').update(key).digest('hex');
-            expect(hashApiKey(key)).toBe(expected);
-        });
-        it('should return different hashes for different keys', () => {
-            const hash1 = hashApiKey('key1');
-            const hash2 = hashApiKey('key2');
-            expect(hash1).not.toBe(hash2);
-        });
-        it('should return same hash for same key', () => {
-            const hash1 = hashApiKey('same-key');
-            const hash2 = hashApiKey('same-key');
-            expect(hash1).toBe(hash2);
-        });
-        it('should return 64-character hex string', () => {
-            const hash = hashApiKey('any-key');
-            expect(hash).toMatch(/^[a-f0-9]{64}$/);
-        });
-    });
-    describe('detectGitUrl', () => {
-        it('should return normalized git URL when git command succeeds', () => {
-            vi.mocked(execSync).mockReturnValue('git@github.com:user/repo.git\n');
-            const result = detectGitUrl();
-            expect(result).toBe('https://github.com/user/repo');
-        });
-        it('should return null when git command fails', () => {
-            vi.mocked(execSync).mockImplementation(() => {
-                throw new Error('Not a git repository');
-            });
-            const result = detectGitUrl();
-            expect(result).toBeNull();
-        });
-        it('should handle HTTPS URLs', () => {
-            vi.mocked(execSync).mockReturnValue('https://github.com/user/repo.git\n');
-            const result = detectGitUrl();
-            expect(result).toBe('https://github.com/user/repo');
-        });
-        it('should call execSync with correct options', () => {
-            vi.mocked(execSync).mockReturnValue('https://github.com/user/repo.git');
-            detectGitUrl();
-            expect(execSync).toHaveBeenCalledWith('git config --get remote.origin.url', {
-                encoding: 'utf8',
-                timeout: 5000,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-        });
-    });
-    describe('validateApiKey', () => {
-        it('should return auth context for valid API key', async () => {
-            const mockSupabase = {
-                from: vi.fn().mockReturnThis(),
-                select: vi.fn().mockReturnThis(),
-                eq: vi.fn().mockReturnThis(),
-                single: vi.fn().mockResolvedValue({
-                    data: { id: 'key-id-123', user_id: 'user-id-456' },
-                    error: null,
-                }),
-            };
-            const result = await validateApiKey(mockSupabase, 'test-api-key');
-            expect(result).toEqual({
-                userId: 'user-id-456',
-                apiKeyId: 'key-id-123',
-            });
-        });
-        it('should return null for invalid API key', async () => {
-            const mockSupabase = {
-                from: vi.fn().mockReturnThis(),
-                select: vi.fn().mockReturnThis(),
-                eq: vi.fn().mockReturnThis(),
-                single: vi.fn().mockResolvedValue({
-                    data: null,
-                    error: { message: 'Not found' },
-                }),
-            };
-            const result = await validateApiKey(mockSupabase, 'invalid-key');
-            expect(result).toBeNull();
-        });
-        it('should query api_keys table with hashed key', async () => {
-            const mockFrom = vi.fn().mockReturnThis();
-            const mockSelect = vi.fn().mockReturnThis();
-            const mockEq = vi.fn().mockReturnThis();
-            const mockSingle = vi.fn().mockResolvedValue({ data: null, error: { message: 'Not found' } });
-            const mockSupabase = {
-                from: mockFrom,
-                select: mockSelect,
-                eq: mockEq,
-                single: mockSingle,
-            };
-            await validateApiKey(mockSupabase, 'test-key');
-            expect(mockFrom).toHaveBeenCalledWith('api_keys');
-            expect(mockSelect).toHaveBeenCalledWith('id, user_id');
-            expect(mockEq).toHaveBeenCalledWith('key_hash', hashApiKey('test-key'));
-        });
-        it('should return null when data is missing', async () => {
-            const mockSupabase = {
-                from: vi.fn().mockReturnThis(),
-                select: vi.fn().mockReturnThis(),
-                eq: vi.fn().mockReturnThis(),
-                single: vi.fn().mockResolvedValue({
-                    data: undefined,
-                    error: null,
-                }),
-            };
-            const result = await validateApiKey(mockSupabase, 'test-key');
-            expect(result).toBeNull();
-        });
-    });
-});
-describe('verify function integration', () => {
-    const originalEnv = process.env;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Reset process.env for each test
-        process.env = { ...originalEnv };
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-    });
-    // Note: The verify function reads environment variables at module load time,
-    // so we need to test through dynamic imports or by mocking at a higher level.
-    // For now, we test the exported functions individually.
-    describe('environment variable validation', () => {
-        it('hashApiKey should work without env vars', () => {
-            // hashApiKey is a pure function that doesn't depend on env vars
-            expect(hashApiKey('test')).toBeTruthy();
-        });
-        it('detectGitUrl should work without env vars', () => {
-            vi.mocked(execSync).mockReturnValue('https://github.com/user/repo.git');
-            expect(detectGitUrl()).toBe('https://github.com/user/repo');
-        });
-    });
-    describe('validateApiKey error handling', () => {
-        it('should handle database errors gracefully', async () => {
-            const mockSupabase = {
-                from: vi.fn().mockReturnThis(),
-                select: vi.fn().mockReturnThis(),
-                eq: vi.fn().mockReturnThis(),
-                single: vi.fn().mockRejectedValue(new Error('Database connection failed')),
-            };
-            await expect(validateApiKey(mockSupabase, 'test-key')).rejects.toThrow('Database connection failed');
-        });
-        it('should handle empty string API key', async () => {
-            const mockSupabase = {
-                from: vi.fn().mockReturnThis(),
-                select: vi.fn().mockReturnThis(),
-                eq: vi.fn().mockReturnThis(),
-                single: vi.fn().mockResolvedValue({ data: null, error: null }),
-            };
-            const result = await validateApiKey(mockSupabase, '');
-            expect(result).toBeNull();
-        });
-    });
-});
-describe('VerificationResult types', () => {
-    it('should have correct status types', () => {
-        const compliant = {
-            status: 'compliant',
-            reason: 'All good',
-        };
-        expect(compliant.status).toBe('compliant');
-        const nonCompliant = {
-            status: 'non_compliant',
-            reason: 'Tasks in progress',
-            continuation_prompt: 'Complete your tasks',
-        };
-        expect(nonCompliant.status).toBe('non_compliant');
-        const error = {
-            status: 'error',
-            reason: 'Missing env vars',
-        };
-        expect(error.status).toBe('error');
-        const noSession = {
-            status: 'no_session',
-            reason: 'No git URL detected',
-        };
-        expect(noSession.status).toBe('no_session');
-    });
-    it('should support optional details', () => {
-        const result = {
-            status: 'compliant',
-            reason: 'All good',
-            details: {
-                session_started: true,
-                project_id: 'proj-123',
-                project_name: 'Test Project',
-                git_url: 'https://github.com/user/repo',
-                in_progress_tasks: 0,
-                tasks_completed_this_session: 5,
-                progress_logs_this_session: 3,
-                blockers_logged_this_session: 1,
-                session_duration_minutes: 45,
-            },
-        };
-        expect(result.details?.session_started).toBe(true);
-        expect(result.details?.tasks_completed_this_session).toBe(5);
-    });
-});
-describe('AuthContext type', () => {
-    it('should have required fields', () => {
-        const auth = {
-            userId: 'user-123',
-            apiKeyId: 'key-456',
-        };
-        expect(auth.userId).toBe('user-123');
-        expect(auth.apiKeyId).toBe('key-456');
-    });
-});
-describe('verify function scenarios', () => {
-    const originalEnv = { ...process.env };
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Set up required env vars
-        process.env.SUPABASE_URL = 'https://test.supabase.co';
-        process.env.SUPABASE_SERVICE_KEY = 'test-service-key';
-        process.env.VIBESCOPE_API_KEY = 'test-api-key';
-    });
-    afterEach(() => {
-        process.env = { ...originalEnv };
-    });
-    // Helper to create a mock Supabase client with chainable methods
-    function createMockSupabase(overrides = {}) {
-        const defaultApiKey = { data: { id: 'key-id', user_id: 'user-id' }, error: null };
-        const defaultProject = {
-            data: { id: 'proj-id', name: 'Test Project', git_url: 'https://github.com/test/repo' },
-            error: null,
-        };
-        const defaultSession = {
-            data: {
-                id: 'session-id',
-                created_at: new Date(Date.now() - 10 * 60 * 1000).toISOString(), // 10 mins ago
-                last_synced_at: new Date().toISOString(),
-            },
-            error: null,
-        };
-        const defaultTasks = { data: [], error: null };
-        const defaultCompleted = { count: 1, error: null };
-        const defaultProgress = { count: 0, error: null };
-        const defaultBlocker = { count: 0, error: null };
-        let currentTable = '';
-        let selectCount = false;
-        const mock = {
-            from: vi.fn((table) => {
-                currentTable = table;
-                return mock;
-            }),
-            select: vi.fn((cols, opts) => {
-                selectCount = !!opts?.count;
-                return mock;
-            }),
-            eq: vi.fn().mockReturnThis(),
-            gte: vi.fn().mockReturnThis(),
-            single: vi.fn(() => {
-                if (currentTable === 'api_keys') {
-                    return Promise.resolve(overrides.apiKeyResult ?? defaultApiKey);
-                }
-                if (currentTable === 'projects') {
-                    return Promise.resolve(overrides.projectResult ?? defaultProject);
-                }
-                if (currentTable === 'agent_sessions') {
-                    return Promise.resolve(overrides.sessionResult ?? defaultSession);
-                }
-                return Promise.resolve({ data: null, error: null });
-            }),
-            then: vi.fn((resolve) => {
-                if (currentTable === 'tasks') {
-                    if (selectCount) {
-                        return Promise.resolve(overrides.completedResult ?? defaultCompleted).then(resolve);
-                    }
-                    return Promise.resolve(overrides.tasksResult ?? defaultTasks).then(resolve);
-                }
-                if (currentTable === 'progress_logs') {
-                    return Promise.resolve(overrides.progressResult ?? defaultProgress).then(resolve);
-                }
-                if (currentTable === 'blockers') {
-                    return Promise.resolve(overrides.blockerResult ?? defaultBlocker).then(resolve);
-                }
-                return Promise.resolve({ data: null, count: 0 }).then(resolve);
-            }),
-        };
-        return mock;
-    }
-    it('should validate API key and return auth context', async () => {
-        const mockSupabase = createMockSupabase();
-        const result = await validateApiKey(mockSupabase, 'test-key');
-        expect(result).toEqual({
-            userId: 'user-id',
-            apiKeyId: 'key-id',
-        });
-    });
-    it('should return null for invalid API key', async () => {
-        const mockSupabase = createMockSupabase({
-            apiKeyResult: { data: null, error: { message: 'Not found' } },
-        });
-        const result = await validateApiKey(mockSupabase, 'invalid-key');
-        expect(result).toBeNull();
-    });
-    it('should handle database query errors', async () => {
-        const mockSupabase = {
-            from: vi.fn().mockReturnThis(),
-            select: vi.fn().mockReturnThis(),
-            eq: vi.fn().mockReturnThis(),
-            single: vi.fn().mockRejectedValue(new Error('Connection timeout')),
-        };
-        await expect(validateApiKey(mockSupabase, 'key')).rejects.toThrow('Connection timeout');
-    });
-});
-describe('detectGitUrl edge cases', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('should trim whitespace from git URL', () => {
-        vi.mocked(execSync).mockReturnValue('  https://github.com/user/repo.git  \n');
-        const result = detectGitUrl();
-        expect(result).toBe('https://github.com/user/repo');
-    });
-    it('should handle GitLab SSH URLs', () => {
-        vi.mocked(execSync).mockReturnValue('git@gitlab.com:user/repo.git');
-        const result = detectGitUrl();
-        expect(result).toBe('https://gitlab.com/user/repo');
-    });
-    it('should handle Azure DevOps SSH URLs (not normalized)', () => {
-        // Azure DevOps URLs are not normalized by the current implementation
-        // The URL is trimmed but SSH format is preserved
-        vi.mocked(execSync).mockReturnValue('git@ssh.dev.azure.com:v3/org/project/repo');
-        const result = detectGitUrl();
-        expect(result).toBe('git@ssh.dev.azure.com:v3/org/project/repo');
-    });
-    it('should handle Bitbucket SSH URLs', () => {
-        vi.mocked(execSync).mockReturnValue('git@bitbucket.org:user/repo.git');
-        const result = detectGitUrl();
-        expect(result).toBe('https://bitbucket.org/user/repo');
-    });
-    it('should return null on timeout', () => {
-        vi.mocked(execSync).mockImplementation(() => {
-            const error = new Error('Command timed out');
-            error.code = 'ETIMEDOUT';
-            throw error;
-        });
-        const result = detectGitUrl();
-        expect(result).toBeNull();
-    });
-    it('should return null when not in a git repo', () => {
-        vi.mocked(execSync).mockImplementation(() => {
-            throw new Error('fatal: not a git repository');
-        });
-        const result = detectGitUrl();
-        expect(result).toBeNull();
-    });
-});

package/dist/handlers/__test-utils__.d.ts

@@ -1,72 +0,0 @@
-/**
- * Shared Test Utilities
- *
- * Common mock factories and test helpers used across handler tests.
- * This eliminates ~85 lines of duplicate code per test file.
- */
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { HandlerContext } from './types.js';
-export interface MockSupabaseOverrides {
-    selectResult?: {
-        data: unknown;
-        error: unknown;
-    };
-    insertResult?: {
-        data: unknown;
-        error: unknown;
-    };
-    updateResult?: {
-        data: unknown;
-        error: unknown;
-    };
-    deleteResult?: {
-        data: unknown;
-        error: unknown;
-    };
-    sessionsResult?: {
-        data: unknown;
-        error: unknown;
-    };
-}
-/**
- * Create a mock Supabase client for testing.
- *
- * The mock tracks which operation is being performed and returns
- * the appropriate result from overrides.
- *
- * @example
- * ```ts
- * const supabase = createMockSupabase({
- *   insertResult: { data: { id: 'new-id' }, error: null }
- * });
- * ```
- */
-export declare function createMockSupabase(overrides?: MockSupabaseOverrides): SupabaseClient;
-export interface MockContextOptions {
-    sessionId?: string | null;
-    userId?: string;
-    apiKeyId?: string;
-    instanceId?: string;
-    persona?: string;
-}
-/**
- * Create a mock HandlerContext for testing.
- *
- * @example
- * ```ts
- * const ctx = createMockContext(supabase, { sessionId: 'test-session' });
- * ```
- */
-export declare function createMockContext(supabase: SupabaseClient, options?: MockContextOptions): HandlerContext;
-/**
- * Generate a valid UUID for testing.
- */
-export declare function testUUID(): string;
-/**
- * Generate a random-ish UUID for testing (deterministic based on seed).
- */
-export declare function testUUIDSeeded(seed: number): string;
-/**
- * Create a mock timestamp for consistent testing.
- */
-export declare function testTimestamp(offsetMinutes?: number): string;

package/dist/handlers/__test-utils__.js

@@ -1,176 +0,0 @@
-/**
- * Shared Test Utilities
- *
- * Common mock factories and test helpers used across handler tests.
- * This eliminates ~85 lines of duplicate code per test file.
- */
-import { vi } from 'vitest';
-/**
- * Create a mock Supabase client for testing.
- *
- * The mock tracks which operation is being performed and returns
- * the appropriate result from overrides.
- *
- * @example
- * ```ts
- * const supabase = createMockSupabase({
- *   insertResult: { data: { id: 'new-id' }, error: null }
- * });
- * ```
- */
-export function createMockSupabase(overrides = {}) {
-    const defaultResult = { data: null, error: null };
-    // Use an object to track state so it persists across all mock function calls
-    const state = {
-        currentOperation: 'select',
-        currentTable: '',
-        insertThenSelect: false,
-        updateCalled: false,
-    };
-    const mock = {
-        from: vi.fn((table) => {
-            state.currentTable = table;
-            // Reset state for new query chain
-            state.currentOperation = 'select';
-            state.insertThenSelect = false;
-            state.updateCalled = false;
-            return mock;
-        }),
-        select: vi.fn(() => {
-            if (state.currentOperation === 'insert') {
-                state.insertThenSelect = true;
-            }
-            else if (!state.updateCalled) {
-                state.currentOperation = 'select';
-                state.insertThenSelect = false;
-            }
-            return mock;
-        }),
-        insert: vi.fn(() => {
-            state.currentOperation = 'insert';
-            state.insertThenSelect = false;
-            return mock;
-        }),
-        update: vi.fn(() => {
-            state.currentOperation = 'update';
-            state.updateCalled = true;
-            state.insertThenSelect = false;
-            return mock;
-        }),
-        delete: vi.fn(() => {
-            state.currentOperation = 'delete';
-            state.insertThenSelect = false;
-            return mock;
-        }),
-        eq: vi.fn().mockReturnThis(),
-        neq: vi.fn().mockReturnThis(),
-        in: vi.fn().mockReturnThis(),
-        is: vi.fn().mockReturnThis(),
-        not: vi.fn().mockReturnThis(),
-        or: vi.fn().mockReturnThis(),
-        gt: vi.fn().mockReturnThis(),
-        gte: vi.fn().mockReturnThis(),
-        lte: vi.fn().mockReturnThis(),
-        lt: vi.fn().mockReturnThis(),
-        order: vi.fn().mockReturnThis(),
-        limit: vi.fn().mockReturnThis(),
-        single: vi.fn(() => {
-            if (state.currentOperation === 'insert' || state.insertThenSelect) {
-                return Promise.resolve(overrides.insertResult ?? defaultResult);
-            }
-            if (state.updateCalled) {
-                return Promise.resolve(overrides.updateResult ?? defaultResult);
-            }
-            if (state.currentOperation === 'select') {
-                return Promise.resolve(overrides.selectResult ?? defaultResult);
-            }
-            if (state.currentOperation === 'update') {
-                return Promise.resolve(overrides.updateResult ?? defaultResult);
-            }
-            return Promise.resolve(defaultResult);
-        }),
-        maybeSingle: vi.fn(() => {
-            return Promise.resolve(overrides.selectResult ?? defaultResult);
-        }),
-        then: vi.fn((resolve) => {
-            // Handle special table cases
-            if (state.currentTable === 'agent_sessions' && overrides.sessionsResult) {
-                return Promise.resolve(overrides.sessionsResult).then(resolve);
-            }
-            if (state.currentOperation === 'insert' || state.insertThenSelect) {
-                return Promise.resolve(overrides.insertResult ?? defaultResult).then(resolve);
-            }
-            if (state.updateCalled) {
-                return Promise.resolve(overrides.updateResult ?? defaultResult).then(resolve);
-            }
-            if (state.currentOperation === 'select') {
-                return Promise.resolve(overrides.selectResult ?? defaultResult).then(resolve);
-            }
-            if (state.currentOperation === 'update') {
-                return Promise.resolve(overrides.updateResult ?? defaultResult).then(resolve);
-            }
-            if (state.currentOperation === 'delete') {
-                return Promise.resolve(overrides.deleteResult ?? defaultResult).then(resolve);
-            }
-            return Promise.resolve(defaultResult).then(resolve);
-        }),
-    };
-    return mock;
-}
-/**
- * Create a mock HandlerContext for testing.
- *
- * @example
- * ```ts
- * const ctx = createMockContext(supabase, { sessionId: 'test-session' });
- * ```
- */
-export function createMockContext(supabase, options = {}) {
-    const defaultTokenUsage = {
-        callCount: 5,
-        totalTokens: 2500,
-        byTool: {},
-        byModel: {},
-        currentModel: null,
-    };
-    const sessionId = 'sessionId' in options ? (options.sessionId ?? null) : 'session-123';
-    return {
-        supabase,
-        auth: {
-            userId: options.userId ?? 'user-123',
-            apiKeyId: options.apiKeyId ?? 'api-key-123',
-            scope: 'personal',
-        },
-        session: {
-            instanceId: options.instanceId ?? 'instance-abc',
-            currentSessionId: sessionId,
-            currentPersona: options.persona ?? 'Wave',
-            tokenUsage: defaultTokenUsage,
-        },
-        updateSession: vi.fn(),
-    };
-}
-// ============================================================================
-// Test Data Generators
-// ============================================================================
-/**
- * Generate a valid UUID for testing.
- */
-export function testUUID() {
-    return '123e4567-e89b-12d3-a456-426614174000';
-}
-/**
- * Generate a random-ish UUID for testing (deterministic based on seed).
- */
-export function testUUIDSeeded(seed) {
-    const hex = seed.toString(16).padStart(8, '0');
-    return `${hex}-e89b-12d3-a456-426614174000`;
-}
-/**
- * Create a mock timestamp for consistent testing.
- */
-export function testTimestamp(offsetMinutes = 0) {
-    const date = new Date('2025-01-14T12:00:00Z');
-    date.setMinutes(date.getMinutes() + offsetMinutes);
-    return date.toISOString();
-}

package/dist/handlers/checkouts.d.ts

@@ -1,37 +0,0 @@
-/**
- * File Checkout Handlers
- *
- * Handles file checkout/checkin for multi-agent coordination:
- * - checkout_file: Reserve a file for editing
- * - checkin_file: Release a file after editing
- * - get_file_checkouts: List active and recent checkouts
- * - abandon_checkout: Force-release a checkout
- */
-import type { Handler, HandlerRegistry } from './types.js';
-/**
- * Checkout a file for editing
- * Prevents other agents from editing the same file
- */
-export declare const checkoutFile: Handler;
-/**
- * Checkin a file after editing
- * Releases the file for other agents to edit
- */
-export declare const checkinFile: Handler;
-/**
- * Get file checkouts for a project
- */
-export declare const getFileCheckouts: Handler;
-/**
- * Abandon a checkout (force release)
- * Use when the original agent session died or is stuck
- */
-export declare const abandonCheckout: Handler;
-/**
- * Check if a file is available for checkout
- */
-export declare const isFileAvailable: Handler;
-/**
- * Checkout handlers registry
- */
-export declare const checkoutHandlers: HandlerRegistry;