@dotrino/vaultd 0.75.0 → 0.76.0

package/lib/src/service.js

@@ -421,7 +421,7 @@ export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device,
  * Renueva el cert automáticamente si está por vencer (best-effort).
  * @returns {Promise<Record<string,string>>}  secretos KEY→valor
  */
-export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, timeoutMs = 30000, onPending, approvalTimeoutMs = APPROVAL_TIMEOUT_MS } = {}) {
+export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, timeoutMs = 30000, onPending, onCert, approvalTimeoutMs = APPROVAL_TIMEOUT_MS } = {}) {
   let saved = null
   if (dir) saved = readServiceIdentity(dir)
   // Sin `dir`: la identidad viene entera por parámetros — es el caso de un agente
@@ -465,7 +465,15 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     recordar({ actaSeq: acta.seq })
   }
 
-    const renovar = typeof saved?.actaSeq === 'number' && typeof cert?.seq === 'number' && saved.actaSeq > cert.seq
+    // DOS MOTIVOS PARA PEDIR PAPEL NUEVO:
+    //   · el nuestro es del MODELO VIEJO (lleva `exp` y no `seq`). Ese hay que cambiarlo sí
+    //     o sí: se acepta por el repliegue de migración, pero muere en su fecha y con él el
+    //     servicio. Sin esta rama la migración no terminaba nunca — el disparador comparaba
+    //     `seq` contra `seq`, y un papel viejo no tiene ninguno, así que no saltaba jamás.
+    //   · o el acta que hemos visto va por delante del papel: el dueño cambió permisos.
+    const legado = !!cert && typeof cert.seq !== 'number'
+    const atrasado = typeof saved?.actaSeq === 'number' && typeof cert?.seq === 'number' && saved.actaSeq > cert.seq
+    const renovar = legado || atrasado
 
     // RENOVAR YA NO ES UNA TAREA DE CALENDARIO. El papel no vence: lo único que obliga a
     // pedir otro es que la bóveda diga que el nuestro se quedó atrás respecto del acta, y
@@ -481,6 +489,11 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
         if (res.type === MSG.RENEWED && res.cert?.sub === device.publickey) {
           cert = res.cert
           recordar({ cert })
+          // QUIEN NO PASA `dir` GUARDA ÉL. Un servicio que lleva su identidad en su propio
+          // archivo (`link.json`) y nos pasa el enlace a mano no tiene `saved`, así que
+          // `recordar` no escribe nada: sin esto renovaba en cada arranque y volvía a
+          // empezar, y su papel del modelo viejo no se cambiaba NUNCA.
+          try { onCert?.(cert) } catch (_) {}
         }
       } catch (_) { /* la renovación no bloquea el fetch */ }
     }
