alegra-data-agent 0.4.2 → 0.4.4

package/dist/commands/status.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { AuthRequiredError, fetchManifest } from "../api.js";
 import { readAuth } from "../auth.js";
 import { bold, cyan, dim, gray, green, log, logError, logWarn, yellow } from "../colors.js";
-import { detectDrift, inspectMcpInTarget } from "../installer.js";
+import { detectDrift, findMisplacedMcps, inspectMcpInTarget } from "../installer.js";
 import { COMMAND_NAME, GATEWAY_URL, getAutoUpdateLogPath, getClaudeJsonPath, getClaudeSkillsDir, getLockFilePath, getMcpScopeDir, getMcpScopeWarning, getPackageVersion, getTargetSkillsDir, readLockFile, } from "../lib.js";
 import { TARGETS } from "../targets.js";
 function reportAutoUpdateLog() {
@@ -145,6 +145,14 @@ export function findRogueMetabase(manifest, specs = Object.values(TARGETS)) {
     }
     return found;
 }
+function reportMisplacedMcps(manifest) {
+    const found = findMisplacedMcps(manifest);
+    if (found.length === 0)
+        return;
+    logWarn(`Hay ${found.length} MCP(s) de Alegra fuera de su lugar: ${found.join(" · ")}`);
+    log(gray(`                  El próximo arranque los retira solo. Para hacerlo ya: ${COMMAND_NAME} update`));
+    log("");
+}
 function reportRogueMetabase(manifest) {
     const official = manifest.mcps?.metabase?.url;
     if (!official)
@@ -320,6 +328,7 @@ export async function runStatus() {
     log("");
     reportMcps(manifest, lock);
     reportRogueMetabase(manifest);
+    reportMisplacedMcps(manifest);
     reportClaudeAiDuplicates(manifest);
     reportAccountConnectorOverlap(manifest);
     const total = drift.toInstall.length +

package/dist/commands/update.js

@@ -97,7 +97,9 @@ async function runUpdateOnce(opts) {
     for (const name of drift.mcps.toUpdate) {
         const motivo = drift.mcps.missing.includes(name)
             ? "(MCP ausente o descartado por el cliente — se repone)"
-            : "(MCP actualizado)";
+            : drift.mcps.outOfPlace.includes(name)
+                ? "(copia fuera de lugar o proxy ausente — se corrige)"
+                : "(MCP actualizado)";
         log(`    ${yellow("↻")} ${name} ${gray(motivo)}`);
     }
     log("");

package/dist/installer.js

@@ -4,8 +4,8 @@ import { chmodSync, copyFileSync, existsSync, readFileSync, readdirSync, renameS
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { AuthRequiredError, fetchManifest, fetchSkillFile } from "./api.js";
 import { dim, gray, green, logError, red, yellow } from "./colors.js";
-import { ensureLazyProxy, lazyMcpDir, stdioLaunch } from "./lazy-mcp.js";
-import { ensureDir, getAntigravityGeminiLegacyMcpConfigPath, getAntigravityGeminiLegacySkillsDir, getAntigravityLegacyMcpConfigPath, getAntigravityLegacySkillsDir, getClaudeSettingsPath, getCursorLegacyRulesDir, getHermesBin, getLockFilePath, getMcpScopeDir, getOpenCodeLegacyPromptsDir, getPackageVersion, readLockFile, sha256File, writeLockFile, } from "./lib.js";
+import { ensureLazyProxy, lazyMcpDir, lazyProxyPath, lazyToolsPath, stdioLaunch, } from "./lazy-mcp.js";
+import { ensureDir, getAntigravityGeminiLegacyMcpConfigPath, getAntigravityGeminiLegacySkillsDir, getAntigravityLegacyMcpConfigPath, getAntigravityLegacySkillsDir, getClaudeSettingsPath, getCursorLegacyRulesDir, getHermesBin, getLockFilePath, getMcpScopeDir, getMcpScopeWarning, getOpenCodeLegacyPromptsDir, getPackageVersion, getUserScopeMcpConfigPath, isMcpScopeEnvOverride, readLockFile, sha256File, writeLockFile, } from "./lib.js";
 import { inlineReferences, renderHermesMcpOps, renderMcpForTarget, } from "./render.js";
 import { TARGETS, detectInstalledTargets } from "./targets.js";
 const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
@@ -288,10 +288,9 @@ export function updateJsonFile(path, mutate) {
     }
     throw new Error(`${path} cambió 5 veces mientras se escribía; volvé a correr la instalación.`);
 }
-function setClaudeProjectMcpApproval(name, spec, approved) {
+function setClaudeProjectMcpApproval(name, spec, approved, dir = getMcpScopeDir()) {
     if (spec.id !== "claude-code")
         return;
-    const dir = getMcpScopeDir();
     if (!dir)
         return;
     const settingsPath = join(dir, ".claude", "settings.json");
@@ -311,6 +310,134 @@ function setClaudeProjectMcpApproval(name, spec, approved) {
     catch {
     }
 }
+export function isOwnMcpEntry(entry, mcp, spec, recordedHash) {
+    if (!entry || typeof entry !== "object")
+        return false;
+    const got = stableStringify(entry);
+    if (recordedHash && createHash("sha256").update(got).digest("hex") === recordedHash)
+        return true;
+    const shapes = [mcp, { ...mcp, lazy: undefined }];
+    return shapes.some((m) => stableStringify(renderMcpForTarget(m, spec)) === got);
+}
+function removeMcpEntryAt(path, rootKey, name, isOurs) {
+    if (!existsSync(path))
+        return false;
+    return updateJsonFile(path, (cfg) => {
+        const section = cfg[rootKey];
+        if (!section || !(name in section) || !isOurs(section[name]))
+            return false;
+        delete section[name];
+        return true;
+    });
+}
+function canReconcileScope() {
+    return !getMcpScopeWarning() && !isMcpScopeEnvOverride();
+}
+function staleMcpConfigPaths(spec, prev) {
+    if (!canReconcileScope())
+        return [];
+    const out = new Set();
+    const recorded = prev?.configPaths?.[spec.id];
+    if (recorded)
+        out.add(recorded);
+    const user = getUserScopeMcpConfigPath(spec.id);
+    if (user && getMcpScopeDir())
+        out.add(user);
+    out.delete(spec.mcpConfigPath);
+    return [...out];
+}
+function retireStaleMcpCopies(mcp, specs, prev) {
+    const touched = [];
+    for (const spec of specs) {
+        if (spec.mcpMechanism === "hermes-cli" || spec.mcpMechanism === "toml-block")
+            continue;
+        for (const path of staleMcpConfigPaths(spec, prev)) {
+            try {
+                const isOurs = (e) => isOwnMcpEntry(e, mcp, spec, prev?.renderedHash?.[spec.id]);
+                if (removeMcpEntryAt(path, spec.mcpRootKey, mcp.name, isOurs)) {
+                    touched.push(path);
+                    if (spec.id === "claude-code" && basename(path) === ".mcp.json") {
+                        setClaudeProjectMcpApproval(mcp.name, spec, false, dirname(path));
+                    }
+                }
+            }
+            catch {
+            }
+        }
+    }
+    return touched;
+}
+function retireFromUnscopableTargets(mcp, specs, prev) {
+    const out = [];
+    for (const spec of specs) {
+        try {
+            if (spec.mcpMechanism === "hermes-cli" || spec.mcpMechanism === "toml-block") {
+                if (prev?.targets?.includes(spec.id) && unregisterMcpInTarget(mcp.name, spec))
+                    out.push(spec.id);
+            }
+            else if (removeMcpEntryAt(spec.mcpConfigPath, spec.mcpRootKey, mcp.name, (e) => isOwnMcpEntry(e, mcp, spec, prev?.renderedHash?.[spec.id]))) {
+                out.push(spec.id);
+            }
+        }
+        catch {
+        }
+    }
+    return out;
+}
+export function mcpOutOfPlace(mcp, prev) {
+    const found = [];
+    if (mcp.delivery === "connector")
+        return found;
+    if (mcp.lazy && prev && (!existsSync(lazyProxyPath()) || !existsSync(lazyToolsPath(mcp.name)))) {
+        found.push("falta el proxy de arranque diferido");
+    }
+    const scoped = Boolean(getMcpScopeDir()) && canReconcileScope();
+    for (const spec of Object.values(TARGETS)) {
+        if (mcp.targets && !mcp.targets.includes(spec.id))
+            continue;
+        if (spec.mcpMechanism === "hermes-cli" || spec.mcpMechanism === "toml-block") {
+            if (scoped && prev?.targets?.includes(spec.id))
+                found.push(`copia en ${spec.id}`);
+            continue;
+        }
+        const candidates = getUserScopeMcpConfigPath(spec.id)
+            ? staleMcpConfigPaths(spec, prev)
+            : scoped
+                ? [spec.mcpConfigPath]
+                : [];
+        for (const path of candidates) {
+            try {
+                if (!existsSync(path))
+                    continue;
+                const cfg = JSON.parse(readFileSync(path, "utf-8"));
+                const entry = cfg[spec.mcpRootKey]?.[mcp.name];
+                if (entry && isOwnMcpEntry(entry, mcp, spec, prev?.renderedHash?.[spec.id])) {
+                    found.push(`copia en ${path}`);
+                }
+            }
+            catch {
+            }
+        }
+    }
+    return found;
+}
+export function findMisplacedMcps(manifest) {
+    const lock = readLockFile();
+    const found = [];
+    for (const mcp of Object.values(manifest.mcps ?? {})) {
+        for (const what of mcpOutOfPlace(mcp, lock.mcps?.[mcp.name]))
+            found.push(`${mcp.name}: ${what}`);
+    }
+    return found;
+}
+function scopedConfigPaths(targetIds) {
+    const out = {};
+    for (const id of targetIds) {
+        if (getUserScopeMcpConfigPath(id))
+            out[id] = TARGETS[id].mcpConfigPath;
+    }
+    return out;
+}
 function registerMcpInTarget(mcp, spec) {
     validateMcpName(mcp.name);
     if (spec.mcpMechanism === "hermes-cli") {
@@ -884,14 +1011,33 @@ export function installMcp(mcp, opts = {}) {
             error: `entry local retirada — ${hint}`,
         };
     }
-    const wantedTargets = resolveTargets(opts).filter((t) => !mcp.targets || mcp.targets.includes(t.id));
+    const selected = resolveTargets(opts).filter((t) => !mcp.targets || mcp.targets.includes(t.id));
+    const unscopable = getMcpScopeDir()
+        ? selected.filter((t) => !getUserScopeMcpConfigPath(t.id))
+        : [];
+    const wantedTargets = selected.filter((t) => !unscopable.includes(t));
     const targetIds = wantedTargets.map((t) => t.id);
+    const retiredUnscoped = opts.dryRun || unscopable.length === 0
+        ? []
+        : retireFromUnscopableTargets(mcp, unscopable, lock.mcps[mcp.name]);
+    const unscopedNote = unscopable.length > 0
+        ? `con MCP_DIR solo va a Claude Code/Cursor; no se instala en ${unscopable.map((t) => t.id).join(", ")}${retiredUnscoped.length > 0 ? ` (retirado de ${retiredUnscoped.join(", ")})` : ""}`
+        : undefined;
     if (targetIds.length === 0) {
+        const prevEntry = lock.mcps[mcp.name];
+        if (prevEntry && retiredUnscoped.length > 0) {
+            const left = (prevEntry.targets ?? []).filter((t) => !retiredUnscoped.includes(t));
+            if (left.length > 0)
+                lock.mcps[mcp.name] = { ...prevEntry, targets: left };
+            else
+                delete lock.mcps[mcp.name];
+            writeLockFile(lock);
+        }
         return {
             name: mcp.name,
             kind: "mcp",
-            status: "skipped",
-            error: "ningún target soportado disponible",
+            status: retiredUnscoped.length > 0 ? "updated" : "skipped",
+            error: unscopedNote ?? "ningún target soportado disponible",
         };
     }
     if (mcp.lazy && !opts.dryRun) {
@@ -922,6 +1068,27 @@ export function installMcp(mcp, opts = {}) {
         .filter((t) => !writeTargets.includes(t) && !needsWrite(t))
         .map((t) => t.id);
     if (writeTargets.length === 0 && targetsMatch) {
+        const retired = opts.dryRun ? [] : retireStaleMcpCopies(mcp, wantedTargets, prev);
+        const configPaths = { ...(prev?.configPaths ?? {}), ...scopedConfigPaths(targetIds) };
+        if (prev &&
+            (retired.length > 0 ||
+                stableStringify(configPaths) !== stableStringify(prev.configPaths ?? {}))) {
+            lock.mcps[mcp.name] = { ...prev, configPaths };
+            writeLockFile(lock);
+        }
+        if (retired.length > 0 || retiredUnscoped.length > 0) {
+            const notes = [
+                retired.length > 0 ? `copia de otro scope retirada de ${retired.join(", ")}` : "",
+                retiredUnscoped.length > 0 ? (unscopedNote ?? "") : "",
+            ].filter(Boolean);
+            return {
+                name: mcp.name,
+                kind: "mcp",
+                status: "updated",
+                targets: targetIds,
+                error: notes.join("; "),
+            };
+        }
         return { name: mcp.name, kind: "mcp", status: "unchanged", targets: targetIds };
     }
     if (opts.dryRun) {
@@ -953,6 +1120,7 @@ export function installMcp(mcp, opts = {}) {
             error: failures.join("; "),
         };
     }
+    const retired = retireStaleMcpCopies(mcp, okTargets.map((id) => TARGETS[id]), prev);
     const renderedHash = { ...(prev?.renderedHash ?? {}) };
     for (const t of writeTargets) {
         if (okTargets.includes(t.id))
@@ -960,7 +1128,10 @@ export function installMcp(mcp, opts = {}) {
     }
     const outOfScopeTargets = configChanged
         ? []
-        : (prev?.targets ?? []).filter((t) => !targetIds.includes(t) && (!mcp.targets || mcp.targets.includes(t)));
+        : (prev?.targets ?? []).filter((t) => !targetIds.includes(t) &&
+            (!mcp.targets || mcp.targets.includes(t)) &&
+            !retiredUnscoped.includes(t) &&
+            !(getMcpScopeDir() && !getUserScopeMcpConfigPath(t)));
     const lockTargets = [...new Set([...outOfScopeTargets, ...okTargets])];
     lock.mcps[mcp.name] = {
         name: mcp.name,
@@ -969,6 +1140,7 @@ export function installMcp(mcp, opts = {}) {
         configHash: mcpConfigHash(mcp),
         targets: lockTargets,
         renderedHash,
+        configPaths: { ...(prev?.configPaths ?? {}), ...scopedConfigPaths(okTargets) },
     };
     writeLockFile(lock);
     return {
@@ -976,7 +1148,13 @@ export function installMcp(mcp, opts = {}) {
         kind: "mcp",
         status: prev ? "updated" : "installed",
         targets: okTargets,
-        error: failures.length > 0 ? `targets con fallo — ${failures.join("; ")}` : undefined,
+        error: [
+            failures.length > 0 ? `targets con fallo — ${failures.join("; ")}` : "",
+            retired.length > 0 ? `copia de otro scope retirada de ${retired.join(", ")}` : "",
+            unscopedNote ?? "",
+        ]
+            .filter(Boolean)
+            .join("; ") || undefined,
     };
 }
 export async function installAll(opts = {}) {
@@ -1079,6 +1257,18 @@ export function uninstallMcp(name, opts = {}) {
         try {
             for (const tId of targetIds) {
                 unregisterMcpInTarget(name, TARGETS[tId]);
+                const recorded = prev.configPaths?.[tId];
+                if (recorded && recorded !== TARGETS[tId].mcpConfigPath) {
+                    try {
+                        if (removeMcpEntryAt(recorded, TARGETS[tId].mcpRootKey, name, () => true)) {
+                            if (tId === "claude-code" && basename(recorded) === ".mcp.json") {
+                                setClaudeProjectMcpApproval(name, TARGETS[tId], false, dirname(recorded));
+                            }
+                        }
+                    }
+                    catch {
+                    }
+                }
             }
         }
         catch (err) {
@@ -1091,6 +1281,7 @@ export function uninstallMcp(name, opts = {}) {
         }
         delete lock.mcps[name];
         writeLockFile(lock);
+        rmSync(lazyToolsPath(name), { force: true });
     }
     return { name, kind: "mcp", status: "installed", targets: targetIds };
 }
@@ -1109,7 +1300,13 @@ export function uninstallAll(opts = {}) {
             catch {
             }
         }
-        rmSync(lazyMcpDir(), { recursive: true, force: true });
+        if (Object.keys(readLockFile().mcps ?? {}).length === 0) {
+            try {
+                rmSync(lazyMcpDir(), { recursive: true, force: true });
+            }
+            catch {
+            }
+        }
     }
     return results;
 }
@@ -1142,6 +1339,7 @@ export function detectDrift(manifest) {
         unchanged: [],
         orphaned: [],
         missing: [],
+        outOfPlace: [],
     };
     const manifestMcps = manifest.mcps ?? {};
     for (const name of Object.keys(manifestMcps)) {
@@ -1157,9 +1355,13 @@ export function detectDrift(manifest) {
             continue;
         }
         const missing = mcpNeedsRepairInTargets(manifestMcps[name], (prevMcp.targets ?? []), prevMcp.renderedHash);
-        if (missing.length > 0) {
+        const outOfPlace = mcpOutOfPlace(manifestMcps[name], prevMcp);
+        if (missing.length > 0 || outOfPlace.length > 0) {
             mcps.toUpdate.push(name);
-            mcps.missing.push(name);
+            if (missing.length > 0)
+                mcps.missing.push(name);
+            if (outOfPlace.length > 0)
+                mcps.outOfPlace.push(name);
         }
         else {
             mcps.unchanged.push(name);

package/dist/lazy-mcp.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { COMMAND_NAME, adaptStdioCommand } from "./lib.js";
@@ -25,12 +25,18 @@ export function ensureLazyProxy(mcp) {
         return;
     mkdirSync(lazyMcpDir(), { recursive: true });
     writeIfChanged(lazyProxyPath(), lazyProxySource());
-    writeIfChanged(lazyToolsPath(mcp.name), `${JSON.stringify({ name: mcp.name, tools: mcp.lazy.tools }, null, 2)}\n`);
+    writeIfChanged(lazyToolsPath(mcp.name), `${JSON.stringify({
+        name: mcp.name,
+        ...(mcp.lazy.protocolVersion ? { protocolVersion: mcp.lazy.protocolVersion } : {}),
+        tools: mcp.lazy.tools,
+    }, null, 2)}\n`);
 }
 function writeIfChanged(path, content) {
     if (existsSync(path) && readFileSync(path, "utf-8") === content)
         return;
-    writeFileSync(path, content, { mode: 0o644 });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, content, { mode: 0o644 });
+    renameSync(tmp, path);
 }
 export function lazyProxySource() {
     const product = JSON.stringify(COMMAND_NAME);
@@ -38,7 +44,7 @@ export function lazyProxySource() {
 // Proxy de arranque diferido de ${COMMAND_NAME}. Generado por el instalador: no
 // editar, se reescribe en cada install/update. Uso:
 //   node lazy-mcp-proxy.mjs <tools.json> -- <comando real> [args…]
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { createInterface } from "node:readline";
 
@@ -51,13 +57,18 @@ if (sep !== 1 || argv.length < 3) {
 const spec = JSON.parse(readFileSync(argv[0], "utf8"));
 const [cmd, ...args] = argv.slice(2);
 const INIT_ID = "__alegra_lazy_init__";
+const START_TIMEOUT_MS = 10 * 60 * 1000;
 
 const send = (m) => process.stdout.write(JSON.stringify(m) + "\\n");
+const key = (id) => JSON.stringify(id);
 let initParams = null;
 let child = null;
 let ready = false;
 let dead = null;
+let startTimer = null;
 const queue = [];
+// Requests reenviadas al server que todavía no tuvieron respuesta.
+const inflight = new Map();
 
 function errorFor(m, reason) {
   if (m.method === "tools/call") {
@@ -66,47 +77,73 @@ function errorFor(m, reason) {
   return { jsonrpc: "2.0", id: m.id, error: { code: -32603, message: reason } };
 }
 
+function killChild() {
+  if (!child || child.exitCode !== null) return;
+  if (process.platform === "win32") {
+    spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+  } else {
+    child.kill("SIGTERM");
+  }
+}
+
 function die(reason) {
+  if (dead) return;
   dead = reason;
   ready = false;
+  clearTimeout(startTimer);
   for (const m of queue.splice(0)) send(errorFor(m, reason));
+  for (const m of inflight.values()) send(errorFor(m, reason));
+  inflight.clear();
+  killChild();
+}
+
+function forward(m) {
+  if (m.id !== undefined && m.id !== null && m.method) inflight.set(key(m.id), m);
+  child.stdin.write(JSON.stringify(m) + "\\n");
 }
 
 function start() {
   if (child || dead) return;
   child = spawn(cmd, args, { stdio: ["pipe", "pipe", "inherit"] });
+  startTimer = setTimeout(
+    () => die("El MCP " + spec.name + " tardó más de 10 min en arrancar (¿se cortó la descarga?). Reintentá en una sesión nueva."),
+    START_TIMEOUT_MS,
+  );
   child.on("error", (e) => die("No se pudo arrancar el MCP " + spec.name + ": " + e.message));
-  child.on("exit", (code, signal) => {
-    if (!dead) die("El MCP " + spec.name + " terminó (" + (signal ?? "código " + code) + "). Reintentá en una sesión nueva; si persiste, corré " + ${product} + " status.");
+  // "close" y no "exit": en "exit" el stdout del server todavía puede tener
+  // respuestas sin leer.
+  child.on("close", (code, signal) => {
+    die("El MCP " + spec.name + " terminó (" + (signal ?? "código " + code) + "). Reintentá en una sesión nueva; si persiste, corré " + ${product} + " status.");
   });
   createInterface({ input: child.stdout }).on("line", (line) => {
+    let m;
+    try { m = JSON.parse(line); } catch { m = null; }
     if (ready) {
+      if (m && m.id !== undefined && !m.method) inflight.delete(key(m.id));
       process.stdout.write(line + "\\n");
       return;
     }
-    let m;
-    try { m = JSON.parse(line); } catch { return; }
-    if (m.id !== INIT_ID) return; // notificaciones previas al handshake
+    if (!m || m.id !== INIT_ID) return; // notificaciones previas al handshake
     if (m.error) {
       die("El MCP " + spec.name + " rechazó el handshake: " + (m.error.message ?? "sin detalle"));
-      child.kill();
       return;
     }
     ready = true;
+    clearTimeout(startTimer);
     child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\\n");
-    for (const q of queue.splice(0)) child.stdin.write(JSON.stringify(q) + "\\n");
+    for (const q of queue.splice(0)) forward(q);
   });
   child.stdin.on("error", () => {});
   child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: INIT_ID, method: "initialize", params: initParams }) + "\\n");
 }
 
 createInterface({ input: process.stdin }).on("line", (line) => {
+  let m;
+  try { m = JSON.parse(line); } catch { return; }
   if (ready) {
-    child.stdin.write(line + "\\n");
+    forward(m);
     return;
   }
-  let m;
-  try { m = JSON.parse(line); } catch { return; }
   switch (m.method) {
     case "initialize":
       initParams = m.params ?? {};
@@ -114,7 +151,7 @@ createInterface({ input: process.stdin }).on("line", (line) => {
         jsonrpc: "2.0",
         id: m.id,
         result: {
-          protocolVersion: initParams.protocolVersion ?? "2025-06-18",
+          protocolVersion: spec.protocolVersion ?? initParams.protocolVersion ?? "2025-06-18",
           capabilities: { tools: {} },
           serverInfo: { name: spec.name, version: "lazy" },
         },
@@ -135,6 +172,12 @@ createInterface({ input: process.stdin }).on("line", (line) => {
     case "prompts/list":
       send({ jsonrpc: "2.0", id: m.id, result: { prompts: [] } });
       return;
+    case "notifications/cancelled": {
+      // Una request cancelada mientras el server arranca no se reenvía.
+      const i = queue.findIndex((q) => key(q.id) === key(m.params?.requestId));
+      if (i >= 0) queue.splice(i, 1);
+      return;
+    }
   }
   if (m.id === undefined || m.id === null) return; // notificación: nada que contestar
   if (dead) {
@@ -145,9 +188,11 @@ createInterface({ input: process.stdin }).on("line", (line) => {
   start();
 });
 
-process.stdin.on("end", () => {
-  if (child) child.kill();
+function shutdown() {
+  killChild();
   process.exit(0);
-});
+}
+process.stdin.on("end", shutdown);
+for (const sig of ["SIGTERM", "SIGINT", "SIGHUP"]) process.on(sig, shutdown);
 `;
 }

package/dist/lib.js

@@ -43,6 +43,9 @@ function readAgentConf() {
     catch {
         return {};
     }
+    return parseAgentConf(raw);
+}
+export function parseAgentConf(raw) {
     const out = {};
     for (const line0 of raw.split("\n")) {
         const line = line0.trim();
@@ -88,6 +91,12 @@ function resolveMcpScope() {
     }
     return { dir, warning: undefined };
 }
+export function isMcpScopeEnvOverride() {
+    const env = process.env.ALEGRA_DATA_AGENT_MCP_DIR;
+    if (env === undefined)
+        return false;
+    return env.trim() !== (readAgentConf().MCP_DIR ?? "").trim();
+}
 export function getMcpScopeWarning() {
     return resolveMcpScope().warning;
 }
@@ -108,7 +117,17 @@ export function getCursorLegacyRulesDir() {
     return join(homedir(), ".cursor", "rules");
 }
 export function getCursorMcpPath() {
-    return mcpScopedPath(join(".cursor", "mcp.json"), join(homedir(), ".cursor", "mcp.json"));
+    return mcpScopedPath(join(".cursor", "mcp.json"), getCursorUserMcpPath());
+}
+export function getCursorUserMcpPath() {
+    return join(homedir(), ".cursor", "mcp.json");
+}
+export function getUserScopeMcpConfigPath(target) {
+    if (target === "claude-code")
+        return getClaudeJsonPath();
+    if (target === "cursor")
+        return getCursorUserMcpPath();
+    return undefined;
 }
 export function getOpenCodeSkillsDir() {
     const xdgHome = process.env.XDG_CONFIG_HOME;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alegra-data-agent",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "private": false,
   "description": "Agente de Data interno de Alegra. Instala skills + MCPs en tu cliente de IA con un comando.",
   "license": "UNLICENSED",