@memoraone/mcp 0.1.58 → 0.1.60

package/dist/cli.cjs

@@ -231,7 +231,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.58",
+      version: "0.1.60",
       type: "module",
       main: "dist/index.cjs",
       exports: {

package/dist/gateway.cjs

@@ -14130,6 +14130,19 @@ async function removeSession(sessionId) {
   } catch {
   }
 }
+function pauseHeartbeatWhenGetSseCloses(req, res, sessionId) {
+  let paused = false;
+  const pause = () => {
+    if (paused) return;
+    if (!res.headersSent || res.statusCode !== 200) return;
+    paused = true;
+    const session = sessionsById.get(sessionId);
+    if (!session || session.closed) return;
+    session.heartbeat?.stop();
+  };
+  res.once("close", pause);
+  req.socket?.once("close", pause);
+}
 async function closeGatewayMcpSessionsForWorkspace(workspaceRoot) {
   const root = path50.resolve(workspaceRoot);
   const ids = [...sessionsById.values()].filter((s) => s.workspaceRoot === root).map((s) => s.sessionId);
@@ -14258,6 +14271,18 @@ async function handleAuthenticatedGatewayMcpRequest(req, res, auth, options = {}
       await existing.transport.handleRequest(req, res, parsed3.body);
       return;
     }
+    if (method === "GET") {
+      const heartbeat = existing.heartbeat;
+      if (heartbeat && !heartbeat.isRunning()) {
+        await heartbeat.start();
+      }
+      pauseHeartbeatWhenGetSseCloses(req, res, existing.sessionId);
+      try {
+        await existing.transport.handleRequest(req, res);
+      } catch {
+      }
+      return;
+    }
     await existing.transport.handleRequest(req, res);
     return;
   }
@@ -14322,6 +14347,9 @@ function sendPairingGate(res, body) {
   });
   res.end(body);
 }
+function canWriteGatewayResponse(res) {
+  return !res.writableEnded && !res.destroyed;
+}
 async function handleGatewayMcpAuthRequest(req, res, url, options = {}) {
   if (url.pathname !== GATEWAY_MCP_PATH) return false;
   const env2 = options.env ?? process.env;
@@ -14393,8 +14421,7 @@ async function handleGatewayMcpAuthRequest(req, res, url, options = {}) {
         return true;
       }
       const pairing = await coordinator.ensure(parsed2.workspaceRoot);
-      if (pairing.status === "pending") {
-        sendPairingGate(res, "Pairing pending");
+      if (!canWriteGatewayResponse(res)) {
         return true;
       }
       if (pairing.status === "failed") {
@@ -14434,6 +14461,9 @@ async function handleGatewayMcpAuthRequest(req, res, url, options = {}) {
     );
     return true;
   } catch {
+    if (!canWriteGatewayResponse(res)) {
+      return true;
+    }
     sendUnauthorized(res, env2, parsed2.workspaceRoot);
     return true;
   }
@@ -14486,13 +14516,19 @@ function createGatewayUnboundPairingCoordinator(options = {}) {
   const openUrl = options.openUrl ?? ((url) => openUrlInBrowser(url));
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS2;
   const apiUrl = (options.apiUrl ?? config2.apiUrl).replace(/\/+$/, "");
+  function settleLatch(key, entry, status) {
+    if (entry.status !== "pending") return;
+    entry.status = status;
+    entry.settle(status);
+    latches.delete(key);
+  }
   async function pollInBackground(key, session, entry) {
     for (; ; ) {
       let result;
       try {
         result = await session.poll();
       } catch {
-        entry.status = "failed";
+        settleLatch(key, entry, "failed");
         return;
       }
       if (result.status === "pending") {
@@ -14500,15 +14536,14 @@ function createGatewayUnboundPairingCoordinator(options = {}) {
         continue;
       }
       if (result.status === "ready") {
-        entry.status = "ready";
-        latches.delete(key);
+        settleLatch(key, entry, "ready");
         return;
       }
       if (result.status === "backend_failure" && result.operation === "poll") {
         await delay3(pollIntervalMs);
         continue;
       }
-      entry.status = "failed";
+      settleLatch(key, entry, "failed");
       return;
     }
   }
@@ -14530,18 +14565,16 @@ function createGatewayUnboundPairingCoordinator(options = {}) {
         try {
           await openUrl(authorizationUrl);
         } catch {
-          entry.status = "failed";
+          settleLatch(key, entry, "failed");
           return;
         }
       } else {
-        entry.status = "failed";
+        settleLatch(key, entry, "failed");
         return;
       }
-      setImmediate(() => {
-        void pollInBackground(key, session, entry);
-      });
+      void pollInBackground(key, session, entry);
     } catch {
-      entry.status = "failed";
+      settleLatch(key, entry, "failed");
     }
   }
   return {
@@ -14549,21 +14582,16 @@ function createGatewayUnboundPairingCoordinator(options = {}) {
       const key = path51.resolve(workspaceRoot);
       const existing = latches.get(key);
       if (existing) {
-        await existing.startPromise;
-        return { status: existing.status };
+        return { status: await existing.settled };
       }
-      let resolveStart;
-      const startPromise = new Promise((resolve47) => {
-        resolveStart = resolve47;
+      let settle;
+      const settled = new Promise((resolve47) => {
+        settle = resolve47;
       });
-      const entry = { status: "pending", startPromise };
+      const entry = { status: "pending", settled, settle };
       latches.set(key, entry);
-      try {
-        await startPairing(key, entry);
-      } finally {
-        resolveStart();
-      }
-      return { status: entry.status };
+      void startPairing(key, entry);
+      return { status: await entry.settled };
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoraone/mcp",
-  "version": "0.1.58",
+  "version": "0.1.60",
   "type": "module",
   "main": "dist/index.cjs",
   "exports": {