@@ -978,11 +991,11 @@ function fingerprintOf (secrets) {
  * servicio no opera hasta que esto resuelva — esa es la regla.
  * @returns {Promise<Record<string,string>>}
  */
-export async function waitForSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, retryMs = 5000, maxRetryMs = 60000, onRetry, onPending } = {}) {
+export async function waitForSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, retryMs = 5000, maxRetryMs = 60000, onRetry, onPending, onCert } = {}) {
   let delay = retryMs
   for (;;) {
     try {
-      return await fetchSecrets({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, onPending })
+      return await fetchSecrets({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, onPending, onCert })
     } catch (e) {
       // Lo NO transitorio no se arregla reintentando: falta de enrolamiento,
       // cert revocado/vencido o scope equivocado exigen re-emparejar → se corta.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.75.0",
+  "version": "0.76.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": {
@@ -20,7 +20,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "0.74.0",
+    "@dotrino/identity": "0.74.1",
     "@dotrino/passmanager": "^0.9.0",
     "@dotrino/proxy-client": "^0.13.1",
     "ws": "^8.18.0"

package/src/vault.js

@@ -615,14 +615,29 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!isFresh(p.data)) return staleReply(from)
     const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, ...(await contextoActa()), revoked: await revocationSet() })
     if (!chk.ok) return denyChain(from, chk, p, null)
-    // La lista de aparatos es el perfil: quién eres, cómo se llama cada máquina y qué puede.
-    // Este mostrador no preguntaba al acta, así que un aparato al que le quitaste `lee`
-    // seguía viendo tu inventario entero hasta que caducara su papel.
-    if (!await actaAllows(from, chk, SCOPE.READ, 'devices')) return
+    // DOS RESPUESTAS, PORQUE SON DOS PREGUNTAS DISTINTAS.
+    //
+    // Un SERVICIO pregunta aquí para enterarse de dos cosas suyas: si le revocaron el papel
+    // y cuál es el acta vigente. Eso no es tu inventario y no puede exigir `lee` — se lo
+    // exigí, y en producción dejó ciegos a los servicios (`rejected devices/acta` en la
+    // bitácora del VPS, dos veces, antes de que lo viera).
+    //
+    // La LISTA DE APARATOS sí es el perfil —cómo se llama cada máquina y qué puede— y esa
+    // sigue pidiendo `lee`. Antes no preguntaba nada, así que un aparato al que le quitaste
+    // el permiso seguía viéndolo todo hasta que su papel caducara.
+    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+    const puedeVerTodo = !!record && Acta.memberCanScope(record, chk.device, SCOPE.READ)
     const { issued, revoked } = await identity.listDelegations()
+    if (!puedeVerTodo) {
+      if (!record) {
+        audit('rejected', { what: 'devices', reason: 'sin-acta' })
+        return reply(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
+      }
+      audit('devices', { device: await deviceIdOf(chk.device).catch(() => null), solo: 'revocaciones' })
+      return reply(from, { type: MSG.DEVICES_RESULT, devices: [], revoked, acta: record })
+    }
     // El acta viaja con la lista: así cada dispositivo se entera de los cambios de
     // política (quién manda, quién puede qué) sin un canal aparte.
-    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
     // Si el dispositivo estuvo apagado y viene con un `seq` viejo, se le manda la CADENA
     // que falta (ventana de retención, §1.3) para que compruebe el encadenamiento en vez
     // de tragarse un salto a ciegas. Si se salió de la ventana, llega vacía y toca
@@ -673,7 +688,6 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // cert fresco (misma sub-clave y scope) sin QR ni aprobación — sigue siendo el
   // mismo dispositivo enrolado, solo extiende la ventana. Un cert vencido o
   // revocado NO puede renovarse (ahí sí toca re-emparejar con aprobación).
-  const RENEW_TTL_MS = 30 * 24 * 60 * 60 * 1000
   async function handleRenew (from, p) {
     if (!isFresh(p.data)) { audit('rejected', { what: 'renew', reason: 'stale' }); return staleReply(from) }
     const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, ...(await contextoActa()), revoked: await revocationSet() })
@@ -699,9 +713,22 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       audit('rejected', { what: 'renew', device: await deviceIdOf(p.cert.sub), reason: 'not-a-member' })
       return reply(from, { type: MSG.ERROR, error: 'unauthorized: the record no longer lists this device' })
     }
-    const { cert } = await identity.signDelegation(p.cert.sub, scope, { ttlMs: RENEW_TTL_MS, label: prev?.label || '' })
-    audit('renew', { device: await deviceIdOf(p.cert.sub), label: prev?.label || '', scope })
-    log(`[vault] cert renewed for ${await deviceIdOf(p.cert.sub)} (30 days)`)
+    // RENOVAR NO RETIRA EL PAPEL ANTERIOR (`supersede: false`), y esto costó dos servicios.
+    //
+    // Retirarlo al emitir parece limpio —un aparato, un papel— pero convierte cualquier
+    // renovación que falle DESPUÉS de emitirse en una expulsión permanente: la máquina se
+    // queda con el papel viejo, que acaba de quedar revocado, y ya no puede ni pedir otro.
+    // Pasó dos veces en la migración del VPS (el registro de selladores y el bot social):
+    // el papel nuevo salió, la respuesta no llegó a guardarse, y al reintentar la bóveda
+    // contestaba `unauthorized: revoked`. Re-emparejar a mano, con TTY, por una renovación.
+    //
+    // Que convivan dos papeles del mismo aparato ya no es el problema que era: ninguno
+    // vence, pero lo que pueden hacer lo decide el ACTA en cada mostrador, así que el
+    // viejo no autoriza nada que el nuevo no autorice. Y quitar el aparato de verdad sigue
+    // siendo `revokeDevice`, que los retira TODOS de una vez.
+    const { cert } = await identity.signDelegation(p.cert.sub, scope, { label: prev?.label || '', supersede: false })
+    audit('renew', { device: await deviceIdOf(p.cert.sub), label: prev?.label || '', scope, seq: cert.seq })
+    log(`[vault] cert renewed for ${await deviceIdOf(p.cert.sub)} · record #${cert.seq}`)
     // El acta viaja con el papel: sin ella quien lo recibe no puede comprobar que lo firmó
     // una selladora del perfil, que es lo que sustituyó a «lo firmó la maestra».
     reply(from, { type: MSG.RENEWED, cert, acta: record })