@mcpjam/inspector 0.3.4 → 0.3.6

package/server/build/database/utils.js

@@ -0,0 +1,86 @@
+/**
+ * Database utilities for MCPJam Inspector
+ * Basic utilities for local SQLite database setup
+ */
+import { mkdir, access } from "fs/promises";
+import { dirname } from "path";
+import { homedir } from "os";
+import { join } from "path";
+/**
+ * Ensures the .mcpjam directory exists in the user's home directory
+ */
+export async function ensureMCPJamDirectory() {
+    const mcpjamDir = join(homedir(), ".mcpjam");
+    try {
+        await access(mcpjamDir);
+    }
+    catch {
+        // Directory doesn't exist, create it
+        await mkdir(mcpjamDir, { recursive: true });
+        console.log(`📁 Created MCPJam directory: ${mcpjamDir}`);
+    }
+    return mcpjamDir;
+}
+/**
+ * Ensures the directory for a given file path exists
+ */
+export async function ensureDirectoryExists(filePath) {
+    const dir = dirname(filePath);
+    try {
+        await access(dir);
+    }
+    catch {
+        await mkdir(dir, { recursive: true });
+    }
+}
+/**
+ * Gets the resolved database path - THE SINGLE SOURCE OF TRUTH
+ * Priority: MCPJAM_DB_PATH env var > default ~/.mcpjam/data.db
+ */
+export function getResolvedDatabasePath() {
+    return process.env.MCPJAM_DB_PATH || join(homedir(), ".mcpjam", "data.db");
+}
+/**
+ * Environment configuration helper
+ */
+export function getDatabaseConfig() {
+    return {
+        localPath: getResolvedDatabasePath(),
+    };
+}
+/**
+ * Checks if the database file exists
+ */
+export async function databaseExists(databasePath) {
+    try {
+        await access(databasePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Database connection test
+ */
+export async function testDatabaseConnection(config) {
+    try {
+        const { createClient } = await import("@libsql/client");
+        // Use the single source of truth for database path
+        const dbPath = config?.localPath || getResolvedDatabasePath();
+        await ensureDirectoryExists(dbPath);
+        const client = createClient({
+            url: `file:${dbPath}`,
+        });
+        // Test the connection with a simple query
+        await client.execute("SELECT 1");
+        client.close();
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

package/server/build/index.js

@@ -3,15 +3,14 @@ import cors from "cors";
 import { parseArgs } from "node:util";
 import { parse as shellParseArgs } from "shell-quote";
 import { createServer } from "node:net";
-import { SSEClientTransport, SseError, } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { SseError } from "@modelcontextprotocol/sdk/client/sse.js";
+import { getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
 import express from "express";
-import { findActualExecutable } from "spawn-rx";
-import mcpProxy from "./mcpProxy.js";
 import { randomUUID } from "node:crypto";
+import { DatabaseManager } from "./database/DatabaseManager.js";
+import { createDatabaseRoutes } from "./database/routes.js";
+import { getDatabaseConfig } from "./database/utils.js";
+import { MCPProxyService, ConsoleLogger } from "./shared/index.js";
 const SSE_HEADERS_PASSTHROUGH = ["authorization"];
 const STREAMABLE_HTTP_HEADERS_PASSTHROUGH = [
     "authorization",
@@ -22,6 +21,9 @@ const defaultEnvironment = {
     ...getDefaultEnvironment(),
     ...(process.env.MCP_ENV_VARS ? JSON.parse(process.env.MCP_ENV_VARS) : {}),
 };
+const serverConfigs = process.env.MCP_SERVER_CONFIGS
+    ? JSON.parse(process.env.MCP_SERVER_CONFIGS)
+    : null;
 const { values } = parseArgs({
     args: process.argv.slice(2),
     options: {
@@ -35,79 +37,86 @@ app.use((req, res, next) => {
     res.header("Access-Control-Expose-Headers", "mcp-session-id");
     next();
 });
-const webAppTransports = new Map(); // Transports by sessionId
-const backingServerTransports = new Map();
-const createTransport = async (req) => {
+// Initialize database
+let databaseManager = null;
+const initializeDatabase = async () => {
+    try {
+        const dbConfig = getDatabaseConfig();
+        databaseManager = new DatabaseManager(dbConfig);
+        await databaseManager.initialize();
+        // Add database routes after successful initialization
+        app.use("/api/db", express.json({ limit: "10mb" }), // JSON middleware only for database routes
+        (req, res, next) => {
+            if (!databaseManager) {
+                res.status(503).json({
+                    success: false,
+                    error: "Database not available",
+                });
+                return;
+            }
+            next();
+        }, createDatabaseRoutes(databaseManager));
+        console.log("✅ Database API routes registered");
+    }
+    catch (error) {
+        console.error("❌ Failed to initialize database:", error);
+        // Don't exit the process - continue without database functionality
+    }
+};
+// Initialize MCPProxyService
+const mcpProxyService = new MCPProxyService({
+    logger: new ConsoleLogger(),
+    maxConnections: 50,
+});
+// Helper function to convert request query to ServerConfig
+const createServerConfigFromRequest = (req) => {
     const query = req.query;
     const transportType = query.transportType;
+    const config = {
+        id: randomUUID(),
+        type: transportType,
+        name: `server-${Date.now()}`,
+    };
     if (transportType === "stdio") {
-        const command = query.command;
-        const origArgs = shellParseArgs(query.args);
-        const queryEnv = query.env ? JSON.parse(query.env) : {};
-        const env = { ...process.env, ...defaultEnvironment, ...queryEnv };
-        const { cmd, args } = findActualExecutable(command, origArgs);
-        console.log(`🚀 Stdio transport: command=${cmd}, args=${args}`);
-        const transport = new StdioClientTransport({
-            command: cmd,
-            args,
-            env,
-            stderr: "pipe",
-        });
-        await transport.start();
-        return transport;
-    }
-    else if (transportType === "sse") {
-        const url = query.url;
-        const headers = {
-            Accept: "text/event-stream",
-        };
-        for (const key of SSE_HEADERS_PASSTHROUGH) {
-            if (req.headers[key] === undefined) {
-                continue;
+        config.command = query.command;
+        config.args = query.args
+            ? shellParseArgs(query.args)
+            : undefined;
+        // Safely parse env - only if it's a valid JSON string
+        if (query.env) {
+            try {
+                config.env = JSON.parse(query.env);
+            }
+            catch (error) {
+                console.warn(`Failed to parse env as JSON: ${query.env}, using empty object`);
+                config.env = {};
             }
-            const value = req.headers[key];
-            headers[key] = Array.isArray(value) ? value[value.length - 1] : value;
         }
-        const transport = new SSEClientTransport(new URL(url), {
-            eventSourceInit: {
-                fetch: (url, init) => fetch(url, { ...init, headers }),
-            },
-            requestInit: {
-                headers,
-            },
-        });
-        await transport.start();
-        return transport;
     }
-    else if (transportType === "streamable-http") {
-        const headers = {
-            Accept: "text/event-stream, application/json",
-        };
-        for (const key of STREAMABLE_HTTP_HEADERS_PASSTHROUGH) {
-            if (req.headers[key] === undefined) {
-                continue;
-            }
-            const value = req.headers[key];
+    else if (transportType === "sse" || transportType === "streamable-http") {
+        config.url = query.url;
+    }
+    return config;
+};
+// Helper function to extract headers for transport
+const extractRequestHeaders = (req) => {
+    const headers = {};
+    const headersToPass = req.query.transportType === "sse"
+        ? SSE_HEADERS_PASSTHROUGH
+        : STREAMABLE_HTTP_HEADERS_PASSTHROUGH;
+    for (const key of headersToPass) {
+        const value = req.headers[key];
+        if (value !== undefined) {
             headers[key] = Array.isArray(value) ? value[value.length - 1] : value;
         }
-        const transport = new StreamableHTTPClientTransport(new URL(query.url), {
-            requestInit: {
-                headers,
-            },
-        });
-        await transport.start();
-        return transport;
-    }
-    else {
-        console.error(`❌ Invalid transport type: ${transportType}`);
-        throw new Error("Invalid transport type specified");
     }
+    return headers;
 };
 app.get("/mcp", async (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
     console.log(`📥 Received GET message for sessionId ${sessionId}`);
     try {
-        const transport = webAppTransports.get(sessionId);
+        const transport = mcpProxyService.getWebAppTransport(sessionId);
         if (!transport) {
             res.status(404).end("Session not found");
             return;
@@ -127,9 +136,14 @@ app.post("/mcp", async (req, res) => {
     if (!sessionId) {
         try {
             console.log("🔄 New streamable-http connection");
-            let backingServerTransport;
+            // Create server config and headers from request
+            const serverConfig = createServerConfigFromRequest(req);
+            const requestHeaders = extractRequestHeaders(req);
             try {
-                backingServerTransport = await createTransport(req);
+                // Use MCPProxyService to create the streamable HTTP connection
+                const { sessionId: newSessionId, webAppTransport } = await mcpProxyService.createStreamableHTTPConnection(serverConfig, requestHeaders);
+                console.log(`✨ Connected MCP client to backing server transport for session ${newSessionId}`);
+                await webAppTransport.handleRequest(req, res, req.body);
             }
             catch (error) {
                 if (error instanceof SseError && error.code === 401) {
@@ -139,26 +153,6 @@ app.post("/mcp", async (req, res) => {
                 }
                 throw error;
             }
-            const webAppTransport = new StreamableHTTPServerTransport({
-                sessionIdGenerator: randomUUID,
-                onsessioninitialized: (newSessionId) => {
-                    console.log("✨ Created streamable web app transport " + newSessionId);
-                    webAppTransports.set(newSessionId, webAppTransport);
-                    backingServerTransports.set(newSessionId, backingServerTransport);
-                    console.log(`✨ Connected MCP client to backing server transport for session ${newSessionId}`);
-                    mcpProxy({
-                        transportToClient: webAppTransport,
-                        transportToServer: backingServerTransport,
-                    });
-                    webAppTransport.onclose = () => {
-                        console.log(`🧹 Cleaning up transports for session ${newSessionId}`);
-                        webAppTransports.delete(newSessionId);
-                        backingServerTransports.delete(newSessionId);
-                    };
-                },
-            });
-            await webAppTransport.start();
-            await webAppTransport.handleRequest(req, res, req.body);
         }
         catch (error) {
             console.error("❌ Error in /mcp POST route:", error);
@@ -167,7 +161,7 @@ app.post("/mcp", async (req, res) => {
     }
     else {
         try {
-            const transport = webAppTransports.get(sessionId);
+            const transport = mcpProxyService.getWebAppTransport(sessionId);
             if (!transport) {
                 res.status(404).end("Transport not found for sessionId " + sessionId);
             }
@@ -184,33 +178,12 @@ app.post("/mcp", async (req, res) => {
 app.get("/stdio", async (req, res) => {
     try {
         console.log("🔄 New stdio/sse connection");
-        const webAppTransport = new SSEServerTransport("/message", res);
-        const sessionId = webAppTransport.sessionId;
-        webAppTransports.set(sessionId, webAppTransport);
+        // Create server config and headers from request
+        const serverConfig = createServerConfigFromRequest(req);
+        const requestHeaders = extractRequestHeaders(req);
         try {
-            const backingServerTransport = await createTransport(req);
-            backingServerTransports.set(sessionId, backingServerTransport);
-            webAppTransport.onclose = () => {
-                console.log(`🧹 Cleaning up transports for session ${sessionId}`);
-                webAppTransports.delete(sessionId);
-                backingServerTransports.delete(sessionId);
-            };
-            await webAppTransport.start();
-            if (backingServerTransport instanceof StdioClientTransport) {
-                backingServerTransport.stderr.on("data", (chunk) => {
-                    webAppTransport.send({
-                        jsonrpc: "2.0",
-                        method: "stderr",
-                        params: {
-                            data: chunk.toString(),
-                        },
-                    });
-                });
-            }
-            mcpProxy({
-                transportToClient: webAppTransport,
-                transportToServer: backingServerTransport,
-            });
+            // Use MCPProxyService to create the SSE connection (handles STDIO stderr automatically)
+            const { sessionId } = await mcpProxyService.createSSEConnection(serverConfig, res, requestHeaders);
             console.log(`✨ Connected MCP client to backing server transport for session ${sessionId}`);
         }
         catch (error) {
@@ -230,22 +203,12 @@ app.get("/stdio", async (req, res) => {
 app.get("/sse", async (req, res) => {
     try {
         console.log("🔄 New sse connection");
-        const webAppTransport = new SSEServerTransport("/message", res);
-        const sessionId = webAppTransport.sessionId;
-        webAppTransports.set(sessionId, webAppTransport);
+        // Create server config and headers from request
+        const serverConfig = createServerConfigFromRequest(req);
+        const requestHeaders = extractRequestHeaders(req);
         try {
-            const backingServerTransport = await createTransport(req);
-            backingServerTransports.set(sessionId, backingServerTransport);
-            webAppTransport.onclose = () => {
-                console.log(`🧹 Cleaning up transports for session ${sessionId}`);
-                webAppTransports.delete(sessionId);
-                backingServerTransports.delete(sessionId);
-            };
-            await webAppTransport.start();
-            mcpProxy({
-                transportToClient: webAppTransport,
-                transportToServer: backingServerTransport,
-            });
+            // Use MCPProxyService to create the SSE connection
+            const { sessionId } = await mcpProxyService.createSSEConnection(serverConfig, res, requestHeaders);
             console.log(`✨ Connected MCP client to backing server transport for session ${sessionId}`);
         }
         catch (error) {
@@ -266,7 +229,7 @@ app.post("/message", async (req, res) => {
     try {
         const sessionId = req.query.sessionId;
         console.log(`📥 Received message for sessionId ${sessionId}`);
-        const transport = webAppTransports.get(sessionId);
+        const transport = mcpProxyService.getWebAppTransport(sessionId);
         if (!transport) {
             res.status(404).end("Session not found");
             return;
@@ -289,6 +252,7 @@ app.get("/config", (req, res) => {
             defaultEnvironment,
             defaultCommand: values.env,
             defaultArgs: values.args,
+            serverConfigs,
         });
     }
     catch (error) {
@@ -296,6 +260,7 @@ app.get("/config", (req, res) => {
         res.status(500).json(error);
     }
 });
+// Database API routes - will be added after database initialization
 // Function to find an available port
 const findAvailablePort = async (startPort) => {
     return new Promise((resolve, reject) => {
@@ -331,6 +296,8 @@ app.get("/port", (req, res) => {
 // Start server with dynamic port finding
 const startServer = async () => {
     try {
+        // Initialize database first
+        await initializeDatabase();
         const availablePort = await findAvailablePort(Number(PORT));
         actualPort = availablePort;
         const server = app.listen(availablePort);
@@ -344,6 +311,17 @@ const startServer = async () => {
             console.error(`❌ Server error: ${err.message}`);
             process.exit(1);
         });
+        // Graceful shutdown
+        process.on("SIGINT", async () => {
+            console.log("\n🔄 Shutting down server...");
+            server.close();
+            await mcpProxyService.closeAllConnections();
+            if (databaseManager) {
+                await databaseManager.close();
+                console.log("✅ Database connection closed");
+            }
+            process.exit(0);
+        });
     }
     catch (error) {
         console.error(`❌ Failed to start server: ${error}`);

package/server/build/shared/MCPProxyService.js

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