@dotrino/identity 0.14.0 → 0.16.0

package/package.json

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

@@ -259,6 +259,23 @@ export class Identity {
     return this.on('vault', handler)
   }
 
+  // ----- multi-perfil por dispositivo -----
+  // Podés tener varios perfiles (identidades) en el mismo navegador, cada uno conectado o no
+  // a su propio vault. Crear/cambiar setea el perfil activo; la app RECARGA la página y toma
+  // el nuevo (no reactivo: las apps abiertas conservan el perfil con el que cargaron).
+  /** Lista de perfiles: [{ id, name, pubkey, current }]. */
+  async listProfiles () { return this._call('listProfiles') }
+  /** El perfil activo: { id, name, pubkey }. */
+  async currentProfile () { return this._call('currentProfile') }
+  /** Crea un perfil nuevo (identidad fresca) y lo deja activo. La app debe recargar. */
+  async createProfile (name) { return this._call('createProfile', { name }) }
+  /** Cambia el perfil activo. La app debe recargar la página. */
+  async switchProfile (id) { return this._call('switchProfile', { id }) }
+  /** Renombra un perfil (o el activo si no se pasa id). */
+  async renameProfile (id, name) { return this._call('renameProfile', { id, name }) }
+  /** Borra un perfil y sus datos (no el único). */
+  async deleteProfile (id) { return this._call('deleteProfile', { id }) }
+
   /**
    * Merge endorsements (signed ratings from third parties) about a subject
    * into the local peer book. Returns { merged, total }.
@@ -426,4 +443,4 @@ export class Identity {
 
 // Helpers de capacidad SIN clave maestra (lado dispositivo + verificación), reutilizables
 // por apps/bridges sin cargar el iframe del vault.
-export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'
+export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, avatarSvg, avatarDataUri, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'

package/src/node.js

@@ -41,14 +41,19 @@ function fileKv (filePath) {
 function filePeers (filePath) {
   let peers = {}
   let markDirty = null
+  let pid = null // multi-perfil: el peer book se namespacea por perfil
+  const fileFor = () => pid ? path.join(path.dirname(filePath), `peers.${pid}.json`) : filePath
   const flush = () => {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true })
-    fs.writeFileSync(filePath, JSON.stringify(peers))
+    const f = fileFor()
+    fs.mkdirSync(path.dirname(f), { recursive: true })
+    fs.writeFileSync(f, JSON.stringify(peers))
   }
   return {
+    setProfile (p) { pid = p || null },
     async initPeerStorage () {
+      const f = fileFor()
       try {
-        if (fs.existsSync(filePath)) peers = JSON.parse(fs.readFileSync(filePath, 'utf8')) || {}
+        peers = (fs.existsSync(f)) ? (JSON.parse(fs.readFileSync(f, 'utf8')) || {}) : {}
       } catch (_) { peers = {} }
       return peers
     },
@@ -144,6 +149,13 @@ export class Identity {
   listVaultDevices () { return this._h('listVaultDevices') }
   getVaultCert () { return this._h('getVaultCert') }
   onVault (handler) { return this.on('vault', handler) }
+  // Multi-perfil por dispositivo (crear/cambiar reinicializa con el nuevo perfil activo).
+  listProfiles () { return this._h('listProfiles') }
+  currentProfile () { return this._h('currentProfile') }
+  createProfile (name) { return this._h('createProfile', { name }) }
+  switchProfile (id) { return this._h('switchProfile', { id }) }
+  renameProfile (id, name) { return this._h('renameProfile', { id, name }) }
+  deleteProfile (id) { return this._h('deleteProfile', { id }) }
   mergeEndorsements (subject, endorsements, askerPubkey) {
     return this._h('mergeEndorsements', { subject, endorsements, askerPubkey })
   }
@@ -186,4 +198,4 @@ export default Identity
 
 // Helpers de capacidad SIN clave maestra (lado dispositivo + verificación), para que
 // un bridge/bot Node pueda crear su clave, firmar acciones y verificar cadenas D←P.
-export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'
+export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, avatarSvg, avatarDataUri, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'

package/vault/capabilities.js

@@ -99,6 +99,50 @@ export async function commitCode ({ code, dpub, sn }) {
   return [...new Uint8Array(h)].map((x) => x.toString(16).padStart(2, '0')).join('')
 }
 
+/**
+ * Avatar generado (identicon de Dotrino): SVG DETERMINISTA a partir de una semilla
+ * (típicamente el pubkey del perfil) → cada perfil/identidad nace con imagen, sin que el
+ * usuario tenga que subir nada. Síncrono (hash FNV-1a + xorshift, sin necesidades de
+ * seguridad: es solo decorativo) → usable directo en plantillas. Rejilla 5×5 simétrica
+ * sobre una "moneda" redondeada, con color derivado del hash.
+ */
+function _hashSeed (s) {
+  let h = 2166136261 >>> 0
+  for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 16777619) }
+  const bytes = []
+  let x = (h ^ 0x9e3779b9) >>> 0
+  for (let i = 0; i < 16; i++) { x ^= x << 13; x ^= x >>> 17; x ^= x << 5; x >>>= 0; bytes.push(x & 0xff) }
+  return { h: h >>> 0, bytes }
+}
+export function avatarSvg (seed, { size = 80 } = {}) {
+  const { h, bytes } = _hashSeed(String(seed || 'dotrino'))
+  const hue = h % 360
+  const hue2 = (hue + 40) % 360
+  const fg = `hsl(${hue} 62% 46%)`
+  const bg1 = `hsl(${hue} 48% 95%)`
+  const bg2 = `hsl(${hue2} 48% 90%)`
+  const cells = 5
+  const unit = size / cells
+  let rects = ''
+  for (let col = 0; col < 3; col++) {
+    for (let row = 0; row < cells; row++) {
+      if (!(bytes[col * cells + row] & 1)) continue
+      for (const c of (col === 2 ? [2] : [col, cells - 1 - col])) {
+        rects += `<rect x="${(c * unit).toFixed(2)}" y="${(row * unit).toFixed(2)}" width="${unit.toFixed(2)}" height="${unit.toFixed(2)}"/>`
+      }
+    }
+  }
+  const id = 'g' + (h % 100000)
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}">` +
+    `<defs><linearGradient id="${id}" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="${bg1}"/><stop offset="1" stop-color="${bg2}"/></linearGradient></defs>` +
+    `<rect width="${size}" height="${size}" rx="${(size * 0.5).toFixed(2)}" fill="url(#${id})"/>` +
+    `<g fill="${fg}" transform="translate(${(size * 0.12).toFixed(2)} ${(size * 0.12).toFixed(2)}) scale(0.76)">${rects}</g></svg>`
+}
+/** El avatar como data-URI listo para `<img src>` o `background-image`. */
+export function avatarDataUri (seed, opts) {
+  return 'data:image/svg+xml,' + encodeURIComponent(avatarSvg(seed, opts))
+}
+
 /** Cuerpo canónico del certificado (lo que se firma): el cert SIN la firma. */
 export function delegationBody (cert) {
   return { v: cert.v, iss: cert.iss, sub: cert.sub, scope: cert.scope, iat: cert.iat, exp: cert.exp, nonce: cert.nonce }

package/vault/core.js

@@ -29,6 +29,10 @@ export const DELEGATIONS_STORAGE = 'dotrino.identity.delegations'   // caps emit
 export const REVOCATIONS_STORAGE = 'dotrino.identity.revocations'   // nonces revocados
 export const VAULT_DEVICE_STORAGE = 'dotrino.identity.vault.device' // sub-clave D de ESTE dispositivo (custodia en el iframe)
 export const VAULT_CERT_STORAGE = 'dotrino.identity.vault.cert'     // { cert, master, proxy, deviceId, pairedAt }
+// Multi-perfil por dispositivo: lista de perfiles + el activo. Cada perfil tiene su propio
+// namespace `dotrino.identity.p.<id>.<suffix>` para TODAS las claves de arriba (keypair, me, etc.).
+export const PROFILES_STORAGE = 'dotrino.identity.profiles' // [{ id, name, pubkey }]
+export const CURRENT_STORAGE = 'dotrino.identity.current'   // id del perfil activo
 
 const NONCE_TTL_MS = 5 * 60 * 1000
 
@@ -104,11 +108,27 @@ async function verifyBytes (publicJwkStr, bytes, signatureBase64) {
  * @returns {Promise<{ handlers:Object, get me():Object, sync:Object|null,
  *                      onSyncStatus(fn):void }>}
  */
-export async function createIdentityCore ({ kv, peers, makeSync = null }) {
+export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null }) {
   const {
     initPeerStorage, loadPeers, savePeers, setPeersDirect, upsertPeer, onDirty
   } = peers
 
+  // ----- multi-perfil: kv SCOPEADO por el perfil activo -----
+  // Todas las claves `dotrino.identity.*` (keypair, me, nonces, delegations, vault.*) se
+  // namespacean transparentemente bajo `dotrino.identity.p.<currentPid>.*`. Las dos claves
+  // globales (lista de perfiles + activo) usan el kv crudo. Cambiar de perfil = setear el
+  // activo; la app recarga la página y re-inicializa con el nuevo (no reactivo, por diseño).
+  let currentPid = null
+  const _scoped = (k) => (!currentPid || k === PROFILES_STORAGE || k === CURRENT_STORAGE)
+    ? k : k.replace(/^dotrino\.identity\./, `dotrino.identity.p.${currentPid}.`)
+  const kv = {
+    getItem: (k) => rawKv.getItem(_scoped(k)),
+    setItem: (k, v) => rawKv.setItem(_scoped(k), v),
+    removeItem: (k) => rawKv.removeItem(_scoped(k))
+  }
+  const loadProfiles = () => { try { return JSON.parse(rawKv.getItem(PROFILES_STORAGE) || '[]') || [] } catch { return [] } }
+  const saveProfiles = (list) => rawKv.setItem(PROFILES_STORAGE, JSON.stringify(list))
+
   // ----- keypair loaders (kv-backed) -----
 
   async function loadOrCreateKeypair () {
@@ -175,6 +195,16 @@ export async function createIdentityCore ({ kv, 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 } }
 
@@ -511,6 +541,54 @@ export async function createIdentityCore ({ kv, peers, makeSync = null }) {
       }
     },
 
+    // ----- perfiles (multi-perfil por dispositivo) -----
+    // Cambiar/crear setea el perfil activo; la app RECARGA la página y re-inicializa con él
+    // (no reactivo, por diseño). Las apps abiertas conservan el perfil con el que cargaron.
+    async listProfiles () {
+      return loadProfiles().map((p) => ({ id: p.id, name: p.name || '', pubkey: p.pubkey || null, current: p.id === currentPid }))
+    },
+    async currentProfile () {
+      const e = loadProfiles().find((p) => p.id === currentPid) || {}
+      return { id: currentPid, name: e.name || me?.nickname || '', pubkey: publickeyJwkStr }
+    },
+    async createProfile ({ name } = {}) {
+      const pid = 'p' + crypto.randomUUID().slice(0, 8)
+      currentPid = pid
+      rawKv.setItem(CURRENT_STORAGE, pid)
+      await peers.setProfile?.(pid)
+      await initPeerStorage()
+      keypair = await loadOrCreateKeypair(); publickeyJwkStr = JSON.stringify(keypair.publicJwk)
+      encKeypair = await loadOrCreateEncKeypair(); encPublickeyJwkStr = JSON.stringify(encKeypair.publicJwk)
+      me = { publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr, nickname: String(name || '').slice(0, 40) }
+      saveMe(me)
+      const list = loadProfiles(); list.push({ id: pid, name: me.nickname, pubkey: publickeyJwkStr }); saveProfiles(list)
+      return { id: pid, name: me.nickname, pubkey: publickeyJwkStr }
+    },
+    async switchProfile ({ id } = {}) {
+      if (!loadProfiles().find((p) => p.id === id)) throw new Error('perfil no existe')
+      rawKv.setItem(CURRENT_STORAGE, id) // la app recarga la página → re-init con el nuevo perfil
+      return { id }
+    },
+    async renameProfile ({ id, name } = {}) {
+      const list = loadProfiles(); const e = list.find((p) => p.id === (id || currentPid))
+      if (!e) throw new Error('perfil no existe')
+      e.name = String(name || '').slice(0, 40); saveProfiles(list)
+      if (e.id === currentPid) { me = { ...(me || {}), nickname: e.name }; saveMe(me) }
+      return { id: e.id, name: e.name }
+    },
+    async deleteProfile ({ id } = {}) {
+      let list = loadProfiles()
+      if (list.length <= 1) throw new Error('no se puede borrar el único perfil')
+      if (!list.find((p) => p.id === id)) throw new Error('perfil no existe')
+      list = list.filter((p) => p.id !== id); saveProfiles(list)
+      // Borrado directo del namespace del perfil (incluye su store del vault si lo tuviera).
+      for (const s of ['keypair', 'enc-keypair', 'me', 'nonces', 'delegations', 'revocations', 'vault.device', 'vault.cert']) {
+        rawKv.removeItem(`dotrino.identity.p.${id}.${s}`)
+      }
+      if (currentPid === id) { currentPid = list[0].id; rawKv.setItem(CURRENT_STORAGE, currentPid) }
+      return { ok: true, current: currentPid }
+    },
+
     // ----- emparejar ESTE dispositivo con el vault del usuario (Fase 1) -----
     // Genera D aquí dentro (su privada NUNCA sale de la identidad), hace el enroll
     // endurecido por el proxy y guarda el cert. NO cambia signData todavía (Fase 2).
@@ -545,7 +623,8 @@ export async function createIdentityCore ({ kv, 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).
@@ -553,14 +632,16 @@ export async function createIdentityCore ({ kv, 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`
@@ -671,6 +752,24 @@ export async function createIdentityCore ({ kv, 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.
+  {
+    let profiles = loadProfiles()
+    currentPid = rawKv.getItem(CURRENT_STORAGE)
+    if (!profiles.length) {
+      currentPid = 'p' + crypto.randomUUID().slice(0, 8)
+      profiles = [{ id: currentPid, name: '', pubkey: null }]
+      saveProfiles(profiles)
+      rawKv.setItem(CURRENT_STORAGE, currentPid)
+    } else if (!currentPid || !profiles.find((p) => p.id === currentPid)) {
+      currentPid = profiles[0].id
+      rawKv.setItem(CURRENT_STORAGE, currentPid)
+    }
+  }
+  await peers.setProfile?.(currentPid)
+
   keypair = await loadOrCreateKeypair()
   publickeyJwkStr = JSON.stringify(keypair.publicJwk)
   encKeypair = await loadOrCreateEncKeypair()
@@ -690,6 +789,14 @@ export async function createIdentityCore ({ kv, peers, makeSync = null }) {
     kv.setItem(ME_STORAGE, JSON.stringify(me))
   }
 
+  // Registrar el pubkey (y nombre) del perfil activo en su meta → para avatar/listado sin abrir cada perfil.
+  {
+    const list = loadProfiles(); const e = list.find((p) => p.id === currentPid)
+    if (e && (e.pubkey !== publickeyJwkStr || (!e.name && me?.nickname))) {
+      e.pubkey = publickeyJwkStr; if (!e.name && me?.nickname) e.name = me.nickname; saveProfiles(list)
+    }
+  }
+
   if (typeof makeSync === 'function') {
     sync = makeSync({
       fileName: 'dotrino-identity-backup.json',

package/vault/peerStore.js

@@ -31,10 +31,15 @@ let _fallback = false
 let _idb = null
 let _writeChain = Promise.resolve()
 let _markDirty = null
+let _pid = null
 
 /** Registra el callback que marca el estado como "sucio" para el sync. */
 export function onDirty (fn) { _markDirty = fn }
 
+/** Multi-perfil: namespacea el peer book por perfil. El core lo llama antes de initPeerStorage. */
+export function setProfile (pid) { _pid = pid || null }
+function peersKey () { return _pid ? `peers.${_pid}.v1` : IDB_PEERS_KEY }
+
 function openIdb () {
   return new Promise((resolve, reject) => {
     let req
@@ -74,43 +79,28 @@ export async function initPeerStorage () {
   catch (_) { /* best-effort */ }
   try {
     _idb = await openIdb()
-    const stored = await idbGet(_idb, IDB_PEERS_KEY)
-    const storedPeers = (stored && typeof stored === 'object') ? stored : {}
-    const migratedFlag = await idbGet(_idb, IDB_MIGRATED_KEY)
-    if (migratedFlag) {
-      // Ya reconciliado: IndexedDB es la fuente de verdad (ignora el LS viejo).
-      _peers = storedPeers
-    } else {
-      // Primera corrida (o reintento tras el bug que escribía {}): unimos el
-      // peer book del localStorage viejo con lo que haya en IndexedDB —unión,
-      // IndexedDB gana en conflictos— para recuperar contactos que un bug previo
-      // pudo enmascarar. Nunca borra. Marcamos el flag para no rehacerlo (así no
-      // se "resucitan" contactos que el usuario borre más adelante).
-      const local = readLocalPeers()
-      _peers = { ...local, ...storedPeers }
-      const recovered = Object.keys(local).filter(k => !(k in storedPeers)).length
-      await idbPut(_idb, IDB_PEERS_KEY, _peers)
-      await idbPut(_idb, IDB_MIGRATED_KEY, true)
-      if (recovered) console.log(`[cc-identity] ${recovered} peer(s) recuperados del localStorage viejo → IndexedDB`)
-    }
+    const stored = await idbGet(_idb, peersKey()) // peer book DEL perfil activo (namespaceado)
+    _peers = (stored && typeof stored === 'object') ? stored : {}
   } catch (e) {
     console.warn('[cc-identity] IndexedDB no disponible, uso localStorage:', e?.message)
     _fallback = true
     _idb = null
-    _peers = readLocalPeers()
+    try { const raw = localStorage.getItem(peersKey()); _peers = raw ? (JSON.parse(raw) || {}) : {} }
+    catch (_) { _peers = {} }
   }
   return _peers
 }
 
 function persistPeers () {
+  const key = peersKey()
   if (_fallback || !_idb) {
-    try { localStorage.setItem(PEERS_STORAGE, JSON.stringify(_peers)) }
+    try { localStorage.setItem(key, JSON.stringify(_peers)) }
     catch (e) { console.warn('[cc-identity] persist (ls) falló:', e?.message) }
     return _writeChain
   }
   const snapshot = _peers
   _writeChain = _writeChain
-    .then(() => idbPut(_idb, IDB_PEERS_KEY, snapshot))
+    .then(() => idbPut(_idb, key, snapshot))
     .catch(e => console.warn('[cc-identity] persist (idb) falló:', e?.message))
   return _writeChain
 }
@@ -143,5 +133,5 @@ export function upsertPeer (publickey, patch) {
 // Sólo para tests: resetea el estado del módulo (y cierra la conexión IDB).
 export function _resetForTest () {
   try { if (_idb && _idb.close) _idb.close() } catch (_) {}
-  _peers = {}; _fallback = false; _idb = null; _writeChain = Promise.resolve(); _markDirty = null
+  _peers = {}; _fallback = false; _idb = null; _writeChain = Promise.resolve(); _markDirty = null; _pid = null
 }