@dotrino/vault 0.51.0 → 0.53.0

package/bin/dotrino-env.js

@@ -206,7 +206,10 @@ async function cmdRun () {
   // ejemplo— y por fuera solo se veía «waiting for approval» una y otra vez, aunque el
   // dueño hubiera aprobado cada una. Un reintento que no dice su causa es un fallback: le
   // pone cara de espera a un error. (Ver CLAUDE.md, «nada de repliegues».)
-  const onRetry = (e, ms) => console.error('[dotrino-env] failed: %s — retrying in %ds', e.message, Math.round(ms / 1000))
+  // El plazo se imprime en minutos cuando lo es: un «retrying in 310s» parece un cuelgue,
+  // y no lo es — es el pedido que ya timbró, esperando a vencer antes de volver a sonar.
+  const humanDelay = (ms) => (ms >= 90000 ? `${Math.round(ms / 60000)} min` : `${Math.round(ms / 1000)}s`)
+  const onRetry = (e, ms) => console.error('[dotrino-env] failed: %s — retrying in %s', e.message, humanDelay(ms))
   // `--public`: SOLO las variables públicas, y por eso no hace sonar el teléfono de nadie.
   // La aprobación existe para soltar claves privadas; una pública está guardada en claro y
   // ya la ve quien administra. Es lo que quiere un arranque que solo necesita configuración

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "description": "Usa ESTE dispositivo (navegador) como bóveda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegación a tus máquinas. Incluye el cliente de SERVICIO (Node): un proyecto se enrola una vez y jala sus credenciales del vault en vez del .env (`import '@dotrino/vault/config'`).",
   "type": "module",
   "main": "src/index.js",

package/src/atrest.js

@@ -14,8 +14,14 @@
  *   · `secrets.json`   secretos de servicios (tokens y llaves de producción)
  *   · `service-identity.json` en la máquina del SERVICIO (`@dotrino/vault/env`):
  *     lleva la llave privada de su dispositivo, así que va igual de cifrado.
- * Queda fuera a propósito `activity.log`: es la bitácora de auditoría y no guarda
- * payloads (solo op, dispositivo y hora), y se quiere legible para diagnosticar.
+ *   · `activity.log`   la bitácora de auditoría, cifrada LÍNEA A LÍNEA (ver `LINE_FILES`)
+ *   · `state.json`, `acta.json`, `secret-request.json`… el canal local con la CLI
+ *     (`src/ipc.js`), por donde pasan la contraseña del perfil y los valores
+ *   · `transport.json` el par de transporte de `@dotrino/proxy-client`, con su privada
+ *
+ * La bitácora estuvo fuera hasta 0.89, con el argumento de que «no guarda payloads». No
+ * guarda valores, pero sí el mapa de la cuenta —qué aparatos, con qué permisos, contra
+ * qué cajones y a qué hora—, que es lo que mira quien elige por dónde entrar.
  *
  * Qué NO resuelve, dicho sin adornos: **no protege contra alguien con acceso a esta misma
  * máquina como tu usuario o como root** — puede leer el mismo material que leemos nosotros.
@@ -178,15 +184,31 @@ export function migrateFile (file, key) {
 }
 
 /** Los archivos de este directorio que están cifrados por nosotros. */
+/**
+ * Archivos que van cifrados **línea a línea**, no de una pieza.
+ *
+ * La bitácora se ESCRIBE AÑADIENDO. Cifrarla entera obligaría a reescribir el archivo
+ * completo en cada anotación, así que cada entrada se cierra sola. Eso la deja fuera del
+ * barrido de abajo (una lectura de todo el archivo no descifra: son muchos textos pegados)
+ * y la mete en su propio camino al cambiar de proveedor.
+ */
+export const LINE_FILES = Object.freeze(['activity.log'])
+
 export function encryptedFilesIn (dir) {
   let names = []
   try { names = fs.readdirSync(dir) } catch (_) { return [] }
   return names.filter((n) => {
     if (n === CONFIG_FILE || n === WRAPPED_FILE || n === SALT_FILE || n === MACHINE_FILE) return false
+    if (LINE_FILES.includes(n)) return false
     try { return isEncrypted(fs.readFileSync(path.join(dir, n), 'utf8')) } catch (_) { return false }
   })
 }
 
+/** Las bitácoras presentes en `dir`, con sus líneas. `[]` si no hay ninguna. */
+export function lineFilesIn (dir) {
+  return LINE_FILES.filter((n) => { try { return fs.statSync(path.join(dir, n)).isFile() } catch (_) { return false } })
+}
+
 /**
  * CAMBIAR DE PROVEEDOR: descifra todo con la clave vieja y lo vuelve a cifrar con la nueva.
  *
@@ -219,6 +241,19 @@ export function rekeyDir (dir, newConfig, { password = '' } = {}) {
       throw new KekError('kek-rekey', `cannot decrypt ${n} with the current provider (${oldCfg.provider}): ${e.message}`)
     }
   }
+  // Las bitácoras, por líneas. `decryptText` deja pasar el texto en claro, así que una
+  // mitad vieja sin cifrar cruza intacta y sale cifrada con la clave nueva.
+  const lineFiles = lineFilesIn(dir)
+  const plainLines = new Map()
+  for (const n of lineFiles) {
+    const p = path.join(dir, n)
+    try {
+      const lines = fs.readFileSync(p, 'utf8').split('\n')
+      plainLines.set(n, lines.map((l) => (l ? decryptText(l, oldKey) : l)))
+    } catch (e) {
+      throw new KekError('kek-rekey', `cannot decrypt ${n} with the current provider (${oldCfg.provider}): ${e.message}`)
+    }
+  }
 
   // 2. La clave nueva, todavía sin escribir su envoltorio.
   let newKey; let newBlob = null
@@ -236,6 +271,15 @@ export function rekeyDir (dir, newConfig, { password = '' } = {}) {
     if (decryptText(blob, newKey) !== text) throw new KekError('kek-verify', `re-encryption check failed for ${n}: nothing was written`)
     out.set(n, blob)
   }
+  for (const [n, lines] of plainLines) {
+    const blobs = lines.map((l) => (l ? encryptText(l, newKey) : l))
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i] && decryptText(blobs[i], newKey) !== lines[i]) {
+        throw new KekError('kek-verify', `re-encryption check failed for ${n} (line ${i + 1}): nothing was written`)
+      }
+    }
+    out.set(n, blobs.join('\n'))
+  }
 
   // 4. A disco. Copia de seguridad, temporal, renombrar.
   const backups = []
@@ -266,6 +310,6 @@ export function rekeyDir (dir, newConfig, { password = '' } = {}) {
 
 export default {
   machineKey, kekFor, atRestFor, migrateFile, isEncrypted, encryptText, decryptText,
-  rekeyDir, encryptedFilesIn, readConfig, writeConfig, probe, KekError
+  rekeyDir, encryptedFilesIn, lineFilesIn, LINE_FILES, readConfig, writeConfig, probe, KekError
 }
 export { readConfig, writeConfig, probe, configFromEnv, KekError, CONFIG_FILE, WRAPPED_FILE }

package/src/service.js

@@ -668,7 +668,13 @@ async function openSealedBundle (sealed, ident, acta = null, masterPubkey = null
     // sería aceptar un valor en claro dentro de un paquete que se supone todo sellado, o
     // sea la puerta para colar uno.
     if (typeof e.v === 'string' && !e.e) {
-      throw Object.assign(new Error(`${key} arrived in the clear: since 2026-09-02 every variable travels sealed`), { code: 'plaintext-var' })
+      // TAMPOCO SE ARREGLA ESPERANDO, igual que `no-wrapping`. El valor está guardado en
+      // claro en la bóveda, de antes de que todo viajara sellado, y solo vuelve a
+      // escribirlo quien puede abrirla. Reintentar no lo sella: solo vuelve a timbrar.
+      throw Object.assign(
+        new Error(`${key} arrived in the clear: since 2026-09-02 every variable travels sealed` +
+          ` — rewrite it in the vault (dotrino-vault unlock, then secret set ${ident?.ns || '<ns>'} ${key} …) or remove it`),
+        { code: 'plaintext-var' })
     }
     // `owner` dice de qué cajón salió, y `gen` con qué llave de ese cajón se abre.
     const cual = String(e.owner || '').startsWith('dev:') ? 'dev' : 'ns'
@@ -1026,21 +1032,52 @@ function fingerprintOf (secrets) {
  * Se decide por `e.code` donde lo hay: emparejar un mensaje por su texto se rompe en
  * silencio en cuanto alguien lo reescribe (ver `dotrino-error-strings`).
  */
+const FINAL_CODES = new Set([
+  'no-wrapping',   // falta la envoltura, y solo la fabrica el dueño abriendo la bóveda
+  'plaintext-var'  // el valor está en claro en la bóveda: hay que volver a escribirlo
+])
+
 export function isFinal (e) {
-  if (e?.code === 'no-wrapping') return true
+  if (FINAL_CODES.has(e?.code)) return true
   return /not enrolled|invalid ns|unauthorized: (revoked|expired|scope|cn|untrusted-issuer|cert-device-mismatch|denied)/.test(e?.message || '')
 }
 
-export async function waitForSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, retryMs = 5000, maxRetryMs = 60000, onRetry, onPending, onCert, publicOnly = false } = {}) {
-  let delay = retryMs
+/**
+ * CUÁNTO ESPERAR ANTES DE VOLVER A PEDIR, y por qué no siempre es el backoff.
+ *
+ * Un cajón con aprobación hace sonar el teléfono en CADA petición. Con el reintento a
+ * cinco segundos, un fallo posterior a la aprobación volvía a pedir enseguida y el dueño
+ * veía dos avisos del mismo cajón: aprobaba el primero para nada. La regla es que un
+ * reintento no llegue nunca antes de que venza el pedido que ya está sonando.
+ *
+ * La otra mitad importa igual: si el intento se pasó la ventana entera esperando a que
+ * alguien aprobara, no se le suma otra ventana — ahí ya no hay nada sonando, y hacerle
+ * esperar cinco minutos más sería un cuelgue.
+ *
+ * @param {number} backoffMs  lo que tocaría por el backoff normal
+ * @param {number} rangAt     cuándo timbró este intento (0 si no timbró)
+ * @param {number} approvalTimeoutMs  lo que dura un pedido de aprobación
+ * @param {number} now
+ */
+export function retryDelay (backoffMs, rangAt, approvalTimeoutMs = APPROVAL_TIMEOUT_MS, now = Date.now()) {
+  if (!rangAt) return backoffMs
+  return Math.max(backoffMs, approvalTimeoutMs - (now - rangAt))
+}
+
+export async function waitForSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, retryMs = 5000, maxRetryMs = 60000, approvalTimeoutMs = APPROVAL_TIMEOUT_MS, onRetry, onPending, onCert, publicOnly = false } = {}) {
+  let backoff = retryMs
+  let rangAt = 0   // cuándo timbró ESTE intento; 0 = no hubo aprobación de por medio
+  const notePending = (info) => { rangAt = Date.now(); onPending?.(info) }
   for (;;) {
     try {
-      return await fetchSecrets({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, onPending, onCert, publicOnly })
+      return await fetchSecrets({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, approvalTimeoutMs, onPending: notePending, onCert, publicOnly })
     } catch (e) {
       if (isFinal(e)) throw e
-      try { onRetry?.(e, delay) } catch (_) {}
-      await new Promise((r) => setTimeout(r, delay))
-      delay = Math.min(maxRetryMs, Math.round(delay * 1.6))
+      const wait = retryDelay(backoff, rangAt, approvalTimeoutMs)
+      rangAt = 0
+      try { onRetry?.(e, wait) } catch (_) {}
+      await new Promise((r) => setTimeout(r, wait))
+      backoff = Math.min(maxRetryMs, Math.round(backoff * 1.6))
     }
   }
 }