nuwax-mcp-stdio-proxy 1.4.8 → 1.4.10

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,15 @@ var ResilientTransportWrapper = class {
   mcpClient = null;
   heartbeatTimer = null;
   consecutiveFailures = 0;
+  /** Captured MCP initialize request for replay on reconnect */
+  initializeMessage = null;
+  /** Captured MCP notifications/initialized for replay on reconnect */
+  initializedNotification = null;
+  /** Pending re-initialize promise resolver */
+  pendingReInit = null;
   state = "idle";
+  /** Current retry attempt count (reset on successful connect) */
+  retryAttempt = 0;
   // Handlers required by the Transport interface
   onclose;
   onerror;
@@ -23060,9 +23146,18 @@ var ResilientTransportWrapper = class {
       ...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
    *
@@ -23072,7 +23167,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";
@@ -23087,6 +23182,7 @@ var ResilientTransportWrapper = class {
     this.startHeartbeat();
   }
   async performConnect(initial = false) {
+    if (this.state === "closed") return;
     try {
       this.activeTransport = await this.options.connectParams();
       this.bindInnerTransport(this.activeTransport);
@@ -23094,18 +23190,77 @@ var ResilientTransportWrapper = class {
       this.state = "connected";
       this.consecutiveFailures = 0;
       this.consecutivePingTimeouts = 0;
-      this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] Connected via ${this.activeTransport.constructor.name}`);
+      this.heartbeatOkCount = 0;
+      this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u2705 Connected via ${this.activeTransport.constructor.name}`);
+      if (!initial && this.initializeMessage) {
+        this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F504} Re-initializing MCP session...`);
+        try {
+          await this.performReInitialize();
+          this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u2705 MCP session re-initialized`);
+        } catch (err) {
+          this.retryAttempt++;
+          const delay = this.getBackoffDelay();
+          this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] \u274C Re-initialize failed: ${err}`);
+          this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F504} Retrying in ${delay}ms (attempt ${this.retryAttempt})...`);
+          this.state = "reconnecting";
+          this.cleanupTransport();
+          setTimeout(() => {
+            this.performConnect();
+          }, delay);
+          return;
+        }
+      }
+      this.retryAttempt = 0;
       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);
+    }
+  }
+  /**
+   * Replay the MCP initialize handshake on a reconnected transport.
+   * Sends the captured `initialize` request with a unique internal ID,
+   * waits for the response, then sends `notifications/initialized`.
+   */
+  async performReInitialize() {
+    if (!this.activeTransport || !this.initializeMessage) {
+      throw new Error("No transport or no captured initialize message");
+    }
+    const initId = `respl-init-${Date.now()}`;
+    const initRequest = {
+      ...this.initializeMessage,
+      id: initId
+    };
+    const initPromise = new Promise((resolve) => {
+      this.pendingReInit = resolve;
+      setTimeout(() => {
+        if (this.pendingReInit) {
+          this.pendingReInit = null;
+          resolve(false);
+        }
+      }, this.options.pingTimeoutMs);
+    });
+    try {
+      await this.activeTransport.send(initRequest);
+    } catch (err) {
+      this.pendingReInit = null;
+      throw err;
+    }
+    const success2 = await initPromise;
+    if (!success2) {
+      throw new Error("Re-initialize timed out");
+    }
+    if (this.initializedNotification) {
+      await this.activeTransport.send(this.initializedNotification);
     }
   }
   bindInnerTransport(transport) {
@@ -23126,6 +23281,13 @@ var ResilientTransportWrapper = class {
       }
     };
     transport.onmessage = (message) => {
+      if ("id" in message && typeof message.id === "string" && message.id.startsWith("respl-init-")) {
+        if (this.pendingReInit) {
+          this.pendingReInit(true);
+          this.pendingReInit = null;
+        }
+        return;
+      }
       if ("id" in message && typeof message.id === "string" && message.id.startsWith("respl-ping-")) {
         const resolve = this.pendingPings.get(message.id);
         if (resolve) {
@@ -23154,6 +23316,8 @@ var ResilientTransportWrapper = class {
   }
   /** Track consecutive ping timeouts (no response at all, not even an error) */
   consecutivePingTimeouts = 0;
+  /** Successful heartbeat counter (for reducing log volume) */
+  heartbeatOkCount = 0;
   async checkHealth() {
     if (this.state !== "connected" || !this.activeTransport) return;
     try {
@@ -23168,7 +23332,6 @@ var ResilientTransportWrapper = class {
         }, this.options.pingTimeoutMs);
       });
       try {
-        this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F493} Sending heartbeat (id: ${healthId})`);
         await this.activeTransport.send({
           jsonrpc: "2.0",
           id: healthId,
@@ -23181,30 +23344,32 @@ var ResilientTransportWrapper = class {
       const success2 = await responsePromise;
       if (!success2) {
         this.consecutivePingTimeouts++;
-        this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Heartbeat timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
+        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.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat timeouts reached. Force reconnecting.`);
+          this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat timeouts reached. Closing and retrying...`);
           this.triggerReconnect();
         }
         return;
       }
-      this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F496} Heartbeat OK (id: ${healthId})`);
+      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 (${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();
       }
     }
   }
