local-mcp 3.0.137 → 3.0.139

package/download.js

@@ -13,34 +13,61 @@ const os     = require('os')
 const { execFileSync } = require('child_process')
 
 const BACKEND_URL = 'https://office-mcp-production.up.railway.app'
-const CACHE_DIR   = path.join(os.homedir(), '.local', 'share', 'local-mcp', 'bin')
-const TRAY_DIR    = path.join(os.homedir(), '.local', 'share', 'local-mcp', 'tray')  // metadata dir
+
+// Platform-aware cache directory:
+//   macOS:   ~/.local/share/local-mcp/bin
+//   Windows: %LOCALAPPDATA%/local-mcp/bin
+//   Linux:   ~/.local/share/local-mcp/bin
+const CACHE_DIR = process.platform === 'win32'
+  ? path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'local-mcp', 'bin')
+  : path.join(os.homedir(), '.local', 'share', 'local-mcp', 'bin')
+
+const TRAY_DIR = process.platform === 'win32'
+  ? path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'local-mcp', 'tray')
+  : path.join(os.homedir(), '.local', 'share', 'local-mcp', 'tray')
+
 // Install to ~/Applications (user-owned) to avoid macOS App Management TCC prompt.
 // /Applications requires kTCCServiceAppManagement permission which shows "node would like
 // to access data from other apps" on every tray update — confusing and unnecessary.
-const TRAY_APP    = path.join(os.homedir(), 'Applications', 'LocalMCPTray.app')
+// On Windows/Linux there is no tray app yet.
+const TRAY_APP = process.platform === 'darwin'
+  ? path.join(os.homedir(), 'Applications', 'LocalMCPTray.app')
+  : null
 
 function _getMachineId() {
   const { execSync } = require('child_process')
-  try {
-    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 {
-    // Full hardware UUID (same format as Swift server)
-    const ioreg = execSync('ioreg -rd1 -c IOPlatformExpertDevice', { stdio: 'pipe' }).toString()
-    const match = ioreg.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)
-    return match ? match[1] : os.hostname()
-  } catch {}
-  return ''
+  if (process.platform === 'darwin') {
+    try {
+      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 {
+      const ioreg = execSync('ioreg -rd1 -c IOPlatformExpertDevice', { stdio: 'pipe' }).toString()
+      const match = ioreg.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)
+      return match ? match[1] : os.hostname()
+    } 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 {}
+  } else {
+    try {
+      const mid = fs.readFileSync('/etc/machine-id', 'utf8').trim()
+      if (mid) return mid
+    } catch {}
+  }
+  return os.hostname()
 }
 
 function getArch() {
+  const plat = process.platform === 'win32' ? 'windows' : process.platform === 'linux' ? 'linux' : 'darwin'
   const arch = process.arch
-  if (arch === 'arm64') return 'darwin-arm64'
-  if (arch === 'x64')   return 'darwin-x64'
-  throw new Error(`Arquitectura no soportada: ${arch}. LMCP requiere macOS arm64 o x64.`)
+  if (arch === 'arm64') return `${plat}-arm64`
+  if (arch === 'x64')   return `${plat}-amd64`
+  throw new Error(`Unsupported architecture: ${plat}/${arch}. LMCP requires arm64 or x64.`)
 }
 
 /**
@@ -121,7 +148,55 @@ async function ensureBinary() {
   const arch   = getArch()
   const info   = await getLatestBinary()
   const version = info.version
-  // URL del binario PyInstaller (nueva nomenclatura)
+
+  // On non-darwin, use the Go server binary (cross-platform).
+  // The Go binary is a single file, not a nested tarball.
+  if (process.platform !== 'darwin') {
+    const binName = process.platform === 'win32' ? 'lmcp-server.exe' : 'lmcp-server'
+    const binPath = path.join(CACHE_DIR, binName)
+    const versionFile = path.join(CACHE_DIR, '.go-server-version')
+
+    // Check if already cached at the right version
+    if (fs.existsSync(binPath)) {
+      try {
+        const cached = fs.readFileSync(versionFile, 'utf8').trim()
+        if (cached === version) return { binPath, versionDir: CACHE_DIR, version }
+      } catch {}
+    }
+
+    // Download the Go binary tarball from R2
+    const url = `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(`Downloading from ${url}\n`)
+
+    fs.mkdirSync(CACHE_DIR, { recursive: true })
+    const tarPath = path.join(CACHE_DIR, `go-server-${version}.tar.gz`)
+
+    try {
+      await downloadFile(url, tarPath)
+      process.stderr.write(`  Extracting...\n`)
+      execFileSync('tar', ['-xzf', tarPath, '-C', CACHE_DIR], { stdio: 'pipe' })
+      fs.unlinkSync(tarPath)
+    } catch (err) {
+      // Go binary not yet published for this version — fall back to message
+      try { fs.unlinkSync(tarPath) } catch {}
+      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.`
+      )
+    }
+
+    if (!fs.existsSync(binPath)) {
+      throw new Error(`Binary not found after extraction: ${binPath}`)
+    }
+    if (process.platform !== 'win32') fs.chmodSync(binPath, 0o755)
+    fs.writeFileSync(versionFile, version)
+
+    process.stderr.write(`  Ready at ${CACHE_DIR}\n`)
+    return { binPath, versionDir: CACHE_DIR, version }
+  }
+
+  // macOS: Swift binary in a nested tarball
   const url = `https://download.local-mcp.com/local-mcp-server-${version}-${arch}.tar.gz`
 
   const versionDir = path.join(CACHE_DIR, version)
@@ -148,28 +223,19 @@ async function ensureBinary() {
     throw new Error(`Binario no encontrado después de extraer: ${binPath}`)
   }
 
-  // Asegurar que sea ejecutable
   fs.chmodSync(binPath, 0o755)
 
-  // Clear quarantine separately — Node.js https downloads don't set it, but tar extraction
-  // on some macOS versions can inherit it from the archive. Non-critical.
-  try { execFileSync('xattr', ['-d', 'com.apple.quarantine', binPath], { stdio: 'pipe' }) } catch { /* no quarantine, fine */ }
+  try { execFileSync('xattr', ['-d', 'com.apple.quarantine', binPath], { stdio: 'pipe' }) } catch {}
 
