@dotrino/vaultd 0.127.0 → 0.129.0

package/lib/src/service.js

@@ -313,7 +313,7 @@ export async function sayHello (client, qr) {
   const hello = await new Promise((resolve, reject) => {
     const off = client.on('message', (_f, p) => {
       if (p?.type === MSG.HELLO_OK) { finish(); verifyHello(p, qr.sn).then(resolve, reject) }
-      else if (p?.type === MSG.ERROR) { finish(); reject(new Error(p.error)) }
+      else if (p?.type === MSG.ERROR) { finish(); reject(vaultError(p)) }
     })
     const t = setTimeout(() => { finish(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
     const finish = () => { off(); clearTimeout(t) }
@@ -387,7 +387,7 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
         if (p.type === MSG.ENROLL_CHALLENGE) {
           const show = onCode || (({ deviceId, code }) => console.log(`[vault] device ${deviceId} · approve it on the vault:  dotrino-vault approve ${code}`))
           show({ deviceId, code })
-        } else if (p.type === MSG.ENROLLED) { cleanup(); resolve(p) } else if (p.type === MSG.ERROR) { cleanup(); reject(new Error(p.error)) }
+        } else if (p.type === MSG.ENROLLED) { cleanup(); resolve(p) } else if (p.type === MSG.ERROR) { cleanup(); reject(vaultError(p)) }
       })
       const t = setTimeout(() => { cleanup(); reject(new Error('timeout waiting for approval on the vault')) }, approveTimeoutMs)
       const cleanup = () => { off(); clearTimeout(t) }
@@ -507,7 +507,7 @@ export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device,
     const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs)
     client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
     const res = await pending
-    if (res.type === MSG.ERROR) throw new Error(res.error)
+    if (res.type === MSG.ERROR) throw vaultError(res)
     return { encPub, created, ok: true }
   } finally { client.close() }
 }
@@ -656,7 +656,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
       try { res = await pending; break } catch (e) { ultimo = e }
     }
     if (!res) throw ultimo || new Error('nobody answered: neither the vault nor any replica')
-    if (res.type === MSG.ERROR) throw new Error(res.error)
+    if (res.type === MSG.ERROR) throw vaultError(res)
 
     // CAJÓN CON APROBACIÓN: la bóveda contesta «pendiente» (firmado) y la respuesta de
     // verdad llega cuando el aparato que aprueba firme — por esta misma conexión, que
@@ -668,7 +668,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
       const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : approvalTimeoutMs
       res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.result') || p.type === MSG.ERROR, Math.min(until, approvalTimeoutMs))
         .catch((e) => { throw new Error(/timeout/.test(e.message) ? 'approval: nobody approved the request in time' : e.message) })
-      if (res.type === MSG.ERROR) throw new Error(res.error)
+      if (res.type === MSG.ERROR) throw vaultError(res)
     }
 
     // AUTENTICIDAD: la firma NO es de la maestra. El acta dice qué llave vale para esto
@@ -1244,9 +1244,23 @@ function fingerprintOf (secrets) {
  */
 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
+  'plaintext-var', // el valor está en claro en la bóveda: hay que volver a escribirlo
+  // NADIE EN EL ACTA PUEDE APROBAR: reintentar no lo arregla, y callarlo es lo peor. Pasó el
+  // 2026-09-24: la limpieza de aparatos muertos se llevó al único teléfono con `aprueba`, y
+  // `dotrino-env` se quedó reintentando cada minuto sin decir nada mientras la bóveda
+  // contestaba exactamente qué había que hacer.
+  'no-approver'
 ])
 
+/**
+ * Un `vault.error` como Error CON SU `code`. Antes se construía con el texto a secas, y el
+ * código que la bóveda manda para distinguir los casos se perdía justo aquí — así que
+ * `isFinal` no podía reconocer ninguno por `code` y todo se reintentaba.
+ */
+function vaultError (p) {
+  return Object.assign(new Error(p?.error || 'vault error'), { code: p?.code || null })
+}
+
 export function isFinal (e) {
   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 || '')

package/package.json

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

@@ -185,4 +185,20 @@ export function createGrants ({ now = Date.now, ttlMs = GRANT_TTL_MS } = {}) {
   return api
 }
 
