local-mcp 1.44.0

package/download.js

@@ -0,0 +1,155 @@
+'use strict'
+/**
+ * download.js — descarga y cachea el runtime Python de Local MCP desde R2.
+ * Cache: ~/.local/share/local-mcp/runtime/{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', 'runtime')
+
+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 runtime desde el backend.
+ * @returns {Promise<{version: string, url: string, checksum: string}>}
+ */
+async function getLatestRuntime() {
+  return new Promise((resolve, reject) => {
+    const req = https.get(`${BACKEND_URL}/runtime/latest`, { timeout: 10000 }, (res) => {
+      let data = ''
+      res.on('data', chunk => data += chunk)
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data))
+        } 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 del runtime')) })
+  })
+}
+
+/**
+ * Descarga un archivo con seguimiento 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: 120000 }, (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 runtime`))
+        }
+
+        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 runtime... ${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 runtime Python esté descargado y listo.
+ * @returns {Promise<{pythonBin: string, serverPath: string, runtimeDir: string}>}
+ */
+async function ensureRuntime() {
+  const arch    = getArch()
+  const info    = await getLatestRuntime()
+  const version = info.version
+  const url     = info.url || `https://download.local-mcp.com/local-mcp-runtime-${version}-${arch}.tar.gz`
+
+  const versionDir = path.join(CACHE_DIR, version)
+  const pythonBin  = path.join(versionDir, 'bin', 'python3')
+  const serverPath = path.join(versionDir, 'server.py')
+
+  // Ya está en cache
+  if (fs.existsSync(pythonBin) && fs.existsSync(serverPath)) {
+    return { pythonBin, serverPath, runtimeDir: versionDir }
+  }
+
+  process.stderr.write(`\nLocal MCP runtime v${version} no encontrado en cache.\n`)
+  process.stderr.write(`Descargando desde ${url}\n`)
+
+  fs.mkdirSync(CACHE_DIR, { recursive: true })
+  const tarPath = path.join(CACHE_DIR, `runtime-${version}.tar.gz`)
+
+  await downloadFile(url, tarPath)
+
+  process.stderr.write(`  Extrayendo...\n`)
+  fs.mkdirSync(versionDir, { recursive: true })
+  execFileSync('tar', ['-xzf', tarPath, '-C', versionDir], { stdio: 'pipe' })
+  fs.unlinkSync(tarPath)
+
+  if (!fs.existsSync(pythonBin)) {
+    throw new Error(`Runtime extraído pero no se encontró ${pythonBin}`)
+  }
+
+  // Re-firmar con ad-hoc — macOS invalida signatures al copiar fuera del .app
+  process.stderr.write(`  Firmando binarios...\n`)
+  try {
+    const glob = require('child_process').execSync
+    // Firmar dylibs y el binario Python individualmente
+    const targets = [
+      path.join(versionDir, 'bin', 'python3'),
+      path.join(versionDir, 'Frameworks'),
+    ]
+    for (const target of targets) {
+      if (fs.existsSync(target)) {
+        execFileSync('find', [target, '-name', '*.dylib', '-exec',
+          'codesign', '--force', '--sign', '-', '{}', ';'], { stdio: 'pipe' })
+        if (fs.existsSync(path.join(versionDir, 'bin', 'python3'))) {
+          execFileSync('codesign', ['--force', '--sign', '-',
+            path.join(versionDir, 'bin', 'python3')], { stdio: 'pipe' })
+        }
+        break
+      }
+    }
+  } catch (e) {
+    process.stderr.write(`  Aviso: codesign falló — continuando...\n`)
+  }
+
+  process.stderr.write(`  Runtime listo en ${versionDir}\n`)
+  return { pythonBin, serverPath, runtimeDir: versionDir }
+}
+
+module.exports = { ensureRuntime, getLatestRuntime, CACHE_DIR }

package/index.js

@@ -0,0 +1,112 @@
+#!/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 { spawnSync } = require('child_process')
+const path  = require('path')
+const os    = require('os')
+
+// 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 } = require('./download')
+
+  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 { pythonBin, serverPath, runtimeDir } = runtime
+
+  // Frameworks bundleados (libssl, libcrypto, etc.)
+  const frameworksPath = path.join(runtimeDir, 'Frameworks')
+  const env = { ...process.env }
+  if (require('fs').existsSync(frameworksPath)) {
+    env.DYLD_FRAMEWORK_PATH = frameworksPath + (env.DYLD_FRAMEWORK_PATH ? ':' + env.DYLD_FRAMEWORK_PATH : '')
+    env.DYLD_LIBRARY_PATH   = frameworksPath + (env.DYLD_LIBRARY_PATH   ? ':' + env.DYLD_LIBRARY_PATH   : '')
+  }
+
+  const extraArgs = process.argv.slice(cmd ? 2 : 3)
+  const result = spawnSync(pythonBin, [serverPath, 'stdio', ...extraArgs], {
+    stdio: 'inherit',
+    env,
+  })
+
+  if (result.error) {
+    process.stderr.write(`Error ejecutando Local MCP: ${result.error.message}\n`)
+    process.exit(1)
+  }
+
+  process.exit(result.status ?? 0)
+}
+
+main().catch(err => {
+  process.stderr.write(`Error fatal: ${err.message}\n`)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "local-mcp",
+  "version": "1.44.0",
+  "description": "Connect Claude, Cursor, Windsurf and other AI agents to Mail, Calendar, Contacts, Teams and OneDrive on Mac — no cloud, no tokens",
+  "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",
+    "claude",
+    "cursor",
+    "windsurf",
+    "ai",
+    "macos",
+    "mail",
+    "calendar",
+    "contacts",
+    "teams",
+    "onedrive",
+    "local"
+  ],
+  "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"
+  }
+}

package/postinstall.js

@@ -0,0 +1,24 @@
+'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 => {
+  // No fallar la instalación si el setup falla
+  process.stderr.write(`\nAviso: setup automático falló: ${err.message}\n`)
+  process.stderr.write('Ejecutá "local-mcp setup" manualmente para configurar tus clientes.\n\n')
+  process.exit(0)
+})

package/setup.js

@@ -0,0 +1,172 @@
+'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 se detectaron clientes MCP instalados.')
+    console.log('Instalá Claude Desktop, Cursor, Windsurf o VS Code y ejecutá este comando nuevamente.\n')
+    console.log('Config manual (copiá en el archivo de config de tu cliente):')
+    console.log(JSON.stringify({ mcpServers: { 'local-mcp': { command: NPX_COMMAND, args: NPX_ARGS } } }, null, 2))
+    return
+  }
+
+  console.log(`Clientes detectados: ${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} configurado`)
+    } 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 guardado en config: ${email}`)
+      }
+    } catch { /* config no existe aún, se creará al arrancar */ }
+  }
+
+  console.log('\n──────────────────────────────────────')
+  if (configured.length > 0) {
+    console.log(`✅ Configurado: ${configured.join(', ')}`)
+    console.log('   Reiniciá tu cliente AI para cargar Local MCP.\n')
+  }
+  if (failed.length > 0) {
+    console.log(`⚠  Falló: ${failed.join(', ')} — revisá los permisos e intentá de nuevo.\n`)
+  }
+
+  console.log('Config MCP aplicada:')
+  console.log(JSON.stringify({ mcpServers: { 'local-mcp': { command: NPX_COMMAND, args: NPX_ARGS } } }, null, 2))
+  console.log('\nPara instalar la app completa con tray (opcional):')
+  console.log('  curl -fsSL https://local-mcp.com/install | bash\n')
+}
+
+module.exports = { runSetup, injectMcpConfig, CLIENTS }