@dotrino/vaultd 0.127.0 → 0.128.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.128.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'
@@ -3617,12 +3617,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. Requests from devices without \`unattended\` will be refused until you enrol a device 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 }