-  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();
+  /**
+   * Detach handlers from and close the current active transport.
+   */
+  cleanupTransport() {
     if (this.activeTransport) {
       this.activeTransport.onclose = void 0;
       this.activeTransport.onerror = void 0;
@@ -23214,9 +23379,21 @@ var ResilientTransportWrapper = class {
       }
       this.activeTransport = null;
     }
+  }
+  /**
+   * Close the current transport and schedule a reconnect with exponential backoff.
+   */
+  triggerReconnect() {
+    if (this.state === "reconnecting" || this.state === "closed") return;
+    this.state = "reconnecting";
+    this.stopHeartbeat();
+    this.cleanupTransport();
+    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;
@@ -23251,6 +23428,10 @@ var ResilientTransportWrapper = class {
       this.messageQueue.push(message);
       return;
     }
+    if ("method" in message) {
+      if (message.method === "initialize") this.initializeMessage = message;
+      else if (message.method === "notifications/initialized") this.initializedNotification = message;
+    }
     if (!this.activeTransport) {
       throw new Error("No active transport to send message");
     }
@@ -24114,7 +24295,7 @@ var StdioServerTransport = class {
 
 // src/constants.ts
 var PKG_NAME = "nuwax-mcp-stdio-proxy";
-var PKG_VERSION = "1.4.8";
+var PKG_VERSION = "1.4.10";
 
 // src/shared.ts
 async function discoverTools(client) {
@@ -26324,7 +26505,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');

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/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 */
@@ -42,13 +47,26 @@ export declare class ResilientTransportWrapper implements Transport {
     private mcpClient;
     private heartbeatTimer;
     private consecutiveFailures;
+    /** Captured MCP initialize request for replay on reconnect */
+    private initializeMessage;
+    /** Captured MCP notifications/initialized for replay on reconnect */
+    private initializedNotification;
+    /** Pending re-initialize promise resolver */
+    private pendingReInit;
     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
      *
@@ -65,12 +83,27 @@ export declare class ResilientTransportWrapper implements Transport {
      */
     enableHeartbeat(): void;
     private performConnect;
+    /**
+     * Replay the MCP initialize handshake on a reconnected transport.
+     * Sends the captured `initialize` request with a unique internal ID,
+     * waits for the response, then sends `notifications/initialized`.
+     */
+    private performReInitialize;
     private bindInnerTransport;
     private startHeartbeat;
     private stopHeartbeat;
     /** Track consecutive ping timeouts (no response at all, not even an error) */
     private consecutivePingTimeouts;
+    /** Successful heartbeat counter (for reducing log volume) */
+    private heartbeatOkCount;
     private checkHealth;
+    /**
+     * Detach handlers from and close the current active transport.
+     */
+    private cleanupTransport;
+    /**
+     * 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,15 @@ export class ResilientTransportWrapper {
     mcpClient = null;
     heartbeatTimer = null;
     consecutiveFailures = 0;
+    /** Captured MCP initialize request for replay on reconnect */
+    initializeMessage = null;
+    /** Captured MCP notifications/initialized for replay on reconnect */
+    initializedNotification = null;
+    /** Pending re-initialize promise resolver */
+    pendingReInit = null;
     state = 'idle';
+    /** Current retry attempt count (reset on successful connect) */
+    retryAttempt = 0;
     // Handlers required by the Transport interface
     onclose;
     onerror;
@@ -50,9 +62,18 @@ export class ResilientTransportWrapper {
             ...(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
      *
@@ -62,8 +83,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';
@@ -78,6 +99,8 @@ export class ResilientTransportWrapper {
         this.startHeartbeat();
     }
     async performConnect(initial = false) {
+        if (this.state === 'closed')
+            return;
         try {
             this.activeTransport = await this.options.connectParams();
             // Inherit the handlers from this wrapper
@@ -86,7 +109,33 @@ export class ResilientTransportWrapper {
             this.state = 'connected';
             this.consecutiveFailures = 0;
             this.consecutivePingTimeouts = 0;
-            this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] Connected via ${this.activeTransport.constructor.name}`);
+            this.heartbeatOkCount = 0;
+            this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] ✅ Connected via ${this.activeTransport.constructor.name}`);
+            // On reconnect, replay MCP initialize handshake before doing anything else.
+            // The server requires initialize + notifications/initialized before accepting
+            // any other requests (tools/list, etc).
+            if (!initial && this.initializeMessage) {
+                this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 🔄 Re-initializing MCP session...`);
+                try {
+                    await this.performReInitialize();
+                    this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] ✅ MCP session re-initialized`);
+                }
+                catch (err) {
+                    // Re-initialize failed — treat as a connect failure, preserve backoff
+                    this.retryAttempt++;
+                    const delay = this.getBackoffDelay();
+                    this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] ❌ Re-initialize failed: ${err}`);
+                    this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 🔄 Retrying in ${delay}ms (attempt ${this.retryAttempt})...`);
+                    this.state = 'reconnecting';
+                    this.cleanupTransport();
+                    setTimeout(() => {
+                        this.performConnect();
+                    }, delay);
+                    return;
+                }
+            }
+            // Reset retry count only after successful connect + re-initialize
+            this.retryAttempt = 0;
             // Flush any queued messages
             this.flushQueue();
             // Only start heartbeat on reconnects — initial connections need
@@ -98,12 +147,54 @@ 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);
+        }
+    }
+    /**
+     * Replay the MCP initialize handshake on a reconnected transport.
+     * Sends the captured `initialize` request with a unique internal ID,
+     * waits for the response, then sends `notifications/initialized`.
+     */
+    async performReInitialize() {
+        if (!this.activeTransport || !this.initializeMessage) {
+            throw new Error('No transport or no captured initialize message');
+        }
+        const initId = `respl-init-${Date.now()}`;
+        // Build the re-initialize request using the original params but with our internal ID
+        const initRequest = {
+            ...this.initializeMessage,
+            id: initId,
+        };
+        const initPromise = new Promise((resolve) => {
+            this.pendingReInit = resolve;
+            setTimeout(() => {
+                if (this.pendingReInit) {
+                    this.pendingReInit = null;
+                    resolve(false); // Timeout
+                }
+            }, this.options.pingTimeoutMs);
+        });
+        try {
+            await this.activeTransport.send(initRequest);
+        }
+        catch (err) {
+            this.pendingReInit = null;
+            throw err;
+        }
+        const success = await initPromise;
+        if (!success) {
+            throw new Error('Re-initialize timed out');
+        }
+        // Send notifications/initialized if we captured it
+        if (this.initializedNotification) {
+            await this.activeTransport.send(this.initializedNotification);
         }
     }
     bindInnerTransport(transport) {
@@ -127,6 +218,14 @@ export class ResilientTransportWrapper {
             }
         };
         transport.onmessage = (message) => {
+            // Intercept re-initialize responses (don't forward to Client)
+            if ('id' in message && typeof message.id === 'string' && message.id.startsWith('respl-init-')) {
+                if (this.pendingReInit) {
+                    this.pendingReInit(true);
+                    this.pendingReInit = null;
+                }
+                return;
+            }
             // 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);
@@ -158,6 +257,8 @@ export class ResilientTransportWrapper {
     }
     /** Track consecutive ping timeouts (no response at all, not even an error) */
     consecutivePingTimeouts = 0;
+    /** Successful heartbeat counter (for reducing log volume) */
+    heartbeatOkCount = 0;
     async checkHealth() {
         if (this.state !== 'connected' || !this.activeTransport)
             return;
@@ -177,7 +278,6 @@ export class ResilientTransportWrapper {
             });
             // Try to send tools/list — if send() throws, the transport itself is broken
             try {
-                this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 💓 Sending heartbeat (id: ${healthId})`);
                 await this.activeTransport.send({
                     jsonrpc: '2.0',
                     id: healthId,
@@ -191,15 +291,19 @@ export class ResilientTransportWrapper {
             const success = await responsePromise;
             if (!success) {
                 this.consecutivePingTimeouts++;
-                this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Heartbeat timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
+                this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] ⏱️ Heartbeat timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
                 if (this.consecutivePingTimeouts >= this.options.maxConsecutiveFailures) {
-                    this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat timeouts reached. Force reconnecting.`);
+                    this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat timeouts reached. Closing and retrying...`);
                     this.triggerReconnect();
                 }
                 return;
             }
             // Got a response — server is alive
-            this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 💖 Heartbeat OK (id: ${healthId})`);
+            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;
         }
