local-mcp 3.0.385 → 3.0.409

package/package.json

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

package/setup.js

@@ -81,7 +81,6 @@ function _writeLaunchScript(npxAbsPath, cacheDir, isWin = _IS_WIN) {
     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'
 
 // ── Platform-aware config paths for AI clients ─────────────────────────────
@@ -93,58 +92,6 @@ const _IS_WIN = process.platform === 'win32'
 const _IS_MAC = process.platform === 'darwin'
 const _APPDATA = process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming')
 
-// Windows MSIX (Microsoft Store / WinGet) installs read config from a
-// virtualized path inside %LOCALAPPDATA%\Packages\Claude_*\LocalCache\Roaming\Claude.
-// The non-MSIX (.exe) install reads from %APPDATA%\Claude.
-// We detect which one exists and write to both if needed.
-function _findMsixClaudePath() {
-  if (!_IS_WIN) return null
-  const localAppData = process.env.LOCALAPPDATA || path.join(HOME, 'AppData', 'Local')
-  const packagesDir = path.join(localAppData, 'Packages')
-  try {
-    const entries = fs.readdirSync(packagesDir)
-    const claudePkg = entries.find(e => e.startsWith('Claude_'))
-    if (claudePkg) {
-      return path.join(packagesDir, claudePkg, 'LocalCache', 'Roaming', 'Claude', 'claude_desktop_config.json')
-    }
-  } catch {}
-  return null
-}
-
-function _claudeDesktopPath() {
-  if (_IS_WIN) {
-    // Prefer MSIX path if the package exists
-    const msix = _findMsixClaudePath()
-    if (msix) return msix
-    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')
-}
-
-// All paths where we should write the config (MSIX + non-MSIX on Windows)
-function _claudeDesktopAllPaths() {
-  if (!_IS_WIN) return [_claudeDesktopPath()]
-  const paths = [path.join(_APPDATA, 'Claude', 'claude_desktop_config.json')]
-  const msix = _findMsixClaudePath()
-  if (msix && !paths.includes(msix)) paths.push(msix)
-  return paths
-}
-
-function _claudeDesktopDetect() {
-  if (_IS_WIN) {
-    // Check both MSIX and non-MSIX paths
-    return _claudeDesktopAllPaths().some(p => fs.existsSync(path.dirname(p)))
-  }
-  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')
-}
-
 // 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
@@ -156,75 +103,8 @@ function _localMcpConfigDir(platform = process.platform, home = HOME, appData =
   return path.join(home, '.config', 'local-mcp')
 }
 
-const CLIENTS = [
-  {
-    id:       'claude-desktop',
-    name:     'Claude Desktop',
-    cfgPath:  _claudeDesktopPath(),
-    detect:   _claudeDesktopDetect,
-  },
-  {
-    id:       'cursor',
-    name:     'Cursor',
-    cfgPath:  path.join(HOME, '.cursor', 'mcp.json'),
-    detect:   () => fs.existsSync(path.join(HOME, '.cursor')) || _appExists('Cursor'),
-  },
-  {
-    id:       'windsurf',
-    name:     'Windsurf',
-    cfgPath:  path.join(HOME, '.codeium', 'windsurf', 'mcp_config.json'),
-    detect:   () => fs.existsSync(path.join(HOME, '.codeium', 'windsurf')) || _appExists('Windsurf'),
-  },
-  {
-    id:       'vscode',
-    name:     'VS Code',
-    cfgPath:  path.join(HOME, '.vscode', 'mcp.json'),
-    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:  _rooClinePath(),
-    detect:   () => fs.existsSync(path.dirname(_rooClinePath())),
-  },
-  {
-    id:       'zed',
-    name:     'Zed',
-    cfgPath:  path.join(HOME, '.config', 'zed', 'settings.json'),
-    detect:   () => fs.existsSync(path.join(HOME, '.config', 'zed')) || _appExists('Zed'),
-    zed:      true,  // Zed usa formato diferente dentro de settings.json
-  },
-  {
-    id:       'claude-code',
-    name:     'Claude Code',
-    // Claude Code reads MCP servers from ~/.claude.json (user-scope top-level
-    // mcpServers), not ~/.claude/settings.json. Writing settings.json never
-    // actually configured Claude Code.
-    cfgPath:  path.join(HOME, '.claude.json'),
-    detect:   () => fs.existsSync(path.join(HOME, '.claude')) || fs.existsSync(path.join(HOME, '.claude.json')) || _cmdExists('claude'),
-  },
-]
-
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
-function _appExists(name) {
-  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) {
   const which = _IS_WIN ? 'where' : 'which'
   try { execSync(`${which} ${cmd}`, { stdio: 'pipe' }); return true } catch { return false }
@@ -297,9 +177,8 @@ function _atomicWriteConfig(filePath, data) {
 // 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 fix is to spawn the interpreter and pass the script as an ARGUMENT. 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
@@ -324,100 +203,99 @@ function _writeLaunchSpec(npxAbsPath, cacheDir, isWin = _IS_WIN) {
   return _launcherSpawnSpec(_writeLaunchScript(npxAbsPath, cacheDir, isWin), isWin)
 }
 
-// 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')
-
-  if (client.zed) {
-    cfg.context_servers = cfg.context_servers || {}
-    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 {
-    cfg.mcpServers = cfg.mcpServers || {}
-    delete cfg.mcpServers['office-mcp']
-    const entry = { command }
-    if (args !== undefined) entry.args = args
-    cfg.mcpServers['local-mcp'] = entry
-  }
-  return { existingCount: existingServers.length, otherServers }
-}
+// ── Main ──────────────────────────────────────────────────────────────────────
 
-// ── 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']
-  }
+// ── #3212 · Mac: las apps de IA las configura el binario, con el modelo del producto ──────────
+// El binario decide y escribe con el mismo escritor que el tray (JSONC que no toca, YAML, TOML,
+// el lock compartido) y devuelve un reporte versionado. Acá sólo se lee. En Windows y Linux sigue
+// el camino JS de abajo hasta que go-server tenga el mismo flag: #3212 no se cierra antes.
+const CLIENTS_REPORT_SCHEMA = 1
+
+// platform is a PARAMETER, not a read of _IS_WIN, for the same reason
+// _writeLaunchScript's isWin parameter exists (#1394 §C): a mutation to the
+// win32 branch has to be exercisable on any machine running this suite, not
+// only on a real Windows box.
+// `home` is a parameter for the same reason `platform` is: the third candidate is the stable
+// link under the user's home, so without it the lookup READS THE MACHINE and a test asserting
+// "finds nothing" passes only where LMCP is not installed. Same seam as _localMcpConfigDir.
+// Every home-derived candidate must come from THIS argument; one that reaches for os.homedir()
+// again puts the machine back in the answer.
+function _findServerBinary(embedded, cacheDir, platform = process.platform, home = HOME) {
+  const binName = platform === 'win32' ? 'lmcp-server.exe' : 'lmcp-server'
+  const stableLink = path.join(home, '.local', 'share', 'local-mcp', 'bin', 'local-mcp-server')
+  const cands = [embedded, cacheDir && path.join(cacheDir, binName), stableLink].filter(Boolean)
+  return cands.find(p => { try { return fs.statSync(p).isFile() } catch { return false } }) || null
+}
 
-  const allPaths = explicitPaths ||
-    ((client.id === 'claude-desktop' && _IS_WIN) ? _claudeDesktopAllPaths() : [client.cfgPath])
+// --command=/--arg= point the binary at the npx-launcher indirection darwin
+// uses to reach the local-mcp-server binary. go-server on Windows has no
+// such indirection and REJECTS these flags outright with exit 2 (contract
+// §3.4) — passing them there would fail every Windows install. Extracted so
+// this platform rule is unit-testable without invoking runSetup's full
+// side-effect chain.
+function _launcherArgsForConfigureClients(platform, command, args) {
+  return platform === 'darwin' ? { command, args } : { command: null, args: [] }
+}
 
-  const perPath = []
-  let existingMcpCount = 0
-  const preservedSet = new Set()
+// §3.8 — Linux's fixed result shape: no capability, no report, exit 0 (not
+// having a writer yet is not a failure). Extracted so the contract itself is
+// directly testable instead of only reachable by reading runSetup's source.
+function _notSupportedOnPlatformResult() {
+  return { runtime: 'not_supported_on_platform', exitCode: 0, report: null }
+}
 
-  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 })
-    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 })
+// Corre `--configure-clients --json`. Nunca cuelga el instalador: un binario que no responde
+// termina en failed(timeout); uno viejo, que no conoce el flag, no imprime el reporte y queda en
+// runtime_too_old. exitCode: 0 bien · 1 algún cliente falló · 2 no se pudo configurar.
+function runConfigureClients(bin, command, args, opts = {}) {
+  const spawn = opts.spawnSync || require('child_process').spawnSync
+  const timeoutMs = opts.timeoutMs || 90000
+  if (!bin) return { runtime: 'no_runtime', exitCode: 2, report: null }
+  const argv = ['--configure-clients', '--json']
+  if (command) argv.push('--command=' + command, ...(args || []).map(a => '--arg=' + a))
+  const r = spawn(bin, argv, { input: '', timeout: timeoutMs, encoding: 'utf8' })
+  if (r.error && r.error.code === 'ETIMEDOUT') return { runtime: 'timeout', exitCode: 2, report: null }
+  if (r.error) return { runtime: 'failed', reason: r.error.message, exitCode: 2, report: null }
+  let report = null
+  try { report = JSON.parse(String(r.stdout || '').trim().split('\n').pop()) } catch { /* sin reporte */ }
+  if (!report || typeof report !== 'object' || report.schema === undefined) {
+    return { runtime: 'runtime_too_old', exitCode: 2, report: null }
   }
-
-  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`)
-    }
+  if (report.schema !== CLIENTS_REPORT_SCHEMA) {
+    return { runtime: 'unsupported_report_schema', reason: String(report.schema), exitCode: 2, report: null }
   }
+  const failedAny = (report.clients || []).some(c => c.status === 'failed')
+  return { runtime: 'ok', exitCode: failedAny ? 1 : 0, report }
+}
 
-  return {
-    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,
+// Los permisos pendientes los mide el tray (GET /permissions): medidos desde este proceso
+// describirían a la terminal. Se reintenta un rato porque el tray acaba de arrancar.
+async function _fetchTrayPermissions(totalMs = 10000) {
+  const http = require('http')
+  const once = () => new Promise(resolve => {
+    const req = http.get({ host: '127.0.0.1', port: 8765, path: '/permissions', timeout: 1500 }, res => {
+      let body = ''
+      res.on('data', d => { body += d })
+      res.on('end', () => {
+        try { const o = JSON.parse(body); resolve(o && o.source === 'tray' ? o : null) } catch { resolve(null) }
+      })
+    })
+    req.on('timeout', () => { req.destroy(); resolve(null) })
+    req.on('error', () => resolve(null))
+  })
+  const end = Date.now() + totalMs
+  while (Date.now() < end) {
+    const o = await once()
+    if (o) return o
+    await new Promise(r => setTimeout(r, 1000))
   }
+  return null
 }
 
-// ── Main ──────────────────────────────────────────────────────────────────────
-
 async function runSetup(opts = {}) {
+  // #3212 — `--json`: el reporte estructurado va solo por stdout; todo lo demás, a stderr.
+  const jsonMode = !!opts.json || process.argv.includes('--json')
+  if (jsonMode) console.log = (...a) => { process.stderr.write(a.join(' ') + '\n') }
   // Cross-platform: macOS configures the Swift tray + embedded server; Windows/Linux
   // download the go-server standalone binary (download.js) and write the MCP client
   // config (the config writer already handles Windows paths). The Mac-only waitlist
@@ -551,71 +429,56 @@ async function runSetup(opts = {}) {
   // failed it falls back to plain 'npx'.
 
   // Detectar clientes
-  const detected = CLIENTS.filter(c => c.detect())
-  const notDetected = CLIENTS.filter(c => !c.detect())
   const _npmPkgVersion = (() => { try { return require('./package.json').version } catch { return '' } })()
-  _trackSetupStep('detect', detected.length > 0 ? 'ok' : 'no_clients', '', {
-    clientsFound:    detected.map(c => c.id),
-    clientsNotFound: notDetected.map(c => c.id),
-    npmVersion:      _npmPkgVersion,
-  })
-
-  if (detected.length === 0) {
-    const entry = stableArgs !== undefined
-      ? { command: stableCommand, args: stableArgs }
-      : { command: stableCommand }
-    const snippet = JSON.stringify({ mcpServers: { 'local-mcp': entry } }, null, 2)
-      .split('\n').map(l => '     ' + l).join('\n')
-
-    console.log('╔══════════════════════════════════════════════════════════╗')
-    console.log('║  LMCP installed — no AI client detected yet             ║')
-    console.log('╚══════════════════════════════════════════════════════════╝\n')
-    console.log('  To get started, add LMCP to your AI client config:\n')
-    console.log('  ── Claude Desktop ────────────────────────────────────────')
-    console.log(`  File: ${_claudeDesktopPath()}\n`)
-    console.log(snippet)
-    console.log('\n  ── Cursor ────────────────────────────────────────────────')
-    console.log('  File: ~/.cursor/mcp.json\n')
-    console.log(snippet)
-    console.log('\n  ── VS Code (Cline / GitHub Copilot) ──────────────────────')
-    console.log('  File: ~/.vscode/mcp.json\n')
-    console.log(snippet)
-    console.log('\n  Then restart your AI client and try:')
-    console.log('    "Summarize my unread emails"\n')
-    console.log('  ── Already installed an AI client? ───────────────────────')
-    console.log('  Run this to auto-configure it:')
-    console.log('    npx local-mcp setup\n')
-    console.log('  Full setup guide: https://local-mcp.com/setup')
-    console.log('─────────────────────────────────────────────────────────────\n')
-    return
-  }
-
-  console.log(`Detected: ${detected.map(c => c.name).join(', ')}\n`)
-
   const configured = []
   const failed     = []
-
-  for (const client of detected) {
-    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`)
-    } 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}`)
+  let clientsRun = null   // #3212: en la Mac, el reporte del binario
+  // #3212 — Windows now shares the exact darwin path: the go-server binary
+  // decides and writes (lmcp-server --configure-clients --json), never a
+  // second JS-side client list. Linux has no runtime-native writer yet
+  // (§3.8): a generic message, no per-client guesswork, no files written.
+  if (process.platform === 'darwin' || _IS_WIN) {
+    const { CACHE_DIR } = require('./download')
+    const launcher = _launcherArgsForConfigureClients(process.platform, stableCommand, stableArgs)
+    clientsRun = runConfigureClients(_findServerBinary(_embeddedServer, CACHE_DIR), launcher.command, launcher.args)
+    const clientes = (clientsRun.report && clientsRun.report.clients) || []
+    _trackSetupStep('detect', clientsRun.runtime === 'ok' ? 'ok' : clientsRun.runtime, '', {
+      clientsFound:    clientes.filter(c => c.status !== 'not_installed').map(c => c.id),
+      clientsNotFound: clientes.filter(c => c.status === 'not_installed').map(c => c.id),
+      npmVersion:      _npmPkgVersion,
+    })
+    for (const c of clientes) {
+      if (c.status === 'configured') {
+        configured.push(c.name)
+        _trackConfigWritten(c.id, c.name)
+        console.log(`✓ ${c.name} configured`)
+      } else if (c.status === 'already') {
+        console.log(`✓ ${c.name} already configured`)
+      } else if (c.status === 'failed') {
+        failed.push({ name: c.name, reason: 'failed', error: c.reason })
+        console.error(`✗ ${c.name}: ${c.reason || 'failed'}`)
+      } else if (c.status !== 'not_installed') {
+        console.log(`· ${c.name}: ${c.status.replace(/_/g, ' ')}${c.reason ? ' — ' + c.reason : ''}`)
       }
     }
+    if (clientsRun.runtime !== 'ok') {
+      console.error(`⚠  AI apps not configured yet (${clientsRun.runtime}) — open LMCP from the system tray and use Connect.`)
+    } else if (clientes.length > 0 && clientes.every(c => c.status === 'not_installed')) {
+      console.log('\n  No AI client detected yet — LMCP is installed and ready.')
+      console.log('  Install one (Claude Desktop, Cursor, VS Code...), then run:')
+      console.log('    npx local-mcp setup\n')
+      console.log('  Full setup guide: https://local-mcp.com/setup')
+    }
+  } else {
+    // Linux (§3.8): no runtime-native config writer exists yet. Say so plainly,
+    // point at the manual guide, and touch nothing — no per-client guessing,
+    // no files written, no client identity hardcoded here.
+    clientsRun = _notSupportedOnPlatformResult()
+    _trackSetupStep('detect', 'not_supported_on_platform', '', { npmVersion: _npmPkgVersion })
+    console.log('\n  LMCP is installed and running.')
+    console.log('  Automatic AI-client configuration is not available on Linux yet.')
+    console.log('  Add LMCP to your AI client\'s MCP config manually — see:')
+    console.log('    https://local-mcp.com/setup\n')
   }
 
   const cfgDir  = _localMcpConfigDir()
@@ -713,7 +576,9 @@ async function runSetup(opts = {}) {
   // JSON files we write above — so we don't auto-configure it (a JSON write would be
   // useless and a blind YAML merge could corrupt the user's config). If Hermes is
   // present, print the exact CLI one-liner instead.
-  if (fs.existsSync(path.join(HOME, '.hermes')) || _cmdExists('hermes')) {
+  const _hermes = clientsRun && clientsRun.report && (clientsRun.report.clients || []).find(c => c.id === 'hermes')
+  const _hermesListo = !!_hermes && ['configured', 'already'].includes(_hermes.status)
+  if (!_hermesListo && (fs.existsSync(path.join(HOME, '.hermes')) || _cmdExists('hermes'))) {
     console.log('┌─────────────────────────────────────────────────────┐')
     console.log('│  HERMES AGENT detected — add LMCP with its CLI:     │')
     console.log('│                                                     │')
@@ -733,11 +598,17 @@ async function runSetup(opts = {}) {
 
   // Instalar y lanzar el tray (menu bar app) — arm64 only, non-fatal
   await _installTray()
+  // Tray permissions are a macOS-only concept (contract §3.1: Windows/Linux
+  // report "not_applicable", not "unknown_until_tray_runs") — polling
+  // 127.0.0.1:8765/permissions off darwin would just cost up to 10s waiting
+  // on an endpoint that was never going to answer.
+  const trayPermissions = _IS_MAC ? (clientsRun ? await _fetchTrayPermissions() : null) : 'not_applicable'
   await _installTeamsProxy()
   await _installSlackProxy()
 
-  // Auto-launch primary configured AI client + show "Try this now" banner
-  _autoLaunchClient(configured)
+  // Auto-launch the primary configured AI client (macOS only — win32/linux
+  // just name the next_step) + show "Try this now" banner.
+  await _autoLaunchClient(clientsRun)
 
   // Anon-first cloud relay activation (replaces the interactive email prompt
   // removed 2026-04-19). When no email is set, register an anonymous tunnel
@@ -804,6 +675,23 @@ async function runSetup(opts = {}) {
   // LMCP_METHOD lets install.sh pass 'curl' so we can distinguish it from
   // a direct 'npx local-mcp setup' invocation in the analytics.
   _pingInstall(configured, process.env.LMCP_METHOD || opts.method || 'npx-setup', email, binaryVersion)
+
+  // #3212 — el reporte para quien instaló sin mirar (un agente): qué quedó hecho y qué espera
+  // a la persona. Los permisos, sólo si los midió el tray. clientsRun is always set by this
+  // point — darwin/win32 from runConfigureClients, linux from its own not_supported sentinel.
+  if (jsonMode) {
+    const rep = clientsRun.report || {}
+    const out = {
+      schema: CLIENTS_REPORT_SCHEMA,
+      installer_version: _npmPkgVersion,
+      runtime: clientsRun.runtime,
+      catalog: rep.catalog || null,
+      clients: rep.clients || [],
+      permissions: trayPermissions || 'unknown_until_tray_runs',
+    }
+    process.stdout.write(JSON.stringify(out) + '\n')
+  }
+  process.exitCode = clientsRun.exitCode
 }
 
 async function _installTeamsProxy() {
@@ -1212,46 +1100,79 @@ function _pingInstall(clients, method, email = '', binaryVersion = '') {
   } catch { /* no bloquear */ }
 }
 
+// _fetchClientsCatalog fetches the served catalog (the SAME endpoint the
+// go-server's RefreshFromRemote uses) so _autoLaunchClient can find a
+// client's macOS .app path without ever typing a client's identity a
+// second time in this file. 4s budget (#3212 §3.9): a slow/unreachable
+// backend must never block the rest of setup. Returns null on any failure —
+// callers treat that as "don't launch anything," never as an error.
+function _fetchClientsCatalog(totalMs = 4000) {
+  return new Promise((resolve) => {
+    const https = require('https')
+    const req = https.request({
+      hostname: BACKEND_HOST, path: '/clients/catalog', method: 'GET', timeout: totalMs,
+    }, (res) => {
+      let body = ''
+      res.on('data', (d) => { body += d })
+      res.on('end', () => { try { resolve(JSON.parse(body)) } catch { resolve(null) } })
+    })
+    req.on('error', () => resolve(null))
+    req.on('timeout', () => { try { req.destroy() } catch {} resolve(null) })
+    req.end()
+  })
+}
+
 /**
- * Auto-launch the primary configured AI client and print a "Try this now" banner.
- * Non-fatal — install succeeds even if open() fails.
+ * Auto-launch the primary configured AI client and print a "Try this now" banner —
+ * derived entirely from ConfigureAll's report and the served catalog (#3212 item 23):
+ * no client name is ever typed here. macOS actually opens the app (via the
+ * catalog's own .app detectPath); win32/linux only name the next_step, since
+ * neither platform has an "open this app" primitive LMCP can safely use.
+ * Non-fatal at every step — install succeeds even if the catalog fetch or
+ * open() fails or times out.
  */
-function _autoLaunchClient(configured) {
-  if (!configured || configured.length === 0) return
-  const appMap = {
-    'Claude Desktop': 'Claude',
-    'Cursor': 'Cursor',
-    'Windsurf': 'Windsurf',
-    'Zed': 'Zed',
-    'VS Code (Cline)': 'Visual Studio Code',
-  }
-  // Claude Code is a CLI tool — no app bundle to open
-  const launchOrder = ['Claude Desktop', 'Cursor', 'Windsurf', 'Zed', 'VS Code (Cline)']
-  let appName = null
-  let clientName = null
-  for (const name of launchOrder) {
-    if (configured.includes(name) && appMap[name]) {
-      appName = appMap[name]
-      clientName = name
-      break
-    }
+async function _autoLaunchClient(clientsRun, opts = {}) {
+  const platform = opts.platform || process.platform
+  const exec = opts.execFileSync || execFileSync
+  const fetchCatalog = opts.fetchCatalog || _fetchClientsCatalog
+
+  const clientes = (clientsRun && clientsRun.report && clientsRun.report.clients) || []
+  // "restart"/"restart_agent_mode" are the only next_steps that name reopening
+  // an app; "new_session" (e.g. Claude Code, a CLI) and "open_mcp_page" have no
+  // app to relaunch, and the catalog lookup below naturally no-ops for them too
+  // (a CLI-only entry has no macOS .app detectPath to find).
+  const entry = clientes.find(c => c.status === 'configured' && c.next_step && c.next_step.startsWith('restart'))
+  if (!entry) return
+
+  if (platform !== 'darwin') {
+    const verb = entry.next_step === 'restart_agent_mode'
+      ? `Toggle agent mode off and back on in ${entry.name}`
+      : `Restart ${entry.name}`
+    console.log(`\n✅ LMCP is ready! ${verb} to activate it.\n`)
+    return
   }
-  if (!appName) return
+
+  const catalog = await fetchCatalog()
+  const found = catalog && (catalog.clients || []).find(c => c.id === entry.id)
+  const macos = found && found.platforms && found.platforms.macos
+  const appPath = ((macos && macos.detectPaths) || []).find(p => p.endsWith('.app'))
+  if (!appPath) return
 
   try {
-    execFileSync('open', ['-a', appName], { stdio: 'pipe', timeout: 5000 })
-    console.log(`\n✅ LMCP is ready! ${clientName} is opening now.\n`)
-    console.log('Try asking Claude: "Read my last 3 emails and summarize them"\n')
+    exec('open', [appPath.replace(/^~/, HOME)], { stdio: 'pipe', timeout: 5000 })
+    console.log(`\n✅ LMCP is ready! ${entry.name} is opening now.\n`)
+    console.log('Try asking: "Read my last 3 emails and summarize them"\n')
   } catch {
     // open failed (app not installed or already open) — non-fatal
-    return
   }
-
 }
 
 module.exports = {
-  runSetup, injectMcpConfig, CLIENTS,
+  runSetup, runConfigureClients, _findServerBinary, _launcherArgsForConfigureClients,
+  CLIENTS_REPORT_SCHEMA,
+  _notSupportedOnPlatformResult,
   _launcherSpawnSpec, _writeLaunchScript, _writeLaunchSpec,
   _getMachineId, _healthCheckSpec, _localMcpConfigDir,
   _cloudTokenPath, _readCachedCloudToken, _writeCloudToken, _registerAnonToken,
+  _autoLaunchClient, _fetchClientsCatalog,
 }