alegra-data-agent 0.3.1 → 0.4.1

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/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,11 @@
+import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { copyFileSync, existsSync, readFileSync, readdirSync, renameSync, rmSync, 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 { adaptStdioCommand, ensureDir, getAntigravityGeminiLegacyMcpConfigPath, getAntigravityGeminiLegacySkillsDir, getAntigravityLegacyMcpConfigPath, getAntigravityLegacySkillsDir, getClaudeSettingsPath, getCursorLegacyRulesDir, getHermesBin, getLockFilePath, 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-]*$/;
@@ -257,6 +258,10 @@ function readJsonOrEmpty(path) {
 }
 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;
@@ -269,6 +274,9 @@ function registerMcpInTarget(mcp, spec) {
     atomicWriteFile(spec.mcpConfigPath, `${JSON.stringify(cfg, null, 2)}\n`);
 }
 function unregisterMcpInTarget(mcpName, spec) {
+    if (spec.mcpMechanism === "hermes-cli") {
+        return unregisterMcpInHermes(mcpName, spec);
+    }
     if (spec.mcpMechanism === "toml-block") {
         return unregisterMcpInTomlBlock(mcpName, spec);
     }
@@ -284,6 +292,148 @@ function unregisterMcpInTarget(mcpName, spec) {
     atomicWriteFile(spec.mcpConfigPath, `${JSON.stringify(cfg, null, 2)}\n`);
     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, '\\"')}"`;
 }
@@ -382,7 +532,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 +552,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") {
@@ -594,12 +757,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 {
@@ -723,12 +890,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);

package/dist/lib.js

@@ -14,6 +14,7 @@ export const ALL_TARGETS = [
     "opencode",
     "antigravity",
     "codex",
+    "hermes",
 ];
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export function getPackageRoot() {
@@ -100,6 +101,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,6 +130,8 @@ export function getTargetSkillsDir(target) {
             return getAntigravitySkillsDir();
         case "codex":
             return getCodexSkillsDir();
+        case "hermes":
+            return getHermesSkillsDir();
     }
 }
 export function getTargetMcpConfigPath(target) {
@@ -126,6 +146,8 @@ export function getTargetMcpConfigPath(target) {
             return getAntigravityMcpConfigPath();
         case "codex":
             return getCodexConfigPath();
+        case "hermes":
+            return getHermesConfigPath();
     }
 }
 export function getLockFilePath() {

package/dist/render.js

@@ -119,5 +119,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 } = adaptStdioCommand(mcp.command ?? "", mcp.args ?? []);
+        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/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, getClaudeJsonPath, getClaudeSkillsDir, getCodexConfigPath, getCodexSkillsDir, getCursorMcpPath, getCursorSkillsDir, getHermesConfigPath, getHermesHome, getHermesSkillsDir, getOpenCodeConfigPath, getOpenCodeSkillsDir, } from "./lib.js";
 export const TARGETS = {
     "claude-code": {
         id: "claude-code",
@@ -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.3.1",
+  "version": "0.4.1",
   "private": false,
   "description": "Agente de Data interno de Alegra. Instala skills + MCPs en tu cliente de IA con un comando.",
   "license": "UNLICENSED",