safari-mcp 2.11.0 → 2.11.2

package/index.js

@@ -20,34 +20,14 @@ import { homedir } from "node:os";
 
 const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10 MB cap on POST body — prevents DoS
 
-// ========== SINGLETON: kill stale instances from previous sessions ==========
-// NOTE: Claude Code VSCode may start 2 instances simultaneously (~40ms apart).
-// Only kill instances running >10 seconds (truly stale), not fresh siblings.
-try {
-  const myPid = process.pid;
-  const lines = execFileSync("pgrep", ["-af", "node.*/safari-mcp/index\\.js"], { encoding: "utf8" }).trim().split("\n");
-  for (const line of lines) {
-    const pid = parseInt(line.split(/\s+/)[0], 10);
-    if (pid && pid !== myPid) {
-      // Check how long the process has been running (elapsed time in seconds)
-      let elapsedSec = 0;
-      try {
-        const etime = execFileSync("ps", ["-o", "etime=", "-p", String(pid)], { encoding: "utf8" }).trim();
-        // etime format: [[DD-]HH:]MM:SS — parse to seconds
-        const parts = etime.replace(/-/g, ":").split(":").map(Number);
-        if (parts.length === 2) elapsedSec = parts[0] * 60 + parts[1];
-        else if (parts.length === 3) elapsedSec = parts[0] * 3600 + parts[1] * 60 + parts[2];
-        else if (parts.length === 4) elapsedSec = parts[0] * 86400 + parts[1] * 3600 + parts[2] * 60 + parts[3];
-      } catch {}
-      if (elapsedSec > 10) {
-        try { process.kill(pid, "SIGTERM"); } catch {}
-        console.error(`[Safari MCP] Killed stale instance PID ${pid} (running ${elapsedSec}s)`);
-      } else {
-        console.error(`[Safari MCP] Skipping fresh instance PID ${pid} (running ${elapsedSec}s)`);
-      }
-    }
-  }
-} catch {}
+// ========== MULTI-INSTANCE: concurrent instances coexist (never kill siblings) ==========
+// This block previously SIGTERM'd every other safari-mcp instance running >10s to
+// clear "stale" processes from previous sessions. That broke multi-session use:
+// each new Claude Code session's instance killed every older session's instance,
+// disconnecting them mid-task. Concurrent instances are fully supported by design —
+// the first to bind HTTP_PORT becomes the extension host, the rest proxy commands
+// through it (see PROXY MODE below). Instances from closed sessions are SIGTERM'd
+// by their own MCP client on shutdown, so no cross-instance cleanup is needed here.
 
 // ========== SESSION ID (unique per MCP process — enables per-session tab tracking) ==========
 const SESSION_ID = randomUUID().slice(0, 8);
@@ -127,6 +107,20 @@ function _isURLOwned(url) {
   return false;
 }
 
