@dotrino/identity 0.42.0 → 0.44.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.42.0",
+  "version": "0.44.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

@@ -251,6 +251,14 @@ export class Identity {
     return this._call('revokeDelegation', { nonce })
   }
 
+  /**
+   * QUITA EL DISPOSITIVO: retira **todos** los certificados vigentes de esa llave.
+   * Revocar por `nonce` retira un papel; un aparato puede tener otros y seguir entrando.
+   */
+  async revokeDevice (sub) {
+    return this._call('revokeDevice', { sub })
+  }
+
   /** Lista las delegaciones emitidas + la lista de revocación (para el gestor de dispositivos). */
   async listDelegations () {
     return this._call('listDelegations')

package/src/node.js

@@ -160,6 +160,8 @@ export class Identity {
   // Delegación de capacidad (sub-clave de dispositivo con scope/exp/revocación)
   signDelegation (sub, scope, opts = {}) { return this._h('signDelegation', { sub, scope, ...opts }) }
   revokeDelegation (nonce) { return this._h('revokeDelegation', { nonce }) }
+  /** Quitar el DISPOSITIVO: retira todos sus certificados vigentes, no solo uno. */
+  revokeDevice (sub) { return this._h('revokeDevice', { sub }) }
   listDelegations () { return this._h('listDelegations') }
   // Acta de perfil (qué llaves son del perfil y qué puede cada una; ver acta-de-perfil.md)
   profileActa () { return this._h('profileActa') }

package/vault/core.js

@@ -314,6 +314,27 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   }
   const saveRevocations = (o) => kv.setItem(REVOCATIONS_STORAGE, JSON.stringify(o))
 
+  /**
+   * Retira todos los certificados vigentes de la llave `sub`, menos `keepNonce` (el recién
+   * emitido, cuando esto se llama desde `signDelegation`). Devuelve los nonces retirados.
+   * Solo toca las listas locales: avisar al aparato es cosa del mostrador de enrolamiento,
+   * que es quien puede firmar la orden de autoborrado.
+   */
+  function revokePriorCertsFor (sub, keepNonce) {
+    const store = loadDelegations()
+    const rev = loadRevocations()
+    const now = Date.now()
+    const hit = []
+    for (const [nonce, d] of Object.entries(store)) {
+      if (nonce === keepNonce || d?.sub !== sub || d?.revokedAt) continue
+      rev[nonce] = now
+      d.revokedAt = now
+      hit.push(nonce)
+    }
+    if (hit.length) { saveRevocations(rev); saveDelegations(store) }
+    return hit
+  }
+
   // ----- emparejamiento con el vault del usuario (este dispositivo enrolado) -----
   // Canal de eventos 'vault' (p.ej. el código a tipear durante el emparejamiento).
   const vaultListeners = new Set()
@@ -326,6 +347,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    */
   const wipeVaultLink = () => {
     try { kv.removeItem(VAULT_CERT_STORAGE); kv.removeItem(VAULT_DEVICE_STORAGE) } catch (_) {}
+    // Y el ACTA. Sin esto el aparato borraba su enlace con la bóveda pero seguía
+    // enseñando el perfil del que acababan de echarlo —con sus miembros y sus permisos—,
+    // porque la copia local se quedaba ahí y ya no podía refrescarla (está revocado). El
+    // dueño lo describió exacto: «el device ni por enterado de que está fuera».
+    // Queda como lo que es: un dispositivo sin cuenta, que puede crear la suya o
+    // emparejarse otra vez.
+    try { kv.removeItem(ACTA_STORAGE) } catch (_) {}
     emitVault({ phase: 'revoked' })
   }
 
@@ -1043,7 +1071,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // de dispositivo `sub`, acotado por `scope` y `exp`, revocable por `nonce`.
     // Es la ÚNICA forma en que la autoridad sale de la clave maestra, y va limitada.
 
-    async signDelegation ({ sub, scope, ttlMs, exp, nonce, label }) {
+    async signDelegation ({ sub, scope, ttlMs, exp, nonce, label, supersede }) {
       if (!sub || typeof sub !== 'string') throw new Error('sub (device pubkey) required')
       if (!scope || (typeof scope !== 'string' && !Array.isArray(scope))) throw new Error('scope required')
       const iat = Date.now()
@@ -1054,9 +1082,27 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const store = loadDelegations()
       store[cert.nonce] = { nonce: cert.nonce, sub, scope, iat, exp: cappedExp, label: typeof label === 'string' ? label.slice(0, 60) : '' }
       saveDelegations(store)
+      // UNA LLAVE, UN CERTIFICADO VIGENTE. Renovar emitía uno nuevo y dejaba vivo el
+      // anterior: el mismo aparato salía dos veces en la lista (parecían dos máquinas) y,
+      // peor, «quitar el dispositivo» revocaba UN cert y el aparato seguía entrando con el
+      // otro — a veces justo con el que llevaba `vault:admin`. Al firmar, los certs previos
+      // de esa misma `sub` se retiran. Silencioso a propósito: NO se emite el aviso de
+      // autoborrado (eso solo lo dispara una revocación de verdad, desde el mostrador).
+      if (supersede !== false) revokePriorCertsFor(sub, cert.nonce)
       return { cert }
     },
 
+    /**
+     * Retira TODOS los certificados vigentes de un dispositivo (por su llave `sub`).
+     * Es lo que significa «quitar el dispositivo»: revocar por `nonce` retira un papel,
+     * no al aparato, que puede tener otros.
+     */
+    async revokeDevice ({ sub }) {
+      if (!sub || typeof sub !== 'string') throw new Error('sub (device pubkey) required')
+      const nonces = revokePriorCertsFor(sub, null)
+      return { ok: true, nonces, revokedAt: Date.now() }
+    },
+
     async revokeDelegation ({ nonce }) {
       if (!nonce || typeof nonce !== 'string') throw new Error('nonce required')
       const rev = loadRevocations()
@@ -1067,10 +1113,16 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { ok: true, revokedAt: rev[nonce] }
     },
 
+    // `issued` = lo que HOY sirve para entrar. Antes devolvía el almacén entero, revocados
+    // incluidos (revocar solo estampa `revokedAt`), así que la consola seguía pintando como
+    // activo un cert ya retirado: pulsabas «quitar» y la fila no se movía. Los caducados ya
+    // los poda `loadDelegations`. El histórico retirado va aparte, en `revokedCerts`.
     async listDelegations () {
       const store = loadDelegations(); const rev = loadRevocations()
+      const all = Object.values(store).sort((a, b) => (b.iat || 0) - (a.iat || 0))
       return {
-        issued: Object.values(store).sort((a, b) => (b.iat || 0) - (a.iat || 0)),
+        issued: all.filter((d) => !d.revokedAt && !rev[d.nonce]),
+        revokedCerts: all.filter((d) => d.revokedAt || rev[d.nonce]),
         revoked: Object.keys(rev).map(nonce => ({ nonce, revokedAt: rev[nonce] }))
       }
     },

package/vault/vault.js

@@ -118,6 +118,7 @@ import { pubkeyId } from './capabilities.js'
     signDelegation: (sub, scope, opts) => handlers.signDelegation({ sub, scope, ...(opts || {}) }),
     listDelegations: () => handlers.listDelegations({}),
     revokeDelegation: (nonce) => handlers.revokeDelegation({ nonce }),
+    revokeDevice: (sub) => handlers.revokeDevice({ sub }),
     admitMember: (m) => handlers.admitMember(m),
     profileActa: () => handlers.profileActa({}),
     // Camino A (`mode: 'adopt'`): la bóveda se queda con la cuenta que trae el aparato,