@dotrino/identity 0.38.0 → 0.40.0

package/package.json

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

@@ -278,6 +278,7 @@ export class Identity {
 
   /** Cambia las capacidades de un miembro (solo el master). */
   async setCaps (pub, caps) { return this._call('setCaps', { pub, caps }) }
+  async setLabel (pub, label) { return this._call('setLabel', { pub, label }) }
 
   /** Expulsa a un miembro (solo el master; al master no se le puede expulsar). */
   async removeMember (pub) { return this._call('removeMember', { pub }) }

package/src/node.js

@@ -168,6 +168,7 @@ export class Identity {
   isMaster () { return this._h('isMaster') }
   admitMember (member) { return this._h('admitMember', member) }
   setCaps (pub, caps) { return this._h('setCaps', { pub, caps }) }
+  setLabel (pub, label) { return this._h('setLabel', { pub, label }) }
   removeMember (pub) { return this._h('removeMember', { pub }) }
   handoverMaster (to, member = null) { return this._h('handoverMaster', { to, member }) }
   renounceCaps (caps) { return this._h('renounceCaps', { caps }) }

package/vault/acta.js

@@ -247,6 +247,17 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         m.caps = cleanCaps(ch.caps).filter((c) => (m.cn ? SERVICE_CAPS : DEVICE_CAPS).includes(c))
         break
       }
+      case 'label': {
+        // RENOMBRAR un miembro. La etiqueta se escribía solo al admitir, con lo que el
+        // aparato se quedaba para siempre con el nombre que tuviera el día que entró
+        // (normalmente el apodo del usuario en ese momento), y para cambiarlo había que
+        // revocarlo y volver a emparejarlo. Es un nombre para el humano: no toca permisos
+        // ni llaves, pero se sella y se firma como cualquier otro cambio del acta.
+        const m = find(ch.pub)
+        if (!m) throw new Error('label: that member is not in the record')
+        m.label = String(ch.label || '').slice(0, 60)
+        break
+      }
       case 'remove': {
         const i = next.members.findIndex((m) => m.pub === ch.pub)
         if (i < 0) throw new Error('remove: that member is not in the record')

package/vault/core.js

@@ -543,21 +543,49 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   const RENEW_WINDOW_MS = 15 * 24 * 60 * 60 * 1000
   const RENEW_RETRY_MS = 60 * 60 * 1000 // si falla (vault apagado), no insistir >1 vez/hora
   let renewLastTry = 0
+  /**
+   * ¿El cert se quedó atrás respecto del ACTA? El acta es la política (lo que el dueño
+   * decidió); el cert es su reflejo, y solo se refresca al renovar. Sin esta comprobación,
+   * un permiso concedido después de emparejar tardaba en llegar lo que tardara el cert en
+   * acercarse a su caducidad: hasta 30 días. En la práctica, dar «administra» y no ver
+   * NUNCA aparecer la consola remota.
+   */
+  function certDesfasadoDelActa () {
+    try {
+      const v = loadVaultCert(); const acta = loadActa()
+      if (!v?.cert || !acta) return false
+      const debeTener = Acta.memberScopes(acta, publickeyJwkStr)
+      if (!debeTener.length) return false           // ya no soy miembro: renovar no toca
+      const tiene = new Set(v.cert.scope || [])
+      return debeTener.length !== tiene.size || debeTener.some((s) => !tiene.has(s))
+    } catch (_) { return false }
+  }
+
   function maybeRenewVaultCert () {
     try {
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) return
       const now = Date.now()
-      if (v.cert.exp <= now || v.cert.exp - now > RENEW_WINDOW_MS) return
+      // Se renueva por dos motivos: porque el cert se acerca a su fin, o porque el acta
+      // dice que este aparato puede algo distinto de lo que lleva escrito el cert.
+      const porCaducar = v.cert.exp > now && v.cert.exp - now <= RENEW_WINDOW_MS
+      if (v.cert.exp <= now || (!porCaducar && !certDesfasadoDelActa())) return
       if (now - renewLastTry < RENEW_RETRY_MS) return
-      renewLastTry = now
-      remoteRenew({ master: v.master, proxy: v.proxy, device, cert: v.cert, onRevoked: wipeVaultLink }).then(({ cert }) => {
-        kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ ...v, cert, renewedAt: Date.now() }))
-        emitVault({ phase: 'renewed', exp: cert.exp })
-      }).catch(() => {}) // best-effort: el cert vigente sigue sirviendo mientras tanto
+      renovarCert().catch(() => {}) // best-effort: el cert vigente sigue sirviendo mientras tanto
     } catch (_) {}
   }
 
