local-mcp 3.0.138 → 3.0.140

package/download.js

@@ -13,34 +13,61 @@ const os     = require('os')
 const { execFileSync } = require('child_process')
 
 const BACKEND_URL = 'https://office-mcp-production.up.railway.app'
-const CACHE_DIR   = path.join(os.homedir(), '.local', 'share', 'local-mcp', 'bin')
-const TRAY_DIR    = path.join(os.homedir(), '.local', 'share', 'local-mcp', 'tray')  // metadata dir
+
+// Platform-aware cache directory:
+//   macOS:   ~/.local/share/local-mcp/bin
+//   Windows: %LOCALAPPDATA%/local-mcp/bin
+//   Linux:   ~/.local/share/local-mcp/bin
+const CACHE_DIR = process.platform === 'win32'
+  ? path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'local-mcp', 'bin')
+  : path.join(os.homedir(), '.local', 'share', 'local-mcp', 'bin')
+
+const TRAY_DIR = process.platform === 'win32'
+  ? path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'local-mcp', 'tray')
+  : path.join(os.homedir(), '.local', 'share', 'local-mcp', 'tray')
+
 // Install to ~/Applications (user-owned) to avoid macOS App Management TCC prompt.
 // /Applications requires kTCCServiceAppManagement permission which shows "node would like
 // to access data from other apps" on every tray update — confusing and unnecessary.
-const TRAY_APP    = path.join(os.homedir(), 'Applications', 'LocalMCPTray.app')
+// On Windows/Linux there is no tray app yet.
+const TRAY_APP = process.platform === 'darwin'
+  ? path.join(os.homedir(), 'Applications', 'LocalMCPTray.app')
+  : null
 
 function _getMachineId() {
   const { execSync } = require('child_process')
-  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()
-    if (id) return id
-  } catch {}
-  try {
-    // Full hardware UUID (same format as Swift server)
-    const ioreg = execSync('ioreg -rd1 -c IOPlatformExpertDevice', { stdio: 'pipe' }).toString()
-    const match = ioreg.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)
-    return match ? match[1] : os.hostname()
-  } catch {}
-  return ''
+  if (process.platform === 'darwin') {
+    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()
+      if (id) return id
+    } catch {}
+    try {
+      const ioreg = execSync('ioreg -rd1 -c IOPlatformExpertDevice', { stdio: 'pipe' }).toString()
+      const match = ioreg.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)
+      return match ? match[1] : os.hostname()
+    } catch {}
+  } else if (process.platform === 'win32') {
+    try {
+      const wmic = execSync('wmic csproduct get UUID /value', { stdio: 'pipe' }).toString()
+      const match = wmic.match(/UUID=(.+)/)
+      if (match) return match[1].trim()
+    } catch {}
+  } else {
+    try {
+      const mid = fs.readFileSync('/etc/machine-id', 'utf8').trim()
+      if (mid) return mid
+    } catch {}
+  }
+  return os.hostname()
 }
 
 function getArch() {
+  const plat = process.platform === 'win32' ? 'windows' : process.platform === 'linux' ? 'linux' : 'darwin'
   const arch = process.arch
-  if (arch === 'arm64') return 'darwin-arm64'
-  if (arch === 'x64')   return 'darwin-x64'
-  throw new Error(`Arquitectura no soportada: ${arch}. LMCP requiere macOS arm64 o x64.`)
+  if (arch === 'arm64') return `${plat}-arm64`
+  if (arch === 'x64')   return `${plat}-amd64`
+  throw new Error(`Unsupported architecture: ${plat}/${arch}. LMCP requires arm64 or x64.`)
 }
 
 /**
@@ -121,7 +148,55 @@ async function ensureBinary() {
   const arch   = getArch()
   const info   = await getLatestBinary()
   const version = info.version
-  // URL del binario PyInstaller (nueva nomenclatura)
+
+  // 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'
+    const binPath = path.join(CACHE_DIR, binName)
+    const versionFile = path.join(CACHE_DIR, '.go-server-version')
+
+    // Check if already cached at the right version
+    if (fs.existsSync(binPath)) {
+      try {
+        const cached = fs.readFileSync(versionFile, 'utf8').trim()
+        if (cached === version) return { binPath, versionDir: CACHE_DIR, version }
+      } catch {}
+    }
+
+    // Download the Go binary tarball from R2
+    const url = `https://download.local-mcp.com/lmcp-server-${version}-${arch}.tar.gz`
+    process.stderr.write(`\nLMCP v${version} (${arch}) not found in cache.\n`)
+    process.stderr.write(`Downloading from ${url}\n`)
+
+    fs.mkdirSync(CACHE_DIR, { recursive: true })
+    const tarPath = path.join(CACHE_DIR, `go-server-${version}.tar.gz`)
+
+    try {
+      await downloadFile(url, tarPath)
+      process.stderr.write(`  Extracting...\n`)
+      execFileSync('tar', ['-xzf', tarPath, '-C', CACHE_DIR], { stdio: 'pipe' })
+      fs.unlinkSync(tarPath)
+    } catch (err) {
+      // Go binary not yet published for this version — fall back to message
+      try { fs.unlinkSync(tarPath) } catch {}
+      throw new Error(
+        `LMCP ${version} is not yet available for ${arch}.\n` +
+        `The Windows/Linux Go server is in preview — check https://local-mcp.com for updates.`
+      )
+    }
+
+    if (!fs.existsSync(binPath)) {
+      throw new Error(`Binary not found after extraction: ${binPath}`)
+    }
+    if (process.platform !== 'win32') fs.chmodSync(binPath, 0o755)
+    fs.writeFileSync(versionFile, version)
+
+    process.stderr.write(`  Ready at ${CACHE_DIR}\n`)
+    return { binPath, versionDir: CACHE_DIR, version }
+  }
+
+  // macOS: Swift binary in a nested tarball
   const url = `https://download.local-mcp.com/local-mcp-server-${version}-${arch}.tar.gz`
 
   const versionDir = path.join(CACHE_DIR, version)
@@ -148,28 +223,19 @@ async function ensureBinary() {
     throw new Error(`Binario no encontrado después de extraer: ${binPath}`)
   }
 
-  // Asegurar que sea ejecutable
   fs.chmodSync(binPath, 0o755)
 
-  // Clear quarantine separately — Node.js https downloads don't set it, but tar extraction
-  // on some macOS versions can inherit it from the archive. Non-critical.
-  try { execFileSync('xattr', ['-d', 'com.apple.quarantine', binPath], { stdio: 'pipe' }) } catch { /* no quarantine, fine */ }
+  try { execFileSync('xattr', ['-d', 'com.apple.quarantine', binPath], { stdio: 'pipe' }) } catch {}
 
