nuwax-mcp-stdio-proxy 1.4.7 → 1.4.9

package/dist/logger.d.ts

@@ -1,5 +1,11 @@
 /**
- * Logging utilities — stderr only, stdout is the MCP JSON-RPC channel
+ * Logging utilities — stderr only, stdout is the MCP JSON-RPC channel.
+ *
+ * When the environment variable MCP_PROXY_LOG_FILE is set, log lines are
+ * also appended to that file so the Electron host can tail them into main.log.
+ *
+ * Log rotation: file is named by date (e.g. mcp-proxy-2026-03-09.log).
+ * A new file is created each day. Old files beyond MAX_LOG_FILES are deleted.
  */
 export declare function log(level: string, msg: string): void;
 export declare const logInfo: (msg: string) => void;

package/dist/logger.js

@@ -1,8 +1,103 @@
 /**
- * Logging utilities — stderr only, stdout is the MCP JSON-RPC channel
+ * Logging utilities — stderr only, stdout is the MCP JSON-RPC channel.
+ *
+ * When the environment variable MCP_PROXY_LOG_FILE is set, log lines are
+ * also appended to that file so the Electron host can tail them into main.log.
+ *
+ * Log rotation: file is named by date (e.g. mcp-proxy-2026-03-09.log).
+ * A new file is created each day. Old files beyond MAX_LOG_FILES are deleted.
  */
