@saulwade/swl-ses 1.5.1 → 1.6.0

package/scripts/lib/ui.js

@@ -82,6 +82,25 @@ function encabezado(titulo, version) {
 // Spinner
 // ---------------------------------------------------------------------------
 
+// Registro global de spinners activos. Permite que las funciones interactivas
+// (preguntarSiNo, preguntarOpcion, preguntarTexto) pausen cualquier spinner en
+// curso antes de crear un readline, evitando que el setInterval del spinner
+// sobreescriba el prompt con `\r`. Origen: bug observado en `swl-ses update`
+// cuando el instalador hace preguntarSiNo dentro del spinner del actualizador.
+const _spinnersActivos = new Set();
+
+function _pausarSpinnersActivos() {
+  for (const sp of _spinnersActivos) {
+    sp._pausar();
+  }
+}
+
+function _reanudarSpinnersActivos() {
+  for (const sp of _spinnersActivos) {
+    sp._reanudar();
+  }
+}
+
 function spinner(mensaje) {
   if (!SOPORTA_COLOR) {
     // Sin TTY: solo mostrar mensaje estático
@@ -91,49 +110,96 @@ function spinner(mensaje) {
       exito: (msg) => { console.log(`  [OK] ${msg}`); },
       fallo: (msg) => { console.log(`  [ERROR] ${msg}`); },
       detener: () => {},
+      _pausar: () => {},
+      _reanudar: () => {},
     };
   }
 
   let frameIdx = 0;
   let textoActual = mensaje;
   let activo = true;
+  let pausado = false;
+  let intervalo = null;
 
-  const intervalo = setInterval(() => {
-    if (!activo) return;
+  function _tick() {
+    if (!activo || pausado) return;
     const frame = SPINNER_FRAMES[frameIdx % SPINNER_FRAMES.length];
     process.stdout.write(`\r  ${color.cyan(frame)} ${textoActual}   `);
     frameIdx++;
-  }, 80);
+  }
+
+  function _arrancarIntervalo() {
+    if (intervalo) return;
+    intervalo = setInterval(_tick, 80);
+  }
+
+  function _detenerIntervalo() {
+    if (intervalo) {
+      clearInterval(intervalo);
+      intervalo = null;
+    }
+  }
 
   function limpiarLinea() {
     process.stdout.write('\r\x1b[2K');
   }
 
+  _arrancarIntervalo();
+
+  // Declarado antes del handle para que las funciones de terminación puedan
+  // removerlo. Origen: F-1 nemesis iter-1 — sin remove, cada spinner deja un
+  // listener muerto en `process` y un loop con N runtimes acumula warnings
+  // de MaxListenersExceeded.
+  const exitHandler = () => { handle.detener(); };
+
   const handle = {
     actualizar(msg) {
       textoActual = msg;
     },
     exito(msg) {
       activo = false;
-      clearInterval(intervalo);
+      _detenerIntervalo();
+      _spinnersActivos.delete(handle);
+      process.removeListener('exit', exitHandler);
       limpiarLinea();
       console.log(`  ${color.verde(icono.check)} ${msg}`);
     },
     fallo(msg) {
       activo = false;
-      clearInterval(intervalo);
+      _detenerIntervalo();
+      _spinnersActivos.delete(handle);
+      process.removeListener('exit', exitHandler);
       limpiarLinea();
       console.log(`  ${color.rojo(icono.cross)} ${msg}`);
     },
     detener() {
       activo = false;
-      clearInterval(intervalo);
+      _detenerIntervalo();
+      _spinnersActivos.delete(handle);
+      process.removeListener('exit', exitHandler);
+      limpiarLinea();
+    },
+    _pausar() {
+      // Pausa el tick para que un readline pueda renderizar el prompt sin
+      // que el spinner lo sobreescriba con `\r`. Limpia la línea para que
+      // el prompt empiece en una columna libre.
+      if (pausado) return;
+      pausado = true;
+      _detenerIntervalo();
       limpiarLinea();
     },
+    _reanudar() {
+      // Reanuda el tick tras el cierre del readline. Solo si el spinner sigue
+      // lógicamente activo (no fue detenido durante la pausa).
+      if (!pausado || !activo) return;
+      pausado = false;
+      _arrancarIntervalo();
+    },
   };
 
-  // Limpieza en caso de que el proceso muera
-  const exitHandler = () => { handle.detener(); };
+  _spinnersActivos.add(handle);
+
+  // Limpieza si el proceso muere antes de exito/fallo/detener
   process.once('exit', exitHandler);
 
   return handle;
@@ -151,19 +217,36 @@ function preguntarSiNo(mensaje, valorDefault = true) {
     }
 
     const hint = valorDefault ? 'S/n' : 's/N';
+    _pausarSpinnersActivos();
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
     });
 
