@dotrino/vaultd 0.96.0 → 0.97.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.96.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": {

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

@@ -2291,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
@@ -2303,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) {
@@ -2310,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
   }