local-mcp 3.0.136 → 3.0.137

package/package.json

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

@@ -41,10 +41,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 +79,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 ──────────────────────────────────────────────────────────────────────
@@ -185,6 +260,11 @@ async function runSetup(opts = {}) {
 
   // 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 +302,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 +331,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 +385,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 +401,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 +440,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 +642,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 +736,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')