@dotrino/identity 0.46.0 → 0.48.0

package/package.json

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

@@ -342,19 +342,60 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
   /**
    * BORRADO por revocación. Solo lo dispara un `vault.revoked` FIRMADO por la maestra
-   * pineada (lo verifica `remote.js` antes de llamar aquí). Emite 'revoked' →
-   * `@dotrino/store` borra el store de ESTE perfil (los demás quedan intactos).
+   * pineada (lo verifica `remote.js` antes de llamar aquí).
+   *
+   * Se va la CUENTA ENTERA, no solo el enlace. Una cuenta que vivía en una bóveda y de la
+   * que te echaron no es «una cuenta sin bóveda»: no es nada. Dejarla ahí —sin acta, sin
+   * certificado, con su llave— era dejar un cascarón que seguía saliendo en el conmutador
+   * de perfiles, con su nombre y su foto, sin poder hacer nada y sin que nadie supiera qué
+   * era ni cómo quitarlo.
+   *
+   * El aparato NUNCA se queda sin cuenta utilizable, que es la otra mitad: si había otras,
+   * se pasa a una de ellas; si esa era la única, se estrena una vacía. Así al terminar hay
+   * exactamente lo que tiene que haber: un dispositivo con su cuenta, listo para usarse o
+   * para volver a conectarse a una bóveda.
+   *
+   * Los pasos van EN ESTE ORDEN a propósito:
+   *   1. fuera el enlace y el acta (deja de poder hablar con la bóveda y de enseñar el
+   *      perfil del que lo echaron);
+   *   2. 'revoked' → `@dotrino/store` borra el store de ESE perfil (apunta al id que ya
+   *      tenía fijado, así que da igual lo que hagamos después con el perfil activo);
+   *   3. se borra la cuenta y se deja otra puesta;
+   *   4. 'account-removed' → la app RECARGA (multi-perfil no es reactivo, por diseño).
    */
   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' })
+    // Sin `await`: quien llama es un manejador de mensajes que no espera nada (y si algo
+    // aquí revienta, el enlace y el acta ya se fueron, que es lo que no puede quedar).
+    removeThisAccount().catch(() => {})
+  }
+
+  /**
+   * Borra la cuenta de ESTE dispositivo y deja otra activa (existente o recién creada).
+   * Se usa al ser expulsado; ver `wipeVaultLink`.
+   */
+  let removingAccount = false
+  async function removeThisAccount () {
+    // UNA VEZ. Puede haber varias peticiones en vuelo y a todas les llega el mismo aviso;
+    // sin este cerrojo, la segunda borraría la cuenta RECIÉN CREADA (para entonces
+    // `currentPid` ya es la nueva) en vez de la que echaron.
+    if (removingAccount) return
+    removingAccount = true
+    const gone = currentPid
+    // Si esa era la única cuenta hay que estrenar otra ANTES de borrarla: `deleteProfile`
+    // se niega a dejar el dispositivo sin ninguna, y con razón. Crear ya deja la nueva
+    // activa; si había otras, es el propio `deleteProfile` quien pasa a la primera.
+    const created = loadProfiles().filter((p) => p.id !== gone).length === 0
+    try {
+      if (created) await handlers.createProfile({ name: '' })
+      await handlers.deleteProfile({ id: gone })
+    } catch (e) {
+      emitVault({ phase: 'account-removed', removed: gone, current: currentPid, error: e?.message || String(e) })
+      return
+    }
+    emitVault({ phase: 'account-removed', removed: gone, current: currentPid, created })
   }
 
   /**

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 })
     },