@@ -207,20 +311,16 @@ export class ResilientTransportWrapper {
             this.consecutiveFailures++;
             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();
             }
         }
     }
-    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
+    /**
+     * Detach handlers from and close the current active transport.
+     */
+    cleanupTransport() {
         if (this.activeTransport) {
-            // Avoid triggering our own onclose
             this.activeTransport.onclose = undefined;
             this.activeTransport.onerror = undefined;
             try {
@@ -229,9 +329,22 @@ export class ResilientTransportWrapper {
             catch { /* ignore */ }
             this.activeTransport = null;
         }
+    }
+    /**
+     * Close the current transport and schedule a reconnect with exponential backoff.
+     */
+    triggerReconnect() {
+        if (this.state === 'reconnecting' || this.state === 'closed')
+            return;
+        this.state = 'reconnecting';
+        this.stopHeartbeat();
+        this.cleanupTransport();
+        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')
@@ -270,6 +383,13 @@ export class ResilientTransportWrapper {
             this.messageQueue.push(message);
             return;
         }
+        // Capture initialize handshake messages for replay on reconnect
+        if ('method' in message) {
+            if (message.method === 'initialize')
+                this.initializeMessage = message;
+            else if (message.method === 'notifications/initialized')
+                this.initializedNotification = message;
+        }
         if (!this.activeTransport) {
             throw new Error('No active transport to send message');
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuwax-mcp-stdio-proxy",
-  "version": "1.4.8",
+  "version": "1.4.10",
   "description": "TypeScript MCP proxy — aggregates multiple MCP servers (stdio + streamable-http + SSE) with convert & proxy modes",
   "type": "module",
   "bin": {
@@ -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"