local-mcp 3.0.369 → 3.0.371

package/README.md

@@ -1,6 +1,6 @@
 # Local MCP
 
-> **The only Mac MCP you can use from ChatGPT & Claude.ai on the web** — plus 260 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 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.
 
 [![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)
@@ -74,7 +74,7 @@ LMCP runs a native MCP server that bridges your Mac apps to any AI client:
 
  
 
-## All 260 tools (macOS)
+## Tool catalog (macOS)
 
 Email (12): `list_accounts` `list_email_accounts` `list_emails` `read_email` `send_email` `reply_email` `create_draft` `search_emails` `move_email` `save_attachment` `create_email_folder` `list_email_folders`
 
@@ -132,6 +132,8 @@ NordVPN (3): `nordvpn_status` `nordvpn_servers` `nordvpn_diagnose`
 
 Referral (2): `create_referral_invites` `list_referral_candidates`
 
+Agent mesh (9): `agent_mesh_status` `agent_mesh_create` `agent_mesh_invite` `agent_mesh_join` `agent_mesh_revoke` `agent_checkin` `agents_list` `agent_send` `agent_inbox`
+
 System (12): `lmcp_state` `get_config` `get_datetime` `daily_brief` `run_diagnostics` `get_audit_log` `lmcp_install_upgrade` `lmcp_upgrade_diagnostics` `report_problem` `request_feature` `report_friction` `run_terminal_command`
 
 _Coming soon (not included in the 162 count above): **Evernote** (support is being rebuilt)._

package/download.js

@@ -18,6 +18,15 @@ function extractTar(tarPath, destDir) {
   const tarBin = process.platform === 'win32'
     ? path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'tar.exe')
     : 'tar'
+  // Windows 10 1803+ ships bsdtar at System32\tar.exe. On an older/stripped Windows
+  // it's absent — fail with a clear cause instead of a bare execFileSync ENOENT that
+  // the caller would otherwise mask as "not yet available" (#1256).
+  if (process.platform === 'win32' && !fs.existsSync(tarBin)) {
+    throw new Error(
+      `tar.exe not found at ${tarBin} — Windows 10 1803+ (with built-in bsdtar) is ` +
+      `required to unpack the LMCP server.`
+    )
+  }
   execFileSync(tarBin, ['-xzf', tarPath, '-C', destDir], { stdio: 'pipe' })
 }
 
@@ -81,6 +90,19 @@ function getArch() {
   throw new Error(`Unsupported architecture: ${plat}/${arch}. LMCP requires arm64 or x64.`)
 }
 
+// Version of the artifact a given URL actually points at, parsed from the
+// published name lmcp-server-<version>-<os>-<arch>.tar.gz. Returns null when the
+// name doesn't match, so the caller falls back explicitly instead of inventing one.
+//
+// Why this exists: /runtime/latest returns a top-level `version` that is the MAC
+// release, while windows_*/linux_* are built from a separate win-* row. They
+// diverge (2026-08-08: version=3.0.369 next to a 3.0.258 windows artifact), so on
+// non-darwin the Mac number describes neither what gets downloaded nor what runs.
+function versionFromArtifactUrl(url, arch) {
+  const m = new RegExp(`/lmcp-server-(.+)-${arch}\\.tar\\.gz$`).exec(String(url || ''))
+  return m ? m[1] : null
+}
+
 /**
  * Obtiene la versión más reciente del binario desde el backend.
  * Si esta máquina está en beta_machines, el backend retorna la versión beta.
@@ -109,7 +131,7 @@ async function getLatestBinary() {
 /**
  * Descarga un archivo con barra de progreso.
  */
