@dotrino/vaultd 0.95.0 → 0.97.0

package/lib/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))
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.95.0",
+  "version": "0.97.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "@dotrino/identity": "0.76.0",
-    "@dotrino/passmanager": "^0.9.0",
+    "@dotrino/passmanager": "^0.10.1",
     "@dotrino/proxy-client": "^0.13.1",
     "ws": "^8.18.0"
   },

package/src/daemon.js

@@ -333,10 +333,13 @@ export async function runDaemon () {
           // cajón envuelto para exactamente quien dice el acta — creando lo que falta,
           // reemplazando lo que alguien metiera mal y quitando lo que sobre.
           const r = await mgr.get(id)?.resealAll?.(ak)
-          if (r?.wrapped) console.log('[vault] keyring rebuilt on unlock: %d wrap(s) in %d drawer(s)%s',
-            r.wrapped, r.drawers, r.dropped ? `, ${r.dropped} stale one(s) dropped` : '')
+          if (r?.wrapped) console.log('[vault] keyring rebuilt on unlock: %d wrap(s) in %d drawer(s)%s%s',
+            r.wrapped, r.drawers, r.dropped ? `, ${r.dropped} stale one(s) dropped` : '',
+            r.sealed ? `, ${r.sealed} value(s) left in the clear now sealed` : '')
           if (r?.dropped) note = ` · llavero al día (${r.dropped} envoltura(s) de más retirada(s))`
           else if (r?.wrapped) note = ' · llavero al día'
+          // Se SUMA, no pisa: es lo que el dueño necesita ver de esta apertura en concreto.
+          if (r?.sealed) note += ` · ${r.sealed} valor(es) que estaban sin cifrar ya están sellados`
           // ABIERTA PERO SIN LLAVERO NO ES «ABIERTA». Si un cajón no se pudo reenvolver, sus
           // aparatos no van a poder leer nada y hay que decirlo AQUÍ: contestar
           // «desbloqueado» a secas dejaba la bóveda pareciendo sana, y el fallo aparecía

package/src/secretsStore.js

@@ -834,11 +834,44 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       if (!bag[k]) return { wrapped: 0, sinLlave: [] }
       const priv = await openRecovery(adminKey)
       let wrapped = 0
+      let sealed = 0
       const sinLlave = new Set()
+      const vars = varsOf(bag, k)
+      const paraVisibilidad = async (esPublica) => (typeof members === 'function' ? members(esPublica) : members)
+
+      // UN VALOR QUE SE QUEDÓ EN CLARO SE SELLA AQUÍ, que es el único sitio donde se puede.
+      //
+      // Una pública escrita antes del 2026-09-02 se guardó legible y SIN sobre, así que no
+      // tiene generación ni entrada en el llavero. Y el llavero es lo único que este
+      // método reenvuelve: por muchas veces que se abra la bóveda, a esa variable no se le
+      // crea una envoltura nunca. Sus aparatos la reclaman para siempre («no key yet») y la
+      // consola invita a abrir la bóveda, que es justo lo que no lo arregla. Peor: desde
+      // 2026-09-02 el agente rechaza el cajón ENTERO por ella, así que una variable de
+      // prueba deja sin leer el token que está al lado.
+      //
+      // Con la bóveda abierta el valor está delante, así que se cifra como si se acabara
+      // de escribir. No es un repliegue ni una migración a medias: es la conversión que
+      // faltaba, y ocurre en el único momento en que hay con qué hacerla.
+      for (const [key, e] of Object.entries(vars)) {
+        if (typeof e.v !== 'string' || e.e) continue
+        const cek = await sealer.newKey()
+        const gen = (topGen(bag, k)?.gen || 0) + 1
+        const r = await sealer.wrapFor(cek, await paraVisibilidad(!!e.pub))
+        r.wraps[RECOVERY] = await sealer.wrapForKey(cek, data.recovery.pub)
+        const sobre = await sealer.encrypt(cek, e.v, gen)
+        const seal = signer ? await signer({ owner, key, gen, iv: sobre.iv, ct: sobre.ct }) : null
+        // `pub` y `at` se conservan: no es un valor nuevo, es el mismo mejor guardado.
+        vars[key] = { pub: !!e.pub, owner, gen, e: sobre, seal, at: e.at || Date.now(), by: e.by || null }
+        bag[k].keyring = [...(bag[k].keyring || []), { gen, createdAt: Date.now(), wraps: r.wraps }]
+        for (const x of r.sinLlave) sinLlave.add(x)
+        sealed++
+      }
+
       // De qué variable es cada generación: es lo que dice si esa CEK es de una pública.
+      // Se calcula DESPUÉS de sellar, para que las generaciones recién creadas entren.
       const visibilidad = new Map()
-      for (const e of Object.values(varsOf(bag, k))) if (e.gen != null) visibilidad.set(e.gen, !!e.pub)
-      const paraGen = async (gen) => (typeof members === 'function' ? members(visibilidad.get(gen) === true) : members)
+      for (const e of Object.values(vars)) if (e.gen != null) visibilidad.set(e.gen, !!e.pub)
+      const paraGen = async (gen) => paraVisibilidad(visibilidad.get(gen) === true)
       for (const g of bag[k].keyring || []) {
         const w = g.wraps?.[RECOVERY]
         if (!w) continue
@@ -859,7 +892,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
         wrapped += Object.keys(r.wraps).length
       }
       save()
-      return { wrapped, sinLlave: [...sinLlave] }
+      return { wrapped, sealed, sinLlave: [...sinLlave] }
     },
 
     /**

package/src/vault.js

@@ -19,6 +19,8 @@ import * as Acta from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS } from '../lib/src/enroll.js'
 import { createAdminDesk, authorBody } from '../lib/src/admin.js'
 import { shouldNotifyRevoked } from '../lib/src/revocation.js'
+// El sobre del gestor, el mismo que usan la bóveda-en-pestaña y la extensión.
+import { identitySealing } from '@dotrino/passmanager'
 import { createTransport, masterPubkeyOf } from './transport.js'
 import { startSealersPublisher } from './sealers.js'
 import { assertKeyOwnsDir } from './keyowner.js'
@@ -1200,30 +1202,22 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * EL SELLADO del gestor: la misma cripto de los sobres del ecosistema
    * (`@dotrino/identity/content`), atada a la llave de cifrado de esta bóveda.
    *
-   * Va aquí y no en el cliente del transporte porque el cliente del vault es UNO y lo
-   * comparte todo: el protocolo de la CA viaja en claro a propósito (un enrolamiento es
-   * público hasta que hay cert). Lo que se sella es lo del gestor, y por eso `isSealed`
-   * mira su marca y no otra.
+   * Lo arma el PILAR (`identitySealing`), que es la MISMA pieza que usan las otras dos
+   * bóvedas —la de la pestaña y la de dentro de la extensión—. Estaba escrito a mano aquí,
+   * y son las tres puntas del mismo sobre: tres copias son dos que se pueden quedar atrás,
+   * y ese fallo no hace ruido — la petición sale, al otro lado «no es para mí», y desde
+   * fuera se ve como que nadie respondió.
+   *
+   * NO se pone `requireSealed` en el cliente, y no es un olvido: el cliente del vault es
+   * UNO y lo comparte todo, y el protocolo de la CA viaja en claro a propósito (un
+   * enrolamiento es público hasta que hay cert). Lo que corta aquí es `VaultResponder`,
+   * que tira lo que llegue sin la marca `sealed`. Por eso `isSealed` mira la marca del
+   * gestor y no otra.
    *
    * Sin esto la bóveda RECIBÍA los sobres y los tiraba —el cliente no tenía con qué
    * abrirlos— y el aparato se quedaba esperando sin que nada lo dijera.
    */
