local-mcp 3.0.414 → 3.0.417

package/README.md

@@ -1,12 +1,12 @@
 # Local MCP
 
-> **Use your Mac from ChatGPT & Claude.ai on the web** — plus 191+ 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, Word/Excel/PowerPoint and more. Runs on your computer, no API keys, free — local tools read your data on your machine, and your AI provider receives the content needed for each request.
+> **Use your Mac from ChatGPT & Claude.ai on the web** — plus 192+ 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, Word/Excel/PowerPoint and more. Runs on your computer, no API keys, free — local tools read your data on your machine, and your AI provider receives the content needed for each request.
 
 [![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)
 [![Signed](https://img.shields.io/badge/Developer%20ID-notarized-111111?style=flat-square)](https://local-mcp.com?ref=npm)
 [![Privacy](https://img.shields.io/badge/tools-run%20locally-2e7d32?style=flat-square)](https://local-mcp.com/en/privacy)
-[![Glama](https://glama.ai/mcp/servers/lanchuske/local-mcp-releases/badge)](https://glama.ai/mcp/servers/lanchuske/local-mcp-releases?ref=npm)
+[![Glama](https://glama.ai/mcp/servers/colibird-ai/local-mcp-releases/badge)](https://glama.ai/mcp/servers/colibird-ai/local-mcp-releases?ref=npm)
 
 **Runs on your computer. No tokens. No API keys. Free.**
 
@@ -203,4 +203,4 @@ Stops all background processes, removes the LaunchAgent, deletes the app and bin
 
 ## Links
 
-[Website](https://local-mcp.com?ref=npm) · [GitHub](https://github.com/lanchuske/local-mcp-releases) · [Guides](https://local-mcp.com/guides) · Support: ctpo@colibird.co
+[Website](https://local-mcp.com?ref=npm) · [GitHub](https://github.com/colibird-ai/local-mcp-releases) · [Guides](https://local-mcp.com/guides) · Support: ctpo@colibird.co

package/download.js

@@ -31,6 +31,7 @@ function extractTar(tarPath, destDir) {
 }
 
 const BACKEND_URL = 'https://office-mcp-production.up.railway.app'
+const LINUX_NO_SOPORTADO = 'Local MCP does not support Linux. It runs on macOS and Windows — https://local-mcp.com'
 
 // Platform-aware cache directory:
 //   macOS:   ~/.local/share/local-mcp/bin
@@ -178,7 +179,7 @@ function _getMachineId(deps = {}) {
   } else if (platform === 'win32') {
     const hw = _probeWinHardwareId(execSync)
     if (hw) {
-      _writeWinMachineIdCache(cacheDir, hw)
+      if (!deps.soloLectura) _writeWinMachineIdCache(cacheDir, hw)
       return hw
     }
     // Both probes failed or are blocked — fall back to whatever the go-server
@@ -193,13 +194,17 @@ function _getMachineId(deps = {}) {
       if (mid) return mid
     } catch {}
   }
+  // El evento de lanzamiento (launch-event.js) pide soloLectura: no escribe el cache de arriba —
+  // en una máquina desinstalada recrearía el directorio que el usuario borró — y prefiere no
+  // tener id antes que uno derivado del hostname.
+  if (deps.soloLectura) return ''
   // Fallback: hash hostname instead of sending raw PII
   const crypto = require('crypto')
   return crypto.createHash('sha256').update(os.hostname()).digest('hex').slice(0, 16)
 }
 
-function getArch() {
-  const plat = process.platform === 'win32' ? 'windows' : process.platform === 'linux' ? 'linux' : 'darwin'
+function getArch(platform = process.platform) {
+  const plat = platform === 'win32' ? 'windows' : platform === 'linux' ? 'linux' : 'darwin'
   const arch = process.arch
   if (arch === 'arm64') return `${plat}-arm64`
   if (arch === 'x64')   return `${plat}-amd64`
@@ -330,15 +335,26 @@ async function downloadFile(url, destPath) {
  * Asegura que el binario esté descargado y listo.
  * @returns {Promise<{binPath: string}>}
  */
-async function ensureBinary() {
-  const arch   = getArch()
-  const info   = await getLatestBinary()
+async function ensureBinary(deps = {}) {
+  // Linux no está soportado (decisión de Dario, 2026-10-02; colibird-ai/lmcp-npm#9). Se dice
+  // ANTES de pedir nada: ni /runtime/latest ni un tarball. Anuncie lo que anuncie el API — llegó a
+  // anunciar URLs `linux_*` que daban 404, y la guarda vieja (sólo «si no hay URL») no saltaba.
+  if ((deps.platform || process.platform) === 'linux') throw new Error(LINUX_NO_SOPORTADO)
+  // Seam for tests (same idiom as ensureTray's `deps`, #2654): lets a test pin the
+  // platform and stub the network without touching process.platform or real HOME.
+  const {
+    platform  = process.platform,
+    getLatest = getLatestBinary,
+    download  = downloadFile,
+  } = deps
+  const arch   = getArch(platform)
+  const info   = await getLatest()
   const version = info.version
 
   // 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'
+  if (platform !== 'darwin') {
+    const binName = platform === 'win32' ? 'lmcp-server.exe' : 'lmcp-server'
     const binPath = path.join(CACHE_DIR, binName)
     const versionFile = path.join(CACHE_DIR, '.go-server-version')
 
@@ -390,7 +406,7 @@ async function ensureBinary() {
     const tarPath = path.join(CACHE_DIR, `go-server-${platformVersion}.tar.gz`)
 
     try {
-      await downloadFile(url, tarPath)
+      await download(url, tarPath)
       process.stderr.write(`  Extracting...\n`)
       extractTar(tarPath, CACHE_DIR)
       fs.unlinkSync(tarPath)
@@ -415,7 +431,7 @@ async function ensureBinary() {
     if (!fs.existsSync(binPath)) {
       throw new Error(`Binary not found after extraction: ${binPath}`)
     }
-    if (process.platform !== 'win32') fs.chmodSync(binPath, 0o755)
+    if (platform !== 'win32') fs.chmodSync(binPath, 0o755)
     fs.writeFileSync(versionFile, platformVersion)
 
     process.stderr.write(`  Ready at ${CACHE_DIR}\n`)
@@ -853,7 +869,7 @@ async function ensureSlackProxy(platform = process.platform) {
 module.exports = {
   ensureBinary, ensureRuntime, ensureTray, ensureTeamsProxy, ensureSlackProxy, versionFromArtifactUrl,
   latestVersionForPlatform, getArch,
-  CACHE_DIR, TRAY_DIR, _getMachineId,
+  CACHE_DIR, TRAY_DIR, _getMachineId, LINUX_NO_SOPORTADO,
   _probeWinHardwareId, _resetWinHardwareIdCacheForTests,
   _readWinMachineIdCache, _writeWinMachineIdCache, WIN_MACHINE_ID_CACHE_NAME,
   _retireSupersededTrays, _isUsableTrayBundle, SYSTEM_TRAY_APP,

package/index.js

@@ -17,6 +17,7 @@ const path  = require('path')
 const os    = require('os')
 const fs    = require('fs')
 const https = require('https')
+const evento = require('./launch-event')
 
 // ── Version + liveness helpers (module scope so they are testable) ────────────
 
@@ -232,12 +233,30 @@ function clearUninstallSentinels() {
   for (const p of uninstallSentinelPaths()) { try { fs.unlinkSync(p) } catch {} }
 }
 
-// Platform support: macOS (Swift tray + embedded server), Windows & Linux
-// (go-server standalone binary downloaded from R2). Re-enabled for the
-// Windows/Linux public re-launch — the waitlist gate is retired.
+const cmd = process.argv[2]
+
+// Comandos que este wrapper entiende. Sin argumentos arranca el server MCP por stdio, que es
+// como lo lanzan los clientes de IA — ese camino NO cambia.
+const COMANDOS = ['setup', 'update', 'uninstall', 'status']
+const PEDIDOS_DE_AYUDA = ['--help', '-h', 'help']
+
+// Evento de lanzamiento (launch-event.js, #11): cada lanzamiento del camino del server reporta
+// UNA vez cómo terminó. Un lanzamiento es: sin argumento, `stdio`, o un argumento desconocido.
+// Los comandos y la ayuda no lo son y no reportan. El `exit` de abajo es la red: una salida de
+// ese camino que nadie nombró —una excepción incluida— sale como `other`, nunca en silencio.
+const ES_LANZAMIENTO = require.main === module && !COMANDOS.includes(cmd) && !PEDIDOS_DE_AYUDA.includes(cmd)
+function reportarLanzamiento(outcome, opciones) {
+  if (ES_LANZAMIENTO) evento.reportar(outcome, evento.claseDeArgumento(cmd), opciones)
+}
+if (ES_LANZAMIENTO) process.on('exit', () => reportarLanzamiento('other'))
+
+// Platform support: macOS (Swift tray + embedded server) and Windows (go-server standalone
+// binary downloaded from R2). Linux passes this guard so that `--help`, `status`, `update` and
+// `uninstall` answer, but it is NOT supported: the server path and `setup` say so (#9).
 const SUPPORTED_PLATFORMS = ['darwin', 'win32', 'linux']
 if (!SUPPORTED_PLATFORMS.includes(process.platform)) {
-  console.error(`LMCP supports macOS, Windows and Linux. Your platform (${process.platform}) is not supported yet — see https://local-mcp.com`)
+  console.error(`LMCP supports macOS and Windows. Your platform (${process.platform}) is not supported yet — see https://local-mcp.com`)
+  reportarLanzamiento('unsupported-platform')
   process.exit(1)
 }
 
@@ -250,13 +269,12 @@ if (parseInt(process.version.slice(1)) < 16) {
     `If you use nvm, run: nvm alias default 22 && nvm uninstall ${process.version}\n` +
     'Then restart Claude Desktop / Cursor.'
   process.stderr.write(msg + '\n')
+  reportarLanzamiento('unsupported-node')
   // 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]
-
 // Detect a MANUAL uninstall — the user dragged LocalMCPTray.app to the Trash (by far the
 // most common way to remove a Mac app) instead of running `npx local-mcp uninstall` or the
 // tray's Uninstall button, so no `.uninstalled` sentinel was written. Signature: the tray
@@ -279,15 +297,18 @@ function detectManualUninstall() {
   )
 }
 
-// Comandos que este wrapper entiende. Sin argumentos arranca el server MCP por stdio, que es
-// como lo lanzan los clientes de IA — ese camino NO cambia.
-const COMANDOS = ['setup', 'update', 'uninstall', 'status']
+// `stdio` no es un comando: es el modo por defecto dicho en voz alta. Las guías públicas
+// mandaron a escribir `"args": ["-y", "local-mcp@latest", "stdio"]` en la config manual de un
+// cliente de IA, y esas configs siguen en máquinas de usuarios. Tratarlo como desconocido
+// (3.0.413 a 3.0.416) las rompió: ayuda por stdout y exit 2 donde el cliente espera JSON-RPC.
+const SINONIMOS_DEL_SERVER = ['stdio']
 
 function mostrarAyuda() {
   console.log(`local-mcp — Local MCP Server
 
 Uso:
   local-mcp              arranca el server MCP por stdio (lo que hace un cliente de IA)
+  local-mcp stdio        lo mismo, dicho explícitamente
   local-mcp setup        instala y configura
   local-mcp status       muestra el estado
   local-mcp update       limpia el cache del runtime
@@ -303,11 +324,12 @@ async function main() {
   // sólo buscaba ayuda de CLI. Un comando de consulta no instala software.
   //
   // Sin argumentos sigue arrancando el server, que es como lo invocan los clientes de IA.
-  if (cmd !== undefined && !COMANDOS.includes(cmd)) {
-    const pedidoDeAyuda = ['--help', '-h', 'help'].includes(cmd)
+  if (cmd !== undefined && !COMANDOS.includes(cmd) && !SINONIMOS_DEL_SERVER.includes(cmd)) {
+    const pedidoDeAyuda = PEDIDOS_DE_AYUDA.includes(cmd)
     mostrarAyuda()
     if (!pedidoDeAyuda) {
       console.error(`\nNo conozco el comando "${cmd}".`)
+      reportarLanzamiento('rejected-argument')
     }
     process.exit(pedidoDeAyuda ? 0 : 2)
   }
@@ -317,7 +339,8 @@ async function main() {
     clearUninstallSentinels()
     const { runSetup } = require('./setup')
     await runSetup()
-    process.exit(0)
+    // En Linux el setup no instaló nada (#9): quien lo encadena en un script tiene que verlo.
+    process.exit(process.platform === 'linux' ? 1 : 0)
   }
 
   if (cmd === 'update') {
@@ -402,6 +425,7 @@ async function main() {
   // runtime-dir and durable App Support copies (see uninstallSentinelPaths).
   {
     if (anyUninstallSentinel()) {
+      reportarLanzamiento('uninstalled')
       process.stderr.write(
         '[LMCP] Local MCP was uninstalled — not starting.\n' +
         '       Reinstall:  npx local-mcp setup\n' +
@@ -421,6 +445,7 @@ async function main() {
   // and we short-circuit here, which is harmless.
   {
     if (detectManualUninstall()) {
+      reportarLanzamiento('uninstalled')
       writeUninstallSentinels()
       const trayPlist = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.local-mcp.tray.plist')
       if (fs.existsSync(trayPlist)) {
@@ -435,6 +460,15 @@ async function main() {
     }
   }
 
+  // ── Linux no está soportado (#9) ────────────────────────────────────────────
+  // Se dice acá, antes de cualquier descarga: sin esto el wrapper pedía un binario que no se
+  // publica y terminaba en un 404. Va después de los chequeos de desinstalación, que no bajan nada.
+  if (process.platform === 'linux') {
+    process.stderr.write(require('./download').LINUX_NO_SOPORTADO + '\n')
+    reportarLanzamiento('unsupported-platform')
+    process.exit(1)
+  }
+
   // ── Modo default: stdio MCP server ──────────────────────────────────────────
   const { CACHE_DIR } = require('./download')
   // macOS ships the Swift `local-mcp-server` (standalone fallback to the embedded
@@ -526,7 +560,10 @@ async function main() {
     try { _pkgVer = require('./package.json').version || '' } catch {}
     const child = spawn(binaryPath, spawnArgs, { stdio: 'inherit', env: { ...process.env, LMCP_NPM_VERSION: _pkgVer } })
     noteSpawnedServer(child.pid)
+    // El server ya arrancó y este proceso queda vivo toda la sesión: el evento sale desde acá.
+    child.on('spawn', () => reportarLanzamiento('spawned', { enProceso: true }))
     child.on('error', (err) => {
+      reportarLanzamiento('spawn-failed')
       process.stderr.write(`Error ejecutando LMCP: ${err.message}\n`)
       process.exit(1)
     })
@@ -667,6 +704,7 @@ async function main() {
   try {
     runtime = await ensureRuntime()
   } catch (err) {
+    reportarLanzamiento('download-failed')
     process.stderr.write(`\nError al preparar el runtime de LMCP:\n${err.message}\n`)
     process.stderr.write(`Intentá reinstalar: npx local-mcp update\n\n`)
     process.exit(1)

package/launch-event.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+'use strict'
+// launch-event.js — el evento de lanzamiento del wrapper (colibird-ai/lmcp-npm#11, parte C).
+//
+// Por qué existe: de 3.0.413 a 3.0.416 el wrapper rechazó `stdio` y ninguna config manual
+// conectaba. Nadie lo vio en diez días: el wrapper salía antes de que existiera telemetría.
+//
+// Contrato: contracts/launch-telemetry.v1.json de lmcp-api (copia fijada en npm/contracts/, que
+// NO se publica: por eso los conjuntos están acá como constantes, y un test los compara).
+//
+// Corre en cada arranque de cada cliente de IA. Lo que no puede pasar nunca:
+//   · escribir en stdout — es el protocolo;
+//   · demorar el arranque del server o una salida — sin reintentos, timeout corto, todo error
+//     tragado;
+//   · mandar algo que no sea uno de los cinco campos: ni el argumento, ni rutas, ni entorno.
+const https = require('https')
+const { spawn } = require('child_process')
+const DESTINO = { hostname: 'office-mcp-production.up.railway.app', path: '/launch-event' }
+const PLATAFORMAS = ['darwin', 'win32', 'linux', 'other']
+const CLASES = ['none', 'stdio', 'unknown']
+const OUTCOMES = ['spawned', 'rejected-argument', 'unsupported-node', 'unsupported-platform',
+  'download-failed', 'spawn-failed', 'uninstalled', 'other']
+const RE_VERSION = /^\d{1,3}\.\d{1,3}\.\d{1,5}$/
+const RE_MAQUINA = /^[A-Za-z0-9._:{}-]{1,64}$/
+const [TIMEOUT_MS, TOPE_MS] = [3000, 4000] // el pedido · la vida del proceso suelto
+
+// Del argumento sólo viaja su clase. `stdio` es el único que se nombra: es el del incidente.
+function claseDeArgumento (cmd) {
+  if (cmd === undefined) return 'none'
+  return cmd === 'stdio' ? 'stdio' : 'unknown'
+}
+
+// El heartbeat no tiene compuerta de consentimiento (ver #11). Este evento respeta además el
+// único interruptor que ya existe en el server de Mac.
+function apagado (env = process.env) {
+  return ['1', 'true', 'yes'].includes(String(env.LMCP_DISABLE_TELEMETRY || '').toLowerCase())
+}
+
+// El id que usa el heartbeat, sin escribir nada y sin el fallback del hostname. Lo que no
+// calza con el patrón del contrato (una ruta en LMCP_MACHINE_ID, por ejemplo) no viaja.
+function idDeMaquina () {
+  try {
+    const id = require('./download')._getMachineId({ soloLectura: true })
+    return RE_MAQUINA.test(id) ? id : undefined
+  } catch { return undefined }
+}
+
+// null = no se manda. Sólo salen valores de los conjuntos del contrato.
+function cuerpo (outcome, clase, deps = {}) {
+  const version = 'version' in deps ? deps.version : require('./package.json').version
+  const plataforma = deps.platform || process.platform
+  if (!OUTCOMES.includes(outcome) || !CLASES.includes(clase) || !RE_VERSION.test(version)) return null
+  const c = {
+    package_version: version,
+    platform: PLATAFORMAS.includes(plataforma) ? plataforma : 'other',
+    arg_class: clase,
+    outcome
+  }
+  const id = 'machineId' in deps ? deps.machineId : idDeMaquina()
+  if (typeof id === 'string' && RE_MAQUINA.test(id)) c.machine_id = id
+  return c
+}
+
+// Un POST, sin reintento, respuesta ignorada. `soltar` es para el pedido que sale desde el
+// wrapper vivo: el socket no retiene al proceso.
+function enviar (c, { soltar = false } = {}) {
+  try {
+    const datos = JSON.stringify(c)
+    const req = https.request({
+      ...DESTINO,
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(datos) },
+      timeout: TIMEOUT_MS
+    }, (res) => res.resume())
+    req.on('error', () => {})
+    req.on('timeout', () => { try { req.destroy() } catch {} })
+    if (soltar) req.on('socket', (s) => { try { s.unref() } catch {} })
+    req.end(datos)
+  } catch {}
+}
+
+// Un evento por lanzamiento: la primera llamada decide, las demás no hacen nada.
+//   enProceso  el server ya arrancó y el wrapper queda vivo toda la sesión (`spawned`): el
+//              pedido sale desde acá, sin proceso extra.
+//   si no      el wrapper está por salir: un proceso suelto manda el evento y el wrapper no
+//              lo espera. Sin stdout heredado y, en Windows, sin ventana de consola.
+// Una persona en una terminal (stdin TTY) no es un cliente de IA lanzando el server: no reporta.
+let reportado = false
+function reportar (outcome, clase, { enProceso = false } = {}) {
+  if (reportado) return
+  reportado = true
+  try {
+    if (apagado() || (process.stdin && process.stdin.isTTY)) return
+    if (!OUTCOMES.includes(outcome) || !CLASES.includes(clase)) return
+    if (enProceso) {
+      // Windows: el id sale de un PowerShell, que acá no se lanza. Sin id, ese `spawned` no se une a un heartbeat.
+      const c = cuerpo(outcome, clase, process.platform === 'win32' ? { machineId: process.env.LMCP_MACHINE_ID } : {})
+      if (c) enviar(c, { soltar: true })
+      return
+    }
+    const hijo = spawn(process.execPath, [__filename, outcome, clase],
+      { detached: true, stdio: 'ignore', windowsHide: true })
+    hijo.on('error', () => {})
+    hijo.unref()
+  } catch {}
+}
+
+// Como programa es el proceso suelto: `node launch-event.js <outcome> <clase>`.
+if (require.main === module) {
+  setTimeout(() => process.exit(0), TOPE_MS).unref()
+  const c = apagado() ? null : cuerpo(process.argv[2], process.argv[3])
+  if (c) enviar(c)
+}
+
+module.exports = { PLATAFORMAS, CLASES, OUTCOMES, RE_VERSION, RE_MAQUINA, claseDeArgumento, apagado, cuerpo, reportar }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-mcp",
-  "version": "3.0.414",
+  "version": "3.0.417",
   "description": "Let ChatGPT, Claude, Cursor & any MCP client actually use your Mac or Windows PC — read & reply to email, manage your calendar, text over iMessage, find files, work with Teams, Slack & Office. Runs locally, no API keys, free.",
   "main": "index.js",
   "bin": {
@@ -14,11 +14,12 @@
     "index.js",
     "download.js",
     "setup.js",
+    "launch-event.js",
     "postinstall.js",
     "README.md"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "os": [
     "darwin",
@@ -68,10 +69,10 @@
   "homepage": "https://local-mcp.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/lanchuske/local-mcp-releases.git"
+    "url": "https://github.com/colibird-ai/local-mcp-releases.git"
   },
   "bugs": {
-    "url": "https://github.com/lanchuske/local-mcp-releases/issues"
+    "url": "https://github.com/colibird-ai/local-mcp-releases/issues"
   },
   "mcpName": "com.local-mcp/local-mcp"
 }

package/setup.js

@@ -237,11 +237,12 @@ function _launcherArgsForConfigureClients(platform, command, args) {
   return platform === 'darwin' ? { command, args } : { command: null, args: [] }
 }
 
-// §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.
+// §3.8 — Linux's fixed result shape: no capability, no report, exit 1. It said exit 0 while
+// Linux was "no writer yet"; since #9 Linux is not supported, and a setup that installed nothing
+// is a failed setup: a script that chains on it has to see it. 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 }
+  return { runtime: 'not_supported_on_platform', exitCode: 1, report: null }
 }
 
 // Corre `--configure-clients --json`. Nunca cuelga el instalador: un binario que no responde
@@ -296,10 +297,27 @@ 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
-  // gate was retired for the Windows/Linux public re-launch.
+  // Linux no está soportado (#9): se dice y no se toca nada — sin descarga, sin launcher, sin
+  // eventos de instalación ni heartbeat (antes terminaba en «LMCP is installed and running»
+  // después de un 404). El reporte --json conserva su forma (§3.8); el código de salida es 1.
+  if (process.platform === 'linux') {
+    const sinLinux = _notSupportedOnPlatformResult()
+    console.log('\n  ' + require('./download').LINUX_NO_SOPORTADO + '\n  Nothing was installed.\n')
+    if (jsonMode) {
+      process.stdout.write(JSON.stringify({
+        schema: CLIENTS_REPORT_SCHEMA,
+        installer_version: require('./package.json').version,
+        runtime: sinLinux.runtime,
+        catalog: null,
+        clients: [],
+        permissions: 'unknown_until_tray_runs',
+      }) + '\n')
+    }
+    process.exitCode = sinLinux.exitCode
+    return
+  }
+  // Cross-platform: macOS configures the Swift tray + embedded server; Windows downloads the
+  // go-server standalone binary (download.js) and writes the MCP client config.
   const forceAll = opts.all || process.argv.includes('--all')
   const refArg = process.argv.find(a => a.startsWith('--ref='))
   if (refArg) process.env.LMCP_REF = refArg.split('=')[1]
@@ -469,16 +487,6 @@ async function runSetup(opts = {}) {
       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()
@@ -530,7 +538,7 @@ async function runSetup(opts = {}) {
   if (configured.length > 0) {
     if (healthOk) {
       console.log(`✅ LMCP configured for: ${configured.join(', ')}\n`)
-      console.log('  ✓ Server binary verified — 191+ tools ready\n')
+      console.log('  ✓ Server binary verified — 192+ 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')
@@ -678,7 +686,7 @@ async function runSetup(opts = {}) {
 
   // #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.
+  // point — darwin/win32 from runConfigureClients (linux returned at the top, #9).
   if (jsonMode) {
     const rep = clientsRun.report || {}
     const out = {