alegra-data-agent 0.2.3 → 0.2.5

package/dist/api.js

@@ -1,5 +1,7 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { readAuth } from "./auth.js";
-import { COMMAND_NAME, GATEWAY_URL, getPackageVersion } from "./lib.js";
+import { COMMAND_NAME, GATEWAY_URL, getManifestCachePath, getPackageVersion } from "./lib.js";
 import { verifyManifestSignature } from "./signature.js";
 export class ManifestSignatureError extends Error {
     constructor(reason) {
@@ -29,11 +31,12 @@ function newRequestId() {
     return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
 function userAgent() {
-    return `${COMMAND_NAME}/${getPackageVersion()} (+https://github.com/alegradev/alegra-data-agent)`;
+    return `${COMMAND_NAME}/${getPackageVersion()} (+https://github.com/Alegra-Team/data-agent-selfservice)`;
 }
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
+let rateLimitCooldownUntil = 0;
 async function authedFetch(path, opts = {}) {
     const auth = readAuth();
     if (!auth) {
@@ -49,6 +52,9 @@ async function authedFetch(path, opts = {}) {
     let attempt = 0;
     const delays = [250, 750, 2250];
     while (true) {
+        const pending = rateLimitCooldownUntil - Date.now();
+        if (pending > 0)
+            await sleep(pending);
         const ac = new AbortController();
         const timer = setTimeout(() => ac.abort(), timeoutMs);
         let res;
@@ -59,6 +65,7 @@ async function authedFetch(path, opts = {}) {
                     Accept: "application/json,application/octet-stream",
                     "User-Agent": userAgent(),
                     "X-Request-Id": reqId,
+                    ...opts.headers,
                 },
                 signal: ac.signal,
             });
@@ -86,13 +93,16 @@ async function authedFetch(path, opts = {}) {
                 "Si saliste de Alegra, esto es esperado. Si no, contacta a #data.");
         }
         if (res.status === 429) {
+            const cap = maxRetries + 4;
             const ra = parseRetryAfter(res.headers.get("retry-after"));
-            if (ra !== null && ra <= 5_000 && attempt < maxRetries) {
-                await sleep(ra);
+            const wait = ra !== null ? ra : delays[Math.min(attempt, delays.length - 1)] * 2;
+            rateLimitCooldownUntil = Math.max(rateLimitCooldownUntil, Date.now() + wait);
+            if (attempt < cap) {
+                await sleep(wait);
                 attempt++;
                 continue;
             }
-            throw new GatewayError(429, path, "Rate limit excedido. Espera un minuto y vuelve a intentar.");
+            throw new GatewayError(429, path, `Rate limit del gateway tras ${cap + 1} intentos. Esperá un minuto y reintentá (request-id ${reqId}).`);
         }
         if (res.status >= 500 && res.status < 600) {
             if (attempt < maxRetries) {
@@ -102,6 +112,8 @@ async function authedFetch(path, opts = {}) {
             }
             throw new GatewayError(res.status, path, `Gateway con error ${res.status}. Reintenta en unos segundos. Si persiste, reporta a #data (request-id ${reqId}).`);
         }
+        if (res.status === 304 && opts.allowNotModified)
+            return res;
         if (!res.ok) {
             throw new GatewayError(res.status, path, `Gateway respondió ${res.status} en ${path}`);
         }
@@ -151,16 +163,76 @@ function mapNetworkError(err, path, timeoutMs) {
     }
     return new GatewayError(0, path, `Error de red al hablar con el gateway: ${err.message}`);
 }
+export function parseManifestCache(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null)
+            return null;
+        const { etag, manifest } = parsed;
+        if (typeof etag !== "string" || etag.length === 0)
+            return null;
+        if (typeof manifest !== "object" || manifest === null)
+            return null;
+        return { etag, manifest: manifest };
+    }
+    catch {
+        return null;
+    }
+}
+function readManifestCache() {
+    try {
+        return parseManifestCache(readFileSync(getManifestCachePath(), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeManifestCache(etag, manifest) {
+    const path = getManifestCachePath();
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        const tmp = `${path}.${process.pid}.tmp`;
+        writeFileSync(tmp, `${JSON.stringify({ etag, manifest })}\n`, { mode: 0o600 });
+        try {
+            renameSync(tmp, path);
+        }
+        catch (err) {
+            rmSync(tmp, { force: true });
+            throw err;
+        }
+    }
+    catch {
+    }
+}
+function verifiedOrThrow(manifest) {
+    const check = verifyManifestSignature(manifest, { softFail: false });
+    if (!check.ok) {
+        throw new ManifestSignatureError(check.reason);
+    }
+    return manifest;
+}
 export async function fetchManifest(opts = {}) {
     try {
-        const res = await authedFetch("/api/manifest", opts);
+        const cached = readManifestCache();
+        const res = await authedFetch("/api/manifest", {
+            ...opts,
+            allowNotModified: true,
+            headers: cached ? { ...opts.headers, "If-None-Match": cached.etag } : opts.headers,
+        });
+        if (res.status === 304) {
+            if (cached)
+                return verifiedOrThrow(cached.manifest);
+            const retry = await authedFetch("/api/manifest", { ...opts, allowNotModified: false });
+            if (!retry.ok)
+                return null;
+            return verifiedOrThrow((await retry.json()));
+        }
         if (!res.ok)
             return null;
-        const manifest = (await res.json());
-        const check = verifyManifestSignature(manifest, { softFail: false });
-        if (!check.ok) {
-            throw new ManifestSignatureError(check.reason);
-        }
+        const manifest = verifiedOrThrow((await res.json()));
+        const etag = res.headers.get("etag");
+        if (etag)
+            writeManifestCache(etag, manifest);
         return manifest;
     }
     catch (err) {
@@ -178,8 +250,3 @@ export async function fetchSkillFile(skillName, relPath) {
     const buffer = await res.arrayBuffer();
     return new Uint8Array(buffer);
 }
-export async function fetchMcps(opts = {}) {
-    const res = await authedFetch("/api/mcps", opts);
-    const body = (await res.json());
-    return body.mcps ?? {};
-}

package/dist/auth.js

@@ -25,19 +25,26 @@ function constantTimeStringEq(a, b) {
         return false;
     return timingSafeEqual(ab, bb);
 }
+let _authCache = null;
 export function readAuth() {
+    if (_authCache)
+        return _authCache.value;
     const path = getAuthFilePath();
-    if (!existsSync(path))
-        return null;
-    try {
-        return JSON.parse(readFileSync(path, "utf-8"));
-    }
-    catch {
-        return null;
+    let value = null;
+    if (existsSync(path)) {
+        try {
+            value = JSON.parse(readFileSync(path, "utf-8"));
+        }
+        catch {
+            value = null;
+        }
     }
+    _authCache = { value };
+    return value;
 }
 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");
     try {
@@ -48,6 +55,7 @@ export function writeAuth(record) {
 }
 export function clearAuth() {
     const path = getAuthFilePath();
+    _authCache = { value: null };
     if (existsSync(path))
         rmSync(path, { force: true });
 }
@@ -278,6 +286,13 @@ function htmlPage(kind, subject) {
 </body>
 </html>`;
 }
+const HTML_ESCAPES = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+};
 function escapeHtml(s) {
-    return s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+    return s.replace(/[&<>"']/g, (c) => HTML_ESCAPES[c] ?? c);
 }

package/dist/autoupdate.js

@@ -0,0 +1,216 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } 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";
+function readJsonSafe(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJson(path, data) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp-${process.pid}`;
+    writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+    renameSync(tmp, path);
+}
+function entryIsOurs(m) {
+    if (!m || typeof m !== "object")
+        return false;
+    const o = m;
+    if (typeof o.command === "string" && o.command.includes(COMMAND_NAME))
+        return true;
+    if (Array.isArray(o.hooks)) {
+        return o.hooks.some((h) => h &&
+            typeof h === "object" &&
+            typeof h.command === "string" &&
+            h.command.includes(COMMAND_NAME));
+    }
+    return false;
+}
+function freshHookList(cfg, key) {
+    const hooks = (cfg.hooks && typeof cfg.hooks === "object" ? cfg.hooks : {});
+    cfg.hooks = hooks;
+    const list = Array.isArray(hooks[key]) ? hooks[key] : [];
+    return list.filter((m) => !entryIsOurs(m));
+}
+export function guiResilientCommand(base, opts) {
+    const platform = opts.platform ?? process.platform;
+    if (platform === "win32")
+        return opts.silence ? `${base} >NUL 2>&1` : base;
+    const extraDirs = [
+        dirname(process.execPath),
+        process.env.PNPM_HOME ?? "",
+        "$HOME/.local/share/pnpm",
+        "$HOME/Library/pnpm",
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+    ].filter(Boolean);
+    const run = opts.silence ? `${base} >/dev/null 2>&1` : base;
+    const logFile = `"\${XDG_CONFIG_HOME:-$HOME/.config}/${COMMAND_NAME}/autoupdate.log"`;
+    return (`PATH="$PATH:${extraDirs.join(":")}"; ` +
+        `if command -v pnpm >/dev/null 2>&1; then ${run}; ` +
+        `else mkdir -p "$(dirname ${logFile})" && ` +
+        `echo "$(date '+%Y-%m-%d %H:%M:%S') [${opts.client}] pnpm no esta en el PATH del cliente; auto-update omitido" >> ${logFile}; fi`);
+}
+function installCursor(command) {
+    const path = getCursorHooksPath();
+    const cfg = readJsonSafe(path);
+    if (cfg === null) {
+        logWarn(`${path} no es JSON válido; salteo el auto-update de Cursor.`);
+        return;
+    }
+    if (typeof cfg.version !== "number")
+        cfg.version = 1;
+    const list = freshHookList(cfg, "workspaceOpen");
+    list.push({ command });
+    cfg.hooks.workspaceOpen = list;
+    writeJson(path, cfg);
+}
+function installCodex(command) {
+    const path = getCodexHooksPath();
+    const cfg = readJsonSafe(path);
+    if (cfg === null) {
+        logWarn(`${path} no es JSON válido; salteo el auto-update de Codex.`);
+        return;
+    }
+    const list = freshHookList(cfg, "SessionStart");
+    list.push({ matcher: "startup|resume", hooks: [{ type: "command", command }] });
+    cfg.hooks.SessionStart = list;
+    writeJson(path, cfg);
+}
+function installAntigravity(command) {
+    const path = getGeminiSettingsPath();
+    const cfg = readJsonSafe(path);
+    if (cfg === null) {
+        logWarn(`${path} no es JSON válido; salteo el auto-update de Antigravity.`);
+        return;
+    }
+    const list = freshHookList(cfg, "SessionStart");
+    list.push({ hooks: [{ type: "command", command }] });
+    cfg.hooks.SessionStart = list;
+    writeJson(path, cfg);
+}
+function installOpenCode(command) {
+    const path = getOpenCodePluginPath();
+    mkdirSync(dirname(path), { recursive: true });
+    const plugin = `// alegra-data-agent: auto-update al iniciar OpenCode. Generado por el instalador.
+// Borrar este archivo desactiva el auto-update. No editar a mano.
+export const AlegraDataAgentAutoUpdate = async ({ $ }) => {
+  if (!$) return {}
+  try {
+    $\`${command}\`.quiet().nothrow().catch(() => {})
+  } catch (_e) {}
+  return {}
+}
+`;
+    writeFileSync(path, plugin, "utf-8");
+}
+function removeJsonHook(path, key) {
+    const cfg = readJsonSafe(path);
+    if (!cfg)
+        return;
+    const hooks = cfg.hooks;
+    if (!hooks || !Array.isArray(hooks[key]))
+        return;
+    const list = hooks[key];
+    const kept = list.filter((m) => !entryIsOurs(m));
+    if (kept.length === list.length)
+        return;
+    if (kept.length === 0)
+        delete hooks[key];
+    else
+        hooks[key] = kept;
+    writeJson(path, cfg);
+}
+export function installAutoUpdate(target, mode = "auto") {
+    const effective = target === "claude-code" ? mode : "auto";
+    try {
+        switch (target) {
+            case "claude-code":
+                runHookInstall(effective);
+                break;
+            case "cursor":
+                installCursor(guiResilientCommand(hookCommandFor(effective), { client: "cursor" }));
+                break;
+            case "codex":
+                installCodex(hookCommandFor(effective));
+                break;
+            case "antigravity":
+                installAntigravity(guiResilientCommand(hookCommandFor(effective), { client: "antigravity", silence: true }));
+                break;
+            case "opencode":
+                installOpenCode(hookCommandFor(effective));
+                break;
+        }
+    }
+    catch (err) {
+        logWarn(`No pude instalar el auto-update de ${target}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export function removeAutoUpdate(target) {
+    try {
+        switch (target) {
+            case "claude-code":
+                runHookUninstall({ quiet: true });
+                break;
+            case "cursor":
+                removeJsonHook(getCursorHooksPath(), "workspaceOpen");
+                break;
+            case "codex":
+                removeJsonHook(getCodexHooksPath(), "SessionStart");
+                break;
+            case "antigravity":
+                removeJsonHook(getGeminiSettingsPath(), "SessionStart");
+                break;
+            case "opencode": {
+                const p = getOpenCodePluginPath();
+                if (existsSync(p))
+                    rmSync(p, { force: true });
+                break;
+            }
+        }
+    }
+    catch (err) {
+        logWarn(`No pude quitar el auto-update de ${target}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function jsonHookHasOurs(path, key) {
+    const cfg = readJsonSafe(path);
+    const hooks = cfg?.hooks;
+    if (!hooks || !Array.isArray(hooks[key]))
+        return false;
+    return hooks[key].some(entryIsOurs);
+}
+export function hasAutoUpdate(target) {
+    switch (target) {
+        case "claude-code":
+            return jsonHookHasOurs(getClaudeSettingsPath(), "SessionStart");
+        case "cursor":
+            return jsonHookHasOurs(getCursorHooksPath(), "workspaceOpen");
+        case "codex":
+            return jsonHookHasOurs(getCodexHooksPath(), "SessionStart");
+        case "antigravity":
+            return jsonHookHasOurs(getGeminiSettingsPath(), "SessionStart");
+        case "opencode":
+            return existsSync(getOpenCodePluginPath());
+    }
+}
+export function refreshAutoUpdate() {
+    const lock = readLockFile();
+    const targets = [
+        ...new Set([
+            ...Object.values(lock.skills).flatMap((s) => s.targets ?? []),
+            ...Object.values(lock.mcps ?? {}).flatMap((m) => m.targets ?? []),
+        ]),
+    ];
+    for (const t of targets) {
+        if (hasAutoUpdate(t))
+            installAutoUpdate(t, "auto");
+    }
+}

package/dist/commands/hook.js

@@ -1,16 +1,22 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { logError, logOk, logWarn } from "../colors.js";
 import { COMMAND_NAME, PRODUCT_NAME, getClaudeSettingsPath, getPackageVersion } from "../lib.js";
+function versionRangeForHook(version) {
+    const [rawMajor] = version.split(".");
+    const major = Number.parseInt(rawMajor ?? "0", 10);
+    if (!Number.isFinite(major))
+        return "latest";
+    return major === 0 ? "0.x" : `^${major}.0.0`;
+}
 function hookCommandFor(mode) {
     const v = getPackageVersion();
-    const parts = v.split(".");
-    const major = parts[0] ?? "0";
-    const minor = parts[1] ?? "0";
-    const range = `~${major}.${minor}.0`;
-    const verb = mode === "auto" ? "update --yes" : "check";
+    const range = versionRangeForHook(v);
+    const verb = mode === "auto" ? "update --yes --background" : "check";
     return `pnpm dlx --config.minimumReleaseAge=0 ${COMMAND_NAME}@${range} ${verb} --no-bounce`;
 }
 const HOOK_SIGNATURE = COMMAND_NAME;
+const HOOK_TIMEOUT_SECONDS = 120;
 function readSettings() {
     const path = getClaudeSettingsPath();
     if (!existsSync(path))
@@ -20,11 +26,15 @@ function readSettings() {
     }
     catch {
         logError(`No se pudo parsear ${path}. Agente: reparalo vos mismo (la skill agent-onboarding tiene la guía) — no le pidas al usuario editar JSON.`);
-        return {};
+        return null;
     }
 }
 function writeSettings(s) {
-    writeFileSync(getClaudeSettingsPath(), `${JSON.stringify(s, null, 2)}\n`, "utf-8");
+    const path = getClaudeSettingsPath();
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp-${process.pid}`;
+    writeFileSync(tmp, `${JSON.stringify(s, null, 2)}\n`, "utf-8");
+    renameSync(tmp, path);
 }
 function isOurMatcher(m) {
     if (!m || typeof m !== "object")
@@ -39,10 +49,12 @@ function isOurMatcher(m) {
         h.command.includes(HOOK_SIGNATURE));
 }
 function buildOurMatcher(command) {
-    return { hooks: [{ type: "command", command }] };
+    return { hooks: [{ type: "command", command, timeout: HOOK_TIMEOUT_SECONDS }] };
 }
 export function runHookInstall(mode = "auto") {
     const settings = readSettings();
+    if (settings === null)
+        return 1;
     settings.hooks = settings.hooks ?? {};
     const command = hookCommandFor(mode);
     const existing = settings.hooks.SessionStart;
@@ -82,63 +94,47 @@ export function runHookInstall(mode = "auto") {
     }
     return 0;
 }
-export function refreshHookCommand() {
-    try {
-        const settings = readSettings();
-        if (!settings.hooks)
-            return;
-        const existing = settings.hooks.SessionStart;
-        if (!Array.isArray(existing))
-            return;
-        const ours = existing.find(isOurMatcher);
-        if (!ours)
-            return;
-        const current = ours.hooks.find((h) => h.type === "command")?.command ?? "";
-        const fresh = hookCommandFor("auto");
-        if (current === fresh)
-            return;
-        const others = existing.filter((m) => !isOurMatcher(m));
-        others.push(buildOurMatcher(fresh));
-        settings.hooks.SessionStart = others;
-        writeSettings(settings);
-    }
-    catch {
-    }
-}
-export function runHookUninstall() {
+export function runHookUninstall(opts = {}) {
+    const say = opts.quiet ? () => { } : logWarn;
+    const sayOk = opts.quiet ? () => { } : logOk;
     const settings = readSettings();
-    const existing = settings.hooks?.SessionStart;
-    if (existing === undefined) {
-        logWarn("No había hook que desinstalar.");
+    if (settings === null) {
+        say("settings.json corrupto — no lo toco. Agente: reparalo vos mismo (la skill agent-onboarding tiene la guía) y re-corré uninstall — no le pidas al usuario editar JSON.");
+        return 1;
+    }
+    const hooks = settings.hooks;
+    const existing = hooks?.SessionStart;
+    if (!hooks || existing === undefined) {
+        say("No había hook que desinstalar.");
         return 0;
     }
     if (typeof existing === "string") {
         if (!existing.includes(HOOK_SIGNATURE)) {
-            logWarn(`El SessionStart hook actual no es de ${PRODUCT_NAME}. No lo toco.`);
+            say(`El SessionStart hook actual no es de ${PRODUCT_NAME}. No lo toco.`);
             return 1;
         }
-        settings.hooks.SessionStart = undefined;
+        hooks.SessionStart = undefined;
         writeSettings(settings);
-        logOk("Hook removido.");
+        sayOk("Hook removido.");
         return 0;
     }
     if (!Array.isArray(existing)) {
-        logWarn("No había hook que desinstalar.");
+        say("No había hook que desinstalar.");
         return 0;
     }
     const filtered = existing.filter((m) => !isOurMatcher(m));
     if (filtered.length === existing.length) {
-        logWarn(`No encontré ningún SessionStart hook de ${PRODUCT_NAME}. No lo toco.`);
+        say(`No encontré ningún SessionStart hook de ${PRODUCT_NAME}. No lo toco.`);
         return 1;
     }
     if (filtered.length === 0) {
-        settings.hooks.SessionStart = undefined;
+        hooks.SessionStart = undefined;
     }
     else {
-        settings.hooks.SessionStart = filtered;
+        hooks.SessionStart = filtered;
     }
     writeSettings(settings);
-    logOk("Hook removido.");
+    sayOk("Hook removido.");
     return 0;
 }
-export { hookCommandFor };
+export { hookCommandFor, versionRangeForHook };