conduit-mcp 2.1.8 → 2.2.0

package/dist/{chunk-LNENHU6Z.js → chunk-NV56BC2A.js}

@@ -40,11 +40,12 @@ var log = {
 // src/bridge.ts
 var REQUEST_TIMEOUT_MS = 6e4;
 var HEARTBEAT_CHECK_INTERVAL_MS = 5e3;
-var HEARTBEAT_TIMEOUT_MS = 15e3;
+var HEARTBEAT_TIMEOUT_MS = 2e4;
 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 = 1e4;
 var Bridge = class extends EventEmitter {
   constructor(port = 3200) {
     super();
@@ -67,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;
@@ -98,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) => {
@@ -113,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));
@@ -125,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);
           }
@@ -152,7 +194,7 @@ var Bridge = class extends EventEmitter {
           resolve(port);
         });
       };
-      tryPort(this.port);
+      tryPort(this.port, true);
     });
   }
   async stop() {
@@ -212,6 +254,12 @@ var Bridge = class extends EventEmitter {
     const id = generateId();
     const request = { id, method, params };
     const json = JSON.stringify(request);
+    if (this.studios.size === 0 && this.httpStudios.size === 0) {
+      await this.waitForFirstStudio(FIRST_CONNECT_WAIT_MS);
+      if (this.studios.size === 0 && this.httpStudios.size === 0) {
+        throw this.buildPluginNotConnectedError(method);
+      }
+    }
     const studio = this.resolveTargetStudio();
     const targetStudioId = this.activeStudioId;
     const effectiveTimeout = timeoutMs ?? REQUEST_TIMEOUT_MS;
@@ -220,7 +268,12 @@ var Bridge = class extends EventEmitter {
         this.pendingRequests.delete(id);
         reject(this.buildTimeoutError(method, effectiveTimeout, targetStudioId));
       }, effectiveTimeout);
-      this.pendingRequests.set(id, { resolve, reject, timer });
+      this.pendingRequests.set(id, {
+        resolve,
+        reject,
+        timer,
+        studioId: targetStudioId
+      });
       if (studio) {
         studio.ws.send(json, (err) => {
           if (err) {
@@ -246,6 +299,32 @@ var Bridge = class extends EventEmitter {
       }
     });
   }
+  // Wait for any studio to register, up to timeoutMs. Resolves immediately if
+  // one is already connected. Used to absorb the startup race between MCP
+  // initialize (instant) and the plugin's WebSocket handshake (~hundreds of ms).
+  waitForFirstStudio(timeoutMs) {
+    if (this.studios.size > 0 || this.httpStudios.size > 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.off("studio-connected", onConnect);
+        resolve();
+      }, timeoutMs);
+      const onConnect = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      this.once("studio-connected", onConnect);
+    });
+  }
+  buildPluginNotConnectedError(method) {
+    const err = new Error(
+      `Cannot ${method}: the Roblox Studio plugin is not connected. Open Roblox Studio with the Conduit plugin enabled \u2014 it auto-connects when HttpService is allowed (Game Settings \u2192 Security \u2192 Allow HTTP Requests). Check the Conduit dashboard in Studio for connection status.`
+    );
+    err.code = "PLUGIN_NOT_CONNECTED";
+    return err;
+  }
   /**
    * Classify why a request timed out. Without this, three very different failure modes
    * ("plugin isn't running", "socket is dead", "plugin got the request but its handler
@@ -312,6 +391,11 @@ var Bridge = class extends EventEmitter {
       studio.ws.terminate();
       this.studios.delete(studioId);
       this.lastHeartbeats.delete(studioId);
+      this.failPendingForStudio(
+        studioId,
+        "PLUGIN_UNRESPONSIVE",
+        `the plugin connection went stale and was evicted before responding`
+      );
       this.emit("studio-disconnected", studio.info);
       log.info(`Evicted stale studio: ${studioId}`);
     }
@@ -412,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;
@@ -453,6 +559,11 @@ var Bridge = class extends EventEmitter {
       if (current && current.ws === ws) {
         this.studios.delete(studioId);
         this.lastHeartbeats.delete(studioId);
+        this.failPendingForStudio(
+          studioId,
+          "PLUGIN_DISCONNECTED",
+          `the plugin WebSocket closed before a response arrived`
+        );
         this.emit("studio-disconnected", info);
         log.info(`Studio disconnected: ${studioId}`);
         if (this.activeStudioId === studioId) {
@@ -472,6 +583,19 @@ var Bridge = class extends EventEmitter {
       }
     });
   }
+  failPendingForStudio(studioId, code, reason) {
+    for (const [id, pending] of this.pendingRequests) {
+      if (pending.studioId === studioId) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(id);
+        const err = new Error(
+          `Request aborted: ${reason} (studio: ${studioId}). The plugin should auto-reconnect \u2014 please retry.`
+        );
+        err.code = code;
+        pending.reject(err);
+      }
+    }
+  }
   handlePluginMessage(msg) {
     if (isBridgeError(msg)) {
       const pending = this.pendingRequests.get(msg.id);
@@ -499,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(
@@ -513,6 +641,12 @@ var Bridge = class extends EventEmitter {
             const info = this.httpStudios.get(studioId);
             this.httpStudios.delete(studioId);
             this.lastHeartbeats.delete(studioId);
+            this.httpPendingCommands.delete(studioId);
+            this.failPendingForStudio(
+              studioId,
+              "PLUGIN_UNRESPONSIVE",
+              `the HTTP-fallback plugin stopped polling for ${Math.round(HEARTBEAT_TIMEOUT_MS / 1e3)}s`
+            );
             this.emit("studio-disconnected", info);
             if (this.activeStudioId === studioId) {
               const remaining = this.getStudios();
@@ -535,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);
   }
@@ -573,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");
@@ -665,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;
@@ -699,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);
@@ -2634,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-LNENHU6Z.js.map
+//# sourceMappingURL=chunk-NV56BC2A.js.map