@dotrino/vaultd 0.12.0 → 0.14.0

package/src/vault.js

@@ -15,7 +15,8 @@ import path from 'node:path'
 import { Identity } from '@dotrino/identity/node'
 import { verifyChain, pubkeyId } from '@dotrino/identity/capabilities'
 import * as Acta from '@dotrino/identity/acta'
-import { createEnrollDesk, deviceIdOf } from '../lib/src/enroll.js'
+import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS } from '../lib/src/enroll.js'
+import { createAdminDesk } from '../lib/src/admin.js'
 import { createTransport, masterPubkeyOf } from './transport.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
@@ -37,14 +38,16 @@ import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
  */
 export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false, forAdoption = false, onAdopted } = {}) {
   ensureDir(dir)
-  // CIFRADO EN REPOSO ligado a esta máquina: `identity.json` deja de estar en claro, así
-  // que copiarlo a otro equipo no sirve de nada. No protege contra quien ya tiene ESTA
+  // CIFRADO EN REPOSO ligado a esta máquina: ningún archivo del dir queda en claro, así
+  // que copiarlos a otro equipo no sirve de nada. La identidad se migra AQUÍ (verificando
+  // antes de reemplazar); el resto —`vault.json`, `threads.json`, `secrets.json`— lo hace
+  // su propio store al abrirse. No protege contra quien ya tiene ESTA
   // máquina (puede leer el mismo material); es subir el listón, no una imposibilidad.
   // La migración verifica antes de reemplazar: si algo falla, el original queda intacto.
   try {
     const r = migrateFile(path.join(dir, 'identity.json'), machineKey(dir))
-    if (r === 'migrado') log('[vault] identidad cifrada en reposo (ligada a esta máquina)')
-  } catch (e) { log('[vault] no se pudo cifrar la identidad en reposo:', e.message) }
+    if (r === 'migrado') log('[vault] identity encrypted at rest (bound to this machine)')
+  } catch (e) { log('[vault] could not encrypt the identity at rest:', e.message) }
   const identity = await Identity.connect({ dir, atRest: atRestFor(dir) })
   if (!identity.me?.publickey) await identity.setMyNickname('')
   // CAMINO A: este perfil nació para adoptar la cuenta de un aparato. La identidad se crea
@@ -52,7 +55,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // acepte cambiar su acta recién nacida por la que traiga el dispositivo. Sin la marca,
   // adoptar sería pisar una cuenta con datos y se rechaza — que es lo correcto por defecto.
   if (forAdoption) {
-    try { await identity.prepareForAdoption() } catch (e) { log('[vault] no se pudo preparar el perfil para adoptar:', e.message) }
+    try { await identity.prepareForAdoption() } catch (e) { log('[vault] could not prepare the profile for adoption:', e.message) }
   }
 
   const store = openStore(dir)
@@ -69,7 +72,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
 
   const reply = (to, obj) => {
-    try { client.send(to, obj) } catch (e) { log('[vault] no se pudo responder:', e.message) }
+    try { client.send(to, obj) } catch (e) { log('[vault] could not reply:', e.message) }
   }
 
   // FRESCURA anti-replay: toda petición firmada debe traer `data.ts` dentro de una
@@ -94,7 +97,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   const FRESH_WINDOW_MS = 5 * 60 * 1000
   const isFresh = (d) => typeof d?.ts === 'number' && Math.abs(Date.now() - d.ts) <= FRESH_WINDOW_MS
-  const staleReply = (from) => reply(from, { type: MSG.ERROR, error: 'petición vencida: ts fuera de la ventana ±5 min (posible replay, o el reloj del dispositivo está desfasado)' })
+  const staleReply = (from) => reply(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
 
   // --- ENROLL / aprobación / revocación: núcleo COMPARTIDO (lib/src/enroll.js) ---
   // El mismo módulo lo usan «este dispositivo es bóveda» (@dotrino/vault) y la copia
@@ -142,9 +145,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       data: p.data, signature: p.signature, cert: p.cert,
       expectedScope: SCOPE.SIGN, trustedIssuer: master, revoked: await revocationSet()
     })
-    if (!chk.ok) { audit('rejected', { what: 'sign', reason: chk.reason }); return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason }) }
+    if (!chk.ok) { audit('rejected', { what: 'sign', reason: chk.reason }); return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason }) }
     const toSign = p.data?.payload
