@dotrino/vaultd 0.95.0 → 0.96.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.96.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/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')