-async function downloadFile(url, destPath) {
+function downloadOnce(url, destPath) {
   return new Promise((resolve, reject) => {
     const file = fs.createWriteStream(destPath)
     const proto = url.startsWith('https') ? https : http
@@ -151,6 +173,27 @@ async function downloadFile(url, destPath) {
   })
 }
 
+// Retry transient download failures (timeouts, resets, 5xx). A 4xx is permanent —
+// a missing/forbidden artifact won't appear on a retry, so fail fast and let the
+// caller decide whether that means "not yet published". Backoff grows per attempt.
+async function downloadFile(url, destPath) {
+  const maxAttempts = 3
+  let lastErr
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await downloadOnce(url, destPath)
+    } catch (err) {
+      lastErr = err
+      if (/HTTP 4\d\d/.test(err.message)) throw err // permanent, don't retry
+      if (attempt < maxAttempts) {
+        process.stderr.write(`\n  Download failed (${err.message}) — retrying (${attempt}/${maxAttempts - 1})...\n`)
+        await new Promise(r => setTimeout(r, 1000 * attempt))
+      }
+    }
+  }
+  throw lastErr
+}
+
 /**
  * Asegura que el binario esté descargado y listo.
  * @returns {Promise<{binPath: string}>}
@@ -167,25 +210,52 @@ async function ensureBinary() {
     const binPath = path.join(CACHE_DIR, binName)
     const versionFile = path.join(CACHE_DIR, '.go-server-version')
 
-    // Check if already cached at the right version
+    // Resolve the download URL BEFORE the cache check: the version this platform
+    // actually installs is the one in that URL, not info.version (the Mac release).
+    //
+    // Each branch knows its own version by construction, so there is no guessing:
+    //   · published URL → the version is whatever that name says. If the name
+    //     doesn't parse we FAIL rather than fall back to info.version, which would
+    //     record a Mac number against a non-Mac artifact — the very bug this path
+    //     exists to fix, reappearing in the one corner nobody would look at.
+    //   · composed URL → we built it from info.version, so that IS the version.
+    const archKey = arch.replace('-', '_') // windows-amd64 → windows_amd64
+    const publishedUrl = (info[archKey] && info[archKey].startsWith('http')) ? info[archKey] : null
+
+    let url, platformVersion
+    if (publishedUrl) {
+      platformVersion = versionFromArtifactUrl(publishedUrl, arch)
+      if (!platformVersion) {
+        throw new Error(
+          `No pude determinar la versión del artefacto publicado para ${arch}.\n` +
+          `  URL: ${publishedUrl}\n` +
+          `  Se esperaba un nombre lmcp-server-<versión>-${arch}.tar.gz.\n` +
+          `Reportalo: la convención de nombres del backend cambió.`
+        )
+      }
+      url = publishedUrl
+    } else {
+      platformVersion = version
+      url = `https://download.local-mcp.com/lmcp-server-${version}-${arch}.tar.gz`
+    }
+
+    // Check if already cached at the right version. Comparing against
+    // info.version here re-downloaded the SAME artifact on every Mac release and
+    // then recorded the Mac number, so the machine reported a build it wasn't
+    // running. Comparing against platformVersion keeps both directions honest:
+    // an unchanged Windows artifact is a cache hit, a new one is a miss.
     if (fs.existsSync(binPath)) {
       try {
         const cached = fs.readFileSync(versionFile, 'utf8').trim()
-        if (cached === version) return { binPath, versionDir: CACHE_DIR, version }
+        if (cached === platformVersion) return { binPath, versionDir: CACHE_DIR, version: platformVersion }
       } catch {}
     }
 
-    // Download the Go binary tarball from R2
-    // Use the platform-specific URL from /runtime/latest if available (avoids version mismatch)
-    const archKey = arch.replace('-', '_') // windows-amd64 → windows_amd64
-    const url = (info[archKey] && info[archKey].startsWith('http'))
-      ? info[archKey]
-      : `https://download.local-mcp.com/lmcp-server-${version}-${arch}.tar.gz`
-    process.stderr.write(`\nLMCP v${version} (${arch}) not found in cache.\n`)
+    process.stderr.write(`\nLMCP v${platformVersion} (${arch}) not found in cache.\n`)
     process.stderr.write(`Downloading from ${url}\n`)
 
     fs.mkdirSync(CACHE_DIR, { recursive: true })
-    const tarPath = path.join(CACHE_DIR, `go-server-${version}.tar.gz`)
+    const tarPath = path.join(CACHE_DIR, `go-server-${platformVersion}.tar.gz`)
 
     try {
       await downloadFile(url, tarPath)
@@ -193,11 +263,20 @@ async function ensureBinary() {
       extractTar(tarPath, CACHE_DIR)
       fs.unlinkSync(tarPath)
     } catch (err) {
-      // Go binary not yet published for this version — fall back to message
       try { fs.unlinkSync(tarPath) } catch {}
+      // Only a 404 means the artifact for this version/arch genuinely isn't published.
+      // Every other failure (network, missing tar.exe, disk) is an environment problem —
+      // surface it verbatim so it's diagnosable. Masking ALL failures as "in preview" sent
+      // us chasing a backend version-alignment ghost that didn't exist (#1256): the artifact
+      // was published, valid and hash-correct; the client just failed to fetch/unpack it.
+      if (/HTTP 404/.test(err.message)) {
+        throw new Error(
+          `LMCP ${platformVersion} is not yet available for ${arch}.\n` +
+          `The Windows/Linux Go server is in preview — check https://local-mcp.com for updates.`
+        )
+      }
       throw new Error(
-        `LMCP ${version} is not yet available for ${arch}.\n` +
-        `The Windows/Linux Go server is in preview — check https://local-mcp.com for updates.`
+        `Failed to install LMCP ${platformVersion} (${arch}) from ${url}:\n  ${err.message}`
       )
     }
 
@@ -205,10 +284,10 @@ async function ensureBinary() {
       throw new Error(`Binary not found after extraction: ${binPath}`)
     }
     if (process.platform !== 'win32') fs.chmodSync(binPath, 0o755)
-    fs.writeFileSync(versionFile, version)
+    fs.writeFileSync(versionFile, platformVersion)
 
     process.stderr.write(`  Ready at ${CACHE_DIR}\n`)
-    return { binPath, versionDir: CACHE_DIR, version }
+    return { binPath, versionDir: CACHE_DIR, version: platformVersion }
   }
 
   // macOS: Swift binary in a nested tarball
@@ -499,4 +578,4 @@ async function ensureSlackProxy() {
   }
 }
 
-module.exports = { ensureBinary, ensureRuntime, ensureTray, ensureTeamsProxy, ensureSlackProxy, CACHE_DIR, TRAY_DIR }
+module.exports = { ensureBinary, ensureRuntime, ensureTray, ensureTeamsProxy, ensureSlackProxy, versionFromArtifactUrl, CACHE_DIR, TRAY_DIR }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-mcp",
-  "version": "3.0.369",
+  "version": "3.0.371",
   "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": {
@@ -20,7 +20,9 @@
     "node": ">=18"
   },
   "os": [
-    "darwin"
+    "darwin",
+    "linux",
+    "win32"
   ],
   "keywords": [
     "mcp",

package/setup.js

@@ -584,7 +584,7 @@ async function runSetup(opts = {}) {
   if (configured.length > 0) {
     if (healthOk) {
       console.log(`✅ LMCP configured for: ${configured.join(', ')}\n`)
-      console.log('  ✓ Server binary verified — 100 tools ready\n')
+      console.log('  ✓ Server binary verified — 215+ 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')
@@ -662,29 +662,50 @@ async function runSetup(opts = {}) {
   // can attach an email later via the tray or /settings to unlock cross-Mac
   // sync + paid-license features. Non-fatal on failure — the install still
   // succeeds and the server can retry at startup.
-  if (!email) {
+  // Provisioning is ALWAYS anonymous, with or without an email — same change made in install.sh
+  // (#1083). Two separate ways this used to be skipped, and both left the machine with NO
+  // cloud_token, depending on /tunnel/token minting one for that address on first contact — the
+  // very TOFU path being removed (a stranger can pre-register someone else's address and end up
+  // sharing the token):
+  //   1. `if (!email)` — an install that supplied LMCP_EMAIL never registered at all.
+  //   2. `alreadyLinked` — a config that already carried license_email was skipped too, even
+  //      with no token. That one is easier to miss: it fires on the SECOND run of a machine
+  //      whose email was saved a few lines above.
+  // Both fail silently: setup finishes, nothing is printed, the relay simply never comes up.
+  {
     try {
       const cfg = (_safeReadConfig(cfgFile)).data || {}
-      const alreadyLinked = (cfg.license_email && cfg.license_email.length > 0)
-      const alreadyAnon   = (cfg.cloud_token && typeof cfg.cloud_token === 'string' && cfg.cloud_token.startsWith('lmcp-'))
-      if (!alreadyLinked && !alreadyAnon) {
-        const tok = await _registerAnonToken()
-        if (tok) {
+      const existing = (cfg.cloud_token && typeof cfg.cloud_token === 'string'
+                        && cfg.cloud_token.startsWith('lmcp-')) ? cfg.cloud_token : ''
+      let token = existing
+      if (!token) {
+        token = await _registerAnonToken()
+        if (token) {
           const cfg2 = (_safeReadConfig(cfgFile)).data || {}
-          cfg2.cloud_token = tok
+          cfg2.cloud_token = token
           _atomicWriteConfig(cfgFile, cfg2)
           console.log('  ✓ Cloud relay activated (anonymous)')
         }
       }
+      // Associate the email with this machine's token — the one just minted OR the one it
+      // already had. Outside the "no token yet" branch on purpose: a machine re-running setup
+      // (reinstall, upgrade, second attempt) already has a token, and nesting this inside meant
+      // its email was dropped without a sound. The cloud_token travels as proof of possession:
+      // /install-event has no auth, so that UPDATE refuses to touch a row unless the caller
+      // holds that machine's token.
+      if (email && token) await _associateEmail(email, token)
     } catch { /* non-fatal */ }
 
