@mcpjam/inspector 0.3.8 → 0.8.0

package/server/build/mcpProxy.js

@@ -1,54 +0,0 @@
-import { isJSONRPCRequest } from "@modelcontextprotocol/sdk/types.js";
-function onClientError(error) {
-    console.error("Error from inspector client:", error);
-}
-function onServerError(error) {
-    if ((error?.message &&
-        error.message.includes("Error POSTing to endpoint (HTTP 404)")) ||
-        (error?.cause && JSON.stringify(error.cause).includes("ECONNREFUSED"))) {
-        console.error("Connection refused. Is the MCP server running?");
-    }
-    else {
-        console.error("Error from MCP server:", error);
-    }
-}
-export default function mcpProxy({ transportToClient, transportToServer, }) {
-    let transportToClientClosed = false;
-    let transportToServerClosed = false;
-    transportToClient.onmessage = (message) => {
-        transportToServer.send(message).catch((error) => {
-            // Send error response back to client if it was a request (has id) and connection is still open
-            if (isJSONRPCRequest(message) && !transportToClientClosed) {
-                const errorResponse = {
-                    jsonrpc: "2.0",
-                    id: message.id,
-                    error: {
-                        code: -32001,
-                        message: error.message,
-                        data: error,
-                    },
-                };
-                transportToClient.send(errorResponse).catch(onClientError);
-            }
-        });
-    };
-    transportToServer.onmessage = (message) => {
-        transportToClient.send(message).catch(onClientError);
-    };
-    transportToClient.onclose = () => {
-        if (transportToServerClosed) {
-            return;
-        }
-        transportToClientClosed = true;
-        transportToServer.close().catch(onServerError);
-    };
-    transportToServer.onclose = () => {
-        if (transportToClientClosed) {
-            return;
-        }
-        transportToServerClosed = true;
-        transportToClient.close().catch(onClientError);
-    };
-    transportToClient.onerror = onClientError;
-    transportToServer.onerror = onServerError;
-}

package/server/build/shared/MCPProxyService.js

