local-mcp 1.2.0

package/README.md

@@ -0,0 +1,126 @@
+# local-mcp
+
+> MCP server for macOS — connect Claude Desktop, Cursor, Windsurf, VS Code and Zed to Mail, Calendar, Contacts, Teams, OneDrive, OmniFocus, Reminders, Notes, Messages, Stocks and more.
+
+[![npm](https://img.shields.io/npm/v/local-mcp)](https://www.npmjs.com/package/local-mcp)
+[![platform](https://img.shields.io/badge/platform-macOS-blue)](https://local-mcp.com?utm_source=npm)
+
+**All data stays on your Mac.** No cloud. No tokens. No API keys.
+
+## Install
+
+```bash
+npx -y local-mcp@latest setup
+```
+
+Auto-detects and configures Claude Desktop, Cursor, Windsurf, VS Code, and Zed. Restart your AI client once.
+
+## Or add directly to your MCP config
+
+```json
+{
+  "mcpServers": {
+    "local-mcp": {
+      "command": "npx",
+      "args": ["-y", "local-mcp@latest"]
+    }
+  }
+}
+```
+
+## What it does
+
+Local MCP runs a native MCP server that bridges your Mac apps to any AI client:
+
+| Service | Capabilities |
+|---------|-------------|
+| **Mail** | Read, search, send, reply — Gmail, Outlook, iCloud, Exchange |
+| **Calendar** | List, create, delete events across all accounts |
+| **Contacts** | Search and list from Contacts.app |
+| **Teams** | Read chats, channels, messages (no tokens needed) |
+| **OneDrive** | List, read, write, search, move, delete files |
+| **Documents** | Word, Excel, PowerPoint, PDF |
+| **Outlook** | Read, search, send emails, list/create calendar events (direct Outlook.app access) |
+| **Reminders & To Do** | List, create, complete — includes Microsoft To Do via sync |
+| **OmniFocus** | List tasks, projects, tags — create and complete tasks |
+| **Notes** | List, read, search, create notes |
+| **Messages** | List chats, read and search iMessages |
+| **Stocks** | Real-time quotes, historical charts, symbol search |
+| **Finder** | Search and list files |
+| **Safari** | List bookmarks |
+
+## 82 MCP Tools
+
+Email: `list_accounts` `list_emails` `read_email` `send_email` `reply_email` `search_emails` `move_email` `save_attachment` `create_email_folder`
+
+Calendar: `list_calendar_names` `list_calendar_events` `create_calendar_event` `delete_calendar_event`
+
+Contacts: `list_contacts`
+
+Teams: `teams_list_teams` `teams_list_channels` `teams_list_chats` `teams_read_channel_messages` `teams_read_chat_messages`
+
+OneDrive: `onedrive_root` `onedrive_list_files` `onedrive_read_file` `onedrive_write_file` `onedrive_move_file` `onedrive_delete_file` `onedrive_search_files`
+
+Documents: `word_create` `word_read` `word_append` `excel_create` `excel_read` `excel_write_cell` `ppt_create` `ppt_read` `pdf_read`
+
+Outlook: `outlook_list_emails` `outlook_read_email` `outlook_search_emails` `outlook_send_email` `outlook_list_events` `outlook_create_event`
+
+Reminders & To Do: `todo_list_lists` `todo_list_tasks` `todo_create_task` `todo_complete_task`
+
+OmniFocus: `list_omnifocus_tasks` `list_omnifocus_projects` `list_omnifocus_tags` `search_omnifocus_tasks` `create_omnifocus_task` `complete_omnifocus_task`
+
+Notes: `list_notes` `read_note` `search_notes` `create_note`
+
+Messages: `list_message_chats` `read_messages` `search_messages`
+
+Stocks: `stocks_get_quote` `stocks_get_chart` `stocks_search_symbol`
+
+Finder: `finder_search` `finder_list`
+
+Safari: `list_safari_bookmarks`
+
+Utilities: `diagnose` `version_info` `report_bug` `request_feature` `send_logs` `lmcp_help` `list_my_feedback` `close_feedback`
+
+## Safety
+
+- Email send/reply always shows a preview before sending — you confirm first
+- Calendar events require explicit calendar name — never creates in the wrong one
+- All destructive operations require confirmation
+
+## Requirements
+
+- macOS 12 Monterey or later (Apple Silicon and Intel)
+- Node.js 18+
+- One of: Claude Desktop, Cursor, Windsurf, VS Code, Zed
+
+## Config file locations
+
+| Client | Path |
+|--------|------|
+| Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| Cursor | `~/.cursor/mcp.json` |
+| Windsurf | `~/.codeium/windsurf/mcp_config.json` |
+| VS Code | `~/.vscode/mcp.json` |
+| Zed | `~/.config/zed/settings.json` |
+
+## Commands
+
+```bash
+npx -y local-mcp@latest setup     # configure all detected AI clients
+npx -y local-mcp@latest update    # force re-download of the runtime
+npx -y local-mcp@latest status    # show server status
+```
+
+## Full app (optional)
+
+For the menu bar status icon, auto-start on login, and Cloud Relay:
+
+```bash
+curl -fsSL https://local-mcp.com/install | bash
+```
+
+## Links
+
+- [Website](https://local-mcp.com?utm_source=npm)
+- [Pricing](https://local-mcp.com/#pricing?utm_source=npm)
+- Support: support@local-mcp.com

package/download.js

@@ -0,0 +1,314 @@
+'use strict'
+/**
+ * download.js — descarga y cachea el binario standalone de Local MCP desde R2.
+ * El binario fue compilado con PyInstaller — no requiere Python instalado.
+ * Cache: ~/.local/share/local-mcp/bin/{version}/
+ */
+
+const https  = require('https')
+const http   = require('http')
+const fs     = require('fs')
+const path   = require('path')
+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
+const TRAY_APP    = '/Applications/LocalMCPTray.app'
+
+function _getMachineId() {
+  const { execSync } = require('child_process')
+  const crypto = require('crypto')
+  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*"([^"]+)"/)
+    const hwUuid = match ? match[1] : os.hostname()
+    return crypto.createHash('sha256').update(hwUuid).digest('hex').slice(0, 24)
+  } catch {}
+  return ''
+}
+
+function getArch() {
+  const arch = process.arch
+  if (arch === 'arm64') return 'darwin-arm64'
+  if (arch === 'x64')   return 'darwin-x64'
+  throw new Error(`Arquitectura no soportada: ${arch}. Local MCP requiere macOS arm64 o x64.`)
+}
+
+/**
+ * Obtiene la versión más reciente del binario desde el backend.
+ * Si esta máquina está en beta_machines, el backend retorna la versión beta.
+ */
+async function getLatestBinary() {
+  const machineId = _getMachineId()
+  const qs = machineId ? `?machine_id=${encodeURIComponent(machineId)}` : ''
+  return new Promise((resolve, reject) => {
+    const req = https.get(`${BACKEND_URL}/runtime/latest${qs}`, { timeout: 10000 }, (res) => {
+      let data = ''
+      res.on('data', chunk => data += chunk)
+      res.on('end', () => {
+        try {
+          const info = JSON.parse(data)
+          resolve(info)
+        } catch (e) {
+          reject(new Error(`Respuesta inválida de /runtime/latest: ${data}`))
+        }
+      })
+    })
+    req.on('error', reject)
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout al consultar versión')) })
+  })
+}
+
+/**
+ * Descarga un archivo con barra de progreso.
+ */
+async function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath)
+    const proto = url.startsWith('https') ? https : http
+
+    const request = (reqUrl) => {
+      proto.get(reqUrl, { timeout: 300000 }, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          file.close()
+          return request(res.headers.location)
+        }
+        if (res.statusCode !== 200) {
+          file.close()
+          fs.unlinkSync(destPath)
+          return reject(new Error(`HTTP ${res.statusCode} descargando binario`))
+        }
+
+        const total = parseInt(res.headers['content-length'] || '0', 10)
+        let downloaded = 0
+        let lastPct = -1
+
+        res.on('data', chunk => {
+          downloaded += chunk.length
+          if (total > 0) {
+            const pct = Math.floor(downloaded / total * 100)
+            if (pct !== lastPct && pct % 10 === 0) {
+              process.stderr.write(`\r  Descargando... ${pct}%`)
+              lastPct = pct
+            }
+          }
+        })
+
+        res.pipe(file)
+        file.on('finish', () => { file.close(); process.stderr.write('\n'); resolve() })
+        file.on('error', (err) => { fs.unlinkSync(destPath); reject(err) })
+      }).on('error', reject)
+    }
+
+    request(url)
+  })
+}
+
+/**
+ * Asegura que el binario esté descargado y listo.
+ * @returns {Promise<{binPath: string}>}
+ */
+async function ensureBinary() {
+  const arch   = getArch()
+  const info   = await getLatestBinary()
+  const version = info.version
+  // URL del binario PyInstaller (nueva nomenclatura)
+  const url = `https://download.local-mcp.com/local-mcp-server-${version}-${arch}.tar.gz`
+
+  const versionDir = path.join(CACHE_DIR, version)
+  const binPath    = path.join(versionDir, 'local-mcp-server', 'local-mcp-server')
+
+  // Ya está en cache
+  if (fs.existsSync(binPath)) {
+    return { binPath, versionDir }
+  }
+
+  process.stderr.write(`\nLocal MCP v${version} no encontrado en cache.\n`)
+  process.stderr.write(`Descargando desde ${url}\n`)
+
+  fs.mkdirSync(versionDir, { recursive: true })
+  const tarPath = path.join(versionDir, `server-${version}.tar.gz`)
+
+  await downloadFile(url, tarPath)
+
+  process.stderr.write(`  Extrayendo...\n`)
+  execFileSync('tar', ['-xzf', tarPath, '-C', versionDir], { stdio: 'pipe' })
+  fs.unlinkSync(tarPath)
+
+  if (!fs.existsSync(binPath)) {
+    throw new Error(`Binario no encontrado después de extraer: ${binPath}`)
+  }
+
+  // Asegurar que sea ejecutable
+  fs.chmodSync(binPath, 0o755)
+
+  // Re-firmar ad-hoc con bundle identifier estable.
+  // --identifier da al binario una identidad TCC persistente aunque cambie la ruta de versión.
+  // Sin esto, macOS atribuye los permisos TCC al proceso padre (node) → diálogo cada reinicio.
+  try {
+    execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.server', binPath], { stdio: 'pipe' })
+  } catch { /* no crítico */ }
+
+  process.stderr.write(`  Listo en ${versionDir}\n`)
+  return { binPath, versionDir }
+}
+
+// Mantener compatibilidad con código que usa ensureRuntime
+async function ensureRuntime() {
+  const { binPath, versionDir } = await ensureBinary()
+  return { pythonBin: binPath, serverPath: binPath, runtimeDir: versionDir, binPath }
+}
+
+/**
+ * Descarga el co-proceso teams-proxy si no está instalado o es una versión diferente.
+ * El binary se instala en ~/.local/share/local-mcp/bin/teams-proxy
+ * @returns {Promise<string|null>} Ruta al binary, o null si falla
+ */
+async function ensureTeamsProxy() {
+  const info = await getLatestBinary()
+  const version = info.version
+  const arch = process.arch === 'arm64' ? 'darwin-arm64' : 'darwin-x64'
+  const binPath = path.join(CACHE_DIR, 'teams-proxy')
+  const verFile = path.join(CACHE_DIR, '.teams-proxy-version')
+
+  // Ya instalado y actualizado
+  if (fs.existsSync(binPath) && fs.existsSync(verFile)) {
+    if (fs.readFileSync(verFile, 'utf8').trim() === version) return binPath
+  }
+
+  const url = `https://download.local-mcp.com/teams-proxy-${version}-${arch}.tar.gz`
+  process.stderr.write(`\nDescargando teams-proxy v${version}...\n`)
+
+  fs.mkdirSync(CACHE_DIR, { recursive: true })
+  const tarPath = path.join(CACHE_DIR, `teams-proxy-${version}.tar.gz`)
+
+  try {
+    await downloadFile(url, tarPath)
+    const stat = fs.statSync(tarPath)
+    if (stat.size < 1000) { fs.unlinkSync(tarPath); throw new Error(`Descarga incompleta (${stat.size} bytes)`) }
+
+    execFileSync('tar', ['-xzf', tarPath, '-C', CACHE_DIR], { stdio: 'pipe' })
+    fs.unlinkSync(tarPath)
+
+    if (!fs.existsSync(binPath)) throw new Error('teams-proxy no encontrado tras extraer')
+    fs.chmodSync(binPath, 0o755)
+    try { execFileSync('codesign', ['--force', '--sign', '-', '--identifier', 'com.local-mcp.teams-proxy', binPath], { stdio: 'pipe' }) } catch { /* no crítico */ }
+
+    fs.writeFileSync(verFile, version, 'utf8')
+    process.stderr.write(`  teams-proxy instalado en ${binPath}\n`)
+    return binPath
+  } catch (err) {
+    try { if (fs.existsSync(tarPath)) fs.unlinkSync(tarPath) } catch {}
+    process.stderr.write(`  (teams-proxy no disponible: ${err.message})\n`)
+    return null
+  }
+}
+
+/**
+ * Descarga e instala el tray SwiftUI (menu bar app) — universal binary (arm64 + Intel).
+ * @returns {Promise<string|null>} Ruta al .app instalado, o null si falla
+ */
+async function ensureTray() {
+
+  const info     = await getLatestBinary()
+  const version  = info.version
+  const trayApp  = TRAY_APP
+  const verFile  = path.join(TRAY_DIR, '.version')
+
+  // Migrar instalación vieja de ~/.local/share si existe
+  const oldTrayApp = path.join(TRAY_DIR, 'LocalMCPTray.app')
+  if (fs.existsSync(oldTrayApp)) {
+    try { execFileSync('rm', ['-rf', oldTrayApp], { stdio: 'pipe' }) } catch { /* ignorar */ }
+  }
+
+  // Ya instalado y actualizado
+  if (fs.existsSync(trayApp) && fs.existsSync(verFile)) {
+    if (fs.readFileSync(verFile, 'utf8').trim() === version) return trayApp
+  }
+
+  const url = `https://download.local-mcp.com/local-mcp-tray-${version}-darwin-universal.tar.gz`
+  process.stderr.write(`\nDescargando tray v${version}...\n`)
+
+  fs.mkdirSync(TRAY_DIR, { recursive: true })
+  const tarPath = path.join(TRAY_DIR, `tray-${version}.tar.gz`)
+
+  // Descargar ANTES de borrar el viejo — si la descarga falla, el tray actual sigue intacto
+  await downloadFile(url, tarPath)
+
+  // Verificar que el archivo descargado no está vacío
+  const tarStat = fs.statSync(tarPath)
+  if (tarStat.size < 10000) {
+    fs.unlinkSync(tarPath)
+    throw new Error(`Descarga del tray incompleta (${tarStat.size} bytes)`)
+  }
+
+  // Recién ahora borrar el viejo e instalar el nuevo
+  if (fs.existsSync(trayApp)) {
+    try { execFileSync('rm', ['-rf', trayApp], { stdio: 'pipe' }) } catch { /* ignorar */ }
+  }
+
+  process.stderr.write(`  Instalando tray en /Applications...\n`)
+  execFileSync('tar', ['-xzf', tarPath, '-C', '/Applications'], { stdio: 'pipe' })
+  fs.unlinkSync(tarPath)
+
+  if (!fs.existsSync(trayApp)) {
+    throw new Error(`Tray no encontrado tras extraer: ${trayApp}`)
+  }
+
+  // Quitar quarantine + firmar ad-hoc
+  try { execFileSync('xattr', ['-rd', 'com.apple.quarantine', trayApp], { stdio: 'pipe' }) } catch { /* no crítico */ }
+  const trayBin = path.join(trayApp, 'Contents', 'MacOS', 'LocalMCPTray')
+  try { execFileSync('codesign', ['--force', '--sign', '-', trayBin], { stdio: 'pipe' }) } catch { /* no crítico */ }
+
+  fs.writeFileSync(verFile, version, 'utf8')
+
+  // LaunchAgent — auto-start en cada reboot de sesión
+  _writeTrayLaunchAgent(trayApp)
+
+  process.stderr.write(`  Tray instalado en ${trayApp}\n`)
+  return trayApp
+}
+
+function _writeTrayLaunchAgent(trayApp) {
+  const trayBin  = path.join(trayApp, 'Contents', 'MacOS', 'LocalMCPTray')
+  const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents')
+  const plistPath = path.join(plistDir, 'com.local-mcp.tray.plist')
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.local-mcp.tray</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${trayBin}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <false/>
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+</dict>
+</plist>
+`
+  try {
+    fs.mkdirSync(plistDir, { recursive: true })
+    fs.writeFileSync(plistPath, plist, 'utf8')
+    // Matar proceso viejo (si estaba corriendo por cualquier medio)
+    try { execFileSync('pkill', ['-x', 'LocalMCPTray'], { stdio: 'pipe' }) } catch { /* no estaba corriendo */ }
+    // Recargar LaunchAgent
+    try { execFileSync('launchctl', ['unload', plistPath], { stdio: 'pipe' }) } catch {}
+    execFileSync('launchctl', ['load', plistPath], { stdio: 'pipe' })
+    // launchctl load con RunAtLoad=true arranca el proceso — no necesitamos open()
+  } catch { /* no crítico */ }
+}
+
+module.exports = { ensureBinary, ensureRuntime, ensureTray, ensureTeamsProxy, CACHE_DIR, TRAY_DIR }

package/index.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+'use strict'
+/**
+ * index.js — entry point del paquete npm local-mcp.
+ *
+ * Modos:
+ *   npx local-mcp              → lanza MCP server en stdio (para Claude Desktop, Cursor, etc.)
+ *   npx local-mcp setup        → wizard de configuración de clientes
+ *   npx local-mcp update       → fuerza re-descarga del runtime
+ *   npx local-mcp uninstall    → elimina cache del runtime
+ *   npx local-mcp status       → muestra estado del servidor local
+ */
+
+const { spawn } = require('child_process')
+const path  = require('path')
+const os    = require('os')
+const fs    = require('fs')
+
+// Solo macOS
+if (process.platform !== 'darwin') {
+  console.error('Local MCP solo está disponible para macOS.')
+  process.exit(1)
+}
+
+const cmd = process.argv[2]
+
+async function main() {
+  if (cmd === 'setup') {
+    const { runSetup } = require('./setup')
+    await runSetup()
+    return
+  }
+
+  if (cmd === 'update') {
+    const { CACHE_DIR } = require('./download')
+    const fs = require('fs')
+    if (fs.existsSync(CACHE_DIR)) {
+      fs.rmSync(CACHE_DIR, { recursive: true, force: true })
+      console.log('Cache del runtime eliminado.')
+    }
+    // Re-descargar en el próximo arranque
+    console.log('Ejecutá "npx local-mcp" nuevamente para descargar la última versión.')
+    return
+  }
+
+  if (cmd === 'uninstall') {
+    const { CACHE_DIR } = require('./download')
+    const fs = require('fs')
+    if (fs.existsSync(CACHE_DIR)) {
+      fs.rmSync(CACHE_DIR, { recursive: true, force: true })
+      console.log(`Runtime eliminado de ${CACHE_DIR}`)
+    } else {
+      console.log('No hay runtime en cache.')
+    }
+    return
+  }
+
+  if (cmd === 'status') {
+    const http = require('http')
+    http.get('http://localhost:8765/status', (res) => {
+      let data = ''
+      res.on('data', c => data += c)
+      res.on('end', () => {
+        try {
+          const s = JSON.parse(data)
+          console.log(`Local MCP 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'))
+    return
+  }
+
+  // Modo default: stdio MCP server
+  const { ensureRuntime, ensureTray } = require('./download')
+
+  // Actualizar tray en background en cada startup (sin bloquear el arranque del servidor)
+  ensureTray().catch(() => { /* no crítico */ })
+
+  let runtime
+  try {
+    runtime = await ensureRuntime()
+  } catch (err) {
+    process.stderr.write(`\nError al preparar el runtime de Local MCP:\n${err.message}\n`)
+    process.stderr.write(`Intentá reinstalar: npx local-mcp update\n\n`)
+    process.exit(1)
+  }
+
+  const { binPath } = runtime
+
+  // ── Symlink estable + migración de config de Claude Desktop ──────────────────
+  // El binario corre como hijo de node → TCC muestra "node" en los diálogos de
+  // permisos (Messages, Mail, etc.) en lugar de "local-mcp-server".
+  // Solución: crear un symlink estable y apuntar Claude Desktop directamente
+  // al binario. En la próxima sesión, Claude Desktop llama al binario sin node
+  // como padre → TCC ve "com.local-mcp.server" directamente.
+  const { CACHE_DIR } = require('./download')
+  const stableLink = path.join(CACHE_DIR, 'local-mcp-server')
+  try {
+    if (fs.existsSync(stableLink)) fs.unlinkSync(stableLink)
+    fs.symlinkSync(binPath, stableLink)
+
+    // Migrar claude_desktop_config.json si todavía usa npx
+    const claudeConfig = path.join(
+      os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'
+    )
+    if (fs.existsSync(claudeConfig)) {
+      const cfg = JSON.parse(fs.readFileSync(claudeConfig, 'utf8'))
+      const srv = cfg.mcpServers?.['local-mcp']
+      if (srv && srv.command === 'npx') {
+        cfg.mcpServers['local-mcp'] = { command: stableLink }
+        fs.writeFileSync(claudeConfig, JSON.stringify(cfg, null, 2))
+        process.stderr.write(`\n✓ Config de Claude Desktop actualizado.\n`)
+        process.stderr.write(`  Reiniciá Claude Desktop para que Local MCP corra sin node como padre.\n`)
+        process.stderr.write(`  (Esto elimina los diálogos de permisos repetidos.)\n\n`)
+      }
+    }
+  } catch { /* no crítico — seguimos con spawn normal */ }
+
+  // Spawn para esta sesión (siguiente sesión ya será binario directo)
+  const child = spawn(binPath, [], {
+    stdio: 'inherit',
+    env: process.env,
+  })
+
+  child.on('error', (err) => {
+    process.stderr.write(`Error ejecutando Local MCP: ${err.message}\n`)
+    process.exit(1)
+  })
+
+  child.on('exit', (code) => {
+    process.exit(code ?? 0)
+  })
+}
+
+main().catch(err => {
+  process.stderr.write(`Error fatal: ${err.message}\n`)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "local-mcp",
+  "version": "1.2.0",
+  "description": "MCP server for macOS — connect Claude Desktop, Cursor, Windsurf to Mail, Calendar, Contacts, Teams, OneDrive. Privacy-first: all data stays on your Mac.",
+  "main": "index.js",
+  "bin": {
+    "local-mcp": "index.js"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "files": [
+    "index.js",
+    "download.js",
+    "setup.js",
+    "postinstall.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "claude",
+    "claude-desktop",
+    "cursor",
+    "windsurf",
+    "vscode",
+    "zed",
+    "ai",
+    "ai-agent",
+    "ai-tools",
+    "macos",
+    "mac",
+    "apple",
+    "mail",
+    "email",
+    "gmail",
+    "outlook",
+    "exchange",
+    "icloud",
+    "calendar",
+    "contacts",
+    "teams",
+    "microsoft-teams",
+    "onedrive",
+    "word",
+    "excel",
+    "powerpoint",
+    "pdf",
+    "local",
+    "privacy",
+    "offline",
+    "no-cloud",
+    "productivity",
+    "automation"
+  ],
+  "author": "Local MCP <hello@local-mcp.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://local-mcp.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lanchuske/local-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lanchuske/local-mcp/issues"
+  },
+  "mcpName": "io.github.lanchuske/local-mcp"
+}

package/postinstall.js

@@ -0,0 +1,23 @@
+'use strict'
+/**
+ * postinstall.js — se ejecuta automáticamente después de `npm install -g local-mcp`.
+ * No corre cuando se usa npx (npm_config_global no está seteado).
+ */
+
+// Skip si: npx (no global), CI, o el usuario lo desactivó
+if (!process.env.npm_config_global || process.env.CI || process.env.SKIP_SETUP) {
+  process.exit(0)
+}
+
+// Solo macOS
+if (process.platform !== 'darwin') {
+  process.exit(0)
+}
+
+const { runSetup } = require('./setup')
+
+runSetup({ all: true }).catch(err => {
+  process.stderr.write(`\nSetup failed: ${err.message}\n`)
+  process.stderr.write('Run manually: npx -y local-mcp@latest setup\n\n')
+  process.exit(0)
+})

package/setup.js

@@ -0,0 +1,252 @@
+'use strict'
+/**
+ * setup.js — wizard de configuración de clientes MCP.
+ * Detecta clientes instalados y escribe la config npx automáticamente.
+ *
+ * Uso:
+ *   local-mcp setup          → configura todos los clientes detectados
+ *   local-mcp setup --all    → configura todos sin preguntar
+ */
+
+const fs   = require('fs')
+const path = require('path')
+const os   = require('os')
+const { execSync, execFileSync } = require('child_process')
+
+const HOME = os.homedir()
+const NPX_COMMAND = 'npx'
+const NPX_ARGS    = ['-y', 'local-mcp@latest']
+
+// ── Rutas de config de cada cliente ──────────────────────────────────────────
+
+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')),
+  },
+  {
+    id:       'cursor',
+    name:     'Cursor',
+    cfgPath:  path.join(HOME, '.cursor', 'mcp.json'),
+    detect:   () => fs.existsSync(path.join(HOME, '.cursor')) || _appExists('Cursor'),
+  },
+  {
+    id:       'windsurf',
+    name:     'Windsurf',
+    cfgPath:  path.join(HOME, '.codeium', 'windsurf', 'mcp_config.json'),
+    detect:   () => fs.existsSync(path.join(HOME, '.codeium', 'windsurf')) || _appExists('Windsurf'),
+  },
+  {
+    id:       'vscode-cline',
+    name:     'VS Code (Cline)',
+    cfgPath:  path.join(HOME, '.vscode', 'mcp.json'),
+    detect:   () => _cmdExists('code') || fs.existsSync(path.join(HOME, '.vscode')),
+  },
+  {
+    id:       'zed',
+    name:     'Zed',
+    cfgPath:  path.join(HOME, '.config', 'zed', 'settings.json'),
+    detect:   () => fs.existsSync(path.join(HOME, '.config', 'zed')) || _appExists('Zed'),
+    zed:      true,  // Zed usa formato diferente dentro de settings.json
+  },
+]
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function _appExists(name) {
+  return fs.existsSync(`/Applications/${name}.app`) ||
+         fs.existsSync(path.join(HOME, `Applications/${name}.app`))
+}
+
+function _cmdExists(cmd) {
+  try { execSync(`which ${cmd}`, { stdio: 'pipe' }); return true } catch { return false }
+}
+
+function _readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function _writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8')
+}
+
+// ── Inyectar config MCP en un cliente estándar ────────────────────────────────
+
+function injectMcpConfig(client) {
+  const cfg = _readJson(client.cfgPath)
+
+  if (client.zed) {
+    // Zed usa { "context_servers": { "local-mcp": { "command": {...} } } }
+    cfg.context_servers = cfg.context_servers || {}
+    cfg.context_servers['local-mcp'] = {
+      command: { path: NPX_COMMAND, args: NPX_ARGS },
+    }
+  } else {
+    // Formato estándar MCP: { "mcpServers": { "local-mcp": { "command": "npx", "args": [...] } } }
+    cfg.mcpServers = cfg.mcpServers || {}
+    // Limpiar entradas legacy
+    delete cfg.mcpServers['office-mcp']
+    cfg.mcpServers['local-mcp'] = {
+      command: NPX_COMMAND,
+      args:    NPX_ARGS,
+    }
+  }
+
+  _writeJson(client.cfgPath, cfg)
+  return true
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+async function runSetup(opts = {}) {
+  const forceAll = opts.all || process.argv.includes('--all')
+
+  console.log('\n╔══════════════════════════════════════╗')
+  console.log('║     Local MCP — Setup Wizard         ║')
+  console.log('╚══════════════════════════════════════╝\n')
+
+  // Detectar clientes
+  const detected = CLIENTS.filter(c => c.detect())
+
+  if (detected.length === 0) {
+    console.log('No AI clients detected.')
+    console.log('Install Claude Desktop, Cursor, Windsurf, or VS Code and run this command again.\n')
+    console.log('Or add this manually to your AI client config:')
+    console.log(JSON.stringify({ mcpServers: { 'local-mcp': { command: NPX_COMMAND, args: NPX_ARGS } } }, null, 2))
+    return
+  }
+
+  console.log(`Detected: ${detected.map(c => c.name).join(', ')}\n`)
+
+  const configured = []
+  const failed     = []
+
+  for (const client of detected) {
+    try {
+      injectMcpConfig(client)
+      configured.push(client.name)
+      console.log(`✓ ${client.name} configured`)
+    } catch (err) {
+      failed.push(client.name)
+      console.error(`✗ ${client.name}: ${err.message}`)
+    }
+  }
+
+  // Escribir email al config si viene por env
+  const email = process.env.LMCP_EMAIL || ''
+  if (email) {
+    const cfgDir  = path.join(HOME, 'Library', 'Application Support', 'Local MCP')
+    const cfgFile = path.join(cfgDir, 'config.json')
+    try {
+      const cfg = _readJson(cfgFile)
+      if (!cfg.license_email) {
+        cfg.license_email = email
+        _writeJson(cfgFile, cfg)
+        console.log(`✓ Email saved: ${email}`)
+      }
+    } catch { /* config not created yet — will be created on first run */ }
+  }
+
+  console.log('\n──────────────────────────────────────')
+  if (configured.length > 0) {
+    console.log(`✅ Local MCP configured for: ${configured.join(', ')}\n`)
+    console.log('┌─────────────────────────────────────────────────────┐')
+    console.log('│  NEXT STEP — This is important:                     │')
+    console.log('│                                                     │')
+    console.log(`│  Quit and reopen ${configured[0].padEnd(35)}│`)
+    console.log('│  Local MCP will appear automatically.               │')
+    console.log('│                                                     │')
+    console.log('│  Then try: "Summarize my unread emails"             │')
+    console.log('└─────────────────────────────────────────────────────┘\n')
+  }
+  if (failed.length > 0) {
+    console.log(`⚠  Could not configure: ${failed.join(', ')} — check permissions and try again.\n`)
+  }
+
+  // Instalar y lanzar el tray (menu bar app) — arm64 only, non-fatal
+  await _installTray()
+  await _installTeamsProxy()
+
+  // Ping de tracking (fire-and-forget, no bloquea)
+  _pingInstall(configured, opts.method || 'setup')
+}
+
+async function _installTeamsProxy() {
+  try {
+    const { ensureTeamsProxy } = require('./download')
+    await ensureTeamsProxy()
+  } catch (err) {
+    process.stderr.write(`  (teams-proxy not available: ${err.message})\n`)
+  }
+}
+
+async function _installTray() {
+  try {
+    const { ensureTray } = require('./download')
+    const trayApp = await ensureTray()
+    if (!trayApp) return  // x64 — skip silencioso
+    console.log('\n✓ Tray installed — look for the Local MCP 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`)
+  }
+}
+
+function _getMachineId() {
+  try {
+    // Try reading from macOS Keychain (same as server.py)
+    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 {
+    // Generate from hardware UUID
+    const crypto = require('crypto')
+    const ioreg = execSync('ioreg -rd1 -c IOPlatformExpertDevice', { stdio: 'pipe' }).toString()
+    const match = ioreg.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)
+    const hwUuid = match ? match[1] : require('os').hostname()
+    const id = crypto.createHash('sha256').update(hwUuid).digest('hex').slice(0, 24)
+    // Save to Keychain
+    try { execSync(`security add-generic-password -s com.local-mcp.machine-id -a machine-id -w ${id} -U 2>/dev/null`, { stdio: 'pipe' }) } catch {}
+    return id
+  } catch {}
+  return ''
+}
+
+function _pingInstall(clients, method) {
+  try {
+    const https = require('https')
+    const pkg    = require('./package.json')
+    const data = JSON.stringify({
+      version: pkg.version,
+      os_version: require('os').release(),
+      arch: process.arch,
+      node_version: process.version,
+      method: method,
+      clients_configured: clients,
+      machine_id: _getMachineId(),
+      source: process.env.LMCP_SOURCE || '',
+    })
+    const req = https.request({
+      hostname: 'office-mcp-production.up.railway.app',
+      path: '/install/npm',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': data.length },
+      timeout: 5000,
+    })
+    req.on('error', () => {})  // silencioso
+    req.write(data)
+    req.end()
+  } catch { /* no bloquear */ }
+}
+
+module.exports = { runSetup, injectMcpConfig, CLIENTS }