-    if (toSign == null) return reply(from, { type: MSG.ERROR, error: 'data.payload requerido' })
+    if (toSign == null) return reply(from, { type: MSG.ERROR, error: 'data.payload required' })
     const { signature, publickey } = await identity.signData(toSign)
     audit('sign', { device: await deviceIdOf(chk.device) })
     reply(from, { type: MSG.SIGNED, signature, publickey, device: chk.device })
@@ -156,7 +159,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       data: p.data, signature: p.signature, cert: p.cert,
       expectedScope: SCOPE.READ, trustedIssuer: master, revoked: await revocationSet()
     })
-    if (!chk.ok) return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason })
+    if (!chk.ok) return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
     const id = p.data?.id || 'root'
     reply(from, { type: MSG.DATA, id, node: store.getNode(id) })
   }
@@ -165,8 +168,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // aceptan vault:store o vault:read. Cada op va firmada por D + cert (cadena D←maestra).
   async function handleStore (from, p) {
     const d = p.data
-    if (!d || typeof d.method !== 'string' || !threads.methods[d.method]) {
-      return reply(from, { type: MSG.ERROR, error: 'store: método inválido' })
+    // `Object.hasOwn` y no `threads.methods[d.method]`: con la comprobación laxa,
+    // `method: 'toString'` (o cualquier miembro heredado de Object) pasaba el filtro y
+    // se llamaba como si fuera del store.
+    if (!d || typeof d.method !== 'string' || !Object.hasOwn(threads.methods, d.method)) {
+      return reply(from, { type: MSG.ERROR, error: 'store: invalid method' })
     }
     if (!isFresh(d)) return staleReply(from)
     // CANDADO del perfil (contraseña opcional): solo frena EDITAR el perfil. Un
@@ -174,14 +180,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // lo que no puede es reescribir quién sos mientras el perfil está bloqueado.
     if (PROFILE_EDIT_METHODS.has(d.method) && isLocked()) {
       audit('rejected', { what: 'store', method: d.method, reason: 'locked' })
-      return reply(from, { type: MSG.ERROR, error: 'perfil bloqueado: desbloquéalo en el PC del vault (dotrino-vault unlock) para editarlo' })
+      return reply(from, { type: MSG.ERROR, error: 'profile locked: unlock it on the vault machine (dotrino-vault unlock) to edit it' })
     }
     const revoked = await revocationSet()
     let chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.STORE, trustedIssuer: master, revoked })
     if (!chk.ok && STORE_READ_METHODS.has(d.method)) {
       chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.READ, trustedIssuer: master, revoked })
     }
-    if (!chk.ok) return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason })
+    if (!chk.ok) return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
     try {
       // CIFRADO de punta a punta con la clave de contenido del perfil: el proxy transporta
       // pero no ve nada de lo que el usuario guarda. Si el dispositivo mandó `enc`, se abre
@@ -190,10 +196,17 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       let cek = null
       if (d.enc) {
         cek = await identity.contentKey?.().catch(() => null)
-        if (!cek) return reply(from, { type: MSG.ERROR, error: 'store: esta bóveda no tiene la clave de contenido del perfil' })
+        if (!cek) return reply(from, { type: MSG.ERROR, error: 'store: this vault does not hold the profile content key' })
         args = JSON.parse(await identity.openContent(d.enc))
       }
       const result = await threads.methods[d.method](args)
+      // Que un aparato ESCRIBA en tu bóveda queda anotado. Antes solo se auditaba el
+      // rechazo, así que la bitácora contaba quién entró pero no qué hizo después.
+      // Solo la operación y el aparato: nunca el contenido (`activity` es un registro
+      // de seguridad, no una copia de lo que guardas).
+      if (!STORE_READ_METHODS.has(d.method)) {
+        audit('store', { device: await deviceIdOf(chk.device), method: d.method })
+      }
       if (cek) {
         const enc = await identity.sealContent(JSON.stringify(result ?? null))
         return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: { __enc: enc } })
@@ -207,7 +220,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   async function handleDevices (from, p) {
     if (!isFresh(p.data)) return staleReply(from)
     const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, trustedIssuer: master, revoked: await revocationSet() })
-    if (!chk.ok) return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason })
+    if (!chk.ok) return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
     const { issued, revoked } = await identity.listDelegations()
     // 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.