-  // Preserve the Developer ID signature from the build pipeline.
-  // On macOS 26+ ad-hoc signatures (--sign -) don't create a stable TCC identity:
-  // each new CDHash is treated as a new app, triggering "node would like to access
-  // data from other apps" on every JXA call. Only fall back to ad-hoc if the binary
-  // has no valid signature at all (e.g. a dev build that was never properly signed).
-  // See: FB-74E468, FB-017B8E — permission prompt loop on macOS 26 beta.
   let hasSig = false
   try {
     execFileSync('codesign', ['--verify', binPath], { stdio: 'pipe' })
     hasSig = true
-  } catch { /* no valid signature — apply ad-hoc fallback */ }
+  } catch {}
   if (!hasSig) {
     try {
       execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', binPath], { stdio: 'pipe' })
-    } catch { /* non-critical */ }
+    } catch {}
   }
 
   process.stderr.write(`  Listo en ${versionDir}\n`)

package/index.js

@@ -18,9 +18,10 @@ const fs    = require('fs')
 const https = require('https')
 
 
-// Solo macOS
-if (process.platform !== 'darwin') {
-  console.error('LMCP solo está disponible para macOS.')
+// Platform support: macOS (full), Windows (Go server), Linux (Go server)
+const SUPPORTED_PLATFORMS = ['darwin', 'win32', 'linux']
+if (!SUPPORTED_PLATFORMS.includes(process.platform)) {
+  console.error(`LMCP is not available for ${process.platform}. Supported: macOS, Windows, Linux.`)
   process.exit(1)
 }
 
@@ -30,7 +31,7 @@ if (process.platform !== 'darwin') {
 // user sees it in Claude Desktop's MCP logs instead of a cryptic spawn error.
 if (parseInt(process.version.slice(1)) < 16) {
   const msg = `LMCP requires Node 16+. Running ${process.version}.\n` +
-    'If you use nvm, run: nvm alias default 22\n' +
+    `If you use nvm, run: nvm alias default 22 && nvm uninstall ${process.version}\n` +
     'Then restart Claude Desktop / Cursor.'
   process.stderr.write(msg + '\n')
   // Exit with a non-zero code so the MCP host marks the server as failed
@@ -89,7 +90,8 @@ async function main() {
 
   // ── Modo default: stdio MCP server ──────────────────────────────────────────
   const { CACHE_DIR } = require('./download')
-  const stableBin = path.join(CACHE_DIR, 'local-mcp-server')
+  const binName = process.platform === 'win32' ? 'local-mcp-server.exe' : 'local-mcp-server'
+  const stableBin = path.join(CACHE_DIR, binName)
   const versionFile = path.join(CACHE_DIR, '.server-version')
   const pkg = require('./package.json')
 
@@ -117,11 +119,13 @@ async function main() {
         : ''
       if (cachedVersion && semverGte(cachedVersion, pkg.version)) {
         // Cached binary is same or newer — use fast path, no download needed
-        const { ensureTray, ensureTeamsProxy, ensureHelper, ensureJXARunner } = require('./download')
-        ensureTray().catch(() => {})
-        ensureTeamsProxy().catch(() => {})
-        ensureHelper().catch(() => {})
-        ensureJXARunner().catch(() => {})
+        if (process.platform === 'darwin') {
+          const { ensureTray, ensureTeamsProxy, ensureHelper, ensureJXARunner } = require('./download')
+          ensureTray().catch(() => {})
+          ensureTeamsProxy().catch(() => {})
+          ensureHelper().catch(() => {})
+          ensureJXARunner().catch(() => {})
+        }
         const child = spawn(stableBin, [], { stdio: 'inherit', env: process.env })
         child.on('error', () => process.exit(1))
         child.on('exit', (code) => process.exit(code ?? 0))
@@ -150,7 +154,7 @@ async function main() {
                         const tmpPath = stableBin + '.tmp'
                         fs.copyFileSync(binPath, tmpPath)
                         fs.chmodSync(tmpPath, 0o755)
-                        try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {}
+                        if (process.platform === 'darwin') { try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {} }
                         fs.renameSync(tmpPath, stableBin)
                         fs.writeFileSync(versionFile, downloadedVersion || latestVersion)
                       } catch {}
@@ -179,11 +183,13 @@ async function main() {
   // Slow path: download/repair binary
   const { ensureRuntime, ensureTray, ensureTeamsProxy, ensureHelper, ensureJXARunner } = require('./download')
 
-  // Update tray + proxies in background. Helper + jxa-runner downloaded only on first install.
-  ensureTray().catch(() => {})
-  ensureTeamsProxy().catch(() => {})
-  ensureHelper().catch(() => {})
-  ensureJXARunner().catch(() => {})
+  // Update tray + proxies in background (macOS only).
+  if (process.platform === 'darwin') {
+    ensureTray().catch(() => {})
+    ensureTeamsProxy().catch(() => {})
+    ensureHelper().catch(() => {})
+    ensureJXARunner().catch(() => {})
+  }
 
   let runtime
   try {
@@ -201,7 +207,7 @@ async function main() {
     const tmpPath = stableBin + '.tmp'
     fs.copyFileSync(binPath, tmpPath)
     fs.chmodSync(tmpPath, 0o755)
-    try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {}
+    if (process.platform === 'darwin') { try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', tmpPath], { stdio: 'pipe' }) } catch {} }
     fs.renameSync(tmpPath, stableBin)
     // Write the ACTUAL downloaded binary version (not pkg.version) so the fast path
     // knows what version is on disk. Using pkg.version here caused LMC-375: machines

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-mcp",
-  "version": "3.0.138",
+  "version": "3.0.140",
   "description": "LMCP — connect Claude Desktop, Cursor, Windsurf to Mail, Calendar, Contacts, Teams, OneDrive on macOS. Privacy-first: all data stays on your Mac.",
   "main": "index.js",
   "bin": {
@@ -20,7 +20,9 @@
     "node": ">=18"
   },
   "os": [
-    "darwin"
+    "darwin",
+    "win32",
+    "linux"
   ],
   "keywords": [
     "mcp",

package/setup.js

@@ -34,6 +34,19 @@ function _resolveNpxPath() {
 // BEFORE Node loads our code (e.g. old nvm default in Claude Desktop's PATH).
 // Returns the path to the launcher, or null if writing fails.
 function _writeLaunchScript(npxAbsPath, cacheDir) {
+  // On Windows, don't write a bash launch script — use npx directly
+  if (_IS_WIN) {
+    try {
+      // Write a .cmd wrapper that Claude Desktop can execute
+      fs.mkdirSync(cacheDir, { recursive: true })
+      const cmdPath = path.join(cacheDir, 'lmcp-launch.cmd')
+      const script = `@echo off\r\n"${npxAbsPath}" -y local-mcp@latest %*\r\n`
+      fs.writeFileSync(cmdPath, script)
+      return cmdPath
+    } catch {
+      return null
+    }
+  }
   try {
     fs.mkdirSync(cacheDir, { recursive: true })
     const launcherPath = path.join(cacheDir, 'lmcp-launch.sh')
@@ -48,7 +61,7 @@ function _writeLaunchScript(npxAbsPath, cacheDir) {
       `  curl -sf --max-time 3 -X POST "https://${BACKEND_HOST}/install-event" \\`,
       '    -H "Content-Type: application/json" \\',
       '    -d "{\\\"stage\\\":\\\"node_too_old\\\",\\\"version\\\":\\\"$NODE_VER\\\"}" &>/dev/null &',
-      '  printf \'LMCP requires Node 16+. Current: %s\\nFix: nvm alias default 22 — then restart Claude Desktop.\\n\' "$NODE_VER" >&2',
+      '  printf \'LMCP requires Node 16+. Current: %s\\nFix: nvm alias default 22 && nvm uninstall %s — then restart Claude Desktop.\\n\' "$NODE_VER" "$NODE_VER" >&2',
       '  exit 1',
       'fi',
       `exec "${npxAbsPath}" -y local-mcp@latest "$@"`,
@@ -62,14 +75,73 @@ function _writeLaunchScript(npxAbsPath, cacheDir) {
 const STABLE_LINK   = path.join(os.homedir(), '.local', 'share', 'local-mcp', 'bin', 'local-mcp-server')
 const BACKEND_HOST  = 'office-mcp-production.up.railway.app'
 
-// ── Rutas de config de cada cliente ──────────────────────────────────────────
+// ── Platform-aware config paths for AI clients ─────────────────────────────
+// macOS: ~/Library/Application Support/...
+// Windows: %APPDATA%/... (most Electron apps use APPDATA)
+// Linux: ~/.config/... (XDG standard)
+
+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')
+}
 
 const CLIENTS = [
   {
     id:       'claude-desktop',
     name:     'Claude Desktop',
-    cfgPath:  path.join(HOME, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
-    detect:   () => fs.existsSync(path.join(HOME, 'Library', 'Application Support', 'Claude')),
+    cfgPath:  _claudeDesktopPath(),
+    detect:   _claudeDesktopDetect,
   },
   {
     id:       'cursor',
@@ -93,8 +165,8 @@ const CLIENTS = [
   {
     id:       'roo-cline',
     name:     'Roo-Cline',
-    cfgPath:  path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'mcp_settings.json'),
-    detect:   () => fs.existsSync(path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline')),
+    cfgPath:  _rooClinePath(),
+    detect:   () => fs.existsSync(path.dirname(_rooClinePath())),
   },
   {
     id:       'zed',
@@ -114,12 +186,25 @@ const CLIENTS = [
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 function _appExists(name) {
-  return fs.existsSync(`/Applications/${name}.app`) ||
-         fs.existsSync(path.join(HOME, `Applications/${name}.app`))
+  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) {
-  try { execSync(`which ${cmd}`, { stdio: 'pipe' }); return true } catch { return false }
+  const which = _IS_WIN ? 'where' : 'which'
+  try { execSync(`${which} ${cmd}`, { stdio: 'pipe' }); return true } catch { return false }
 }
 
 // ── Safe config read ─────────────────────────────────────────────────────────
@@ -185,6 +270,11 @@ function _atomicWriteConfig(filePath, data) {
 // Never overwrites a file whose JSON cannot be parsed.
 
 function injectMcpConfig(client, command = NPX_COMMAND, args = NPX_ARGS) {
+  // 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']
+  }
   // 1. Read existing config safely
   const read = _safeReadConfig(client.cfgPath)
   if (read.hadParseError) {
@@ -217,7 +307,14 @@ function injectMcpConfig(client, command = NPX_COMMAND, args = NPX_ARGS) {
   }
 
   // 3. Atomic write + verify
-  const write = _atomicWriteConfig(client.cfgPath, cfg)
+  // On Windows, Claude Desktop MSIX reads from a different path than the .exe install.
+  // Write to all known paths so both install types work.
+  const allPaths = (client.id === 'claude-desktop' && _IS_WIN) ? _claudeDesktopAllPaths() : [client.cfgPath]
+  let write = { ok: false, error: 'no paths' }
+  for (const p of allPaths) {
+    fs.mkdirSync(path.dirname(p), { recursive: true })
+    write = _atomicWriteConfig(p, cfg)
+  }
   return {
     ok:              write.ok,
     stage:           write.ok ? 'config_write' : 'config_write_failed',
@@ -262,7 +359,7 @@ async function runSetup(opts = {}) {
   if (nodeMajor < 16) {
     console.error(`\n⚠️  Warning: you're running Node ${process.version}.`)
     console.error('   Claude Desktop may fail to start LMCP because it finds an old npx on its PATH.')
-    console.error('   Fix: nvm alias default 22  (then relaunch Claude Desktop)\n')
+    console.error(`   Fix: nvm alias default 22 && nvm uninstall ${process.version}  (then relaunch Claude Desktop)\n`)
   }
 
   // Pre-download binary so first launch is instant
@@ -494,7 +591,7 @@ async function runSetup(opts = {}) {
       console.log('┌─────────────────────────────────────────────────────┐')
       console.log('│  CURSOR — activate in 3 steps:                      │')
       console.log('│                                                     │')
-      console.log('│  1. Quit Cursor completely (Cmd+Q)                  │')
+      console.log(`│  1. Quit Cursor completely (${_IS_WIN ? 'Alt+F4' : 'Cmd+Q'})${_IS_WIN ? '                ' : '                  '}│`)
       console.log('│  2. Reopen Cursor                                   │')
       console.log('│  3. Cursor Settings (⚙) → MCP → find "local-mcp"   │')
       console.log('│     → toggle it ON                                  │')
@@ -511,7 +608,8 @@ async function runSetup(opts = {}) {
       console.log('┌─────────────────────────────────────────────────────┐')
       console.log('│  NEXT STEP — restart to activate:                   │')
       console.log('│                                                     │')
-      console.log(`│  1. Quit ${primaryClient} completely (Cmd+Q)${''.padEnd(Math.max(0, 30 - primaryClient.length))}│`)
+      const quitKey = _IS_WIN ? 'Alt+F4' : 'Cmd+Q'
+      console.log(`│  1. Quit ${primaryClient} completely (${quitKey})${''.padEnd(Math.max(0, 28 - primaryClient.length - quitKey.length))}│`)
       console.log(`│  2. Reopen ${primaryClient.padEnd(41)}│`)
       console.log('│                                                     │')
       console.log('│  Then try: "Summarize my unread emails"             │')
@@ -592,15 +690,14 @@ async function _installSlackProxy() {
 }
 
 async function _installTray() {
+  // Tray is macOS-only — skip on Windows/Linux
+  if (_IS_WIN || process.platform === 'linux') return
   try {
     const { ensureTray } = require('./download')
     const trayApp = await ensureTray()
     if (!trayApp) return  // x64 — skip silencioso
     console.log('\n✓ Tray installed — look for the LMCP icon in your menu bar\n')
-    // ensureTray() ya escribió el LaunchAgent y lo cargó con RunAtLoad=true
-    // No hace falta llamar open() por separado
   } catch (err) {
-    // No fatal — el servidor MCP funciona igual sin el tray
     process.stderr.write(`  (Tray not available: ${err.message})\n\n`)
   }
 }