alegra-data-agent 0.4.1 → 0.4.2

package/dist/auth.js

@@ -46,7 +46,7 @@ export function writeAuth(record) {
     const path = getAuthFilePath();
     _authCache = { value: record };
     mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, "utf-8");
+    writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, { encoding: "utf-8", mode: 0o600 });
     try {
         chmodSync(path, 0o600);
     }

package/dist/commands/status.js

@@ -5,7 +5,7 @@ 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 { COMMAND_NAME, GATEWAY_URL, getAutoUpdateLogPath, getClaudeSkillsDir, getLockFilePath, getPackageVersion, getTargetSkillsDir, readLockFile, } from "../lib.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() {
     const logPath = getAutoUpdateLogPath();
@@ -75,7 +75,7 @@ function reportMcps(manifest, lock) {
     log("");
 }
 function reportAccountConnectorOverlap(manifest) {
-    const claudeCfg = TARGETS["claude-code"].mcpConfigPath;
+    const claudeCfg = getClaudeJsonPath();
     if (!existsSync(claudeCfg))
         return;
     let connected = [];
@@ -180,7 +180,7 @@ function connectorUrlsFromCredentials(ourServerNames, credentialsPath = join(hom
     }
     return urls;
 }
-export function findClaudeAiDuplicates(manifest, claudeJsonPath = TARGETS["claude-code"].mcpConfigPath) {
+export function findClaudeAiDuplicates(manifest, claudeJsonPath = getClaudeJsonPath(), mcpConfigPath = claudeJsonPath) {
     if (!existsSync(claudeJsonPath))
         return [];
     let cfg;
@@ -193,7 +193,18 @@ export function findClaudeAiDuplicates(manifest, claudeJsonPath = TARGETS["claud
     const connectors = cfg.claudeAiMcpEverConnected;
     if (!Array.isArray(connectors))
         return [];
-    const localServers = cfg[TARGETS["claude-code"].mcpRootKey];
+    let mcpCfg = cfg;
+    if (mcpConfigPath !== claudeJsonPath) {
+        if (!existsSync(mcpConfigPath))
+            return [];
+        try {
+            mcpCfg = JSON.parse(readFileSync(mcpConfigPath, "utf-8"));
+        }
+        catch {
+            return [];
+        }
+    }
+    const localServers = mcpCfg[TARGETS["claude-code"].mcpRootKey];
     if (!localServers || typeof localServers !== "object")
         return [];
     const ourNames = new Set(Object.keys(localServers));
@@ -222,7 +233,7 @@ export function findClaudeAiDuplicates(manifest, claudeJsonPath = TARGETS["claud
     return out;
 }
 function reportClaudeAiDuplicates(manifest) {
-    const dupes = findClaudeAiDuplicates(manifest);
+    const dupes = findClaudeAiDuplicates(manifest, getClaudeJsonPath(), TARGETS["claude-code"].mcpConfigPath);
     if (dupes.length === 0)
         return;
     logWarn(`Hay ${dupes.length} MCP(s) que tenés por dos vías: server local y conector de claude.ai.`);
@@ -259,6 +270,14 @@ export async function runStatus() {
     log(`  ${gray("Autenticado:")}    ${auth ? green(auth.email) : gray("no")}`);
     log(`  ${gray("Destino:")}        ${destino}`);
     log(`  ${gray("Lock file:")}      ${getLockFilePath()}`);
+    log(`  ${gray("MCPs en:")}        ${TARGETS["claude-code"].mcpConfigPath}`);
+    const scopeDir = getMcpScopeDir();
+    if (scopeDir) {
+        log(`  ${gray("Scope MCPs:")}     proyecto ${dim(`(solo dentro de ${scopeDir})`)}`);
+    }
+    const scopeWarning = getMcpScopeWarning();
+    if (scopeWarning)
+        logWarn(`${scopeWarning} — los MCPs quedaron en scope usuario.`);
     log("");
     reportAutoUpdateLog();
     if (!auth) {

package/dist/installer.js

@@ -1,10 +1,11 @@
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { copyFileSync, existsSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 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 { adaptStdioCommand, ensureDir, getAntigravityGeminiLegacyMcpConfigPath, getAntigravityGeminiLegacySkillsDir, getAntigravityLegacyMcpConfigPath, getAntigravityLegacySkillsDir, getClaudeSettingsPath, getCursorLegacyRulesDir, getHermesBin, getLockFilePath, getOpenCodeLegacyPromptsDir, getPackageVersion, readLockFile, sha256File, writeLockFile, } from "./lib.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 { inlineReferences, renderHermesMcpOps, renderMcpForTarget, } from "./render.js";
 import { TARGETS, detectInstalledTargets } from "./targets.js";
 const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
@@ -43,6 +44,7 @@ function mcpConfigHash(mcp) {
         type: mcp.auth.type,
         tokenEnv: mcp.auth.tokenEnv ?? null,
         ...(mcp.delivery ? { delivery: mcp.delivery } : {}),
+        ...(mcp.lazy ? { lazy: mcp.lazy } : {}),
     });
     return createHash("sha256").update(salient).digest("hex");
 }
@@ -198,10 +200,24 @@ function withFsRetry(fn) {
         }
     }
 }
-function atomicWriteFile(path, content) {
+export function atomicWriteFile(path, content) {
     ensureDir(dirname(path));
     const tmp = `${path}.${process.pid}.tmp`;
-    writeFileSync(tmp, content);
+    let mode;
+    try {
+        mode = statSync(path).mode & 0o777;
+    }
+    catch {
+        mode = undefined;
+    }
+    writeFileSync(tmp, content, mode === undefined ? undefined : { mode });
+    if (mode !== undefined) {
+        try {
+            chmodSync(tmp, mode);
+        }
+        catch {
+        }
+    }
     for (let attempt = 0;; attempt++) {
         try {
             renameSync(tmp, path);
@@ -246,16 +262,55 @@ function pruneBackups(path) {
     catch {
     }
 }
-function readJsonOrEmpty(path) {
-    if (!existsSync(path))
+function parseJsonConfig(path, raw) {
+    if (raw === null)
         return {};
     try {
-        return JSON.parse(readFileSync(path, "utf-8"));
+        return JSON.parse(raw);
     }
     catch {
         throw new Error(`${path} no es JSON válido. Agente: respaldalo vos mismo (renombralo a .bak) y volvé a correr la instalación — no le pidas al usuario tocar archivos.`);
     }
 }
+export function updateJsonFile(path, mutate) {
+    for (let attempt = 0; attempt < 5; attempt++) {
+        const raw = existsSync(path) ? readFileSync(path, "utf-8") : null;
+        const cfg = parseJsonConfig(path, raw);
+        if (!mutate(cfg))
+            return false;
+        const next = `${JSON.stringify(cfg, null, 2)}\n`;
+        backupIfExists(path);
+        const now = existsSync(path) ? readFileSync(path, "utf-8") : null;
+        if (now !== raw)
+            continue;
+        atomicWriteFile(path, next);
+        return true;
+    }
+    throw new Error(`${path} cambió 5 veces mientras se escribía; volvé a correr la instalación.`);
+}
+function setClaudeProjectMcpApproval(name, spec, approved) {
+    if (spec.id !== "claude-code")
+        return;
+    const dir = getMcpScopeDir();
+    if (!dir)
+        return;
+    const settingsPath = join(dir, ".claude", "settings.json");
+    try {
+        updateJsonFile(settingsPath, (cfg) => {
+            const current = Array.isArray(cfg.enabledMcpjsonServers)
+                ? cfg.enabledMcpjsonServers.filter((v) => typeof v === "string")
+                : [];
+            if (current.includes(name) === approved)
+                return false;
+            cfg.enabledMcpjsonServers = approved
+                ? [...current, name].sort()
+                : current.filter((n) => n !== name);
+            return true;
+        });
+    }
+    catch {
+    }
+}
 function registerMcpInTarget(mcp, spec) {
     validateMcpName(mcp.name);
     if (spec.mcpMechanism === "hermes-cli") {
@@ -266,12 +321,13 @@ function registerMcpInTarget(mcp, spec) {
         registerMcpInTomlBlock(mcp, spec);
         return;
     }
-    const cfg = readJsonOrEmpty(spec.mcpConfigPath);
-    const section = cfg[spec.mcpRootKey] ?? {};
-    section[mcp.name] = renderMcpForTarget(mcp, spec);
-    cfg[spec.mcpRootKey] = section;
-    backupIfExists(spec.mcpConfigPath);
-    atomicWriteFile(spec.mcpConfigPath, `${JSON.stringify(cfg, null, 2)}\n`);
+    updateJsonFile(spec.mcpConfigPath, (cfg) => {
+        const section = cfg[spec.mcpRootKey] ?? {};
+        section[mcp.name] = renderMcpForTarget(mcp, spec);
+        cfg[spec.mcpRootKey] = section;
+        return true;
+    });
+    setClaudeProjectMcpApproval(mcp.name, spec, true);
 }
 function unregisterMcpInTarget(mcpName, spec) {
     if (spec.mcpMechanism === "hermes-cli") {
@@ -282,14 +338,17 @@ function unregisterMcpInTarget(mcpName, spec) {
     }
     if (!existsSync(spec.mcpConfigPath))
         return false;
-    const cfg = readJsonOrEmpty(spec.mcpConfigPath);
-    const section = cfg[spec.mcpRootKey];
-    if (!section || !(mcpName in section))
+    const removed = updateJsonFile(spec.mcpConfigPath, (cfg) => {
+        const section = cfg[spec.mcpRootKey];
+        if (!section || !(mcpName in section))
+            return false;
+        delete section[mcpName];
+        cfg[spec.mcpRootKey] = section;
+        return true;
+    });
+    if (!removed)
         return false;
-    delete section[mcpName];
-    cfg[spec.mcpRootKey] = section;
-    backupIfExists(spec.mcpConfigPath);
-    atomicWriteFile(spec.mcpConfigPath, `${JSON.stringify(cfg, null, 2)}\n`);
+    setClaudeProjectMcpApproval(mcpName, spec, false);
     return true;
 }
 const HERMES_CLI_TIMEOUT_MS = 20_000;
@@ -439,7 +498,7 @@ function tomlBasicString(s) {
 }
 export function renderMcpToml(mcp) {
     if (mcp.transport === "stdio") {
-        const { command, args } = adaptStdioCommand(mcp.command ?? "", mcp.args ?? []);
+        const { command, args } = stdioLaunch(mcp);
         const lines = [`[mcp_servers.${mcp.name}]`, `command = ${tomlBasicString(command)}`];
         if (args.length > 0) {
             lines.push(`args = [${args.map((a) => tomlBasicString(a)).join(", ")}]`);
@@ -619,31 +678,27 @@ const LEGACY_RENAMED_SKILLS = ["alanube", "alegra-producto", "alegra-ce-universe
 function stripMcpEntries(path, names) {
     if (!existsSync(path) || names.length === 0)
         return;
-    let cfg;
     try {
-        cfg = JSON.parse(readFileSync(path, "utf-8"));
+        updateJsonFile(path, (cfg) => {
+            let changed = false;
+            for (const key of ["mcpServers", "mcp"]) {
+                const section = cfg[key];
+                if (!section || typeof section !== "object")
+                    continue;
+                for (const n of names) {
+                    if (n in section) {
+                        delete section[n];
+                        changed = true;
+                    }
+                }
+                if (Object.keys(section).length === 0)
+                    delete cfg[key];
+            }
+            return changed;
+        });
     }
     catch {
-        return;
     }
-    let changed = false;
-    for (const key of ["mcpServers", "mcp"]) {
-        const section = cfg[key];
-        if (!section || typeof section !== "object")
-            continue;
-        for (const n of names) {
-            if (n in section) {
-                delete section[n];
-                changed = true;
-            }
-        }
-        if (Object.keys(section).length === 0)
-            delete cfg[key];
-    }
-    if (!changed)
-        return;
-    backupIfExists(path);
-    atomicWriteFile(path, `${JSON.stringify(cfg, null, 2)}\n`);
 }
 function cleanupLegacySkillArtifacts(spec) {
     try {
@@ -839,6 +894,19 @@ export function installMcp(mcp, opts = {}) {
             error: "ningún target soportado disponible",
         };
     }
+    if (mcp.lazy && !opts.dryRun) {
+        try {
+            ensureLazyProxy(mcp);
+        }
+        catch (err) {
+            return {
+                name: mcp.name,
+                kind: "mcp",
+                status: "failed",
+                error: `no se pudo escribir el proxy de arranque diferido: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
     const prev = lock.mcps[mcp.name];
     const targetsMatch = prev?.targets &&
         prev.targets.length === targetIds.length &&
@@ -936,6 +1004,15 @@ export async function installAll(opts = {}) {
         const mcp = manifest.mcps?.[name];
         if (!mcp)
             continue;
+        if (mcp.name !== name) {
+            results.push({
+                name,
+                kind: "mcp",
+                status: "failed",
+                error: `la entry "${name}" declara name "${mcp.name}"`,
+            });
+            continue;
+        }
         results.push(installMcp(mcp, { ...opts, targets }));
     }
     return { manifest, results, targets };
@@ -1032,6 +1109,7 @@ export function uninstallAll(opts = {}) {
             catch {
             }
         }
+        rmSync(lazyMcpDir(), { recursive: true, force: true });
     }
     return results;
 }

package/dist/lazy-mcp.js

@@ -0,0 +1,153 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { COMMAND_NAME, adaptStdioCommand } from "./lib.js";
+export function lazyMcpDir() {
+    return join(homedir(), ".alegra", "mcp");
+}
+export function lazyProxyPath() {
+    return join(lazyMcpDir(), "lazy-mcp-proxy.mjs");
+}
+export function lazyToolsPath(name) {
+    return join(lazyMcpDir(), `${name}.tools.json`);
+}
+export function stdioLaunch(mcp, platform = process.platform) {
+    const inner = adaptStdioCommand(mcp.command ?? "", mcp.args ?? [], platform);
+    if (!mcp.lazy)
+        return inner;
+    return {
+        command: "node",
+        args: [lazyProxyPath(), lazyToolsPath(mcp.name), "--", inner.command, ...inner.args],
+    };
+}
+export function ensureLazyProxy(mcp) {
+    if (!mcp.lazy)
+        return;
+    mkdirSync(lazyMcpDir(), { recursive: true });
+    writeIfChanged(lazyProxyPath(), lazyProxySource());
+    writeIfChanged(lazyToolsPath(mcp.name), `${JSON.stringify({ name: mcp.name, 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 });
+}
+export function lazyProxySource() {
+    const product = JSON.stringify(COMMAND_NAME);
+    return `#!/usr/bin/env node
+// 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 { readFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+
+const argv = process.argv.slice(2);
+const sep = argv.indexOf("--");
+if (sep !== 1 || argv.length < 3) {
+  process.stderr.write("uso: lazy-mcp-proxy.mjs <tools.json> -- <comando> [args…]\\n");
+  process.exit(2);
+}
+const spec = JSON.parse(readFileSync(argv[0], "utf8"));
+const [cmd, ...args] = argv.slice(2);
+const INIT_ID = "__alegra_lazy_init__";
+
+const send = (m) => process.stdout.write(JSON.stringify(m) + "\\n");
+let initParams = null;
+let child = null;
+let ready = false;
+let dead = null;
+const queue = [];
+
+function errorFor(m, reason) {
+  if (m.method === "tools/call") {
+    return { jsonrpc: "2.0", id: m.id, result: { content: [{ type: "text", text: reason }], isError: true } };
+  }
+  return { jsonrpc: "2.0", id: m.id, error: { code: -32603, message: reason } };
+}
+
+function die(reason) {
+  dead = reason;
+  ready = false;
+  for (const m of queue.splice(0)) send(errorFor(m, reason));
+}
+
+function start() {
+  if (child || dead) return;
+  child = spawn(cmd, args, { stdio: ["pipe", "pipe", "inherit"] });
+  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.");
+  });
+  createInterface({ input: child.stdout }).on("line", (line) => {
+    if (ready) {
+      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.error) {
+      die("El MCP " + spec.name + " rechazó el handshake: " + (m.error.message ?? "sin detalle"));
+      child.kill();
+      return;
+    }
+    ready = true;
+    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");
+  });
+  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) => {
+  if (ready) {
+    child.stdin.write(line + "\\n");
+    return;
+  }
+  let m;
+  try { m = JSON.parse(line); } catch { return; }
+  switch (m.method) {
+    case "initialize":
+      initParams = m.params ?? {};
+      send({
+        jsonrpc: "2.0",
+        id: m.id,
+        result: {
+          protocolVersion: initParams.protocolVersion ?? "2025-06-18",
+          capabilities: { tools: {} },
+          serverInfo: { name: spec.name, version: "lazy" },
+        },
+      });
+      return;
+    case "ping":
+      send({ jsonrpc: "2.0", id: m.id, result: {} });
+      return;
+    case "tools/list":
+      send({ jsonrpc: "2.0", id: m.id, result: { tools: spec.tools } });
+      return;
+    case "resources/list":
+      send({ jsonrpc: "2.0", id: m.id, result: { resources: [] } });
+      return;
+    case "resources/templates/list":
+      send({ jsonrpc: "2.0", id: m.id, result: { resourceTemplates: [] } });
+      return;
+    case "prompts/list":
+      send({ jsonrpc: "2.0", id: m.id, result: { prompts: [] } });
+      return;
+  }
+  if (m.id === undefined || m.id === null) return; // notificación: nada que contestar
+  if (dead) {
+    send(errorFor(m, dead));
+    return;
+  }
+  queue.push(m);
+  start();
+});
+
+process.stdin.on("end", () => {
+  if (child) child.kill();
+  process.exit(0);
+});
+`;
+}

package/dist/lib.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, relative, sep } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 export const PRODUCT_NAME = "alegra-data-agent";
 export const COMMAND_NAME = "alegra-data-agent";
@@ -29,6 +29,78 @@ export function getClaudeSettingsPath() {
 export function getClaudeJsonPath() {
     return join(homedir(), ".claude.json");
 }
+export function getAgentConfPath() {
+    return join(homedir(), ".alegra", "agent.conf");
+}
+function readAgentConf() {
+    const path = getAgentConfPath();
+    if (!existsSync(path))
+        return {};
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch {
+        return {};
+    }
+    const out = {};
+    for (const line0 of raw.split("\n")) {
+        const line = line0.trim();
+        if (line.length === 0 || line.startsWith("#"))
+            continue;
+        const eq = line.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = line.slice(0, eq).trim();
+        const value = line
+            .slice(eq + 1)
+            .trim()
+            .replace(/^(["'])(.*)\1$/, "$2");
+        if (key.length > 0)
+            out[key] = value;
+    }
+    return out;
+}
+function resolveMcpScope() {
+    const raw = process.env.ALEGRA_DATA_AGENT_MCP_DIR ?? readAgentConf().MCP_DIR;
+    if (!raw || raw.trim().length === 0)
+        return { dir: undefined, warning: undefined };
+    const expanded = raw.trim().replace(/^~(?=$|\/)/, homedir());
+    if (!isAbsolute(expanded)) {
+        return {
+            dir: undefined,
+            warning: `MCP_DIR debe ser una ruta absoluta; se ignoró "${raw.trim()}"`,
+        };
+    }
+    const dir = resolve(expanded);
+    let isDir;
+    try {
+        isDir = existsSync(dir) && statSync(dir).isDirectory();
+    }
+    catch {
+        isDir = false;
+    }
+    if (!isDir) {
+        return {
+            dir: undefined,
+            warning: `MCP_DIR apunta a una carpeta que no existe; se ignoró "${dir}"`,
+        };
+    }
+    return { dir, warning: undefined };
+}
+export function getMcpScopeWarning() {
+    return resolveMcpScope().warning;
+}
+export function getMcpScopeDir() {
+    return resolveMcpScope().dir;
+}
+function mcpScopedPath(relPath, fallback) {
+    const dir = getMcpScopeDir();
+    return dir ? join(dir, relPath) : fallback;
+}
+export function getClaudeMcpConfigPath() {
+    return mcpScopedPath(".mcp.json", getClaudeJsonPath());
+}
 export function getCursorSkillsDir() {
     return join(homedir(), ".cursor", "skills");
 }
@@ -36,7 +108,7 @@ export function getCursorLegacyRulesDir() {
     return join(homedir(), ".cursor", "rules");
 }
 export function getCursorMcpPath() {
-    return join(homedir(), ".cursor", "mcp.json");
+    return mcpScopedPath(join(".cursor", "mcp.json"), join(homedir(), ".cursor", "mcp.json"));
 }
 export function getOpenCodeSkillsDir() {
     const xdgHome = process.env.XDG_CONFIG_HOME;
@@ -137,7 +209,7 @@ export function getTargetSkillsDir(target) {
 export function getTargetMcpConfigPath(target) {
     switch (target) {
         case "claude-code":
-            return getClaudeJsonPath();
+            return getClaudeMcpConfigPath();
         case "cursor":
             return getCursorMcpPath();
         case "opencode":

package/dist/render.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { extname, join } from "node:path";
-import { adaptStdioCommand, parseFrontmatter } from "./lib.js";
+import { stdioLaunch } from "./lazy-mcp.js";
+import { parseFrontmatter } from "./lib.js";
 function readSkillEntryPoint(skillDir) {
     const candidates = ["SKILL.md", "README.md"];
     for (const c of candidates) {
@@ -95,7 +96,7 @@ export function renderMcpForTarget(mcp, spec) {
     return obj;
 }
 function renderStdioMcpForTarget(mcp, spec) {
-    const { command, args } = adaptStdioCommand(mcp.command ?? "", mcp.args ?? []);
+    const { command, args } = stdioLaunch(mcp);
     const hasEnv = mcp.env && Object.keys(mcp.env).length > 0;
     if (spec.id === "opencode") {
         const obj = { type: "local", command: [command, ...args], enabled: true };
@@ -125,7 +126,7 @@ function bearerInterpolation(env, target) {
 }
 export function renderHermesMcpOps(mcp) {
     if (mcp.transport === "stdio") {
-        const { command, args } = adaptStdioCommand(mcp.command ?? "", mcp.args ?? []);
+        const { command, args } = stdioLaunch(mcp);
         const ops = [{ path: "command", value: command }];
         if (args.length > 0)
             ops.push({ path: "args", value: JSON.stringify(args) });

package/dist/signature.js

@@ -12,16 +12,19 @@ export const TRUSTED_KEYS = [
 ];
 export const PUBLIC_KEY_B64 = TRUSTED_KEYS[0].publicKeyB64;
 export function canonicalize(obj) {
-    if (obj === null || typeof obj !== "object")
-        return JSON.stringify(obj);
-    if (Array.isArray(obj)) {
-        return `[${obj.map((v) => canonicalize(v)).join(",")}]`;
+    return canonicalValue(obj, true);
+}
+function canonicalValue(value, isRoot) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => canonicalValue(v, false)).join(",")}]`;
     }
-    const o = obj;
+    const o = value;
     const keys = Object.keys(o)
-        .filter((k) => k !== "signature")
+        .filter((k) => !(isRoot && k === "signature"))
         .sort();
-    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalize(o[k])}`).join(",")}}`;
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalValue(o[k], false)}`).join(",")}}`;
 }
 const MAX_MANIFEST_AGE_DAYS = 90;
 export function verifyManifestSignature(manifest, options = {}) {

package/dist/targets.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { getAntigravityGeminiSkillsDir, getAntigravityMcpConfigPath, getAntigravitySkillsDir, getClaudeJsonPath, getClaudeSkillsDir, getCodexConfigPath, getCodexSkillsDir, getCursorMcpPath, getCursorSkillsDir, getHermesConfigPath, getHermesHome, getHermesSkillsDir, getOpenCodeConfigPath, getOpenCodeSkillsDir, } from "./lib.js";
+import { getAntigravityGeminiSkillsDir, getAntigravityMcpConfigPath, getAntigravitySkillsDir, getClaudeMcpConfigPath, getClaudeSkillsDir, getCodexConfigPath, getCodexSkillsDir, getCursorMcpPath, getCursorSkillsDir, getHermesConfigPath, getHermesHome, getHermesSkillsDir, getOpenCodeConfigPath, getOpenCodeSkillsDir, } from "./lib.js";
 export const TARGETS = {
     "claude-code": {
         id: "claude-code",
@@ -9,7 +9,7 @@ export const TARGETS = {
         mcpHttpTypeValue: "http",
         skillsDir: getClaudeSkillsDir(),
         skillFormat: "folder",
-        mcpConfigPath: getClaudeJsonPath(),
+        mcpConfigPath: getClaudeMcpConfigPath(),
         mcpRootKey: "mcpServers",
         mcpUrlKey: "url",
     },

package/package.json

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