safari-mcp 2.19.0 → 2.19.1

package/extension/background.js

@@ -732,7 +732,16 @@ async function pollForCommands(pollGeneration) {
               _bridgeFetch(`${bridgeUrl}/heartbeat`, { method: "POST" }).catch(() => {});
             }, 5000);
             await previousExecution.catch(() => {});
-            await executeAndReply(msg, bridgeUrl);
+            // 7.9.26: a command whose handleCommand never settles (a tab that never answers,
+            // a runtime call that hangs) used to park this loop for good: the beat kept the
+            // host believing we were alive, /poll went silent for hours, connectToServer
+            // waited on the same claim, and only a Safari restart brought the profile back.
+            // Bound it: past the host's hard ceiling we answer with an error, release the
+            // claim and keep polling; the abandoned promise may settle later into the void.
+            await Promise.race([
+              executeAndReply(msg, bridgeUrl),
+              _wedgedCommandGuard(msg, bridgeUrl),
+            ]);
           }
         } finally {
           if (beat) clearInterval(beat);
@@ -764,6 +773,33 @@ async function pollForCommands(pollGeneration) {
   }
 }
 
+// Ceiling for one command. The host's own hard deadline is max(4×timeout, 180s) and its
+// longest tool timeout is 75s, so nothing legitimate is still awaited after five minutes.
+const _WEDGED_COMMAND_MS = 330000;
+function _wedgedCommandGuard(msg, bridgeUrl) {
+  return new Promise((resolve) => {
+    setTimeout(async () => {
+      console.log("Safari MCP: command wedged, releasing the poll loop", msg && msg.type);
+      try {
+        await _bridgeFetch(`${bridgeUrl}/result`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            type: "response",
+            id: msg.id,
+            result: null,
+            error: `command ${msg.type} did not settle within ${_WEDGED_COMMAND_MS}ms`,
+          }),
+          signal: AbortSignal.timeout(5000),
+        });
+      } catch (e) {
+        /* the host most likely expired it already */
+      }
+      resolve();
+    }, _WEDGED_COMMAND_MS);
+  });
+}
+
 // ========== SHARED: Execute command and send response ==========
 
 async function executeAndReply(msg, bridgeUrl = HTTP_URL) {

package/extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "Safari MCP Bridge",
   "description": "Connects AI agents to Safari — fast JS execution, screenshots, clicks with your real cookies/logins",
-  "version": "2.10.9",
+  "version": "2.10.10",
   "icons": {
     "48": "images/icon-48.png",
     "96": "images/icon-96.png",

package/index.js

@@ -908,15 +908,23 @@ try {
       const heartbeatingWorkerId = _requireActiveHttpWorker(req, res);
       if (!heartbeatingWorkerId) return;
       _extensionLastHeartbeat = Date.now();
-      _extensionLastPollTime = Date.now();
       // Re-arm in-flight deadlines: the worker told us it is still on the command.
       // hardDeadline inside armTimer keeps this from extending indefinitely.
+      let liveInFlight = false;
       for (const pending of _pendingRequests.values()) {
         if (pending.dispatchedWorkerId !== heartbeatingWorkerId) continue;
         if (!pending.armTimer || Date.now() >= pending.hardDeadline) continue;
+        liveInFlight = true;
         clearTimeout(pending.timer);
         pending.timer = pending.armTimer();
       }
+      // A beat proves liveness only while the worker is on a command we still wait for.
+      // 7.9.26: a worker wedged inside one command (its handleCommand never settled) kept
+      // beating every 5s for hours after that command's hard deadline had expired; each
+      // beat refreshed the stale clock, so "HTTP poll timeout" never fired, no successor
+      // could take the lease, and every tool call died with "Extension timeout". Once
+      // nothing dispatched to this worker is in flight, its beats no longer count as polls.
+      if (liveInFlight) _extensionLastPollTime = Date.now();
       res.writeHead(204);
       res.end();
       return;
@@ -1219,6 +1227,18 @@ _staleHttpTimer.unref();  // stale-detection must not keep the Node process aliv
 
 // ========== SHARED EXTENSION LOGIC ==========
 
+// A worker that keeps beating but never finishes a command holds the profile lease
+// hostage. Releasing it is the same bookkeeping the stale timer does on poll timeout.
+function _dropWedgedHttpWorker(reason) {
+  if (!_extensionConnected && !_activeHttpWorkerId) return;
+  _extensionConnected = false;
+  _activeHttpWorkerId = "";
+  _connectingHttpWorkers.clear();
+  _reloadHttpWorkerHandoff = null;
+  _drainOnDisconnect(`wedged worker: ${reason}`);
+  console.error(`[Safari MCP] Extension worker dropped as wedged (${reason})`);
+}
+
 // Drain pending requests and command queue on disconnect — allows fast fallback to AppleScript
 function _drainOnDisconnect(reason) {
   if (process.env.SAFARI_PROFILE) {
@@ -1301,6 +1321,7 @@ function sendToExtension(type, payload = {}, timeoutMs = 30000) {
     // hardDeadline is the ceiling, so a worker that beats forever cannot hang us.
     const hardDeadline = Date.now() + Math.max(timeoutMs * 4, 180000);
     const expire = () => {
+      const pending = _pendingRequests.get(id);
       _pendingRequests.delete(id);
       if (reloadHandoff) _cancelReloadHttpWorkerHandoff(reloadHandoff);
       // Also drop it from the HTTP poll queue — otherwise the extension could poll this command
@@ -1308,6 +1329,15 @@ function sendToExtension(type, payload = {}, timeoutMs = 30000) {
       const qi = _commandQueue.findIndex(c => c.id === id);
       if (qi >= 0) _commandQueue.splice(qi, 1);
       reject(new Error(`Extension timeout after ${timeoutMs}ms`));
+      // The worker took this command and never answered, even past the hard ceiling: it is
+      // wedged (see /heartbeat). Drop its lease now instead of waiting for the stale timer,
+      // so a fresh worker — or Safari re-spawning this one — can connect at once.
+      if (
+        pending && pending.dispatchedWorkerId && pending.dispatchedWorkerId === _activeHttpWorkerId &&
+        Date.now() >= pending.hardDeadline
+      ) {
+        _dropWedgedHttpWorker(`${type} exceeded its hard deadline`);
+      }
     };
     const armTimer = () => setTimeout(expire, Math.min(timeoutMs, Math.max(0, hardDeadline - Date.now())));
     _pendingRequests.set(id, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safari-mcp",
-  "version": "2.19.0",
+  "version": "2.19.1",
   "mcpName": "io.github.achiya-automation/safari-mcp",
   "description": "Safari browser automation for AI agents — native macOS, zero Chrome overhead. 97 tools via AppleScript + JavaScript.",
   "type": "module",