@dotrino/identity 0.103.0 → 0.104.1

package/package.json

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

@@ -0,0 +1,161 @@
+/**
+ * TODO LO DE LA IDENTIDAD EN LA APP, NO EN LA PÁGINA (app de iOS, 2026-09-26).
+ *
+ * WebKit guarda el localStorage y el IndexedDB de un iframe de otro origen APARTE por cada
+ * página que lo contiene. Dentro de la app de iOS eso partía la identidad en tantas como
+ * páginas: `dotrino.com`, `profile.dotrino.com` y `vault.dotrino.com` veían cada una un
+ * perfil distinto, recién inventado (dueño: «todas deberían tener el perfil/perfiles
+ * cargados nativamente»). El WebView de Android no separa así, y por eso allí no pasaba.
+ *
+ * Con esto, cuando la app lo ofrece (`bridge.storage`), las tres piezas que la identidad
+ * guarda —el `kv` síncrono, los registros de llaves y el libro de contactos— viven en UN
+ * almacén de la app, el mismo para todas las páginas. Nada secreto viaja: las llaves son del
+ * chip (el registro es `{ external: kid, kind, publicJwk }`) y el resto es lo que ya se
+ * guardaba en el disco de la página.
+ *
+ * Cómo: al arrancar se trae TODO de una vez (`storeLoad`) y se sirve desde memoria, que es
+ * lo que el `kv` necesita para seguir siendo síncrono. Cada cambio se escribe en la app al
+ * momento, en orden. Solo hay un iframe de identidad vivo a la vez (la app tiene un solo
+ * WebView), así que no hay dos memorias que se pisen.
+ */
+
+const KV = 'kv:'
+const KEY = 'key:'
+const PEERS = 'peers:'
+
+/** El asa de una llave no se puede guardar en la app: solo su registro, que no tiene nada secreto. */
+function plainKeyRecord (rec) {
+  if (rec && typeof rec.external === 'string' && rec.publicJwk && (rec.kind === 'sign' || rec.kind === 'enc')) {
+    return { external: rec.external, kind: rec.kind, publicJwk: rec.publicJwk }
+  }
+  // Una llave de SOFTWARE (adoptar un perfil, entrar con contraseña) no cabe en el chip, y
+  // guardarla a medias sería perder la cuenta sin decirlo. Se para aquí y se dice.
+  throw Object.assign(new Error('this app keeps keys in the phone chip only: a software key cannot be stored here'), { code: 'native-no-import' })
+}
+
+export async function nativeBackends (bridge) {
+  const { items } = await bridge.call('storeLoad', {})
+  if (!items || typeof items !== 'object') {
+    throw Object.assign(new Error('the app did not return its store'), { code: 'native-no-store' })
+  }
+  const mem = new Map(Object.entries(items))
+
+  // Escrituras EN ORDEN: un `remove` que adelantara a su `set` resucitaría el dato. Una que
+  // falla se dice en la consola con su código (sin tragársela) y no frena a las siguientes.
+  let chain = Promise.resolve()
+  const write = (method, params) => {
+    chain = chain.then(() => bridge.call(method, params)).catch((e) => {
+      console.error(`[cc-identity] native store ${method} failed (${e?.code || 'error'}): ${e?.message}`)
+    })
+    return chain
+  }
+  const set = (k, v) => { mem.set(k, v); return write('storeSet', { k, v }) }
+  const del = (k) => { mem.delete(k); return write('storeRemove', { k }) }
+
+  const kv = {
+    getItem: (k) => (mem.has(KV + k) ? mem.get(KV + k) : null),
+    setItem: (k, v) => { set(KV + k, String(v)) },
+    removeItem: (k) => { del(KV + k) }
+  }
+
+  const keyStore = {
+    async get (name) {
+      const raw = mem.get(KEY + name)
+      return raw ? JSON.parse(raw) : null
+    },
+    async set (name, rec) { await set(KEY + name, JSON.stringify(plainKeyRecord(rec))) },
+    async remove (name) { await del(KEY + name) }
+  }
+
+  // El libro de contactos por perfil (`peerStore.useBackend`).
+  const peers = {
+    async get (key) {
+      const raw = mem.get(PEERS + key)
+      return raw ? JSON.parse(raw) : null
+    },
+    async put (key, val) { await set(PEERS + key, JSON.stringify(val)) }
+  }
+
+  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/peerStore.js

@@ -40,6 +40,14 @@ let _pid = null
  */
 let _volatile = false
 
+/**
+ * Otro almacén para el libro, en vez del IndexedDB de la página: el de la app de iOS
+ * (`nativeStore.js`), que es uno para todas las páginas. `{ get(key), put(key, val) }`.
+ * Se pone antes de `initPeerStorage`.
+ */
+let _backend = null
+export function useBackend (b) { _backend = b || null }
+
 /** Registra el callback que marca el estado como "sucio" para el sync. */
 export function onDirty (fn) { _markDirty = fn }
 
@@ -53,6 +61,7 @@ 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) {
+  if (_backend) return   // el almacén de la app nació después: no hay libro viejo que adoptar
   try {
     _idb = _idb || await openIdb()
     let legacy = await idbGet(_idb, IDB_PEERS_KEY) // 'peers.v1' (viejo)
@@ -103,6 +112,11 @@ export async function initPeerStorage () {
   try { if (typeof navigator !== 'undefined' && navigator.storage?.persist) await navigator.storage.persist() }
   catch (_) { /* best-effort */ }
   if (_volatile) { _peers = {}; return _peers }
+  if (_backend) {
+    const stored = await _backend.get(peersKey())
+    _peers = (stored && typeof stored === 'object') ? stored : {}
+    return _peers
+  }
   try {
     _idb = await openIdb()
     const stored = await idbGet(_idb, peersKey()) // peer book DEL perfil activo (namespaceado)
@@ -120,6 +134,13 @@ export async function initPeerStorage () {
 function persistPeers () {
   if (_volatile) return _writeChain   // cuenta volátil: en memoria y en ningún disco
   const key = peersKey()
+  if (_backend) {
+    const snapshot = _peers
+    _writeChain = _writeChain
+      .then(() => _backend.put(key, snapshot))
+      .catch(e => console.warn('[cc-identity] persist (app) failed:', e?.message))
+    return _writeChain
+  }
   if (_fallback || !_idb) {
     try { localStorage.setItem(key, JSON.stringify(_peers)) }
     catch (e) { console.warn('[cc-identity] persist (ls) failed:', e?.message) }

package/vault/vault.js

@@ -15,10 +15,27 @@ import {
 import { createIdentityCore } from './core.js'
 import { pubkeyId } from './capabilities.js'
 import { withExternalKeys, appBridge } from './externalKeys.js'
+import { nativeBackends, adoptPageProfiles, readPageStorage } from './nativeStore.js'
+import { useBackend as usePeerBackend } from './peerStore.js'
 
 ;(async () => {
+  // DENTRO DE LA APP, el puente con el teléfono. En un navegador no está y nada cambia.
+  const idKeys = typeof window !== 'undefined' ? window.DotrinoIdentityKeys : null
+  const bridge = idKeys ? appBridge(idKeys) : null
+  // 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)
+    // 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 = {
+  const kv = native ? native.kv : {
     getItem: (k) => localStorage.getItem(k),
     setItem: (k, v) => localStorage.setItem(k, v),
     removeItem: (k) => localStorage.removeItem(k)
@@ -28,7 +45,7 @@ import { withExternalKeys, appBridge } from './externalKeys.js'
   // IndexedDB (clonado estructurado). Nadie —ni este código, ni un XSS en este
   // origen— puede leer sus bytes; solo firmar/derivar con ellas. Las llaves
   // planas (JWK) viejas de localStorage se migran y se borran (core.js).
-  const baseKeyStore = await (() => new Promise((resolve) => {
+  const baseKeyStore = native ? native.keyStore : await (() => new Promise((resolve) => {
     const req = indexedDB.open('dotrino-identity-keys', 1)
     req.onupgradeneeded = () => req.result.createObjectStore('keys')
     req.onsuccess = () => {
@@ -47,11 +64,10 @@ import { withExternalKeys, appBridge } from './externalKeys.js'
     }
     req.onerror = () => resolve(null) // sin IDB (raro): cae al modo kv legado
   }))()
-  // DENTRO DE LA APP DE ANDROID, las llaves nuevas nacen en el chip del teléfono: una sola
+  // DENTRO DE LA APP (Android e iOS), las llaves nuevas nacen en el chip del teléfono: una sola
   // llave por cuenta, la misma que aprueba en la pantalla nativa (`./externalKeys.js`). El
   // puente solo existe en este origen; en un navegador no está y nada cambia.
-  const idKeys = typeof window !== 'undefined' ? window.DotrinoIdentityKeys : null
-  const keyStore = idKeys && baseKeyStore ? withExternalKeys(baseKeyStore, appBridge(idKeys)) : baseKeyStore
+  const keyStore = bridge && baseKeyStore ? withExternalKeys(baseKeyStore, bridge) : baseKeyStore
 
   // sessionKv: la prueba de desbloqueo del candado por contraseña vive en
   // sessionStorage — POR PESTAÑA: sobrevive al refresco, muere al cerrarla.