@dotrino/vault 0.52.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.52.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/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))
     }
   }
 }