nuwax-mcp-stdio-proxy 1.4.8 → 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"
 };
@@ -23041,6 +23119,8 @@ var ResilientTransportWrapper = class {
   heartbeatTimer = null;
   consecutiveFailures = 0;
   state = "idle";
+  /** Current retry attempt count (reset on successful connect) */
+  retryAttempt = 0;
   // Handlers required by the Transport interface
   onclose;
   onerror;
@@ -23060,9 +23140,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 +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";
@@ -23087,6 +23176,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 +23184,22 @@ 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.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) {
@@ -23154,6 +23248,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 +23264,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,28 +23276,33 @@ 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();
       }
     }
   }
+  /**
+   * 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) {
@@ -23214,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;
@@ -24114,7 +24217,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.9";
 
 // src/shared.ts
 async function discoverTools(client) {
@@ -26324,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');

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 */
@@ -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
      *
@@ -70,7 +82,12 @@ export declare class ResilientTransportWrapper implements Transport {
     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;
+    /**
+     * 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',
 };
@@ -27,6 +31,8 @@ export class ResilientTransportWrapper {
     heartbeatTimer = null;
     consecutiveFailures = 0;
     state = 'idle';
+    /** Current retry attempt count (reset on successful connect) */
+    retryAttempt = 0;
     // Handlers required by the Transport interface
     onclose;
     onerror;
@@ -50,9 +56,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 +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';
@@ -78,6 +93,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 +103,9 @@ 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.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
@@ -98,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) {
@@ -158,6 +179,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 +200,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 +213,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,15 +233,17 @@ 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();
             }
         }
     }
+    /**
+     * 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
@@ -229,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuwax-mcp-stdio-proxy",
-  "version": "1.4.8",
+  "version": "1.4.9",
   "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"