-  const passwordSealing = {
-    async seal (msg, peerEncPub) {
-      if (!peerEncPub) throw Object.assign(new Error('no encryption key'), { code: 'unsealed' })
-      return {
-        app: 'passmanager',
-        // Destinatarios como OBJETOS y no como llaves sueltas: `encrypt` expande cada
-        // uno a todos los aparatos de esa persona, y una cadena a secas se le cae por
-        // el `continue` sin envolver nada — el sobre salía vacío y sin error.
-        sealed: await identity.encrypt([{ encryptionPubkey: peerEncPub }], JSON.stringify(msg)),
-        from: await identity.getEncryptionPubkey()
-      }
-    },
-    // `decrypt` devuelve `{ plaintext }`, no la cadena.
-    async open (env) { return JSON.parse((await identity.decrypt(env.from, null, env.sealed)).plaintext) },
-    isSealed: (m) => !!m && m.app === 'passmanager' && !!m.sealed
-  }
+  const passwordSealing = identitySealing(identity)
   const startPasswordDesk = async () => {
     if (passwords || !passwordDevices().length) return
     const { createPasswordDesk } = await import('./passwords.js')
@@ -2297,7 +2291,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // ANTES de reenvolver nada: si la copia de recuperación se quedó bajo la llave de la
     // máquina, se pasa a la frase. Sin esto, todo lo de abajo falla con «wrong password».
     if (adminKey) await migrarRecuperacionALaFrase(adminKey)
-    const out = { drawers: 0, wrapped: 0, dropped: 0, sinLlave: [], failed: [] }
+    const out = { drawers: 0, wrapped: 0, sealed: 0, dropped: 0, sinLlave: [], failed: [] }
     for (const owner of secrets.owners?.() || []) {
       const before = new Set(secrets.recipientsIn(owner))
       // POR VISIBILIDAD, no una lista fija: una pública lleva además la envoltura de quien
@@ -2309,6 +2303,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         const after = new Set(secrets.recipientsIn(owner))
         out.drawers++
         out.wrapped += r?.wrapped || 0
+        out.sealed += r?.sealed || 0
         out.dropped += [...before].filter((p) => !after.has(p)).length
         for (const p of r?.sinLlave || []) out.sinLlave.push(p)
       } catch (e) {
@@ -2316,7 +2311,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         out.failed.push({ owner, error: e.message })
       }
     }
-    if (out.dropped) audit('secret.reseal', { drawers: out.drawers, dropped: out.dropped })
+    if (out.dropped || out.sealed) audit('secret.reseal', { drawers: out.drawers, dropped: out.dropped, sealed: out.sealed })
     if (out.failed.length) audit('secret.reseal-failed', { drawers: out.failed.map((f) => f.owner) })
     return out
   }