@dotrino/identity 0.103.0 → 0.104.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.103.0",
+  "version": "0.104.0",
   "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,80 @@
+/**
+ * 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 }
+}

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,20 @@ import {
 import { createIdentityCore } from './core.js'
 import { pubkeyId } from './capabilities.js'
 import { withExternalKeys, appBridge } from './externalKeys.js'
+import { nativeBackends } 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)
+
   // 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 +38,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 +57,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.