@dotrino/vaultd 0.126.0 → 0.127.0

package/lib/src/admin.js

@@ -284,6 +284,12 @@ export function createAdminDesk ({
             by
           })
           const keys = result?.keys || []
+          // EN ESPERA DE APROBACIÓN: todavía no cambió nada, así que no hay de qué avisar. El
+          // aviso sale cuando se aprueba y se escribe de verdad.
+          if (result?.pending) {
+            audit('admin.var.pending', { by, ns: toScope ? data.ns : null, id: result.pending, count: data.items.length })
+            return { ok: true, result }
+          }
           audit('admin.var.set', { by, ns: toScope ? data.ns : null, device: toDevice ? await deviceIdOf(data.pub).catch(() => null) : null, keys })
           await notify('vars', { by, keys, ns: toScope ? data.ns : null })
           return { ok: true, result: result || { ok: true } }
@@ -308,6 +314,10 @@ export function createAdminDesk ({
           caller: chk.device,
           by
         })
+        if (result?.pending) {
+          audit('admin.var.pending', { by, ns: toScope ? data.ns : null, id: result.pending, count: 1 })
+          return { ok: true, result }
+        }
         audit('admin.var.set', { by, ns: toScope ? data.ns : null, device: toDevice ? await deviceIdOf(data.pub).catch(() => null) : null, key: data.key })
         // Cambiar la configuración de un servicio a distancia no puede ser invisible: es
         // la contrapartida de delegar (F3 de docs/consola-remota.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.126.0",