@@ -236,13 +249,28 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   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, trustedIssuer: master, revoked: await revocationSet() })
-    if (!chk.ok) { audit('rejected', { what: 'renew', reason: chk.reason }); return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason }) }
+    if (!chk.ok) { audit('rejected', { what: 'renew', reason: chk.reason }); return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason }) }
     // Reusar el label del cert original (si sigue registrado en delegations).
     const { issued } = await identity.listDelegations()
     const prev = (issued || []).find((x) => x.nonce === p.cert.nonce)
-    const { cert } = await identity.signDelegation(p.cert.sub, p.cert.scope, { ttlMs: RENEW_TTL_MS, label: prev?.label || '' })
-    audit('renew', { device: await deviceIdOf(p.cert.sub), label: prev?.label || '' })
-    log(`[vault] cert renovado para ${await deviceIdOf(p.cert.sub)} (30 días)`)
+    // EL SCOPE SALE DEL ACTA, no del cert viejo. El acta es la política (lo que el dueño
+    // decidió con `caps`); el cert es su reflejo, y solo dura 30 días para poder cambiar.
+    // Copiar `p.cert.scope` congelaba la política en el momento del emparejamiento: dar
+    // `administra` no llegaba nunca al cert (la consola remota no podía funcionar) y
+    // QUITARLO tampoco surtía efecto hasta que el cert caducara, hasta un mes después.
+    // Si el miembro ya no está en el acta, no se renueva nada: lo echaron.
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta
+    let scope = p.cert.scope
+    if (acta) {
+      scope = Acta.memberScopes(acta, p.cert.sub)
+      if (!scope.length) {
+        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)`)
     reply(from, { type: MSG.RENEWED, cert })
   }
 
@@ -256,26 +284,26 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   async function handleSecrets (from, p) {
     if (!isFresh(p.data)) { audit('rejected', { what: 'secrets', reason: 'stale' }); return staleReply(from) }
     const ns = p.data?.ns
-    if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'secrets: namespace inválido' })
-    if (typeof p.data?.ek !== 'string') return reply(from, { type: MSG.ERROR, error: 'secrets: falta ek (llave efímera del solicitante)' })
+    if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'secrets: invalid namespace' })
+    if (typeof p.data?.ek !== 'string') return reply(from, { type: MSG.ERROR, error: 'secrets: missing ek (requester ephemeral key)' })
     const chk = await verifyChain({
       data: p.data, signature: p.signature, cert: p.cert,
       expectedScope: secretsScope(ns), trustedIssuer: master, revoked: await revocationSet()
     })
-    if (!chk.ok) { audit('rejected', { what: 'secrets', ns, reason: chk.reason }); return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason }) }
+    if (!chk.ok) { audit('rejected', { what: 'secrets', ns, reason: chk.reason }); return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason }) }
     // FRONTERA DEL CN (acta): además del scope del cert, el acta tiene que decir que este
     // miembro es el servicio `ns`. Así el límite no depende solo de qué cert se emitió: la
     // llave del proxy no ve nada que no sea del proxy, y está escrito donde se puede comprobar.
     const acta = (await identity.profileActa?.().catch(() => null))?.acta
     if (acta && !Acta.memberCanReadSecrets(acta, chk.device, ns)) {
       audit('rejected', { what: 'secrets', ns, reason: 'cn' })
-      return reply(from, { type: MSG.ERROR, error: `no autorizado: cn — el acta no reconoce a este miembro como el servicio «${ns}»` })
+      return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
     }
     let enc
     try {
       enc = await seal({ ek: p.data.ek, payload: { secrets: secrets.get(ns) } })
     } catch (e) {
-      return reply(from, { type: MSG.ERROR, error: 'secrets: ek inválida' })
+      return reply(from, { type: MSG.ERROR, error: 'secrets: invalid ek' })
     }
     const body = { op: 'secrets.result', ns, enc, ts: Date.now() }
     const { signature } = await identity.signData(body)
@@ -295,6 +323,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (payload.type === MSG.DEVICES) return await handleDevices(from, payload)
       if (payload.type === MSG.RENEW) return await handleRenew(from, payload)
       if (payload.type === MSG.SECRETS) return await handleSecrets(from, payload)
+      if (payload.type === MSG.ADMIN) return await handleAdmin(from, payload)
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: e.message })
     }
@@ -305,9 +334,133 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // ----- API local (CLI/UI de control) -----
   // Emparejar / aprobar / rechazar / revocar viven en el núcleo compartido (`desk`).
 
+  // ----- AVISO DE CAMBIO a los agentes del ns -----
+  //
+  // Guardar un secreto no sirve de nada si quien lo usa no se entera. La bóveda
+  // avisa (sin mandar valores: solo «el ns cambió») y el agente decide — el
+  // estándar es que SALGA y lo levante su supervisor, para leer todo fresco y,
+  // sobre todo, para que el valor viejo deje de existir en su memoria.
+  //
+  // AGRUPADO a propósito: cargar cinco valores seguidos con `secret set` son cinco
+  // escrituras, pero un solo cambio de configuración. Sin esta ventana serían cinco
+  // reinicios en cadena, y el agente se pasaría la carga entera reiniciándose.
+  const AVISO_AGRUPA_MS = Number(process.env.DOTRINO_VAULT_AVISO_MS) || 3000
+  const avisosPendientes = new Map()   // ns → timer
+
+  async function avisarCambio (ns) {
+    let destinos = []
+    try {
+      const { issued } = await identity.listDelegations()
+      const revocados = await revocationSet()
+      const scope = secretsScope(ns)
+      // Los agentes de ESE ns y nadie más: el aviso dice qué namespace cambió, así
+      // que mandárselo a otro sería filtrarle que existe.
+      //
+      // Y UNO POR LLAVE, no uno por delegación: renovar el cert emite una
+      // delegación nueva para la MISMA sub-clave, así que un agente que lleve
+      // tiempo enrolado aparece varias veces y recibiría el aviso repetido.
+      const vistas = new Set()
+      destinos = (issued || []).filter((x) => {
+        if (!x.sub || revocados.has(x.nonce) || !(x.scope || []).includes(scope)) return false
+        if (vistas.has(x.sub)) return false
+        vistas.add(x.sub)
+        return true
+      })
+    } catch (e) { return log('[vault] could not list who to notify:', e.message) }
+    if (!destinos.length) return
+
+    const body = { op: 'secrets.changed', ns, ts: Date.now() }
+    const { signature } = await identity.signData(body)
+    for (const d of destinos) {
+      try { client.sendByPubkey(d.sub, { type: MSG.SECRETS_CHANGED, body, signature }) } catch (_) {}
+    }
+    audit('secrets.changed', { ns, avisados: destinos.length })
+    log(`[vault] config for "${ns}" changed: notified ${destinos.length} agent(s)`)
+  }
+
+  function programarAviso (ns) {
+    clearTimeout(avisosPendientes.get(ns))
+    const t = setTimeout(() => {
+      avisosPendientes.delete(ns)
+      avisarCambio(ns).catch((e) => log('[vault] change notice failed:', e.message))
+    }, AVISO_AGRUPA_MS)
+    t.unref?.()
+    avisosPendientes.set(ns, t)
+  }
+
+  // --- CONSOLA REMOTA (docs/consola-remota.md) ---------------------------------
+  // Un dispositivo con cert `vault:admin` puede ADMITIR y EXPULSAR miembros sin venir
+  // al PC. No puede cambiar permisos, traspasar el mando, conceder `admin` ni tocar los
+  // secretos: esas operaciones no existen como mensaje, a propósito. Así un aparato con
+  // `admin` robado hace daño acotado y reversible (se le revoca) en vez de poder dejar
+  // al dueño fuera de su propia cuenta, que no tiene vuelta atrás.
+  /** Últimas entradas de la bitácora (JSONL), de la más reciente hacia atrás. */
+  function readActivity (limit = 100) {
+    try {
+      return fs.readFileSync(activityFile, 'utf8').split('\n').filter(Boolean).slice(-limit)
+        .map((l) => { try { return JSON.parse(l) } catch (_) { return null } }).filter(Boolean).reverse()
+    } catch (_) { return [] }
+  }
+
+  /**
+   * Avisa a TODOS los miembros de que el perfil cambió, firmado por la maestra. Sin
+   * esto, administrar a distancia sería invisible para el resto de los dispositivos —
+   * y esa visibilidad es lo que hace DETECTABLE a un admin comprometido. Va por
+   * `sendByPubkey`, así que al que está apagado le llega cuando encienda (cola 24 h).
+   */
+  async function notifyMembers (ev, info = {}) {
+    try {
+      const body = { ev, ...info, ts: Date.now() }
+      const { signature } = await identity.signData(body)
+      const { issued } = await identity.listDelegations()
+      // UNO POR LLAVE, no uno por delegación: renovar emite una delegación nueva para la
+      // MISMA sub-clave, así que un aparato que lleve tiempo enrolado aparece varias veces
+      // y recibía el mismo aviso repetido —una vez por renovación acumulada—. Mismo
+      // cuidado que en `avisarCambio`.
+      const vistas = new Set()
+      for (const d of issued || []) {
+        if (!d.sub || vistas.has(d.sub)) continue
+        vistas.add(d.sub)
+        try { client.sendByPubkey(d.sub, { type: MSG.ADMIN_EVENT, body, signature }) } catch (_) {}
+      }
+    } catch (e) { log('[vault] could not notify members of the change:', e.message) }
+  }
+
+  const admin = createAdminDesk({
+    desk,
+    deviceIdOf,
+    ttlMs: DEVICE_TTL_MS,
+    audit,
+    notify: notifyMembers,
+    readActivity,
+    // CERT ∩ ACTA, igual que los secretos con su CN. El cert dice qué se emitió; el acta,
+    // qué decidió el dueño AHORA. Sin el segundo, `caps <ID> -administra` no surtía efecto
+    // hasta que el cert caducara: quitarle la administración a un aparato que ya no es de
+    // fiar exigía revocarlo entero. Con el cruce, deja de administrar en el acto.
+    verify: async ({ data, signature, cert }) => {
+      const chk = await verifyChain({
+        data, signature, cert,
+        expectedScope: SCOPE.ADMIN, trustedIssuer: master, revoked: await revocationSet()
+      })
+      if (!chk.ok) return chk
+      const acta = (await identity.profileActa?.().catch(() => null))?.acta
+      if (acta && !Acta.memberCan(acta, chk.device, 'admin')) return { ok: false, reason: 'acta' }
+      return chk
+    }
+  })
+
+  async function handleAdmin (from, p) {
+    // La frescura se comprueba aquí (es del transporte, igual que en el resto de
+    // handlers); el resto de la regla vive en el módulo puro.
+    if (!isFresh(p.data)) return staleReply(from)
+    const r = await admin.handle(p.data, { signature: p.signature, cert: p.cert })
+    if (!r.ok) return reply(from, { type: MSG.ERROR, error: r.error })
+    reply(from, { type: MSG.ADMIN_RESULT, op: p.data.op, result: r.result })
+  }
+
   // API local de secretos (solo CLI/UI del dueño; audita cada cambio).
-  function setSecret (ns, key, value) { secrets.set(ns, key, value); audit('secret.set', { ns, key }) }
-  function deleteSecret (ns, key) { const ok = secrets.delete(ns, key); if (ok) audit('secret.rm', { ns, key }); return ok }
+  function setSecret (ns, key, value) { secrets.set(ns, key, value); audit('secret.set', { ns, key }); programarAviso(ns) }
+  function deleteSecret (ns, key) { const ok = secrets.delete(ns, key); if (ok) { audit('secret.rm', { ns, key }); programarAviso(ns) } return ok }
   function listSecrets () { return secrets.list() }
 
   return {
@@ -315,7 +468,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     startPairing: desk.startPairing,
     stopPairing: desk.stopPairing,
     listPending: desk.listPending,
-    approveDevice: (code) => desk.approve(code),
+    // Aprobar desde el PC avisa igual que aprobar a distancia: el resto de tus
+    // dispositivos se entera de que entró alguien, venga de donde venga.
+    approveDevice: async (code) => {
+      const r = await desk.approve(code)
+      await notifyMembers('enrolled', { deviceId: r?.deviceId || null, by: 'pc' })
+      return r
+    },
     rejectDevice: (deviceId) => desk.reject(deviceId),
     setSecret, deleteSecret, listSecrets,
     listDevices: () => identity.listDelegations(),
@@ -324,8 +483,21 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     profileMembers: () => identity.profileMembers(),
     // ¿Es ESTA bóveda la que sella el acta? Lo usa el freno de borrado (D12).
     isMaster: () => identity.isMaster(),
-    setCaps: (pub, caps) => identity.setCaps(pub, caps),
-    revokeDevice: (nonce) => desk.revoke(nonce),
-    close () { try { client.close() } catch (_) {} identity.destroy() }
+    setCaps: async (pub, caps) => {
+      const r = await identity.setCaps(pub, caps)
+      audit('caps', { device: await deviceIdOf(pub).catch(() => null), caps })
+      await notifyMembers('caps', { deviceId: await deviceIdOf(pub).catch(() => null), caps })
+      return r
+    },
+    revokeDevice: async (nonce) => {
+      const r = await desk.revoke(nonce)
+      await notifyMembers('revoked', { certNonce: nonce, by: 'pc' })
+      return r
+    },
+    close () {
+      for (const t of avisosPendientes.values()) clearTimeout(t)
+      avisosPendientes.clear()
+      try { client.close() } catch (_) {} identity.destroy()
+    }
   }
 }

package/src/vaultControl.js

@@ -149,7 +149,7 @@ async function profileOp (op, { profile, name, password } = {}) {
   writeReq(F.profileReq, { op, ...extra }, profile)
   signalOrCleanup('SIGUSR2', [F.profileReq])
   const d = await waitFor(F.profilesList)
-  if (!d) throw coded('el daemon no respondió', 'NO_REPLY')
+  if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
   if (d.error) throw coded(d.error, d.code) // p.ej. MASTER_WITH_MEMBERS (freno D12)
   return d // { profiles:[{id,name,protected,locked,current,fingerprint,iss,createdAt}], current, done? }
 }
@@ -189,7 +189,7 @@ export async function snapshot (profile) {
  */
 export async function listDevices (profile) {
   const { devices } = await snapshot(profile)
-  if (!devices) throw coded('el daemon no respondió', 'NO_REPLY')
+  if (!devices) throw coded('the daemon did not reply', 'NO_REPLY')
   const issued = devices.issued || devices.active || devices.delegations || []
   const withIds = await Promise.all(issued.map(async (d) => ({
     ...d, deviceId: d.sub ? await deviceIdOf(d.sub) : '????-????'
@@ -213,7 +213,7 @@ export async function revokeDevice (nonce, profile) {
 /** Scopes→[claves] del perfil (NUNCA los valores; el daemon no los expone). */
 export async function listSecrets (profile) {
   const { secrets } = await snapshot(profile)
-  if (!secrets) throw coded('el daemon no respondió', 'NO_REPLY')
+  if (!secrets) throw coded('the daemon did not reply', 'NO_REPLY')
   return secrets.ns || {}
 }
 
@@ -225,8 +225,8 @@ export async function setSecret (ns, key, value, profile) {
   writeReq(F.dumpReq, {}, profile)
   signalOrCleanup('SIGUSR2', [F.secretReq, F.dumpReq])
   const d = await waitFor(F.secretsList)
-  if (!d) throw coded('el daemon no respondió', 'NO_REPLY')
-  if (!(d.ns?.[ns] || []).includes(key)) throw coded('el daemon no aplicó el cambio (revisa los logs del servicio)', 'NOT_APPLIED')
+  if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
+  if (!(d.ns?.[ns] || []).includes(key)) throw coded('the daemon did not apply the change (check the service logs)', 'NOT_APPLIED')
   return d.ns
 }
 
@@ -238,8 +238,8 @@ export async function deleteSecret (ns, key, profile) {
   writeReq(F.dumpReq, {}, profile)
   signalOrCleanup('SIGUSR2', [F.secretReq, F.dumpReq])
   const d = await waitFor(F.secretsList)
-  if (!d) throw coded('el daemon no respondió', 'NO_REPLY')
-  if ((d.ns?.[ns] || []).includes(key)) throw coded('el daemon no borró la variable (revisa los logs del servicio)', 'NOT_DELETED')
+  if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
+  if ((d.ns?.[ns] || []).includes(key)) throw coded('the daemon did not delete the variable (check the service logs)', 'NOT_DELETED')
   return d.ns
 }
 
@@ -292,7 +292,7 @@ export async function startPairing ({ profile, service } = {}) {
       return { qr: pr.qr, expiresAt: pr.expiresAt, url, payload, code, b64: code, profile: pr.profile || null, profileName: pr.profileName || '' }
     }
   }
-  throw coded('el daemon no inició el emparejamiento', 'PAIR_FAILED')
+  throw coded('the daemon did not start the pairing', 'PAIR_FAILED')
 }
 
 /** Dispositivo pendiente de aprobar (el que se conectó con el QR), o null. */