@dotrino/identity 0.104.0 → 0.104.1

package/package.json

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

package/vault/nativeStore.js

@@ -78,3 +78,84 @@ export async function nativeBackends (bridge) {
 
   return { kv, keyStore, peers, flush: () => chain }
 }
+
+const PROFILES = 'dotrino.identity.profiles'
+const CURRENT = 'dotrino.identity.current'
+const scopedKey = (pid, k) => `dotrino.identity.p.${pid}.${k}`
+
+/**
+ * LOS PERFILES QUE SE QUEDARON EN LA PÁGINA pasan a la app (dueño, 2026-09-26: «todas las
+ * pestañas usan el mismo perfil, pero NO es el de Dotrino que está en Pedidos»).
+ *
+ * Antes de `nativeStore` cada página guardaba la identidad aparte, así que la cuenta que se
+ * emparejó en `vault.dotrino.com/d` quedó en el almacén de ESA página: su llave está en el
+ * chip (Pedidos la usa), pero su acta, su papel y su nombre no llegaron a la app, y la app
+ * estrenó un perfil vacío. Esto la trae.
+ *
+ * Solo se trae un perfil cuya llave VIVE en el chip (`open` contesta): uno de software no
+ * cabe, y uno cuya llave ya se borró no sirve para nada. Lo que la app ya tiene no se pisa.
+ * Y si el perfil activo de la app no está emparejado y el traído sí, pasa a ser el activo:
+ * el vacío se inventó justo porque faltaba este.
+ *
+ * `page`: lo que hay en el almacén de ESTA página — `kv` (entradas del localStorage),
+ * `keys` (registros del IndexedDB de llaves) y `peers` (libros de contactos).
+ */
+export async function adoptPageProfiles (native, bridge, page) {
+  const mine = JSON.parse(native.kv.getItem(PROFILES) || '[]')
+  const theirs = JSON.parse(page.kv.get(PROFILES) || '[]')
+  const adopted = []
+  for (const p of theirs) {
+    if (!p?.id || mine.some((m) => m.id === p.id)) continue
+    const sign = page.keys.get(scopedKey(p.id, 'keypair'))
+    const enc = page.keys.get(scopedKey(p.id, 'enc-keypair'))
+    if (!sign?.external) continue
+    try { await bridge.call('open', { kid: sign.external }) } catch (_) { continue }
+    const prefix = `dotrino.identity.p.${p.id}.`
+    for (const [k, v] of page.kv) if (k.startsWith(prefix)) native.kv.setItem(k, v)
+    await native.keyStore.set(scopedKey(p.id, 'keypair'), sign)
+    if (enc?.external) await native.keyStore.set(scopedKey(p.id, 'enc-keypair'), enc)
+    const book = page.peers.get(`peers.${p.id}.v1`)
+    if (book) await native.peers.put(`peers.${p.id}.v1`, book)
+    mine.push(p)
+    adopted.push(p.id)
+  }
+  if (!adopted.length) return adopted
+  native.kv.setItem(PROFILES, JSON.stringify(mine))
+  const cur = native.kv.getItem(CURRENT)
+  const paired = (pid) => !!native.kv.getItem(scopedKey(pid, 'vault.cert'))
+  if (!cur || !paired(cur)) {
+    const next = adopted.find(paired)
+    if (next) native.kv.setItem(CURRENT, next)
+  }
+  console.info(`[cc-identity] adopted ${adopted.length} profile(s) from this page's storage into the app: ${adopted.join(', ')}`)
+  return adopted
+}
+
+/** Todo lo que la identidad guardó en el almacén de ESTA página (localStorage + sus dos IndexedDB). */
+export async function readPageStorage () {
+  const kv = new Map()
+  for (let i = 0; i < localStorage.length; i++) {
+    const k = localStorage.key(i)
+    if (k && k.startsWith('dotrino.identity.')) kv.set(k, localStorage.getItem(k))
+  }
+  return { kv, keys: await idbAll('dotrino-identity-keys', 'keys'), peers: await idbAll('cc-identity', 'kv') }
+}
+
+function idbAll (dbName, store) {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(dbName)
+    req.onupgradeneeded = () => { if (!req.result.objectStoreNames.contains(store)) req.result.createObjectStore(store) }
+    req.onerror = () => reject(req.error)
+    req.onsuccess = () => {
+      const db = req.result
+      if (!db.objectStoreNames.contains(store)) { db.close(); resolve(new Map()); return }
+      const out = new Map()
+      const cur = db.transaction(store, 'readonly').objectStore(store).openCursor()
+      cur.onsuccess = () => {
+        const c = cur.result
+        if (c) { out.set(String(c.key), c.value); c.continue() } else { db.close(); resolve(out) }
+      }
+      cur.onerror = () => reject(cur.error)
+    }
+  })
+}

package/vault/vault.js

@@ -15,7 +15,7 @@ import {
 import { createIdentityCore } from './core.js'
 import { pubkeyId } from './capabilities.js'
 import { withExternalKeys, appBridge } from './externalKeys.js'
-import { nativeBackends } from './nativeStore.js'
+import { nativeBackends, adoptPageProfiles, readPageStorage } from './nativeStore.js'
 import { useBackend as usePeerBackend } from './peerStore.js'
 
 ;(async () => {
@@ -25,7 +25,14 @@ import { useBackend as usePeerBackend } from './peerStore.js'
   // Y si la app GUARDA la identidad (`storage`, la de iOS): todo vive allí, uno para todas
   // las páginas, porque WebKit parte el almacén de este iframe por página (`./nativeStore.js`).
   const native = bridge && idKeys.storage === true ? await nativeBackends(bridge) : null
-  if (native) usePeerBackend(native.peers)
+  if (native) {
+    usePeerBackend(native.peers)
+    // Lo que se emparejó cuando la identidad aún vivía en la página, a la app. Si no se puede
+    // leer el almacén de la página se dice (con su error) y se sigue: la identidad de la app
+    // funciona igual, solo que sin ese perfil.
+    try { await adoptPageProfiles(native, bridge, await readPageStorage()) }
+    catch (e) { console.error('[cc-identity] could not bring this page\'s profiles into the app:', e?.message || e) }
+  }
 
   // kv estilo localStorage (síncrono) para me, nonces, delegaciones, certs.
   const kv = native ? native.kv : {