-export default { createApprovals, createGrants, PENDING_TTL_MS, UPDATE_TTL_MS, GRANT_TTL_MS }
+/**
+ * ¿SE LLEVÓ UNA LIMPIEZA AL ÚLTIMO QUE APROBABA? Devuelve los aprobadores que se fueron si
+ * antes había alguno y ahora no queda ninguno; si no, una lista vacía.
+ *
+ * Una cuenta SIN aprobadores puede ser legítima (todo desatendido, se actualiza sola), así
+ * que el aviso no es «no hay aprobadores»: es «LOS HABÍA y acabas de perder el último».
+ *
+ * @param {string[]} before  llaves con `approve` antes
+ * @param {string[]} after   llaves con `approve` después
+ * @param {string[]} removed llaves que salieron del acta
+ */
+export function lastApproverGone (before, after, removed) {
+  if (!before.length || after.length) return []
+  return removed.filter((pub) => before.includes(pub))
+}
+
+export default { createApprovals, createGrants, lastApproverGone, PENDING_TTL_MS, UPDATE_TTL_MS, GRANT_TTL_MS }

package/src/vault.js

@@ -37,7 +37,7 @@ import { loadManifest, brokenOf } from '@dotrino/roadmap'
 // espera reventaba con un ReferenceError y la aprobación del mostrador de contraseñas no
 // llegaba a existir. Solo se veía por ese camino —el único que lo usa—, y no había prueba
 // que lo recorriera hasta que la hubo (dotrino-test, smoke:demonio, 2026-08-30).
-import { createApprovals, createGrants, PENDING_TTL_MS, GRANT_TTL_MS } from './approvals.js'
+import { createApprovals, createGrants, lastApproverGone, PENDING_TTL_MS, GRANT_TTL_MS } from './approvals.js'
 import { readProcContext, sanitizeContext, commandFingerprint, commandLine } from '../lib/src/proc.js'
 import { makeContentKey, encryptWithCek, wrapForMember } from '@dotrino/identity/content'
 import { makeSealer } from './sealer.js'
@@ -152,6 +152,12 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    */
   function needsApproval (pub, record) {
     if (!record) return true          // sin acta no se decide que sí: se pide permiso
+    // SIN NADIE QUE APRUEBE, NO SE NECESITA APROBACIÓN (dueño, 2026-09-24: «la regla es, si
+    // no hay aprobador no se necesita aprobación»). Es la misma que ya seguía la
+    // actualización automática: esperar un sí que nadie puede dar solo deja al servicio
+    // colgado. Aquí se decide para las tres puertas —entregar claves, contraseñas y guardar
+    // variables— y por eso no hay un «nadie aprueba» aparte en ninguna de ellas.
+    if (!record.members?.some((m) => Acta.memberCan(record, m.pub, 'approve'))) return false
     return !Acta.memberCan(record, pub, 'unattended')
   }
 
@@ -1460,6 +1466,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // hace la BÓVEDA (`bundleFor({ publicOnly })`), no el que pide: si mandáramos todo y el
     // cliente eligiera, pedir «solo públicas» sería la manera de saltarse la aprobación.
     const publicOnly = p.data?.publicOnly === true
+    // Entregar SIN aprobación porque no hay quien apruebe es la regla (ver `needsApproval`),
+    // pero se deja dicho: quien mire el log tiene que poder ver por qué no sonó el teléfono.
+    if (!publicOnly && record && !Acta.memberCan(record, chk.device, 'unattended') &&
+        !record.members?.some((m) => Acta.memberCan(record, m.pub, 'approve'))) {
+      audit('secrets.no-approver', { device: await deviceIdOf(chk.device).catch(() => null), ns })
+      log(`[vault] ${ns}: served ${await deviceIdOf(chk.device).catch(() => '????-????')} without approval — nobody in the record can approve`)
+    }
     if (!publicOnly && needsApproval(chk.device, record)) {
       const deviceId = await deviceIdOf(chk.device).catch(() => null)
       const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
@@ -1484,27 +1497,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
           return reply(from, { type: MSG.ERROR, error: 'secrets: invalid ek' })
         }
       }