+    // El evento 'close' es la única ruta de finalización. Se garantiza que
+    // se dispare incluso si el callback de question no se ejecuta (Ctrl+C,
+    // EOF, error en stdin). Esto evita el bug donde los spinners quedaban
+    // permanentemente pausados tras un cierre prematuro del readline.
+    let valorFinal = valorDefault;
+    let resuelto = false;
+
+    function finalizar() {
+      if (resuelto) return;
+      resuelto = true;
+      _reanudarSpinnersActivos();
+      resolve(valorFinal);
+    }
+
+    rl.on('close', finalizar);
+
     rl.question(`  ${mensaje} [${hint}] `, (respuesta) => {
-      rl.close();
       const r = respuesta.trim().toLowerCase();
       if (r === '') {
-        resolve(valorDefault);
+        valorFinal = valorDefault;
       } else {
-        resolve(r === 's' || r === 'si' || r === 'sí' || r === 'y' || r === 'yes');
+        valorFinal = r === 's' || r === 'si' || r === 'sí' || r === 'y' || r === 'yes';
       }
+      rl.close(); // dispara 'close' → finalizar(); idempotente vía `resuelto`
     });
   });
 }
@@ -185,6 +268,11 @@ function preguntarOpcion(titulo, opciones, opts = {}) {
       return;
     }
 
+    // Pausar antes de emitir el menú con console.log — si hay spinner activo,
+    // un tick a 80ms puede sobreescribir la primera línea del menú. Origen:
+    // F-2 nemesis iter-1.
+    _pausarSpinnersActivos();
+
     console.log('');
     console.log(`  ${titulo}`);
     console.log('');
@@ -197,21 +285,36 @@ function preguntarOpcion(titulo, opciones, opts = {}) {
 
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const hint = `[1-${opciones.length}, Enter=${opciones[indiceDefault].valor}]`;
+
+    // Ver preguntarSiNo: 'close' garantiza reanudación incluso si el callback
+    // de question no se invoca (Ctrl+C, EOF, error).
+    let valorFinal = opciones[indiceDefault].valor;
+    let resuelto = false;
+
+    function finalizar() {
+      if (resuelto) return;
+      resuelto = true;
+      _reanudarSpinnersActivos();
+      resolve(valorFinal);
+    }
+
+    rl.on('close', finalizar);
+
     rl.question(`  Tu elección ${hint}: `, (respuesta) => {
-      rl.close();
       const r = respuesta.trim();
       if (r === '') {
-        resolve(opciones[indiceDefault].valor);
-        return;
-      }
-      const n = parseInt(r, 10);
-      if (Number.isFinite(n) && n >= 1 && n <= opciones.length) {
-        resolve(opciones[n - 1].valor);
+        valorFinal = opciones[indiceDefault].valor;
       } else {
-        // Permitir también escribir el valor directo si coincide
-        const match = opciones.find(o => o.valor === r);
-        resolve(match ? match.valor : opciones[indiceDefault].valor);
+        const n = parseInt(r, 10);
+        if (Number.isFinite(n) && n >= 1 && n <= opciones.length) {
+          valorFinal = opciones[n - 1].valor;
+        } else {
+          // Permitir también escribir el valor directo si coincide
+          const match = opciones.find(o => o.valor === r);
+          valorFinal = match ? match.valor : opciones[indiceDefault].valor;
+        }
       }
+      rl.close();
     });
   });
 }
