up-mcp-bridge 1.0.21 → 1.0.22

package/dist/{chunk-AEDNEZ76.js → chunk-FN3ZSOWT.js}

@@ -20163,13 +20163,9 @@ function mcpProxy({
   let inPersistentRetry = false;
   let connectionHealthy = true;
   let mcpSessionInitialized = false;
-  const HANDSHAKE_METHODS = /* @__PURE__ */ new Set([
+  const PRE_INIT_METHODS = /* @__PURE__ */ new Set([
     "initialize",
     "notifications/initialized",
-    "tools/list",
-    "resources/list",
-    "prompts/list",
-    "resources/templates/list",
     "ping"
   ]);
   const pendingMessages = [];
@@ -20195,6 +20191,7 @@ function mcpProxy({
   const maxDelayMs = reconnectOptions.maxDelayMs ?? 15e3;
   const connectionTimeoutMs = reconnectOptions.connectionTimeoutMs ?? 5e3;
   const persistentRetryDelayMs = reconnectOptions.persistentRetryDelayMs ?? 3e4;
+  const maxReconnectDurationMs = reconnectOptions.maxReconnectDurationMs ?? 3e5;
   const messageTimeoutMs = 6e4;
   const requestTimeoutMs = 5e3;
   const maxConsecutiveTimeouts = 3;
@@ -20654,11 +20651,21 @@ function mcpProxy({
         log(`Remote transport closed. Starting reconnection loop...`);
         debugLog("Remote transport closed, starting reconnection loop", { attempt: reconnectAttempts + 1 });
         isReconnecting = true;
+        let persistentStartTime;
         while (!transportToClientClosed) {
           reconnectAttempts++;
           if (!inPersistentRetry && reconnectAttempts > reconnectOptions.maxAttempts) {
             inPersistentRetry = true;
-            log(`[Persistent] Entering persistent retry mode after ${reconnectOptions.maxAttempts} fast attempts. Will retry every ${persistentRetryDelayMs / 1e3}s indefinitely until gateway recovers.`);
+            persistentStartTime = Date.now();
+            log(`[Persistent] Entering persistent retry mode after ${reconnectOptions.maxAttempts} fast attempts. Will retry every ${persistentRetryDelayMs / 1e3}s for up to ${maxReconnectDurationMs / 1e3}s before self-destruct.`);
+          }
+          if (inPersistentRetry && persistentStartTime && Date.now() - persistentStartTime > maxReconnectDurationMs) {
+            const elapsedSec = Math.round((Date.now() - persistentStartTime) / 1e3);
+            log(`[BUG-006 Self-destruct] Reconnection failed for ${elapsedSec}s (limit: ${maxReconnectDurationMs / 1e3}s). Exiting process for clean restart.`);
+            flushAllPendingMessagesWithError("Bridge self-destructing after prolonged reconnection failure");
+            clearInterval(statusInterval);
+            stopBackgroundHeartbeat();
+            process.exit(1);
           }
           let delay;
           let logThisAttempt;
@@ -20735,8 +20742,10 @@ function mcpProxy({
             log(`[Queue] Flush complete: ${flushedCount} sent, ${expiredCount} expired`);
             return;
           } catch (error2) {
-            log(`Reconnection attempt ${reconnectAttempts} failed:`, error2);
-            debugLog("Reconnection attempt failed", { error: error2, attempts: reconnectAttempts });
+            const errorCode = error2?.code || error2?.event?.code || "unknown";
+            const errorStr = String(error2).substring(0, 200);
+            log(`Reconnection attempt ${reconnectAttempts} failed (HTTP ${errorCode}): ${errorStr}`);
+            debugLog("Reconnection attempt failed", { error: error2, errorCode, attempts: reconnectAttempts, serverUrl });
           }
         }
         log(`Reconnection loop ended: client disconnected after ${reconnectAttempts} attempts.`);
@@ -20853,12 +20862,12 @@ function mcpProxy({
       });
       return;
     }
-    if (!mcpSessionInitialized && !HANDSHAKE_METHODS.has(message.method)) {
+    if (!mcpSessionInitialized && !PRE_INIT_METHODS.has(message.method)) {
       log(`[BUG-005] Session not initialized, queuing message ${message.id || "(no id)"} (${message.method})`);
       log("[Local\u2192Remote] (queuing - session not initialized)", message.method || message.id);
       queueMessageForRetry(message);
       if (pendingMessages.length === 1) {
-        log("[BUG-005] Messages will be sent after server confirms session is initialized.");
+        log("[BUG-005] Messages will be sent after notifications/initialized confirms session.");
       }
       return;
     }
@@ -20880,10 +20889,28 @@ function mcpProxy({
         log(`[BUG-003 SendSlow] Message ${message.id || "(no id)"} (${message.method}) send() took ${sendDuration}ms`);
       }
       if (message.method === "notifications/initialized") {
-        log("[MCP Init] notifications/initialized sent to server, awaiting confirmation via first successful response...");
+        mcpSessionInitialized = true;
+        log("[MCP Init] notifications/initialized sent to server, session marked as initialized");
         const queueSize = pendingMessages.length;
         if (queueSize > 0) {
-          log(`[MCP Init] ${queueSize} messages queued, will flush after server confirms session`);
+          log(`[MCP Init] Flushing ${queueSize} queued messages after session confirmed`);
+          let flushedCount = 0;
+          while (pendingMessages.length > 0) {
+            const pending = pendingMessages.shift();
+            if (pending.message.id) {
+              queuedMessageIds.delete(pending.message.id);
+            }
+            if (Date.now() - pending.timestamp < messageTimeoutMs) {
+              log(`[MCP Init] Sending queued message ${pending.message.id || "(no id)"} (${pending.message.method})`);
+              trackRequest(pending.message);
+              currentTransportToServer.send(pending.message).catch(onServerError);
+              flushedCount++;
+            } else {
+              log(`[MCP Init] Message ${pending.message.id} expired during init wait`);
+              sendErrorForPendingMessage(pending, "Request timed out waiting for MCP session initialization");
+            }
+          }
+          log(`[MCP Init] Flush complete: ${flushedCount} messages sent`);
         }
       }
     }).catch((error2) => {
@@ -21318,16 +21345,28 @@ async function parseCommandLineArgs(args, usage) {
       log(`Warning: Ignoring invalid --persistent-retry-delay value: ${args[persistentRetryDelayIndex + 1]}. Must be a positive number.`);
     }
   }
+  let maxReconnectDurationMs = 3e5;
+  const maxReconnectDurationIndex = args.indexOf("--max-reconnect-duration");
+  if (maxReconnectDurationIndex !== -1 && maxReconnectDurationIndex < args.length - 1) {
+    const value = parseInt(args[maxReconnectDurationIndex + 1], 10);
+    if (!isNaN(value) && value > 0) {
+      maxReconnectDurationMs = value;
+      log(`Using max reconnect duration: ${maxReconnectDurationMs}ms (${maxReconnectDurationMs / 1e3}s)`);
+    } else {
+      log(`Warning: Ignoring invalid --max-reconnect-duration value: ${args[maxReconnectDurationIndex + 1]}. Must be a positive number.`);
+    }
+  }
   const reconnectOptions = {
     enabled: autoReconnect,
     maxAttempts: maxReconnectAttempts,
     baseDelayMs: reconnectDelayMs,
     maxDelayMs: maxReconnectDelayMs,
     connectionTimeoutMs,
-    persistentRetryDelayMs
+    persistentRetryDelayMs,
+    maxReconnectDurationMs
   };
   if (autoReconnect) {
-    log(`Auto-reconnect enabled: fast phase: ${maxReconnectAttempts} attempts (${reconnectDelayMs}ms\u2192${maxReconnectDelayMs}ms backoff), persistent phase: every ${persistentRetryDelayMs / 1e3}s indefinitely`);
+    log(`Auto-reconnect enabled: fast phase: ${maxReconnectAttempts} attempts (${reconnectDelayMs}ms\u2192${maxReconnectDelayMs}ms backoff), persistent phase: every ${persistentRetryDelayMs / 1e3}s for up to ${maxReconnectDurationMs / 1e3}s`);
   }
   if (!serverUrl) {
     log(usage);

package/dist/client.js

@@ -12,7 +12,7 @@ import {
   parseCommandLineArgs,
   setupSignalHandlers,
   version
-} from "./chunk-AEDNEZ76.js";
+} from "./chunk-FN3ZSOWT.js";
 
 // src/client.ts
 import { EventEmitter } from "events";

package/dist/proxy.js

@@ -11,7 +11,7 @@ import {
   parseCommandLineArgs,
   setupSignalHandlers,
   version
-} from "./chunk-AEDNEZ76.js";
+} from "./chunk-FN3ZSOWT.js";
 
 // src/proxy.ts
 import { EventEmitter } from "events";
@@ -131,6 +131,7 @@ Options:
   --reconnect-delay N          Base delay between fast attempts in ms (default: 1000)
   --max-reconnect-delay N      Maximum delay in fast phase in ms (default: 15000)
   --persistent-retry-delay N   Fixed delay in persistent phase in ms (default: 30000)
+  --max-reconnect-duration N   Max time in persistent phase before self-destruct in ms (default: 300000)
   --connection-timeout N       Connection timeout in ms (default: 5000)
   --transport STRATEGY         Transport strategy: sse-only, http-only, sse-first, http-first
   --header "Key: Value"        Add custom header (can be repeated)
@@ -138,8 +139,10 @@ Options:
 
 Reconnection behavior (two-phase):
   Fast phase:       Attempts 1-N with exponential backoff (1s\u21922s\u21924s\u2192...\u219215s)
-  Persistent phase: After N attempts, retries every 30s indefinitely until
-                    the gateway recovers or the client disconnects.
+  Persistent phase: After N attempts, retries every 30s for up to 5 minutes
+                    (configurable via --max-reconnect-duration). If the gateway
+                    doesn't recover, the bridge exits so the MCP client can
+                    spawn a fresh process that connects cleanly.
 
 Example:
   npx up-mcp-bridge http://localhost:3000/sse --auto-reconnect
@@ -203,7 +206,7 @@ async function runProxy(serverUrl, callbackPort, headers, transportStrategy = "h
     log("Local STDIO server running");
     log(`Proxy established successfully between local STDIO and remote ${remoteTransport.constructor.name}`);
     if (reconnectOptions.enabled) {
-      log(`Auto-reconnect enabled (fast: ${reconnectOptions.maxAttempts} attempts, persistent: every ${(reconnectOptions.persistentRetryDelayMs ?? 3e4) / 1e3}s, never gives up)`);
+      log(`Auto-reconnect enabled (fast: ${reconnectOptions.maxAttempts} attempts, persistent: every ${(reconnectOptions.persistentRetryDelayMs ?? 3e4) / 1e3}s, max duration: ${(reconnectOptions.maxReconnectDurationMs ?? 3e5) / 1e3}s)`);
     }
     log("Press Ctrl+C to exit");
     const cleanup = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "up-mcp-bridge",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "description": "Remote proxy for MCP with auto-reconnect support. Fork of mcp-remote with transparent server restart handling.",
   "keywords": [
     "mcp",