@dotrino/identity 0.15.0 → 0.16.1

package/package.json

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

package/src/node.js

@@ -50,6 +50,16 @@ function filePeers (filePath) {
   }
   return {
     setProfile (p) { pid = p || null },
+    adoptLegacy (newPid) {
+      // Migración: copia el peers.json viejo (sin namespace) al perfil newPid.
+      try {
+        if (!fs.existsSync(filePath)) return
+        const legacy = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+        if (legacy && typeof legacy === 'object' && Object.keys(legacy).length) {
+          fs.writeFileSync(path.join(path.dirname(filePath), `peers.${newPid}.json`), JSON.stringify(legacy))
+        }
+      } catch (_) { /* sin peers viejos */ }
+    },
     async initPeerStorage () {
       const f = fileFor()
       try {

package/vault/core.js

@@ -195,6 +195,16 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
   // Canal de eventos 'vault' (p.ej. el SAS a comparar durante el emparejamiento).
   const vaultListeners = new Set()
   const emitVault = (p) => { for (const fn of vaultListeners) { try { fn(p) } catch (_) {} } }
+  // Si el vault RECHAZA por cert revocado, este dispositivo perdió el acceso: limpiamos el
+  // cert local (ya no sirve) y emitimos 'revoked' → @dotrino/store borra SOLO el store de
+  // ESTE perfil (los demás perfiles quedan intactos). Cualquier otro error se propaga igual.
+  const handleVaultError = (e) => {
+    if (e && /\brevoked\b/.test(e.message || '')) {
+      try { kv.removeItem(VAULT_CERT_STORAGE); kv.removeItem(VAULT_DEVICE_STORAGE) } catch (_) {}
+      emitVault({ phase: 'revoked' })
+    }
+    throw e
+  }
   const loadVaultCert = () => { try { return JSON.parse(kv.getItem(VAULT_CERT_STORAGE) || 'null') } catch (_) { return null } }
   const loadVaultDevice = () => { try { return JSON.parse(kv.getItem(VAULT_DEVICE_STORAGE) || 'null') } catch (_) { return null } }
 
@@ -613,7 +623,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     async vaultSign ({ payload }) {
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
-      return remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload })
+      try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload }) }
+      catch (e) { return handleVaultError(e) }
     },
 
     // Store DELEGADO: lee/escribe el store de hilos+aperturas EN tu vault (con el cert).
@@ -621,14 +632,16 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     async vaultStore ({ method, args }) {
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
-      return remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method, args })
+      try { return await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method, args }) }
+      catch (e) { return handleVaultError(e) }
     },
 
     // Lista (solo lectura) de dispositivos enrolados en tu vault.
     async listVaultDevices () {
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
-      return remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert })
+      try { return await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert }) }
+      catch (e) { return handleVaultError(e) }
     },
 
     // El cert de delegación de este dispositivo (para presentarlo al proxy en `identify`
@@ -739,17 +752,27 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
 
   // ----- bootstrap -----
 
-  // Perfil activo (multi-perfil por dispositivo). Sin migración (ecosistema nuevo, no importa
-  // perder data): si no hay perfiles, se crea uno fresco. A partir de acá `kv` está scopeado a
-  // `currentPid` y `peers` apunta al peer book de ese perfil.
+  // Perfil activo (multi-perfil por dispositivo). Si no hay perfiles, se crea el primero; si
+  // existe una identidad ÚNICA vieja (pre-multi-perfil, claves sin namespace), se ADOPTA como
+  // "Perfil 1" — sin pérdida. A partir de acá `kv` está scopeado a `currentPid`.
   {
     let profiles = loadProfiles()
     currentPid = rawKv.getItem(CURRENT_STORAGE)
     if (!profiles.length) {
-      currentPid = 'p' + crypto.randomUUID().slice(0, 8)
-      profiles = [{ id: currentPid, name: '', pubkey: null }]
+      const pid = 'p' + crypto.randomUUID().slice(0, 8)
+      // Migración: adoptar la identidad única vieja (si la hay) copiando sus claves al namespace de pid.
+      const legacy = rawKv.getItem(KEY_STORAGE)
+      if (legacy) {
+        for (const s of ['keypair', 'enc-keypair', 'me', 'nonces', 'delegations', 'revocations', 'vault.device', 'vault.cert']) {
+          const v = rawKv.getItem('dotrino.identity.' + s)
+          if (v != null) rawKv.setItem(`dotrino.identity.p.${pid}.${s}`, v)
+        }
+        try { await peers.adoptLegacy?.(pid) } catch (_) { /* peers viejos opcionales */ }
+      }
+      currentPid = pid
+      profiles = [{ id: pid, name: '', pubkey: null }]
       saveProfiles(profiles)
-      rawKv.setItem(CURRENT_STORAGE, currentPid)
+      rawKv.setItem(CURRENT_STORAGE, pid)
     } else if (!currentPid || !profiles.find((p) => p.id === currentPid)) {
       currentPid = profiles[0].id
       rawKv.setItem(CURRENT_STORAGE, currentPid)

package/vault/peerStore.js

@@ -40,6 +40,20 @@ export function onDirty (fn) { _markDirty = fn }
 export function setProfile (pid) { _pid = pid || null }
 function peersKey () { return _pid ? `peers.${_pid}.v1` : IDB_PEERS_KEY }
 
+/** Migración: copia el peer book VIEJO (pre-multi-perfil, sin namespace) al perfil `pid`. */
+export async function adoptLegacy (pid) {
+  try {
+    _idb = _idb || await openIdb()
+    let legacy = await idbGet(_idb, IDB_PEERS_KEY) // 'peers.v1' (viejo)
+    if (!legacy || typeof legacy !== 'object' || !Object.keys(legacy).length) {
+      try { const raw = localStorage.getItem(PEERS_STORAGE); legacy = raw ? JSON.parse(raw) : null } catch (_) { legacy = null }
+    }
+    if (legacy && typeof legacy === 'object' && Object.keys(legacy).length) {
+      await idbPut(_idb, `peers.${pid}.v1`, legacy)
+    }
+  } catch (_) { /* sin peers viejos que adoptar */ }
+}
+
 function openIdb () {
   return new Promise((resolve, reject) => {
     let req