@@ -230,10 +333,26 @@ function preguntarTexto(mensaje, valorDefault = '') {
       return;
     }
     const hint = valorDefault ? ` [${valorDefault}]` : '';
+    _pausarSpinnersActivos();
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    // Ver preguntarSiNo: 'close' garantiza reanudación incluso si el callback
+    // de question no se invoca (Ctrl+C, EOF, error).
+    let valorFinal = valorDefault;
+    let resuelto = false;
+
+    function finalizar() {
+      if (resuelto) return;
+      resuelto = true;
+      _reanudarSpinnersActivos();
+      resolve(valorFinal);
+    }
+
+    rl.on('close', finalizar);
+
     rl.question(`  ${mensaje}${hint}: `, (respuesta) => {
+      valorFinal = respuesta.trim() || valorDefault;
       rl.close();
-      resolve(respuesta.trim() || valorDefault);
     });
   });
 }
@@ -245,6 +364,13 @@ function preguntarTexto(mensaje, valorDefault = '') {
 module.exports = {
   SOPORTA_COLOR,
   ES_TTY,
+  // Exports internos para tests del fix de race spinner/prompt. NO usar en
+  // código de producción — la API estable es spinner() + preguntar*.
+  __internalForTesting: {
+    spinnersActivos: _spinnersActivos,
+    pausarSpinnersActivos: _pausarSpinnersActivos,
+    reanudarSpinnersActivos: _reanudarSpinnersActivos,
+  },
   color,
   icono,
   formatearPaso,

package/scripts/limpiar-artefactos-python.js

@@ -1,131 +1,131 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * limpiar-artefactos-python.js — limpia caché Python antes de empaquetar.
- *
- * Se ejecuta como `prepack` antes de `npm pack` y `npm publish` para evitar
- * que artefactos locales (.pyc, __pycache__/) contaminen el tarball publicado.
- *
- * Reglas de seguridad (defensa en profundidad):
- *   1. Aborta si cwd no coincide con la raíz del package.json del repo.
- *   2. Profundidad máxima de recursión: 3 niveles desde la raíz.
- *   3. Allowlist explícita de directorios a EXCLUIR de la búsqueda
- *      (node_modules, .git, temp, .planning, respositorios-git, _userland).
- *   4. Solo elimina directorios cuyo nombre coincide exactamente con el
- *      conjunto cerrado: __pycache__, .pytest_cache, .mypy_cache, .ruff_cache.
- *   5. Solo elimina archivos sueltos con extensiones .pyc, .pyo.
- *   6. En CI no-interactivo respeta el flag SWL_PREPACK_DRY=1 (no borra,
- *      solo lista).
- *
- * Exit codes:
- *   0 — OK (limpieza ejecutada o nada que limpiar)
- *   1 — error de invariante (cwd incorrecto, package.json no encontrado)
- */
-
-const fs   = require('fs');
-const path = require('path');
-
-const { NOMBRES_VALIDOS } = require('./lib/paquetes-conocidos');
-const {
-  DIRS_ARTEFACTOS_PYTHON: DIRS_A_LIMPIAR,
-  EXTS_ARTEFACTOS_PYTHON: EXTS_A_LIMPIAR,
-} = require('./lib/artefactos-python');
-
-const PROFUNDIDAD_MAX = 3;
-const DIRS_EXCLUIDOS  = new Set([
-  'node_modules', '.git', 'temp', '.planning', 'respositorios-git',
-  '_userland', 'tests', '.github',
-]);
-
-const dryRun = process.env.SWL_PREPACK_DRY === '1';
-
-function log(msg) { process.stdout.write(`[prepack] ${msg}\n`); }
-function err(msg) { process.stderr.write(`[prepack] ERROR: ${msg}\n`); }
-
-/**
- * Verifica que el cwd actual contiene el package.json del repo swl-ses.
- * Esto evita que el script borre directorios en la máquina del usuario si
- * algún día se invocara desde un cwd incorrecto (ej. dentro de un tarball
- * extraído por npm en .npm/_cacache).
- */
-function verificarRaiz() {
-  const cwd = process.cwd();
-  const pkgPath = path.join(cwd, 'package.json');
-  if (!fs.existsSync(pkgPath)) {
-    err(`no existe package.json en cwd: ${cwd}`);
-    process.exit(1);
-  }
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-  if (!NOMBRES_VALIDOS.includes(pkg.name)) {
-    err(`package.json en ${cwd} no corresponde a swl-ses (name: ${pkg.name}). Abortando por seguridad.`);
-    process.exit(1);
-  }
-  return cwd;
-}
-
-/**
- * Recorre el árbol desde root con profundidad limitada y elimina los
- * artefactos Python detectados. No sigue symlinks.
- */
-function limpiar(root, profundidad = 0) {
-  if (profundidad > PROFUNDIDAD_MAX) return { dirs: 0, files: 0 };
-
-  let dirsEliminados = 0;
-  let filesEliminados = 0;
-
-  let entries;
-  try {
-    entries = fs.readdirSync(root, { withFileTypes: true });
-  } catch (e) {
-    err(`no se pudo leer ${root}: ${e.message}`);
-    return { dirs: 0, files: 0 };
-  }
-
-  for (const entry of entries) {
-    if (entry.isSymbolicLink()) continue;
-    const fullPath = path.join(root, entry.name);
-
-    if (entry.isDirectory()) {
-      if (DIRS_A_LIMPIAR.has(entry.name)) {
-        if (dryRun) {
-          log(`[dry-run] borraría dir: ${path.relative(process.cwd(), fullPath)}`);
-        } else {
-          fs.rmSync(fullPath, { recursive: true, force: true });
-          log(`borrado dir: ${path.relative(process.cwd(), fullPath)}`);
-        }
-        dirsEliminados++;
-      } else if (!DIRS_EXCLUIDOS.has(entry.name) && !entry.name.startsWith('.')) {
-        const sub = limpiar(fullPath, profundidad + 1);
-        dirsEliminados  += sub.dirs;
-        filesEliminados += sub.files;
-      }
-    } else if (entry.isFile()) {
-      const ext = path.extname(entry.name).toLowerCase();
-      if (EXTS_A_LIMPIAR.has(ext)) {
-        if (dryRun) {
-          log(`[dry-run] borraría archivo: ${path.relative(process.cwd(), fullPath)}`);
-        } else {
-          fs.rmSync(fullPath, { force: true });
-        }
-        filesEliminados++;
-      }
-    }
-  }
-
-  return { dirs: dirsEliminados, files: filesEliminados };
-}
-
-function main() {
-  const root = verificarRaiz();
-  const result = limpiar(root);
-
-  if (result.dirs === 0 && result.files === 0) {
-    log('sin artefactos Python que limpiar.');
-  } else {
-    const accion = dryRun ? 'detectados' : 'eliminados';
-    log(`${accion}: ${result.dirs} directorios + ${result.files} archivos.`);
-  }
-}
-
-main();
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * limpiar-artefactos-python.js — limpia caché Python antes de empaquetar.
+ *
+ * Se ejecuta como `prepack` antes de `npm pack` y `npm publish` para evitar
+ * que artefactos locales (.pyc, __pycache__/) contaminen el tarball publicado.
+ *
+ * Reglas de seguridad (defensa en profundidad):
+ *   1. Aborta si cwd no coincide con la raíz del package.json del repo.
+ *   2. Profundidad máxima de recursión: 3 niveles desde la raíz.
+ *   3. Allowlist explícita de directorios a EXCLUIR de la búsqueda
+ *      (node_modules, .git, temp, .planning, respositorios-git, _userland).
+ *   4. Solo elimina directorios cuyo nombre coincide exactamente con el
+ *      conjunto cerrado: __pycache__, .pytest_cache, .mypy_cache, .ruff_cache.
+ *   5. Solo elimina archivos sueltos con extensiones .pyc, .pyo.
+ *   6. En CI no-interactivo respeta el flag SWL_PREPACK_DRY=1 (no borra,
+ *      solo lista).
+ *
+ * Exit codes:
+ *   0 — OK (limpieza ejecutada o nada que limpiar)
+ *   1 — error de invariante (cwd incorrecto, package.json no encontrado)
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const { NOMBRES_VALIDOS } = require('./lib/paquetes-conocidos');
+const {
+  DIRS_ARTEFACTOS_PYTHON: DIRS_A_LIMPIAR,
+  EXTS_ARTEFACTOS_PYTHON: EXTS_A_LIMPIAR,
+} = require('./lib/artefactos-python');
+
+const PROFUNDIDAD_MAX = 3;
+const DIRS_EXCLUIDOS  = new Set([
+  'node_modules', '.git', 'temp', '.planning', 'respositorios-git',
+  '_userland', 'tests', '.github',
+]);
+
+const dryRun = process.env.SWL_PREPACK_DRY === '1';
+
+function log(msg) { process.stdout.write(`[prepack] ${msg}\n`); }
+function err(msg) { process.stderr.write(`[prepack] ERROR: ${msg}\n`); }
+
+/**
+ * Verifica que el cwd actual contiene el package.json del repo swl-ses.
+ * Esto evita que el script borre directorios en la máquina del usuario si
+ * algún día se invocara desde un cwd incorrecto (ej. dentro de un tarball
+ * extraído por npm en .npm/_cacache).
+ */
+function verificarRaiz() {
+  const cwd = process.cwd();
+  const pkgPath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    err(`no existe package.json en cwd: ${cwd}`);
+    process.exit(1);
+  }
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  if (!NOMBRES_VALIDOS.includes(pkg.name)) {
+    err(`package.json en ${cwd} no corresponde a swl-ses (name: ${pkg.name}). Abortando por seguridad.`);
+    process.exit(1);
+  }
+  return cwd;
+}
+
+/**
+ * Recorre el árbol desde root con profundidad limitada y elimina los
+ * artefactos Python detectados. No sigue symlinks.
+ */
+function limpiar(root, profundidad = 0) {
+  if (profundidad > PROFUNDIDAD_MAX) return { dirs: 0, files: 0 };
+
+  let dirsEliminados = 0;
+  let filesEliminados = 0;
+
+  let entries;
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch (e) {
+    err(`no se pudo leer ${root}: ${e.message}`);
+    return { dirs: 0, files: 0 };
+  }
+
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const fullPath = path.join(root, entry.name);
+
+    if (entry.isDirectory()) {
+      if (DIRS_A_LIMPIAR.has(entry.name)) {
+        if (dryRun) {
+          log(`[dry-run] borraría dir: ${path.relative(process.cwd(), fullPath)}`);
+        } else {
+          fs.rmSync(fullPath, { recursive: true, force: true });
+          log(`borrado dir: ${path.relative(process.cwd(), fullPath)}`);
+        }
+        dirsEliminados++;
+      } else if (!DIRS_EXCLUIDOS.has(entry.name) && !entry.name.startsWith('.')) {
+        const sub = limpiar(fullPath, profundidad + 1);
+        dirsEliminados  += sub.dirs;
+        filesEliminados += sub.files;
+      }
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (EXTS_A_LIMPIAR.has(ext)) {
+        if (dryRun) {
+          log(`[dry-run] borraría archivo: ${path.relative(process.cwd(), fullPath)}`);
+        } else {
+          fs.rmSync(fullPath, { force: true });
+        }
+        filesEliminados++;
+      }
+    }
+  }
+
+  return { dirs: dirsEliminados, files: filesEliminados };
+}
+
+function main() {
+  const root = verificarRaiz();
+  const result = limpiar(root);
+
+  if (result.dirs === 0 && result.files === 0) {
+    log('sin artefactos Python que limpiar.');
+  } else {
+    const accion = dryRun ? 'detectados' : 'eliminados';
+    log(`${accion}: ${result.dirs} directorios + ${result.files} archivos.`);
+  }
+}
+
+main();