+  "version": "0.127.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": {
@@ -25,7 +25,7 @@
     "@dotrino/identity": "0.101.0",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.17.0",
-    "@dotrino/proxy-client": "0.23.1",
+    "@dotrino/proxy-client": "0.24.0",
     "@dotrino/roadmap": "0.3.7",
     "@dotrino/store": "0.11.0",
     "@dotrino/update": "0.1.1",

package/src/approvals.js

@@ -73,7 +73,9 @@ export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS
    * de un sobre (`handleApproval`). Si mañana aparece otro sitio que publique esta lista,
    * esto es lo que hay que recordar.
    */
-  const publicOf = (p) => ({ id: p.id, ns: p.ns, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp, ctx: p.ctx || null })
+  // `kind` dice QUÉ se pide: `read` (llevarse las claves, lo de siempre) o `write` (guardar
+  // variables). La pantalla del teléfono no puede decir «pide tus claves» a una escritura.
+  const publicOf = (p) => ({ id: p.id, ns: p.ns, kind: p.kind, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp, ctx: p.ctx || null })
 
   return {
     /** Apunta un pedido. Uno por cajón y aparato: pedir otra vez reemplaza al anterior. */
@@ -82,12 +84,15 @@ export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS
      * apruebe— y tiene que volver por el mismo sitio: desde que la bóveda atiende también
      * por un socket local, mandarla siempre por el proxio la dejaba en el vacío.
      */
-    request ({ ns, device, deviceId, label = '', ek, ctx = null, from = null, ttlMs = null }) {
-      for (const [id, p] of pending) if (p.ns === ns && p.device === device) pending.delete(id)
+    request ({ ns, device, deviceId, label = '', ek, ctx = null, from = null, ttlMs = null, kind = 'read' }) {
+      // Pedir las claves otra vez reemplaza al pedido anterior: es la misma pregunta. Una
+      // ESCRITURA no: cada una lleva su propio valor, y reemplazarla tiraría la anterior
+      // sin que nadie dijera que no.
+      if (kind !== 'write') for (const [id, p] of pending) if (p.kind !== 'write' && p.ns === ns && p.device === device) pending.delete(id)
       const ts = now()
       // `ttlMs` lo pone quien pide: una actualización aguanta un día y un comando cinco
       // minutos, y la mesa no tiene por qué saber cuál es cuál (ver `PENDING_TTL_MS`).
-      const p = { id: rnd(), ns, device, deviceId, label, ek, ctx, ts, exp: ts + (ttlMs || pendingTtlMs), from }
+      const p = { id: rnd(), ns, kind, device, deviceId, label, ek, ctx, ts, exp: ts + (ttlMs || pendingTtlMs), from }
       pending.set(p.id, p)
       return publicOf(p)
     },

package/src/vault.js

@@ -155,6 +155,31 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return !Acta.memberCan(record, pub, 'unattended')
   }
 
+  /**
+   * APUNTA UN PEDIDO QUE NO ENTREGA UN CAJÓN, avisa a quien aprueba y deja la respuesta en
+   * `onAnswer(sí|no)`. Lo usan la bóveda de contraseñas (un aparato espera su sí) y guardar
+   * variables (la escritura se aplica al aprobar). Si nadie contesta, vence solo con un no:
+   * nada se queda colgado para siempre.
+   */
+  async function awaitApproval ({ device, ns, kind, what, op = null, ctx = null, onAnswer }) {
+    const deviceId = await deviceIdOf(device).catch(() => null)
+    const record = await refreshActa()
+    const label = (record?.members || []).find((m) => m.pub === device)?.label || ''
+    const pend = approvals.request({ ns, device, deviceId, label, ek: '', ctx, kind })
+    audit(`${what}.pending`, { device: deviceId, ns, id: pend.id, op })
+    log(`[vault] ${what}: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
+    waiters.set(pend.id, onAnswer)
+    const t = setTimeout(() => {
+      if (waiters.delete(pend.id)) {
+        audit(`${what}.expired`, { device: deviceId, ns, id: pend.id })
+        onAnswer(false)
+      }
+    }, PENDING_TTL_MS)
+    t.unref?.()
+    await notifyApprovers(pend, record)
+    return pend
+  }
+
   /**
    * QUÉ COMANDO ESTÁ PIDIENDO LAS CLAVES, Y DESDE QUÉ CARPETA — medido, no creído.
    *
@@ -1595,16 +1620,23 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const id = typeof p.data?.id === 'string' ? p.data.id : ''
     const pend = approvals.take(id)
     if (!pend) return reply(from, { type: MSG.ERROR, error: 'approval: unknown or expired request' })
-    // PEDIDOS QUE NO SON DE UN CAJÓN (hoy: la bóveda de contraseñas). Se resuelve ANTES
-    // de tocar `resultFor`, que asume un cajón y una `ek`: aquí no hay nada que sellar,
-    // solo una promesa esperando un sí o un no.
+    // PEDIDOS QUE NO ENTREGAN UN CAJÓN (la bóveda de contraseñas, guardar variables). Se
+    // resuelven ANTES de tocar `resultFor`, que asume un cajón y una `ek`: aquí no hay nada
+    // que sellar, solo una promesa esperando un sí o un no.
     if (waiters.has(id)) {
       const resolver = waiters.get(id)
       waiters.delete(id)
       const ok = op === 'approve'
-      audit(ok ? 'passwords.approved' : 'passwords.denied', { device: pend.deviceId, id, by })
-      log(`[vault] passwords: request of ${pend.deviceId} ${ok ? 'approved' : 'DENIED'} by ${by}`)
-      resolver(ok)
+      const what = pend.kind === 'write' ? 'vars' : 'passwords'
+      audit(ok ? `${what}.approved` : `${what}.denied`, { device: pend.deviceId, ns: pend.ns, id, by })
+      log(`[vault] ${what}: request ${pend.id} of ${pend.deviceId} ${ok ? 'approved' : 'DENIED'} by ${by}`)
+      // Lo aprobado SE HACE AQUÍ (una escritura se aplica ahora), y si falla quien aprobó
+      // tiene que enterarse: decirle «hecho» a algo que no se guardó es el peor resultado.
+      try { await resolver(ok) } catch (e) {
+        log(`[vault] ${what}: ${pend.id} was approved but could not be applied: ${e.message}`)
+        audit(`${what}.apply-failed`, { id, reason: e.message })
+        return reply(from, { type: MSG.ERROR, error: `approval: approved, but it could not be applied: ${e.message}` })
+      }
       return answer({ op: `${op}.result`, id, ok: true })
     }
     if (op === 'deny') {
@@ -1917,24 +1949,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // El teléfono: se apunta el pedido, se le avisa y esta promesa espera su firma.
       // Es el mismo camino que ya recorren los cajones de secretos.
       approve: async ({ pubkey, op }) => {
-        const deviceId = await deviceIdOf(pubkey).catch(() => null)
-        const label = (actaCache?.members || []).find((m) => m.pub === pubkey)?.label || ''
-        const pend = approvals.request({ ns: 'passwords', device: pubkey, deviceId, label, ek: '' })
-        audit('passwords.pending', { device: deviceId, id: pend.id, op })
-        log(`[vault] passwords: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
-        const espera = new Promise((resolve) => {
-          waiters.set(pend.id, resolve)
-          // Si nadie contesta, vence solo: la promesa no se queda colgada para siempre
-          // y el aparato recibe un no en vez de esperar sin fin.
-          const t = setTimeout(() => {
-            if (waiters.delete(pend.id)) {
-              audit('passwords.expired', { device: deviceId, id: pend.id })
-              resolve(false)
-            }
-          }, PENDING_TTL_MS)
-          t.unref?.()
-        })
-        await notifyApprovers(pend, actaCache)
+        let resolve
+        const espera = new Promise((r) => { resolve = r })
+        await awaitApproval({ device: pubkey, ns: 'passwords', kind: 'read', what: 'passwords', op, onAnswer: resolve })
         return espera
       },
       audit,
@@ -2111,7 +2128,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         // El fallo NO se traga. Que un aviso no salga es exactamente lo que deja a dos
         // bóvedas con actas distintas sin que nadie se entere, y encontrarlo sin una línea
         // de log cuesta días (la última vez, tres).
-        try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, signature, acta }) }
+        // CALLADO (`quiet`): se encola igual, pero no toca el timbre push. Un aviso de que
+        // el perfil cambió puede esperar a que el aparato abra solo; timbrar por él hacía
+        // sonar el teléfono con «alguien pide tus claves» sin ningún pedido detrás.
+        // El timbre es para los pedidos (`notifyApprovers`), que sí esperan una mano.
+        try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, signature, acta }, { quiet: true }) }
         catch (e) { log(`[vault] could not notify ${pub.slice(0, 24)}… of "${ev}": ${e.message}`) }
       }
       for (const m of miembros) avisar(m.pub)
