@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.0

package/dist/server/src/utils/transports/stdio-transport.js

@@ -1,37 +1,10 @@
-import { spawn } from 'child_process';
-import { PassThrough } from 'stream';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { logger } from '../logger.js';
-// Re-implement ReadBuffer as it is not exported from SDK root
-class ReadBuffer {
-    _buffer;
-    append(chunk) {
-        this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
-    }
-    readMessage() {
-        if (!this._buffer) {
-            return null;
-        }
-        const index = this._buffer.indexOf('\n');
-        if (index === -1) {
-            return null;
-        }
-        const line = this._buffer.toString('utf8', 0, index).replace(/\r$/, '');
-        this._buffer = this._buffer.subarray(index + 1);
-        try {
-            return JSON.parse(line);
-        }
-        catch {
-            return null;
-        }
-    }
-    clear() {
-        this._buffer = undefined;
-    }
-}
+import { PassThrough } from 'stream';
 /**
  * A transport implementation for communicating with MCP (Model Context Protocol) servers
- * via standard input/output streams. This transport spawns a child process and establishes
- * bidirectional communication using stdin/stdout for JSON-RPC message exchange.
+ * via standard input/output streams. This transport wraps the official SDK's StdioClientTransport
+ * and provides consistent logging and integration with the MCP Hub Lite system.
  *
  * The StdioTransport handles:
  * - Cross-platform process spawning (including Windows batch file compatibility)
@@ -46,21 +19,11 @@ class ReadBuffer {
  * @implements {Transport}
  */
 export class StdioTransport {
-    _process;
-    _readBuffer = new ReadBuffer();
-    _stderrStream = null;
-    _serverParams;
+    _transport;
     _serverName;
-    _serverId;
+    _compositeKey;
     _logStorage;
-    /**
-     * Gets the process ID of the spawned child process.
-     *
-     * @returns {number | undefined} The PID of the child process, or undefined if not started
-     */
-    get pid() {
-        return this._process?.pid;
-    }
+    _stderrStream = null;
     onclose;
     onerror;
     onmessage;
@@ -74,251 +37,107 @@ export class StdioTransport {
      * @param {StdioTransportOptions} [options] - Additional options for the transport
      */
     constructor(server, serverName, options) {
-        this._serverParams = server;
+        // Convert our server parameters to match SDK format
+        const sdkParams = {
+            command: server.command,
+            args: server.args,
+            env: server.env,
+            stderr: 'pipe', // Always use pipe for stderr to enable logging
+            cwd: server.cwd
+        };
+        this._transport = new StdioClientTransport(sdkParams);
         this._serverName = serverName;
-        this._serverId = options?.serverId;
+        this._compositeKey = options?.compositeKey;
         this._logStorage = options?.logStorage;
-        if (server.stderr === 'pipe') {
-            this._stderrStream = new PassThrough();
-        }
+        this._stderrStream = new PassThrough();
     }
     /**
      * Starts the transport by spawning the child process and establishing communication channels.
      *
-     * This method handles platform-specific considerations:
-     * - On Windows, it automatically wraps batch commands (like npx, npm, etc.) with cmd.exe /c
-     * - Sets up proper stdio configuration based on the server parameters
-     * - Configures event listeners for process lifecycle events
-     * - Establishes data flow for stdout and stderr handling
+     * This method delegates to the SDK's StdioClientTransport.start() method which handles:
+     * - Platform-specific process spawning (including Windows batch file compatibility)
+     * - Proper stdio configuration
+     * - Event listeners for process lifecycle events
+     * - Data flow for stdout and stderr handling
      *
      * @returns {Promise<void>} Resolves when the child process is successfully spawned
      * @throws {Error} If the transport is already started
      */
     async start() {
-        if (this._process) {
-            throw new Error('StdioTransport already started!');
-        }
-        let command = this._serverParams.command;
-        let args = this._serverParams.args ?? [];
-        // Windows compatibility: Batch files (npx, npm, etc.) need cmd.exe /c to run with shell: false
-        if (process.platform === 'win32') {
-            const knownBatchCommands = ['npx', 'npm', 'pnpm', 'yarn', 'uvx'];
-            if (knownBatchCommands.includes(command) ||
-                command.endsWith('.cmd') ||
-                command.endsWith('.bat')) {
-                // Use cmd.exe /c to execute the batch file
-                args = ['/c', command, ...args];
-                command = 'cmd.exe';
-            }
-        }
-        return new Promise((resolve, reject) => {
-            this._process = spawn(command, args, {
-                env: { ...process.env, ...this._serverParams.env },
-                stdio: [
-                    'pipe',
-                    'pipe',
-                    this._serverParams.stderr === 'pipe' ? 'pipe' : this._serverParams.stderr || 'inherit'
-                ],
-                shell: false,
-                windowsHide: true, // Force hide window on Windows
-                cwd: this._serverParams.cwd
-            });
-            this._process.on('error', (error) => {
-                reject(error);
-                this.onerror?.(error);
-            });
-            this._process.on('spawn', () => {
-                resolve();
-            });
-            this._process.on('close', () => {
-                this._process = undefined;
-                this.onclose?.();
-            });
-            this._process.stdin?.on('error', (error) => {
-                this.onerror?.(error);
-            });
-            this._process.stdout?.on('data', (chunk) => {
-                const dataStr = chunk.toString('utf8');
-                // Forward raw stdout data
-                this.onstdout?.(dataStr);
-                // Don't log raw JSON-RPC communication to avoid log noise
-                // Only need to view raw communication during development debugging
-                // Parse JSON-RPC messages
-                this._readBuffer.append(chunk);
-                this.processReadBuffer();
-            });
-            this._process.stdout?.on('error', (error) => {
-                this.onerror?.(error);
-            });
-            /**
-             * Handles stderr data with common processing logic.
-             *
-             * @param chunk - The stderr data chunk
-             * @param writeToStream - Whether to write data to the PassThrough stream
-             */
-            const handleStderrData = (chunk, writeToStream = false) => {
-                const dataStr = chunk.toString('utf8');
+        // Set up event handlers before starting
+        this._transport.onmessage = (message) => {
+            this.onmessage?.(message);
+        };
+        this._transport.onerror = (error) => {
+            this.onerror?.(error);
+        };
+        this._transport.onclose = () => {
+            this.onclose?.();
+        };
+        // Start the underlying transport
+        await this._transport.start();
+        // Handle stderr data by listening to the transport's stderr stream
+        if (this._transport.stderr) {
+            this._transport.stderr.on('data', (chunk) => {
+                const dataStr = chunk.toString('utf8').trim();
+                if (!dataStr)
+                    return;
                 // Forward raw stderr data
                 this.onstderr?.(dataStr);
-                const trimmedData = dataStr.trim();
-                let logLevel = 'info';
-                // Identify log levels by keywords: only explicit error/warning markers
-                // use corresponding levels, everything else defaults to info
-                const lowerData = trimmedData.toLowerCase();
-                // Error level keywords
-                if (lowerData.includes('error') ||
-                    lowerData.includes('err') ||
-                    lowerData.includes('exception') ||
-                    lowerData.includes('fatal') ||
-                    lowerData.includes('critical')) {
-                    logLevel = 'error';
-                }
-                // Warn level keywords
-                else if (lowerData.includes('warn') ||
-                    lowerData.includes('wrn') ||
-                    lowerData.includes('warning') ||
-                    lowerData.includes('deprecation') ||
-                    lowerData.includes('deprecated')) {
-                    logLevel = 'warn';
+                // Log stderr output (per MCP spec, stderr is not necessarily errors)
+                const serverIdentifier = this._compositeKey || this._serverName || 'Unknown Server';
+                logger.serverLog('info', serverIdentifier, dataStr, { pid: this.pid });
+                if (this._logStorage && this._compositeKey) {
+                    this._logStorage.append(this._compositeKey, 'info', dataStr);
                 }
-                if (this._serverName) {
-                    logger.serverLog(logLevel, this._serverName, trimmedData, {
-                        pid: this._process?.pid
-                    });
+                // Also write to our PassThrough stream for compatibility
+                // Guard against write after end during close() race condition
+                if (this._stderrStream && !this._stderrStream.writableEnded) {
+                    this._stderrStream.write(chunk);
                 }
-                else {
-                    logger.serverLog(logLevel, 'Unknown Server', trimmedData, {
-                        pid: this._process?.pid
-                    });
-                }
-                // Store in logStorage for frontend display if available
-                if (this._logStorage && this._serverId) {
-                    this._logStorage.append(this._serverId, logLevel, `[${this._serverName || 'Unknown Server'}] [STDERR] ${trimmedData}`);
-                }
-                // Optionally write to PassThrough stream if configured
-                if (writeToStream) {
-                    this._stderrStream?.write(chunk);
-                }
-            };
-            if (this._stderrStream && this._process.stderr) {
-                this._process.stderr.on('data', (chunk) => {
-                    handleStderrData(chunk, true); // Write to PassThrough stream for piped stderr
-                });
-            }
-            else if (this._process.stderr) {
-                // If stderr is not in pipe mode, listen directly
-                this._process.stderr.on('data', (chunk) => {
-                    handleStderrData(chunk, false); // No PassThrough stream for non-piped stderr
-                });
-            }
-        });
+            });
+        }
     }
     /**
      * Gets the stderr stream for the child process.
      *
-     * Returns a PassThrough stream if stderr is configured as 'pipe', otherwise returns
-     * the actual stderr stream from the child process, or null if no stderr is available.
+     * Returns our PassThrough stream that captures stderr data.
      *
-     * @returns {PassThrough | NodeJS.ReadableStream | null} The stderr stream or null
+     * @returns {PassThrough | null} The stderr stream or null
      */
     get stderr() {
-        return this._stderrStream ?? this._process?.stderr ?? null;
+        return this._stderrStream;
     }
     /**
-     * Processes the internal read buffer to extract and dispatch JSON-RPC messages.
-     *
-     * This method continuously reads complete JSON-RPC messages from the buffer
-     * and dispatches them to the onmessage callback. It handles partial messages
-     * by leaving incomplete data in the buffer for future processing.
-     *
-     * The method uses a while loop to process all available complete messages
-     * in a single call, ensuring efficient message handling without blocking.
+     * Gets the process ID of the spawned child process.
      *
-     * @private
+     * @returns {number | undefined} The PID of the child process, or undefined if not started
      */
-    processReadBuffer() {
-        while (true) {
-            try {
-                const message = this._readBuffer.readMessage();
-                if (message === null) {
-                    break;
-                }
-                this.onmessage?.(message);
-            }
-            catch (error) {
-                this.onerror?.(error);
-            }
-        }
+    get pid() {
+        return this._transport.pid ?? undefined;
     }
     /**
      * Closes the transport by gracefully terminating the child process.
      *
-     * This method implements a graceful shutdown sequence:
-     * 1. Sends SIGTERM to allow the child process to clean up
-     * 2. Waits up to 5 seconds for graceful termination
-     * 3. Forces termination with SIGKILL if the process doesn't exit
-     * 4. Cleans up internal state and resolves the promise
-     *
-     * The method ensures proper cleanup of the read buffer and handles
-     * any errors that occur during the shutdown process.
+     * This method delegates to the SDK's StdioClientTransport.close() method which handles:
+     * - Graceful shutdown sequence with SIGTERM/SIGKILL
+     * - Proper cleanup of internal state
      *
      * @returns {Promise<void>} Resolves when the transport is fully closed
      */
     async close() {
-        if (this._process) {
-            return new Promise((resolve) => {
-                // Listen for child process exit events
-                const cleanup = () => {
-                    this._process = undefined;
-                    this._readBuffer.clear();
-                    resolve();
-                };
-                if (this._process) {
-                    this._process.once('close', cleanup);
-                    this._process.once('exit', cleanup);
-                    // Send SIGTERM signal to give child process a chance to shut down gracefully
-                    try {
-                        this._process.kill('SIGTERM');
-                        // Set timeout protection to force kill if child process doesn't exit within 5 seconds
-                        const timeout = setTimeout(() => {
-                            if (this._process) {
-                                logger.warn('Child process did not exit gracefully, force killing...');
-                                this._process.kill('SIGKILL');
-                            }
-                        }, 5000);
-                        // Ensure timeout timer is cleared after process exits
-                        this._process.once('close', () => clearTimeout(timeout));
-                        this._process.once('exit', () => clearTimeout(timeout));
-                    }
-                    catch (error) {
-                        logger.error('Error closing stdio transport:', error);
-                        cleanup();
-                    }
-                }
-                else {
-                    // Process is already undefined, just resolve
-                    resolve();
-                }
-            });
-        }
-        this._readBuffer.clear();
+        await this._transport.close();
+        this._stderrStream?.end();
     }
     /**
      * Sends a JSON-RPC message to the child process via stdin.
      *
-     * This method serializes the message to JSON, appends a newline character,
-     * and writes it to the child process's stdin stream. It validates that
-     * the transport is connected before attempting to send the message.
+     * This method delegates to the SDK's StdioClientTransport.send() method.
      *
      * @param {JSONRPCMessage} message - The JSON-RPC message to send
      * @returns {Promise<void>} Resolves when the message is written to stdin
-     * @throws {Error} If the transport is not connected (no active child process)
      */
     async send(message) {
-        if (!this._process?.stdin) {
-            throw new Error('Not connected');
-        }
-        const json = JSON.stringify(message) + '\n';
-        this._process.stdin.write(json);
+        await this._transport.send(message);
     }
 }

package/dist/server/src/utils/transports/streamable-http-transport.d.ts

@@ -29,6 +29,7 @@ export declare class StreamableHttpTransport implements Transport {
     private url;
     private headers;
     private timeout;
+    private proxy?;
     /**
      * Internal reference to the underlying MCP SDK transport instance
      * @private
@@ -40,6 +41,16 @@ export declare class StreamableHttpTransport implements Transport {
      * @private
      */
     private isClosing;
+    /**
+     * Server name for logging context
+     * @private
+     */
+    private _serverName?;
+    /**
+     * Composite key (serverName-serverIndex) for logging context
+     * @private
+     */
+    private _compositeKey?;
     /**
      * Event handler called when a JSON-RPC message is received from the server
      * @public
@@ -63,8 +74,20 @@ export declare class StreamableHttpTransport implements Transport {
      *                 Commonly used for authentication tokens, API keys, or custom headers
      * @param timeout - Request timeout in milliseconds (default: 30000 = 30 seconds)
      *                  Controls how long to wait for HTTP responses before timing out
+     * @param proxy - Optional proxy configuration
+     * @param serverName - Optional server name for logging
+     * @param compositeKey - Optional composite key (serverName-serverIndex) for logging
+     */
+    constructor(url: string, headers?: Record<string, string>, timeout?: number, proxy?: {
+        url: string;
+    } | undefined, serverName?: string, compositeKey?: string);
+    /**
+     * Helper method to format log messages with server context.
+     *
+     * @param message - The base message
+     * @returns Formatted message with server context if available
      */
-    constructor(url: string, headers?: Record<string, string>, timeout?: number);
+    private formatLogMessage;
     /**
      * Initializes and starts the Streamable HTTP transport connection
      *

package/dist/server/src/utils/transports/streamable-http-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streamable-http-transport.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/streamable-http-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAK1E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,uBAAwB,YAAW,SAAS;IA0CrD,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IA3CjB;;;OAGG;IACH,OAAO,CAAC,SAAS,CAA8C;IAE/D;;;;OAIG;IACH,OAAO,CAAC,SAAS,CAAS;IAE1B;;;OAGG;IACI,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAErD;;;OAGG;IACI,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAExC;;;OAGG;IACI,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IAE5B;;;;;;;;OAQG;gBAEO,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACpC,OAAO,GAAE,MAAc;IAGjC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAwD5B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAoBnD"}
+{"version":3,"file":"streamable-http-transport.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/streamable-http-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAM1E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,uBAAwB,YAAW,SAAS;IAyDrD,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,KAAK,CAAC;IA3DhB;;;OAGG;IACH,OAAO,CAAC,SAAS,CAA8C;IAE/D;;;;OAIG;IACH,OAAO,CAAC,SAAS,CAAS;IAE1B;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAC,CAAS;IAE7B;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAC,CAAS;IAE/B;;;OAGG;IACI,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAErD;;;OAGG;IACI,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAExC;;;OAGG;IACI,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IAE5B;;;;;;;;;;;OAWG;gBAEO,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACpC,OAAO,GAAE,MAAc,EACvB,KAAK,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,YAAA,EAC/B,UAAU,CAAC,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,MAAM;IAMvB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA6G5B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CA6BnD"}

package/dist/server/src/utils/transports/streamable-http-transport.js

@@ -1,6 +1,7 @@
 import { logger, LOG_MODULES } from '../logger.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { URL } from 'url';
+import { ProxyAgent, fetch as undiciFetch } from 'undici';
 /**
  * Streamable HTTP Transport implementation for MCP (Model Context Protocol)
  *
@@ -30,6 +31,7 @@ export class StreamableHttpTransport {
     url;
     headers;
     timeout;
+    proxy;
     /**
      * Internal reference to the underlying MCP SDK transport instance
      * @private
@@ -41,6 +43,16 @@ export class StreamableHttpTransport {
      * @private
      */
     isClosing = false;
+    /**
+     * Server name for logging context
+     * @private
+     */
+    _serverName;
+    /**
+     * Composite key (serverName-serverIndex) for logging context
+     * @private
+     */
+    _compositeKey;
     /**
      * Event handler called when a JSON-RPC message is received from the server
      * @public
@@ -64,11 +76,34 @@ export class StreamableHttpTransport {
      *                 Commonly used for authentication tokens, API keys, or custom headers
      * @param timeout - Request timeout in milliseconds (default: 30000 = 30 seconds)
      *                  Controls how long to wait for HTTP responses before timing out
+     * @param proxy - Optional proxy configuration
+     * @param serverName - Optional server name for logging
+     * @param compositeKey - Optional composite key (serverName-serverIndex) for logging
      */
-    constructor(url, headers = {}, timeout = 30000) {
+    constructor(url, headers = {}, timeout = 30000, proxy, serverName, compositeKey) {
         this.url = url;
         this.headers = headers;
         this.timeout = timeout;
+        this.proxy = proxy;
+        this._serverName = serverName;
+        this._compositeKey = compositeKey;
+    }
+    /**
+     * Helper method to format log messages with server context.
+     *
+     * @param message - The base message
+     * @returns Formatted message with server context if available
+     */
+    formatLogMessage(message) {
+        if (this._compositeKey) {
+            return `${message} (compositeKey=${this._compositeKey}, url=${this.url})`;
+        }
+        else if (this._serverName) {
+            return `${message} (server=${this._serverName}, url=${this.url})`;
+        }
+        else {
+            return `${message} (url=${this.url})`;
+        }
     }
     /**
      * Initializes and starts the Streamable HTTP transport connection
@@ -101,6 +136,8 @@ export class StreamableHttpTransport {
             throw new Error('Streamable HTTP Transport already started!');
         }
         this.isClosing = false;
+        const proxyInfo = this.proxy?.url ? `, proxy=${this.proxy.url}` : '';
+        logger.info(this.formatLogMessage(`Attempting to connect to Streamable HTTP server: timeout=${this.timeout}ms, headers=${JSON.stringify(Object.keys(this.headers))}${proxyInfo}`), LOG_MODULES.HTTP_TRANSPORT);
         try {
             const url = new URL(this.url);
             const requestInit = {
@@ -110,19 +147,37 @@ export class StreamableHttpTransport {
                 },
                 signal: AbortSignal.timeout(this.timeout)
             };
-            this.transport = new StreamableHTTPClientTransport(url, {
+            // Create transport options
+            const transportOptions = {
                 requestInit
-            });
+            };
+            // Add proxy support if configured
+            if (this.proxy?.url) {
+                const agent = new ProxyAgent(this.proxy.url);
+                // Create custom fetch function with proxy
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const customFetch = (input, init) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const fetchOptions = {
+                        ...init,
+                        dispatcher: agent
+                    };
+                    return undiciFetch(input, fetchOptions);
+                };
+                transportOptions.fetch = customFetch;
+                logger.info(this.formatLogMessage(`Streamable HTTP transport configured with proxy: ${this.proxy.url}`), LOG_MODULES.HTTP_TRANSPORT);
+            }
+            this.transport = new StreamableHTTPClientTransport(url, transportOptions);
             // Set up event handlers
             this.transport.onmessage = (message) => {
                 this.onmessage?.(message);
             };
             this.transport.onerror = (error) => {
-                logger.error('Streamable HTTP transport error:', error, LOG_MODULES.HTTP_TRANSPORT);
+                logger.error(this.formatLogMessage(`Streamable HTTP transport error occurred: errorType=${error.name || 'unknown'}, message=${error.message || 'no message'}`), error, LOG_MODULES.HTTP_TRANSPORT);
                 this.onerror?.(error);
             };
             this.transport.onclose = () => {
-                logger.info('Streamable HTTP transport closed', LOG_MODULES.HTTP_TRANSPORT);
+                logger.info(this.formatLogMessage('Streamable HTTP transport closed'), LOG_MODULES.HTTP_TRANSPORT);
                 if (!this.isClosing) {
                     // Unexpected close, trigger error
                     const error = new Error('Streamable HTTP transport closed unexpectedly');
@@ -130,11 +185,13 @@ export class StreamableHttpTransport {
                 }
                 this.onclose?.();
             };
+            logger.debug(this.formatLogMessage('Starting underlying transport connection...'), LOG_MODULES.HTTP_TRANSPORT);
             await this.transport.start();
-            logger.info(`Streamable HTTP transport initialized for ${this.url}`, LOG_MODULES.HTTP_TRANSPORT);
+            logger.info(this.formatLogMessage('Streamable HTTP transport successfully initialized'), LOG_MODULES.HTTP_TRANSPORT);
         }
         catch (error) {
-            logger.error('Failed to create Streamable HTTP transport:', error, LOG_MODULES.HTTP_TRANSPORT);
+            logger.error(this.formatLogMessage(`Failed to create Streamable HTTP transport: error=${error instanceof Error ? error.message : String(error)}`), LOG_MODULES.HTTP_TRANSPORT);
+            logger.error('Complete error details:', error, LOG_MODULES.HTTP_TRANSPORT);
             throw error;
         }
     }
@@ -201,11 +258,14 @@ export class StreamableHttpTransport {
         if (!this.transport) {
             throw new Error('Streamable HTTP transport not started');
         }
+        const method = 'method' in message ? message.method : 'notification';
+        const proxyInfo = this.proxy?.url ? `, proxy=${this.proxy.url}` : '';
+        logger.debug(this.formatLogMessage(`Sending message via Streamable HTTP: method=${method}${proxyInfo}`), LOG_MODULES.HTTP_TRANSPORT);
         try {
             await this.transport.send(message);
         }
         catch (error) {
-            logger.error('Failed to send message via Streamable HTTP:', error, LOG_MODULES.HTTP_TRANSPORT);
+            logger.error(this.formatLogMessage(`Failed to send message via Streamable HTTP: method=${method}${proxyInfo}, error=${error instanceof Error ? error.message : String(error)}`), error, LOG_MODULES.HTTP_TRANSPORT);
             throw error;
         }
     }

package/dist/server/src/utils/transports/transport-factory.d.ts

@@ -1,4 +1,4 @@
-import type { ServerConfig } from '../../config/config.schema.js';
+import type { ServerRuntimeConfig } from '../../../shared/models/server.model.js';
 /**
  * Transport Factory - creates appropriate transport client based on server configuration
  */
@@ -6,18 +6,23 @@ export declare class TransportFactory {
     /**
      * Create transport client
      * @param server Server configuration, including base configuration and instance configuration
-     * @param serverId Optional server ID for log storage integration
+     * @param compositeKey Optional composite key (serverName-serverIndex) for log storage integration
      * @returns Transport client instance
      * @throws Error if server type is not supported or configuration is invalid
      */
-    static createTransport(server: ServerConfig & {
+    static createTransport(server: ServerRuntimeConfig & {
         name: string;
-    }, serverId?: string): import('@modelcontextprotocol/sdk/shared/transport.js').Transport;
+    }, compositeKey?: string): import('@modelcontextprotocol/sdk/shared/transport.js').Transport;
     /**
      * Build system environment variables
      * Add necessary system environment variables for stdio transport
      */
     private static buildSystemEnv;
+    /**
+     * Check if a command is related to Python execution
+     * Detects python, python3, py, uv, uvx, and similar commands
+     */
+    private static isPythonCommand;
     /**
      * Validate and convert server configuration to transport configuration
      */

package/dist/server/src/utils/transports/transport-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transport-factory.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/transport-factory.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D;;GAEG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CACpB,MAAM,EAAE,YAAY,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EACvC,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,+CAA+C,EAAE,SAAS;IAmDpE;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAI7B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,wBAAwB;CA4CxC"}
+{"version":3,"file":"transport-factory.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/transport-factory.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAG1E;;GAEG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CACpB,MAAM,EAAE,mBAAmB,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAC9C,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,+CAA+C,EAAE,SAAS;IA6DpE;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAW7B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAW9B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,wBAAwB;CA8CxC"}