@dotrino/vaultd 0.87.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.87.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

@@ -618,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.
      *

package/src/vault.js

@@ -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(),
@@ -2327,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