local-mcp 1.44.5 → 1.44.6

package/download.js

@@ -1,7 +1,8 @@
 'use strict'
 /**
- * download.js — descarga y cachea el runtime Python de Local MCP desde R2.
- * Cache: ~/.local/share/local-mcp/runtime/{version}/
+ * 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')
@@ -12,7 +13,7 @@ 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')
+const CACHE_DIR   = path.join(os.homedir(), '.local', 'share', 'local-mcp', 'bin')
 
 function getArch() {
   const arch = process.arch
@@ -22,29 +23,29 @@ function getArch() {
 }
 
 /**
- * Obtiene la versión más reciente del runtime desde el backend.
- * @returns {Promise<{version: string, url: string, checksum: string}>}
+ * Obtiene la versión más reciente del binario desde el backend.
  */
-async function getLatestRuntime() {
+async function getLatestBinary() {
   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))
+          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 del runtime')) })
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout al consultar versión')) })
   })
 }
 
 /**
- * Descarga un archivo con seguimiento de progreso.
+ * Descarga un archivo con barra de progreso.
  */
 async function downloadFile(url, destPath) {
   return new Promise((resolve, reject) => {
@@ -52,7 +53,7 @@ async function downloadFile(url, destPath) {
     const proto = url.startsWith('https') ? https : http
 
     const request = (reqUrl) => {
-      proto.get(reqUrl, { timeout: 120000 }, (res) => {
+      proto.get(reqUrl, { timeout: 300000 }, (res) => {
         if (res.statusCode === 301 || res.statusCode === 302) {
           file.close()
           return request(res.headers.location)
@@ -60,7 +61,7 @@ async function downloadFile(url, destPath) {
         if (res.statusCode !== 200) {
           file.close()
           fs.unlinkSync(destPath)
-          return reject(new Error(`HTTP ${res.statusCode} descargando runtime`))
+          return reject(new Error(`HTTP ${res.statusCode} descargando binario`))
         }
 
         const total = parseInt(res.headers['content-length'] || '0', 10)
@@ -72,7 +73,7 @@ async function downloadFile(url, destPath) {
           if (total > 0) {
             const pct = Math.floor(downloaded / total * 100)
             if (pct !== lastPct && pct % 10 === 0) {
-              process.stderr.write(`\r  Descargando runtime... ${pct}%`)
+              process.stderr.write(`\r  Descargando... ${pct}%`)
               lastPct = pct
             }
           }
@@ -89,72 +90,56 @@ async function downloadFile(url, destPath) {
 }
 
 /**
- * Asegura que el runtime Python esté descargado y listo.
- * @returns {Promise<{pythonBin: string, serverPath: string, runtimeDir: string}>}
+ * Asegura que el binario esté descargado y listo.
+ * @returns {Promise<{binPath: string}>}
  */
-async function ensureRuntime() {
-  const arch    = getArch()
-  const info    = await getLatestRuntime()
+async function ensureBinary() {
+  const arch   = getArch()
+  const info   = await getLatestBinary()
   const version = info.version
-  const url     = info.url || `https://download.local-mcp.com/local-mcp-runtime-${version}-${arch}.tar.gz`
+  // 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 pythonBin  = path.join(versionDir, 'bin', 'python3')
-  const serverPath = path.join(versionDir, 'server.py')
+  const binPath    = path.join(versionDir, 'local-mcp-server', 'local-mcp-server')
 
-  // Ya está en cache — verificar que los archivos esenciales existan
-  if (fs.existsSync(pythonBin) && fs.existsSync(serverPath)) {
-    return { pythonBin, serverPath, runtimeDir: versionDir }
-  }
-  // Cache incompleto → limpiar y re-descargar
-  if (fs.existsSync(versionDir)) {
-    process.stderr.write(`  Cache incompleto — re-descargando...\n`)
-    fs.rmSync(versionDir, { recursive: true, force: true })
+  // Ya está en cache
+  if (fs.existsSync(binPath)) {
+    return { binPath, versionDir }
   }
 
-  process.stderr.write(`\nLocal MCP runtime v${version} no encontrado en cache.\n`)
+  process.stderr.write(`\nLocal MCP 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`)
+  fs.mkdirSync(versionDir, { recursive: true })
+  const tarPath = path.join(versionDir, `server-${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}`)
+  if (!fs.existsSync(binPath)) {
+    throw new Error(`Binario no encontrado después de extraer: ${binPath}`)
   }
 
-  // Re-firmar con ad-hoc — macOS invalida signatures al copiar fuera del .app
-  process.stderr.write(`  Firmando binarios...\n`)
+  // Asegurar que sea ejecutable
+  fs.chmodSync(binPath, 0o755)
+
+  // Re-firmar ad-hoc (macOS puede invalidar al copiar/extraer)
   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`)
-  }
+    execFileSync('codesign', ['--force', '--sign', '-', binPath], { stdio: 'pipe' })
+  } catch { /* no crítico */ }
 
-  process.stderr.write(`  Runtime listo en ${versionDir}\n`)
-  return { pythonBin, serverPath, runtimeDir: versionDir }
+  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 }
 }
 
-module.exports = { ensureRuntime, getLatestRuntime, CACHE_DIR }
+module.exports = { ensureBinary, ensureRuntime, CACHE_DIR }

package/index.js

@@ -82,34 +82,12 @@ async function main() {
     process.exit(1)
   }
 
-  const { pythonBin, serverPath, runtimeDir } = runtime
-
-  // Variables de entorno para el servidor Python
-  const frameworksPath = path.join(runtimeDir, 'Frameworks')
-  const libPath        = path.join(runtimeDir, 'lib', 'python3.13')
-  const env = { ...process.env }
-
-  // Frameworks bundleados (libssl, libcrypto, liblzma, etc.)
-  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   : '')
-  }
-
-  // PYTHONPATH: módulos del runtime (sin zip — magic number varía entre builds)
-  // PYTHONNOUSERSITE: evita mezclar con site-packages del sistema
-  env.PYTHONNOUSERSITE = '1'
-  const sitePkgs   = path.join(libPath, 'site-packages')
-  const libDynload = path.join(libPath, 'lib-dynload')
-  const pyPaths    = [libPath, sitePkgs, libDynload]
-    .filter(p => require('fs').existsSync(p))
-  if (pyPaths.length > 0) {
-    env.PYTHONPATH = pyPaths.join(':') + (env.PYTHONPATH ? ':' + env.PYTHONPATH : '')
-  }
-
+  // Binario PyInstaller standalone — sin Python, sin dependencias externas
+  const { binPath } = runtime
   const extraArgs = process.argv.slice(cmd ? 2 : 3)
-  const result = spawnSync(pythonBin, [serverPath, 'stdio', ...extraArgs], {
+  const result = spawnSync(binPath, ['stdio', ...extraArgs], {
     stdio: 'inherit',
-    env,
+    env: process.env,
   })
 
   if (result.error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-mcp",
-  "version": "1.44.5",
+  "version": "1.44.6",
   "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": {