safari-mcp 2.21.7 → 2.21.8

package/extension/background.js

@@ -639,6 +639,10 @@ async function connect() {
       if (_restartInvalidatedConnect(pollGeneration)) return;
       isConnected = true;
       _reconnectDelay = 3000; // Reset backoff on success
+      // A retry scheduled before this attempt succeeded (the wake alarm, a lease-held
+      // backoff) would run connect() again seconds later, invalidate this healthy loop and
+      // drop the command it had just been handed (15.9.26: every keepalive list_tabs).
+      if (_reconnectTimer) { clearTimeout(_reconnectTimer); _reconnectTimer = null; }
       updateBadge("ON");
       _startHeartbeat(); // Keep service worker alive between polls
       _connecting = false;
@@ -693,7 +697,12 @@ async function pollForCommands(pollGeneration) {
       const res = await _bridgeFetch(`${bridgeUrl}/poll`, {
         signal: controller.signal,
       });
-      if (pollGeneration !== _pollLoopGeneration) return;
+      // The response is here, so a reconnect must no longer abort this fetch (that would
+      // kill the body), and a loop it invalidated must still run a command it received:
+      // the host marked it dispatched to this worker, so nobody else ever will.
+      if (pollAbort === controller) pollAbort = null;
+      const invalidated = pollGeneration !== _pollLoopGeneration;
+      if (invalidated && res.status !== 200) return;
       if (res.status === 423) {
         // A replacement worker completed profile verification. This stale worker must
         // stay dormant until Safari reloads it; reconnecting would steal the lease back.
@@ -719,6 +728,7 @@ async function pollForCommands(pollGeneration) {
         const claim = new Promise((resolve) => { releaseClaim = resolve; });
         _commandExecutionTail = previousExecution.catch(() => {}).then(() => claim);
         let beat = null;
+        let guard = null;
         try {
           // A single malformed/truncated body must NOT tear down the poll loop — a bad
           // packet used to throw SyntaxError here, fall through to "server gone", and
@@ -738,13 +748,15 @@ async function pollForCommands(pollGeneration) {
             // 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.
+            guard = _wedgedCommandGuard(msg, bridgeUrl);
             await Promise.race([
               executeAndReply(msg, bridgeUrl),
-              _wedgedCommandGuard(msg, bridgeUrl),
+              guard,
             ]);
           }
         } finally {
           if (beat) clearInterval(beat);
+          if (guard) guard.cancel();
           releaseClaim();
         }
       }
@@ -777,8 +789,9 @@ async function pollForCommands(pollGeneration) {
 // 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 () => {
+  let timer = null;
+  const fired = new Promise((resolve) => {
+    timer = setTimeout(async () => {
       console.log("Safari MCP: command wedged, releasing the poll loop", msg && msg.type);
       try {
         await _bridgeFetch(`${bridgeUrl}/result`, {
@@ -798,6 +811,10 @@ function _wedgedCommandGuard(msg, bridgeUrl) {
       resolve();
     }, _WEDGED_COMMAND_MS);
   });
+  // The poll loop cancels the guard however the command ends. An uncancelled timer fired
+  // 330s after EVERY command and posted "did not settle" for an id the host had already
+  // answered (15.9.26: one bogus result per command, five and a half minutes late).
+  return Object.assign(fired, { cancel: () => clearTimeout(timer) });
 }
 
 // ========== SHARED: Execute command and send response ==========
@@ -890,12 +907,10 @@ async function handleCommand(type, payload) {
   let targetTab;
   try {
     if (suppliedReceipt) {
+      // Throws a refusal naming the failed check; it never returns without a tab.
       targetTab = await _resolveReceiptTab(suppliedReceipt, {
         allowOriginChange: allowReceiptOriginChange,
       });
-      if (!targetTab) {
-        throw new Error("Tab safety: receipt is forged, stale, ambiguous, or not valid for this origin");
-      }
       receiptResolved = true;
       payload._receiptTabId = targetTab.id;
       // A valid receipt names one concrete tab. It may move a stateless session into
@@ -3210,18 +3225,25 @@ async function _refreshAllReceiptIdentities() {
   });
 }
 
+// Each refusal names the check that failed. They used to share one sentence ("forged,
+// stale, ambiguous, or not valid for this origin"), and the server appends getReceipt
+// advice for an origin change to anything that says "not valid for this origin" — so a
+// receipt this worker had simply never seen was told to rotate a tab that never moved.
 async function _resolveReceiptTab(token, { allowOriginChange = false } = {}) {
   return _withReceiptMutationLock(async () => {
     const normalized = String(token || "");
-    if (!/^[A-Za-z0-9_-]{24,}$/.test(normalized)) return null;
     const record = _receiptByToken.get(normalized);
-    if (!_isValidReceiptRecord(normalized, record)) return null;
+    if (!/^[A-Za-z0-9_-]{24,}$/.test(normalized) || !_isValidReceiptRecord(normalized, record)) {
+      throw new Error("Tab safety: this extension has no record of that receipt. It was never issued by this extension instance, or it ended when its tab closed, when getReceipt replaced it, or when Safari or the extension restarted. Open the tab again with safari_new_tab.");
+    }
     const browserEpoch = await _ensureBrowserSessionEpoch();
-    if (record.browserEpoch !== browserEpoch) return null;
+    if (record.browserEpoch !== browserEpoch) {
+      throw new Error("Tab safety: receipt belongs to an earlier browser session — Safari or the extension restarted after it was issued. Open the tab again with safari_new_tab.");
+    }
 
     const allTabs = await browser.tabs.query({});
     const direct = allTabs.find((tab) => tab.id === record.tabId) || null;
-    if (!direct) return null;
+    if (!direct) throw new Error("Tab safety: the receipt's tab is closed. Open a new one with safari_new_tab.");
     const directDigest = await _digestTabUrl(direct.url || "");
     if (directDigest === record.identityDigest ||
       (_tokenByTabId.get(direct.id) === normalized && _isTabOwnedByAnySession(direct.id))) {
@@ -3239,11 +3261,14 @@ async function _resolveReceiptTab(token, { allowOriginChange = false } = {}) {
         }
       }
     } else {
-      return null;
+      throw new Error("Tab safety: the receipt's tab has moved to a different page and no MCP session owns it any more. Open the tab again with safari_new_tab.");
     }
 
     const currentOrigin = _receiptOrigin(direct.url);
-    if (!allowOriginChange && currentOrigin !== record.receiptOrigin) return null;
+    // index.js keys its getReceipt advice on "not valid for this origin"; keep that phrase here only.
+    if (!allowOriginChange && currentOrigin !== record.receiptOrigin) {
+      throw new Error("Tab safety: receipt is not valid for this origin.");
+    }
     return direct;
   });
 }
@@ -4599,8 +4624,9 @@ function _stopHeartbeat() {
 browser.alarms.create("keepalive", { periodInMinutes: 1 });
 browser.alarms.onAlarm.addListener((alarm) => {
   if (alarm.name === "keepalive" || alarm.name === "reconnect") {
-    // Only reconnect if disconnected, enabled, and no reconnect already scheduled
-    if (!isConnected && _enabled && !_bridgeWorkerSuperseded && !_bridgeWorkerRetiring && !_reconnectTimer) {
+    // Only reconnect if disconnected, enabled, and no reconnect already scheduled or in
+    // flight — a worker woken by this alarm is still connecting, not disconnected
+    if (!isConnected && !_connecting && _enabled && !_bridgeWorkerSuperseded && !_bridgeWorkerRetiring && !_reconnectTimer) {
       scheduleReconnect();
     }
     // Restart heartbeat in case it was lost on worker restart

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.15",
+  "version": "2.10.17",
   "icons": {
     "48": "images/icon-48.png",
     "96": "images/icon-96.png",

package/index.js

@@ -492,6 +492,20 @@ function _cancelReloadHttpWorkerHandoff(handoff) {
   if (_reloadHttpWorkerHandoff === handoff) _reloadHttpWorkerHandoff = null;
 }
 
+function _reloadAwaitsDelivery(handoff) {
+  return [..._pendingRequests.values()].some(
+    (pending) => pending.reloadHandoff === handoff && !pending.dispatchedWorkerId
+  );
+}
+
+// A new worker won the lease. A reload its predecessor never received moves with the
+// lease — that worker is the one that will run it; any other prepared handoff is void.
+function _adoptReloadHandoff(workerId) {
+  const handoff = _reloadHttpWorkerHandoff;
+  if (handoff && !handoff.armed && _reloadAwaitsDelivery(handoff)) handoff.fromWorkerId = workerId;
+  else _reloadHttpWorkerHandoff = null;
+}
+
 function _activeHttpWorkerIsFresh(now = Date.now()) {
   const lastActivity = Math.max(_extensionLastPollTime, _extensionLastHeartbeat);
   return !!_activeHttpWorkerId && _extensionConnected && lastActivity > 0 && now - lastActivity <= _HTTP_WORKER_SUCCESSOR_GRACE_MS;
@@ -513,7 +527,14 @@ function _mayReplaceActiveHttpWorker(workerId, presentedToken, now = Date.now())
   if (handoff) {
     // While the old worker is preparing a reload, no unrelated worker may use a
     // momentary poll/heartbeat gap to clear the handoff before /result arms it.
-    if (!handoff.armed) return false;
+    // A reload nobody has received is not being prepared, though: a parked worker can
+    // never take it, and pinning its lease deadlocked the reload until it timed out
+    // (15.9.26). Then only the ordinary freshness rule applies, and the successor
+    // inherits the reload (_adoptReloadHandoff).
+    if (!handoff.armed) {
+      if (!_reloadAwaitsDelivery(handoff)) return false;
+      return !_activeHttpWorkerIsFresh(now);
+    }
     if (handoff.expiresAt >= now) {
       return handoff.fromWorkerId === _activeHttpWorkerId && presentedToken === handoff.token;
     }
@@ -721,6 +742,9 @@ function _handleContentWakeRequest(req, res) {
   return true;
 }
 
+// Binds the extension bridge port; set once the bridge server exists (see PROXY MODE).
+let _listenAsExtensionHost = null;
+
 try {
   const httpServer = createServer((req, res) => {
     if (_handleContentWakeRequest(req, res)) return;
@@ -888,7 +912,7 @@ try {
         _activeHttpWorkerId = workerId;
         _connectingHttpWorkers.delete(workerId);
         if (workerChanged) {
-          _reloadHttpWorkerHandoff = null;
+          _adoptReloadHandoff(workerId);
           _extensionConnectionGeneration += 1;
         }
         if (!_extensionConnected) {
@@ -949,7 +973,7 @@ try {
       const workerChanged = workerId !== _activeHttpWorkerId;
       _activeHttpWorkerId = workerId;
       _connectingHttpWorkers.delete(workerId);
-      if (workerChanged) _reloadHttpWorkerHandoff = null;
+      if (workerChanged) _adoptReloadHandoff(workerId);
       _profileExtensionVerified = true;
       if (workerChanged) _extensionConnectionGeneration += 1;
       if (!_extensionConnected) {
@@ -1108,18 +1132,31 @@ try {
     res.end("Not found");
   });
 
-  httpServer.listen(HTTP_PORT, "127.0.0.1", () => {
+  let binding = false;
+  let proxying = false;
+  httpServer.on("listening", () => {
+    binding = false;
     _isExtensionHost = true;
     console.error(`[Safari MCP] HTTP server listening on port ${HTTP_PORT} (extension host)`);
   });
   httpServer.on("error", (err) => {
-    if (err.code === "EADDRINUSE") {
+    binding = false;
+    if (err.code === "EADDRINUSE" && !proxying) {
+      proxying = true;
       console.error(`[Safari MCP] HTTP port ${HTTP_PORT} in use — will proxy commands to primary instance`);
       _isExtensionHost = false;
       // Check if primary instance has extension connected
       _checkPrimaryExtension();
     }
   });
+  // Callable again after a failed bind; the guard keeps a second call from throwing
+  // ERR_SERVER_ALREADY_LISTEN while a bind is still in flight.
+  _listenAsExtensionHost = () => {
+    if (binding || httpServer.listening) return;
+    binding = true;
+    httpServer.listen(HTTP_PORT, "127.0.0.1");
+  };
+  _listenAsExtensionHost();
 } catch {}
 
 // ========== PROXY MODE ==========
@@ -1156,7 +1193,14 @@ async function _checkPrimaryExtension() {
       }
     }
   } catch {
+    // Nothing answers on the bridge port: the primary is gone. A secondary that keeps
+    // proxying to nobody leaves the extension without a bridge until a restart (seen
+    // 15.9.26, after a short-lived process held the port during a daemon restart), so
+    // take the port over. If something else still holds it, the bind fails quietly.
     _primaryHasExtension = false;
+    _extensionConnected = false;
+    if (process.env.SAFARI_PROFILE) _profileExtensionVerified = false;
+    _listenAsExtensionHost?.();
   }
   // Re-check every 10s (unref'd — must not keep the Node process alive on its own)
   setTimeout(_checkPrimaryExtension, 10000).unref();

package/package.json

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