local-mcp 3.0.136 → 3.0.138

package/index.js

@@ -24,6 +24,20 @@ if (process.platform !== 'darwin') {
   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\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)
+}
+
 const cmd = process.argv[2]
 
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-mcp",
-  "version": "3.0.136",
+  "version": "3.0.138",
   "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": {

package/setup.js

@@ -16,6 +16,49 @@ 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 — then restart Claude Desktop.\\n\' "$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'
 
@@ -41,10 +84,17 @@ const CLIENTS = [
     detect:   () => fs.existsSync(path.join(HOME, '.codeium', 'windsurf')) || _appExists('Windsurf'),
   },
   {
-    id:       'vscode-cline',
-    name:     'VS Code (Cline)',
+    id:       'vscode',
+    name:     'VS Code',
     cfgPath:  path.join(HOME, '.vscode', 'mcp.json'),
-    detect:   () => _cmdExists('code') || fs.existsSync(path.join(HOME, '.vscode')),
+    detect:   () => _cmdExists('code') || _appExists('Visual Studio Code') || fs.existsSync(path.join(HOME, '.vscode')),
+    vscode:   true,  // native MCP uses "servers" key + type:"stdio"
+  },
+  {
+    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')),
   },
   {
     id:       'zed',
@@ -72,42 +122,110 @@ function _cmdExists(cmd) {
   try { execSync(`which ${cmd}`, { stdio: 'pipe' }); return true } catch { return false }
 }
 
-function _readJson(filePath) {
+// ── Safe config read ─────────────────────────────────────────────────────────
+// Returns { data, wasEmpty, hadParseError, error }.
+// If the file exists but JSON.parse fails we BACK IT UP and return hadParseError=true
+// so callers can skip the write instead of silently wiping the user's other MCPs.
+
+function _safeReadConfig(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return { data: {}, wasEmpty: true, hadParseError: false, error: '' }
+  }
+  let raw
+  try { raw = fs.readFileSync(filePath, 'utf8').trim() } catch (e) {
+    return { data: {}, wasEmpty: true, hadParseError: false, error: e.message }
+  }
+  if (!raw || raw === '{}') {
+    return { data: {}, wasEmpty: true, hadParseError: false, error: '' }
+  }
   try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'))
-  } catch {
-    return {}
+    return { data: JSON.parse(raw), wasEmpty: false, hadParseError: false, error: '' }
+  } catch (e) {
+    // Existing config is not valid JSON — back it up, never overwrite
+    try { fs.copyFileSync(filePath, filePath + '.lmcp-backup') } catch {}
+    return { data: null, wasEmpty: false, hadParseError: true, error: e.message }
   }
 }
 
-function _writeJson(filePath, data) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true })
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8')
+// ── Atomic write ──────────────────────────────────────────────────────────────
+// Writes to a .tmp file then renames (atomic on POSIX). Verifies the written
+// file is valid JSON and contains the local-mcp entry before returning ok=true.
+
+function _atomicWriteConfig(filePath, data) {
+  const json = JSON.stringify(data, null, 2) + '\n'
+  try { JSON.parse(json) } catch (e) {
+    return { ok: false, error: 'merge produced invalid JSON: ' + e.message }
+  }
+  const tmpPath = filePath + '.lmcp-tmp'
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true })
+    fs.writeFileSync(tmpPath, json, 'utf8')
+    fs.renameSync(tmpPath, filePath)
+  } catch (e) {
+    try { fs.unlinkSync(tmpPath) } catch {}
+    return { ok: false, error: e.message }
+  }
+  // Post-write verify
+  try {
+    const v = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+    const hasEntry = !!(
+      (v.mcpServers   && v.mcpServers['local-mcp']) ||
+      (v.servers      && v.servers['local-mcp'])    ||
+      (v.context_servers && v.context_servers['local-mcp'])
+    )
+    if (!hasEntry) return { ok: false, error: 'verify failed: local-mcp not found after write' }
+  } catch (e) {
+    return { ok: false, error: 'verify read failed: ' + e.message }
+  }
+  return { ok: true, error: '' }
 }
 
-// ── Inyectar config MCP en un cliente estándar ────────────────────────────────
+// ── 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) {
-  const cfg = _readJson(client.cfgPath)
+  // 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: [] }
+  }
+
+  const cfg = read.data || {}
 
