@hoilab/ada-cli 0.84.21 → 0.85.0

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

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

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