+  /** Pide un cert fresco y lo guarda. Devuelve promesa para poder ESPERARLO cuando hace falta. */
+  async function renovarCert () {
+    const v = loadVaultCert(); const device = loadVaultDevice()
+    if (!v?.cert || !device) return null
+    renewLastTry = Date.now()
+    const { cert } = await remoteRenew({ master: v.master, proxy: v.proxy, device, cert: v.cert, onRevoked: wipeVaultLink })
+    kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ ...v, cert, renewedAt: Date.now() }))
+    emitVault({ phase: 'renewed', exp: cert.exp })
+    return cert
+  }
+
   // ----- me (kv-backed) -----
 
   function loadMe () {
@@ -1191,6 +1219,22 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { ok: true, seq: acta.seq }
     },
 
+    /**
+     * RENOMBRA un miembro (el nombre con el que lo reconoces). Se escribe en el acta y
+     * TAMBIÉN en la delegación: son dos registros distintos —el acta dice quién es del
+     * perfil, las delegaciones qué certs se emitieron— y las listas de dispositivos leen
+     * la segunda, así que tocar solo una deja el nombre viejo a la vista.
+     */
+    async setLabel ({ pub, label } = {}) {
+      const limpio = String(label || '').slice(0, 60)
+      const acta = await sealChanges([{ op: 'label', pub, label: limpio }])
+      const store = loadDelegations()
+      let tocadas = 0
+      for (const d of Object.values(store)) { if (d.sub === pub) { d.label = limpio; tocadas++ } }
+      if (tocadas) saveDelegations(store)
+      return { ok: true, seq: acta.seq, label: limpio, delegations: tocadas }
+    },
+
     async removeMember ({ pub } = {}) {
       const acta = await sealChanges([{ op: 'remove', pub }])
       // Expulsar rota la clave: el que sale no podrá abrir el contenido NUEVO. Lo que ya
@@ -1512,7 +1556,12 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * cert que le dio la bóveda, no de una preferencia: la interfaz pregunta para
      * saber qué pintar, pero quien decide es la bóveda al recibir la petición.
      */
-    canAdminVault () {
+    async canAdminVault () {
+      // Si el acta ya dice que este aparato administra pero el cert todavía no, se ESPERA a
+      // renovarlo aquí mismo. Disparar la renovación y contestar «no» dejaba la consola
+      // escondida hasta la siguiente visita, y el dueño —que acababa de dar el permiso— no
+      // tenía forma de saber que solo faltaba recargar.
+      if (certDesfasadoDelActa()) { try { await renovarCert() } catch (_) {} }
       const v = loadVaultCert()
       return !!v?.cert && (v.cert.scope || []).includes('vault:admin')
     },
@@ -1530,6 +1579,10 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
           if (res.chain?.length && res.chain[0].profileId === loadActa()?.profileId) await adoptChain(res.chain)
           else if (res.acta) await (res.acta.profileId === loadActa()?.profileId ? adoptActa(res.acta) : joinProfile(res.acta))
         } catch (_) {}
+        // El acta acaba de llegar: si trae permisos que el cert no lleva, se renueva YA. La
+        // comprobación de arriba corrió ANTES de tenerla, así que sin esto haría falta una
+        // segunda visita para estrenar un permiso recién concedido.
+        maybeRenewVaultCert()
         return res
       } catch (e) { return handleVaultError(e) }
     },