+  // Count other MCP servers before merge (for telemetry)
+  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) {
-    // Zed usa { "context_servers": { "local-mcp": { "command": {...} } } }
     cfg.context_servers = cfg.context_servers || {}
-    cfg.context_servers['local-mcp'] = {
-      command: { path: command, args: args ?? [] },
-    }
+    cfg.context_servers['local-mcp'] = { command: { path: command, args: args ?? [] } }
+  } else if (client.vscode) {
+    // VS Code native MCP (1.99+) uses "servers" key with type:"stdio"
+    cfg.servers = cfg.servers || {}
+    cfg.servers['local-mcp'] = { type: 'stdio', command, args: args ?? [] }
   } else {
-    // Formato estándar MCP: { "mcpServers": { "local-mcp": { "command": "...", "args": [...] } } }
     cfg.mcpServers = cfg.mcpServers || {}
-    // Limpiar entradas legacy
     delete cfg.mcpServers['office-mcp']
     const entry = { command }
     if (args !== undefined) entry.args = args
     cfg.mcpServers['local-mcp'] = entry
   }
 
-  _writeJson(client.cfgPath, cfg)
-  return true
+  // 3. Atomic write + verify
+  const write = _atomicWriteConfig(client.cfgPath, cfg)
+  return {
+    ok:              write.ok,
+    stage:           write.ok ? 'config_write' : 'config_write_failed',
+    error:           write.error,
+    hadParseError:   false,
+    existingMcpCount: existingServers.length,
+    preservedServers: otherServers,
+  }
 }
 
 // ── Main ──────────────────────────────────────────────────────────────────────
