@mcpjam/inspector 0.3.9 → 0.8.0

package/server/build/testing/TestExecutor.js

@@ -1,240 +0,0 @@
-// server/src/testing/TestExecutor.ts
-import { randomUUID } from "node:crypto";
-export class TestExecutor {
-    mcpProxyService;
-    logger;
-    constructor(mcpProxyService, logger) {
-        this.mcpProxyService = mcpProxyService;
-        this.logger = logger;
-    }
-    async executeTest(testCase) {
-        const startTime = Date.now();
-        const resultId = randomUUID();
-        this.logger.info(`🧪 Starting test execution: ${testCase.name} (${testCase.id})`);
-        try {
-            // Validate test case
-            this.validateTestCase(testCase);
-            // Initialize connections to MCP servers
-            const connections = await this.initializeConnections(testCase);
-            // Execute the test
-            const toolCalls = await this.executeTestLogic(testCase, connections);
-            // Clean up connections
-            await this.cleanupConnections(connections);
-            const duration = Date.now() - startTime;
-            const result = {
-                id: resultId,
-                testCase: testCase,
-                toolCalls: toolCalls,
-                duration: duration,
-                success: true,
-                timestamp: new Date(),
-                metadata: {
-                    executorVersion: "1.0.0",
-                    executionMode: "single",
-                },
-            };
-            this.logger.info(`✅ Test execution completed: ${testCase.name} (${duration}ms)`);
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            this.logger.error(`❌ Test execution failed: ${testCase.name} - ${errorMessage}`);
-            const result = {
-                id: resultId,
-                testCase: testCase,
-                toolCalls: [],
-                duration: duration,
-                success: false,
-                error: errorMessage,
-                timestamp: new Date(),
-                metadata: {
-                    executorVersion: "1.0.0",
-                    executionMode: "single",
-                },
-            };
-            return result;
-        }
-    }
-    validateTestCase(testCase) {
-        if (!testCase.id) {
-            throw new Error("Test case must have an ID");
-        }
-        if (!testCase.name) {
-            throw new Error("Test case must have a name");
-        }
-        if (!testCase.prompt) {
-            throw new Error("Test case must have a prompt");
-        }
-        if (!testCase.serverConfigs || testCase.serverConfigs.length === 0) {
-            throw new Error("Test case must have at least one server configuration");
-        }
-        // Validate timeout
-        if (testCase.timeout && testCase.timeout < 1000) {
-            throw new Error("Test case timeout must be at least 1000ms");
-        }
-    }
-    async initializeConnections(testCase) {
-        const connections = new Map();
-        for (const serverConfig of testCase.serverConfigs) {
-            try {
-                this.logger.info(`🔗 Initializing connection to server: ${serverConfig.name}`);
-                // Use MCPProxyService to create connection
-                let sessionId;
-                if (serverConfig.type === "stdio") {
-                    // For STDIO, we need to create a mock response object for SSE
-                    const mockResponse = {
-                        writeHead: () => { },
-                        write: () => { },
-                        end: () => { },
-                        on: () => { },
-                        setHeader: () => { },
-                    };
-                    const connection = await this.mcpProxyService.createSSEConnection(serverConfig, mockResponse, {});
-                    sessionId = connection.sessionId;
-                }
-                else if (serverConfig.type === "streamable-http") {
-                    const connection = await this.mcpProxyService.createStreamableHTTPConnection(serverConfig, {});
-                    sessionId = connection.sessionId;
-                }
-                else {
-                    throw new Error(`Unsupported server type: ${serverConfig.type}`);
-                }
-                connections.set(serverConfig.id, sessionId);
-                this.logger.info(`✅ Connected to server: ${serverConfig.name} (${sessionId})`);
-            }
-            catch (error) {
-                this.logger.error(`❌ Failed to connect to server: ${serverConfig.name} - ${error}`);
-                throw new Error(`Failed to connect to server: ${serverConfig.name}`);
-            }
-        }
-        return connections;
-    }
-    async executeTestLogic(testCase, connections) {
-        const toolCalls = [];
-        // Set timeout for the entire test execution
-        const timeout = testCase.timeout || 30000;
-        const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`Test execution timed out after ${timeout}ms`)), timeout);
-        });
-        try {
-            // Execute the test logic with timeout
-            const result = await Promise.race([
-                this.runTestWithConnections(testCase, connections),
-                timeoutPromise,
-            ]);
-            return result;
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes("timed out")) {
-                this.logger.error(`⏱️ Test execution timed out: ${testCase.name}`);
-            }
-            throw error;
-        }
-    }
-    async runTestWithConnections(testCase, connections) {
-        const toolCalls = [];
-        // For now, implement a simple test execution that simulates tool calls
-        // In a real implementation, this would involve:
-        // 1. Sending the prompt to an LLM
-        // 2. Processing tool calls returned by the LLM
-        // 3. Executing those tool calls against the connected MCP servers
-        // 4. Recording the results
-        this.logger.info(`🤖 Processing prompt: ${testCase.prompt.substring(0, 100)}...`);
-        // Simulate tool calls based on expected tools
-        if (testCase.expectedTools && testCase.expectedTools.length > 0) {
-            for (const expectedTool of testCase.expectedTools) {
-                for (const [serverId, _sessionId] of connections.entries()) {
-                    const serverConfig = testCase.serverConfigs.find((s) => s.id === serverId);
-                    if (!serverConfig)
-                        continue;
-                    const toolCallStartTime = Date.now();
-                    try {
-                        // Simulate tool call execution
-                        await new Promise((resolve) => setTimeout(resolve, 100 + Math.random() * 400));
-                        const toolCall = {
-                            toolName: expectedTool,
-                            serverId: serverId,
-                            serverName: serverConfig.name,
-                            parameters: {
-                                prompt: testCase.prompt,
-                                timestamp: new Date().toISOString(),
-                            },
-                            response: {
-                                success: true,
-                                data: `Mock response for ${expectedTool}`,
-                                timestamp: new Date().toISOString(),
-                            },
-                            executionTimeMs: Date.now() - toolCallStartTime,
-                            success: true,
-                            timestamp: new Date(),
-                        };
-                        toolCalls.push(toolCall);
-                        this.logger.info(`🔧 Tool call executed: ${expectedTool} on ${serverConfig.name}`);
-                    }
-                    catch (error) {
-                        const errorMessage = error instanceof Error ? error.message : String(error);
-                        const toolCall = {
-                            toolName: expectedTool,
-                            serverId: serverId,
-                            serverName: serverConfig.name,
-                            parameters: {
-                                prompt: testCase.prompt,
-                                timestamp: new Date().toISOString(),
-                            },
-                            response: null,
-                            executionTimeMs: Date.now() - toolCallStartTime,
-                            success: false,
-                            error: errorMessage,
-                            timestamp: new Date(),
-                        };
-                        toolCalls.push(toolCall);
-                        this.logger.error(`❌ Tool call failed: ${expectedTool} on ${serverConfig.name} - ${errorMessage}`);
-                    }
-                }
-            }
-        }
-        else {
-            // If no expected tools, simulate a basic interaction
-            const serverId = connections.keys().next().value;
-            if (serverId) {
-                const _sessionId = connections.get(serverId);
-                const serverConfig = testCase.serverConfigs.find((s) => s.id === serverId);
-                if (serverConfig) {
-                    const toolCallStartTime = Date.now();
-                    const toolCall = {
-                        toolName: "default_interaction",
-                        serverId: serverId,
-                        serverName: serverConfig.name,
-                        parameters: {
-                            prompt: testCase.prompt,
-                            timestamp: new Date().toISOString(),
-                        },
-                        response: {
-                            success: true,
-                            data: "Mock response for default interaction",
-                            timestamp: new Date().toISOString(),
-                        },
-                        executionTimeMs: Date.now() - toolCallStartTime,
-                        success: true,
-                        timestamp: new Date(),
-                    };
-                    toolCalls.push(toolCall);
-                }
-            }
-        }
-        return toolCalls;
-    }
-    async cleanupConnections(connections) {
-        for (const [serverId, sessionId] of connections.entries()) {
-            try {
-                // Note: MCPProxyService doesn't have a direct cleanup method for individual sessions
-                // In a real implementation, you might want to add this functionality
-                this.logger.info(`🧹 Cleaning up connection: ${serverId} (${sessionId})`);
-            }
-            catch (error) {
-                this.logger.error(`❌ Failed to cleanup connection: ${serverId} - ${error}`);
-            }
-        }
-    }
-}