-    // Show settings URL with machine_id so user can register email (LMC-887)
-    try {
-      const mid = _getMachineId()
-      if (mid) {
-        console.log(`\n  \x1b[1m📧 Get update notifications:\x1b[0m https://local-mcp.com/settings?m=${mid}`)
-      }
-    } catch { /* non-fatal */ }
+    // Show settings URL with machine_id so user can register email (LMC-887). Only when no
+    // email was supplied — someone who passed LMCP_EMAIL does not need to be asked for it.
+    if (!email) {
+      try {
+        const mid = _getMachineId()
+        if (mid) {
+          console.log(`\n  \x1b[1m📧 Get update notifications:\x1b[0m https://local-mcp.com/settings?m=${mid}`)
+        }
+      } catch { /* non-fatal */ }
+    }
   }
 
   // LMCP_METHOD lets install.sh pass 'curl' so we can distinguish it from
@@ -771,6 +792,48 @@ function _getMachineId() {
   return ''
 }
 
+/// Associate an email with this machine's tunnel token, presenting the token as proof of
+/// possession. Setup used to get this for free by registering WITH the email; now that
+/// provisioning is always anonymous, the association has to happen explicitly or these users
+/// stay anonymous forever on the backend.
+///
+/// /install-event has no auth, so the UPDATE behind it refuses to touch a row unless the caller
+/// holds that machine's token — that guard is what makes calling this from an unauthenticated
+/// installer safe. Calling it when the email is already set is harmless: the backend also guards
+/// on (email IS NULL OR email = ''), so a no-op is the normal case here, not an error.
+///
+/// Non-fatal on every failure path: setup must finish regardless.
+async function _associateEmail(email, token) {
+  return new Promise((resolve) => {
+    try {
+      const https = require('https')
+      const payload = JSON.stringify({
+        stage: 'email_prompt',
+        email_prompt_result: 'submitted',
+        email,
+        machine_id: _getMachineId(),
+        cloud_token: token,
+        source: 'npx-setup',
+      })
+      const req = https.request({
+        host: BACKEND_HOST,
+        port: 443,
+        method: 'POST',
+        path: '/install-event',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+        },
+        timeout: 5000,
+      }, (res) => { res.on('data', () => {}); res.on('end', () => resolve()) })
+      req.on('error', () => resolve())
+      req.on('timeout', () => { try { req.destroy() } catch {} resolve() })
+      req.write(payload)
+      req.end()
+    } catch { resolve() }
+  })
+}
+
 /// 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