@mcpjam/inspector 0.3.4 → 0.3.6

package/server/build/shared/TransportFactory.js

@@ -0,0 +1,130 @@
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { findActualExecutable } from "spawn-rx";
+import { validateServerConfig, ConsoleLogger } from "./utils.js";
+const SSE_HEADERS_PASSTHROUGH = ["authorization"];
+const STREAMABLE_HTTP_HEADERS_PASSTHROUGH = [
+    "authorization",
+    "mcp-session-id",
+    "last-event-id",
+];
+export class TransportFactory {
+    logger;
+    defaultEnvironment;
+    constructor(options = {}) {
+        this.logger = options.logger || new ConsoleLogger();
+        this.defaultEnvironment = {
+            ...getDefaultEnvironment(),
+            ...(process.env.MCP_ENV_VARS ? JSON.parse(process.env.MCP_ENV_VARS) : {}),
+        };
+    }
+    async createTransport(config, requestHeaders) {
+        validateServerConfig(config);
+        this.logger.info(`Creating ${config.type} transport for ${config.name}`);
+        try {
+            switch (config.type) {
+                case "stdio":
+                    return await this.createStdioTransport(config);
+                case "sse":
+                    return await this.createSSETransport(config, requestHeaders);
+                case "streamable-http":
+                    return await this.createStreamableHTTPTransport(config, requestHeaders);
+                default:
+                    throw new Error(`Unsupported transport type: ${config.type}`);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Failed to create transport for ${config.name}:`, error);
+            throw error;
+        }
+    }
+    async createStdioTransport(config) {
+        const command = config.command;
+        const origArgs = config.args || [];
+        const queryEnv = config.env || {};
+        // Filter out undefined values from process.env
+        const processEnv = Object.fromEntries(Object.entries(process.env).filter(([, value]) => value !== undefined));
+        const env = { ...processEnv, ...this.defaultEnvironment, ...queryEnv };
+        const { cmd, args } = findActualExecutable(command, origArgs);
+        this.logger.info(`🚀 Stdio transport: command=${cmd}, args=${args}`);
+        const transport = new StdioClientTransport({
+            command: cmd,
+            args,
+            env,
+            stderr: "pipe",
+        });
+        await this.setupTransportLifecycle(transport, config.id);
+        await transport.start();
+        return transport;
+    }
+    async createSSETransport(config, requestHeaders) {
+        const url = config.url;
+        const headers = {
+            Accept: "text/event-stream",
+            ...config.headers,
+        };
+        // Add headers passed through from the request
+        if (requestHeaders) {
+            for (const key of SSE_HEADERS_PASSTHROUGH) {
+                if (requestHeaders[key] !== undefined) {
+                    headers[key] = requestHeaders[key];
+                }
+            }
+        }
+        this.logger.info(`🚀 SSE transport: url=${url}`);
+        const transport = new SSEClientTransport(new URL(url), {
+            eventSourceInit: {
+                fetch: (url, init) => fetch(url, { ...init, headers }),
+            },
+            requestInit: {
+                headers,
+            },
+        });
+        await this.setupTransportLifecycle(transport, config.id);
+        await transport.start();
+        return transport;
+    }
+    async createStreamableHTTPTransport(config, requestHeaders) {
+        const url = config.url;
+        const headers = {
+            Accept: "text/event-stream, application/json",
+            ...config.headers,
+        };
+        // Add headers passed through from the request
+        if (requestHeaders) {
+            for (const key of STREAMABLE_HTTP_HEADERS_PASSTHROUGH) {
+                if (requestHeaders[key] !== undefined) {
+                    headers[key] = requestHeaders[key];
+                }
+            }
+        }
+        this.logger.info(`🚀 StreamableHTTP transport: url=${url}`);
+        const transport = new StreamableHTTPClientTransport(new URL(url), {
+            requestInit: {
+                headers,
+            },
+        });
+        await this.setupTransportLifecycle(transport, config.id);
+        await transport.start();
+        return transport;
+    }
+    async setupTransportLifecycle(transport, configId) {
+        // Set up event handlers without aggressive timeouts
+        // The original server didn't have connection timeouts, so we preserve that behavior
+        const originalOnClose = transport.onclose;
+        transport.onclose = () => {
+            this.logger.info(`Transport closed for ${configId}`);
+            if (originalOnClose) {
+                originalOnClose();
+            }
+        };
+        const originalOnError = transport.onerror;
+        transport.onerror = (error) => {
+            this.logger.error(`Transport error for ${configId}:`, error);
+            if (originalOnError) {
+                originalOnError(error);
+            }
+        };
+    }
+}

package/server/build/shared/index.js

@@ -0,0 +1,4 @@
+// Export all shared components for easy importing
+export { MCPProxyService } from "./MCPProxyService.js";
+export { TransportFactory } from "./TransportFactory.js";
+export { generateSessionId, validateServerConfig, ConsoleLogger, } from "./utils.js";

package/server/build/shared/types.js

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

package/server/build/shared/utils.js

@@ -0,0 +1,27 @@
+import { randomUUID } from "crypto";
+export function generateSessionId() {
+    return randomUUID();
+}
+export function validateServerConfig(config) {
+    if (!config.id || !config.type || !config.name) {
+        throw new Error("Invalid server configuration: id, type, and name are required");
+    }
+    if (config.type === "stdio" && !config.command) {
+        throw new Error("STDIO transport requires command");
+    }
+    if ((config.type === "sse" || config.type === "streamable-http") &&
+        !config.url) {
+        throw new Error("SSE and StreamableHTTP transports require URL");
+    }
+}
+export class ConsoleLogger {
+    info(message, ...args) {
+        console.log(`[INFO] ${message}`, ...args);
+    }
+    error(message, ...args) {
+        console.error(`[ERROR] ${message}`, ...args);
+    }
+    warn(message, ...args) {
+        console.warn(`[WARN] ${message}`, ...args);
+    }
+}

package/server/build/test-server.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import { TestServer } from "./testing/TestServer.js";
+import { MCPProxyService } from "./shared/MCPProxyService.js";
+import { DatabaseManager } from "./database/DatabaseManager.js";
+import { ConsoleLogger } from "./shared/utils.js";
+import { getDatabaseConfig } from "./database/utils.js";
+import { createServer } from "node:net";
+import { parseArgs } from "node:util";
+// Function to find an available port
+const findAvailablePort = async (startPort) => {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.listen(startPort, () => {
+            const port = server.address()?.port;
+            server.close(() => {
+                resolve(port);
+            });
+        });
+        server.on("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                // Port is in use, try the next one
+                findAvailablePort(startPort + 1)
+                    .then(resolve)
+                    .catch(reject);
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+};
+async function startTestServer() {
+    const logger = new ConsoleLogger();
+    // Parse command line arguments
+    const { values } = parseArgs({
+        args: process.argv.slice(2),
+        options: {
+            port: { type: "string", short: "p", default: "3002" },
+            host: { type: "string", short: "h", default: "localhost" },
+            env: { type: "string", short: "e", default: "development" },
+            config: { type: "string", short: "c" },
+            help: { type: "boolean", default: false },
+        },
+        allowPositionals: true,
+    });
+    if (values.help) {
+        console.log(`
+🧪 MCPJam Inspector Test Server
+
+Usage: node test-server.js [options]
+
+Options:
+  -p, --port <port>     Port to run the test server on (default: 3002)
+  -h, --host <host>     Host to bind the server to (default: localhost)
+  -e, --env <env>       Environment mode (default: development)
+  -c, --config <file>   Configuration file path
+  --help                Show this help message
+
+Environment Variables:
+  TEST_PORT            Override the default port
+  TEST_HOST            Override the default host
+  NODE_ENV             Set the environment mode
+  DATABASE_URL         Database connection string
+  LOG_LEVEL            Logging level (debug, info, warn, error)
+
+Examples:
+  node test-server.js --port 4000 --host 0.0.0.0
+  TEST_PORT=5000 node test-server.js
+  NODE_ENV=production node test-server.js
+    `);
+        process.exit(0);
+    }
+    try {
+        // Initialize core services
+        const mcpProxyService = new MCPProxyService({
+            logger,
+            maxConnections: 100, // Higher limit for test server
+        });
+        const dbConfig = getDatabaseConfig();
+        const database = new DatabaseManager(dbConfig);
+        await database.initialize();
+        // Determine port with fallback logic
+        const preferredPort = process.env.TEST_PORT
+            ? parseInt(process.env.TEST_PORT)
+            : parseInt(values.port);
+        const actualPort = await findAvailablePort(preferredPort);
+        // Create and start test server
+        const testServer = new TestServer({
+            port: actualPort,
+            host: process.env.TEST_HOST || values.host,
+            cors: values.env !== "production",
+            rateLimiting: true,
+            database: {
+                url: process.env.DATABASE_URL || "sqlite://test.db",
+                maxConnections: 10,
+                timeout: 5000,
+            },
+            logging: {
+                level: process.env.LOG_LEVEL || "info",
+                format: "json",
+                outputs: ["console"],
+            },
+        });
+        await testServer.start(mcpProxyService, database);
+        if (actualPort !== preferredPort) {
+            logger.info(`⚠️  Port ${preferredPort} was in use, using available port ${actualPort} instead`);
+        }
+        logger.info(`🧪 Test server started on http://${testServer.config.host}:${testServer.config.port}`);
+        logger.info(`📊 Health check available at http://${testServer.config.host}:${testServer.config.port}/api/test/health`);
+        logger.info(`🔍 Status endpoint available at http://${testServer.config.host}:${testServer.config.port}/api/test/status`);
+        logger.info(`🎯 Test execution endpoint available at http://${testServer.config.host}:${testServer.config.port}/api/test/run`);
+        // Graceful shutdown
+        const shutdown = async (signal) => {
+            logger.info(`🔄 Received ${signal}, shutting down test server...`);
+            try {
+                await testServer.stop();
+                await mcpProxyService.closeAllConnections();
+                await database.close();
+                logger.info("✅ Test server shutdown complete");
+                process.exit(0);
+            }
+            catch (error) {
+                logger.error("❌ Error during shutdown:", error);
+                process.exit(1);
+            }
+        };
+        process.on("SIGINT", () => shutdown("SIGINT"));
+        process.on("SIGTERM", () => shutdown("SIGTERM"));
+        // Handle unhandled promise rejections
+        process.on("unhandledRejection", (reason, promise) => {
+            logger.error("❌ Unhandled Rejection at:", promise, "reason:", reason);
+        });
+        process.on("uncaughtException", (error) => {
+            logger.error("❌ Uncaught Exception:", error);
+            process.exit(1);
+        });
+    }
+    catch (error) {
+        logger.error("❌ Failed to start test server:", error);
+        process.exit(1);
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    startTestServer();
+}

package/server/build/testing/HealthCheck.js

@@ -0,0 +1,42 @@
+export class HealthCheck {
+    mcpProxyService;
+    database;
+    logger;
+    constructor(mcpProxyService, database, logger) {
+        this.mcpProxyService = mcpProxyService;
+        this.database = database;
+        this.logger = logger;
+    }
+    getStatus() {
+        return {
+            testing: true,
+            status: "healthy",
+            version: process.env.npm_package_version || "0.3.5",
+            timestamp: new Date().toISOString(),
+        };
+    }
+    getDetailedStatus() {
+        return {
+            testing: true,
+            server: {
+                status: "running",
+                uptime: process.uptime(),
+                memory: process.memoryUsage(),
+                version: process.env.npm_package_version || "0.3.5",
+            },
+            connections: {
+                active: this.mcpProxyService.getActiveConnections().length,
+                list: this.mcpProxyService.getActiveConnections(),
+            },
+            database: {
+                connected: this.isDatabaseConnected(),
+                status: this.isDatabaseConnected() ? "connected" : "disconnected",
+            },
+            timestamp: new Date().toISOString(),
+        };
+    }
+    isDatabaseConnected() {
+        // Simple check - in a real implementation you might want to ping the database
+        return this.database !== null && this.database !== undefined;
+    }
+}

package/server/build/testing/TestExecutor.js

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