conduit-mcp 2.1.9 → 2.2.0

package/dist/{chunk-2OAUC6UN.js → chunk-NV56BC2A.js}

@@ -45,7 +45,7 @@ var PING_INTERVAL_MS = 1e4;
 var LONG_POLL_TIMEOUT_MS = 25e3;
 var MAX_PORT_RETRIES = 10;
 var REGISTRATION_TIMEOUT_MS = 1e4;
-var FIRST_CONNECT_WAIT_MS = 3e3;
+var FIRST_CONNECT_WAIT_MS = 1e4;
 var Bridge = class extends EventEmitter {
   constructor(port = 3200) {
     super();
@@ -68,6 +68,9 @@ var Bridge = class extends EventEmitter {
   // HTTP fallback state (per-studio)
   httpPendingCommands = /* @__PURE__ */ new Map();
   httpPollWaiters = /* @__PURE__ */ new Map();
+  // Set by the host process; reports whether the MCP client driving this server
+  // is still attached. Used to refuse /shutdown while we're actively serving.
+  clientAliveCheck = null;
   get isConnected() {
     for (const [, studio] of this.studios) {
       if (studio.ws.readyState === WebSocket.OPEN) return true;
@@ -99,8 +102,37 @@ var Bridge = class extends EventEmitter {
   }
   // ── Server lifecycle ───────────────────────────────────────────
   /**
-   * Try to shut down a stale Conduit instance on the target port.
-   * Returns true if the port was freed (or was already free).
+   * Check whether the process holding a port is a healthy Conduit server.
+   * Returns true only when /health answers with the Conduit signature —
+   * meaning another live MCP session is being served on that port.
+   */
+  async isLiveConduit(port) {
+    return new Promise((resolve) => {
+      const req = http.request(
+        { hostname: "127.0.0.1", port, path: "/health", method: "GET", timeout: 2e3 },
+        (res) => {
+          let body = "";
+          res.on("data", (chunk) => body += chunk);
+          res.on("end", () => {
+            try {
+              resolve(JSON.parse(body)?.status === "ok");
+            } catch {
+              resolve(false);
+            }
+          });
+        }
+      );
+      req.on("error", () => resolve(false));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(false);
+      });
+      req.end();
+    });
+  }
+  /**
+   * Try to shut down a wedged Conduit instance on the target port.
+   * Returns true if the shutdown request was accepted.
    */
   async evictStaleInstance(port) {
     return new Promise((resolve) => {
@@ -114,7 +146,7 @@ var Bridge = class extends EventEmitter {
         },
         (res) => {
           res.resume();
-          setTimeout(() => resolve(true), 500);
+          setTimeout(() => resolve(res.statusCode === 200), 500);
         }
       );
       req.on("error", () => resolve(false));
@@ -126,20 +158,29 @@ var Bridge = class extends EventEmitter {
     });
   }
   async start() {
-    await this.evictStaleInstance(this.port);
     return new Promise((resolve, reject) => {
       let attempts = 0;
-      const tryPort = (port) => {
+      const tryPort = (port, allowEvict) => {
         const server = http.createServer(
           (req, res) => this.handleHttp(req, res)
         );
-        server.once("error", (err) => {
+        server.once("error", async (err) => {
           if (err.code === "EADDRINUSE" && attempts < MAX_PORT_RETRIES) {
             attempts++;
-            log.warn(
-              `Port ${port} still in use after eviction \u2014 trying ${port + 1}`
-            );
-            tryPort(port + 1);
+            if (await this.isLiveConduit(port)) {
+              log.info(
+                `Port ${port} is serving another Conduit session \u2014 trying ${port + 1}`
+              );
+              tryPort(port + 1, true);
+              return;
+            }
+            if (allowEvict && await this.evictStaleInstance(port)) {
+              log.warn(`Evicted unresponsive instance on port ${port} \u2014 retrying`);
+              tryPort(port, false);
+              return;
+            }
+            log.warn(`Port ${port} in use \u2014 trying ${port + 1}`);
+            tryPort(port + 1, true);
           } else {
             reject(err);
           }
@@ -153,7 +194,7 @@ var Bridge = class extends EventEmitter {
           resolve(port);
         });
       };
-      tryPort(this.port);
+      tryPort(this.port, true);
     });
   }
   async stop() {
@@ -455,9 +496,31 @@ var Bridge = class extends EventEmitter {
     }
     this.studios.set(studioId, { ws, info });
     this.lastHeartbeats.set(studioId, Date.now());
+    if (this.httpStudios.has(studioId)) {
+      this.httpStudios.delete(studioId);
+      const waiters = this.httpPollWaiters.get(studioId) ?? [];
+      for (const waiter of waiters) {
+        clearTimeout(waiter.timer);
+        waiter.res.writeHead(204);
+        waiter.res.end();
+      }
+      this.httpPollWaiters.delete(studioId);
+      const queued = this.httpPendingCommands.get(studioId) ?? [];
+      this.httpPendingCommands.delete(studioId);
+      for (const cmd of queued) {
+        ws.send(JSON.stringify(cmd));
+      }
+      if (queued.length > 0) {
+        log.info(
+          `Re-dispatched ${queued.length} queued command(s) over WebSocket for studio ${studioId}`
+        );
+      }
+    }
     ws.isAlive = true;
+    ws.missedPongs = 0;
     ws.on("pong", () => {
       ws.isAlive = true;
+      ws.missedPongs = 0;
     });
     if (this.activeStudioId === null || this.activeStudioId === studioId) {
       this.activeStudioId = studioId;
@@ -560,6 +623,10 @@ var Bridge = class extends EventEmitter {
       const now = Date.now();
       for (const [studioId, lastBeat] of this.lastHeartbeats) {
         if (now - lastBeat > HEARTBEAT_TIMEOUT_MS) {
+          if (!this.studios.has(studioId) && (this.httpPollWaiters.get(studioId)?.length ?? 0) > 0) {
+            this.lastHeartbeats.set(studioId, now);
+            continue;
+          }
           const studio = this.studios.get(studioId);
           if (studio) {
             log.warn(
@@ -602,14 +669,23 @@ var Bridge = class extends EventEmitter {
       for (const [studioId, studio] of this.studios) {
         const ws = studio.ws;
         if (ws.isAlive === false) {
-          log.warn(
-            `Ping timeout for studio "${studioId}" \u2014 terminating connection`
-          );
-          ws.terminate();
-          return;
+          ws.missedPongs = (ws.missedPongs ?? 0) + 1;
+          if (ws.missedPongs >= 2) {
+            log.warn(
+              `No pong from studio "${studioId}" after ${ws.missedPongs} pings \u2014 terminating connection`
+            );
+            ws.terminate();
+            continue;
+          }
+          log.warn(`Missed pong from studio "${studioId}" \u2014 retrying`);
+        } else {
+          ws.missedPongs = 0;
         }
         ws.isAlive = false;
-        ws.ping();
+        try {
+          ws.ping();
+        } catch {
+        }
       }
     }, PING_INTERVAL_MS);
   }
@@ -640,6 +716,12 @@ var Bridge = class extends EventEmitter {
         res.end("Forbidden");
         return;
       }
+      if (this.clientAliveCheck && this.clientAliveCheck()) {
+        log.warn("Refusing shutdown request \u2014 MCP client is still attached");
+        res.writeHead(409);
+        res.end("busy");
+        return;
+      }
       log.info("Received shutdown request from new Conduit instance");
       res.writeHead(200);
       res.end("ok");
@@ -732,6 +814,16 @@ var Bridge = class extends EventEmitter {
     const waiters = this.httpPollWaiters.get(studioId) ?? [];
     waiters.push({ res, timer });
     this.httpPollWaiters.set(studioId, waiters);
+    res.on("close", () => {
+      if (res.writableEnded) return;
+      clearTimeout(timer);
+      const current = this.httpPollWaiters.get(studioId);
+      if (current) {
+        const idx = current.findIndex((w) => w.res === res);
+        if (idx !== -1) current.splice(idx, 1);
+        if (current.length === 0) this.httpPollWaiters.delete(studioId);
+      }
+    });
   }
   handleResult(req, res) {
     const MAX_BODY_SIZE = 10 * 1024 * 1024;
@@ -766,10 +858,17 @@ var Bridge = class extends EventEmitter {
     const queue = this.httpPendingCommands.get(studioId) ?? [];
     while (waiters.length > 0 && queue.length > 0) {
       const waiter = waiters.shift();
-      const cmd = queue.shift();
       clearTimeout(waiter.timer);
-      waiter.res.writeHead(200, { "Content-Type": "application/json" });
-      waiter.res.end(JSON.stringify(cmd));
+      if (waiter.res.destroyed || waiter.res.writableEnded) {
+        continue;
+      }
+      const cmd = queue.shift();
+      try {
+        waiter.res.writeHead(200, { "Content-Type": "application/json" });
+        waiter.res.end(JSON.stringify(cmd));
+      } catch {
+        queue.unshift(cmd);
+      }
     }
     if (waiters.length === 0) this.httpPollWaiters.delete(studioId);
     if (queue.length === 0) this.httpPendingCommands.delete(studioId);
@@ -2701,9 +2800,19 @@ async function startServer(port = 3200, options = {}) {
   bridge.on("shutdown", shutdown);
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
+  let clientAlive = true;
+  const onClientGone = () => {
+    if (!clientAlive) return;
+    clientAlive = false;
+    log.info("MCP client disconnected (stdin closed) \u2014 shutting down");
+    void shutdown();
+  };
+  process.stdin.on("end", onClientGone);
+  process.stdin.on("close", onClientGone);
+  bridge.clientAliveCheck = () => clientAlive;
 }
 
 export {
   startServer
 };
-//# sourceMappingURL=chunk-2OAUC6UN.js.map
+//# sourceMappingURL=chunk-NV56BC2A.js.map