alegra-data-agent 0.4.0 → 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/autoupdate.js

@@ -1,8 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
 import { logWarn } from "./colors.js";
 import { hookCommandFor, runHookInstall, runHookUninstall, } from "./commands/hook.js";
-import { COMMAND_NAME, getClaudeSettingsPath, getCodexHooksPath, getCursorHooksPath, getGeminiSettingsPath, getOpenCodePluginPath, readLockFile, } from "./lib.js";
+import { HERMES_PLUGIN_NAME, hermesPluginManifest, hermesPluginModule } from "./hermes-plugin.js";
+import { runHermesCliAt } from "./installer.js";
+import { COMMAND_NAME, getClaudeSettingsPath, getCodexHooksPath, getCursorHooksPath, getGeminiSettingsPath, getHermesHome, getHermesPluginsDir, getOpenCodePluginPath, readLockFile, } from "./lib.js";
 function readJsonSafe(path) {
     if (!existsSync(path))
         return {};
@@ -111,6 +113,49 @@ export const AlegraDataAgentAutoUpdate = async ({ $ }) => {
 `;
     writeFileSync(path, plugin, "utf-8");
 }
+function installHermes(command) {
+    const dir = join(getHermesPluginsDir(), HERMES_PLUGIN_NAME);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "plugin.yaml"), hermesPluginManifest(), "utf-8");
+    writeFileSync(join(dir, "__init__.py"), hermesPluginModule(command), "utf-8");
+    enableHermesPlugin();
+}
+function enableHermesPlugin() {
+    const res = runHermesCliAt(getHermesHome(), ["plugins", "enable", HERMES_PLUGIN_NAME]);
+    if (res.ok)
+        return;
+    logWarn(res.missingBinary
+        ? `No encontré el binario 'hermes' en el PATH: el plugin de auto-update quedó escrito pero sin habilitar (corré 'hermes plugins enable ${HERMES_PLUGIN_NAME}').`
+        : `No pude habilitar el plugin de auto-update de Hermes: ${(res.stderr || res.stdout).trim().slice(0, 200)}`);
+}
+function removeHermesPlugin() {
+    const dir = join(getHermesPluginsDir(), HERMES_PLUGIN_NAME);
+    if (!existsSync(dir))
+        return;
+    const home = getHermesHome();
+    runHermesCliAt(home, ["plugins", "disable", HERMES_PLUGIN_NAME]);
+    rmSync(dir, { recursive: true, force: true });
+    dropHermesPluginFromList(home, "enabled");
+    dropHermesPluginFromList(home, "disabled");
+    runHermesCliAt(home, ["config", "unset", `plugins.entries.${HERMES_PLUGIN_NAME}`]);
+}
+function dropHermesPluginFromList(home, key) {
+    const res = runHermesCliAt(home, ["config", "get", `plugins.${key}`]);
+    if (!res.ok)
+        return;
+    const names = res.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("- "))
+        .map((line) => line
+        .slice(2)
+        .trim()
+        .replace(/^['"]|['"]$/g, ""));
+    if (!names.includes(HERMES_PLUGIN_NAME))
+        return;
+    const kept = names.filter((n) => n !== HERMES_PLUGIN_NAME);
+    runHermesCliAt(home, ["config", "set", `plugins.${key}`, JSON.stringify(kept)]);
+}
 function removeJsonHook(path, key) {
     const cfg = readJsonSafe(path);
     if (!cfg)
@@ -147,6 +192,9 @@ export function installAutoUpdate(target, mode = "auto") {
             case "opencode":
                 installOpenCode(hookCommandFor(effective));
                 break;
+            case "hermes":
+                installHermes(hookCommandFor(effective));
+                break;
         }
     }
     catch (err) {
@@ -174,6 +222,9 @@ export function removeAutoUpdate(target) {
                     rmSync(p, { force: true });
                 break;
             }
+            case "hermes":
+                removeHermesPlugin();
+                break;
         }
     }
     catch (err) {
@@ -199,6 +250,10 @@ export function hasAutoUpdate(target) {
             return jsonHookHasOurs(getGeminiSettingsPath(), "SessionStart");
         case "opencode":
             return existsSync(getOpenCodePluginPath());
+        case "hermes": {
+            const manifest = join(getHermesPluginsDir(), HERMES_PLUGIN_NAME, "plugin.yaml");
+            return existsSync(manifest);
+        }
     }
 }
 export function refreshAutoUpdate() {

package/dist/commands/install.js

@@ -124,7 +124,7 @@ function printSummary(results, manifest, targets) {
 }
 function printNextSteps(noHook) {
     section("Ya estás listo");
-    log(`   ${bold(yellow("1."))} ${bold("Reiniciá tu cliente")} ${gray("(Claude Code, Cursor, OpenCode, Antigravity o Codex)")}.`);
+    log(`   ${bold(yellow("1."))} ${bold("Reiniciá tu cliente")} ${gray("(Claude Code, Cursor, OpenCode, Antigravity, Codex o Hermes)")}.`);
     log(`   ${bold(yellow("2."))} ${bold("Hacele tu pregunta en español.")}`);
     log(`      ${gray("Ejemplo:")} ${cyan('"cuántos nuevos clientes en mayo en Colombia?"')}`);
     log("");

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/hermes-plugin.js

@@ -0,0 +1,83 @@
+import { COMMAND_NAME } from "./lib.js";
+export const HERMES_PLUGIN_NAME = "alegra-data-agent-autoupdate";
+export function hermesPluginManifest() {
+    return `# Generado por ${COMMAND_NAME}. Borrar esta carpeta desactiva el auto-update.
+name: ${HERMES_PLUGIN_NAME}
+version: 1.0.0
+description: Mantiene al día las skills y MCPs de ${COMMAND_NAME} al iniciar una sesión de Hermes.
+provides_hooks:
+  - on_session_start
+`;
+}
+export function hermesPluginModule(command) {
+    const commandLiteral = JSON.stringify(command);
+    const productLiteral = JSON.stringify(COMMAND_NAME);
+    return `"""Auto-update de ${COMMAND_NAME} al iniciar una sesión de Hermes.
+
+Generado por el instalador — no editar a mano. Borrar esta carpeta (o correr
+\`${COMMAND_NAME} uninstall\`) desactiva el auto-update.
+"""
+
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+COMMAND = ${commandLiteral}
+
+# Hermes puede arrancar sin el PATH del shell del usuario (Desktop, servicios):
+# ahí \`pnpm\` no resuelve y el auto-update moriría en silencio.
+EXTRA_PATH_DIRS = (
+    os.environ.get("PNPM_HOME", ""),
+    os.path.expanduser("~/.local/share/pnpm"),
+    os.path.expanduser("~/Library/pnpm"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+)
+
+
+def _log_skip(reason: str) -> None:
+    """Deja constancia en autoupdate.log — el mismo archivo que reporta status."""
+    try:
+        base = os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config")
+        log_file = Path(base) / ${productLiteral} / "autoupdate.log"
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        with log_file.open("a", encoding="utf-8") as fh:
+            fh.write(f"[hermes] {reason}\\n")
+    except Exception:
+        pass
+
+
+def _run_update(**_kwargs) -> None:
+    """Lanza el update y vuelve: nunca bloquea ni rompe el arranque."""
+    try:
+        argv = shlex.split(COMMAND)
+        if not argv:
+            return
+        env = dict(os.environ)
+        extra = [d for d in EXTRA_PATH_DIRS if d and os.path.isdir(d)]
+        if extra:
+            env["PATH"] = os.pathsep.join(extra + [env.get("PATH", "")])
+        if shutil.which(argv[0], path=env.get("PATH")) is None:
+            _log_skip(f"'{argv[0]}' no esta en el PATH; auto-update omitido")
+            return
+        subprocess.Popen(
+            argv,
+            env=env,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+    except Exception as exc:
+        logger.debug("%s: auto-update no se pudo lanzar: %s", ${productLiteral}, exc)
+
+
+def register(ctx):
+    ctx.register_hook("on_session_start", _run_update)
+`;
+}

package/dist/installer.js

@@ -1,10 +1,12 @@
+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, getLockFilePath, getOpenCodeLegacyPromptsDir, getPackageVersion, readLockFile, sha256File, writeLockFile, } from "./lib.js";
-import { inlineReferences, renderMcpForTarget } from "./render.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-]*$/;
 const MCP_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
@@ -42,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");
 }
@@ -197,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);
@@ -245,51 +262,243 @@ 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") {
+        registerMcpInHermes(mcp, spec);
+        return;
+    }
     if (spec.mcpMechanism === "toml-block") {
         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") {
+        return unregisterMcpInHermes(mcpName, spec);
+    }
     if (spec.mcpMechanism === "toml-block") {
         return unregisterMcpInTomlBlock(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;
+export function runHermesCliAt(hermesHome, args) {
+    const res = spawnSync(getHermesBin(), args, {
+        encoding: "utf-8",
+        timeout: HERMES_CLI_TIMEOUT_MS,
+        env: { ...process.env, HERMES_HOME: hermesHome },
+    });
+    const missingBinary = res.error?.code === "ENOENT";
+    return {
+        ok: res.status === 0,
+        stdout: res.stdout ?? "",
+        stderr: res.stderr ?? res.error?.message ?? "",
+        missingBinary,
+    };
+}
+function runHermesCli(spec, args) {
+    return runHermesCliAt(dirname(spec.mcpConfigPath), args);
+}
+function hermesCliError(action, res) {
+    if (res.missingBinary) {
+        return new Error(`no encontré el binario '${getHermesBin()}' en el PATH, necesario para registrar MCPs en Hermes. Instalá Hermes Agent (curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash) o apuntá HERMES_BIN al binario.`);
+    }
+    const detail = (res.stderr || res.stdout).trim().split("\n").slice(-1)[0] ?? "";
+    return new Error(`'hermes ${action}' falló: ${detail.slice(0, 300)}`);
+}
+function registerMcpInHermes(mcp, spec) {
+    for (const op of renderHermesMcpOps(mcp)) {
+        const key = `mcp_servers.${mcp.name}.${op.path}`;
+        const res = runHermesCli(spec, ["config", "set", key, op.value]);
+        if (!res.ok)
+            throw hermesCliError(`config set ${key}`, res);
+    }
+}
+function unregisterMcpInHermes(mcpName, spec) {
+    if (readHermesMcpFields(spec, mcpName) === null)
+        return false;
+    const key = `mcp_servers.${mcpName}`;
+    const res = runHermesCli(spec, ["config", "unset", key]);
+    if (!res.ok)
+        throw hermesCliError(`config unset ${key}`, res);
     return true;
 }
+export function readHermesMcpFields(spec, name) {
+    const res = runHermesCli(spec, ["config", "get", `mcp_servers.${name}`]);
+    if (!res.ok)
+        return null;
+    return parseHermesConfigGet(res.stdout);
+}
+export function parseHermesConfigGet(text) {
+    const out = {};
+    let groupKey = null;
+    let groupIndent = 0;
+    let group = null;
+    const closeGroup = () => {
+        if (groupKey !== null && group !== null)
+            out[groupKey] = group;
+        groupKey = null;
+        group = null;
+    };
+    for (const raw of text.split(/\r?\n/)) {
+        if (raw.trim() === "")
+            continue;
+        const line = raw.trim();
+        const indent = raw.length - raw.trimStart().length;
+        if (groupKey !== null) {
+            if (line.startsWith("- ") && indent >= groupIndent) {
+                const list = Array.isArray(group) ? [...group] : [];
+                list.push(unquoteYamlScalar(line.slice(2).trim()));
+                group = list;
+                continue;
+            }
+            if (indent > groupIndent) {
+                const kv = line.match(/^([A-Za-z0-9_.-]+):\s*(.+)$/);
+                if (kv) {
+                    const map = group !== null && !Array.isArray(group) ? { ...group } : {};
+                    map[kv[1]] = unquoteYamlScalar(kv[2].trim());
+                    group = map;
+                    continue;
+                }
+            }
+            closeGroup();
+        }
+        const kv = line.match(/^([A-Za-z0-9_.-]+):\s*(.*)$/);
+        if (!kv)
+            continue;
+        if (kv[2] === "") {
+            groupKey = kv[1];
+            groupIndent = indent;
+            group = null;
+            continue;
+        }
+        out[kv[1]] = unquoteYamlScalar(kv[2].trim());
+    }
+    closeGroup();
+    return Object.keys(out).length > 0 ? out : null;
+}
+function unquoteYamlScalar(value) {
+    if (value.length >= 2) {
+        const first = value[0];
+        const last = value[value.length - 1];
+        if ((first === "'" && last === "'") || (first === '"' && last === '"')) {
+            return value.slice(1, -1);
+        }
+    }
+    return value;
+}
+function normalizeHermesValue(value) {
+    if (value === undefined)
+        return null;
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+}
+function hermesExpectedFields(mcp) {
+    const expected = {};
+    for (const op of renderHermesMcpOps(mcp))
+        expected[op.path] = parseHermesSerialized(op.value);
+    return expected;
+}
+function parseHermesSerialized(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return value;
+        }
+    }
+    return value;
+}
+export function hermesExpectedSnapshot(mcp) {
+    return stableStringify(hermesExpectedFields(mcp));
+}
+export function hermesActualSnapshot(mcp, fields) {
+    const actual = {};
+    for (const op of renderHermesMcpOps(mcp))
+        actual[op.path] = normalizeHermesValue(fields[op.path]);
+    return stableStringify(actual);
+}
 function tomlBasicString(s) {
     return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 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(", ")}]`);
@@ -382,7 +591,9 @@ function unregisterMcpInTomlBlock(name, spec) {
 export function renderedEntryHash(mcp, spec) {
     const rendered = spec.mcpMechanism === "toml-block"
         ? renderMcpToml(mcp).trim()
-        : stableStringify(renderMcpForTarget(mcp, spec));
+        : spec.mcpMechanism === "hermes-cli"
+            ? hermesExpectedSnapshot(mcp)
+            : stableStringify(renderMcpForTarget(mcp, spec));
     return createHash("sha256").update(rendered).digest("hex");
 }
 function hashOf(value) {
@@ -400,6 +611,17 @@ function isDiscardedByClient(current, spec) {
 }
 export function inspectMcpInTarget(mcp, spec, prevHash) {
     try {
+        if (spec.mcpMechanism === "hermes-cli") {
+            const fields = readHermesMcpFields(spec, mcp.name);
+            if (fields === null)
+                return "missing";
+            const current = hermesActualSnapshot(mcp, fields);
+            if (current === hermesExpectedSnapshot(mcp))
+                return "ok";
+            if (prevHash && hashOf(current) === prevHash)
+                return "stale";
+            return "modified";
+        }
         if (!existsSync(spec.mcpConfigPath))
             return "missing";
         if (spec.mcpMechanism === "toml-block") {
@@ -456,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 {
@@ -594,12 +812,16 @@ export async function installSkill(name, manifest, opts = {}) {
             error: failures.join("; "),
         };
     }
+    const outOfScopeTargets = prev && prev.bundleHash === entry.bundleHash
+        ? (prev.targets ?? []).filter((t) => !targetIds.includes(t))
+        : [];
+    const lockTargets = [...new Set([...outOfScopeTargets, ...okTargets])];
     lock.skills[name] = {
         name,
         installedFrom: getPackageVersion(),
         installedAt: new Date().toISOString(),
         bundleHash: entry.bundleHash,
-        targets: okTargets,
+        targets: lockTargets,
     };
     writeLockFile(lock);
     return {
@@ -672,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 &&
@@ -723,12 +958,16 @@ export function installMcp(mcp, opts = {}) {
         if (okTargets.includes(t.id))
             renderedHash[t.id] = renderedEntryHash(mcp, t);
     }
+    const outOfScopeTargets = configChanged
+        ? []
+        : (prev?.targets ?? []).filter((t) => !targetIds.includes(t) && (!mcp.targets || mcp.targets.includes(t)));
+    const lockTargets = [...new Set([...outOfScopeTargets, ...okTargets])];
     lock.mcps[mcp.name] = {
         name: mcp.name,
         installedFrom: getPackageVersion(),
         installedAt: new Date().toISOString(),
         configHash: mcpConfigHash(mcp),
-        targets: okTargets,
+        targets: lockTargets,
         renderedHash,
     };
     writeLockFile(lock);
@@ -765,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 };
@@ -861,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";
@@ -14,6 +14,7 @@ export const ALL_TARGETS = [
     "opencode",
     "antigravity",
     "codex",
+    "hermes",
 ];
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export function getPackageRoot() {
@@ -28,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");
 }
@@ -35,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;
@@ -100,6 +173,23 @@ export function getCodexConfigPath() {
     const base = codexHome && codexHome.length > 0 ? codexHome : join(homedir(), ".codex");
     return join(base, "config.toml");
 }
+export function getHermesHome() {
+    const hermesHome = process.env.HERMES_HOME;
+    return hermesHome && hermesHome.length > 0 ? hermesHome : join(homedir(), ".hermes");
+}
+export function getHermesSkillsDir() {
+    return join(getHermesHome(), "skills");
+}
+export function getHermesConfigPath() {
+    return join(getHermesHome(), "config.yaml");
+}
+export function getHermesPluginsDir() {
+    return join(getHermesHome(), "plugins");
+}
+export function getHermesBin() {
+    const bin = process.env.HERMES_BIN;
+    return bin && bin.length > 0 ? bin : "hermes";
+}
 export function getTargetSkillsDir(target) {
     switch (target) {
         case "claude-code":
@@ -112,12 +202,14 @@ export function getTargetSkillsDir(target) {
             return getAntigravitySkillsDir();
         case "codex":
             return getCodexSkillsDir();
+        case "hermes":
+            return getHermesSkillsDir();
     }
 }
 export function getTargetMcpConfigPath(target) {
     switch (target) {
         case "claude-code":
-            return getClaudeJsonPath();
+            return getClaudeMcpConfigPath();
         case "cursor":
             return getCursorMcpPath();
         case "opencode":
@@ -126,6 +218,8 @@ export function getTargetMcpConfigPath(target) {
             return getAntigravityMcpConfigPath();
         case "codex":
             return getCodexConfigPath();
+        case "hermes":
+            return getHermesConfigPath();
     }
 }
 export function getLockFilePath() {

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 };
@@ -119,5 +120,38 @@ function bearerInterpolation(env, target) {
             return `Bearer {env:${env}}`;
         case "codex":
             throw new Error("codex usa config TOML (bearer_token_env_var), no headers JSON");
+        case "hermes":
+            return `Bearer \${${env}}`;
+    }
+}
+export function renderHermesMcpOps(mcp) {
+    if (mcp.transport === "stdio") {
+        const { command, args } = stdioLaunch(mcp);
+        const ops = [{ path: "command", value: command }];
+        if (args.length > 0)
+            ops.push({ path: "args", value: JSON.stringify(args) });
+        if (mcp.env && Object.keys(mcp.env).length > 0) {
+            ops.push({ path: "env", value: JSON.stringify(mcp.env) });
+        }
+        return ops;
+    }
+    const ops = [{ path: "url", value: mcp.url ?? "" }];
+    if (mcp.auth.type === "oauth") {
+        ops.push({ path: "auth", value: "oauth" });
     }
+    else if (mcp.auth.type === "gateway") {
+        if (!mcp.auth.tokenEnv) {
+            throw new Error(`MCP '${mcp.name}' es type=gateway pero no trae tokenEnv`);
+        }
+        ops.push({
+            path: "headers",
+            value: JSON.stringify({ Authorization: bearerInterpolation(mcp.auth.tokenEnv, "hermes") }),
+        });
+    }
+    return ops;
+}
+export function hermesManagedFields(mcp) {
+    return renderHermesMcpOps(mcp)
+        .map((op) => op.path)
+        .sort();
 }

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, 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",
     },
@@ -53,6 +53,16 @@ export const TARGETS = {
         mcpUrlKey: "url",
         mcpMechanism: "toml-block",
     },
+    hermes: {
+        id: "hermes",
+        label: "Hermes",
+        skillsDir: getHermesSkillsDir(),
+        skillFormat: "folder",
+        mcpConfigPath: getHermesConfigPath(),
+        mcpRootKey: "mcp_servers",
+        mcpUrlKey: "url",
+        mcpMechanism: "hermes-cli",
+    },
 };
 export function detectInstalledTargets() {
     const home = homedir();
@@ -68,6 +78,7 @@ export function detectInstalledTargets() {
         opencode: [join(xdgConfig, "opencode")],
         antigravity: [join(home, ".gemini", "antigravity-cli"), join(home, ".gemini", "antigravity")],
         codex: [codexHome],
+        hermes: [getHermesHome()],
     };
     const out = [];
     for (const id of Object.keys(sentinels)) {

package/dist/ui.js

@@ -44,7 +44,7 @@ ${bold("Comandos:")}
   login              Autenticarte con tu cuenta @alegra.com
   logout             Cerrar sesión (borra el token local)
   whoami             Mostrar la cuenta actualmente autenticada
-  install            Instala skills + MCPs en tus clientes (Claude Code, Cursor, OpenCode, Antigravity, Codex)
+  install            Instala skills + MCPs en tus clientes (Claude Code, Cursor, OpenCode, Antigravity, Codex, Hermes)
   update             Re-descarga skills/MCPs que cambiaron
   list               Lista skills y MCPs disponibles en el gateway
   status             Muestra estado: auth, instalado, drift
@@ -59,7 +59,7 @@ ${bold("Opciones:")}
   -y, --yes            No pedir confirmación — solo uninstall pregunta
       --dry-run        Mostrar qué se haría, sin tocar archivos
       --only=a,b,c     Instalar solo esas skills/MCPs
-      --target=NAME    Restringir al cliente NAME (claude-code|cursor|opencode|antigravity|codex)
+      --target=NAME    Restringir al cliente NAME (claude-code|cursor|opencode|antigravity|codex|hermes)
       --no-hook        No instalar el hook de SessionStart
       --no-bounce      No saltar a la última versión publicada (la usa el hook)
       --auto-update    Aceptado por compatibilidad — el hook ya es auto-update por default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alegra-data-agent",
-  "version": "0.4.0",
+  "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",