@dotrino/vaultd 0.108.0 → 0.109.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.108.0",
+  "version": "0.109.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": {
@@ -22,7 +22,7 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "0.79.0",
+    "@dotrino/identity": "0.81.0",
     "@dotrino/passmanager": "^0.10.1",
     "@dotrino/proxy-client": "0.15.0",
     "@dotrino/roadmap": "0.2.0",

package/src/ctl.js

@@ -598,6 +598,11 @@ async function cmdMembers () {
     // QUÉ CORRE, y si cuadra con esta bóveda (CONVENCIONES §14). Sin esto una
     // incompatibilidad de versiones se ve como que ese aparato «no responde», que es el
     // fallo más caro que ha tenido el ecosistema. No bloquea nada: se enseña.
+    // RENUNCIAS SIN SELLAR. Ya no los tiene —la bóveda no se los reconoce— pero el acta
+    // que se lee arriba todavía los nombra, así que hay que decirlo aquí o la lista miente.
+    if (m.renounced?.length) {
+      console.log('      %s↓ renunció a %s (pendiente de sellar: abre la bóveda)%s', R, m.renounced.join(', '), Z)
+    }
     if (m.running) {
       const v = `${m.running.product} ${m.running.version}`
       if (m.running.compatible) console.log('      %scorre %s%s', D, v, Z)

package/src/subacta.js

@@ -0,0 +1,102 @@
+/**
+ * subacta.js — LO DECIDIDO QUE TODAVÍA NO SELLÓ EL ACTA.
+ *
+ * Idea del dueño (2026-09-04): *«una subacta efímera que se comparte entre todos los
+ * dispositivos y puede tener decisiones a futuro que se aceptan cuando el acta se abre»*.
+ *
+ * EL AGUJERO QUE TAPA. Sellar el acta es de la maestra, y con el perfil cerrado la maestra
+ * no está. Así que una renuncia —«me quito estos permisos»— no surtía NINGÚN efecto hasta
+ * que alguien iba a la máquina y tecleaba la contraseña. Justo el caso que la renuncia
+ * existe para cubrir: te roban el teléfono, renuncias desde él, y el ladrón sigue siendo
+ * admin hasta que llegues. El pilar ya tenía la pieza (`extraRenounces`) y no la pasaba
+ * nadie.
+ *
+ * LA REGLA DURA, y es la que sostiene todo lo demás:
+ *
+ *     LA SUBACTA SOLO PUEDE QUITAR, NUNCA DAR.
+ *
+ * De ahí salen las tres propiedades que la hacen segura sin maestra:
+ *
+ *   · **Se autentica sola.** Cada entrada la firma EL MIEMBRO AL QUE AFECTA. No hace falta
+ *     sellador, así que no hay una segunda autoridad al lado del acta.
+ *   · **Una entrada falsa o repetida cuesta disponibilidad, no autoridad.** Lo peor que
+ *     consigue quien cuele una es quitarle permisos a alguien: molesto y reversible.
+ *   · **Nadie puede quitarle nada a otro.** Si valiera la firma de cualquiera, un servicio
+ *     con `secrets` en un VPS alquilado podría dejar sin `admin` a tu teléfono.
+ *
+ * Y por eso el catálogo de operaciones es una LISTA BLANCA de una sola: `renounce`. La
+ * lista es la regla — si algún día entra otra, tiene que quitar y venir firmada por su
+ * sujeto, y se escribe aquí a propósito, no se cuela.
+ *
+ * JUNTAR DOS ES UNIR. Dos entradas nunca se contradicen porque las dos quitan, así que no
+ * hay conflictos ni hace falta un `seq`. Y **solo salen al absorberse** en el acta: nunca
+ * por reloj, o un aparato apagado perdería justo la que lo protege.
+ */
+import path from 'node:path'
+import { verifyRenounce } from '@dotrino/identity/acta'
+import { readJson, writeJson } from './paths.js'
+
+/** Las operaciones que caben. La lista ES la regla: todas quitan, todas las firma su sujeto. */
+export const OPS = Object.freeze(['renounce'])
+
+/** Identidad de una entrada, para no guardar dos veces la misma. */
+const idOf = (e) => `${e.op}|${e.member}|${[...(e.caps || [])].sort().join(',')}|${e.ts}`
+
+/**
+ * ¿Es una entrada que se puede aceptar? Comprueba la FORMA y la FIRMA; que quite es
+ * estructural (el catálogo) y no una comprobación aparte.
+ */
+export async function isAcceptable (e) {
+  if (!e || !OPS.includes(e.op)) return false
+  if (e.op === 'renounce') return verifyRenounce(e).catch(() => false)
+  return false
+}
+
+/**
+ * La subacta de un perfil. Vive en su directorio y va cifrada en reposo como todo lo
+ * demás: sus entradas dicen qué aparatos se quedaron sin qué, y eso es material de la
+ * cuenta aunque no sea un secreto.
+ */
+export function openSubacta (dir, atRest) {
+  const file = path.join(dir, 'subacta.json')
+  let data = readJson(file, null, atRest) || { v: 1, entries: [] }
+  const guardar = () => writeJson(file, data, atRest)
+
+  return {
+    /** Las entradas vigentes, tal cual se le pasan a `memberCan` y compañía. */
+    entries () { return [...data.entries] },
+    get count () { return data.entries.length },
+
+    /** Las de UN miembro. Es lo que se mira al decidir sobre él. */
+    forMember (pub) { return data.entries.filter((e) => e.member === pub) },
+
+    /**
+     * Acepta una entrada. Devuelve `{ok, reason}` — y un `false` aquí no es un fallo del
+     * que la manda: puede ser que ya la tuviéramos, que es el caso normal cuando dos
+     * aparatos se cuentan lo mismo.
+     */
+    async add (e) {
+      if (!(await isAcceptable(e))) return { ok: false, reason: 'no-aceptable' }
+      const id = idOf(e)
+      if (data.entries.some((x) => idOf(x) === id)) return { ok: false, reason: 'ya-estaba' }
+      data.entries = [...data.entries, e]
+      guardar()
+      return { ok: true, reason: 'nueva' }
+    },
+
+    /**
+     * SACA TODO para absorberlo en el acta, y vacía. Se llama con la bóveda ABIERTA, que es
+     * la única que puede sellar. Vaciar aquí y fallar el sellado perdería la entrada, así
+     * que quien llama tiene que absorber primero y vaciar después (`clear`).
+     */
+    drain () { return [...data.entries] },
+
+    /** Vacía lo ya absorbido. Se le pasa lo que se absorbió, no «todo»: mientras se sella
+     *  puede haber entrado una nueva, y tirarla sería perder una renuncia sin aplicar. */
+    clear (absorbidas) {
+      const ids = new Set(absorbidas.map(idOf))
+      data.entries = data.entries.filter((e) => !ids.has(idOf(e)))
+      guardar()
+    }
+  }
+}

package/src/vault.js

@@ -15,7 +15,7 @@ import nodeCrypto from 'node:crypto'
 import path from 'node:path'
 import { Identity } from '@dotrino/identity/node'
 import { verifyChain as verifyChainRaw, pubkeyId, verifyDeviceSig } from '@dotrino/identity/capabilities'
-import * as Acta from '@dotrino/identity/acta'
+import * as ActaPilar from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS } from '../lib/src/enroll.js'
 import { createAdminDesk, authorBody } from '../lib/src/admin.js'
 import { shouldNotifyRevoked } from '../lib/src/revocation.js'
@@ -27,6 +27,7 @@ import { assertKeyOwnsDir } from './keyowner.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
 import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER } from './secretsStore.js'
+import { openSubacta } from './subacta.js'
 import { VERSION } from './version.js'
 import { declare as compatDeclare, check as compatCheck, annotate as compatAnnotate } from '@dotrino/compat'
 import { loadManifest, brokenOf } from '@dotrino/roadmap'
@@ -372,6 +373,55 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   /** El dictamen de un aparato, para enseñarlo o para pegárselo a un error. */
   const versionDe = (pub) => versiones.get(pub) || null
 
+  // ----- LA SUBACTA: lo decidido que todavía no selló el acta (`src/subacta.js`) -----
+  //
+  // Sellar es de la maestra, así que con el perfil CERRADO una renuncia no surtía ningún
+  // efecto: el aparato conservaba todos sus permisos hasta que alguien fuera a la máquina
+  // a teclear la contraseña. Justo el caso que la renuncia existe para cubrir.
+  //
+  // Se honra ya, sin sellar, y es seguro porque una entrada de la subacta SOLO PUEDE
+  // QUITAR: no concede nada a nadie, y va firmada por el miembro al que afecta.
+  const subacta = openSubacta(dir, atRestFor(dir))
+
+  /**
+   * EL ACTA, LEÍDA CON LA SUBACTA EN LA MANO.
+   *
+   * Envuelve al pilar en UN sitio en vez de pasar la lista en los diecisiete mostradores:
+   * una comprobación repetida diecisiete veces son dieciséis sitios donde olvidarla, y
+   * olvidarla aquí significa atender a un aparato que ya renunció.
+   *
+   * Solo se tocan las cinco que DECIDEN. El resto del pilar pasa tal cual.
+   */
+  const Acta = {
+    ...ActaPilar,
+    memberCan: (acta, pub, cap) => ActaPilar.memberCan(acta, pub, cap, subacta.forMember(pub)),
+    memberCanScope: (acta, pub, scope) => ActaPilar.memberCanScope(acta, pub, scope, subacta.forMember(pub)),
+    memberCanReadSecrets: (acta, pub, ns) => ActaPilar.memberCanReadSecrets(acta, pub, ns, subacta.forMember(pub)),
+    memberCanSign: (acta, pub, ns = null) => ActaPilar.memberCanSign(acta, pub, ns, subacta.forMember(pub)),
+    memberScopes: (acta, pub) => ActaPilar.memberScopes(acta, pub, subacta.forMember(pub)),
+    effectiveCaps: (acta, pub) => ActaPilar.effectiveCaps(acta, pub, subacta.forMember(pub))
+  }
+
+  /**
+   * ABSORBER lo pendiente en el acta. Solo con la bóveda abierta, que es la única que
+   * sella. Se vacía DESPUÉS y solo lo absorbido: mientras se sella puede entrar una nueva,
+   * y tirarla sería perder una renuncia sin aplicar.
+   */
+  async function absorberSubacta (motivo = 'unlock') {
+    const pendientes = subacta.drain()
+    if (!pendientes.length) return 0
+    const hechas = []
+    for (const e of pendientes) {
+      try { await identity.absorbRenounce(e); hechas.push(e) }
+      catch (err) { log(`[vault] ${motivo}: could not absorb a pending renounce: ${err.message}`) }
+    }
+    if (hechas.length) {
+      subacta.clear(hechas)
+      log(`[vault] ${motivo}: ${hechas.length} pending renounce(s) absorbed into the record`)
+    }
+    return hechas.length
+  }
+
   /**
    * LA VERSIÓN SE APUNTA DONDE YA SE COMPRUEBA LA FIRMA, y por eso esto envuelve a
    * `verifyChain` en vez de mirar el envoltorio del mensaje: `data` va firmado, así que
@@ -958,7 +1008,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce,
       running: x.sub ? versionDe(x.sub) : null
     })))
-    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain, vault: MI_VERSION }))
+    // LA SUBACTA VIAJA CON EL ACTA. Es la mitad de «se comparte entre todos los
+    // dispositivos»: sin esto, una renuncia sin sellar solo la respeta esta máquina.
+    // Cada entrada va firmada por su sujeto, así que quien la recibe la verifica sola.
+    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain, vault: MI_VERSION, subacta: subacta.entries() }))
   }
 
   /**
@@ -2013,12 +2066,32 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return reply(from, { type: MSG.ERROR, error: 'renounce: that member no longer holds any of those capabilities' })
     }
     try {
-      const r = await identity.absorbRenounce(record)
+      // A LA SUBACTA PRIMERO, y aquí está el arreglo: desde este momento surte efecto,
+      // esté la bóveda abierta o cerrada. Antes se intentaba sellar directamente, sellar es
+      // de la maestra, y con el perfil cerrado la renuncia se perdía con un error — en el
+      // único momento en que de verdad hace falta.
+      const guardada = await subacta.add(record)
+      if (!guardada.ok && guardada.reason === 'no-aceptable') {
+        audit('rejected', { what: 'renounce', reason: 'no-aceptable' })
+        return reply(from, { type: MSG.ERROR, error: 'renounce: the entry is not one this vault accepts' })
+      }
       const device = await deviceIdOf(record.member).catch(() => null)
       audit('renounce', { device, caps: record.caps })
-      log(`[vault] ${device} renounced: ${(record.caps || []).join(', ')}`)
+      log(`[vault] ${device} renounced: ${(record.caps || []).join(', ')} — in effect now`)
+
+      // Y SE SELLA SI SE PUEDE. Con la bóveda abierta entra en el acta y lo respeta toda la
+      // cuenta; cerrada se queda pendiente y lo absorbe el `unlock`. Las dos ramas son
+      // correctas, así que el fallo al sellar NO es un error para quien renunció.
+      let seq = null
+      try {
+        const r = await identity.absorbRenounce(record)
+        subacta.clear([record])
+        seq = r?.seq ?? null
+      } catch (e) {
+        log(`[vault] the renounce stays pending until the vault is opened (${e.message})`)
+      }
       await notifyMembers('renounce', { deviceId: device, caps: record.caps })
-      reply(from, { type: MSG.RENOUNCE_RESULT, ok: true, seq: r?.seq ?? null })
+      reply(from, { type: MSG.RENOUNCE_RESULT, ok: true, seq, pending: seq === null })
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: 'renounce: ' + e.message })
     }
@@ -3019,6 +3092,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // aquí donde puede estrenar su llave de comunicación (ver `ensureCommKeyInActa`).
       // Si falla, no se arrastra: abrir el perfil no puede depender de esto.
       if (r?.locked === false) { try { await ensureCommKeyInActa() } catch (_) {} }
+      // Y ABSORBER LO PENDIENTE. La subacta ya lo estaba honrando con el perfil cerrado —de
+      // eso vive—, pero mientras siga ahí solo lo sabe esta máquina: al sellarlo, entra en
+      // el acta y lo respeta toda la cuenta. Si falla no se arrastra: abrir el perfil no
+      // puede depender de esto, y lo pendiente sigue surtiendo efecto igual.
+      if (r?.locked === false) { try { await absorberSubacta('unlock') } catch (_) {} }
       return { locked: r?.locked !== false }
     },
     // Forzar un empujón: lo usa `replica push` de la CLI y el smoke, para no depender
@@ -3117,7 +3195,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return {
         ...r,
         vault: MI_VERSION,
-        members: (r?.members || []).map((m) => ({ ...m, running: versionDe(m.pub) }))
+        // Y LO QUE RENUNCIÓ Y NO SE HA SELLADO. Ya surte efecto —de eso vive la subacta—
+        // pero si no se ve, el dueño mira la lista, lee los permisos del acta y cree que
+        // ese aparato los tiene. Un freno que no se explica es otro silencio.
+        members: (r?.members || []).map((m) => ({
+          ...m,
+          running: versionDe(m.pub),
+          renounced: subacta.forMember(m.pub).flatMap((e) => e.caps || [])
+        }))
       }
     },
     // Los namespaces que quedaron a deber una rotación (se fue un miembro y no se pudo