@ebowwa/claude-code-mcp 1.0.0 → 1.0.2

package/dist/integration.test.js

@@ -0,0 +1,716 @@
+#!/usr/bin/env bun
+/**
+ * Integration Tests with Mock Claude Binary
+ *
+ * Tests the full MCP server integration with:
+ * - Mock claude binary for predictable testing
+ * - Full tool call lifecycle
+ * - Session state management
+ * - Doppler integration simulation
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+// Mock Claude binary script - creates a temporary executable
+async function createMockClaude() {
+    const mockPath = `/tmp/mock-claude-${Date.now()}.sh`;
+    await Bun.write(mockPath, `#!/bin/bash
+# Mock Claude binary for testing
+
+echo "Mock Claude CLI v1.0.0" >&2
+
+# Parse arguments
+case "$1" in
+  --version)
+    echo "claude version 1.0.0"
+    exit 0
+    ;;
+  --help)
+    echo "Usage: claude [options]"
+    exit 0
+    ;;
+  --resume)
+    # Mock resume behavior
+    UUID="$2"
+    echo "Resuming session: $UUID" >&2
+    # Simulate session work
+    sleep 0.1
+    echo '{"status":"resumed","sessionId":"'"$UUID"'"}'
+    exit 0
+    ;;
+  *)
+    # Default: simulate a new session
+    echo "Starting new session..." >&2
+    sleep 0.1
+    echo '{"status":"started","sessionId":"mock-uuid-'"$(date +%s)"'"}'
+    exit 0
+    ;;
+esac
+`);
+    // Make executable
+    await Bun.spawn(['chmod', '+x', mockPath]).exited;
+    return mockPath;
+}
+describe('MCP Server Integration', () => {
+    let mockClaudePath;
+    let server;
+    beforeEach(async () => {
+        mockClaudePath = await createMockClaude();
+        // Mock MCP server
+        server = {
+            tools: new Map(),
+            sessions: new Map(),
+            registerTool(name, handler) {
+                this.tools.set(name, handler);
+            },
+            async callTool(name, args) {
+                const handler = this.tools.get(name);
+                if (!handler) {
+                    throw new Error(`Tool not found: ${name}`);
+                }
+                return await handler.call(this, args);
+            }
+        };
+    });
+    afterEach(async () => {
+        // Cleanup mock binary
+        try {
+            await Bun.spawn(['rm', '-f', mockClaudePath]).exited;
+        }
+        catch { }
+    });
+    describe('start_session', () => {
+        it('should start a new session', async () => {
+            server.registerTool('start_session', async function (args) {
+                const { projectPath, message } = args;
+                // Mock spawning Claude
+                const sessionId = `test-session-${Date.now()}`;
+                const process = await Bun.spawn([
+                    mockClaudePath,
+                    projectPath || '/tmp/test'
+                ]);
+                this.sessions.set(sessionId, {
+                    id: sessionId,
+                    projectPath,
+                    status: 'running',
+                    pid: process.pid,
+                    startTime: Date.now()
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                sessionId,
+                                status: 'started',
+                                pid: process.pid
+                            })
+                        }]
+                };
+            });
+            const result = await server.callTool('start_session', {
+                projectPath: '/tmp/test-project',
+                message: 'Hello Claude'
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.status).toBe('started');
+            expect(data.sessionId).toBeDefined();
+            expect(server.sessions.size).toBe(1);
+        });
+        it('should handle missing projectPath', async () => {
+            server.registerTool('start_session', async function (args) {
+                if (!args.projectPath) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: 'projectPath is required'
+                                })
+                            }],
+                        isError: true
+                    };
+                }
+                // ... rest of implementation
+            });
+            const result = await server.callTool('start_session', {
+                message: 'Hello'
+            });
+            expect(result.isError).toBe(true);
+            const data = JSON.parse(result.content[0].text);
+            expect(data.error).toContain('projectPath');
+        });
+    });
+    describe('resume_session', () => {
+        it('should resume an existing session', async () => {
+            server.registerTool('resume_session', async function (args) {
+                const { sessionId, message, options } = args;
+                // Check if useDoppler is enabled
+                const useDoppler = options?.useDoppler ?? true;
+                if (useDoppler) {
+                    // Mock doppler-wrapped resume
+                    const process = await Bun.spawn([
+                        'bash',
+                        '-c',
+                        `${mockClaudePath} --resume ${sessionId}`
+                    ]);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    sessionId,
+                                    status: 'resumed',
+                                    dopplerWrapped: true,
+                                    pid: process.pid
+                                })
+                            }]
+                    };
+                }
+                // Direct resume without doppler
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                sessionId,
+                                status: 'resumed',
+                                dopplerWrapped: false
+                            })
+                        }]
+                };
+            });
+            const result = await server.callTool('resume_session', {
+                sessionId: 'test-uuid-123',
+                message: 'Continue working',
+                options: { useDoppler: true }
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.status).toBe('resumed');
+            expect(data.dopplerWrapped).toBe(true);
+        });
+        it('should handle invalid sessionId', async () => {
+            server.registerTool('resume_session', async function (args) {
+                const { sessionId } = args;
+                if (!sessionId || sessionId.length < 10) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: 'Invalid sessionId format'
+                                })
+                            }],
+                        isError: true
+                    };
+                }
+                // ... resume logic
+            });
+            const result = await server.callTool('resume_session', {
+                sessionId: 'short'
+            });
+            expect(result.isError).toBe(true);
+        });
+    });
+    describe('list_sessions', () => {
+        beforeEach(() => {
+            // Add some mock sessions
+            server.sessions.set('session-1', {
+                id: 'session-1',
+                projectPath: '/path/to/project1',
+                status: 'running',
+                startTime: Date.now() - 3600000
+            });
+            server.sessions.set('session-2', {
+                id: 'session-2',
+                projectPath: '/path/to/project2',
+                status: 'completed',
+                startTime: Date.now() - 7200000
+            });
+        });
+        it('should list all sessions', async () => {
+            server.registerTool('list_sessions', async function (args) {
+                const { status, limit } = args;
+                let sessions = Array.from(this.sessions.values());
+                if (status && status !== 'all') {
+                    sessions = sessions.filter((s) => s.status === status);
+                }
+                if (limit) {
+                    sessions = sessions.slice(0, limit);
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                sessions,
+                                count: sessions.length
+                            })
+                        }]
+                };
+            });
+            const result = await server.callTool('list_sessions', {
+                status: 'all'
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.count).toBe(2);
+            expect(data.sessions).toHaveLength(2);
+        });
+        it('should filter by status', async () => {
+            server.registerTool('list_sessions', async function (args) {
+                const { status } = args;
+                let sessions = Array.from(this.sessions.values());
+                if (status && status !== 'all') {
+                    sessions = sessions.filter((s) => s.status === status);
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ sessions })
+                        }]
+                };
+            });
+            const result = await server.callTool('list_sessions', {
+                status: 'running'
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.sessions).toHaveLength(1);
+            expect(data.sessions[0].id).toBe('session-1');
+        });
+        it('should apply limit', async () => {
+            server.registerTool('list_sessions', async function (args) {
+                const { limit } = args;
+                let sessions = Array.from(this.sessions.values());
+                if (limit) {
+                    sessions = sessions.slice(0, limit);
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ sessions })
+                        }]
+                };
+            });
+            const result = await server.callTool('list_sessions', {
+                limit: 1
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.sessions).toHaveLength(1);
+        });
+    });
+    describe('kill_session', () => {
+        beforeEach(() => {
+            server.sessions.set('session-to-kill', {
+                id: 'session-to-kill',
+                status: 'running',
+                pid: 12345
+            });
+        });
+        it('should kill a running session', async () => {
+            server.registerTool('kill_session', async function (args) {
+                const { sessionId, force } = args;
+                const session = this.sessions.get(sessionId);
+                if (!session) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Session not found' })
+                            }],
+                        isError: true
+                    };
+                }
+                // Mock kill
+                session.status = 'killed';
+                session.killedAt = Date.now();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                sessionId,
+                                status: 'killed',
+                                force: force || false
+                            })
+                        }]
+                };
+            });
+            const result = await server.callTool('kill_session', {
+                sessionId: 'session-to-kill'
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.status).toBe('killed');
+        });
+        it('should return error for non-existent session', async () => {
+            server.registerTool('kill_session', async function (args) {
+                const { sessionId } = args;
+                if (!this.sessions.has(sessionId)) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Session not found' })
+                            }],
+                        isError: true
+                    };
+                }
+            });
+            const result = await server.callTool('kill_session', {
+                sessionId: 'non-existent'
+            });
+            expect(result.isError).toBe(true);
+        });
+    });
+    describe('send_message', () => {
+        beforeEach(() => {
+            server.sessions.set('active-session', {
+                id: 'active-session',
+                status: 'running',
+                messages: []
+            });
+        });
+        it('should send message to active session', async () => {
+            server.registerTool('send_message', async function (args) {
+                const { sessionId, message } = args;
+                const session = this.sessions.get(sessionId);
+                if (!session) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Session not found' })
+                            }],
+                        isError: true
+                    };
+                }
+                if (session.status !== 'running') {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Session is not running' })
+                            }],
+                        isError: true
+                    };
+                }
+                session.messages.push({
+                    content: message,
+                    timestamp: Date.now()
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                sessionId,
+                                messageSent: true,
+                                messageCount: session.messages.length
+                            })
+                        }]
+                };
+            });
+            const result = await server.callTool('send_message', {
+                sessionId: 'active-session',
+                message: 'What is the status?'
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.messageSent).toBe(true);
+            expect(data.messageCount).toBe(1);
+        });
+        it('should handle waitForResponse option', async () => {
+            server.registerTool('send_message', async function (args) {
+                const { sessionId, message, waitForResponse } = args;
+                const session = this.sessions.get(sessionId);
+                session.messages.push({ content: message, timestamp: Date.now() });
+                const response = {
+                    sessionId,
+                    messageSent: true
+                };
+                if (waitForResponse) {
+                    // Mock waiting for response
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                    response.response = {
+                        content: 'Task completed successfully',
+                        timestamp: Date.now()
+                    };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(response)
+                        }]
+                };
+            });
+            const result = await server.callTool('send_message', {
+                sessionId: 'active-session',
+                message: 'Check status',
+                waitForResponse: true
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.response).toBeDefined();
+        });
+    });
+    describe('sync_context', () => {
+        beforeEach(() => {
+            server.sessions.set('source-session', {
+                id: 'source-session',
+                context: {
+                    files: ['/path/to/file1.ts'],
+                    history: ['message1', 'message2']
+                }
+            });
+            server.sessions.set('target-session', {
+                id: 'target-session',
+                context: {}
+            });
+        });
+        it('should sync context between sessions', async () => {
+            server.registerTool('sync_context', async function (args) {
+                const { sourceSessionId, targetSessionId, contextType } = args;
+                const source = this.sessions.get(sourceSessionId);
+                const target = this.sessions.get(targetSessionId);
+                if (!source || !target) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Session not found' })
+                            }],
+                        isError: true
+                    };
+                }
+                // Sync based on contextType
+                if (contextType === 'all' || contextType === 'history') {
+                    target.context.history = source.context.history;
+                }
+                if (contextType === 'all' || contextType === 'files') {
+                    target.context.files = source.context.files;
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                synced: true,
+                                targetSessionId,
+                                contextTypes: [contextType]
+                            })
+                        }]
+                };
+            });
+            const result = await server.callTool('sync_context', {
+                sourceSessionId: 'source-session',
+                targetSessionId: 'target-session',
+                contextType: 'all'
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.synced).toBe(true);
+            const target = server.sessions.get('target-session');
+            expect(target.context).toEqual({
+                files: ['/path/to/file1.ts'],
+                history: ['message1', 'message2']
+            });
+        });
+        it('should apply direct context data', async () => {
+            server.registerTool('sync_context', async function (args) {
+                const { targetSessionId, contextData } = args;
+                const target = this.sessions.get(targetSessionId);
+                if (!target) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Session not found' })
+                            }],
+                        isError: true
+                    };
+                }
+                target.context = { ...target.context, ...contextData };
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                applied: true,
+                                targetSessionId
+                            })
+                        }]
+                };
+            });
+            const result = await server.callTool('sync_context', {
+                targetSessionId: 'target-session',
+                contextData: {
+                    files: ['/new/file.ts'],
+                    customData: 'test'
+                }
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.applied).toBe(true);
+        });
+    });
+    describe('stream_output', () => {
+        beforeEach(() => {
+            server.sessions.set('streaming-session', {
+                id: 'streaming-session',
+                output: [
+                    'Line 1: Starting task...',
+                    'Line 2: Processing data...',
+                    'Line 3: Complete!'
+                ]
+            });
+        });
+        it('should stream session output', async () => {
+            server.registerTool('stream_output', async function (args) {
+                const { sessionId, lines } = args;
+                const session = this.sessions.get(sessionId);
+                if (!session) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Session not found' })
+                            }],
+                        isError: true
+                    };
+                }
+                let output = session.output || [];
+                if (lines && lines > 0) {
+                    output = output.slice(-lines);
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                sessionId,
+                                output,
+                                lineCount: output.length
+                            })
+                        }]
+                };
+            });
+            const result = await server.callTool('stream_output', {
+                sessionId: 'streaming-session',
+                lines: 2
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.lineCount).toBe(2);
+            expect(data.output).toEqual([
+                'Line 2: Processing data...',
+                'Line 3: Complete!'
+            ]);
+        });
+        it('should return all output when lines is 0', async () => {
+            server.registerTool('stream_output', async function (args) {
+                const { sessionId, lines } = args;
+                const session = this.sessions.get(sessionId);
+                let output = session.output || [];
+                if (lines > 0) {
+                    output = output.slice(-lines);
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ output })
+                        }]
+                };
+            });
+            const result = await server.callTool('stream_output', {
+                sessionId: 'streaming-session',
+                lines: 0
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.output).toHaveLength(3);
+        });
+    });
+    describe('wait_for_completion', () => {
+        it('should wait for session completion', async () => {
+            let sessionCompleted = false;
+            server.registerTool('wait_for_completion', async function (args) {
+                const { sessionId, timeout, pollInterval } = args;
+                const startTime = Date.now();
+                // Simulate polling
+                while (Date.now() - startTime < (timeout || 300000)) {
+                    await new Promise(resolve => setTimeout(resolve, pollInterval || 1000));
+                    // Check if session completed (mock)
+                    if (sessionCompleted) {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        sessionId,
+                                        status: 'completed',
+                                        duration: Date.now() - startTime
+                                    })
+                                }]
+                        };
+                    }
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                sessionId,
+                                status: 'timeout'
+                            })
+                        }]
+                };
+            });
+            // Complete session after 50ms
+            setTimeout(() => { sessionCompleted = true; }, 50);
+            const result = await server.callTool('wait_for_completion', {
+                sessionId: 'waiting-session',
+                timeout: 5000,
+                pollInterval: 10
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.status).toBe('completed');
+            expect(data.duration).toBeGreaterThan(0);
+        });
+        it('should timeout after specified duration', async () => {
+            server.registerTool('wait_for_completion', async function (args) {
+                const { timeout } = args;
+                const startTime = Date.now();
+                // Simulate timeout
+                await new Promise(resolve => setTimeout(resolve, timeout || 100));
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                status: 'timeout',
+                                duration: Date.now() - startTime
+                            })
+                        }]
+                };
+            });
+            const result = await server.callTool('wait_for_completion', {
+                sessionId: 'slow-session',
+                timeout: 50
+            });
+            const data = JSON.parse(result.content[0].text);
+            expect(data.status).toBe('timeout');
+        });
+    });
+});
+describe('Doppler Integration Tests', () => {
+    describe('Doppler Environment Setup', () => {
+        it('should verify DOPPLER_TOKEN is available', async () => {
+            // Mock environment check
+            const hasToken = process.env.DOPPLER_TOKEN !== undefined;
+            expect(typeof hasToken).toBe('boolean');
+        });
+        it('should construct doppler run command correctly', () => {
+            const buildDopplerCommand = (project, config, command) => {
+                return ['doppler', 'run', '--project', project, '--config', config, '--command', command];
+            };
+            const cmd = buildDopplerCommand('test-project', 'dev', 'claude --resume test-uuid');
+            expect(cmd).toContain('doppler');
+            expect(cmd).toContain('--project');
+            expect(cmd).toContain('test-project');
+            expect(cmd).toContain('--config');
+            expect(cmd).toContain('dev');
+            expect(cmd).toContain('--command');
+        });
+    });
+    describe('Rolling Keys with Doppler', () => {
+        it('should handle ANTHROPIC_API_KEYS array format', () => {
+            const mockKeys = '["key1","key2","key3"]';
+            const parsed = JSON.parse(mockKeys);
+            expect(Array.isArray(parsed)).toBe(true);
+            expect(parsed).toHaveLength(3);
+        });
+        it('should select first available key', () => {
+            const keys = ['key1', 'key2', 'key3'];
+            const selectedKey = keys[0];
+            expect(selectedKey).toBe('key1');
+        });
+        it('should fallback to ANTHROPIC_AUTH_TOKEN if API_KEY missing', () => {
+            const fallback = (apiKey, authToken) => {
+                return apiKey || authToken;
+            };
+            expect(fallback('', 'auth-token-value')).toBe('auth-token-value');
+            expect(fallback('api-key-value', 'auth-token-value')).toBe('api-key-value');
+        });
+    });
+});
+//# sourceMappingURL=integration.test.js.map