local-mcp 3.0.372 → 3.0.374

package/README.md

@@ -1,6 +1,6 @@
 # Local MCP
 
-> **The only Mac MCP you can use from ChatGPT & Claude.ai on the web** — plus 215+ local tools for Claude Desktop, Cursor, Windsurf, VS Code & Zed. Connect any AI to Mail, Calendar, Contacts, iMessage, Teams, Slack, WhatsApp, Signal, OneDrive, Google Drive, Microsoft 365, Notes, Reminders, OmniFocus, Safari, Chrome, Word/Excel/PowerPoint and more. 100% local, no API keys, free — your data never leaves your machine.
+> **The only Mac MCP you can use from ChatGPT & Claude.ai on the web** — plus 188+ local tools for Claude Desktop, Cursor, Windsurf, VS Code & Zed. Connect any AI to Mail, Calendar, Contacts, iMessage, Teams, Slack, WhatsApp, Signal, OneDrive, Google Drive, Microsoft 365, Notes, Reminders, OmniFocus, Word/Excel/PowerPoint and more. 100% local, no API keys, free — your data never leaves your machine.
 
 [![npm](https://img.shields.io/npm/v/local-mcp?style=flat-square&label=npm)](https://www.npmjs.com/package/local-mcp)
 [![macOS](https://img.shields.io/badge/macOS-13%2B-111111?style=flat-square)](https://local-mcp.com?ref=npm)
@@ -64,8 +64,7 @@ LMCP runs a native MCP server that bridges your Mac apps to any AI client:
 | **Stocks** | Real-time quotes, historical charts, symbol search |
 | **Weather** | Current conditions + forecast for any city (Open-Meteo, no key) |
 | **Finder** | Search files via Spotlight, list directory contents |
-| **Safari** | Bookmarks, open tabs, click/type/fill forms, run JavaScript |
-| **Chrome** | Open tabs, navigate, read pages, click/type/fill forms, run JavaScript |
+| **Web** | Navigate, read, click/type/fill forms, run JavaScript and scrape structured data in LMCP's own browser sessions — you sign in once and the login persists |
 | **Microsoft 365** | Read/send email, manage calendar, search org directory — device code login, works with Outlook.com and work accounts |
 | **ServiceNow** | Search/create incidents, get details, search Knowledge Base — Basic auth |
 | **NordVPN** | Status, server recommendations, diagnostics |
@@ -120,9 +119,7 @@ Weather (1): `get_weather`
 
 Finder (5): `finder_search` `finder_list` `fs_list` `fs_read` `fs_search`
 
-Safari (13): `list_safari_bookmarks` `safari_list_tabs` `safari_read_tab` `safari_search_tabs` `safari_navigate` `safari_go_back` `safari_setup_check` `safari_evaluate_js` `safari_click` `safari_type` `safari_fill_form` `safari_wait_for` `safari_query_selector_all`
-
-Chrome (12): `chrome_list_tabs` `chrome_read_tab` `chrome_search_tabs` `chrome_navigate` `chrome_go_back` `chrome_setup_check` `chrome_evaluate_js` `chrome_click` `chrome_type` `chrome_fill_form` `chrome_wait_for` `chrome_query_selector_all`
+Web (13): `web_login` `web_navigate` `web_read` `web_find` `web_click` `web_type` `web_extract` `web_wait_for` `web_screenshot` `web_show` `web_eval` `web_session_list` `web_session_close`
 
 Microsoft 365 (16): `connect_m365_account` `disconnect_m365_account` `m365_list_emails` `m365_read_email` `m365_send_email` `m365_reply_email` `m365_search_emails` `m365_list_events` `m365_create_event` `m365_delete_event` `search_m365_directory` `get_m365_person` `list_m365_people_insights` `m365_list_contacts` `m365_search_contacts` `m365_get_contact`
 

package/download.js

@@ -52,7 +52,106 @@ const TRAY_APP = process.platform === 'darwin'
   ? path.join(os.homedir(), 'Applications', 'LocalMCPTray.app')
   : null
 
+// Mirror of go-server's CacheDir()/.machine-id (internal/machineid/machineid.go).
+// Only the win32 ladder reads/writes it: it's the side of the probe that can
+// come up empty on a real machine (wmic gone, PowerShell blocked by policy),
+// and consulting the same file the go-server already wrote/reads is what lets
+// the two sides converge on one id instead of the hostname-hash fallback.
+// cacheDir is a parameter (not read from the module-level CACHE_DIR directly)
+// for the same reason setup.js's _cloudTokenPath/_readCachedCloudToken/
+// _writeCloudToken take it explicitly: it lets tests point at a temp dir
+// instead of writing into the real user's cache.
+const WIN_MACHINE_ID_CACHE_NAME = '.machine-id'
+
+function _readWinMachineIdCache(cacheDir) {
+  try {
+    return fs.readFileSync(path.join(cacheDir, WIN_MACHINE_ID_CACHE_NAME), 'utf8').trim()
+  } catch {
+    return ''
+  }
+}
+
+function _writeWinMachineIdCache(cacheDir, id) {
+  try {
+    fs.mkdirSync(cacheDir, { recursive: true })
+    const dest = path.join(cacheDir, WIN_MACHINE_ID_CACHE_NAME)
+    // Short-circuit if the on-disk value is already correct — mirrors
+    // go-server's writeCache() (machineid.go:117-119): avoids an unnecessary
+    // rewrite on every call.
+    try {
+      if (fs.readFileSync(dest, 'utf8').trim() === id) return
+    } catch {}
+    // Write-then-rename rather than writeFileSync straight onto dest.
+    // writeFileSync truncates in place, so a write interrupted by a crash or
+    // a killed `npx` leaves a SHORT id on disk — and a short id is not an
+    // empty one: _readWinMachineIdCache (and the go-server's own reader,
+    // same TrimSpace+non-empty check) would hand it back as a perfectly
+    // valid identity, splitting this machine's telemetry in two (#1704).
+    // Same fix as go-server/internal/machineid/machineid.go:120-124
+    // (CreateTemp + Rename): rename is atomic on the same volume, so a
+    // reader always sees either the old value or the complete new one.
+    const tmp = path.join(cacheDir, `${WIN_MACHINE_ID_CACHE_NAME}.tmp${process.pid}`)
+    fs.writeFileSync(tmp, id)
+    fs.renameSync(tmp, dest)
+  } catch {}
+}
+
+// Memoizes only the hardware probe (PowerShell/wmic spawn), not the whole
+// ladder — same split as go-server's cachedHardware(). _getMachineId() runs on
+// every ensureBinary()/ensureTray()/... call, and setup.js calls it several
+// times per `npx … setup` run (once per tracked step); without memoizing,
+// each of those would pay a fresh PowerShell spawn. A failed probe is
+// memoized too, on purpose: a run where PowerShell is blocked shouldn't retry
+// it on every subsequent call in the same process.
+let _winHardwareIdCache
+// execImpl is injectable (defaults to the real execSync) so tests can pin the
+// PowerShell-then-wmic ORDER without a Windows machine — see
+// npm/test/machine-id-windows-order.test.js.
+function _probeWinHardwareId(execImpl = require('child_process').execSync) {
+  if (_winHardwareIdCache !== undefined) return _winHardwareIdCache
+  // Same order as go-server's probeHardware (probe_windows.go): PowerShell's
+  // WMI UUID first, wmic only as fallback. wmic is deprecated and absent from
+  // modern Windows images, which is why trying it first split machine_id
+  // between npm and the go-server and reintroduced #1544 (0 of 9 Windows
+  // installs joined their heartbeat because the two sides disagreed on id).
+  try {
+    const ps = execImpl(
+      'powershell -NoProfile -Command "(Get-WmiObject Win32_ComputerSystemProduct).UUID"',
+      { stdio: 'pipe' }
+    ).toString().trim()
+    // PowerShell prints the literal string "nil", not an empty line, when WMI
+    // has no UUID to give — an emptiness check alone would accept it as an id.
+    if (ps && ps !== 'nil') {
+      _winHardwareIdCache = ps
+      return _winHardwareIdCache
+    }
+  } catch {}
+  try {
+    const wmic = execImpl('wmic csproduct get UUID /value', { stdio: 'pipe' }).toString()
+    const match = wmic.match(/UUID=(.+)/)
+    if (match) {
+      _winHardwareIdCache = match[1].trim()
+      return _winHardwareIdCache
+    }
+  } catch {}
+  _winHardwareIdCache = ''
+  return _winHardwareIdCache
+}
+
+// Test-only: the hardware probe is memoized process-wide (see above), so a
+// test that wants to exercise the ladder more than once with different
+// canned execImpl behavior needs to clear it between cases.
+function _resetWinHardwareIdCacheForTests() {
+  _winHardwareIdCache = undefined
+}
+
 function _getMachineId() {
+  // QA override, checked before any platform probe — same rank as go-server's
+  // Get() — so a smoke-* run stays a smoke-* run on every code path that
+  // reports machine_id, not just the ones that already remembered to check it.
+  const envId = (process.env.LMCP_MACHINE_ID || '').trim()
+  if (envId) return envId
+
   const { execSync } = require('child_process')
   if (process.platform === 'darwin') {
     try {
@@ -66,11 +165,17 @@ function _getMachineId() {
       if (match) return match[1]
     } catch {}
   } else if (process.platform === 'win32') {
-    try {
-      const wmic = execSync('wmic csproduct get UUID /value', { stdio: 'pipe' }).toString()
-      const match = wmic.match(/UUID=(.+)/)
-      if (match) return match[1].trim()
-    } catch {}
+    const hw = _probeWinHardwareId()
+    if (hw) {
+      _writeWinMachineIdCache(CACHE_DIR, hw)
+      return hw
+    }
+    // Both probes failed or are blocked — fall back to whatever the go-server
+    // already cached rather than diverging to the hostname hash (the poisoned-
+    // cache case go-server's own Get() guards against does not apply here:
+    // this file is only ever written with a hardware-derived id, by either side).
+    const cached = _readWinMachineIdCache(CACHE_DIR)
+    if (cached) return cached
   } else {
     try {
       const mid = fs.readFileSync('/etc/machine-id', 'utf8').trim()
@@ -349,7 +454,13 @@ async function ensureRuntime() {
  * El binary se instala en ~/.local/share/local-mcp/bin/teams-proxy
  * @returns {Promise<string|null>} Ruta al binary, o null si falla
  */
-async function ensureTeamsProxy() {
+async function ensureTeamsProxy(platform = process.platform) {
+  // Only published for darwin (darwin-arm64/darwin-x64 artifacts) — mirrors the
+  // guard ensureTray() already has. Without it, every Windows/Linux install fired
+  // a doomed download attempt and printed a confusing "not available" error (#1390).
+  // platform is a parameter (default process.platform) so the guard is testable
+  // without a network mock — same pattern as _writeLaunchScript's isWin.
+  if (platform !== 'darwin') return null
   const info = await getLatestBinary()
   const version = info.version
   const arch = process.arch === 'arm64' ? 'darwin-arm64' : 'darwin-x64'
@@ -536,7 +647,13 @@ function _writeTrayLaunchAgent(trayApp) {
  * Binary is installed at ~/.local/share/local-mcp/bin/slack-proxy
  * @returns {Promise<string|null>} Path to the binary, or null if it fails
  */
-async function ensureSlackProxy() {
+async function ensureSlackProxy(platform = process.platform) {
+  // Only published for darwin (darwin-arm64/darwin-x64 artifacts) — mirrors the
+  // guard ensureTray() already has. Without it, every Windows/Linux install fired
+  // a doomed download attempt and printed a confusing "not available" error (#1390).
+  // platform is a parameter (default process.platform) so the guard is testable
+  // without a network mock — same pattern as _writeLaunchScript's isWin.
+  if (platform !== 'darwin') return null
   const info = await getLatestBinary()
   const version = info.version
   const arch = process.arch === 'arm64' ? 'darwin-arm64' : 'darwin-x64'
@@ -581,4 +698,9 @@ async function ensureSlackProxy() {
   }
 }
 
-module.exports = { ensureBinary, ensureRuntime, ensureTray, ensureTeamsProxy, ensureSlackProxy, versionFromArtifactUrl, CACHE_DIR, TRAY_DIR }
+module.exports = {
+  ensureBinary, ensureRuntime, ensureTray, ensureTeamsProxy, ensureSlackProxy, versionFromArtifactUrl,
+  CACHE_DIR, TRAY_DIR, _getMachineId,
+  _probeWinHardwareId, _resetWinHardwareIdCacheForTests,
+  _readWinMachineIdCache, _writeWinMachineIdCache, WIN_MACHINE_ID_CACHE_NAME,
+}

package/index.js

@@ -18,6 +18,161 @@ const os    = require('os')
 const fs    = require('fs')
 const https = require('https')
 
+// ── Version + liveness helpers (module scope so they are testable) ────────────
+
+// PIDs of the server processes THIS process spawned. The liveness guard asks about
+// OTHER instances; counting our own child made it answer "servers running" forever.
+const _spawnedServerPids = []
+function spawnedServerPids() { return _spawnedServerPids.slice() }
+function noteSpawnedServer(pid) { if (typeof pid === 'number') _spawnedServerPids.push(pid) }
+
+/** Semver comparison: returns true if version a >= b (e.g. "3.0.72" >= "3.0.70") */
+function semverGte(a, b) {
+  const av = (a || '').split('.').map(Number)
+  const bv = (b || '').split('.').map(Number)
+  for (let i = 0; i < 3; i++) {
+    const ai = av[i] || 0, bi = bv[i] || 0
+    if (ai > bi) return true
+    if (ai < bi) return false
+  }
+  return true
+}
+
+/**
+ * Whether the cached binary is fresh enough to exec directly (the fast path).
+ *
+ * #1394 §C: the gate used to be `semverGte(cachedVersion, pkg.version)` on every
+ * platform. On Windows/Linux those two numbers are DIFFERENT SERIES by construction
+ * — `.server-version` holds the go-server artifact version while pkg.version is the
+ * npm/Mac release, and download.js documents the divergence it already has to work
+ * around ("version=3.0.369 next to a 3.0.258 windows artifact"). The comparison is
+ * therefore false on every machine in the fleet: every single spawn paid a
+ * /runtime/latest round-trip and exit(1) when offline, holding a perfectly good
+ * cached binary. And the slow path rewrites `.server-version` with the artifact
+ * version again, so it can never heal itself.
+ *
+ * On darwin the two ARE the same series, so the comparison is meaningful and stays:
+ * it is what stops a stale npx cache from downgrading a binary the tray already
+ * upgraded (LMC-375). Off darwin, "there is a cached binary and we know its version"
+ * is the whole requirement; the 24h background check below handles staleness.
+ */
+function fastPathVersionOK(platform, cachedVersion, pkgVersion) {
+  if (!cachedVersion) return false           // nothing cached → must download
+  if (platform === 'darwin') return semverGte(cachedVersion, pkgVersion)
+  return true
+}
+
+/**
+ * PIDs of the lmcp/local-mcp servers running right now, or null when the answer
+ * cannot be determined.
+ *
+ * #1394 §C: this was `pgrep -fc local-mcp-server`, which returned 0 on every
+ * Windows/Linux machine for two reasons — Windows has no `pgrep` (the `|| echo 0`
+ * swallowed it) and off macOS the binary is called `lmcp-server`. So the LMCA-1044
+ * guard was permanently disabled exactly where the updater renames the file.
+ *
+ * The first fix for that inverted the defect, and the review of #1565 caught it:
+ * counting was correct but the count was never zero, so nothing ever updated again.
+ * Two independent causes, both handled here:
+ *
+ *   1. THIS process has already spawned its own server as a child (launchMcpStdio
+ *      runs ~10s before this timer fires), so the count always included it. We are
+ *      asking about OTHER instances — replacing the binary is what SIGTERMs sibling
+ *      proxies — so known PIDs are excluded by the caller.
+ *
+ *   2. `execSync` runs through `/bin/sh -c`, whose own cmdline contains the pattern,
+ *      so `pgrep -f 'lmcp-server'` matched the shell running the pgrep. Verified in
+ *      Docker: it returns 2 with nothing running. The `[l]` bracket makes the regex
+ *      match `lmcp-server` while the literal pattern text in the shell's cmdline
+ *      (with the brackets) does not match itself.
+ */
+function listRunningServerPids(exec, platform = process.platform) {
+  try {
+    if (platform === 'win32') {
+      // tasklist ships on every Windows SKU. CSV so the PID column is unambiguous.
+      const pids = []
+      for (const name of ['lmcp-server.exe', 'local-mcp-server.exe']) {
+        const out = exec(`tasklist /FI "IMAGENAME eq ${name}" /NH /FO CSV`)
+        if (/INFO:/i.test(out)) continue
+        for (const line of String(out).split(/\r?\n/)) {
+          const m = line.match(/^"[^"]+","(\d+)"/)
+          if (m) pids.push(Number(m[1]))
+        }
+      }
+      return pids
+    }
+    // See (2) above for the brackets. One alternation per name: `lmcp-server` is not
+    // a substring of `local-mcp-server`, so both are needed.
+    //
+    // NO `|| true`, and that is the whole point of this branch. execSync throws on any
+    // non-zero exit, and pgrep overloads the code: 1 means it ran and matched nothing
+    // — a real answer — while 127 means the shell could not find pgrep at all (a
+    // container with no procps) and 2/3 are usage/fatal. `|| true` collapsed every one
+    // of them into empty stdout, so a MISSING pgrep read as "no servers running" and
+    // the guard authorised the swap with a server live. Measured in Docker without
+    // procps. Windows already honoured the contract below; the asymmetry was an
+    // accident of the shell idiom, not a decision.
+    let out
+    try {
+      out = exec(`pgrep -f '[l]mcp-server|[l]ocal-mcp-server'`)
+    } catch (err) {
+      if (err && err.status === 1) return []   // ran fine, nothing matched
+      throw err                                // could not look → null, via the catch below
+    }
+    return String(out).trim().split(/\s+/).filter(Boolean).map(Number).filter(n => !Number.isNaN(n))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * How many server processes are running OTHER than the ones we already know about.
+ * Returns -1 when the count CANNOT be determined. Callers must treat that as
+ * "assume servers are running": a guard that cannot see must not say yes.
+ */
+function countRunningServers(exec, platform = process.platform, excludePids = []) {
+  const pids = listRunningServerPids(exec, platform)
+  if (pids === null) return -1
+  const skip = new Set([process.pid, ...excludePids].filter(p => typeof p === 'number'))
+  return pids.filter(p => !skip.has(p)).length
+}
+
+/** True when it is safe to replace the cached binary on disk. */
+function safeToReplaceBinary(exec, platform = process.platform, excludePids = []) {
+  return countRunningServers(exec, platform, excludePids) === 0
+}
+
+/**
+ * Replace the cached server binary with `srcPath`, refusing while any server is
+ * running (LMCA-1044: swapping it mid-session changes its mtime and used to get
+ * sibling stdio proxies SIGTERM'd → Cursor transport_closed).
+ *
+ * The check lives INSIDE this function on purpose. It used to sit at the call site,
+ * and a mutation run showed the consequence: deleting it there passed every test,
+ * because the only caller is a closure inside main()'s background update timer that
+ * no unit test can reach. Callers can no longer forget a guard they cannot see.
+ *
+ * Returns 'replaced' | 'servers-running' | 'failed'.
+ */
+function replaceCachedBinary(deps, srcPath, destPath, version, versionFilePath) {
+  const { exec, fs, execFileSync, platform = process.platform, excludePids = [] } = deps
+  if (!safeToReplaceBinary(exec, platform, excludePids)) return 'servers-running'
+  try {
+    const tmpPath = destPath + '.tmp'
+    fs.copyFileSync(srcPath, tmpPath)
+    fs.chmodSync(tmpPath, 0o755)
+    if (platform === 'darwin') {
+      try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {}
+    }
+    fs.renameSync(tmpPath, destPath)
+    fs.writeFileSync(versionFilePath, version)
+    return 'replaced'
+  } catch {
+    return 'failed'
+  }
+}
+
+
 // ── Uninstall sentinels ───────────────────────────────────────────────────────
 // A `.uninstalled` sentinel marks a machine the user removed, so no respawn (an
 // AI client that still has `local-mcp` in its config re-spawning `npx local-mcp`)
@@ -232,19 +387,21 @@ async function main() {
     : (process.platform === 'win32' ? 'lmcp-server.exe' : 'lmcp-server')
   const stableBin = path.join(CACHE_DIR, binName)
   const versionFile = path.join(CACHE_DIR, '.server-version')
-  const pkg = require('./package.json')
-
-  // Semver comparison: returns true if version a >= b (e.g. "3.0.72" >= "3.0.70")
-  function semverGte(a, b) {
-    const av = (a || '').split('.').map(Number)
-    const bv = (b || '').split('.').map(Number)
-    for (let i = 0; i < 3; i++) {
-      const ai = av[i] || 0, bi = bv[i] || 0
-      if (ai > bi) return true
-      if (ai < bi) return false
-    }
-    return true
+  // On Windows/Linux the file download.js and the go-server updater keep current is
+  // `.go-server-version`; `.server-version` is only written by this script's slow
+  // path. Read both, newest-wins, so the fast path sees what the updater actually
+  // installed instead of a value only it ever writes (#1394 §C).
+  const goVersionFileRead = path.join(CACHE_DIR, '.go-server-version')
+  function readCachedVersion() {
+    const read = (p) => { try { return fs.readFileSync(p, 'utf8').trim() } catch { return '' } }
+    const own = read(versionFile)
+    if (process.platform === 'darwin') return own
+    const plat = read(goVersionFileRead)
+    if (!own) return plat
+    if (!plat) return own
+    return semverGte(plat, own) ? plat : own
   }
+  const pkg = require('./package.json')
 
   /** MCP hosts (Cursor, Claude) spawn us without a TTY — keep stdio bridge alive. */
   const isMcpClientSpawn = !(process.stdin && process.stdin.isTTY)
@@ -310,6 +467,7 @@ async function main() {
     let _pkgVer = ''
     try { _pkgVer = require('./package.json').version || '' } catch {}
     const child = spawn(binaryPath, spawnArgs, { stdio: 'inherit', env: { ...process.env, LMCP_NPM_VERSION: _pkgVer } })
+    noteSpawnedServer(child.pid)
     child.on('error', (err) => {
       process.stderr.write(`Error ejecutando LMCP: ${err.message}\n`)
       process.exit(1)
@@ -378,10 +536,8 @@ async function main() {
     // hard failure when offline despite a valid cached binary). Only require the
     // exec bit off-Windows, where it's meaningful.
     if (stat.isFile() && (process.platform === 'win32' || (stat.mode & 0o111))) {
-      const cachedVersion = fs.existsSync(versionFile)
-        ? fs.readFileSync(versionFile, 'utf8').trim()
-        : ''
-      if (cachedVersion && semverGte(cachedVersion, pkg.version)) {
+      const cachedVersion = readCachedVersion()
+      if (fastPathVersionOK(process.platform, cachedVersion, pkg.version)) {
         // Cached binary is same or newer — use fast path, no download needed
         await ensureDarwinComponents()
         launchMcpStdio(stableBin, cachedVersion || pkg.version)
@@ -406,34 +562,19 @@ async function main() {
                     // New version available — download for next restart only while no server is running.
                     // Replacing stableBin mid-session changes its mtime and used to cause sibling
                     // stdio proxies to be SIGTERM'd → Cursor transport_closed (LMCA-1044).
-                    let activeServers = 0
-                    try {
-                      activeServers = parseInt(
-                        execSync('pgrep -fc local-mcp-server 2>/dev/null || echo 0', { encoding: 'utf8' }).trim(),
-                        10
-                      ) || 0
-                    } catch {}
-                    if (activeServers > 0) return
+                    const _exec = (cmd) => execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+                    // Our OWN server child does not count: launchMcpStdio spawned it
+                    // ~10s ago and it is the session this update is for. Counting it
+                    // made the guard permanently false and stopped every update.
+                    const _deps = { exec: _exec, fs, execFileSync, excludePids: spawnedServerPids() }
+                    // Cheap pre-check so we do not download for nothing; the binding
+                    // guard is the one inside replaceCachedBinary, re-checked after
+                    // the download (a server can start while it runs).
+                    if (!safeToReplaceBinary(_exec, process.platform, spawnedServerPids())) return
 
                     const { ensureRuntime } = require('./download')
                     ensureRuntime().then(({ binPath, version: downloadedVersion }) => {
-                      try {
-                        let stillActive = 0
-                        try {
-                          stillActive = parseInt(
-                            execSync('pgrep -fc local-mcp-server 2>/dev/null || echo 0', { encoding: 'utf8' }).trim(),
-                            10
-                          ) || 0
-                        } catch {}
-                        if (stillActive > 0) return
-
-                        const tmpPath = stableBin + '.tmp'
-                        fs.copyFileSync(binPath, tmpPath)
-                        fs.chmodSync(tmpPath, 0o755)
-                        if (process.platform === 'darwin') { try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {} }
-                        fs.renameSync(tmpPath, stableBin)
-                        fs.writeFileSync(versionFile, downloadedVersion || latestVersion)
-                      } catch {}
+                      replaceCachedBinary(_deps, binPath, stableBin, downloadedVersion || latestVersion, versionFile)
                     }).catch(() => {})
                   }
                 } catch {}
@@ -493,7 +634,14 @@ async function main() {
   launchMcpStdio(stableBin, downloadedVersion || pkg.version)
 }
 
-main().catch(err => {
-  process.stderr.write(`Error fatal: ${err.message}\n`)
-  process.exit(1)
-})
+// Only auto-run as a program. Being requirable is what lets the version/liveness
+// helpers above be unit-tested at all — they guard a binary swap and a network
+// round-trip that no static check can see.
+if (require.main === module) {
+  main().catch(err => {
+    process.stderr.write(`Error fatal: ${err.message}\n`)
+    process.exit(1)
+  })
+}
+
+module.exports = { semverGte, fastPathVersionOK, listRunningServerPids, countRunningServers, safeToReplaceBinary, replaceCachedBinary }

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "local-mcp",
-  "version": "3.0.372",
+  "version": "3.0.374",
   "description": "Let ChatGPT, Claude, Cursor & any MCP client actually use your Mac — read & reply to email, manage your calendar, text over iMessage, find files, work with Teams, Slack & Office. On your Mac, no API keys, free.",
   "main": "index.js",
   "bin": {
     "local-mcp": "index.js"
   },
   "scripts": {
-    "postinstall": "node postinstall.js"
+    "postinstall": "node postinstall.js",
+    "test": "node --test test/*.test.js"
   },
   "files": [
     "index.js",

package/setup.js

@@ -12,6 +12,7 @@ const fs   = require('fs')
 const path = require('path')
 const os   = require('os')
 const { execSync, execFileSync } = require('child_process')
+const download = require('./download')
 
 const HOME = os.homedir()
 const NPX_COMMAND = 'npx'
@@ -33,14 +34,22 @@ function _resolveNpxPath() {
 // curl-based telemetry. This gives us visibility into failures that happen
 // BEFORE Node loads our code (e.g. old nvm default in Claude Desktop's PATH).
 // Returns the path to the launcher, or null if writing fails.
-function _writeLaunchScript(npxAbsPath, cacheDir) {
+// isWin is a parameter, not a read of _IS_WIN, so the Windows branch can be
+// exercised on any machine. Written as `if (_IS_WIN)` it could only be tested ON
+// Windows — and nobody runs this suite there day to day, so a mutation that put the
+// broken `%*` back stayed green everywhere it was checked (#1394 §C).
+function _writeLaunchScript(npxAbsPath, cacheDir, isWin = _IS_WIN) {
   // On Windows, don't write a bash launch script — use npx directly
-  if (_IS_WIN) {
+  if (isWin) {
     try {
       // Write a .cmd wrapper that Claude Desktop can execute
       fs.mkdirSync(cacheDir, { recursive: true })
       const cmdPath = path.join(cacheDir, 'lmcp-launch.cmd')
-      const script = `@echo off\r\n"${npxAbsPath}" -y local-mcp@latest %*\r\n`
+      // No %*: the arguments are already baked into the line above. Forwarding %*
+      // appended a SECOND copy of whatever the MCP host passed, so a client
+      // configured with args ended up running `npx -y local-mcp@latest -y
+      // local-mcp@latest` (#1394 §C).
+      const script = `@echo off\r\n"${npxAbsPath}" -y local-mcp@latest\r\n`
       fs.writeFileSync(cmdPath, script)
       return cmdPath
     } catch {
@@ -136,6 +145,17 @@ function _rooClinePath() {
   return path.join(HOME, '.config', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'mcp_settings.json')
 }
 
+// Where LMCP's own config.json (license_email, cloud_token, activation_checklist_pending)
+// lives. Used to hardcode the macOS "Library/Application Support" path unconditionally, so
+// on Windows it resolved to a nonsense C:\Users\X\Library\...\Local MCP directory that
+// nothing reads or creates on its own (#1390). Parameterized so it's testable without
+// being on each OS.
+function _localMcpConfigDir(platform = process.platform, home = HOME, appData = _APPDATA) {
+  if (platform === 'darwin') return path.join(home, 'Library', 'Application Support', 'Local MCP')
+  if (platform === 'win32') return path.join(appData, 'Local MCP')
+  return path.join(home, '.config', 'local-mcp')
+}
+
 const CLIENTS = [
   {
     id:       'claude-desktop',
@@ -268,32 +288,51 @@ function _atomicWriteConfig(filePath, data) {
   return { ok: true, error: '' }
 }
 
-// ── Inyectar config MCP en un cliente ────────────────────────────────────────
-// Returns { ok, stage, error, existingMcpCount, preservedServers }.
-// Never overwrites a file whose JSON cannot be parsed.
-
-function injectMcpConfig(client, command = NPX_COMMAND, args = NPX_ARGS) {
-  // On Windows, Claude Desktop needs cmd /c wrapper to find npx
-  if (_IS_WIN && client.id === 'claude-desktop') {
-    command = 'cmd'
-    args = ['/c', 'npx', '-y', 'local-mcp@latest']
-  }
-  // 1. Read existing config safely
-  const read = _safeReadConfig(client.cfgPath)
-  if (read.hadParseError) {
-    return { ok: false, stage: 'config_read', error: read.error, hadParseError: true,
-             existingMcpCount: 0, preservedServers: [] }
+// _launcherSpawnSpec turns a launcher path into the {command, args} an MCP client
+// config must carry so the host can actually SPAWN it.
+//
+// #1394 §C: on Windows the launcher is a `.cmd`, and it was written into the config
+// as a bare `command` for every client except claude-desktop. Node has refused to
+// spawn a `.cmd`/`.bat` without `shell: true` since the CVE-2024-27980 fix, so every
+// Node-based MCP host — Cursor, VS Code, Windsurf, Cline, Roo — got `spawn EINVAL`
+// and showed local-mcp as failed, on the very platform this release re-launches.
+//
+// The fix is to spawn the interpreter and pass the script as an ARGUMENT, which is
+// exactly what the claude-desktop branch of injectMcpConfig already did. A batch file
+// is never the executable; cmd.exe is.
+//
+// The invariant a test can check without knowing this function's shape: `command`
+// must never be a batch file. That is the precise condition Node refuses, not a
+// spelling of the fix.
+function _launcherSpawnSpec(launcherPath, isWin = _IS_WIN) {
+  // Kept as its own function so the rule is testable in isolation, but callers get
+  // it through _writeLaunchSpec below, which returns the SPEC and never a bare path.
+  // A mutation run showed why: with the conversion left to the caller, a caller that
+  // skipped it passed every test — the only caller lives inside runSetup(), where no
+  // unit test can reach. There is now nothing to forget.
+  if (!launcherPath) return null
+  if (isWin && /\.(cmd|bat)$/i.test(launcherPath)) {
+    return { command: process.env.COMSPEC || 'cmd.exe', args: ['/c', launcherPath] }
   }
+  return { command: launcherPath, args: [] }
+}
 
-  const cfg = read.data || {}
+// _writeLaunchSpec is what every caller uses: it writes the launcher AND returns the
+// {command, args} an MCP client config can actually spawn. Returning a bare path is
+// what let a `.cmd` land in the config as the executable (#1394 §C).
+function _writeLaunchSpec(npxAbsPath, cacheDir, isWin = _IS_WIN) {
+  return _launcherSpawnSpec(_writeLaunchScript(npxAbsPath, cacheDir, isWin), isWin)
+}
 
-  // Count other MCP servers before merge (for telemetry)
+// Merges the local-mcp entry into a SINGLE config object, mutating it in place.
+// Split out of injectMcpConfig so the same merge logic runs independently per path —
+// see the comment on injectMcpConfig for why that independence matters.
+function _mergeLocalMcpEntry(cfg, client, command, args) {
   const existingServers = Object.keys(
     cfg.mcpServers || cfg.servers || cfg.context_servers || {}
   )
   const otherServers = existingServers.filter(k => k !== 'local-mcp' && k !== 'office-mcp')
 
-  // 2. Merge — preserve everything, only add/replace local-mcp
   if (client.zed) {
     cfg.context_servers = cfg.context_servers || {}
     cfg.context_servers['local-mcp'] = { command: { path: command, args: args ?? [] } }
@@ -308,23 +347,71 @@ function injectMcpConfig(client, command = NPX_COMMAND, args = NPX_ARGS) {
     if (args !== undefined) entry.args = args
     cfg.mcpServers['local-mcp'] = entry
   }
+  return { existingCount: existingServers.length, otherServers }
+}
+
+// ── Inyectar config MCP en un cliente ────────────────────────────────────────
+// Returns { ok, stage, error, existingMcpCount, preservedServers, perPath }.
+// Never overwrites a file whose JSON cannot be parsed.
+//
+// Windows Claude Desktop can have TWO install types (MSIX + .exe) reading from TWO
+// different config files (_claudeDesktopAllPaths()). This used to read only the
+// PREFERRED path, merge local-mcp into that single object, then write that SAME
+// object to both paths — silently erasing any mcpServers that existed only in the
+// non-preferred file, and reporting only the last path's write result because `write`
+// was reassigned each loop iteration (#1390 finding 4). Each path is now read,
+// merged, and written independently, and the JSON-parse-error backup guard in
+// _safeReadConfig now protects every path, not just the preferred one.
+//
+// explicitPaths lets a test exercise the multi-path merge deterministically without
+// running on Windows with two real Claude Desktop installs (default null preserves
+// the real path-selection logic below).
+function injectMcpConfig(client, command = NPX_COMMAND, args = NPX_ARGS, explicitPaths = null) {
+  // On Windows, Claude Desktop needs cmd /c wrapper to find npx
+  if (_IS_WIN && client.id === 'claude-desktop') {
+    command = 'cmd'
+    args = ['/c', 'npx', '-y', 'local-mcp@latest']
+  }
+
+  const allPaths = explicitPaths ||
+    ((client.id === 'claude-desktop' && _IS_WIN) ? _claudeDesktopAllPaths() : [client.cfgPath])
+
+  const perPath = []
+  let existingMcpCount = 0
+  const preservedSet = new Set()
 
-  // 3. Atomic write + verify
-  // On Windows, Claude Desktop MSIX reads from a different path than the .exe install.
-  // Write to all known paths so both install types work.
-  const allPaths = (client.id === 'claude-desktop' && _IS_WIN) ? _claudeDesktopAllPaths() : [client.cfgPath]
-  let write = { ok: false, error: 'no paths' }
   for (const p of allPaths) {
+    const read = _safeReadConfig(p)
+    if (read.hadParseError) {
+      perPath.push({ path: p, ok: false, stage: 'config_read', error: read.error, hadParseError: true })
+      continue
+    }
+    const cfg = read.data || {}
+    const { existingCount, otherServers } = _mergeLocalMcpEntry(cfg, client, command, args)
+    existingMcpCount = Math.max(existingMcpCount, existingCount)
+    otherServers.forEach((s) => preservedSet.add(s))
+
     fs.mkdirSync(path.dirname(p), { recursive: true })
-    write = _atomicWriteConfig(p, cfg)
+    const write = _atomicWriteConfig(p, cfg)
+    perPath.push({ path: p, ok: write.ok, stage: write.ok ? 'config_write' : 'config_write_failed', error: write.error, hadParseError: false })
   }
+
+  const anyOk = perPath.some((r) => r.ok)
+  const failed = perPath.filter((r) => !r.ok)
+  if (failed.length > 0) {
+    for (const f of failed) {
+      process.stderr.write(`  ⚠ ${client.name}: could not update ${f.path} (${f.error}) — other MCP servers configured only there may be affected\n`)
+    }
+  }
+
   return {
-    ok:              write.ok,
-    stage:           write.ok ? 'config_write' : 'config_write_failed',
-    error:           write.error,
-    hadParseError:   false,
-    existingMcpCount: existingServers.length,
-    preservedServers: otherServers,
+    ok:               anyOk,
+    stage:            anyOk ? 'config_write' : (perPath[0] ? perPath[0].stage : 'config_read'),
+    error:            failed.map((f) => `${f.path}: ${f.error}`).join('; ') || (perPath[0] ? perPath[0].error : 'no paths'),
+    hadParseError:    !anyOk && perPath.some((r) => r.hadParseError),
+    existingMcpCount,
+    preservedServers: Array.from(preservedSet),
+    perPath,
   }
 }
 
@@ -403,30 +490,39 @@ async function runSetup(opts = {}) {
       process.stderr.write('Downloading LMCP runtime...\n')
       const { binPath, version: bv } = await ensureBinary()
       binaryVersion = bv || ''
-      // Copy binary to stable path (npx fast-path will exec it directly)
-      const stablePath = path.join(CACHE_DIR, 'local-mcp-server')
       try {
-        const tmpPath = stablePath + '.tmp'
-        fs.copyFileSync(binPath, tmpPath)
-        fs.chmodSync(tmpPath, 0o755)
-        try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {}
-        // curl route-3 installs the binary one level deeper:
-        //   ~/.local/share/local-mcp/bin/local-mcp-server/local-mcp-server
-        // leaving stablePath itself as a DIRECTORY. fs.renameSync throws EISDIR
-        // silently, so the npm stable binary is never written and the old curl
-        // server stays running forever (LMC-158).
-        try {
-          const st = fs.statSync(stablePath)
-          if (st.isDirectory()) {
-            process.stderr.write('  Migrating from curl install: removing old versioned directory at stable path\n')
-            fs.rmSync(stablePath, { recursive: true, force: true })
-          }
-        } catch { /* stablePath doesn't exist — nothing to do */ }
-        fs.renameSync(tmpPath, stablePath)
+        // Copy binary to stable path (npx fast-path will exec it directly). darwin-only:
+        // off darwin, ensureBinary() already writes the go-server binary directly at its
+        // final name (lmcp-server / lmcp-server.exe) inside CACHE_DIR — index.js's fast
+        // path looks for exactly that. This block, unguarded, used to also run there and
+        // leave a dead second copy misnamed `local-mcp-server` (no .exe, never read by
+        // anything) plus a doomed `codesign` call and an EISDIR migration written for a
+        // curl-install bug that only ever existed on macOS's old Python installer (#1390).
+        if (_IS_MAC) {
+          const stablePath = path.join(CACHE_DIR, 'local-mcp-server')
+          const tmpPath = stablePath + '.tmp'
+          fs.copyFileSync(binPath, tmpPath)
+          fs.chmodSync(tmpPath, 0o755)
+          try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {}
+          // curl route-3 installs the binary one level deeper:
+          //   ~/.local/share/local-mcp/bin/local-mcp-server/local-mcp-server
+          // leaving stablePath itself as a DIRECTORY. fs.renameSync throws EISDIR
+          // silently, so the npm stable binary is never written and the old curl
+          // server stays running forever (LMC-158).
+          try {
+            const st = fs.statSync(stablePath)
+            if (st.isDirectory()) {
+              process.stderr.write('  Migrating from curl install: removing old versioned directory at stable path\n')
+              fs.rmSync(stablePath, { recursive: true, force: true })
+            }
+          } catch { /* stablePath doesn't exist — nothing to do */ }
+          fs.renameSync(tmpPath, stablePath)
+        }
         // Write the actual binary version (from /runtime/latest), not the npm package
         // version. npm and Swift binary versions can diverge (npm-only fixes bump npm
         // without a Swift rebuild). Writing pkg.version here caused the tray to think
-        // a newer binary was on disk and restart-loop (LMC-TODO).
+        // a newer binary was on disk and restart-loop (LMC-TODO). Runs on every
+        // platform: index.js's readCachedVersion() reads .server-version off darwin too.
         fs.writeFileSync(path.join(CACHE_DIR, '.server-version'), binaryVersion || '')
         const settingsSrc = path.join(path.dirname(binPath), 'settings.html')
         const settingsDst = path.join(CACHE_DIR, 'settings.html')
@@ -438,16 +534,16 @@ async function runSetup(opts = {}) {
     // The launcher uses curl (no Node dependency) to send telemetry if Node is
     // too old, then exec's npx. Claude Desktop runs this script instead of npx
     // directly, so failures are visible in MCP logs AND in our backend events.
-    const launcherPath = _writeLaunchScript(npxAbsPath, CACHE_DIR)
-    if (launcherPath) stableCommand = launcherPath
+    const spec = _writeLaunchSpec(npxAbsPath, CACHE_DIR)
+    if (spec) { stableCommand = spec.command; stableArgs = spec.args }
   } catch (err) {
     process.stderr.write(`  (Runtime download failed, will download on first run: ${err.message})\n\n`)
     // Still try to write a launcher even if binary download failed — the version
     // check + telemetry path is independent of the binary.
     try {
       const { CACHE_DIR } = require('./download')
-      const launcherPath = _writeLaunchScript(npxAbsPath, CACHE_DIR)
-      if (launcherPath) stableCommand = launcherPath
+      const spec = _writeLaunchSpec(npxAbsPath, CACHE_DIR)
+      if (spec) { stableCommand = spec.command; stableArgs = spec.args }
     } catch {}
   }
   // stableCommand is now the shell launcher script path. It wraps npx with a
@@ -476,7 +572,7 @@ async function runSetup(opts = {}) {
     console.log('╚══════════════════════════════════════════════════════════╝\n')
     console.log('  To get started, add LMCP to your AI client config:\n')
     console.log('  ── Claude Desktop ────────────────────────────────────────')
-    console.log('  File: ~/Library/Application Support/Claude/claude_desktop_config.json\n')
+    console.log(`  File: ${_claudeDesktopPath()}\n`)
     console.log(snippet)
     console.log('\n  ── Cursor ────────────────────────────────────────────────')
     console.log('  File: ~/.cursor/mcp.json\n')
@@ -522,7 +618,7 @@ async function runSetup(opts = {}) {
     }
   }
 
-  const cfgDir  = path.join(HOME, 'Library', 'Application Support', 'Local MCP')
+  const cfgDir  = _localMcpConfigDir()
   const cfgFile = path.join(cfgDir, 'config.json')
 
   // Escribir email al config si viene por env
@@ -571,7 +667,7 @@ async function runSetup(opts = {}) {
   if (configured.length > 0) {
     if (healthOk) {
       console.log(`✅ LMCP configured for: ${configured.join(', ')}\n`)
-      console.log('  ✓ Server binary verified — 215+ tools ready\n')
+      console.log('  ✓ Server binary verified — 188+ tools ready\n')
     } else {
       console.log(`⚠  LMCP configured for: ${configured.join(', ')}`)
       console.log('  Server binary could not be verified — it may still work after restart.\n')
@@ -661,16 +757,26 @@ async function runSetup(opts = {}) {
   // Both fail silently: setup finishes, nothing is printed, the relay simply never comes up.
   {
     try {
+      // On darwin the token lives in config.json, read by the Swift tray. Off darwin
+      // the go-server reads ONLY CACHE_DIR/.cloud-token (#1390 finding 2) — check and
+      // write there instead, so this doesn't mint a second, unredeemable token under
+      // the same (now-correct, per finding 1) machine_id the go-server would otherwise
+      // register for itself on first run.
       const cfg = (_safeReadConfig(cfgFile)).data || {}
-      const existing = (cfg.cloud_token && typeof cfg.cloud_token === 'string'
+      const cfgToken = (cfg.cloud_token && typeof cfg.cloud_token === 'string'
                         && cfg.cloud_token.startsWith('lmcp-')) ? cfg.cloud_token : ''
+      const existing = _IS_MAC ? cfgToken : (cfgToken || _readCachedCloudToken(download.CACHE_DIR))
       let token = existing
       if (!token) {
         token = await _registerAnonToken()
         if (token) {
-          const cfg2 = (_safeReadConfig(cfgFile)).data || {}
-          cfg2.cloud_token = token
-          _atomicWriteConfig(cfgFile, cfg2)
+          if (_IS_MAC) {
+            const cfg2 = (_safeReadConfig(cfgFile)).data || {}
+            cfg2.cloud_token = token
+            _atomicWriteConfig(cfgFile, cfg2)
+          } else {
+            _writeCloudToken(download.CACHE_DIR, token)
+          }
           console.log('  ✓ Cloud relay activated (anonymous)')
         }
       }
@@ -730,21 +836,43 @@ async function _installTray() {
   }
 }
 
+// Resolves what to exec to prove the installed binary launches and responds. Pulled out
+// as a pure function (platform/home/cacheDir all parameters) so it's testable without
+// being on each OS. darwin uses the Swift binary's --export-tools (unchanged, tool-count
+// check); win32/linux use the go-server binary, which only supports --version/--daemon
+// (go-server/cmd/lmcp-server/main.go:430-433) — the old code called --export-tools there
+// too, which would have fallen through to stdio mode and hung until the timeout (#1390
+// finding 3), on top of checking a path+name (local-mcp-server, no .exe) the go-server
+// binary never has.
+function _healthCheckSpec(platform = process.platform, home = HOME, cacheDir = download.CACHE_DIR) {
+  if (platform === 'darwin') {
+    return { binPath: path.join(home, '.local', 'share', 'local-mcp', 'bin', 'local-mcp-server'), args: ['--export-tools'] }
+  }
+  const binName = platform === 'win32' ? 'lmcp-server.exe' : 'lmcp-server'
+  return { binPath: path.join(cacheDir, binName), args: ['--version'] }
+}
+
 function _runHealthCheck() {
   try {
-    const binPath = path.join(HOME, '.local', 'share', 'local-mcp', 'bin', 'local-mcp-server')
+    const { binPath, args } = _healthCheckSpec()
     if (!fs.existsSync(binPath)) return false
-    // Run with --export-tools to verify binary launches and responds
-    const result = execFileSync(binPath, ['--export-tools'], {
+    const result = execFileSync(binPath, args, {
       timeout: 10000,
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...process.env, HOME },
     })
     const output = result.toString().trim()
-    // Should return JSON array of tools
-    const tools = JSON.parse(output)
-    if (Array.isArray(tools) && tools.length > 50) {
-      process.stderr.write(`  Health check: ${tools.length} tools verified\n`)
+    if (_IS_MAC) {
+      // Should return JSON array of tools
+      const tools = JSON.parse(output)
+      if (Array.isArray(tools) && tools.length > 50) {
+        process.stderr.write(`  Health check: ${tools.length} tools verified\n`)
+        return true
+      }
+      return false
+    }
+    if (output) {
+      process.stderr.write(`  Health check: server binary responds (v${output})\n`)
       return true
     }
     return false
@@ -759,24 +887,23 @@ function _getRef() {
   return process.env.LMCP_REF || 'npm'
 }
 
+// Delegates to download.js's cross-platform implementation (darwin Keychain/ioreg +
+// win32 wmic UUID + linux /etc/machine-id + hashed-hostname fallback) instead of the
+// darwin-only Keychain/ioreg pair this function used to hardcode — that duplicate is
+// why machine_id traveled empty through the ENTIRE Windows/Linux setup funnel (#1390).
+//
+// The one thing download.js's version doesn't do is seed the macOS Keychain with the
+// ioreg-derived id so the Swift tray reads the same value setup computed. That side
+// effect stays here, gated to darwin, instead of moving into download.js: download's
+// _getMachineId runs on every ensureBinary()/ensureTray()/... call (i.e. on every
+// npx spawn), and a Keychain write there would be needless overhead on a hot path
+// that setup.js — which only runs once at install time — doesn't share.
 function _getMachineId() {
-  try {
-    // Try reading from macOS Keychain (shared with Swift server)
-    const r = execSync('security find-generic-password -s com.local-mcp.machine-id -a machine-id -w 2>/dev/null', { stdio: 'pipe' })
-    const id = r.toString().trim()
-    if (id) return id
-  } catch {}
-  try {
-    // Generate from hardware UUID (full UUID, same format as Swift server)
-    const ioreg = execSync('ioreg -rd1 -c IOPlatformExpertDevice', { stdio: 'pipe' }).toString()
-    const match = ioreg.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)
-    if (!match) return ''  // No hostname fallback — avoid PII leak
-    const id = match[1]
-    // Save to Keychain for Swift server to read
+  const id = download._getMachineId()
+  if (_IS_MAC && id) {
     try { execSync(`security add-generic-password -s com.local-mcp.machine-id -a machine-id -w "${id}" -U 2>/dev/null`, { stdio: 'pipe' }) } catch {}
-    return id
-  } catch {}
-  return ''
+  }
+  return id
 }
 
 /// Associate an email with this machine's tunnel token, presenting the token as proof of
@@ -821,6 +948,30 @@ async function _associateEmail(email, token) {
   })
 }
 
+// On darwin the anon cloud_token is persisted in config.json (cfgFile), which the Swift
+// tray already reads. Off darwin, the go-server reads it EXCLUSIVELY from
+// getCacheDir()/.cloud-token as a plain trimmed string (tunnel.go:454,513-523) — it never
+// looks at config.json — so writing the token to cfgFile there left it registered under a
+// key nothing could ever redeem (#1390 finding 2). getCacheDir() in the go-server resolves
+// to the exact same directory as CACHE_DIR here (tunnel.go:1107-1113 vs. download.js:39-41).
+function _cloudTokenPath(cacheDir) {
+  return path.join(cacheDir, '.cloud-token')
+}
+
+function _readCachedCloudToken(cacheDir) {
+  try {
+    const tok = fs.readFileSync(_cloudTokenPath(cacheDir), 'utf8').trim()
+    return tok.startsWith('lmcp-') ? tok : ''
+  } catch { return '' }
+}
+
+function _writeCloudToken(cacheDir, token) {
+  fs.mkdirSync(cacheDir, { recursive: true })
+  // 0o600 matches tokenFileMode in tunnel.go — best-effort on Windows, where POSIX bits
+  // are largely ignored, but real restriction on Linux.
+  fs.writeFileSync(_cloudTokenPath(cacheDir), token, { mode: 0o600 })
+}
+
 /// Claim an anonymous tunnel token via /tunnel/register-anon so cloud relay
 /// activates without asking for an email (2026-04-19 anon-first rollout). The
 /// token is keyed on the Mac's machine_id (IOPlatformUUID, shared via Keychain
@@ -1098,4 +1249,9 @@ function _autoLaunchClient(configured) {
 
 }
 
-module.exports = { runSetup, injectMcpConfig, CLIENTS }
+module.exports = {
+  runSetup, injectMcpConfig, CLIENTS,
+  _launcherSpawnSpec, _writeLaunchScript, _writeLaunchSpec,
+  _getMachineId, _healthCheckSpec, _localMcpConfigDir,
+  _cloudTokenPath, _readCachedCloudToken, _writeCloudToken, _registerAnonToken,
+}