-      // NADIE PUEDE APROBAR = SE DICE AHORA, no se deja esperando cinco minutos.
-      //
-      // La bóveda ya lo sabía —lo escribía en su propio log, «rang 0 approver(s)»— y aun
-      // así contestaba «pendiente» y dejaba al otro aguardando a algo que no podía pasar.
-      // Eso es un fallo ruidoso convertido en uno mudo, que es exactamente lo que la norma
-      // prohíbe (CLAUDE.md, «nada de repliegues»), y encima el que sabe es el ÚNICO que
-      // puede enterar al otro (CONVENCIONES §14): el que pide no tiene el acta, así que no
-      // hay forma de que lo averigüe por su cuenta.
-      //
-      // Lo pidió el dueño el 2026-09-05, después de mirar un `dotrino-env check` que parecía
-      // colgado y era esto.
-      const quienAprueba = (record?.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve'))
-      if (!quienAprueba.length) {
-        audit('rejected', { what: 'secrets', ns, reason: 'sin-aprobador' })
-        log(`[vault] ${ns}: refused ${deviceId || '????-????'} — nobody in the record can approve`)
-        return reply(from, {
-          type: MSG.ERROR,
-          code: 'no-approver',
-          error: `approval: nobody in the record can approve — grant it with \`dotrino-vault caps <ID> +aprueba\`, or let this service run unattended with \`dotrino-vault caps ${deviceId || '<ID>'} +desatendido\``
-        })
-      }
+      // (Aquí se rechazaba con `no-approver` cuando nadie podía aprobar. Desde 2026-09-24 ese
+      // caso ya no llega: sin aprobadores, `needsApproval` dice que no hace falta aprobación.)
       // `from` SE GUARDA: la respuesta llega más tarde —cuando alguien apruebe— y tiene que
       // volver POR DONDE VINO. Si la pregunta entró por el mostrador local, mandarla por el
       // proxio la deja en el vacío: quien preguntó está escuchando en el socket, no ahí.
@@ -3617,12 +3611,27 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // Si falla no se arrastra —abrir no depende de esto—, pero se dice.
       if (r?.locked === false) {
         try {
+          const antes = await refreshActa()
+          const aprobaban = (antes?.members || []).filter((m) => Acta.memberCan(antes, m.pub, 'approve')).map((m) => m.pub)
           const { removed = [], seq } = await identity.pruneExpiredDevices?.() || {}
           for (const d of removed) {
             const id = await deviceIdOf(d.pub).catch(() => null)
             audit('pruned', { device: id, label: d.label || '', reason: 'expired', seq })
             log(`[vault] unlock: removed ${id || '????-????'} ${d.label ? `(${d.label}) ` : ''}from the record: its certificate expired and cannot be renewed · record #${seq}`)
           }
+          // ¿SE LLEVÓ AL ÚLTIMO QUE APROBABA? Entonces se dice ALTO. Quitarlo es correcto —con
+          // el papel muerto no podía firmar ninguna aprobación, estuviera o no en el acta—,
+          // pero desde ese momento todo pedido de un aparato sin `unattended` se rechaza, y
+          // el 2026-09-22 eso pasó en silencio: el teléfono se fue y nadie lo supo en dos días.
+          const despues = await refreshActa()
+          const quedan = (despues?.members || []).filter((m) => Acta.memberCan(despues, m.pub, 'approve')).map((m) => m.pub)
+          const idosPub = lastApproverGone(aprobaban, quedan, removed.map((d) => d.pub))
+          const idos = removed.filter((d) => idosPub.includes(d.pub))
+          if (idos.length) {
+            const quienes = (await Promise.all(idos.map(async (d) => `${await deviceIdOf(d.pub).catch(() => '????-????')}${d.label ? ` (${d.label})` : ''}`))).join(', ')
+            audit('no-approver', { removed: idos.length, seq })
+            log(`[vault] WARNING: nobody in the record can approve any more — ${quienes} was the last. From now on every device gets its keys WITHOUT approval, until you enrol one and grant it \`dotrino-vault caps <ID> +aprueba\``)
+          }
         } catch (e) { log(`[vault] unlock: could not remove expired devices: ${e.message}`) }
       }
       return { locked: r?.locked !== false }