@@ -1,221 +0,0 @@
-import { EventEmitter } from "events";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { TransportFactory } from "./TransportFactory.js";
-import { generateSessionId, ConsoleLogger } from "./utils.js";
-import mcpProxy from "../mcpProxy.js";
-export class MCPProxyService extends EventEmitter {
-    webAppTransports = new Map();
-    backingServerTransports = new Map();
-    connectionStatus = new Map();
-    cleanupInProgress = new Set();
-    transportFactory;
-    logger;
-    maxConnections;
-    constructor(options = {}) {
-        super();
-        this.logger = options.logger || new ConsoleLogger();
-        this.maxConnections = options.maxConnections || 50;
-        this.transportFactory = new TransportFactory({
-            logger: this.logger,
-        });
-    }
-    async createConnection(serverConfig, requestHeaders) {
-        if (this.backingServerTransports.size >= this.maxConnections) {
-            throw new Error(`Maximum connections reached (${this.maxConnections})`);
-        }
-        const sessionId = generateSessionId();
-        try {
-            this.logger.info(`Creating connection ${sessionId} for ${serverConfig.name}`);
-            // Update status to connecting
-            this.connectionStatus.set(sessionId, {
-                id: sessionId,
-                status: "connecting",
-                lastActivity: new Date(),
-                errorCount: 0,
-            });
-            // Create transport
-            const transport = await this.transportFactory.createTransport(serverConfig, requestHeaders);
-            // Store transport
-            this.backingServerTransports.set(sessionId, transport);
-            // Set up transport event handlers
-            this.setupTransportEvents(sessionId, transport);
-            // Update status to connected
-            this.updateConnectionStatus(sessionId, "connected");
-            this.emit("connection", sessionId, serverConfig);
-            return sessionId;
-        }
-        catch (error) {
-            this.updateConnectionStatus(sessionId, "error");
-            this.logger.error(`Failed to create connection ${sessionId}:`, error);
-            throw error;
-        }
-    }
-    getActiveConnections() {
-        return Array.from(this.backingServerTransports.keys());
-    }
-    getConnectionStatus(sessionId) {
-        return this.connectionStatus.get(sessionId);
-    }
-    getAllConnectionStatuses() {
-        return Array.from(this.connectionStatus.values());
-    }
-    async sendMessage(sessionId, message) {
-        const transport = this.backingServerTransports.get(sessionId);
-        if (!transport) {
-            throw new Error(`No transport found for session: ${sessionId}`);
-        }
-        try {
-            this.updateConnectionStatus(sessionId, "connected");
-            await transport.send(message);
-        }
-        catch (error) {
-            this.incrementErrorCount(sessionId);
-            this.logger.error(`Message failed for session ${sessionId}:`, error);
-            throw error;
-        }
-    }
-    getTransport(sessionId) {
-        return this.backingServerTransports.get(sessionId);
-    }
-    getWebAppTransport(sessionId) {
-        return this.webAppTransports.get(sessionId);
-    }
-    setWebAppTransport(sessionId, transport) {
-        this.webAppTransports.set(sessionId, transport);
-        this.logger.info(`Web app transport set for session ${sessionId}`);
-    }
-    removeWebAppTransport(sessionId) {
-        this.webAppTransports.delete(sessionId);
-        this.logger.info(`Web app transport removed for session ${sessionId}`);
-    }
-    async closeConnection(sessionId) {
-        // Prevent duplicate cleanup calls
-        if (this.cleanupInProgress.has(sessionId)) {
-            return;
-        }
-        this.cleanupInProgress.add(sessionId);
-        try {
-            const transport = this.backingServerTransports.get(sessionId);
-            if (transport) {
-                try {
-                    await transport.close();
-                }
-                catch (error) {
-                    this.logger.error(`Error closing connection ${sessionId}:`, error);
-                }
-            }
-            this.backingServerTransports.delete(sessionId);
-            this.webAppTransports.delete(sessionId);
-            this.connectionStatus.delete(sessionId);
-            this.emit("disconnection", sessionId);
-            this.logger.info(`🧹 Cleaning up transports for session ${sessionId}`);
-        }
-        finally {
-            this.cleanupInProgress.delete(sessionId);
-        }
-    }
-    async closeAllConnections() {
-        const closePromises = Array.from(this.backingServerTransports.keys()).map((sessionId) => this.closeConnection(sessionId));
-        await Promise.all(closePromises);
-        this.logger.info(`All connections closed (${closePromises.length} total)`);
-    }
-    updateConnectionStatus(sessionId, status) {
-        const current = this.connectionStatus.get(sessionId);
-        if (current) {
-            current.status = status;
-            current.lastActivity = new Date();
-            this.connectionStatus.set(sessionId, current);
-        }
-    }
-    incrementErrorCount(sessionId) {
-        const current = this.connectionStatus.get(sessionId);
-        if (current) {
-            current.errorCount += 1;
-            this.connectionStatus.set(sessionId, current);
-        }
-    }
-    setupTransportEvents(sessionId, transport) {
-        // Store original handlers to preserve existing functionality
-        const originalOnClose = transport.onclose;
-        const originalOnError = transport.onerror;
-        transport.onclose = () => {
-            this.logger.info(`Transport closed for session ${sessionId}`);
-            this.updateConnectionStatus(sessionId, "disconnected");
-            this.emit("disconnection", sessionId);
-            // Call original handler if it exists
-            if (originalOnClose) {
-                originalOnClose();
-            }
-        };
-        transport.onerror = (error) => {
-            this.logger.error(`Transport error for session ${sessionId}:`, error);
-            this.updateConnectionStatus(sessionId, "error");
-            this.incrementErrorCount(sessionId);
-            this.emit("error", sessionId, error);
-            // Call original handler if it exists
-            if (originalOnError) {
-                originalOnError(error);
-            }
-        };
-    }
-    // Helper methods for StreamableHTTP transport handling
-    async createStreamableHTTPConnection(serverConfig, requestHeaders) {
-        const sessionId = await this.createConnection(serverConfig, requestHeaders);
-        const webAppTransport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: () => sessionId,
-            onsessioninitialized: (newSessionId) => {
-                this.logger.info(`✨ Created streamable web app transport ${newSessionId}`);
-                this.setWebAppTransport(newSessionId, webAppTransport);
-                // Set up proxy between web app transport and backing server transport
-                const backingTransport = this.getTransport(newSessionId);
-                if (backingTransport) {
-                    mcpProxy({
-                        transportToClient: webAppTransport,
-                        transportToServer: backingTransport,
-                    });
-                }
-                // Set up cleanup handler
-                webAppTransport.onclose = () => {
-                    this.closeConnection(newSessionId);
-                };
-            },
-        });
-        await webAppTransport.start();
-        return { sessionId, webAppTransport };
-    }
-    // Helper method for SSE transport handling
-    async createSSEConnection(serverConfig, res, requestHeaders) {
-        const connectionId = await this.createConnection(serverConfig, requestHeaders);
-        const webAppTransport = new SSEServerTransport("/message", res);
-        const sessionId = webAppTransport.sessionId;
-        this.setWebAppTransport(sessionId, webAppTransport);
-        // Set up cleanup handler
-        webAppTransport.onclose = () => {
-            this.closeConnection(connectionId);
-        };
-        await webAppTransport.start();
-        // Set up proxy between web app transport and backing server transport
-        const backingTransport = this.getTransport(connectionId);
-        if (backingTransport) {
-            // Special handling for STDIO stderr
-            if (backingTransport instanceof StdioClientTransport) {
-                backingTransport.stderr?.on("data", (chunk) => {
-                    webAppTransport.send({
-                        jsonrpc: "2.0",
-                        method: "stderr",
-                        params: {
-                            data: chunk.toString(),
-                        },
-                    });
-                });
-            }
-            mcpProxy({
-                transportToClient: webAppTransport,
-                transportToServer: backingTransport,
-            });
-        }
-        return { sessionId, webAppTransport };
-    }
-}

package/server/build/shared/TransportFactory.js

@@ -1,130 +0,0 @@
-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

@@ -1,4 +0,0 @@
-// 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

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

package/server/build/shared/utils.js

@@ -1,27 +0,0 @@
-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

@@ -1,145 +0,0 @@
-#!/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

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