@hoilab/ada-cli 0.84.22 → 0.85.1

package/dist/core/credenciales/reposo.js

@@ -0,0 +1,489 @@
+/**
+ * Cifrado en reposo de `<agentDir>/auth.json`.
+ *
+ * EL HUECO: vendemos "vault cifrado con clasificación y auditoría"
+ * (memory-engine/vault.ts) mientras las claves de API y los tokens OAuth de
+ * los proveedores viven en auth.json EN CLARO, con permisos 0600 pero
+ * legibles por cualquier proceso del usuario. La política de aprobación
+ * (aprobacion/politica.ts) ya le impide leerlo a NUESTRO agente; esto le
+ * cierra la puerta a cualquier OTRO proceso.
+ *
+ * DISEÑO — envolver, no sustituir:
+ * `auth-storage.ts` es de upstream y el presupuesto de fork está agotado
+ * (ver scripts/sync-ada.sh --check). No podemos reescribir su lectura/
+ * escritura de fichero ni su bloqueo entre procesos (proper-lockfile) sin
+ * pagar hunks que no tenemos. En vez de eso, ENVOLVEMOS su
+ * `AuthStorageBackend`: el interior (`FileAuthStorageBackend`) sigue
+ * poseyendo el candado y el `ensureFileExists`/`ensureParentDir`; nosotros
+ * solo transformamos el CONTENIDO que entra y sale del candado. Todo el
+ * cifrado ocurre DENTRO de la sección crítica del candado que ya existía,
+ * así que la seguridad frente a otros procesos de Ada no cambia.
+ *
+ * CLAVE: un secreto aleatorio de 256 bits en el LLAVERO del sistema (no una
+ * passphrase memorizable — nadie va a teclear una contraseña para que el
+ * CLI arranque). Se deriva de nada: se genera con randomBytes y se guarda
+ * en Keychain la primera vez que hace falta. Sin llavero disponible (CI,
+ * contenedor, Linux sin secret-service) NO SE CIFRA: una clave que vive en
+ * el mismo disco que el fichero que protege es ofuscación, no cifrado, y
+ * llamarlo cifrado sería mentir en la única parte del producto donde no se
+ * puede mentir. Se avisa una vez, con una línea clara, y se sigue
+ * funcionando en claro (mismo comportamiento que hoy).
+ *
+ * FORMATO: una cabecera literal al principio del fichero distingue claro de
+ * cifrado — nunca adivinamos intentando JSON.parse (un fichero cifrado
+ * corrupto a medias podría parsear igual como JSON basura y confundirse con
+ * "en claro", perdiendo credenciales calladamente).
+ *
+ * MIGRACIÓN: en cada lectura, si el contenido está en claro se devuelve tal
+ * cual (nunca bloquea al llamador) y se agenda un recifrado en segundo
+ * plano con `setImmediate` — nunca DENTRO del candado que la propia lectura
+ * mantiene abierto, porque volver a pedirlo desde dentro se autobloquearía.
+ * En cada escritura (a través del wrapper) se cifra antes de tocar disco,
+ * con copia de seguridad y escritura atómica (fichero temporal + rename):
+ * si esto corrompe auth.json, el usuario pierde el acceso a TODOS sus
+ * proveedores, así que no se sustituye el fichero real hasta que el
+ * temporal esté completo en disco.
+ */
+import { execFileSync } from "node:child_process";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { chmodSync, existsSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "../../config.js";
+import { stripBom } from "../../utils/text.js";
+// ─── Formato: cabecera literal, nunca "adivinada" por JSON.parse ───────────
+const CABECERA_CIFRADO = "ADA-AUTHJSON-CIFRADO-V1\n";
+function esFormatoCifrado(contenido) {
+    return contenido.startsWith(CABECERA_CIFRADO);
+}
+// ─── Llavero del sistema (macOS Keychain vía `security`, sin bindings nativos) ───
+const SERVICIO_LLAVERO_PRODUCCION = "ada-cli-credenciales";
+const CUENTA_LLAVERO = "auth-json-clave-maestra";
+const TIMEOUT_LLAVERO_MS = 5_000;
+/**
+ * Bajo qué nombre vive la clave maestra en el llavero REAL de la máquina.
+ *
+ * Se puede sustituir por entorno porque las pruebas de este módulo necesitan un
+ * llavero de verdad —no hay bindings nativos que fingir, y fingir `execFileSync`
+ * probaría el mock, no el Keychain— y hasta ahora usaban la entrada de
+ * PRODUCCIÓN. Con `__eliminarClaveDeLlaveroParaPruebas()` en su `afterEach`,
+ * cada corrida de la suite BORRABA la clave maestra del usuario y creaba otra.
+ *
+ * Lo que eso deja detrás no es un inconveniente: el `~/.ada/agent/auth.json`
+ * del usuario quedó cifrado con la clave anterior, así que pasa a ser
+ * indescifrable PARA SIEMPRE, y su `.bak` también (se recifra con la misma
+ * clave). Medido en esta máquina, con la huella SHA-256 de la clave del
+ * llavero antes y después:
+ *
+ *     == antes ==                        15900260def30338
+ *     npx vitest --run test/commit-mensaje.test.ts
+ *     == después ==                      15900260def30338   (intacta)
+ *     npx vitest --run test/credenciales-reposo.test.ts
+ *     == después ==                      c8b382bb95b2285b   (OTRA)
+ *
+ * Y AGENTS.md manda ejecutar la suite antes de dar nada por terminado, así que
+ * el flujo de trabajo del propio proyecto rompía las credenciales del usuario.
+ *
+ * Falla CERRADO bajo vitest: si alguien quita el ajuste de `vitest.config.ts`,
+ * las pruebas del llavero se caen con este mensaje en vez de volver
+ * calladamente a morder la entrada de producción.
+ */
+function servicioLlavero() {
+    const propio = process.env.ADA_LLAVERO_SERVICIO;
+    if (propio)
+        return propio;
+    if (process.env.VITEST) {
+        throw new Error("Una prueba ha intentado usar la entrada de llavero de PRODUCCIÓN " +
+            `("${SERVICIO_LLAVERO_PRODUCCION}"). Eso borra la clave maestra del usuario y deja su ` +
+            "auth.json indescifrable. Define ADA_LLAVERO_SERVICIO (lo hace vitest.config.ts).");
+    }
+    return SERVICIO_LLAVERO_PRODUCCION;
+}
+function esMacOS() {
+    return typeof process !== "undefined" && process.platform === "darwin";
+}
+/**
+ * True cuando hay un llavero de sistema utilizable en esta máquina.
+ *
+ * `ADA_SIN_LLAVERO=1` fuerza "no disponible" aunque estemos en macOS — es la
+ * única forma de probar de verdad la rama "sin llavero" (headless/CI) sin
+ * necesitar una máquina Linux, y también sirve de escape manual para quien
+ * quiera desactivar el uso del Keychain explícitamente.
+ */
+export function hayLlaveroDisponible() {
+    return esMacOS() && process.env.ADA_SIN_LLAVERO !== "1";
+}
+/** `security` devuelve 44 (errSecItemNotFound) cuando la entrada no está. */
+const CODIGO_NO_ENCONTRADO = 44;
+function leerClaveDelLlavero() {
+    if (!hayLlaveroDisponible())
+        return { estado: "no-existe" };
+    // Fuera del try a propósito: si `servicioLlavero()` se planta porque una
+    // prueba iba a morder la entrada de producción, ese error tiene que SALIR.
+    // Dentro del try acabaría clasificado como un `estado: "error"` cualquiera,
+    // y lo que hay que hacer con él es parar, no seguir sin cifrar.
+    const servicio = servicioLlavero();
+    let salida;
+    try {
+        salida = execFileSync("/usr/bin/security", ["find-generic-password", "-s", servicio, "-a", CUENTA_LLAVERO, "-w"], 
+        // stdio "pipe" en los tres canales: sin esto, `security` hereda
+        // nuestro stderr y el "could not be found in the keychain" (normal
+        // en el primer arranque, antes de crear la clave) se ve como si
+        // algo hubiera ido mal.
+        { timeout: TIMEOUT_LLAVERO_MS, encoding: "utf-8", windowsHide: true, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    }
+    catch (error) {
+        const e = error;
+        if (e.status === CODIGO_NO_ENCONTRADO)
+            return { estado: "no-existe" };
+        // Todo lo demás es un fallo del que NO se puede deducir que no haya
+        // clave: tiempo agotado (`ETIMEDOUT`), llavero bloqueado, `security`
+        // que no arranca. Rotar aquí es lo que destruyó las credenciales.
+        return { estado: "error", motivo: e.code ?? `security salió con ${e.status}` };
+    }
+    if (!salida)
+        return { estado: "error", motivo: "el llavero devolvió una entrada vacía" };
+    const clave = Buffer.from(salida, "base64");
+    // Una entrada presente pero con el tamaño equivocado también es un error, no
+    // una ausencia: sobrescribirla tiraría la clave buena si el fallo está en la
+    // lectura y no en el dato.
+    if (clave.length !== 32)
+        return { estado: "error", motivo: `la clave del llavero mide ${clave.length} bytes, no 32` };
+    return { estado: "leida", clave };
+}
+function guardarClaveEnLlavero(clave) {
+    if (!hayLlaveroDisponible())
+        return false;
+    const servicio = servicioLlavero(); // fuera del try: ver `leerClaveDelLlavero`
+    try {
+        // -w sin valor en argv: la contraseña se pasa por stdin para que no quede
+        // visible en `ps`/el historial del proceso (mismo patrón que
+        // memory-engine/keychain.ts). Comprobado a mano: `security` pide el valor
+        // DOS VECES por stdin (password + confirmación) aunque no haya terminal;
+        // una sola línea deja la segunda lectura vacía y falla con "passwords
+        // don't match".
+        const valor = clave.toString("base64");
+        execFileSync("/usr/bin/security", 
+        // SIN `-U`. Con `-U` esto SOBRESCRIBE la entrada existente, y ese es el
+        // segundo camino por el que se perdieron las credenciales de esta
+        // máquina: un fallo de lectura hacía creer que no había clave y este
+        // `-U` remataba tirando la buena. Sin él, `security` falla si ya existe,
+        // que es justo la señal que quien llama necesita para releer.
+        //
+        // El PRIMER camino lo encontró la revisión de `hueco-commit` y es
+        // distinto: las pruebas de este módulo borraban la entrada de
+        // PRODUCCIÓN en su `afterEach`. Los dos arreglos hacen falta —
+        // `servicioLlavero()` impide que una prueba toque la clave real, y esto
+        // impide que un fallo pasajero la rote.
+        ["add-generic-password", "-s", servicio, "-a", CUENTA_LLAVERO, "-w"], {
+            timeout: TIMEOUT_LLAVERO_MS,
+            windowsHide: true,
+            input: `${valor}\n${valor}\n`,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+let claveEnCache; // undefined = aún no consultada
+/**
+ * Clave maestra. `null` = no hay llavero en esta máquina (CI, contenedor), que
+ * es el caso legítimo de "no se cifra". **Lanza** si el llavero está pero no se
+ * ha podido leer: ahí seguir sería inventarse una clave nueva y perder lo
+ * cifrado con la anterior.
+ */
+function obtenerOCrearClave() {
+    if (!hayLlaveroDisponible())
+        return null;
+    if (claveEnCache !== undefined)
+        return claveEnCache;
+    const lectura = leerClaveDelLlavero();
+    if (lectura.estado === "leida") {
+        claveEnCache = lectura.clave;
+        return claveEnCache;
+    }
+    if (lectura.estado === "error") {
+        // Fallar cerrado. Un error aquí NO se cachea: el fallo puede ser pasajero
+        // y el siguiente intento debe volver a preguntarle al llavero.
+        throw new Error(`No se ha podido leer la clave maestra del llavero (${lectura.motivo}).\n` +
+            "No se genera una nueva a propósito: eso dejaría ilegible para siempre el auth.json\n" +
+            "ya cifrado. Desbloquea el llavero y vuelve a intentarlo, o exporta ADA_SIN_LLAVERO=1\n" +
+            "para trabajar sin cifrado en reposo.");
+    }
+    // No existe: primera vez. Se crea SIN `-U`, para que dos procesos a la vez no
+    // se pisen — quien pierde la carrera relee en vez de sobrescribir.
+    const nueva = randomBytes(32);
+    if (guardarClaveEnLlavero(nueva)) {
+        claveEnCache = nueva;
+        return claveEnCache;
+    }
+    const segunda = leerClaveDelLlavero();
+    if (segunda.estado === "leida") {
+        claveEnCache = segunda.clave;
+        return claveEnCache;
+    }
+    // Ni se pudo crear ni leer: sin llavero utilizable. Se deja sin cifrar, que
+    // es el comportamiento documentado, y se avisa una vez.
+    claveEnCache = null;
+    return null;
+}
+// ─── AES-256-GCM ────────────────────────────────────────────────────────────
+function cifrar(contenidoClaro, clave) {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", clave, iv);
+    const datos = Buffer.concat([cipher.update(contenidoClaro, "utf-8"), cipher.final()]);
+    const sobre = {
+        iv: iv.toString("base64"),
+        tag: cipher.getAuthTag().toString("base64"),
+        datos: datos.toString("base64"),
+    };
+    return CABECERA_CIFRADO + JSON.stringify(sobre);
+}
+function descifrar(contenidoFichero, clave) {
+    const sobre = JSON.parse(contenidoFichero.slice(CABECERA_CIFRADO.length));
+    const decipher = createDecipheriv("aes-256-gcm", clave, Buffer.from(sobre.iv, "base64"));
+    decipher.setAuthTag(Buffer.from(sobre.tag, "base64"));
+    const claro = Buffer.concat([decipher.update(Buffer.from(sobre.datos, "base64")), decipher.final()]);
+    return claro.toString("utf-8");
+}
+// ─── Error legible: nunca un stack para un fichero dañado ─────────────────
+/**
+ * auth.json cifrado que no se puede leer: auth tag inválido, JSON del sobre
+ * truncado, o llavero sin la clave que lo cifró (p.ej. copiado desde otra
+ * máquina). "no he podido leerlo" y "no hay credenciales" son cosas
+ * distintas: esto SIEMPRE es lo primero, nunca se confunde con un auth.json
+ * vacío legítimo.
+ */
+export class AuthJsonCorruptoError extends Error {
+    constructor(authPath, causa) {
+        super(`auth.json está cifrado pero no se ha podido leer (${authPath}).\n` +
+            `Puede estar dañado, o cifrado con la clave de otra máquina.\n` +
+            `Qué hacer:\n` +
+            `  1. Si existe una copia de seguridad, restáurala:\n` +
+            `       cp "${authPath}.bak" "${authPath}"\n` +
+            `  2. Si no, vuelve a iniciar sesión con cada proveedor:\n` +
+            `       ada-cli auth login <proveedor>\n` +
+            (causa instanceof Error ? `(detalle técnico: ${causa.message})` : ""));
+        this.name = "AuthJsonCorruptoError";
+    }
+}
+// ─── Escritura: copia de seguridad + atómica (temporal + rename) ──────────
+function escrituraAtomicaConCopia(authPath, contenido, contenidoParaCopia) {
+    // El permiso del fichero (0600, o 0660 si un administrador lo gestiona) es
+    // intencional y no es nuestro para decidir — igual que
+    // AUTH_FILE_WRITE_OPTIONS en auth-storage.ts, que solo fija el modo al
+    // CREAR. Un rename sustituye el inodo entero, así que sin esto el permiso
+    // original se perdería silenciosamente en cada recifrado.
+    const modoExistente = existsSync(authPath) ? statSync(authPath).mode & 0o777 : 0o600;
+    // Copia ANTES de tocar el fichero real: si el rename de abajo no llegara a
+    // completarse (disco lleno a mitad, proceso matado entre write y rename),
+    // .bak es la única vía para no perder el acceso a TODOS los proveedores.
+    //
+    // `contenidoParaCopia` (si se pasa) sustituye lo que hay en disco: la
+    // primera migración de un auth.json en claro pasa por aquí con el fichero
+    // TODAVÍA en claro sobre disco, y una copia literal (`readFileSync`)
+    // dejaría el secreto en claro para siempre en `.bak` — con el mismo modo
+    // 0600 que el propio auth.json ya tenía, así que no cierra nada: reabre
+    // exactamente el agujero que este módulo existe para tapar. Quien llama
+    // (`escribirConCifradoSiHayClave`) cifra ese contenido antes de pasarlo.
+    if (existsSync(authPath)) {
+        const backupPath = `${authPath}.bak`;
+        writeFileSync(backupPath, contenidoParaCopia ?? readFileSync(authPath), { mode: modoExistente });
+        chmodSync(backupPath, modoExistente); // mismo motivo que el temporal: el umask no debe recortar el modo
+    }
+    const tmpPath = `${authPath}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tmpPath, contenido, { encoding: "utf-8", mode: modoExistente });
+    // El `mode` de writeFileSync pasa por el umask del proceso al CREAR un
+    // fichero (0660 con umask 022 se queda en 0640) — algo que un `writeFileSync`
+    // normal sobre un fichero YA existente no sufre, porque el modo se ignora
+    // del todo si no hay creación. Como el temporal siempre es nuevo, hace
+    // falta un chmod explícito (ignora el umask) para replicar ese mismo
+    // comportamiento y no perder un modo gestionado por un administrador.
+    chmodSync(tmpPath, modoExistente);
+    renameSync(tmpPath, authPath); // rename es atómico dentro del mismo filesystem
+}
+let avisoSinLlaveroMostrado = false;
+/** Se llama tanto al detectar un fichero en claro sin poder cifrarlo como al querer escribir sin llavero. */
+function avisarSinLlaveroUnaVez() {
+    if (avisoSinLlaveroMostrado)
+        return;
+    avisoSinLlaveroMostrado = true;
+    console.error(`[ada] auth.json NO se cifra: no hay llavero del sistema disponible en esta máquina ` +
+        `(CI, contenedor, o Linux sin secret-service). Una clave guardada en el mismo disco que ` +
+        `el fichero que protege sería ofuscación, no cifrado — se deja en claro con permisos 0600, ` +
+        `como hasta ahora.`);
+}
+function escribirConCifradoSiHayClave(authPath, contenidoClaro) {
+    const clave = obtenerOCrearClave();
+    if (!clave) {
+        avisarSinLlaveroUnaVez();
+        escrituraAtomicaConCopia(authPath, contenidoClaro);
+        return;
+    }
+    // Si lo que hay AHORA en disco está en claro (primera migración), la copia
+    // de seguridad se cifra también con la misma clave — en vez de dejar que
+    // `escrituraAtomicaConCopia` copie los bytes tal cual. `.bak` sigue
+    // sirviendo para recuperar de una escritura a medias: al restaurarlo,
+    // `decodificarParaLectura` reconoce la cabecera y lo descifra igual que al
+    // auth.json real.
+    const actual = existsSync(authPath) ? readFileSync(authPath, "utf-8") : undefined;
+    const copiaSegura = actual !== undefined && !esFormatoCifrado(actual) ? cifrar(actual, clave) : actual;
+    escrituraAtomicaConCopia(authPath, cifrar(contenidoClaro, clave), copiaSegura);
+}
+let avisoCorruptoMostrado = false;
+/**
+ * `AuthStorage.reload()` (upstream, `auth-storage.ts`) atrapa CUALQUIER error
+ * de su backend y lo trata como "transitorio, conserva el último estado
+ * bueno" — y sin `signal`, `readLatestData()` hace lo mismo. Si solo
+ * lanzáramos, ese catch se come el error y el llamador ve "no hay
+ * credenciales" en vez de "no he podido leerlas": exactamente la confusión
+ * que no puede pasar (ver AGENTS.md, regla de errores). Por eso esto SIEMPRE
+ * imprime la guía en stderr, una vez, ANTES de lanzar: quien atrape la
+ * excepción se la queda para sí, pero el aviso ya salió por su cuenta.
+ */
+function lanzarCorrupto(authPath, causa) {
+    const error = new AuthJsonCorruptoError(authPath, causa);
+    if (!avisoCorruptoMostrado) {
+        avisoCorruptoMostrado = true;
+        console.error(`[ada] ${error.message}`);
+    }
+    throw error;
+}
+/** Descifra si hace falta; el contenido en claro se devuelve tal cual, sin adivinar. */
+function decodificarParaLectura(authPath, contenidoBruto) {
+    if (contenidoBruto === undefined || !esFormatoCifrado(contenidoBruto))
+        return contenidoBruto;
+    const clave = obtenerOCrearClave();
+    if (!clave) {
+        lanzarCorrupto(authPath, new Error("el fichero está cifrado pero no hay llavero disponible para descifrarlo aquí"));
+    }
+    try {
+        return descifrar(contenidoBruto, clave);
+    }
+    catch (error) {
+        lanzarCorrupto(authPath, error);
+    }
+}
+// ─── Migración en segundo plano (nunca dentro del candado de la lectura) ──
+const migracionEnCursoPara = new Set();
+function programarMigracionEnSegundoPlano(interno, authPath) {
+    if (!hayLlaveroDisponible()) {
+        // Sin llavero no hay nada que recifrar: pedir el candado igualmente
+        // solo para reescribir el mismo texto en claro es trabajo (y contención
+        // entre procesos) sin beneficio. Basta con avisar.
+        avisarSinLlaveroUnaVez();
+        return;
+    }
+    if (migracionEnCursoPara.has(authPath))
+        return; // ya hay una en vuelo; la lectura repetida no acumula trabajo
+    migracionEnCursoPara.add(authPath);
+    // setImmediate: la lectura que detectó "en claro" todavía mantiene el
+    // candado de `interno` abierto en su propia pila de llamadas. Pedirlo de
+    // nuevo aquí mismo se autobloquearía; con setImmediate se agenda para
+    // DESPUÉS de que esa lectura suelte el candado.
+    setImmediate(() => {
+        void interno
+            .withLockAsync(async (actual) => {
+            if (actual === undefined || esFormatoCifrado(actual)) {
+                return { result: undefined }; // otro proceso ya migró, o no hay nada que migrar
+            }
+            escribirConCifradoSiHayClave(authPath, actual);
+            // Ya escribimos nosotros mismos (copia + atómico); devolver `next`
+            // aquí haría que el backend interno reescribiera SIN copia de
+            // seguridad, pisando la que acabamos de crear.
+            return { result: undefined };
+        }, {})
+            .catch((error) => {
+            console.error(`[ada] no se pudo recifrar auth.json en segundo plano: ${error instanceof Error ? error.message : String(error)}`);
+        })
+            .finally(() => {
+            migracionEnCursoPara.delete(authPath);
+        });
+    });
+}
+// ─── El wrapper ─────────────────────────────────────────────────────────────
+/**
+ * Envuelve un `AuthStorageBackend` (normalmente un `FileAuthStorageBackend`
+ * ya construido, que sigue poseyendo el candado entre procesos) para que
+ * cifre/descifre en reposo de forma transparente para quien lo use.
+ */
+export function envolverBackendCifrado(interno, authPath) {
+    return {
+        withLock(fn) {
+            return interno.withLock((actual) => {
+                const claro = decodificarParaLectura(authPath, actual);
+                if (actual !== undefined && !esFormatoCifrado(actual)) {
+                    programarMigracionEnSegundoPlano(interno, authPath);
+                }
+                const { result, next } = fn(claro);
+                if (next !== undefined)
+                    escribirConCifradoSiHayClave(authPath, next);
+                return { result }; // `next` siempre undefined hacia `interno`: la escritura ya ocurrió arriba
+            });
+        },
+        async withLockAsync(fn, options) {
+            return interno.withLockAsync(async (actual) => {
+                const claro = decodificarParaLectura(authPath, actual);
+                if (actual !== undefined && !esFormatoCifrado(actual)) {
+                    programarMigracionEnSegundoPlano(interno, authPath);
+                }
+                const { result, next } = await fn(claro);
+                if (next !== undefined)
+                    escribirConCifradoSiHayClave(authPath, next);
+                return { result };
+            }, options);
+        },
+    };
+}
+/**
+ * Lectura síncrona de UNA credencial ya guardada, descifrando si hace falta.
+ *
+ * Sustituye a `readStoredCredential` (upstream, `auth-storage.ts`), exportada
+ * en `index.ts` como parte de la API pública del SDK (`@hoilab/ada-cli`) para
+ * lecturas puntuales sin instanciar `AuthStorage`. Esa función hace su propio
+ * `readFileSync` + `JSON.parse` sin pasar por este módulo: con auth.json ya
+ * migrado a cifrado, la cabecera `ADA-AUTHJSON-CIFRADO-V1\n` delante del JSON
+ * hace que `JSON.parse` lance un `SyntaxError` que su `catch { return
+ * undefined; }` convierte en "no hay credencial" — indistinguible de un
+ * proveedor sin configurar, para CUALQUIER consumidor de esta función
+ * pública, presente o futuro. Mismo nombre y misma firma (con el mismo valor
+ * por defecto de `authPath`) para seguir siendo un reemplazo directo.
+ */
+export function leerCredencialGuardada(providerId, authPath = join(getAgentDir(), "auth.json")) {
+    try {
+        const bruto = stripBom(readFileSync(authPath, "utf-8"));
+        const claro = decodificarParaLectura(authPath, bruto);
+        if (claro === undefined)
+            return undefined;
+        const datos = JSON.parse(claro);
+        return datos[providerId];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Solo para pruebas: limpia el estado en memoria del módulo entre casos. */
+export function __resetEstadoParaPruebas() {
+    claveEnCache = undefined;
+    avisoSinLlaveroMostrado = false;
+    avisoCorruptoMostrado = false;
+    migracionEnCursoPara.clear();
+}
+/** Solo para pruebas: borra la clave maestra del llavero real de esta máquina. */
+export function __eliminarClaveDeLlaveroParaPruebas() {
+    if (!esMacOS())
+        return;
+    const servicio = servicioLlavero(); // fuera del try: ver `leerClaveDelLlavero`
+    try {
+        execFileSync("/usr/bin/security", ["delete-generic-password", "-s", servicio, "-a", CUENTA_LLAVERO], {
+            timeout: TIMEOUT_LLAVERO_MS,
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch {
+        // no había clave que borrar
+    }
+}
+//# sourceMappingURL=reposo.js.map

package/dist/core/credenciales/reposo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reposo.js","sourceRoot":"","sources":["../../../src/core/credenciales/reposo.ts"],"names":[],"mappings":"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"}

package/dist/core/credenciales/servidor.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Servidor HTTP del broker de credenciales.
+ *
+ * No es un producto nuevo: es un MODO de `ada-cli serve` (ver
+ * `cli/serve-command.ts`). El gateway de oh-my-pi resuelve la credencial en el
+ * servidor y la inyecta para que el cliente nunca vea el token; aquí no hay
+ * proxy de peticiones a proveedores (fuera de alcance), así que `/v1/credential`
+ * SÍ entrega el secreto — es lo mínimo para que un cliente pueda llamar al
+ * proveedor sin tenerlo nunca en su disco. Lo que sí se copia sin rebajar:
+ *
+ * - **Fallar cerrado.** Sin bearer configurado, `iniciarServidorBroker` lanza
+ *   antes de abrir el socket de escucha. Un broker que arrancara sin auth
+ *   "por ahora" es exactamente el tipo de atajo que se queda para siempre.
+ * - **Comparación en tiempo constante del bearer**, para no dar una guía de
+ *   temporización a quien intente adivinarlo por fuerza bruta.
+ * - **Todo excepto `/v1/health` exige bearer.** La salud tiene que poder
+ *   contestar aunque el token esté mal configurado en quien pregunta — es lo
+ *   único que un balanceador o un `curl` de comprobación necesita sin secreto.
+ *
+ * Cada resolución de credencial y cada reporte de uso quedan en el libro de
+ * sesión (`core/audit/libro.ts`) — es la pieza que oh-my-pi no tiene: quién
+ * usó qué cuenta y cuándo, auditable.
+ */
+import type { LibroDeSesion } from "../audit/libro.ts";
+import type { CredencialPool } from "./pool.ts";
+import type { RegistroEnfriamiento } from "./ratelimit.ts";
+export declare const DEFAULT_BROKER_BIND = "127.0.0.1:8765";
+export interface OpcionesServidorBroker {
+    pool: CredencialPool;
+    /** Bearer requerido en cada petición salvo `/v1/health`. Vacío = error: ver `iniciarServidorBroker`. */
+    token: string;
+    libro: LibroDeSesion;
+    /** `host:puerto`. Por defecto `127.0.0.1:8765` — solo loopback, sin exposición externa. */
+    bind?: string;
+    /**
+     * Permite escuchar FUERA de loopback aun sabiendo que el transporte es HTTP
+     * sin cifrar. Sin esto, un `bind` a una interfaz real no arranca.
+     *
+     * El nombre es largo y feo a propósito: quien lo escribe no puede decir
+     * después que no lo sabía, y queda escrito en el fichero de despliegue —que
+     * es auditable— en vez de en un aviso que se va con el scroll.
+     */
+    inseguroSinTls?: boolean;
+    /**
+     * Registro persistente de rate-limits. Si se pasa, un 429 reportado con
+     * `retryTrasSegundos` enfriía la credencial (por huella, nunca por clave)
+     * hasta el epoch indicado — y el descanso sobrevive a un reinicio del
+     * broker. Sin registro, el 429 sigue sin bloquear la cuenta, como siempre.
+     */
+    enfriamiento?: RegistroEnfriamiento;
+}
+export interface ServidorBroker {
+    url: string;
+    puerto: number;
+    cerrar(): Promise<void>;
+}
+/**
+ * Arranca el broker. Lanza SIN escuchar si no hay bearer — fallar cerrado, no
+ * "escuchar sin auth por ahora". Esto es lo que la puerta de verificación
+ * comprueba forzando el caso vacío y confirmando que no hay servidor.
+ */
+export declare function iniciarServidorBroker(opciones: OpcionesServidorBroker): Promise<ServidorBroker>;
+//# sourceMappingURL=servidor.d.ts.map

package/dist/core/credenciales/servidor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"servidor.d.ts","sourceRoot":"","sources":["../../../src/core/credenciales/servidor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,MAAM,WAAW,sBAAsB;IACtC,IAAI,EAAE,cAAc,CAAC;IACrB,wGAAwG;IACxG,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,aAAa,CAAC;IACrB,2FAA2F;IAC3F,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACpC;AAED,MAAM,WAAW,cAAc;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAuCD;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAyKrG"}