@dotrino/vaultd 0.86.0 → 0.88.0

package/lib/src/admin.js

@@ -204,7 +204,9 @@ export function createAdminDesk ({
         const toScope = typeof data.ns === 'string' && !!data.ns
         const toDevice = typeof data.pub === 'string' && !!data.pub
         if (data.op === 'vars') {
-          const result = await vars.list({ by })
+          // QUIÉN PREGUNTA, no solo su nombre: con su llave se le manda la envoltura de
+          // cada pública para que pueda abrirla en su casa.
+          const result = await vars.list({ by, caller: chk.device })
           audit('admin.vars', { by })
           return { ok: true, result }
         }

package/package.json

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

@@ -1112,12 +1112,12 @@ async function cmdSecret (rest) {
   /**
    * Una variable en la lista: su nombre, y que TIENE valor. Ninguna lo enseña.
    *
-   * La pública lo enseñaba, porque se guardaba en claro. Desde 2026-09-02 las dos van
-   * selladas igual y `pública` solo dice que se entrega sin pedir aprobación (dueño: «la
-   * única diferencia es si se despachan o no, son políticas»). Enseñar el hueco vacío de
-   * una pública era peor que no enseñar nada: parecía que se había perdido.
+   * Las dos van selladas igual desde 2026-09-02. Lo que las separa es que a quien administra
+   * se le hace la envoltura de las PÚBLICAS y la bóveda le manda su sobre, así que puede
+   * abrirlas; de una privada de un cajón con dueño no tiene envoltura ni recibe sobre.
    */
-  const printVar = (k) => console.log('  · %s   ••••••%s', k.key, k.public ? '   (pública)' : '')
+  const printVar = (k) => console.log('  · %s   %s', k.key,
+    k.public ? `${k.value ?? '••••••'}   (pública)` : '••••••')
   /**
    * Por qué no se aplicó. El daemon deja el motivo en el volcado siguiente; sin él lo
    * único que se podía decir era «revisa los logs», que no ayuda a quien acaba de
@@ -1187,7 +1187,7 @@ async function cmdSecret (rest) {
     // QUÉ SIGNIFICA HOY (dueño, 2026-09-02): todas se guardan selladas igual, y `pública`
     // solo dice a quién se le entrega SIN APROBACIÓN. Decir «su valor se puede ver» era
     // verdad cuando se guardaba en claro; dejarlo ahí sería prometer algo que ya no pasa.
-    console.log('\n(pública) = se entrega sin pedirte aprobación. Todas se guardan cifradas igual.\n')
+    console.log('\n(pública) = se entrega sin pedirte aprobación y quien administra puede leerla. Todas van cifradas.\n')
     printPending(d)
     await printNoPassword()
     return

package/src/secretsStore.js

@@ -296,8 +296,13 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
   }
 
   /** Los destinatarios de un cajón: los que dice el acta, más la copia de recuperación. */
-  const wrapAll = async (cek, owner) => {
-    const members = (await recipients?.(owner)) || []
+  /**
+   * @param {boolean} isPublic Una PÚBLICA se envuelve además para quien administra, aunque
+   *   el cajón tenga dueño (dueño, 2026-09-02). Puede variar por variable porque cada
+   *   escritura estrena su propia CEK: el llavero guarda una generación por valor.
+   */
+  const wrapAll = async (cek, owner, isPublic = false) => {
+    const members = (await recipients?.(owner, { public: isPublic })) || []
     const { wraps, sinLlave } = await sealer.wrapFor(cek, members)
     wraps[RECOVERY] = await sealer.wrapForKey(cek, data.recovery.pub)
     return { wraps, sinLlave }
@@ -537,7 +542,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       // CEK NUEVA, siempre: no se puede reutilizar la de antes sin poder abrirla.
       const cek = await sealer.newKey()
       const gen = (topGen(bag, k)?.gen || 0) + 1
-      const { wraps, sinLlave } = await wrapAll(cek, owner)
+      const { wraps, sinLlave } = await wrapAll(cek, owner, pub)
       const e = await sealer.encrypt(cek, value, gen)
       // La FIRMA dice que este sobre salió de esta bóveda, y con qué acta (§8.8). Si no
       // hay con qué firmar, el sobre sale sin firma: guardar es más importante.
@@ -613,6 +618,24 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       return { gen }
     },
 
+    /**
+     * LA ENTRADA TAL CUAL (sobre, generación, visibilidad) — sin abrir nada.
+     *
+     * Es lo que hace falta para MANDARLE a alguien una variable que sí puede leer: el sobre
+     * viaja cerrado y lo abre en su casa, con su envoltura. Aquí no se descifra.
+     */
+    entryOf (owner, key) {
+      const [kind, k] = splitOwner(owner)
+      const bag = kind === 'ns' ? data.ns : data.dev
+      return varsOf(bag, k)[key] || null
+    },
+    /** La envoltura de ESA generación para ESE miembro, o `null` si no la tiene. */
+    wrapOf (owner, gen, memberPub) {
+      const [kind, k] = splitOwner(owner)
+      const bag = kind === 'ns' ? data.ns : data.dev
+      return (bag[k]?.keyring || []).find((g) => g.gen === gen)?.wraps?.[memberPub] || null
+    },
+
     /**
      * ¿EXISTE YA ESTA VARIABLE? Sin abrirla ni decir qué vale.
      *
@@ -631,9 +654,9 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
      * haya dos sitios respondiendo a «quién puede abrir este cajón» (la lista la sabe el
      * acta, y de ahí sale `recipients`).
      */
-    async recipientsFor (owner) {
+    async recipientsFor (owner, { public: isPublic = false } = {}) {
       await ensureRecovery(null)
-      const members = (await recipients?.(owner)) || []
+      const members = (await recipients?.(owner, { public: isPublic })) || []
       return {
         recoveryPub: data.recovery.pub,
         members: members.filter((m) => m.encPub).map((m) => ({ pub: m.pub, encPub: m.encPub }))
@@ -796,6 +819,13 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       return [...Object.keys(data.ns).map((k) => `ns:${k}`), ...Object.keys(data.dev).map((k) => `dev:${k}`)]
     },
     /** @private */
+    /**
+     * @param {Array|((isPublic:boolean)=>Promise<Array>)} members A quién envolver. Puede ser
+     *   una FUNCIÓN de la visibilidad: desde 2026-09-02 una pública se envuelve además para
+     *   quien administra, y eso se decide por variable — cada escritura estrena su CEK, así
+     *   que el llavero tiene una generación por valor. Con una lista fija se aplicaría la
+     *   misma a todas y se le daría a la consola la envoltura de una privada con dueño.
+     */
     async _rewrap (owner, members, adminKey = null, { exact = false } = {}) {
       needSealer('re-wrap the key of a drawer')
       if (needsMigration()) throw new NeedsMigration()
@@ -805,11 +835,15 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       const priv = await openRecovery(adminKey)
       let wrapped = 0
       const sinLlave = new Set()
+      // De qué variable es cada generación: es lo que dice si esa CEK es de una pública.
+      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 g of bag[k].keyring || []) {
         const w = g.wraps?.[RECOVERY]
         if (!w) continue
         const cek = await sealer.openWrapWith(priv, w)
-        const r = await sealer.wrapFor(cek, members)
+        const r = await sealer.wrapFor(cek, await paraGen(g.gen))
         // `exact`: el llavero queda con lo que dice el acta y NADA más. Es lo que hace
         // falta para rehacerlo al abrir la bóveda:
         //   · una envoltura basura que metió alguien se reemplaza por la buena;

package/src/vault.js

@@ -197,7 +197,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // A QUIÉN se le envuelve la llave de cada cajón: los servicios de ese namespace (o el
     // propio aparato, si el cajón es suyo) MÁS los aparatos que administran. Sale del
     // acta, y por eso lo pone el vault: el store no conoce el acta.
-    recipients: (owner) => recipientsOf(owner),
+    recipients: (owner, opts) => recipientsOf(owner, opts),
     // La FIRMA del sobre: dice que salió de esta bóveda y con qué acta (§8.8).
     signer: (body) => signSeal(body),
     // CON QUÉ se cierra la copia de recuperación cuando quien llama no trajo la frase:
@@ -808,7 +808,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // Y su cajón PROPIO también: un aparato con variables suyas se quedaba sin poder
       // abrirlas, que es el mismo agujero por otra puerta.
       for (const owner of [`ns:${ns}`, `dev:${chk.device}`]) {
-        await spreadKey(owner, await recipientsOf(owner))
+        await spreadKey(owner, (esPublica) => recipientsOf(owner, { public: esPublica }))
           .catch((e) => log(`[vault] ${owner}: could not hand it the key: ${e.message}`))
       }
       const body = { op: 'secrets.result', ns, enc: null, ok: true, ts: Date.now() }
@@ -1358,14 +1358,21 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
 
   const varsDesk = {
-    async list () {
-      // `listSecrets`/`listDeviceSecrets` ya traen el valor de las públicas y solo de esas:
-      // la frontera se decide en un sitio, y lo mismo ve el dueño en su terminal que aquí.
+    async list ({ caller = null } = {}) {
+      // EL VAULT DECIDE QUÉ ENVÍA PARA LEER (dueño, 2026-09-02: «la consola debe tener todos
+      // los sobres; la diferencia es si el vault se los envía para la lectura o no»).
+      //
+      // Tener la envoltura y recibir el sobre son dos cosas: quien administra tiene la
+      // envoltura de cada PÚBLICA, y por eso aquí se le manda el sobre de esas y solo de
+      // esas. Las privadas de un cajón con dueño no se mandan — y aunque se mandaran no
+      // podría abrirlas, porque su envoltura no existe. Dos cerrojos para lo mismo, a
+      // propósito: que uno falle no basta para leerlas.
+      //
       // Se sella la lista ENTERA, no solo los valores: el proxy tampoco tiene por qué
       // aprender cómo se llaman tus variables ni qué servicios corres.
       return {
         enc: await identity.sealContent(JSON.stringify({
-          ns: listSecrets(), dev: await listDeviceSecrets(),
+          ns: conSobres(listSecrets(), 'ns', caller), dev: conSobres(await listDeviceSecrets(), 'dev', caller),
           // Aparatos que están en el acta pero no pueden abrir lo suyo: hay que
           // enseñarlo donde se administra, no solo en el log del servicio.
           incomplete: await incompleteMembers(),
@@ -1386,8 +1393,12 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
      * (`recipientsOf`), y tener dos sitios respondiendo a «quién puede abrir este cajón» es
      * exactamente cómo se acaba dejando fuera a alguien sin que nadie se entere.
      */
-    async recipients ({ ns, pub }) {
-      return secrets.recipientsFor(ns ? `ns:${ns}` : `dev:${pub}`)
+    async recipients ({ ns, pub, public: isPublic }) {
+      // LA VISIBILIDAD CAMBIA LA LISTA: una pública se envuelve además para quien
+      // administra, así que hay que decirlo al preguntar. Pedirla sin decirlo y luego
+      // guardarla como pública produciría un sobre que la consola no puede abrir — y la
+      // bóveda lo rechazaría, que es lo correcto pero desorienta.
+      return secrets.recipientsFor(ns ? `ns:${ns}` : `dev:${pub}`, { public: !!isPublic })
     },
     /**
      * GUARDAR UNA VARIABLE **SIN VERLA** (dueño, 2026-09-01).
@@ -1416,7 +1427,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         // despachan o no, son políticas; dales el mismo tratamiento de seguridad»). La
         // marca solo decide si se entrega sin aprobación.
         await verificarAutor(owner, key, sealed, caller)
-        await verificarDestinatarios(owner, sealed.wraps)
+        await verificarDestinatarios(owner, sealed.wraps, !!isPublic)
         await secrets.putSealed(owner, key, sealed, { by: who, public: isPublic })
         audit('secret.set', { ns: ns || null, key, sealed: true }); scheduleNotice(ns)
         await settleDebts(owner)
@@ -1456,7 +1467,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       for (const it of items) {
         if (!it?.key || !it?.sealed) throw new Error('var.setMany: each variable needs its key and its sealed envelope')
         await verificarAutor(owner, it.key, it.sealed, caller)
-        await verificarDestinatarios(owner, it.sealed.wraps)
+        await verificarDestinatarios(owner, it.sealed.wraps, !!it.public)
       }
       // Se comprueban TODAS antes de escribir NINGUNA: media carga aplicada es una
       // configuración que nadie quiso, y el servicio se reinicia con ella.
@@ -1660,24 +1671,43 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
 
   /** Sin duplicar: un cosellador puede ser además el dueño del cajón. */
+  /** Sin repetidos por llave: un aparato puede entrar por dos vías (dueño y admin). */
+  const dedup = (miembros) => {
+    const vistos = new Set()
+    return miembros.filter((m) => m && !vistos.has(m.pub) && vistos.add(m.pub))
+  }
   const conCoselladores = (base, co) => {
     const vistos = new Set(base.map((m) => m.pub))
     return [...base, ...co.filter((m) => !vistos.has(m.pub))]
   }
 
-  async function recipientsOf (owner) {
+  async function recipientsOf (owner, { public: isPublic = false } = {}) {
     const co = await cosealerMembers()
+    // UNA PÚBLICA SE ENVUELVE TAMBIÉN PARA QUIEN ADMINISTRA (dueño, 2026-09-02: «la consola
+    // debe poder leer todas las variables… debe tener todos los sobres; la diferencia es si
+    // el vault se los envía para la lectura o no» → «cambia la regla y di que se envuelven
+    // las públicas»).
+    //
+    // Puede decidirse variable a variable porque cada escritura estrena su propia CEK: el
+    // llavero guarda una generación por valor, no una por cajón.
+    //
+    // Y la PRIVADA de un cajón con dueño sigue sin envoltura para la consola, que es la
+    // regla de agosto y su motivo no ha cambiado: el token de R2 no tiene por qué poder
+    // abrirse desde un navegador. Lo que cambia es que «pública» ya sí quiere decir algo
+    // para quien administra — puede leerla— además de que se despacha sin aprobación.
+    const admins = isPublic ? await adminDevices() : []
     if (owner.startsWith('ns:')) {
       const owned = await nsMembers(owner.slice(3))
-      // Sin dueño (un cajón personal, o uno cuyo servicio ya no está) sí entra quien
-      // administra: si no, no quedaría nadie que pudiera abrirlo sin la frase.
-      return conCoselladores(owned.length ? owned : await adminDevices(), co)
+      // Sin dueño (un cajón personal, o uno cuyo servicio ya no está) entra quien administra
+      // SIEMPRE: si no, no quedaría nadie que pudiera abrirlo sin la frase.
+      const base = owned.length ? [...owned, ...admins] : await adminDevices()
+      return conCoselladores(dedup(base), co)
     }
     const pub = owner.slice(owner.indexOf(':') + 1)
     const m = await memberOf(pub)
     // El cajón propio de un aparato de SERVICIO es tan suyo como el de su ns.
-    if (m?.cn) return conCoselladores([m], co)
-    return conCoselladores([...(m ? [m] : []), ...await adminDevices()], co)
+    if (m?.cn) return conCoselladores(dedup([m, ...admins]), co)
+    return conCoselladores(dedup([...(m ? [m] : []), ...await adminDevices()]), co)
   }
 
   /**
@@ -2052,9 +2082,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    *
    * Lo de dentro lo corrige el repaso al abrir la bóveda, que es para lo que está.
    */
-  async function verificarDestinatarios (owner, wraps) {
+  async function verificarDestinatarios (owner, wraps, isPublic = false) {
     if (!wraps || typeof wraps !== 'object') throw new Error('var.set: the envelope carries no wraps')
-    const { recoveryPub, members } = await secrets.recipientsFor(owner)
+    const { recoveryPub, members } = await secrets.recipientsFor(owner, { public: isPublic })
     if (!recoveryPub) throw new Error('var.set: this vault has no recovery key yet')
     const deben = new Set(members.map((m) => m.pub))
     const traidos = new Set(Object.keys(wraps).filter((k) => k !== RECOVERY_WRAP))
@@ -2146,7 +2176,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const out = { drawers: 0, wrapped: 0, dropped: 0, sinLlave: [], failed: [] }
     for (const owner of secrets.owners?.() || []) {
       const before = new Set(secrets.recipientsIn(owner))
-      const members = await recipientsOf(owner)
+      // POR VISIBILIDAD, no una lista fija: una pública lleva además la envoltura de quien
+      // administra. Con una sola lista se le daría también la de una privada con dueño, que
+      // es justo lo que no puede pasar.
+      const members = (esPublica) => recipientsOf(owner, { public: esPublica })
       try {
         const r = await secrets.rewrap(owner, members, adminKey, { exact: true })
         const after = new Set(secrets.recipientsIn(owner))
@@ -2179,7 +2212,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // Los destinatarios de un cajón no son solo quien lo consume: también quien lo
       // administra (`recipientsOf`). Envolver solo para los primeros dejaba a la consola
       // sin poder destapar lo que ella misma acababa de saldar.
-      const members = await recipientsOf(owner)
+      const members = (esPublica) => recipientsOf(owner, { public: esPublica })
       try { out[owner] = await spreadKey(owner, members, adminKey) } catch (e) {
         // Sin frase, el último recurso es pedírselo a quien sí puede: el propio servicio.
         let delegated = 0
@@ -2213,7 +2246,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // (dueño, 2026-09-01: «al envolver hay que envolver siempre para todos los selladores,
     // para que siempre tengan la info fresca»). Dos listas para la misma pregunta acaban
     // siempre así: una se actualiza y la otra no.
-    try { return await spreadKey(owner, await recipientsOf(owner), null) } catch (_) { return null }
+    try { return await spreadKey(owner, (esPublica) => recipientsOf(owner, { public: esPublica }), null) } catch (_) { return null }
   }
   async function deleteSecret (ns, key) { const ok = await secrets.delete(ns, key); if (ok) { audit('secret.rm', { ns, key }); scheduleNotice(ns) } return ok }
 
@@ -2301,6 +2334,34 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * de esta máquina»: taparlo justo aquí —en la máquina donde vive, delante de su dueño—
    * era lo único que la marca no significaba. La consola remota ya las enseña.
    */
+  /**
+   * LE PONE A CADA PÚBLICA SU SOBRE Y LA ENVOLTURA DE QUIEN PREGUNTA, para que pueda leerla.
+   *
+   * Solo a las públicas: es la política de despacho, y es lo único que cambia entre una y
+   * otra. A una privada no se le manda nada — y aunque se le mandara, quien administra no
+   * tiene su envoltura en un cajón con dueño, así que no la abriría igual.
+   *
+   * Si falta la envoltura de quien pregunta (todavía no se le ha hecho, o el cajón se
+   * escribió antes de que entrara) se manda la variable SIN sobre: se ve que existe y que es
+   * pública, y no se puede leer. Eso es cierto y se arregla abriendo la bóveda; inventarse
+   * un valor o esconder la fila sería peor.
+   */
+  const conSobres = (lista, tipo, caller) => {
+    if (!caller) return lista
+    const dar = (owner, k) => {
+      if (!k.public) return k
+      const e = secrets.entryOf?.(owner, k.key)
+      const wrap = e?.gen != null ? secrets.wrapOf?.(owner, e.gen, caller) : null
+      return e?.e && wrap ? { ...k, e: e.e, wrap } : k
+    }
+    if (tipo === 'ns') {
+      const out = {}
+      for (const [ns, keys] of Object.entries(lista)) out[ns] = keys.map((k) => dar(`ns:${ns}`, k))
+      return out
+    }
+    return lista.map((row) => ({ ...row, keys: row.keys.map((k) => dar(`dev:${row.pub}`, k)) }))
+  }
+
   function listSecrets () {
     // YA NO SE ENSEÑA EL VALOR DE UNA PÚBLICA (dueño, 2026-09-02). Desde que todas van en
     // sobre, «pública» dejó de significar «en claro»: dice a quién se le despacha sin
@@ -2448,7 +2509,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         // envolver hay que envolver siempre para todos los selladores, para que siempre
         // tengan la info fresca»). Repartiendo solo a los del ns, un cajón tocado por esta
         // puerta dejaba a los selladores con la envoltura vieja.
-        await spreadKey(`ns:${m.cn}`, await recipientsOf(`ns:${m.cn}`), adminKey).catch(async (e) => {
+        await spreadKey(`ns:${m.cn}`, (esPublica) => recipientsOf(`ns:${m.cn}`, { public: esPublica }), adminKey).catch(async (e) => {
           log('[vault] could not hand the key to the new service:', e.message)
           // Sin la frase la bóveda no puede envolvérsela… pero un HERMANO suyo sí: otro
           // servicio del mismo cajón ya tiene la llave abierta (§8.11). Si contesta, el