package/scripts/mcp-orchestrator.py

@@ -30,6 +30,10 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
+# Importar helper compartido sin convertir scripts/ en paquete.
+sys.path.insert(0, str(Path(__file__).resolve().parent / 'lib'))
+from mcp_config import cargar_config_mcp  # noqa: E402
+
 # ---------------------------------------------------------------------------
 # Dependencias — raw mcp SDK
 # ---------------------------------------------------------------------------
@@ -45,32 +49,18 @@ except ImportError:
 # Constantes
 # ---------------------------------------------------------------------------
 
-SETTINGS_CANDIDATES = [
-    '.claude/settings.local.json',
-    '.claude/settings.json',
-    'mcp-servers.json',
-]
-
 TIMEOUT_S           = 12
 SNAPSHOT_FILE       = Path('.planning') / 'mcp-snapshot.json'
 
 # ---------------------------------------------------------------------------
-# Carga de config (identica a mcp-pool-manager para evitar dependencia circular)
+# Carga de config — delega a scripts/lib/mcp_config.py para deep merge
+# unificado con mcp-pool-manager.py. Antes hacia first-wins y rompia el
+# health check cuando settings.local.json contenia overrides parciales.
 # ---------------------------------------------------------------------------
 
 
 def _cargar_config(cwd: Path, config_path: str | None = None) -> dict:
