@dotrino/identity 0.46.0 → 0.47.0

package/package.json

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

@@ -439,8 +439,18 @@ export class Identity {
   async selfVaultApprove (deviceId, code) { return this._call('selfVaultApprove', { deviceId, code }) }
   /** Rechaza una solicitud de emparejamiento pendiente. */
   async selfVaultReject (deviceId) { return this._call('selfVaultReject', { deviceId }) }
-  /** Revoca una máquina/agente enrolado por nonce de delegación. */
-  async selfVaultRevoke (nonce) { return this._call('selfVaultRevoke', { nonce }) }
+  /**
+   * QUITA una máquina/agente enrolado en esta bóveda. Se le pasa **el aparato**
+   * (`{ sub }`, su llave): sale del acta y se le retiran todos sus certificados.
+   *
+   * Un `nonce` suelto (string, o `{ nonce }`) retira UN certificado y deja al aparato
+   * dentro del acta: eso no es quitarlo, y quien queda así ya no recibe nunca el aviso
+   * de expulsión. Se acepta por compatibilidad, no como la forma normal.
+   */
+  async selfVaultRevoke (target) {
+    const p = typeof target === 'string' ? { nonce: target } : { sub: target?.sub, nonce: target?.nonce }
+    return this._call('selfVaultRevoke', p)
+  }
   /** Presencia online (ping/pong) de las máquinas enroladas. Devuelve { online: [pubkeys] }. */
   async selfVaultProbe (pubkeys) { return this._call('selfVaultProbe', { pubkeys }, 10000) }
   /** Suscribe a eventos del self-vault ('selfVault'): { running?, pending?, error? }. */

package/vault/remote.js

@@ -223,6 +223,13 @@ export async function requestSign ({ master, proxy, device, cert, payload, onRev
   return { signature: res.signature, publickey: res.publickey }
 }
 
+/**
+ * Cuánto se espera el aviso FIRMADO de expulsión después de que la bóveda conteste
+ * «revoked». Corto a propósito: es el tiempo de un mensaje que ya viene en camino, no una
+ * espera de verdad.
+ */
+const REVOKE_GRACE_MS = 1500
+
 /**
  * Helper genérico: una RPC al vault firmada por D + cert, esperando `okType`.
  *
@@ -240,6 +247,7 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
     const signed = { ...data, publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data: signed })
     const pending = new Promise((resolve, reject) => {
+      let graceTimer = null
       const off = client.on('message', (_f, p) => {
         if (!p || typeof p !== 'object') return
         if (p.type === MSG.REVOKED) {
@@ -249,10 +257,21 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
           return
         }
         if (p.type === okType) { cleanup(); resolve(p) }
-        else if (p.type === 'vault.error') { cleanup(); reject(new Error(p.error)) }
+        else if (p.type === 'vault.error') {
+          // «Te echaron» llega en DOS mensajes: este error (que no va firmado, así que no
+          // puede borrar nada — wipe-DoS) y el `vault.revoked` FIRMADO, que es el único que
+          // sí. Cerrar el socket al recibir el primero era llegar a cerrar la puerta justo
+          // antes que el segundo, y entonces el aparato se quedaba con la cuenta puesta
+          // hasta vaya a saber cuándo. Se le da un respiro corto para recogerlo.
+          if (/\brevoked\b/.test(p.error || '') && !graceTimer) {
+            graceTimer = setTimeout(() => { cleanup(); reject(new Error(p.error)) }, REVOKE_GRACE_MS)
+            return
+          }
+          cleanup(); reject(new Error(p.error))
+        }
       })
       const t = setTimeout(() => { cleanup(); reject(new Error('the vault did not reply (is it running?)')) }, timeoutMs)
-      const cleanup = () => { off(); clearTimeout(t) }
+      const cleanup = () => { off(); clearTimeout(t); clearTimeout(graceTimer) }
     })
     client.sendByPubkey(master, { type: sendType, data: signed, signature, cert })
     return await pending

package/vault/vault.js

@@ -239,7 +239,20 @@ import { pubkeyId } from './capabilities.js'
       daemon.reject(deviceId)
       return { ok: true }
     },
-    selfVaultRevoke: async ({ nonce }) => {
+    /**
+     * QUITAR UN APARATO cuando la bóveda es ESTE navegador. Por `sub` (su llave): sale del
+     * acta y se le retiran todos los certificados, que son las dos caras del mismo acto.
+     *
+     * Con `nonce` a secas solo cae UN papel y el aparato sigue siendo miembro — un
+     * fantasma en la lista al que además ya nunca le llega el aviso de expulsión, porque
+     * mientras siga en el acta un papel retirado significa «renueva», no «estás fuera».
+     * Se conserva para quien de verdad quiera retirar un certificado suelto.
+     */
+    selfVaultRevoke: async ({ sub, nonce }) => {
+      if (sub) {
+        if (daemon?.revokeDevice) return daemon.revokeDevice(sub)
+        return handlers.revokeDevice({ sub })
+      }
       if (daemon) return daemon.revoke(nonce)
       return handlers.revokeDelegation({ nonce })
     },