@@ -2300,11 +2321,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         // PÚBLICA Y PRIVADA VAN IGUAL (dueño, 2026-09-02: «la única diferencia es si se
         // despachan o no, son políticas; dales el mismo tratamiento de seguridad»). La
         // marca solo decide si se entrega sin aprobación.
+        const apply = async () => {
+          await checkAuthor(owner, key, sealed, caller)
+          await checkRecipients(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)
+        }
+        // Comprobado ANTES de dejarlo en espera: un sobre malo falla al guardarlo, no cinco
+        // minutos después en la pantalla de quien aprueba. `apply` lo repite al aprobar.
         await checkAuthor(owner, key, sealed, caller)
         await checkRecipients(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)
+        const pending = await holdWrite({ caller, ns, pub, keys: [key], apply })
+        if (pending) return { ok: true, key, pending }
+        await apply()
         return { ok: true, key }
       }
       // NO HAY OTRO CAMINO (dueño, 2026-09-02: «no dejes caminos viejos ni fallbacks; no hay
@@ -2345,16 +2375,58 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       }
       // Se comprueban TODAS antes de escribir NINGUNA: media carga aplicada es una
       // configuración que nadie quiso, y el servicio se reinicia con ella.
-      for (const it of items) {
-        await secrets.putSealed(owner, it.key, it.sealed, { by: who, public: !!it.public })
-        keys.push(it.key)
+      const apply = async () => {
+        for (const it of items) {
+          await checkAuthor(owner, it.key, it.sealed, caller)
+          await checkRecipients(owner, it.sealed.wraps, !!it.public)
+        }
+        for (const it of items) {
+          await secrets.putSealed(owner, it.key, it.sealed, { by: who, public: !!it.public })
+          keys.push(it.key)
+        }
+        audit('secret.setMany', { ns: ns || null, keys }); scheduleNotice(ns)
+        await settleDebts(owner)
       }
-      audit('secret.setMany', { ns: ns || null, keys }); scheduleNotice(ns)
-      await settleDebts(owner)
+      const pending = await holdWrite({ caller, ns, pub, keys: items.map((it) => it.key), apply })
+      if (pending) return { ok: true, keys: [], pending }
+      await apply()
       return { ok: true, keys }
     }
   }
 
+  /**
+   * GUARDAR VARIABLES TAMBIÉN PIDE PERMISO (dueño, 2026-09-23: «si el admin no es
+   * unattended, sí debería pedir permiso para almacenar variables»).
+   *
+   * Es el mismo permiso que ya decide si un aparato se lleva las claves solo: quien tiene
+   * `unattended` escribe sin preguntar; quien no, deja la escritura en espera y el teléfono
+   * decide. Un permiso, una regla, para leer y para escribir.
+   *
+   * No se espera DENTRO de la llamada: la consola corta a los 20 s y aprobar puede tardar
+   * cinco minutos. Se contesta «pendiente» en el acto, el sobre se queda en memoria (va
+   * sellado, la bóveda no lo abre) y se escribe al aprobar. Denegado o vencido, se tira.
+   *
+   * Devuelve el id del pedido si la escritura quedó en espera, o `null` si se puede hacer ya.
+   */
+  async function holdWrite ({ caller, ns, pub, keys, apply }) {
+    if (!needsApproval(caller, await refreshActa())) return null
+    // Quien llama ya comprobó el sobre; `apply` lo vuelve a comprobar al aprobar, porque el
+    // acta pudo cambiar en medio.
+    const target = ns || await deviceIdOf(pub).catch(() => null) || '?'
+    const pend = await awaitApproval({
+      device: caller, ns: target, kind: 'write', what: 'vars',
+      // LOS NOMBRES van en el contexto, que viaja SELLADO al que aprueba: el proxio no
+      // tiene por qué aprender cómo se llama la configuración de un servicio.
+      ctx: { keys },
+      onAnswer: async (ok) => {
+        if (!ok) return
+        await apply()
+        await notifyMembers('vars', { by: await deviceIdOf(caller).catch(() => null), keys, ns: ns || null })
+      }
+    })
+    return pend.id
+  }
+
   const admin = createAdminDesk({
     desk,
     deviceIdOf,