-  // Preserve the Developer ID signature from the build pipeline.
-  // On macOS 26+ ad-hoc signatures (--sign -) don't create a stable TCC identity:
-  // each new CDHash is treated as a new app, triggering "node would like to access
-  // data from other apps" on every JXA call. Only fall back to ad-hoc if the binary
-  // has no valid signature at all (e.g. a dev build that was never properly signed).
-  // See: FB-74E468, FB-017B8E — permission prompt loop on macOS 26 beta.
   let hasSig = false
   try {
     execFileSync('codesign', ['--verify', binPath], { stdio: 'pipe' })
     hasSig = true
-  } catch { /* no valid signature — apply ad-hoc fallback */ }
+  } catch {}
   if (!hasSig) {
     try {
       execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', binPath], { stdio: 'pipe' })
-    } catch { /* non-critical */ }
+    } catch {}
   }
 
   process.stderr.write(`  Listo en ${versionDir}\n`)

package/index.js

@@ -18,9 +18,24 @@ const fs    = require('fs')
 const https = require('https')
 
 
-// Solo macOS
-if (process.platform !== 'darwin') {
-  console.error('LMCP solo está disponible para macOS.')
+// Platform support: macOS (full), Windows (Go server), Linux (Go server)
+const SUPPORTED_PLATFORMS = ['darwin', 'win32', 'linux']
+if (!SUPPORTED_PLATFORMS.includes(process.platform)) {
+  console.error(`LMCP is not available for ${process.platform}. Supported: macOS, Windows, Linux.`)
+  process.exit(1)
+}
+
+// Node version guard — Claude Desktop can silently launch LMCP with an old
+// nvm default (e.g. v11) that makes `npx -y` fail before this file loads.
+// If this code IS running on an old Node, surface the error clearly so the
+// user sees it in Claude Desktop's MCP logs instead of a cryptic spawn error.
+if (parseInt(process.version.slice(1)) < 16) {
+  const msg = `LMCP requires Node 16+. Running ${process.version}.\n` +
+    `If you use nvm, run: nvm alias default 22 && nvm uninstall ${process.version}\n` +
+    'Then restart Claude Desktop / Cursor.'
+  process.stderr.write(msg + '\n')
+  // Exit with a non-zero code so the MCP host marks the server as failed
+  // (vs hanging forever with no output).
   process.exit(1)
 }
 
@@ -75,7 +90,8 @@ async function main() {
 
   // ── Modo default: stdio MCP server ──────────────────────────────────────────
   const { CACHE_DIR } = require('./download')
-  const stableBin = path.join(CACHE_DIR, 'local-mcp-server')
+  const binName = process.platform === 'win32' ? 'local-mcp-server.exe' : 'local-mcp-server'
+  const stableBin = path.join(CACHE_DIR, binName)
   const versionFile = path.join(CACHE_DIR, '.server-version')
   const pkg = require('./package.json')
 
@@ -103,11 +119,13 @@ async function main() {
         : ''
       if (cachedVersion && semverGte(cachedVersion, pkg.version)) {
         // Cached binary is same or newer — use fast path, no download needed
-        const { ensureTray, ensureTeamsProxy, ensureHelper, ensureJXARunner } = require('./download')
-        ensureTray().catch(() => {})
-        ensureTeamsProxy().catch(() => {})
-        ensureHelper().catch(() => {})
-        ensureJXARunner().catch(() => {})
+        if (process.platform === 'darwin') {
+          const { ensureTray, ensureTeamsProxy, ensureHelper, ensureJXARunner } = require('./download')
+          ensureTray().catch(() => {})
+          ensureTeamsProxy().catch(() => {})
+          ensureHelper().catch(() => {})
+          ensureJXARunner().catch(() => {})
+        }
         const child = spawn(stableBin, [], { stdio: 'inherit', env: process.env })
         child.on('error', () => process.exit(1))
         child.on('exit', (code) => process.exit(code ?? 0))
@@ -136,7 +154,7 @@ async function main() {
                         const tmpPath = stableBin + '.tmp'
                         fs.copyFileSync(binPath, tmpPath)
                         fs.chmodSync(tmpPath, 0o755)
-                        try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {}
+                        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 {}
@@ -165,11 +183,13 @@ async function main() {
   // Slow path: download/repair binary
   const { ensureRuntime, ensureTray, ensureTeamsProxy, ensureHelper, ensureJXARunner } = require('./download')
 
-  // Update tray + proxies in background. Helper + jxa-runner downloaded only on first install.
-  ensureTray().catch(() => {})
-  ensureTeamsProxy().catch(() => {})
-  ensureHelper().catch(() => {})
-  ensureJXARunner().catch(() => {})
+  // Update tray + proxies in background (macOS only).
+  if (process.platform === 'darwin') {
+    ensureTray().catch(() => {})
+    ensureTeamsProxy().catch(() => {})
+    ensureHelper().catch(() => {})
+    ensureJXARunner().catch(() => {})
+  }
 
   let runtime
   try {
@@ -187,7 +207,7 @@ async function main() {
     const tmpPath = stableBin + '.tmp'
     fs.copyFileSync(binPath, tmpPath)
     fs.chmodSync(tmpPath, 0o755)
-    try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {}
+    if (process.platform === 'darwin') { try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {} }
     fs.renameSync(tmpPath, stableBin)
     // Write the ACTUAL downloaded binary version (not pkg.version) so the fast path
     // knows what version is on disk. Using pkg.version here caused LMC-375: machines

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-mcp",
-  "version": "3.0.137",
+  "version": "3.0.139",
   "description": "LMCP — connect Claude Desktop, Cursor, Windsurf to Mail, Calendar, Contacts, Teams, OneDrive on macOS. Privacy-first: all data stays on your Mac.",
   "main": "index.js",
   "bin": {
@@ -20,7 +20,9 @@
     "node": ">=18"
   },
   "os": [
-    "darwin"
+    "darwin",
+    "win32",
+    "linux"
   ],
   "keywords": [
     "mcp",

package/setup.js

@@ -16,17 +16,83 @@ const { execSync, execFileSync } = require('child_process')
 const HOME = os.homedir()
 const NPX_COMMAND = 'npx'
 const NPX_ARGS    = ['-y', 'local-mcp@latest']
+
+// Resolve absolute path to npx from the current Node binary so Claude Desktop
+// doesn't pick up an old npx from its own PATH (common with nvm users whose
+// nvm default points to Node v11/v12 — those npx versions don't support -y).
+// Falls back to plain 'npx' if resolution fails (non-nvm setups, symlinks, etc.)
+function _resolveNpxPath() {
+  try {
+    const candidate = path.join(path.dirname(process.execPath), 'npx')
+    if (fs.existsSync(candidate)) return candidate
+  } catch {}
+  return NPX_COMMAND
+}
+
+// Write a shell launcher script that wraps npx with a Node version check and
+// 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) {
+  try {
+    fs.mkdirSync(cacheDir, { recursive: true })
+    const launcherPath = path.join(cacheDir, 'lmcp-launch.sh')
+    const script = [
+      '#!/bin/bash',
+      '# LMCP launcher — generated by npx local-mcp setup, do not edit.',
+      '# Checks Node version before launching npx; sends telemetry if too old.',
+      'NODE_VER=$(node --version 2>/dev/null || echo "none")',
+      'NODE_MAJOR=$(echo "$NODE_VER" | sed \'s/v//\' | cut -d. -f1)',
+      'if [ "${NODE_MAJOR:-0}" -lt 16 ] 2>/dev/null; then',
+      '  # curl telemetry — no Node dependency, fire-and-forget',
+      `  curl -sf --max-time 3 -X POST "https://${BACKEND_HOST}/install-event" \\`,
+      '    -H "Content-Type: application/json" \\',
+      '    -d "{\\\"stage\\\":\\\"node_too_old\\\",\\\"version\\\":\\\"$NODE_VER\\\"}" &>/dev/null &',
+      '  printf \'LMCP requires Node 16+. Current: %s\\nFix: nvm alias default 22 && nvm uninstall %s — then restart Claude Desktop.\\n\' "$NODE_VER" "$NODE_VER" >&2',
+      '  exit 1',
+      'fi',
+      `exec "${npxAbsPath}" -y local-mcp@latest "$@"`,
+    ].join('\n') + '\n'
+    fs.writeFileSync(launcherPath, script, { mode: 0o755 })
+    return launcherPath
+  } catch {
+    return null
+  }
+}
 const STABLE_LINK   = path.join(os.homedir(), '.local', 'share', 'local-mcp', 'bin', 'local-mcp-server')
 const BACKEND_HOST  = 'office-mcp-production.up.railway.app'
 
-// ── Rutas de config de cada cliente ──────────────────────────────────────────
+// ── Platform-aware config paths for AI clients ─────────────────────────────
+// macOS: ~/Library/Application Support/...
+// Windows: %APPDATA%/... (most Electron apps use APPDATA)
+// Linux: ~/.config/... (XDG standard)
+
+const _IS_WIN = process.platform === 'win32'
+const _IS_MAC = process.platform === 'darwin'
+const _APPDATA = process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming')
+
+function _claudeDesktopPath() {
+  if (_IS_WIN) return path.join(_APPDATA, 'Claude', 'claude_desktop_config.json')
+  if (_IS_MAC) return path.join(HOME, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json')
+  return path.join(HOME, '.config', 'Claude', 'claude_desktop_config.json')
+}
+
+function _claudeDesktopDetect() {
+  return fs.existsSync(path.dirname(_claudeDesktopPath()))
+}
+
+function _rooClinePath() {
+  if (_IS_WIN) return path.join(_APPDATA, 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'mcp_settings.json')
+  if (_IS_MAC) return path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'mcp_settings.json')
+  return path.join(HOME, '.config', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'mcp_settings.json')
+}
 
 const CLIENTS = [
   {
     id:       'claude-desktop',
     name:     'Claude Desktop',
-    cfgPath:  path.join(HOME, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
-    detect:   () => fs.existsSync(path.join(HOME, 'Library', 'Application Support', 'Claude')),
+    cfgPath:  _claudeDesktopPath(),
+    detect:   _claudeDesktopDetect,
   },
   {
     id:       'cursor',
@@ -50,8 +116,8 @@ const CLIENTS = [
   {
     id:       'roo-cline',
     name:     'Roo-Cline',
-    cfgPath:  path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'mcp_settings.json'),
-    detect:   () => fs.existsSync(path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline')),
+    cfgPath:  _rooClinePath(),
+    detect:   () => fs.existsSync(path.dirname(_rooClinePath())),
   },
   {
     id:       'zed',
@@ -71,12 +137,25 @@ const CLIENTS = [
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 function _appExists(name) {
-  return fs.existsSync(`/Applications/${name}.app`) ||
-         fs.existsSync(path.join(HOME, `Applications/${name}.app`))
+  if (_IS_MAC) {
+    return fs.existsSync(`/Applications/${name}.app`) ||
+           fs.existsSync(path.join(HOME, `Applications/${name}.app`))
+  }
+  if (_IS_WIN) {
+    // Check common Windows install locations
+    const pf = process.env.ProgramFiles || 'C:\\Program Files'
+    const pf86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)'
+    const localApp = process.env.LOCALAPPDATA || path.join(HOME, 'AppData', 'Local')
+    return fs.existsSync(path.join(pf, name)) ||
+           fs.existsSync(path.join(pf86, name)) ||
+           fs.existsSync(path.join(localApp, name))
+  }
+  return false  // Linux: rely on _cmdExists or config path detection
 }
 
 function _cmdExists(cmd) {
-  try { execSync(`which ${cmd}`, { stdio: 'pipe' }); return true } catch { return false }
+  const which = _IS_WIN ? 'where' : 'which'
+  try { execSync(`${which} ${cmd}`, { stdio: 'pipe' }); return true } catch { return false }
 }
 
 // ── Safe config read ─────────────────────────────────────────────────────────
@@ -212,9 +291,21 @@ async function runSetup(opts = {}) {
   console.log('║     LMCP — Setup Wizard         ║')
   console.log('╚══════════════════════════════════════╝\n')
 
+  // Warn if running on an old Node version. Claude Desktop resolves 'npx' from
+  // its own PATH (not the user's shell), so an old nvm default (v11/v12) causes
+  // a silent "You must supply a command" failure on first launch.
+  const nodeMajor = parseInt(process.version.slice(1))
+  if (nodeMajor < 16) {
+    console.error(`\n⚠️  Warning: you're running Node ${process.version}.`)
+    console.error('   Claude Desktop may fail to start LMCP because it finds an old npx on its PATH.')
+    console.error(`   Fix: nvm alias default 22 && nvm uninstall ${process.version}  (then relaunch Claude Desktop)\n`)
+  }
+
   // Pre-download binary so first launch is instant
-  // All clients use npx as launcher (self-healing if binary is missing/broken)
-  let stableCommand = NPX_COMMAND
+  // All clients use a shell launcher that wraps npx (self-healing if binary is
+  // missing/broken, and surfaces telemetry + clear errors if Node is too old).
+  let npxAbsPath    = _resolveNpxPath()   // baked into the launcher script
+  let stableCommand = NPX_COMMAND         // fallback; replaced below once CACHE_DIR is known
   let stableArgs    = NPX_ARGS
   let binaryVersion = ''
   try {
@@ -252,11 +343,25 @@ async function runSetup(opts = {}) {
       if (fs.existsSync(settingsSrc)) fs.copyFileSync(settingsSrc, settingsDst)
     } catch {}
     process.stderr.write('✓ Runtime ready\n\n')
+    // Write the launcher script now that we have CACHE_DIR.
+    // 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
   } 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
+    } catch {}
   }
-  // Always use npx as the command — it has a fast-path that execs the binary directly
-  // but can self-heal if the binary is missing or broken
+  // stableCommand is now the shell launcher script path. It wraps npx with a
+  // Node version check + curl telemetry before exec'ing. If launcher creation
+  // failed it falls back to plain 'npx'.
 
   // Detectar clientes
   const detected = CLIENTS.filter(c => c.detect())