@@ -137,9 +255,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  (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 {
@@ -177,14 +307,33 @@ 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())
+  const notDetected = CLIENTS.filter(c => !c.detect())
+  _trackSetupStep('detect', detected.length > 0 ? 'ok' : 'no_clients', '', {
+    clientsFound:    detected.map(c => c.id),
+    clientsNotFound: notDetected.map(c => c.id),
+  })
 
   if (detected.length === 0) {
     const entry = stableArgs !== undefined
@@ -222,14 +371,25 @@ async function runSetup(opts = {}) {
   const failed     = []
 
   for (const client of detected) {
-    try {
-      injectMcpConfig(client, stableCommand, stableArgs)
+    const result = injectMcpConfig(client, stableCommand, stableArgs)
+    if (result.ok) {
+      _trackSetupStep('config_write', 'ok', client.id, {
+        existingMcpCount: result.existingMcpCount,
+        preservedServers: result.preservedServers,
+      })
       _trackConfigWritten(client.id || client.name, client.name)
       configured.push(client.name)
       console.log(`✓ ${client.name} configured`)
-    } catch (err) {
-      failed.push(client.name)
-      console.error(`✗ ${client.name}: ${err.message}`)
+    } else {
+      const status = result.hadParseError ? 'parse_error' : 'write_error'
+      _trackSetupStep('config_write', status, client.id, { error: result.error })
+      failed.push({ name: client.name, reason: status, error: result.error })
+      if (result.hadParseError) {
+        console.error(`✗ ${client.name}: existing config has invalid JSON — backed up to ${client.cfgPath}.lmcp-backup`)
+        console.error(`  Edit or remove the backup to fix: ${result.error}`)
+      } else {
+        console.error(`✗ ${client.name}: ${result.error}`)
+      }
     }
   }
 
@@ -240,10 +400,11 @@ async function runSetup(opts = {}) {
   let email = process.env.LMCP_EMAIL || ''
   if (email) {
     try {
-      const cfg = _readJson(cfgFile)
+      const r = _safeReadConfig(cfgFile)
+      const cfg = r.data || {}
       if (!cfg.license_email) {
         cfg.license_email = email
-        _writeJson(cfgFile, cfg)
+        _atomicWriteConfig(cfgFile, cfg)
         console.log(`✓ Email saved: ${email}`)
       }
     } catch { /* config not created yet — will be created on first run */ }
@@ -293,8 +454,9 @@ async function runSetup(opts = {}) {
         email = ans
         emailPromptResult = 'submitted'
         try {
-          const cfg = _readJson(cfgFile)
-          if (!cfg.license_email) { cfg.license_email = email; _writeJson(cfgFile, cfg) }
+          const r = _safeReadConfig(cfgFile)
+          const cfg = r.data || {}
+          if (!cfg.license_email) { cfg.license_email = email; _atomicWriteConfig(cfgFile, cfg) }
         } catch {}
         console.log('  ✓ Email saved')
       } else {
@@ -308,6 +470,13 @@ async function runSetup(opts = {}) {
 
   // Health check — verify binary works before showing success
   const healthOk = _runHealthCheck()
+  _trackSetupStep('binary_health', healthOk ? 'ok' : 'failed', '', {})
+
+  // setup_complete summary
+  _trackSetupStep('setup_complete', configured.length > 0 ? 'ok' : 'failed', '', {
+    clientsFound:    configured,
+    clientsNotFound: failed.map(f => f.name || f),
+  })
 
   const hasCursor = configured.includes('Cursor')
 
@@ -340,17 +509,19 @@ async function runSetup(opts = {}) {
     } else {
       const primaryClient = configured[0]
       console.log('┌─────────────────────────────────────────────────────┐')
-      console.log('│  NEXT STEP — This is important:                     │')
+      console.log('│  NEXT STEP — restart to activate:                   │')
       console.log('│                                                     │')
-      console.log(`│  Quit and reopen ${primaryClient.padEnd(35)}│`)
-      console.log('│  LMCP will appear automatically.               │')
+      console.log(`│  1. Quit ${primaryClient} completely (Cmd+Q)${''.padEnd(Math.max(0, 30 - primaryClient.length))}│`)
+      console.log(`│  2. Reopen ${primaryClient.padEnd(41)}│`)
       console.log('│                                                     │')
       console.log('│  Then try: "Summarize my unread emails"             │')
       console.log('└─────────────────────────────────────────────────────┘\n')
+      _trackRestartPrompted(primaryClient)
     }
   }
   if (failed.length > 0) {
-    console.log(`⚠  Could not configure: ${failed.join(', ')} — check permissions and try again.\n`)
+    const failNames = failed.map(f => (typeof f === 'string' ? f : f.name)).join(', ')
+    console.log(`⚠  Could not configure: ${failNames} — check permissions and try again.\n`)
   }
   console.log('  Setup guide & troubleshooting: https://local-mcp.com/setup\n')
 
@@ -540,6 +711,46 @@ function _migrateCurlLaunchAgent() {
   } catch { /* non-fatal — don't block install on unexpected plist content */ }
 }
 
+// ── Setup funnel telemetry ────────────────────────────────────────────────────
+// Fire-and-forget. Sends one event per step to /setup-step so we can see exactly
+// where each machine's install funnel breaks without waiting for a heartbeat.
+
+function _trackSetupStep(step, status, client, detail) {
+  try {
+    const https = require('https')
+    const payload = {
+      machine_id:  _getMachineId(),
+      install_id:  process.env.INSTALL_ID || '',
+      method:      process.env.LMCP_METHOD || 'npm',
+      step,
+      status,
+      client:      client || '',
+      error:       (detail && detail.error) ? String(detail.error).slice(0, 300) : '',
+    }
+    if (detail) {
+      if (detail.existingMcpCount >= 0)  payload.existing_mcp_count = detail.existingMcpCount
+      if (detail.preservedServers && detail.preservedServers.length)
+        payload.preserved_servers = detail.preservedServers.join(',')
+      if (detail.clientsFound)    payload.clients_found     = detail.clientsFound.join(',')
+      if (detail.clientsNotFound) payload.clients_not_found = detail.clientsNotFound.join(',')
+      if (detail.toolCount >= 0)  payload.tool_count        = detail.toolCount
+      if (detail.binaryVersion)   payload.binary_version    = detail.binaryVersion
+    }
+    const data = JSON.stringify(payload)
+    const req = https.request({
+      hostname: BACKEND_HOST,
+      path: '/setup-step',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) },
+      timeout: 5000,
+    })
+    req.on('response', (res) => res.resume())
+    req.on('error', () => {})
+    req.write(data)
+    req.end()
+  } catch { /* non-fatal */ }
+}
+
 function _trackConfigWritten(clientId, clientName) {
   try {
     const https = require('https')
@@ -594,6 +805,31 @@ function _trackEmailPrompt(result, email, errorMsg) {
   } catch { /* non-fatal */ }
 }
 
+function _trackRestartPrompted(clientName) {
+  try {
+    const https = require('https')
+    const machineId = _getMachineId()
+    const payload = {
+      stage: 'restart_prompted',
+      client_name: clientName,
+      machine_id: machineId,
+      install_id: process.env.INSTALL_ID || '',
+    }
+    const data = JSON.stringify(payload)
+    const req = https.request({
+      hostname: BACKEND_HOST,
+      path: '/install-event',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': data.length },
+      timeout: 5000,
+    })
+    req.on('response', (res) => res.resume())
+    req.on('error', () => {})
+    req.write(data)
+    req.end()
+  } catch { /* non-fatal */ }
+}
+
 function _pingInstall(clients, method, email = '', binaryVersion = '') {
   try {
     const https = require('https')