package/server/build/testing/TestRunner.js

@@ -1,198 +0,0 @@
-// server/src/testing/TestRunner.ts
-import { EventEmitter } from "events";
-import { randomUUID } from "node:crypto";
-export class TestRunner extends EventEmitter {
-    mcpProxyService;
-    _database;
-    logger;
-    activeTests = new Map();
-    constructor(mcpProxyService, _database, logger) {
-        super();
-        this.mcpProxyService = mcpProxyService;
-        this._database = _database;
-        this.logger = logger;
-    }
-    async runTest(testCase) {
-        const testId = randomUUID();
-        const startTime = Date.now();
-        this.logger.info(`Starting test: ${testCase.name} (${testId})`);
-        try {
-            // Create test execution context
-            const execution = new TestExecution(testId, testCase, this.logger);
-            this.activeTests.set(testId, execution);
-            // Create MCP connections
-            const connections = await this.createConnections(testCase.serverConfigs);
-            execution.setConnections(connections);
-            // Execute test
-            const toolCalls = await this.executeTest(testCase, connections);
-            // Create result
-            const result = {
-                id: testId,
-                testCase,
-                toolCalls,
-                duration: Date.now() - startTime,
-                success: true,
-                timestamp: new Date(),
-            };
-            this.logger.info(`Test completed: ${testCase.name} (${testId})`);
-            this.emit("testComplete", result);
-            return result;
-        }
-        catch (error) {
-            this.logger.error(`Test failed: ${testCase.name} (${testId}):`, error);
-            const result = {
-                id: testId,
-                testCase,
-                toolCalls: [],
-                duration: Date.now() - startTime,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                timestamp: new Date(),
-            };
-            this.emit("testError", result, error);
-            return result;
-        }
-        finally {
-            this.activeTests.delete(testId);
-        }
-    }
-    async runBatch(testCases) {
-        this.logger.info(`Starting batch test: ${testCases.length} tests`);
-        // Run tests in parallel with controlled concurrency
-        const maxConcurrency = 5;
-        const results = [];
-        for (let i = 0; i < testCases.length; i += maxConcurrency) {
-            const batch = testCases.slice(i, i + maxConcurrency);
-            const batchResults = await Promise.all(batch.map((testCase) => this.runTest(testCase)));
-            results.push(...batchResults);
-        }
-        this.logger.info(`Batch test completed: ${results.length} results`);
-        return results;
-    }
-    async getResults(_query) {
-        // Mock implementation - in real version would query database
-        return [];
-    }
-    async getResult(_id) {
-        // Mock implementation - in real version would query database
-        return null;
-    }
-    getActiveConnections() {
-        return this.mcpProxyService.getActiveConnections();
-    }
-    async closeConnection(id) {
-        // Note: MCPProxyService doesn't have closeConnection method
-        // Would need to be implemented
-        this.logger.info(`Closing connection: ${id}`);
-    }
-    async close() {
-        // Close all active tests
-        for (const [_testId, execution] of this.activeTests) {
-            await execution.cancel();
-        }
-        this.activeTests.clear();
-        // Close MCP connections
-        await this.mcpProxyService.closeAllConnections();
-        this.logger.info("Test runner closed");
-    }
-    async createConnections(serverConfigs) {
-        const connections = [];
-        for (const config of serverConfigs) {
-            try {
-                let sessionId;
-                if (config.type === "stdio") {
-                    // For STDIO, create a mock response for SSE
-                    const mockResponse = {
-                        writeHead: () => { },
-                        write: () => { },
-                        end: () => { },
-                        on: () => { },
-                        setHeader: () => { },
-                    };
-                    const connection = await this.mcpProxyService.createSSEConnection(config, mockResponse, {});
-                    sessionId = connection.sessionId;
-                }
-                else if (config.type === "streamable-http") {
-                    const connection = await this.mcpProxyService.createStreamableHTTPConnection(config, {});
-                    sessionId = connection.sessionId;
-                }
-                else {
-                    throw new Error(`Unsupported server type: ${config.type}`);
-                }
-                connections.push(sessionId);
-                this.logger.info(`Created connection: ${config.name} (${sessionId})`);
-            }
-            catch (error) {
-                this.logger.error(`Failed to create connection for ${config.name}:`, error);
-                throw error;
-            }
-        }
-        return connections;
-    }
-    async executeTest(testCase, connections) {
-        const toolCalls = [];
-        const _timeout = testCase.timeout || 30000;
-        // Simple mock execution for now
-        // In real implementation, would use LLM to process prompt and make tool calls
-        if (testCase.expectedTools && testCase.expectedTools.length > 0) {
-            for (const expectedTool of testCase.expectedTools) {
-                const toolCallStartTime = Date.now();
-                try {
-                    // Mock tool call execution
-                    await new Promise((resolve) => setTimeout(resolve, 100));
-                    const toolCall = {
-                        toolName: expectedTool,
-                        serverId: connections[0] || "unknown",
-                        serverName: "Mock Server",
-                        parameters: { test: true },
-                        response: {
-                            success: true,
-                            data: `Mock response for ${expectedTool}`,
-                        },
-                        executionTimeMs: Date.now() - toolCallStartTime,
-                        success: true,
-                        timestamp: new Date(),
-                    };
-                    toolCalls.push(toolCall);
-                }
-                catch (error) {
-                    const toolCall = {
-                        toolName: expectedTool,
-                        serverId: connections[0] || "unknown",
-                        serverName: "Mock Server",
-                        parameters: { test: true },
-                        response: null,
-                        executionTimeMs: Date.now() - toolCallStartTime,
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                        timestamp: new Date(),
-                    };
-                    toolCalls.push(toolCall);
-                }
-            }
-        }
-        return toolCalls;
-    }
-}
-class TestExecution {
-    id;
-    testCase;
-    logger;
-    _connections = [];
-    cancelled = false;
-    constructor(id, testCase, logger) {
-        this.id = id;
-        this.testCase = testCase;
-        this.logger = logger;
-    }
-    setConnections(connections) {
-        this._connections = connections;
-    }
-    async cancel() {
-        this.cancelled = true;
-        this.logger.info(`Test execution cancelled: ${this.id}`);
-    }
-    isCancelled() {
-        return this.cancelled;
-    }
-}