-    candidates = [Path(config_path)] if config_path else [cwd / p for p in SETTINGS_CANDIDATES]
-    for p in candidates:
-        if p.exists():
-            try:
-                data = json.loads(p.read_text(encoding='utf-8'))
-                servers = data.get('mcpServers', {})
-                if servers:
-                    return servers
-            except Exception:
-                continue
-    return {}
+    return cargar_config_mcp(cwd, config_path)
 
 
 def _build_env(cfg: dict) -> dict | None:

package/scripts/mcp-pool-manager.py

@@ -4,10 +4,11 @@
 Conecta a servidores MCP configurados en .claude/settings.json y expone
 sus herramientas para uso por agentes y scripts de swl-ses.
 
-Lee la configuracion de mcpServers en orden de precedencia:
-  1. .claude/settings.local.json
-  2. .claude/settings.json
-  3. mcp-servers.json (config independiente opcional)
+Lee la configuracion fusionando las capas con deep merge (semantica de
+Claude Code): mcp-servers.json -> .claude/settings.json -> .claude/settings.local.json.
+La capa mas profunda sobrescribe por clave; env se mergea por sub-clave.
+Esto permite que settings.local.json contenga overrides parciales (p.ej.
+solo OBSIDIAN_API_KEY) sin perder command/args de la capa compartida.
 
 Uso:
   python scripts/mcp-pool-manager.py list-servers
