@dotrino/identity 0.16.0 → 0.17.0

package/package.json

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

@@ -306,6 +306,22 @@ export class Identity {
     return result
   }
 
+  /**
+   * Actualiza tu PERFIL (merge): `{ nickname?, avatar?, avatarVisible?, links?, fields? }`.
+   * `avatar` = data-URI 250×250 (o null para quitarla); `links`/`fields` = arrays con `visible`
+   * por ítem (oculto = no se comparte). No pisa lo que no mandes.
+   */
+  async updateMe (patch) {
+    const result = await this._call('updateMe', { patch })
+    if (result?.me) this._me = result.me
+    return result
+  }
+
+  /** Tu `me` completo (incluye ocultos). */
+  async getMe () { return this._call('getMe') }
+  /** Subconjunto PÚBLICO de tu perfil (solo lo visible) — para compartir/publicar. */
+  async publicMe () { return this._call('publicMe') }
+
   /** Pubkey ECDH (JWK string) propio para encripción. */
   async getEncryptionPubkey () {
     return this._call('getEncryptionPubkey')

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 {
@@ -165,6 +175,9 @@ export class Identity {
     const result = await this._h('setMyNickname', { nickname })
     return result
   }
+  async updateMe (patch) { return this._h('updateMe', { patch }) }
+  getMe () { return this._h('getMe') }
+  publicMe () { return this._h('publicMe') }
   getEncryptionPubkey () { return this._h('getEncryptionPubkey') }
   encrypt (recipients, plaintext) { return this._h('encrypt', { recipients, plaintext }) }
   decrypt (senderEncryptionPubkey, myToken, envelope) {

package/vault/core.js

@@ -108,6 +108,33 @@ async function verifyBytes (publicJwkStr, bytes, signatureBase64) {
  * @returns {Promise<{ handlers:Object, get me():Object, sync:Object|null,
  *                      onSyncStatus(fn):void }>}
  */
+// Sanea un patch de perfil (avatar/links/fields/nickname). Cada link/field lleva `visible`
+// (oculto = no se comparte). Caps de tamaño para no inflar el `me`. Los ids los pone la UI.
+function sanitizeProfilePatch (patch = {}) {
+  const out = {}
+  if (typeof patch.nickname === 'string') out.nickname = patch.nickname.slice(0, 40)
+  if (patch.avatar === null) out.avatar = null
+  else if (typeof patch.avatar === 'string') out.avatar = patch.avatar.slice(0, 120000) // ~90KB: data-URI 250x250
+  if (typeof patch.avatarVisible === 'boolean') out.avatarVisible = patch.avatarVisible
+  if (Array.isArray(patch.links)) {
+    out.links = patch.links.slice(0, 12).map((l) => ({
+      id: String(l?.id || '').slice(0, 24),
+      type: String(l?.type || 'web').slice(0, 16),
+      value: String(l?.value || '').slice(0, 200),
+      visible: l?.visible !== false
+    })).filter((l) => l.value)
+  }
+  if (Array.isArray(patch.fields)) {
+    out.fields = patch.fields.slice(0, 20).map((f) => ({
+      id: String(f?.id || '').slice(0, 24),
+      label: String(f?.label || '').slice(0, 40),
+      value: String(f?.value || '').slice(0, 280),
+      visible: f?.visible !== false
+    })).filter((f) => f.label || f.value)
+  }
+  return out
+}
+
 export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null }) {
   const {
     initPeerStorage, loadPeers, savePeers, setPeersDirect, upsertPeer, onDirty
@@ -354,6 +381,20 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
 
   // ----- handlers (idénticos a la versión iframe) -----
 
+  // Merge de un patch de perfil en `me` (preserva lo demás), saneado. Refleja el nombre en la
+  // meta del perfil (para el switcher). Devuelve el `me` resultante.
+  function applyMeUpdate (patch) {
+    const clean = sanitizeProfilePatch(patch || {})
+    me = { ...(me || {}), ...clean, publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr }
+    if (clean.avatar === null) delete me.avatar
+    saveMe(me)
+    if (typeof clean.nickname === 'string') {
+      const list = loadProfiles(); const e = list.find((p) => p.id === currentPid)
+      if (e && e.name !== clean.nickname) { e.name = clean.nickname; saveProfiles(list) }
+    }
+    return me
+  }
+
   const handlers = {
     async makeChallenge () {
       const nonce = crypto.randomUUID()
@@ -656,9 +697,24 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     },
 
     async setMyNickname ({ nickname }) {
-      const next = { publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr, nickname: String(nickname || '').slice(0, 40) }
-      saveMe(next)
-      return { me: next }
+      return { me: applyMeUpdate({ nickname }) }
+    },
+
+    // Perfil completo (avatar 250x250, links de redes, datos), cada ítem con `visible`
+    // (oculto = no se comparte). Merge: no pisa lo que no venga en el patch.
+    async updateMe ({ patch } = {}) {
+      return { me: applyMeUpdate(patch || {}) }
+    },
+    async getMe () { return me },
+    // Subconjunto PÚBLICO del perfil (solo lo marcado visible) — para compartir/publicar.
+    async publicMe () {
+      const m = me || {}
+      const out = { publickey: m.publickey, encryptionPubkey: m.encryptionPubkey }
+      if (m.nickname) out.nickname = m.nickname
+      if (m.avatar && m.avatarVisible !== false) out.avatar = m.avatar
+      if (Array.isArray(m.links)) { const v = m.links.filter((l) => l.visible !== false).map(({ visible, ...r }) => r); if (v.length) out.links = v }
+      if (Array.isArray(m.fields)) { const v = m.fields.filter((f) => f.visible !== false).map(({ visible, ...r }) => r); if (v.length) out.fields = v }
+      return out
     },
 
     async getEncryptionPubkey () { return encPublickeyJwkStr },
@@ -752,17 +808,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