+import * as fs from 'fs';
+import * as path from 'path';
+const logFilePath = process.env.MCP_PROXY_LOG_FILE;
+const MAX_LOG_FILES = 7;
+let logStream = null;
+let logDir = '';
+let logBaseName = '';
+let logExt = '';
+let currentDateStr = '';
+function dateStr() {
+    const d = new Date();
+    const pad2 = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+}
+function openLogFile() {
+    if (!logFilePath)
+        return;
+    const today = dateStr();
+    if (today === currentDateStr && logStream)
+        return;
+    // Close previous stream
+    if (logStream) {
+        try {
+            logStream.end();
+        }
+        catch { /* ignore */ }
+    }
+    currentDateStr = today;
+    const dated = path.join(logDir, `${logBaseName}-${today}${logExt}`);
+    try {
+        logStream = fs.createWriteStream(dated, { flags: 'a' });
+    }
+    catch {
+        logStream = null;
+    }
+    // Cleanup old log files
+    cleanupOldLogs();
+}
+function cleanupOldLogs() {
+    if (!logDir || !logBaseName)
+        return;
+    try {
+        const prefix = `${logBaseName}-`;
+        const files = fs.readdirSync(logDir)
+            .filter(f => f.startsWith(prefix) && f.endsWith(logExt))
+            .sort()
+            .reverse();
+        for (let i = MAX_LOG_FILES; i < files.length; i++) {
+            try {
+                fs.unlinkSync(path.join(logDir, files[i]));
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch { /* ignore */ }
+}
+if (logFilePath) {
+    try {
+        logDir = path.dirname(logFilePath);
+        if (logDir && !fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        const fullName = path.basename(logFilePath);
+        const dotIdx = fullName.lastIndexOf('.');
+        if (dotIdx > 0) {
+            logBaseName = fullName.substring(0, dotIdx);
+            logExt = fullName.substring(dotIdx);
+        }
+        else {
+            logBaseName = fullName;
+            logExt = '.log';
+        }
+        openLogFile();
+    }
+    catch {
+        // If file creation fails, continue without file logging
+    }
+}
+function timestamp() {
+    const d = new Date();
+    const pad2 = (n) => String(n).padStart(2, '0');
+    const pad3 = (n) => String(n).padStart(3, '0');
+    return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}.${pad3(d.getMilliseconds())}`;
+}
 export function log(level, msg) {
-    process.stderr.write(`[nuwax-mcp-proxy] ${level}: ${msg}\n`);
+    const line = `[${timestamp()}] [${level.toLowerCase()}]  [nuwax-mcp-proxy] ${msg}\n`;
+    process.stderr.write(line);
+    if (logFilePath) {
+        openLogFile(); // Rotate if date changed
+        logStream?.write(line);
+    }
 }
 export const logInfo = (msg) => log('INFO', msg);
 export const logWarn = (msg) => log('WARN', msg);

package/dist/modes/stdio.js

@@ -24,7 +24,16 @@ export async function runStdio(config, allowTools, denyTools) {
     const toolToClient = new Map();
     const toolToServer = new Map();
     const toolsByName = new Map();
-    for (const [id, entry] of entries) {
+    // Filter out persistent entries (handled by PersistentMcpBridge, not this proxy)
+    const connectableEntries = entries.filter(([id, entry]) => {
+        if (entry.persistent) {
+            logWarn(`Skipping persistent server "${id}" (handled by PersistentMcpBridge)`);
+            return false;
+        }
+        return true;
+    });
+    // Connect to all servers in parallel
+    const results = await Promise.allSettled(connectableEntries.map(async ([id, entry]) => {
         try {
             let connected;
             if (isSseEntry(entry)) {
@@ -46,36 +55,43 @@ export async function runStdio(config, allowTools, denyTools) {
             else {
                 connected = await connectStdio(id, entry, baseEnv);
             }
-            const { client, cleanup } = connected;
-            clients.set(id, client);
-            cleanups.set(id, cleanup);
-            let serverTools = await discoverTools(client);
-            // Per-server tool filtering (allowTools/denyTools in config entry)
-            if (entry.allowTools || entry.denyTools) {
-                const perFilter = {};
-                if (entry.allowTools)
-                    perFilter.allowTools = new Set(entry.allowTools);
-                if (entry.denyTools)
-                    perFilter.denyTools = new Set(entry.denyTools);
-                const before = serverTools.length;
-                serverTools = filterTools(serverTools, perFilter);
-                if (serverTools.length !== before) {
-                    logInfo(`Server "${id}": filtered ${before} → ${serverTools.length} tool(s)`);
-                }
-            }
-            logInfo(`Server "${id}": ${serverTools.length} tool(s)${serverTools.length > 0 ? ' — ' + serverTools.map((t) => t.name).join(', ') : ''}`);
-            for (const tool of serverTools) {
-                if (toolToClient.has(tool.name)) {
-                    logWarn(`Tool "${tool.name}" from "${id}" shadows existing tool from "${toolToServer.get(tool.name)}"`);
-                }
-                toolToClient.set(tool.name, client);
-                toolToServer.set(tool.name, id);
-                toolsByName.set(tool.name, tool);
-            }
+            return { id, entry, connected };
         }
         catch (e) {
-            logError(`Failed to connect to server "${id}": ${e}`);
-            // Continue with remaining servers — partial startup is acceptable
+            throw new Error(`Server "${id}": ${e}`);
+        }
+    }));
+    for (const result of results) {
+        if (result.status === 'rejected') {
+            logError(`Failed to connect: ${result.reason}`);
+            continue;
+        }
+        const { id, entry, connected } = result.value;
+        const { client, cleanup } = connected;
+        clients.set(id, client);
+        cleanups.set(id, cleanup);
+        let serverTools = await discoverTools(client);
+        // Per-server tool filtering (allowTools/denyTools in config entry)
+        if (entry.allowTools || entry.denyTools) {
+            const perFilter = {};
+            if (entry.allowTools)
+                perFilter.allowTools = new Set(entry.allowTools);
+            if (entry.denyTools)
+                perFilter.denyTools = new Set(entry.denyTools);
+            const before = serverTools.length;
+            serverTools = filterTools(serverTools, perFilter);
+            if (serverTools.length !== before) {
+                logInfo(`Server "${id}": filtered ${before} → ${serverTools.length} tool(s)`);
+            }
+        }
+        logInfo(`Server "${id}": ${serverTools.length} tool(s)${serverTools.length > 0 ? ' — ' + serverTools.map((t) => t.name).join(', ') : ''}`);
+        for (const tool of serverTools) {
+            if (toolToClient.has(tool.name)) {
+                logWarn(`Tool "${tool.name}" from "${id}" shadows existing tool from "${toolToServer.get(tool.name)}"`);
+            }
+            toolToClient.set(tool.name, client);
+            toolToServer.set(tool.name, id);
+            toolsByName.set(tool.name, tool);
         }
     }
     if (clients.size === 0) {

package/dist/resilient.d.ts

@@ -3,6 +3,9 @@
  *
  * Provides heartbeat monitoring, automatic reconnection, and request queueing
  * for MCP transports (HTTP, SSE, Stdio).
+ *
+ * Retry strategy: exponential backoff 1s → 2s → 4s → ... → 60s (capped),
+ * unlimited retries. Matches the Rust mcp-proxy CappedExponentialBackoff.
  */
 import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
@@ -21,8 +24,10 @@ export interface ResilientTransportOptions {
     maxConsecutiveFailures?: number;
     /** Timeout for checking ping or listTools (ms). Default: 5000 */
     pingTimeoutMs?: number;
-    /** Backoff delay before reconnect attempt (ms). Default: 3000 */
+    /** Base backoff delay for reconnect (ms). Default: 1000 */
     reconnectDelayMs?: number;
+    /** Max backoff delay cap (ms). Default: 60000 */
+    maxReconnectDelayMs?: number;
     /** Max queued requests during reconnect. Default: 100 */
     maxQueueSize?: number;
     /** Server name/ID for logging */
@@ -43,12 +48,19 @@ export declare class ResilientTransportWrapper implements Transport {
     private heartbeatTimer;
     private consecutiveFailures;
     private state;
+    /** Current retry attempt count (reset on successful connect) */
+    private retryAttempt;
     onclose?: () => void;
     onerror?: (error: Error) => void;
     onmessage?: (message: JSONRPCMessage) => void;
     private messageQueue;
     private pendingPings;
     constructor(options: ResilientTransportOptions);
+    /**
+     * Calculate backoff delay using capped exponential backoff.
+     * 1s → 2s → 4s → 8s → 16s → 32s → 60s (capped)
+     */
+    private getBackoffDelay;
     /**
      * Initializes the transport and connects to the backend
      *
@@ -61,7 +73,7 @@ export declare class ResilientTransportWrapper implements Transport {
     /**
      * Enable heartbeat monitoring. Call this AFTER the MCP client has
      * completed its initialize handshake (client.connect()), otherwise
-     * the server will reject ping requests with "Server not initialized".
+     * the server will reject requests with "Server not initialized".
      */
     enableHeartbeat(): void;
     private performConnect;
@@ -70,9 +82,12 @@ export declare class ResilientTransportWrapper implements Transport {
     private stopHeartbeat;
     /** Track consecutive ping timeouts (no response at all, not even an error) */
     private consecutivePingTimeouts;
-    /** If server doesn't support ping, auto-disable heartbeat after maxConsecutiveFailures timeouts */
-    private pingDisabled;
+    /** Successful heartbeat counter (for reducing log volume) */
+    private heartbeatOkCount;
     private checkHealth;
+    /**
+     * Close the current transport and schedule a reconnect with exponential backoff.
+     */
     private triggerReconnect;
     private flushQueue;
     send(message: JSONRPCMessage): Promise<void>;

package/dist/resilient.js

@@ -3,13 +3,17 @@
  *
  * Provides heartbeat monitoring, automatic reconnection, and request queueing
  * for MCP transports (HTTP, SSE, Stdio).
+ *
+ * Retry strategy: exponential backoff 1s → 2s → 4s → ... → 60s (capped),
+ * unlimited retries. Matches the Rust mcp-proxy CappedExponentialBackoff.
  */
 import { logInfo, logWarn, logError } from './logger.js';
 const DEFAULT_OPTIONS = {
     pingIntervalMs: 20000,
     maxConsecutiveFailures: 3,
     pingTimeoutMs: 5000,
-    reconnectDelayMs: 3000,
+    reconnectDelayMs: 1000,
+    maxReconnectDelayMs: 60000,
     maxQueueSize: 100,
     name: 'remote',
 };
@@ -26,7 +30,9 @@ export class ResilientTransportWrapper {
     mcpClient = null;
     heartbeatTimer = null;
     consecutiveFailures = 0;
-    state = 'connecting';
+    state = 'idle';
+    /** Current retry attempt count (reset on successful connect) */
+    retryAttempt = 0;
     // Handlers required by the Transport interface
     onclose;
     onerror;
@@ -37,7 +43,30 @@ export class ResilientTransportWrapper {
     pendingPings = new Map();
     constructor(options) {
         this.log = options.logger ?? defaultLogger;
-        this.options = { ...DEFAULT_OPTIONS, logger: this.log, ...options };
+        // Build options by starting from defaults and only overriding with
+        // explicitly provided values. Spreading { pingIntervalMs: undefined }
+        // would clobber the default 20000, causing setInterval(fn, undefined)
+        // → interval ~0ms (fires every tick).
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            logger: this.log,
+            connectParams: options.connectParams,
+            ...(options.name !== undefined && { name: options.name }),
+            ...(options.pingIntervalMs !== undefined && { pingIntervalMs: options.pingIntervalMs }),
+            ...(options.pingTimeoutMs !== undefined && { pingTimeoutMs: options.pingTimeoutMs }),
+            ...(options.maxConsecutiveFailures !== undefined && { maxConsecutiveFailures: options.maxConsecutiveFailures }),
+            ...(options.reconnectDelayMs !== undefined && { reconnectDelayMs: options.reconnectDelayMs }),
+            ...(options.maxReconnectDelayMs !== undefined && { maxReconnectDelayMs: options.maxReconnectDelayMs }),
+            ...(options.maxQueueSize !== undefined && { maxQueueSize: options.maxQueueSize }),
+        };
+    }
+    /**
+     * Calculate backoff delay using capped exponential backoff.
+     * 1s → 2s → 4s → 8s → 16s → 32s → 60s (capped)
+     */
+    getBackoffDelay() {
+        const delay = this.options.reconnectDelayMs * Math.pow(2, this.retryAttempt);
+        return Math.min(delay, this.options.maxReconnectDelayMs);
     }
     /**
      * Initializes the transport and connects to the backend
@@ -48,8 +77,8 @@ export class ResilientTransportWrapper {
      * internally calls transport.start(), and we also call it explicitly in bridge.ts.
      */
     async start() {
-        // Idempotent check: if already connected or connecting, return early
-        if (this.state === 'connected' || this.state === 'connecting') {
+        // Idempotent check: if already connected, connecting, or retrying, return early
+        if (this.state === 'connected' || this.state === 'connecting' || this.state === 'reconnecting') {
             return;
         }
         this.state = 'connecting';
@@ -58,12 +87,14 @@ export class ResilientTransportWrapper {
     /**
      * Enable heartbeat monitoring. Call this AFTER the MCP client has
      * completed its initialize handshake (client.connect()), otherwise
-     * the server will reject ping requests with "Server not initialized".
+     * the server will reject requests with "Server not initialized".
      */
     enableHeartbeat() {
         this.startHeartbeat();
     }
     async performConnect(initial = false) {
+        if (this.state === 'closed')
+            return;
         try {
             this.activeTransport = await this.options.connectParams();
             // Inherit the handlers from this wrapper
@@ -71,7 +102,10 @@ export class ResilientTransportWrapper {
             await this.activeTransport.start();
             this.state = 'connected';
             this.consecutiveFailures = 0;
-            this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] Connected via ${this.activeTransport.constructor.name}`);
+            this.consecutivePingTimeouts = 0;
+            this.retryAttempt = 0;
+            this.heartbeatOkCount = 0;
+            this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] ✅ Connected via ${this.activeTransport.constructor.name}`);
             // Flush any queued messages
             this.flushQueue();
             // Only start heartbeat on reconnects — initial connections need
@@ -83,12 +117,14 @@ export class ResilientTransportWrapper {
             }
         }
         catch (err) {
-            this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Connect failed: ${err}`);
-            if (initial) {
-                this.state = 'closed';
-                throw err;
-            }
-            this.triggerReconnect(); // Retry connection
+            const delay = this.getBackoffDelay();
+            this.retryAttempt++;
+            this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] ❌ Connect failed (attempt ${this.retryAttempt}): ${err}`);
+            this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 🔄 Retrying in ${delay}ms...`);
+            this.state = 'reconnecting';
+            setTimeout(() => {
+                this.performConnect();
+            }, delay);
         }
     }
     bindInnerTransport(transport) {
@@ -112,7 +148,7 @@ export class ResilientTransportWrapper {
             }
         };
         transport.onmessage = (message) => {
-            // Intercept our own ping responses here (both success and error responses)
+            // Intercept our own heartbeat responses (tools/list used as health check)
             if ('id' in message && typeof message.id === 'string' && message.id.startsWith('respl-ping-')) {
                 const resolve = this.pendingPings.get(message.id);
                 if (resolve) {
@@ -143,74 +179,71 @@ export class ResilientTransportWrapper {
     }
     /** Track consecutive ping timeouts (no response at all, not even an error) */
     consecutivePingTimeouts = 0;
-    /** If server doesn't support ping, auto-disable heartbeat after maxConsecutiveFailures timeouts */
-    pingDisabled = false;
+    /** Successful heartbeat counter (for reducing log volume) */
+    heartbeatOkCount = 0;
     async checkHealth() {
         if (this.state !== 'connected' || !this.activeTransport)
             return;
-        if (this.pingDisabled)
-            return;
         try {
-            // Send raw ping JSON-RPC
-            const pingId = `respl-ping-${Date.now()}`;
+            // Use tools/list as health check (all MCP servers must support it).
+            // Unlike ping, which is optional and many servers ignore, tools/list
+            // is a required MCP method — matching Rust mcp-proxy behavior.
+            const healthId = `respl-ping-${Date.now()}`;
             const responsePromise = new Promise((resolve) => {
-                this.pendingPings.set(pingId, resolve);
+                this.pendingPings.set(healthId, resolve);
                 setTimeout(() => {
-                    if (this.pendingPings.has(pingId)) {
-                        this.pendingPings.delete(pingId);
+                    if (this.pendingPings.has(healthId)) {
+                        this.pendingPings.delete(healthId);
                         resolve(false); // Timeout
                     }
                 }, this.options.pingTimeoutMs);
             });
-            // Try to send ping — if send() throws, the transport itself is broken
-            let sendFailed = false;
+            // Try to send tools/list — if send() throws, the transport itself is broken
             try {
-                this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 💓 Sending heartbeat ping (id: ${pingId})`);
                 await this.activeTransport.send({
                     jsonrpc: '2.0',
-                    id: pingId,
-                    method: 'ping',
+                    id: healthId,
+                    method: 'tools/list',
+                    params: {},
                 });
             }
             catch (sendErr) {
-                sendFailed = true;
                 throw sendErr; // Transport broken, treat as real failure
             }
             const success = await responsePromise;
             if (!success) {
-                // Ping was sent successfully but timed out — server might not support ping
                 this.consecutivePingTimeouts++;
+                this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] ⏱️ Heartbeat timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
                 if (this.consecutivePingTimeouts >= this.options.maxConsecutiveFailures) {
-                    // Server consistently never responds to ping — it probably doesn't support
-                    // the ping method. Auto-disable heartbeat instead of reconnecting, since
-                    // the transport is likely healthy (sends succeed, no errors from transport).
-                    this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Server does not respond to ping. Disabling heartbeat monitoring.`);
-                    this.pingDisabled = true;
-                    this.stopHeartbeat();
-                    return;
+                    this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat timeouts reached. Closing and retrying...`);
+                    this.triggerReconnect();
                 }
-                // Still count as a failure for logging, but don't reconnect yet
-                this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Ping timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
                 return;
             }
             // Got a response — server is alive
-            this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 💖 Heartbeat successful (id: ${pingId})`);
+            this.heartbeatOkCount++;
+            // Only log every 5th success to reduce log volume (~100s interval)
+            if (this.heartbeatOkCount % 5 === 1 || this.consecutiveFailures > 0 || this.consecutivePingTimeouts > 0) {
+                this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 💖 Heartbeat OK (count: ${this.heartbeatOkCount})`);
+            }
             this.consecutiveFailures = 0;
             this.consecutivePingTimeouts = 0;
         }
         catch (err) {
             this.consecutiveFailures++;
-            this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] 💔 Heartbeat error (attempt ${this.consecutiveFailures}/${this.options.maxConsecutiveFailures}): ${err}`);
+            this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] 💔 Heartbeat error (${this.consecutiveFailures}/${this.options.maxConsecutiveFailures}): ${err}`);
             if (this.consecutiveFailures >= this.options.maxConsecutiveFailures) {
-                this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat failures reached. Force reconnecting.`);
+                this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat failures reached. Closing and retrying...`);
                 this.triggerReconnect();
             }
         }
     }
+    /**
+     * Close the current transport and schedule a reconnect with exponential backoff.
+     */
     triggerReconnect() {
         if (this.state === 'reconnecting' || this.state === 'closed')
             return;
-        this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] 🔄 Triggering reconnect (previous state: ${this.state})`);
         this.state = 'reconnecting';
         this.stopHeartbeat();
         // Clean up old transport
@@ -224,9 +257,12 @@ export class ResilientTransportWrapper {
             catch { /* ignore */ }
             this.activeTransport = null;
         }
+        const delay = this.getBackoffDelay();
+        this.retryAttempt++;
+        this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] 🔄 Closed. Retrying in ${delay}ms (attempt ${this.retryAttempt})...`);
         setTimeout(() => {
             this.performConnect();
-        }, this.options.reconnectDelayMs);
+        }, delay);
     }
     async flushQueue() {
         if (!this.activeTransport || this.state !== 'connected')

package/dist/transport.js

@@ -7,6 +7,8 @@ import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { CustomStdioClientTransport } from './customStdio.js';
 import { logInfo } from './logger.js';
 import { ResilientTransportWrapper } from './resilient.js';
+const DEFAULT_STDIO_CONNECTION_TIMEOUT_MS = 60_000;
+const DEFAULT_HTTP_CONNECTION_TIMEOUT_MS = 30_000;
 /**
  * Helper to wrap a promise with a timeout
  */
@@ -73,16 +75,16 @@ export async function connectStdio(id, entry, baseEnv) {
             }
             return t;
         },
-        pingIntervalMs: entry.pingIntervalMs,
-        pingTimeoutMs: entry.pingTimeoutMs,
+        // No heartbeat for stdio — child process close/error events handle detection
+        pingIntervalMs: 0,
     });
     const client = new Client({ name: `proxy-${id}`, version: '1.0.0' });
+    const timeoutMs = entry.connectionTimeoutMs ?? DEFAULT_STDIO_CONNECTION_TIMEOUT_MS;
     try {
         await withTimeout((async () => {
             await wrapper.start();
             await client.connect(wrapper);
-            wrapper.enableHeartbeat(); // Start heartbeat AFTER MCP initialize completes
-        })(), 5000, `Connection initialization timed out after 5s`);
+        })(), timeoutMs, `Connection initialization timed out after ${timeoutMs / 1000}s`);
     }
     catch (err) {
         try {
@@ -121,12 +123,13 @@ export async function connectStreamable(id, entry) {
         pingTimeoutMs: entry.pingTimeoutMs,
     });
     const client = new Client({ name: `proxy-${id}`, version: '1.0.0' });
+    const timeoutMs = entry.connectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
     try {
         await withTimeout((async () => {
             await wrapper.start();
             await client.connect(wrapper);
             wrapper.enableHeartbeat(); // Start heartbeat AFTER MCP initialize completes
-        })(), 5000, `Connection initialization timed out after 5s`);
+        })(), timeoutMs, `Connection initialization timed out after ${timeoutMs / 1000}s`);
     }
     catch (err) {
         try {
@@ -165,12 +168,13 @@ export async function connectSse(id, entry) {
         pingTimeoutMs: entry.pingTimeoutMs,
     });
     const client = new Client({ name: `proxy-${id}`, version: '1.0.0' });
+    const timeoutMs = entry.connectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
     try {
         await withTimeout((async () => {
             await wrapper.start();
             await client.connect(wrapper);
             wrapper.enableHeartbeat(); // Start heartbeat AFTER MCP initialize completes
-        })(), 5000, `Connection initialization timed out after 5s`);
+        })(), timeoutMs, `Connection initialization timed out after ${timeoutMs / 1000}s`);
     }
     catch (err) {
         try {

package/dist/types.d.ts

@@ -10,10 +10,8 @@ export interface StdioServerEntry {
     allowTools?: string[];
     /** 工具黑名单（排除指定工具） */
     denyTools?: string[];
-    /** Heartbeat ping interval configuration (ms) */
-    pingIntervalMs?: number;
-    /** Heartbeat ping timeout configuration (ms) */
-    pingTimeoutMs?: number;
+    /** Connection initialization timeout (ms). Defaults to 60000 for stdio. */
+    connectionTimeoutMs?: number;
 }
 /**
  * Streamable HTTP 类型: 连接远程 MCP server (Streamable HTTP)
@@ -34,6 +32,8 @@ export interface StreamableServerEntry {
     pingIntervalMs?: number;
     /** Heartbeat ping timeout configuration (ms) */
     pingTimeoutMs?: number;
+    /** Connection initialization timeout (ms). Defaults to 30000. */
+    connectionTimeoutMs?: number;
 }
 /**
  * SSE 类型: 连接远程 MCP server (Server-Sent Events)
@@ -53,6 +53,8 @@ export interface SseServerEntry {
     pingIntervalMs?: number;
     /** Heartbeat ping timeout configuration (ms) */
     pingTimeoutMs?: number;
+    /** Connection initialization timeout (ms). Defaults to 30000. */
+    connectionTimeoutMs?: number;
 }
 export type McpServerEntry = StdioServerEntry | StreamableServerEntry | SseServerEntry;
 export declare function isSseEntry(entry: McpServerEntry): entry is SseServerEntry;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "nuwax-mcp-stdio-proxy",
-  "version": "1.4.7",
+  "version": "1.4.9",
   "description": "TypeScript MCP proxy — aggregates multiple MCP servers (stdio + streamable-http + SSE) with convert & proxy modes",
   "type": "module",
   "bin": {
-    "nuwax-mcp-stdio-proxy": "./dist/index.js"
+    "nuwax-mcp-stdio-proxy": "dist/index.js"
   },
   "main": "./dist/lib.js",
   "types": "./dist/lib.d.ts",
@@ -18,7 +18,8 @@
     "test:run": "npm run build:tsc && vitest run",
     "test:coverage": "npm run build:tsc && vitest run --coverage",
     "prepublishOnly": "npm run build",
-    "publish:non-latest": "npm publish --tag beta"
+    "publish:non-latest": "npm publish --tag beta",
+    "publish:prerelease": "npm publish --tag prerelease"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1"