local-mcp 3.0.417 → 3.0.418

package/download.js

@@ -109,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.
@@ -120,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
     }
@@ -155,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
@@ -166,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()
@@ -252,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)
@@ -870,7 +921,7 @@ module.exports = {
   ensureBinary, ensureRuntime, ensureTray, ensureTeamsProxy, ensureSlackProxy, versionFromArtifactUrl,
   latestVersionForPlatform, getArch,
   CACHE_DIR, TRAY_DIR, _getMachineId, LINUX_NO_SOPORTADO,
-  _probeWinHardwareId, _resetWinHardwareIdCacheForTests,
+  _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

@@ -248,7 +248,8 @@ const ES_LANZAMIENTO = require.main === module && !COMANDOS.includes(cmd) && !PE
 function reportarLanzamiento(outcome, opciones) {
   if (ES_LANZAMIENTO) evento.reportar(outcome, evento.claseDeArgumento(cmd), opciones)
 }
-if (ES_LANZAMIENTO) process.on('exit', () => reportarLanzamiento('other'))
+// 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
@@ -404,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'))

package/launch-event.js

@@ -14,7 +14,7 @@
 //     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 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']
@@ -23,6 +23,7 @@ const OUTCOMES = ['spawned', 'rejected-argument', 'unsupported-node', 'unsupport
 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) {
@@ -79,13 +80,66 @@ function enviar (c, { soltar = false } = {}) {
   } 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
@@ -93,18 +147,42 @@ function reportar (outcome, clase, { enProceso = false } = {}) {
     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 } : {})
+      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
     }
-    const hijo = spawn(process.execPath, [__filename, outcome, clase],
-      { detached: true, stdio: 'ignore', windowsHide: true })
-    hijo.on('error', () => {})
-    hijo.unref()
+    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()
@@ -112,4 +190,5 @@ if (require.main === module) {
   if (c) enviar(c)
 }
 
-module.exports = { PLATAFORMAS, CLASES, OUTCOMES, RE_VERSION, RE_MAQUINA, claseDeArgumento, apagado, cuerpo, reportar }
+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.417",
+  "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": {

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 ─────────────────────────────────────────────────────────
@@ -254,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
@@ -621,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
@@ -755,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()
@@ -1191,6 +1194,7 @@ async function _autoLaunchClient(clientsRun, opts = {}) {
 
 module.exports = {
   runSetup, runConfigureClients, _findServerBinary, _launcherArgsForConfigureClients,
+  _cmdExists, _runHealthCheck,
   CLIENTS_REPORT_SCHEMA,
   _notSupportedOnPlatformResult,
   _launcherSpawnSpec, _writeLaunchScript, _writeLaunchSpec,