local-mcp 3.0.416 → 3.0.418

package/README.md

@@ -6,7 +6,7 @@
 [![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
@@ -108,6 +109,26 @@ function _writeWinMachineIdCache(cacheDir, id) {
 // memoized too, on purpose: a run where PowerShell is blocked shouldn't retry
 // it on every subsequent call in the same process.
 let _winHardwareIdCache
+// Valores que Win32_ComputerSystemProduct.UUID devuelve y que NO identifican a una máquina:
+// relleno, o —el caso peligroso— el MISMO valor en máquinas distintas (defaults de OEM/BIOS).
+// Aceptar uno junta a N máquinas en una identidad, y la separa de su propio heartbeat, porque el
+// cliente Go lo rechaza. Copia a mano de `knownGarbageHardwareIDs` de lmcp-win
+// (internal/machineid/probe_windows.go, #1594): si esa lista cambia, ésta cambia con ella
+// (colibird-ai/lmcp-npm#29). En mayúsculas; la comparación no distingue mayúsculas.
+const UUIDS_DE_HARDWARE_BASURA = new Set([
+  'NIL', // lo que imprime PowerShell cuando WMI no tiene nada que dar
+  '00000000-0000-0000-0000-000000000000',
+  'FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF',
+  '03000200-0400-0500-0006-000700080009', // el default clásico de OEM/BIOS
+])
+// Tope de cada llamada del probe (#42, O1). execSync bloquea el event loop: con WMI colgado, el
+// proceso suelto del evento de lanzamiento no llegaba nunca a su propio tope de 4 s y quedaba vivo,
+// oculto, para siempre. Con el tope, una llamada colgada se mata y el probe sigue (o termina vacío).
+const TOPE_PROBE_MS = 2000
+function _esIdDeHardwareValido(id) {
+  return !!id && !UUIDS_DE_HARDWARE_BASURA.has(String(id).toUpperCase())
+}
+
 // execImpl is injectable (defaults to the real execSync) so tests can pin the
 // PowerShell-then-wmic ORDER without a Windows machine — see
 // npm/test/machine-id-windows-order.test.js.
@@ -119,21 +140,24 @@ function _probeWinHardwareId(execImpl = require('child_process').execSync) {
   // between npm and the go-server and reintroduced #1544 (0 of 9 Windows
   // installs joined their heartbeat because the two sides disagreed on id).
   try {
+    // windowsHide: lo corre un proceso sin consola propia (el emisor del evento de lanzamiento,
+    // el setup lanzado por un cliente de IA). Sin la opción, Windows puede mostrar una consola; el
+    // cliente Go pone HideWindow por lo mismo (#31). Medido sin ventana en 3.0.417; esto la descarta.
     const ps = execImpl(
       'powershell -NoProfile -Command "(Get-WmiObject Win32_ComputerSystemProduct).UUID"',
-      { stdio: 'pipe' }
+      { stdio: 'pipe', windowsHide: true, timeout: TOPE_PROBE_MS }
     ).toString().trim()
     // PowerShell prints the literal string "nil", not an empty line, when WMI
     // has no UUID to give — an emptiness check alone would accept it as an id.
-    if (ps && ps !== 'nil') {
+    if (_esIdDeHardwareValido(ps)) {
       _winHardwareIdCache = ps
       return _winHardwareIdCache
     }
   } catch {}
   try {
-    const wmic = execImpl('wmic csproduct get UUID /value', { stdio: 'pipe' }).toString()
+    const wmic = execImpl('wmic csproduct get UUID /value', { stdio: 'pipe', windowsHide: true, timeout: TOPE_PROBE_MS }).toString()
     const match = wmic.match(/UUID=(.+)/)
-    if (match) {
+    if (match && _esIdDeHardwareValido(match[1].trim())) {
       _winHardwareIdCache = match[1].trim()
       return _winHardwareIdCache
     }
@@ -154,6 +178,19 @@ function _resetWinHardwareIdCacheForTests() {
 // que invertir la prioridad hardware-antes-que-cache —la decision irreversible de
 // machineid.go— los pasaba a todos en verde. Sin argumentos se comporta igual que
 // antes; ningun caller de produccion pasa deps.
+// The machine_id the macOS tray persisted in its config.json, or '' when there is none yet.
+function _readTrayMachineId(deps = {}) {
+  const home = deps.homeDir || require('os').homedir()
+  const read = deps.readFileImpl || ((p) => require('fs').readFileSync(p, 'utf8'))
+  try {
+    const cfg = JSON.parse(read(require('path').join(home, 'Library', 'Application Support', 'Local MCP', 'config.json')))
+    const id = typeof cfg.machine_id === 'string' ? cfg.machine_id.trim() : ''
+    return id
+  } catch {
+    return ''
+  }
+}
+
 function _getMachineId(deps = {}) {
   const platform = deps.platform || process.platform
   const cacheDir = deps.cacheDir || CACHE_DIR
@@ -165,6 +202,13 @@ function _getMachineId(deps = {}) {
 
   const execSync = deps.execImpl || require('child_process').execSync
   if (platform === 'darwin') {
+    // QA 3.0.418 (Dario, m4): the tray's own id lives in its config.json (it read the keychain
+    // when IT could). An npm run in a context without keychain access (an agent or SSH session)
+    // fell to the hardware UUID and minted the cloud token for a SECOND identity of the same Mac,
+    // so the server refused that Mac's device key, its machine approval and the agent mesh.
+    // The id the tray already uses comes first.
+    const trayId = _readTrayMachineId(deps)
+    if (trayId) return trayId
     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()
@@ -178,7 +222,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,6 +237,10 @@ 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)
@@ -247,12 +295,20 @@ async function getLatestBinary() {
       let data = ''
       res.on('data', chunk => data += chunk)
       res.on('end', () => {
+        let info
         try {
-          const info = JSON.parse(data)
-          resolve(info)
+          info = JSON.parse(data)
         } catch (e) {
-          reject(new Error(`Respuesta inválida de /runtime/latest: ${data}`))
+          return reject(new Error(`Respuesta inválida de /runtime/latest: ${data}`))
+        }
+        // Un error del API también es JSON (`{"detail": …}` en un 5xx o un 429). Aceptarlo dejaba
+        // `version` en undefined y los co-procesos se pedían como `teams-proxy-undefined-…`: 25
+        // pedidos en un día de API caído (#38). Sin un 200 con versión no hay respuesta, y todo
+        // el que llama ya trata un rechazo como «no disponible».
+        if (res.statusCode !== 200 || !info || !/^[0-9][0-9A-Za-z.+-]*$/.test(String(info.version || ''))) {
+          return reject(new Error(`/runtime/latest no dio una versión (HTTP ${res.statusCode})`))
         }
+        resolve(info)
       })
     })
     req.on('error', reject)
@@ -331,6 +387,10 @@ async function downloadFile(url, destPath) {
  * @returns {Promise<{binPath: string}>}
  */
 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 {
@@ -361,17 +421,6 @@ async function ensureBinary(deps = {}) {
     const archKey = arch.replace('-', '_') // windows-amd64 → windows_amd64
     const publishedUrl = (info[archKey] && info[archKey].startsWith('http')) ? info[archKey] : null
 
-    // Linux has no published artifact today — unlike Windows, where windows_amd64
-    // IS published — so composing the fallback URL below only ever 404s: 817
-    // requests/week of dead traffic from MCP sandboxes testing the npm package
-    // (#3794). Fail before any network call instead of catching the 404 after.
-    if (platform === 'linux' && !publishedUrl) {
-      throw new Error(
-        'Local MCP does not support Linux yet.\n' +
-        '  Check https://local-mcp.com for updates.'
-      )
-    }
-
     let url, platformVersion
     if (publishedUrl) {
       platformVersion = versionFromArtifactUrl(publishedUrl, arch)
@@ -871,8 +920,8 @@ async function ensureSlackProxy(platform = process.platform) {
 module.exports = {
   ensureBinary, ensureRuntime, ensureTray, ensureTeamsProxy, ensureSlackProxy, versionFromArtifactUrl,
   latestVersionForPlatform, getArch,
-  CACHE_DIR, TRAY_DIR, _getMachineId,
-  _probeWinHardwareId, _resetWinHardwareIdCacheForTests,
+  CACHE_DIR, TRAY_DIR, _getMachineId, LINUX_NO_SOPORTADO,
+  _probeWinHardwareId, _resetWinHardwareIdCacheForTests, UUIDS_DE_HARDWARE_BASURA, _esIdDeHardwareValido,
   _readWinMachineIdCache, _writeWinMachineIdCache, WIN_MACHINE_ID_CACHE_NAME,
   _retireSupersededTrays, _isUsableTrayBundle, SYSTEM_TRAY_APP,
   _bundleVersion, _isTrayRunningFrom, _versionIsNewer,

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,31 @@ 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)
+}
+// Antes que nada: un `spawned` que en Windows esperaba su id sale ahora, por el proceso suelto (#21).
+if (ES_LANZAMIENTO) process.on('exit', () => { evento.soltarPendiente(); 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 +270,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 +298,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 +325,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 +340,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') {
@@ -381,7 +405,6 @@ async function main() {
         try {
           const s = JSON.parse(data)
           console.log(`LMCP v${s.version} — ${s.server}`)
-          console.log(`Licencia: ${s.license?.status} (${s.license?.days_left}d)`)
         } catch { console.log(data) }
       })
     }).on('error', () => console.log('Servidor no disponible en localhost:8765'))
@@ -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,194 @@
+#!/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 cp = 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
+const TOPE_ID_MS = 2000 // Windows: cuánto puede esperar el `spawned` al id de hardware (#21)
+
+// 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 {}
+}
+
+// Windows, sin bloquear (#21): el mismo id que manda el heartbeat del cliente Go
+// (lmcp-win internal/machineid/probe_windows.go: PowerShell, después wmic, TrimSpace, sin cambiar
+// mayúsculas, sin los ids basura), por execFile y sin shell. Llama a `listo` UNA vez: con el id, o
+// con undefined si los dos fallan, devuelven basura o pasa el tope. Del cache y del hash del
+// hostname del cliente Go no se toma nada: un id rechazado no viaja.
+// Lo que corre después de que reportar() volvió (#42, O2/O3/O5): pasado el tope no se lanza otro
+// probe; el probe vivo se mata al terminar y cuando el wrapper sale (matarProbe); y ningún
+// callback puede tirar, porque una excepción acá mataría al wrapper y con él la sesión MCP.
+let probeVivo = null
+let cancelarProbe = () => {}
+function matarProbe () {
+  const p = probeVivo
+  probeVivo = null
+  try { if (p) p.kill() } catch {}
+}
+function idDeHardwareWindows (listo) {
+  let hecho = false
+  const fin = (id) => {
+    if (hecho) return
+    hecho = true
+    clearTimeout(tope)
+    matarProbe()
+    try { listo(id) } catch {}
+  }
+  const tope = setTimeout(() => fin(undefined), TOPE_ID_MS)
+  cancelarProbe = () => { hecho = true; clearTimeout(tope); matarProbe() }
+  const opciones = { windowsHide: true, timeout: TOPE_ID_MS }
+  const correr = (cmd, args, alResponder) => {
+    if (hecho) return
+    try {
+      probeVivo = cp.execFile(cmd, args, opciones, (err, out) => {
+        probeVivo = null
+        try { alResponder(err ? '' : String(out)) } catch { fin(undefined) }
+      })
+    } catch { fin(undefined) }
+  }
+  try {
+    const { _esIdDeHardwareValido: valido } = require('./download')
+    correr('powershell', ['-NoProfile', '-Command', '(Get-WmiObject Win32_ComputerSystemProduct).UUID'], (out) => {
+      const ps = out.trim()
+      if (valido(ps)) return fin(ps)
+      correr('wmic', ['csproduct', 'get', 'UUID', '/value'], (out2) => {
+        const m = out2.match(/UUID=(.+)/)
+        const id = m ? m[1].trim() : ''
+        fin(valido(id) ? id : undefined)
+      })
+    })
+  } catch { fin(undefined) }
+}
+
+// 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.
+//   En Windows sin LMCP_MACHINE_ID, el `spawned` espera al id sin bloquear (idDeHardwareWindows);
+//   si el wrapper sale antes, soltarPendiente() lo manda por el proceso suelto, que busca el id solo.
+// Una persona en una terminal (stdin TTY) no es un cliente de IA lanzando el server: no reporta.
+let reportado = false
+let pendiente = null
+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) {
+      const idEntorno = (process.env.LMCP_MACHINE_ID || '').trim()
+      if (process.platform === 'win32' && !idEntorno) {
+        pendiente = { outcome, clase }
+        idDeHardwareWindows((id) => {
+          if (!pendiente) return // ya salió por el proceso suelto
+          pendiente = null
+          const c = cuerpo(outcome, clase, { machineId: id })
+          if (c) enviar(c, { soltar: true })
+        })
+        return
+      }
+      const c = cuerpo(outcome, clase, process.platform === 'win32' ? { machineId: idEntorno } : {})
+      if (c) enviar(c, { soltar: true })
+      return
+    }
+    lanzarSuelto(outcome, clase)
+  } catch {}
+}
+
+function lanzarSuelto (outcome, clase) {
+  const hijo = cp.spawn(process.execPath, [__filename, outcome, clase],
+    { detached: true, stdio: 'ignore', windowsHide: true })
+  hijo.on('error', () => {})
+  hijo.unref()
+}
+
+// El wrapper está por salir con el `spawned` todavía esperando su id: sale por el proceso suelto,
+// y el probe que seguía vivo se mata (el timeout de execFile vive en el wrapper y se va con él).
+function soltarPendiente () {
+  cancelarProbe()
+  if (!pendiente) return
+  const { outcome, clase } = pendiente
+  pendiente = null
+  try { lanzarSuelto(outcome, clase) } 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, TOPE_ID_MS, claseDeArgumento, apagado, cuerpo, reportar, soltarPendiente,
+  _idDeHardwareWindows: idDeHardwareWindows } // costura de test

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-mcp",
-  "version": "3.0.416",
+  "version": "3.0.418",
   "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,6 +14,7 @@
     "index.js",
     "download.js",
     "setup.js",
+    "launch-event.js",
     "postinstall.js",
     "README.md"
   ],
@@ -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

@@ -107,7 +107,7 @@ function _localMcpConfigDir(platform = process.platform, home = HOME, appData =
 
 function _cmdExists(cmd) {
   const which = _IS_WIN ? 'where' : 'which'
-  try { execSync(`${which} ${cmd}`, { stdio: 'pipe' }); return true } catch { return false }
+  try { execSync(`${which} ${cmd}`, { stdio: 'pipe', windowsHide: true }); return true } catch { return false }
 }
 
 // ── Safe config read ─────────────────────────────────────────────────────────
@@ -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
@@ -253,7 +254,9 @@ function runConfigureClients(bin, command, args, opts = {}) {
   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' })
+  // windowsHide en los tres procesos que setup arranca en Windows (#31): todos capturan su
+  // salida, ninguno es para mirar, y setup puede correr sin consola (un agente, postinstall).
+  const r = spawn(bin, argv, { input: '', timeout: timeoutMs, encoding: 'utf8', windowsHide: true })
   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
@@ -296,10 +299,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 +489,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()
@@ -613,8 +623,8 @@ async function runSetup(opts = {}) {
   // Anon-first cloud relay activation (replaces the interactive email prompt
   // removed 2026-04-19). When no email is set, register an anonymous tunnel
   // token keyed on machine_id so cloud relay comes online immediately. Users
-  // can attach an email later via the tray or /settings to unlock cross-Mac
-  // sync + paid-license features. Non-fatal on failure — the install still
+  // can attach an email later via the tray or /settings for cross-Mac
+  // sync. Non-fatal on failure — the install still
   // succeeds and the server can retry at startup.
   // Provisioning is ALWAYS anonymous, with or without an email — same change made in install.sh
   // (#1083). Two separate ways this used to be skipped, and both left the machine with NO
@@ -678,7 +688,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 = {
@@ -747,6 +757,7 @@ function _runHealthCheck() {
     const result = execFileSync(binPath, args, {
       timeout: 10000,
       stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
       env: { ...process.env, HOME },
     })
     const output = result.toString().trim()
@@ -1183,6 +1194,7 @@ async function _autoLaunchClient(clientsRun, opts = {}) {
 
 module.exports = {
   runSetup, runConfigureClients, _findServerBinary, _launcherArgsForConfigureClients,
+  _cmdExists, _runHealthCheck,
   CLIENTS_REPORT_SCHEMA,
   _notSupportedOnPlatformResult,
   _launcherSpawnSpec, _writeLaunchScript, _writeLaunchSpec,