@mcpjam/inspector 0.3.5 → 0.3.6

package/server/build/testing/TestRunner.js

@@ -0,0 +1,198 @@
+// 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;
+    }
+}

package/server/build/testing/TestServer.js

@@ -0,0 +1,440 @@
+// server/src/testing/TestServer.ts
+import express from "express";
+import cors from "cors";
+import { HealthCheck } from "./HealthCheck.js";
+import { ConsoleLogger } from "../shared/utils.js";
+export class TestServer {
+    app;
+    server;
+    healthCheck = null;
+    logger;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.logger = new ConsoleLogger();
+        this.app = express();
+        this.setupMiddleware();
+    }
+    setupMiddleware() {
+        // CORS support
+        if (this.config.cors) {
+            this.app.use(cors({
+                origin: true,
+                credentials: true,
+            }));
+        }
+        // Body parsing
+        this.app.use(express.json({ limit: "10mb" }));
+        this.app.use(express.urlencoded({ extended: true }));
+        // Request logging
+        this.app.use((req, res, next) => {
+            this.logger.info(`${req.method} ${req.path}`, {
+                ip: req.ip,
+                userAgent: req.get("User-Agent"),
+            });
+            next();
+        });
+    }
+    setupRoutes() {
+        // Health check endpoints
+        this.app.get("/api/test/health", (req, res) => {
+            if (!this.healthCheck) {
+                return res.status(503).json({ error: "Health check not initialized" });
+            }
+            res.json(this.healthCheck.getStatus());
+        });
+        this.app.get("/api/test/status", (req, res) => {
+            if (!this.healthCheck) {
+                return res.status(503).json({ error: "Health check not initialized" });
+            }
+            res.json(this.healthCheck.getDetailedStatus());
+        });
+        // Test execution endpoints
+        this.app.post("/api/test/run", async (req, res) => {
+            try {
+                const { testCase } = req.body;
+                if (!testCase ||
+                    !testCase.id ||
+                    !testCase.prompt ||
+                    !testCase.serverConfigs) {
+                    return res.status(400).json({
+                        success: false,
+                        error: "Invalid test case format. Required fields: id, prompt, serverConfigs",
+                    });
+                }
+                this.logger.info(`🧪 Starting test execution for: ${testCase.name || testCase.id}`);
+                // Mock test execution for now - will be replaced with actual implementation
+                const startTime = Date.now();
+                // Simulate test execution
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+                const result = {
+                    id: `result-${Date.now()}`,
+                    testCase: testCase,
+                    toolCalls: [],
+                    duration: Date.now() - startTime,
+                    success: true,
+                    timestamp: new Date().toISOString(),
+                    metadata: {
+                        executionMode: "single",
+                        server: "test-server",
+                    },
+                };
+                this.logger.info(`✅ Test execution completed for: ${testCase.name || testCase.id}`);
+                res.json({
+                    success: true,
+                    result: result,
+                });
+            }
+            catch (error) {
+                this.logger.error("❌ Test execution failed:", error);
+                res.status(500).json({
+                    success: false,
+                    error: "Test execution failed",
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        this.app.post("/api/test/run-batch", async (req, res) => {
+            try {
+                const { testCases } = req.body;
+                if (!Array.isArray(testCases) || testCases.length === 0) {
+                    return res.status(400).json({
+                        success: false,
+                        error: "Invalid request format. Expected array of test cases",
+                    });
+                }
+                this.logger.info(`🧪 Starting batch test execution for ${testCases.length} tests`);
+                const results = [];
+                const startTime = Date.now();
+                // Process each test case
+                for (const testCase of testCases) {
+                    if (!testCase.id || !testCase.prompt || !testCase.serverConfigs) {
+                        results.push({
+                            id: `result-${Date.now()}`,
+                            testCase: testCase,
+                            toolCalls: [],
+                            duration: 0,
+                            success: false,
+                            error: "Invalid test case format",
+                            timestamp: new Date().toISOString(),
+                        });
+                        continue;
+                    }
+                    const testStartTime = Date.now();
+                    // Simulate test execution
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                    results.push({
+                        id: `result-${Date.now()}`,
+                        testCase: testCase,
+                        toolCalls: [],
+                        duration: Date.now() - testStartTime,
+                        success: true,
+                        timestamp: new Date().toISOString(),
+                        metadata: {
+                            executionMode: "batch",
+                            server: "test-server",
+                        },
+                    });
+                }
+                const totalDuration = Date.now() - startTime;
+                const successCount = results.filter((r) => r.success).length;
+                this.logger.info(`✅ Batch test execution completed: ${successCount}/${testCases.length} passed`);
+                res.json({
+                    success: true,
+                    results: results,
+                    summary: {
+                        total: testCases.length,
+                        passed: successCount,
+                        failed: testCases.length - successCount,
+                        duration: totalDuration,
+                    },
+                });
+            }
+            catch (error) {
+                this.logger.error("❌ Batch test execution failed:", error);
+                res.status(500).json({
+                    success: false,
+                    error: "Batch test execution failed",
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        this.app.get("/api/test/results", (req, res) => {
+            try {
+                const { limit = 50, offset = 0, testCaseId } = req.query;
+                // Mock results for now - will be replaced with database queries
+                const mockResults = [
+                    {
+                        id: "result-1",
+                        testCase: {
+                            id: "test-1",
+                            name: "Sample Test",
+                            prompt: "Test prompt",
+                        },
+                        toolCalls: [],
+                        duration: 1250,
+                        success: true,
+                        timestamp: new Date().toISOString(),
+                    },
+                ];
+                res.json({
+                    success: true,
+                    results: mockResults,
+                    pagination: {
+                        limit: parseInt(limit),
+                        offset: parseInt(offset),
+                        total: mockResults.length,
+                    },
+                });
+            }
+            catch (error) {
+                this.logger.error("❌ Failed to retrieve test results:", error);
+                res.status(500).json({
+                    success: false,
+                    error: "Failed to retrieve test results",
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        this.app.get("/api/test/results/:id", (req, res) => {
+            try {
+                const { id } = req.params;
+                // Mock result for now - will be replaced with database query
+                const mockResult = {
+                    id: id,
+                    testCase: {
+                        id: "test-1",
+                        name: "Sample Test",
+                        prompt: "Test prompt",
+                    },
+                    toolCalls: [],
+                    duration: 1250,
+                    success: true,
+                    timestamp: new Date().toISOString(),
+                    metadata: {
+                        executionMode: "single",
+                        server: "test-server",
+                    },
+                };
+                res.json({
+                    success: true,
+                    result: mockResult,
+                });
+            }
+            catch (error) {
+                this.logger.error("❌ Failed to retrieve test result:", error);
+                res.status(500).json({
+                    success: false,
+                    error: "Failed to retrieve test result",
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        this.app.get("/api/test/connections", (req, res) => {
+            try {
+                // Mock connection info for now
+                const mockConnections = [
+                    {
+                        id: "conn-1",
+                        name: "Test Server",
+                        type: "stdio",
+                        status: "connected",
+                        lastActivity: new Date().toISOString(),
+                    },
+                ];
+                res.json({
+                    success: true,
+                    connections: mockConnections,
+                    summary: {
+                        total: mockConnections.length,
+                        active: mockConnections.filter((c) => c.status === "connected")
+                            .length,
+                        inactive: mockConnections.filter((c) => c.status !== "connected")
+                            .length,
+                    },
+                });
+            }
+            catch (error) {
+                this.logger.error("❌ Failed to retrieve connections:", error);
+                res.status(500).json({
+                    success: false,
+                    error: "Failed to retrieve connections",
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        // Test case management endpoints
+        this.app.get("/api/test/cases", (req, res) => {
+            try {
+                const { limit = 50, offset = 0 } = req.query;
+                // Mock test cases for now
+                const mockTestCases = [
+                    {
+                        id: "test-1",
+                        name: "Sample Test Case",
+                        prompt: "Test the weather tool functionality",
+                        expectedTools: ["get_weather"],
+                        serverConfigs: [{ id: "server-1", name: "Weather Server" }],
+                        timeout: 30000,
+                        metadata: { category: "weather" },
+                    },
+                ];
+                res.json({
+                    success: true,
+                    testCases: mockTestCases,
+                    pagination: {
+                        limit: parseInt(limit),
+                        offset: parseInt(offset),
+                        total: mockTestCases.length,
+                    },
+                });
+            }
+            catch (error) {
+                this.logger.error("❌ Failed to retrieve test cases:", error);
+                res.status(500).json({
+                    success: false,
+                    error: "Failed to retrieve test cases",
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        this.app.post("/api/test/cases", async (req, res) => {
+            try {
+                const testCase = req.body;
+                if (!testCase.name || !testCase.prompt || !testCase.serverConfigs) {
+                    return res.status(400).json({
+                        success: false,
+                        error: "Invalid test case format. Required fields: name, prompt, serverConfigs",
+                    });
+                }
+                // Generate ID if not provided
+                if (!testCase.id) {
+                    testCase.id = `test-${Date.now()}`;
+                }
+                this.logger.info(`💾 Creating test case: ${testCase.name}`);
+                // Mock save operation
+                const savedTestCase = {
+                    ...testCase,
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                };
+                res.status(201).json({
+                    success: true,
+                    testCase: savedTestCase,
+                });
+            }
+            catch (error) {
+                this.logger.error("❌ Failed to create test case:", error);
+                res.status(500).json({
+                    success: false,
+                    error: "Failed to create test case",
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        this.app.get("/api/test/cases/:id", (req, res) => {
+            try {
+                const { id } = req.params;
+                // Mock test case
+                const mockTestCase = {
+                    id: id,
+                    name: "Sample Test Case",
+                    prompt: "Test the weather tool functionality",
+                    expectedTools: ["get_weather"],
+                    serverConfigs: [{ id: "server-1", name: "Weather Server" }],
+                    timeout: 30000,
+                    metadata: { category: "weather" },
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                };
+                res.json({
+                    success: true,
+                    testCase: mockTestCase,
+                });
+            }
+            catch (error) {
+                this.logger.error("❌ Failed to retrieve test case:", error);
+                res.status(500).json({
+                    success: false,
+                    error: "Failed to retrieve test case",
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        // Statistics endpoint
+        this.app.get("/api/test/stats", (_req, res) => {
+            try {
+                const stats = {
+                    testCases: {
+                        total: 1,
+                        active: 1,
+                        inactive: 0,
+                    },
+                    testResults: {
+                        total: 1,
+                        passed: 1,
+                        failed: 0,
+                        recentRuns: 1,
+                    },
+                    connections: {
+                        total: 1,
+                        active: 1,
+                        inactive: 0,
+                    },
+                    performance: {
+                        averageTestDuration: 1250,
+                        successRate: 100,
+                        lastRunTime: new Date().toISOString(),
+                    },
+                };
+                res.json({
+                    success: true,
+                    stats: stats,
+                });
+            }
+            catch (error) {
+                this.logger.error("❌ Failed to retrieve statistics:", error);
+                res.status(500).json({
+                    success: false,
+                    error: "Failed to retrieve statistics",
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        // Error handling
+        this.app.use((error, _req, res, _next) => {
+            this.logger.error("Unhandled error:", error);
+            res.status(500).json({
+                success: false,
+                error: "Internal server error",
+            });
+        });
+    }
+    async start(mcpProxyService, database) {
+        // Initialize components
+        this.healthCheck = new HealthCheck(mcpProxyService, database, this.logger);
+        // Setup routes
+        this.setupRoutes();
+        // Start server
+        return new Promise((resolve, reject) => {
+            this.server = this.app.listen(this.config.port, this.config.host, () => {
+                this.logger.info(`🧪 Test server listening on ${this.config.host}:${this.config.port}`);
+                resolve();
+            });
+            this.server.on("error", (error) => {
+                this.logger.error("Server error:", error);
+                reject(error);
+            });
+        });
+    }
+    async stop() {
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server.close(() => {
+                    this.logger.info("🧪 Test server stopped");
+                    resolve();
+                });
+            });
+        }
+    }
+}

package/server/build/testing/types.js

@@ -0,0 +1 @@
+export {};