@dotrino/identity 0.40.0 → 0.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.40.0",
+  "version": "0.42.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -269,6 +269,8 @@ export class Identity {
 
   /** Dónde estoy yo: { inProfile, profileId, seq, isMaster, caps, id }. */
   async myMembership () { return this._call('myMembership') }
+  /** La cadena de actas desde `sinceSeq` (ver la nota en `node.js`). */
+  async actaHistory (opts) { return this._call('actaHistory', opts || {}) }
 
   /** ¿Es ESTE dispositivo el master (el único que puede cambiar el acta)? */
   async isMaster () { return this._call('isMaster') }

package/src/node.js

@@ -165,6 +165,17 @@ export class Identity {
   profileActa () { return this._h('profileActa') }
   profileMembers () { return this._h('profileMembers') }
   myMembership () { return this._h('myMembership') }
+  /**
+   * La CADENA de actas desde `sinceSeq` (para que un dispositivo que estuvo apagado
+   * compruebe el encadenamiento en vez de tragarse un salto a ciegas).
+   *
+   * Vivía en el núcleo pero NO estaba aquí, así que `identity.actaHistory` era
+   * `undefined` en el daemon: al pedir la lista de dispositivos con un `sinceSeq`
+   * —que es lo que manda SIEMPRE un navegador ya emparejado— reventaba con
+   * «is not a function», la bóveda respondía error, y el aparato NUNCA volvía a
+   * sincronizar su acta. Se quedaba con la copia del día que emparejó.
+   */
+  actaHistory (opts) { return this._h('actaHistory', opts || {}) }
   isMaster () { return this._h('isMaster') }
   admitMember (member) { return this._h('admitMember', member) }
   setCaps (pub, caps) { return this._h('setCaps', { pub, caps }) }

package/vault/acta.js

@@ -245,6 +245,15 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         // No se puede ascender un servicio a dispositivo cambiándole las capacidades: para
         // eso hay que sacarlo y volver a admitirlo, que es un gesto visible.
         m.caps = cleanCaps(ch.caps).filter((c) => (m.cn ? SERVICE_CAPS : DEVICE_CAPS).includes(c))
+        // CONCEDER LIMPIA LA RENUNCIA. `effectiveCaps` resta lo renunciado, así que sin
+        // esto una renuncia sellada era IRREVERSIBLE: el master le devolvía el permiso en
+        // `caps` y la resta seguía dejándolo fuera, para siempre. La interfaz promete
+        // «puedes devolvérselo desde el Master», así que tiene que ser verdad.
+        // Se tira el registro entero y no se le recortan capacidades: va FIRMADO por el
+        // miembro, y editarlo lo dejaría sin firma válida.
+        const renunciadas = new Set()
+        for (const r of next.renounced) if (r.member === m.pub) for (const c of (r.caps || [])) renunciadas.add(c)
+        if (m.caps.some((c) => renunciadas.has(c))) next.renounced = next.renounced.filter((r) => r.member !== m.pub)
         break
       }
       case 'label': {

package/vault/core.js

@@ -22,7 +22,7 @@ import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './
 import * as Acta from './acta.js'
 import * as Content from './content.js'
 import { pubkeyId as pubkeyIdOf } from './capabilities.js'
-import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin } from './remote.js'
+import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin, requestRenounce as remoteRenounce } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
 export const ENC_KEY_STORAGE = 'dotrino.identity.enc-keypair'
@@ -1270,6 +1270,16 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       pend.push(record)
       saveRenounces(pend)
       emitVault({ phase: 'renounced', caps: record.caps })
+      // Y se le MANDA a la bóveda para que la selle en el acta. Sin esto la renuncia solo
+      // valía aquí dentro: la bóveda seguía teniendo escrito que este aparato puede firmar
+      // y le seguía aceptando peticiones. Best-effort: si la bóveda está apagada, la
+      // renuncia ya está en pie localmente (para eso no necesita a nadie) y se reintenta
+      // la próxima vez que se renuncie.
+      const v = loadVaultCert(); const dev = loadVaultDevice()
+      if (v?.cert && dev) {
+        remoteRenounce({ master: v.master, proxy: v.proxy, device: dev, cert: v.cert, record })
+          .catch(() => {})
+      }
       // Si además soy el master, la absorbo ya en el acta.
       if (amMaster()) { try { await sealChanges([{ op: 'renounce', record }]) } catch (_) {} }
       return { ok: true, record, caps: Acta.effectiveCaps(loadActa(), publickeyJwkStr, loadRenounces()) }

package/vault/remote.js

@@ -32,6 +32,9 @@ const MSG = {
   ADMIN: 'vault.admin',
   ADMIN_RESULT: 'vault.admin.result',
   ADMIN_EVENT: 'vault.admin.event',
+  // Renuncia: el miembro se quita capacidades a sí mismo y la bóveda la sella en el acta.
+  RENOUNCE: 'vault.renounce',
+  RENOUNCE_RESULT: 'vault.renounce.result',
   ERROR: 'vault.error'
 }
 export { MSG as VAULT_MSG }
@@ -275,6 +278,26 @@ export async function requestRenew ({ master, proxy, device, cert, onRevoked } =
   return { cert: res.cert }
 }
 
+/**
+ * Manda a la bóveda la RENUNCIA de este dispositivo para que la selle en el acta.
+ *
+ * Sin esto, renunciar solo valía en el propio aparato: la bóveda seguía teniendo escrito
+ * que podía firmar, le seguía aceptando peticiones, y cualquiera que mirara el acta lo
+ * seguía viendo como firmante. Una renuncia que no llega al acta no es oponible a nadie —
+ * y en el caso que la justifica (te robaron el aparato) su registro local no vale nada,
+ * porque lo borra quien lo tenga en la mano.
+ *
+ * El `record` va FIRMADO por el propio miembro y solo puede QUITAR, así que la bóveda no
+ * necesita comprobar ningún certificado para honrarlo: le basta la firma.
+ */
+export async function requestRenounce ({ master, proxy, device, cert, record, onRevoked } = {}) {
+  const res = await vaultRpc({
+    master, proxy, device, cert, onRevoked,
+    sendType: MSG.RENOUNCE, okType: MSG.RENOUNCE_RESULT, data: { op: 'renounce', record }
+  })
+  return { ok: !!res.ok, seq: res.seq ?? null }
+}
+
 /**
  * CONSOLA REMOTA (`dotrino-vault/docs/consola-remota.md`): administrar el perfil desde
  * este dispositivo, sin ir al PC. Requiere un cert con scope `vault:admin`, que **no se