@@ -30,6 +31,10 @@ import time
 from pathlib import Path
 from typing import Any
 
+# Importar helper compartido sin convertir scripts/ en paquete.
+sys.path.insert(0, str(Path(__file__).resolve().parent / 'lib'))
+from mcp_config import cargar_config_mcp  # noqa: E402
+
 # ---------------------------------------------------------------------------
 # Dependencias — raw mcp SDK (disponible en entornos con Claude Code)
 # ---------------------------------------------------------------------------
@@ -45,33 +50,17 @@ except ImportError:
 # Constantes
 # ---------------------------------------------------------------------------
 
-SETTINGS_CANDIDATES = [
-    '.claude/settings.local.json',
-    '.claude/settings.json',
-    'mcp-servers.json',
-]
-
 TIMEOUT_CONNECT_S = 10   # segundos maximo para conectar a un servidor
 TIMEOUT_CALL_S    = 30   # segundos maximo para llamar una herramienta
 
 # ---------------------------------------------------------------------------
-# Carga de configuracion
+# Carga de configuracion — delega a scripts/lib/mcp_config.py
 # ---------------------------------------------------------------------------
 
 
 def _cargar_config(cwd: Path, config_path: str | None = None) -> dict:
-    """Carga la seccion mcpServers del primer archivo de config encontrado."""
-    candidates = [Path(config_path)] if config_path else [cwd / p for p in SETTINGS_CANDIDATES]
-    for p in candidates:
-        if p.exists():
-            try:
-                data = json.loads(p.read_text(encoding='utf-8'))
-                servers = data.get('mcpServers', {})
-                if servers:
-                    return servers
-            except Exception:
-                continue
-    return {}
+    """Devuelve los servidores MCP fusionados de todas las capas."""
+    return cargar_config_mcp(cwd, config_path)
 
 
 def _get_server(servers: dict, nombre: str) -> dict: