nuwax-mcp-stdio-proxy 1.4.7 → 1.4.9

package/dist/index.js

@@ -3222,8 +3222,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path2) {
-      let input = path2;
+    function removeDotSegments(path3) {
+      let input = path3;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3422,8 +3422,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path2, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path2 && path2 !== "/" ? path2 : void 0;
+        const [path3, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path3 && path3 !== "/" ? path3 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6785,12 +6785,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs3, exportName) {
+    function addFormats(ajv, list, fs4, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs3[f]);
+        ajv.addFormat(f, fs4[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -6799,12 +6799,89 @@ var require_dist = __commonJS({
 });
 
 // src/index.ts
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 
 // src/logger.ts
+import * as fs from "fs";
+import * as path from "path";
+var logFilePath = process.env.MCP_PROXY_LOG_FILE;
+var MAX_LOG_FILES = 7;
+var logStream = null;
+var logDir = "";
+var logBaseName = "";
+var logExt = "";
+var currentDateStr = "";
+function dateStr() {
+  const d = /* @__PURE__ */ 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;
+  if (logStream) {
+    try {
+      logStream.end();
+    } catch {
+    }
+  }
+  currentDateStr = today;
+  const dated = path.join(logDir, `${logBaseName}-${today}${logExt}`);
+  try {
+    logStream = fs.createWriteStream(dated, { flags: "a" });
+  } catch {
+    logStream = null;
+  }
+  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 {
+      }
+    }
+  } catch {
+  }
+}
+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 {
+  }
+}
+function timestamp() {
+  const d = /* @__PURE__ */ 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())}`;
+}
 function log(level, msg) {
-  process.stderr.write(`[nuwax-mcp-proxy] ${level}: ${msg}
-`);
+  const line = `[${timestamp()}] [${level.toLowerCase()}]  [nuwax-mcp-proxy] ${msg}
+`;
+  process.stderr.write(line);
+  if (logFilePath) {
+    openLogFile();
+    logStream?.write(line);
+  }
 }
 var logInfo = (msg) => log("INFO", msg);
 var logWarn = (msg) => log("WARN", msg);
@@ -7180,8 +7257,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path2, errorMaps, issueData } = params;
-  const fullPath = [...path2, ...issueData.path || []];
+  const { data, path: path3, errorMaps, issueData } = params;
+  const fullPath = [...path3, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -7296,11 +7373,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path2, key) {
+  constructor(parent, value, path3, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path2;
+    this._path = path3;
     this._key = key;
   }
   get path() {
@@ -10944,10 +11021,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path3) {
+  if (!path3)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path3.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11330,11 +11407,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path3, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path3);
     return iss;
   });
 }
@@ -22810,8 +22887,8 @@ function serializeMessage(message) {
 }
 
 // src/customStdio.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 function logDebug(msg) {
   process.stderr.write(`[customStdio] ${msg}
 `);
@@ -22848,8 +22925,8 @@ var CustomStdioClientTransport = class {
         const pathDirs = (mergedEnv.PATH || "").split(";");
         for (const dir of pathDirs) {
           for (const ext of cmdExtensions) {
-            const fullPath = path.join(dir, command + ext);
-            if (fs.existsSync(fullPath)) {
+            const fullPath = path2.join(dir, command + ext);
+            if (fs2.existsSync(fullPath)) {
               command = fullPath;
               logDebug(`Resolved "${this._serverParams.command}" to "${command}"`);
               break;
@@ -23024,7 +23101,8 @@ var DEFAULT_OPTIONS = {
   pingIntervalMs: 2e4,
   maxConsecutiveFailures: 3,
   pingTimeoutMs: 5e3,
-  reconnectDelayMs: 3e3,
+  reconnectDelayMs: 1e3,
+  maxReconnectDelayMs: 6e4,
   maxQueueSize: 100,
   name: "remote"
 };
@@ -23040,7 +23118,9 @@ var ResilientTransportWrapper = class {
   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;
@@ -23051,7 +23131,26 @@ var ResilientTransportWrapper = class {
   pendingPings = /* @__PURE__ */ new Map();
   constructor(options) {
     this.log = options.logger ?? defaultLogger;
-    this.options = { ...DEFAULT_OPTIONS, logger: this.log, ...options };
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      logger: this.log,
+      connectParams: options.connectParams,
+      ...options.name !== void 0 && { name: options.name },
+      ...options.pingIntervalMs !== void 0 && { pingIntervalMs: options.pingIntervalMs },
+      ...options.pingTimeoutMs !== void 0 && { pingTimeoutMs: options.pingTimeoutMs },
+      ...options.maxConsecutiveFailures !== void 0 && { maxConsecutiveFailures: options.maxConsecutiveFailures },
+      ...options.reconnectDelayMs !== void 0 && { reconnectDelayMs: options.reconnectDelayMs },
+      ...options.maxReconnectDelayMs !== void 0 && { maxReconnectDelayMs: options.maxReconnectDelayMs },
+      ...options.maxQueueSize !== void 0 && { 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
@@ -23062,7 +23161,7 @@ var ResilientTransportWrapper = class {
    * internally calls transport.start(), and we also call it explicitly in bridge.ts.
    */
   async start() {
-    if (this.state === "connected" || this.state === "connecting") {
+    if (this.state === "connected" || this.state === "connecting" || this.state === "reconnecting") {
       return;
     }
     this.state = "connecting";
@@ -23071,30 +23170,36 @@ var ResilientTransportWrapper = class {
   /**
    * 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();
       this.bindInnerTransport(this.activeTransport);
       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}] \u2705 Connected via ${this.activeTransport.constructor.name}`);
       this.flushQueue();
       if (!initial) {
         this.startHeartbeat();
       }
     } catch (err) {
-      this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Connect failed: ${err}`);
-      if (initial) {
-        this.state = "closed";
-        throw err;
-      }
-      this.triggerReconnect();
+      const delay = this.getBackoffDelay();
+      this.retryAttempt++;
+      this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] \u274C Connect failed (attempt ${this.retryAttempt}): ${err}`);
+      this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F504} Retrying in ${delay}ms...`);
+      this.state = "reconnecting";
+      setTimeout(() => {
+        this.performConnect();
+      }, delay);
     }
   }
   bindInnerTransport(transport) {
@@ -23143,61 +23248,61 @@ var ResilientTransportWrapper = class {
   }
   /** 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 {
-      const pingId = `respl-ping-${Date.now()}`;
+      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);
           }
         }, this.options.pingTimeoutMs);
       });
-      let sendFailed = false;
       try {
-        this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F493} 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;
       }
       const success2 = await responsePromise;
       if (!success2) {
         this.consecutivePingTimeouts++;
+        this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] \u23F1\uFE0F Heartbeat timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
         if (this.consecutivePingTimeouts >= this.options.maxConsecutiveFailures) {
-          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();
         }
-        this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Ping timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
         return;
       }
-      this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F496} Heartbeat successful (id: ${pingId})`);
+      this.heartbeatOkCount++;
+      if (this.heartbeatOkCount % 5 === 1 || this.consecutiveFailures > 0 || this.consecutivePingTimeouts > 0) {
+        this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F496} Heartbeat OK (count: ${this.heartbeatOkCount})`);
+      }
       this.consecutiveFailures = 0;
       this.consecutivePingTimeouts = 0;
     } catch (err) {
       this.consecutiveFailures++;
-      this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F494} Heartbeat error (attempt ${this.consecutiveFailures}/${this.options.maxConsecutiveFailures}): ${err}`);
+      this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F494} 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}] \u{1F504} Triggering reconnect (previous state: ${this.state})`);
     this.state = "reconnecting";
     this.stopHeartbeat();
     if (this.activeTransport) {
@@ -23209,9 +23314,12 @@ var ResilientTransportWrapper = class {
       }
       this.activeTransport = null;
     }
+    const delay = this.getBackoffDelay();
+    this.retryAttempt++;
+    this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F504} Closed. Retrying in ${delay}ms (attempt ${this.retryAttempt})...`);
     setTimeout(() => {
       this.performConnect();
-    }, this.options.reconnectDelayMs);
+    }, delay);
   }
   async flushQueue() {
     if (!this.activeTransport || this.state !== "connected") return;
@@ -23274,6 +23382,8 @@ var ResilientTransportWrapper = class {
 };
 
 // src/transport.ts
+var DEFAULT_STDIO_CONNECTION_TIMEOUT_MS = 6e4;
+var DEFAULT_HTTP_CONNECTION_TIMEOUT_MS = 3e4;
 async function withTimeout(promise2, ms, message) {
   let timeoutId;
   const timeoutPromise = new Promise((_, reject) => {
@@ -23327,19 +23437,19 @@ 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();
       })(),
-      5e3,
-      `Connection initialization timed out after 5s`
+      timeoutMs,
+      `Connection initialization timed out after ${timeoutMs / 1e3}s`
     );
   } catch (err) {
     try {
@@ -23375,6 +23485,7 @@ 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 () => {
@@ -23382,8 +23493,8 @@ async function connectStreamable(id, entry) {
         await client.connect(wrapper);
         wrapper.enableHeartbeat();
       })(),
-      5e3,
-      `Connection initialization timed out after 5s`
+      timeoutMs,
+      `Connection initialization timed out after ${timeoutMs / 1e3}s`
     );
   } catch (err) {
     try {
@@ -23419,6 +23530,7 @@ 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 () => {
@@ -23426,8 +23538,8 @@ async function connectSse(id, entry) {
         await client.connect(wrapper);
         wrapper.enableHeartbeat();
       })(),
-      5e3,
-      `Connection initialization timed out after 5s`
+      timeoutMs,
+      `Connection initialization timed out after ${timeoutMs / 1e3}s`
     );
   } catch (err) {
     try {
@@ -24105,7 +24217,7 @@ var StdioServerTransport = class {
 
 // src/constants.ts
 var PKG_NAME = "nuwax-mcp-stdio-proxy";
-var PKG_VERSION = "1.4.7";
+var PKG_VERSION = "1.4.9";
 
 // src/shared.ts
 async function discoverTools(client) {
@@ -24190,7 +24302,7 @@ async function detectProtocol(url2, headers) {
       ...headers
     };
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const timeout = setTimeout(() => controller.abort(), 5e3);
     const res = await fetch(url2, {
       method: "POST",
       headers: reqHeaders,
@@ -24207,52 +24319,51 @@ async function detectProtocol(url2, headers) {
       signal: controller.signal
     });
     clearTimeout(timeout);
-    const ct = res.headers.get("content-type") || "";
-    if (res.ok && (ct.includes("application/json") || ct.includes("text/event-stream"))) {
-      logInfo(`Detected streamable-http protocol for ${url2}`);
+    if (res.headers.get("mcp-session-id")) {
+      logInfo(`Detected streamable-http protocol for ${url2} (mcp-session-id header)`);
+      cleanupSession(url2, res.headers.get("mcp-session-id"), headers);
       await res.text().catch(() => {
       });
-      const sessionId = res.headers.get("mcp-session-id");
-      if (sessionId) {
-        fetch(url2, {
-          method: "DELETE",
-          headers: { "mcp-session-id": sessionId, ...headers },
-          signal: AbortSignal.timeout(5e3)
-        }).catch(() => {
-        });
-      }
       return "stream";
     }
-    await res.text().catch(() => {
-    });
-  } catch {
-  }
-  try {
-    const reqHeaders = {
-      Accept: "text/event-stream",
-      ...headers
-    };
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
-    const res = await fetch(url2, {
-      method: "GET",
-      headers: reqHeaders,
-      signal: controller.signal
-    });
     const ct = res.headers.get("content-type") || "";
-    if (ct.includes("text/event-stream")) {
-      clearTimeout(timeout);
-      logInfo(`Detected SSE protocol for ${url2}`);
+    if (ct.includes("text/event-stream") && res.ok) {
+      logInfo(`Detected streamable-http protocol for ${url2} (event-stream response)`);
+      cleanupSession(url2, res.headers.get("mcp-session-id"), headers);
       controller.abort();
-      return "sse";
+      return "stream";
+    }
+    let bodyText = "";
+    try {
+      bodyText = await res.text();
+    } catch {
+    }
+    try {
+      const json2 = JSON.parse(bodyText);
+      if (json2 && json2.jsonrpc === "2.0") {
+        logInfo(`Detected streamable-http protocol for ${url2} (JSON-RPC 2.0 response)`);
+        cleanupSession(url2, res.headers.get("mcp-session-id"), headers);
+        return "stream";
+      }
+    } catch {
+    }
+    if (res.status === 406) {
+      logInfo(`Detected streamable-http protocol for ${url2} (406 Not Acceptable)`);
+      return "stream";
     }
-    clearTimeout(timeout);
-    await res.text().catch(() => {
-    });
   } catch {
   }
-  logWarn(`Could not auto-detect protocol for ${url2}, defaulting to streamable-http`);
-  return "stream";
+  logWarn(`Could not detect streamable-http for ${url2}, defaulting to SSE`);
+  return "sse";
+}
+function cleanupSession(url2, sessionId, headers) {
+  if (!sessionId) return;
+  fetch(url2, {
+    method: "DELETE",
+    headers: { "mcp-session-id": sessionId, ...headers },
+    signal: AbortSignal.timeout(5e3)
+  }).catch(() => {
+  });
 }
 
 // src/modes/stdio.ts
@@ -24271,52 +24382,69 @@ async function runStdio(config2, allowTools, denyTools) {
   const toolToClient = /* @__PURE__ */ new Map();
   const toolToServer = /* @__PURE__ */ new Map();
   const toolsByName = /* @__PURE__ */ new Map();
-  for (const [id, entry] of entries) {
-    try {
-      let connected;
-      if (isSseEntry(entry)) {
-        connected = await connectSse(id, entry);
-      } else if (isStreamableEntry(entry)) {
-        connected = await connectStreamable(id, entry);
-      } else if (needsProtocolDetection(entry)) {
-        const detected = await detectProtocol(entry.url, buildRequestHeaders(entry));
-        if (detected === "sse") {
-          connected = await connectSse(id, { ...entry, transport: "sse" });
-        } else {
+  const connectableEntries = entries.filter(([id, entry]) => {
+    if (entry.persistent) {
+      logWarn(`Skipping persistent server "${id}" (handled by PersistentMcpBridge)`);
+      return false;
+    }
+    return true;
+  });
+  const results = await Promise.allSettled(
+    connectableEntries.map(async ([id, entry]) => {
+      try {
+        let connected;
+        if (isSseEntry(entry)) {
+          connected = await connectSse(id, entry);
+        } else if (isStreamableEntry(entry)) {
           connected = await connectStreamable(id, entry);
+        } else if (needsProtocolDetection(entry)) {
+          const detected = await detectProtocol(entry.url, buildRequestHeaders(entry));
+          if (detected === "sse") {
+            connected = await connectSse(id, { ...entry, transport: "sse" });
+          } else {
+            connected = await connectStreamable(id, entry);
+          }
+        } else {
+          connected = await connectStdio(id, entry, baseEnv);
         }
-      } else {
-        connected = await connectStdio(id, entry, baseEnv);
-      }
-      const { client, cleanup } = connected;
-      clients.set(id, client);
-      cleanups.set(id, cleanup);
-      let serverTools = await discoverTools(client);
-      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} \u2192 ${serverTools.length} tool(s)`);
-        }
-      }
-      logInfo(
-        `Server "${id}": ${serverTools.length} tool(s)${serverTools.length > 0 ? " \u2014 " + 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) {
+        throw new Error(`Server "${id}": ${e}`);
       }
-    } catch (e) {
-      logError(`Failed to connect to 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);
+    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} \u2192 ${serverTools.length} tool(s)`);
+      }
+    }
+    logInfo(
+      `Server "${id}": ${serverTools.length} tool(s)${serverTools.length > 0 ? " \u2014 " + 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) {
@@ -25829,8 +25957,8 @@ var PersistentMcpBridge = class {
           }
           return t;
         },
-        pingIntervalMs: entry.config.pingIntervalMs,
-        pingTimeoutMs: entry.config.pingTimeoutMs
+        pingIntervalMs: 0
+        // No heartbeat for stdio — child process close/error events handle detection
       });
       const client = new Client(
         { name: "nuwax-persistent-bridge", version: "1.0.0" },
@@ -25848,7 +25976,6 @@ var PersistentMcpBridge = class {
       };
       await wrapper.start();
       await client.connect(wrapper);
-      wrapper.enableHeartbeat();
       entry.client = client;
       entry.transport = wrapper;
       const result = await client.listTools();
@@ -26300,7 +26427,7 @@ function parseConfigJson(json2) {
 }
 function parseConfigFile(filePath) {
   try {
-    const content = fs2.readFileSync(filePath, "utf-8");
+    const content = fs3.readFileSync(filePath, "utf-8");
     const config2 = JSON.parse(content);
     if (!config2.mcpServers || typeof config2.mcpServers !== "object") {
       throw new Error('config must contain a "mcpServers" object');