safari-mcp 2.11.1 → 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safari-mcp",
-  "version": "2.11.1",
+  "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

@@ -3005,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) {
@@ -3045,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.