+// Sentinel persisted when a blank tab (about:blank) is opened by this session.
+// A blank tab has no unique URL to own, but ownership must still survive an MCP
+// process restart (_openedTabs is in-memory only) — otherwise reopening blank
+// tabs falsely trips the "no tabs opened yet" guard. The sentinel is never a
+// real tab URL, so it cannot falsely match a user's page in _isURLOwned().
+const BLANK_TAB_SENTINEL = "__mcp-blank-tab__";
+
+function _markBlankTabOpened() {
+  if (!_ownedTabURLs.has(BLANK_TAB_SENTINEL)) {
+    _ownedTabURLs.add(BLANK_TAB_SENTINEL);
+    _saveOwnershipFile(_ownedTabURLs);
+  }
+}
+
 function _addOwnedURL(url) {
   if (url && url !== 'about:blank' && url !== 'favorites://') {
     _ownedTabURLs.add(url);
@@ -697,7 +691,7 @@ async function extensionOrFallback(extensionType, extensionPayload, fallbackFn)
       throw new Error(msg);
     } else if (currentUrl && !_isURLOwned(currentUrl)) {
       // about:blank tabs are owned if we have any tracked tabs (new_tab creates them at about:blank)
-      const isBlankOwned = (currentUrl === 'about:blank' || currentUrl === 'missing value') && _openedTabs.size > 0;
+      const isBlankOwned = (currentUrl === 'about:blank' || currentUrl === 'missing value') && (_openedTabs.size > 0 || _ownedTabURLs.has(BLANK_TAB_SENTINEL));
       if (!isBlankOwned) {
         const msg = `⚠️ Tab safety: refusing "${extensionType}" — current tab (${currentUrl}) was not opened by this MCP session. Use safari_new_tab or safari_switch_tab to target your own tab.`;
         console.error(`[Safari MCP] ${msg}`);
@@ -1354,6 +1348,9 @@ server.tool(
       _addOwnedURL(trackUrl);
       if (url && url !== trackUrl) _addOwnedURL(url);  // also own the requested URL (handles www redirects)
     }
+    // Blank tab (no URL requested): persist a restart-surviving ownership marker.
+    const _effectiveNewURL = (result?.url && result.url !== 'about:blank' && result.url !== 'missing value') ? result.url : url;
+    if (!_effectiveNewURL) _markBlankTabOpened();
     return { content: [{ type: "text", text: typeof rawResult === 'string' ? rawResult : JSON.stringify(result) }] };
   }
 );
@@ -1384,7 +1381,7 @@ server.tool(
         const target = parsed.find(t => t.index === index);
         if (target && target.url && !_isURLOwned(target.url)) {
           // about:blank / missing value tabs are owned if tracked in _openedTabs
-          const isBlankOwned = (target.url === 'about:blank' || target.url === 'missing value') && _openedTabs.has(index);
+          const isBlankOwned = (target.url === 'about:blank' || target.url === 'missing value') && (_openedTabs.has(index) || _ownedTabURLs.has(BLANK_TAB_SENTINEL));
           if (!isBlankOwned) {
             const msg = `⚠️ Tab safety: refusing switch_tab to index ${index} (${target.url}) — not opened by this MCP session. Use safari_new_tab to open your own tab.`;
             console.error(`[Safari MCP] ${msg}`);

package/package.json

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

package/safari.js

@@ -107,6 +107,15 @@ function cleanupHelper() {
 // cleanupHelper runs via process.on("exit"), which fires when index.js calls process.exit().
 process.on("exit", cleanupHelper);
 process.on("uncaughtException", (err) => { console.error("Uncaught:", err); cleanupHelper(); process.exit(1); });
+// Unhandled promise rejections must NOT terminate the server. A single failed
+// async operation — e.g. a proxy fetch to the primary instance while it is
+// mid-restart, or an aborted fetch timeout — would otherwise bubble to the
+// uncaughtException handler above (Node's default for unhandled rejections) and
+// exit the whole MCP process, disconnecting every concurrent session. Log and
+// continue: the failed operation is localized, the process itself is healthy.
+process.on("unhandledRejection", (reason) => {
+  console.error("[Safari MCP] Unhandled rejection (non-fatal, continuing):", (reason && reason.stack) || reason);
+});
 
 // ========== SAFARI RUNNING CHECK ==========
 // Prevent AppleScript from auto-launching Safari when it's closed
@@ -2996,6 +3005,26 @@ export async function waitFor({ selector, text, timeout = 10000 }) {
 
 // ========== EVALUATE ==========
 
+// Index of the last `;` that ends a top-level statement — skips `;` inside strings,
+// template literals and parens/brackets/braces (e.g. a `for (;;)` header). Returns
+// -1 when there is no top-level statement separator.
+function _lastTopLevelSemicolon(s) {
+  let depth = 0, inStr = false, quote = '', last = -1;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (inStr) {
+      if (c === '\\') { i++; continue; }
+      if (c === quote) inStr = false;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') { inStr = true; quote = c; }
+    else if (c === '(' || c === '[' || c === '{') depth++;
+    else if (c === ')' || c === ']' || c === '}') depth--;
+    else if (c === ';' && depth === 0) last = i;
+  }
+  return last;
+}
+
 // Build the expression to evaluate from a user script. Pure (no Safari calls) so
 // it can be unit-tested directly — see scripts/test-evaluate-wrapping.js.
 export function _buildEvalExpr(js) {
@@ -3036,8 +3065,16 @@ export function _buildEvalExpr(js) {
     if (addedReturn) {
       expr = `(${isAsync ? 'async function' : 'function'}(){${lines.join('\n')}})()`;
     } else if (isAsync) {
-      // No safe return slot — run the body in an async IIFE (value may be undefined).
-      expr = `(async function(){${js}})()`;
+      // No newline gave a return slot — typically a single-line `const x = await …; expr`.
+      // Split at the last top-level `;`: if a bare expression follows it, that becomes the
+      // awaited result. Otherwise run the body as-is (value may be undefined).
+      const semi = _lastTopLevelSemicolon(js);
+      const tail = semi >= 0 ? js.slice(semi + 1).trim() : '';
+      if (tail && !tail.startsWith('}') && !NON_EXPR.test(tail)) {
+        expr = `(async function(){${js.slice(0, semi + 1)} return (${tail}); })()`;
+      } else {
+        expr = `(async function(){${js}})()`;
+      }
     } else {
       // Indirect eval yields the completion value of an arbitrary statement list;
       // the catch re-runs the body plainly when a strict CSP blocks eval.