@dotrino/identity 0.86.2 → 0.88.0

package/README.md

@@ -168,10 +168,20 @@ ceremonia, no seguridad. Cualquier **dato tuyo** —nombre, foto, correo, enlace
 cosa: hace falta que lo concedas a ESE origen, y lo concedido se guarda y se puede retirar.
 
 ```js
-await id.listGrants()          // [{ origin, scopes, at }]
+await id.listGrants()          // [{ origin, scopes, at, lastUsed, onBehalfOf? }]
 await id.revokeGrant(origin)   // y la próxima vez se vuelve a preguntar
 ```
 
+`lastUsed` se apunta cada vez que ese origen pide una prueba, **aunque solo pida el
+mínimo**: entrar es usar, lleve datos o no. Sin ese dato, «dónde se usó mi identidad» solo
+podría decir qué concediste, no si sigue usándose — que es lo que hace que uno se decida a
+retirar un permiso que ya no hace falta.
+
+`onBehalfOf` lo declara el origen cuando pide **por otro** (lo usa el puente OIDC, que pide
+por una aplicación de fuera; sin esto todas ellas se verían como una sola entrada). Es una
+afirmación suya, no un hecho comprobable, así que se enseña siempre subordinada al origen —
+«Tal App · a través de sso.dotrino.com»— y nunca en su lugar.
+
 **El panel lo pinta la bóveda, no la aplicación.** Vive en otro origen, así que la página
 que pide no puede pulsar ahí dentro ni leerlo; lo único que puede hacer es no mostrarlo, y
 entonces no consigue el permiso — que es el lado correcto en el que fallar. Sin nadie a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.86.2",
+  "version": "0.88.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/src/index.d.ts

@@ -123,9 +123,9 @@ export class Identity {
   removeContact (publickey: string): Promise<PeerInfo | null>
   listContacts (): Promise<PeerInfo[]>
   signData (data: any): Promise<{ signature: string; publickey: string }>
-  requestAssertion (args: { audience: string; nonce: string; scopes?: AssertionScope[]; ttlMs?: number }): Promise<Assertion>
+  requestAssertion (args: { audience: string; nonce: string; scopes?: AssertionScope[]; ttlMs?: number; onBehalfOf?: string }): Promise<Assertion>
   /** Qué le has concedido a cada aplicación (permiso por origen). */
-  listGrants (): Promise<Array<{ origin: string; scopes: AssertionScope[]; at: number }>>
+  listGrants (): Promise<Array<{ origin: string; scopes: AssertionScope[]; at: number; lastUsed: number; onBehalfOf?: string }>>
   /** Retirar lo concedido a un origen: la próxima vez que pida, se vuelve a preguntar. */
   revokeGrant (origin: string): Promise<{ ok: boolean }>
   setMyNickname (nickname: string): Promise<{ me: Me }>
@@ -167,6 +167,11 @@ export class Identity {
   vaultSign (payload: any): Promise<{ signature: string; publickey: string }>
   vaultStore (method: string, args?: any): Promise<any>
   listVaultDevices (): Promise<{ devices: any[]; revoked: any[] }>
+  /** Pedidos de aprobación de la cuenta activa (o de otra, con `profile`). */
+  vaultApprovals (op: 'approvals' | 'approve' | 'deny', args?: { id?: string; profile?: string }): Promise<any>
+  /** Los pedidos de TODAS las cuentas de este dispositivo que aprueban, sin cambiar la activa. */
+  vaultApprovalsAll (): Promise<Array<{ profile: string; name: string; current: boolean; items: any[]; error?: string }>>
+  canApproveVault (): Promise<boolean>
   getVaultCert (): Promise<any>
   onVault (handler: (payload: any) => void): () => void
   // self-vault (este dispositivo ES el vault, daemon dentro del iframe)

package/src/index.js

@@ -277,14 +277,14 @@ export class Identity {
   /** Retirar lo concedido a un origen: la próxima vez que pida, se vuelve a preguntar. */
   async revokeGrant (origin) { return this._call('revokeGrant', { origin }) }
 
-  async requestAssertion ({ audience, nonce, scopes, ttlMs } = {}) {
+  async requestAssertion ({ audience, nonce, scopes, ttlMs, onBehalfOf } = {}) {
     // ESPERA LO QUE TARDE UNA PERSONA. Los cinco segundos de siempre valen para una
     // llamada que solo hace cuentas; esta puede abrir la pantalla de permiso (§permiso por
     // origen) y ahí quien contesta es un humano. Con el plazo corto, el cliente se rendía
     // con «Vault timeout» mientras el usuario todavía miraba el panel — y pulsar «Permitir»
     // ya no servía de nada. El tope es un poco mayor que el del propio panel, para que el
     // error que llegue sea «no lo concedió», que dice lo que pasó.
-    const { assertion } = await this._call('requestAssertion', { audience, nonce, scopes, ttlMs }, 65000)
+    const { assertion } = await this._call('requestAssertion', { audience, nonce, scopes, ttlMs, onBehalfOf }, 65000)
     return assertion
   }
 
@@ -463,11 +463,29 @@ export class Identity {
   /**
    * PEDIDOS DE APROBACIÓN de la bóveda (cajones con `approval`): `op` = `approvals` ·
    * `approve` · `deny` (estos dos con `{ id }`). Requiere `vault:approve` en el cert.
+   *
+   * `args.profile` apunta a OTRA cuenta de este dispositivo (la que diga
+   * `vaultApprovalsAll`); sin él es la activa.
    */
   async vaultApprovals (op, args) {
     return this._call('vaultApprovals', { op, ...(args || {}) }, 20000)
   }
 
+  /**
+   * LOS PEDIDOS DE TODAS TUS CUENTAS, SIN CAMBIARTE DE CUENTA.
+   *
+   * Una entrada por cuenta de este dispositivo que pueda aprobar: `{ profile, name,
+   * current, items }`, o `{ ..., error }` si a esa no se le pudo preguntar. El timbre no
+   * dice a qué cuenta llamó, así que quien enseña Pedidos tiene que mirar en todas —y
+   * hacerlo cambiando la cuenta activa significaba una recarga por cuenta, con el avatar
+   * y el icono de la app cambiando a la vista.
+   *
+   * Aprobar uno de otra cuenta: `vaultApprovals('approve', { id, profile })`.
+   */
+  async vaultApprovalsAll () {
+    return this._call('vaultApprovalsAll', {}, 30000)
+  }
+
   /** Registra el token de push de la app nativa (FCM/APNs) bajo la llave de este aparato. */
   async registerPush (args) {
     return this._call('registerPush', args || {}, 20000)

package/src/node.js

@@ -257,6 +257,9 @@ export class Identity {
   vaultStore (method, args) { return this._h('vaultStore', { method, args }) }
   listVaultDevices () { return this._h('listVaultDevices') }
   getVaultCert () { return this._h('getVaultCert') }
+  vaultApprovals (op, args) { return this._h('vaultApprovals', { op, ...(args || {}) }) }
+  /** Los pedidos de TODAS las cuentas que aprueban, sin cambiar la activa. */
+  vaultApprovalsAll () { return this._h('vaultApprovalsAll') }
   onVault (handler) { return this.on('vault', handler) }
   // Multi-perfil por dispositivo (crear/cambiar reinicializa con el nuevo perfil activo).
   listProfiles () { return this._h('listProfiles') }

package/vault/core.js

@@ -527,6 +527,42 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     } catch (_) { return null }
   }
 
+  /**
+   * LA LLAVE DE FIRMA DE OTRA CUENTA DE ESTE DISPOSITIVO, sin abrirla ni ponerla activa.
+   *
+   * Existe para poder PREGUNTAR por los pedidos de cada cuenta sin cambiarse a ella (ver
+   * `vaultApprovalsAll`). La privada nunca se ve: en el almacén de llaves es una `CryptoKey`
+   * no extraíble y se devuelve tal cual, para firmar y nada más.
+   *
+   * Tres cosas que NO se hacen aquí, y las tres importan:
+   *
+   * · **No se mueve `currentPid`.** Abrir otra cuenta «un momento» pisa la identidad en
+   *   memoria y además persiste cuál es la activa: cualquier otra llamada que caiga en medio
+   *   se atendería con la cuenta equivocada, y una recarga a mitad te deja en otra cuenta.
+   * · **No se genera ninguna llave.** Si no está, se dice. Un `catch` que cae a `generateKey`
+   *   le cambiaría la identidad a esa cuenta y la dejaría fuera de su propio perfil para
+   *   siempre — el mismo fallo que ya está avisado en `loadOrCreatePair`.
+   * · **No se abre lo sellado.** Una cuenta del camino legado guarda su privada sellada bajo
+   *   su contraseña; sin la frase no hay con qué, y se contesta `profile-locked` en vez de
+   *   fingir que no existe.
+   */
+  async function signerForProfile (pid) {
+    const nombre = KEY_STORAGE.replace(/^dotrino\.identity\./, `dotrino.identity.p.${pid}.`)
+    if (keyStore) {
+      const guardado = await keyStore.get(nombre).catch(() => null)
+      if (guardado?.privateKey && guardado?.publicJwk) {
+        return { publickey: JSON.stringify(guardado.publicJwk), privateKey: guardado.privateKey }
+      }
+    }
+    const raw = rawKv.getItem(nombre)
+    if (raw) {
+      const g = JSON.parse(raw)
+      if (g?.sealed) throw Object.assign(new Error('that profile is locked: its key is sealed under its password'), { code: 'profile-locked' })
+      if (g?.privateJwk && g?.publicJwk) return { publickey: JSON.stringify(g.publicJwk), privateJwk: g.privateJwk }
+    }
+    throw Object.assign(new Error('no signing key stored for that profile'), { code: 'no-key' })
+  }
+
   /** La cuenta de este dispositivo que YA está emparejada con la bóveda `master`, si la hay. */
   const profilePairedWith = (master) => {
     if (!master) return null
@@ -575,6 +611,25 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     if (e && /\brevoked\b/.test(e.message || '')) emitVault({ phase: 'rejected', reason: e.message })
     throw e
   }
+  /**
+   * APROBAR O DENEGAR un pedido de OTRA cuenta de este dispositivo.
+   *
+   * Es el par de `vaultApprovalsAll`: si la pantalla enseña los pedidos de las tres cuentas,
+   * el botón «Aprobar» tiene que funcionar en las tres — si no, seguirías teniendo que
+   * cambiarte, que es lo que esto vino a quitar. Firma con la llave de ESA cuenta y no toca
+   * nada de la activa.
+   *
+   * Solo lo suyo: sin cert o sin `vault:approve` en ese cert, no hay nada que hacer aquí.
+   */
+  async function approvalsDeOtroPerfil (pid, { op, id } = {}) {
+    if (!loadProfiles().some((p) => p.id === pid)) throw Object.assign(new Error('that profile does not exist on this device'), { code: 'no-profile' })
+    const v = vaultCertOf(pid)
+    if (!v?.cert) throw Object.assign(new Error('that profile is not paired with a vault'), { code: 'not-paired' })
+    if (!(v.cert.scope || []).includes('vault:approve')) throw Object.assign(new Error('that profile does not approve requests'), { code: 'no-approve' })
+    const device = await signerForProfile(pid)
+    return remoteApproval({ master: v.master, proxy: v.proxy, device, cert: v.cert, op, id })
+  }
+
   /** Id estable y corto de una llave de cifrado: con esto se indexan las envolturas. */
   const encKeyId = async (encPub) => (await pubkeyIdOf(encPub)).slice(0, 16)
 
@@ -1415,31 +1470,48 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    * lo que ya estuviera concedido y nada más. **No se amplía en silencio**: sin respuesta,
    * la respuesta es no.
    */
-  async function consentFor (origin, pedidos) {
+  async function consentFor (origin, pedidos, onBehalfOf = null) {
     const org = String(origin || '').trim()
+    // APUNTA CUÁNDO SE USÓ. Sin esto, «dónde se usó mi identidad» solo puede decir qué
+    // concediste, no si sigue usándose — y eso es lo que hace que uno se decida a retirar
+    // un permiso que ya no hace falta. Se apunta aunque solo se pida el mínimo: entrar es
+    // usar, lleve datos o no.
+    const marcarUso = () => {
+      if (!org) return
+      const g = loadGrants()
+      const prev = g[org] || { scopes: [], at: Date.now() }
+      g[org] = { ...prev, lastUsed: Date.now(), ...(onBehalfOf ? { onBehalfOf: String(onBehalfOf).slice(0, 60) } : {}) }
+      saveGrants(g)
+    }
     const base = pedidos.filter((s) => s === 'id:whoami')
     const extra = pedidos.filter((s) => s !== 'id:whoami')
-    if (!extra.length) return pedidos
+    if (!extra.length) { marcarUso(); return pedidos }
     // Sin origen no se puede llevar la cuenta de a quién se le concedió qué, así que no se
     // concede nada más que el mínimo. Es el caso de Node y el de una llamada interna.
     if (!org) return base.length ? base : ['id:whoami']
 
     const yaTiene = grantedTo(org)
     const faltan = extra.filter((s) => !yaTiene.includes(s))
-    if (!faltan.length) return pedidos
+    if (!faltan.length) { marcarUso(); return pedidos }
 
     if (typeof askConsent !== 'function') {
       const conocidos = [...base, ...extra.filter((s) => yaTiene.includes(s))]
+      marcarUso()
       return conocidos.length ? conocidos : ['id:whoami']
     }
     let ok = false
-    try { ok = !!(await askConsent({ origin: org, scopes: faltan, already: yaTiene })) } catch (_) { ok = false }
+    try { ok = !!(await askConsent({ origin: org, scopes: faltan, already: yaTiene, onBehalfOf })) } catch (_) { ok = false }
     if (!ok) {
       const conocidos = [...base, ...extra.filter((s) => yaTiene.includes(s))]
+      marcarUso()
       return conocidos.length ? conocidos : ['id:whoami']
     }
     const g = loadGrants()
-    g[org] = { scopes: [...new Set([...yaTiene, ...faltan])].sort(), at: Date.now() }
+    g[org] = {
+      scopes: [...new Set([...yaTiene, ...faltan])].sort(),
+      at: (g[org]?.at) || Date.now(), lastUsed: Date.now(),
+      ...(onBehalfOf ? { onBehalfOf: String(onBehalfOf).slice(0, 60) } : {})
+    }
     saveGrants(g)
     return pedidos
   }
@@ -1709,8 +1781,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async listGrants () {
       const g = loadGrants()
-      return Object.entries(g).map(([origin, v]) => ({ origin, scopes: v?.scopes || [], at: v?.at || 0 }))
-        .sort((a, b) => b.at - a.at)
+      return Object.entries(g).map(([origin, v]) => ({
+        origin, scopes: v?.scopes || [], at: v?.at || 0,
+        lastUsed: v?.lastUsed || v?.at || 0,
+        ...(v?.onBehalfOf ? { onBehalfOf: v.onBehalfOf } : {})
+      })).sort((a, b) => b.lastUsed - a.lastUsed)
     },
     /** Retirar lo concedido a un origen. La próxima vez que pida, se vuelve a preguntar. */
     async revokeGrant ({ origin } = {}) {
@@ -1721,13 +1796,22 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { ok: true }
     },
 
-    async requestAssertion ({ audience, nonce, scopes, ttlMs, __origin } = {}) {
+    /**
+     * `onBehalfOf` es EN NOMBRE DE QUIÉN dice pedir el origen. Lo usa el puente OIDC, que
+     * pide por una aplicación de fuera: sin esto, todas ellas se verían como una sola
+     * entrada («Sso») y el usuario no sabría a quién le está dejando entrar.
+     *
+     * Es una AFIRMACIÓN del origen, no un hecho comprobable — y por eso se enseña siempre
+     * subordinado a él («sso.dotrino.com dice: Tal App»), nunca en su lugar. Quien
+     * responde por lo que pase sigue siendo el origen.
+     */
+    async requestAssertion ({ audience, nonce, scopes, ttlMs, onBehalfOf, __origin } = {}) {
       if (typeof audience !== 'string' || !audience.trim()) throw new Error('audience required')
       if (typeof nonce !== 'string' || !nonce) throw new Error('nonce required')
       const acta = loadActa()
       // A NOMBRE DE QUIÉN va: la identidad es el `profileId`, no la llave de este aparato.
       const sub = acta?.profileId || publickeyJwkStr
-      const granted = await consentFor(__origin, cleanScopes(scopes))
+      const granted = await consentFor(__origin, cleanScopes(scopes), onBehalfOf)
       const permitido = claimsAllowed(granted)
       const claims = {}
       if (permitido.size) {
@@ -2472,8 +2556,12 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * PEDIDOS DE APROBACIÓN: lo que le toca al teléfono cuando un cajón de la bóveda exige
      * el visto bueno por uso. `op`: `approvals` (listar) · `approve` · `deny` (con `id`).
      * Requiere `vault:approve` en el cert, que se concede a mano (`caps <ID> +aprueba`).
+     *
+     * `profile` apunta a OTRA cuenta de este mismo dispositivo (ver `vaultApprovalsAll`):
+     * sin él es la activa, como siempre.
      */
-    async vaultApprovals ({ op, id } = {}) {
+    async vaultApprovals ({ op, id, profile = null } = {}) {
+      if (profile && profile !== currentPid) return approvalsDeOtroPerfil(profile, { op, id })
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
       maybeRenewVaultCert()
@@ -2481,6 +2569,52 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       catch (e) { return handleVaultError(e) }
     },
 
+    /**
+     * LOS PEDIDOS DE TODAS TUS CUENTAS, SIN CAMBIARTE DE CUENTA.
+     *
+     * El timbre del teléfono no dice a qué perfil llamó —viaja por FCM, o sea por Google, y
+     * ahí no se mete nada que identifique al dueño—, así que la pantalla de Pedidos tiene
+     * que mirar en todos los que aprueban. Antes lo hacía cambiando el perfil activo y
+     * recargando la página una vez por cuenta: funcionaba y era insufrible, porque el avatar
+     * y el icono de la app cambiaban dos o tres veces por abrir la pantalla (dueño,
+     * 2026-09-10: «rotan los perfiles, cambia el icono y es molesto»).
+     *
+     * Y era innecesario: **este iframe tiene las llaves de todos los perfiles**. Cada cuenta
+     * guarda la suya en el mismo almacén, bajo su propio nombre, y son `CryptoKey` NO
+     * EXTRAÍBLES: se puede firmar con ellas sin verlas y sin tocar cuál es la activa. Eso es
+     * justo lo que hace falta, y es lo único que se hace aquí.
+     *
+     * Lo que NO hace, a propósito: no renueva certificados ajenos ni borra enlaces ajenos
+     * (eso escribe, y escribir en otra cuenta desde la pantalla de otra es pedir un lío).
+     * Mirar es de solo lectura; si el papel de una cuenta está desfasado, se dice y punto.
+     *
+     * @returns {Promise<Array<{ profile, name, items, error? }>>} una entrada por cuenta que
+     *   aprueba — con sus pedidos, o con el motivo por el que no se pudo preguntar.
+     */
+    async vaultApprovalsAll () {
+      // La activa sí se pone al día: es la única en la que esta pantalla puede escribir.
+      try { maybeRenewVaultCert() } catch (_) {}
+      const perfiles = loadProfiles()
+      const salida = await Promise.all(perfiles.map(async (p) => {
+        const v = p.id === currentPid ? loadVaultCert() : vaultCertOf(p.id)
+        if (!v?.cert) return null                                             // sin bóveda: no es asunto suyo
+        if (!(v.cert.scope || []).includes('vault:approve')) return null      // no aprueba: tampoco
+        const base = { profile: p.id, name: p.name || '', current: p.id === currentPid }
+        let device = null
+        try { device = p.id === currentPid ? loadVaultDevice() : await signerForProfile(p.id) } catch (e) {
+          return { ...base, items: [], error: e?.code || 'no-key' }
+        }
+        if (!device) return { ...base, items: [], error: 'no-key' }
+        try {
+          const r = await remoteApproval({ master: v.master, proxy: v.proxy, device, cert: v.cert, op: 'approvals' })
+          return { ...base, items: Array.isArray(r?.items) ? r.items : [] }
+        } catch (e) {
+          return { ...base, items: [], error: e?.code || e?.message || 'error' }
+        }
+      }))
+      return salida.filter(Boolean)
+    },
+
     /**
      * PUSH DE LA APP NATIVA: registra el token (FCM/APNs) de este aparato en el proxio,
      * bajo la llave del dispositivo, para que la bóveda pueda «timbrarlo» cuando haya

package/vault/vault.js

@@ -67,8 +67,8 @@ import { pubkeyId } from './capabilities.js'
   const T_CONSENT = (() => {
     const en = (navigator.language || 'es').startsWith('en')
     return en
-      ? { title: 'wants to see', allow: 'Allow', deny: 'No', who: 'Your Dotrino identity', once: 'Only what you allow leaves here.' }
-      : { title: 'quiere ver', allow: 'Permitir', deny: 'No', who: 'Tu identidad de Dotrino', once: 'De aquí solo sale lo que permitas.' }
+      ? { title: 'wants to see', allow: 'Allow', deny: 'No', who: 'Your Dotrino identity', once: 'Only what you allow leaves here.', via: 'through' }
+      : { title: 'quiere ver', allow: 'Permitir', deny: 'No', who: 'Tu identidad de Dotrino', once: 'De aquí solo sale lo que permitas.', via: 'a través de' }
   })()
   const SCOPE_TXT = (() => {
     const en = (navigator.language || 'es').startsWith('en')
@@ -85,6 +85,9 @@ import { pubkeyId } from './capabilities.js'
    * No se importa el catálogo de aplicaciones: eso ataría este iframe al repositorio del
    * home y habría que subirlo cada vez que nace una app. El subdominio ya es el nombre.
    */
+  /** Lo que dice el origen se pinta como texto, nunca como marcado: quien lo escribe es él. */
+  const escaparTexto = (t) => String(t).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]))
+
   function nombreDeOrigen (origin) {
     try {
       const h = new URL(origin).hostname
@@ -96,7 +99,7 @@ import { pubkeyId } from './capabilities.js'
   }
 
   let consentAbierto = null
-  function askConsent ({ origin, scopes }) {
+  function askConsent ({ origin, scopes, onBehalfOf }) {
     if (consentAbierto) return Promise.resolve(false)   // una pregunta a la vez
     return new Promise((resolve) => {
       const host = document.createElement('div')
@@ -104,8 +107,8 @@ import { pubkeyId } from './capabilities.js'
       const lista = scopes.map((x) => `<li>${SCOPE_TXT[x] || x}</li>`).join('')
       host.innerHTML = `<div style="background:#171331;border:1px solid #2a2350;border-radius:16px;padding:22px;min-width:min(320px,90vw);max-width:90vw;color:#e7e3ff">
         <div style="opacity:.7;font-size:13px">${T_CONSENT.who}</div>
-        <div style="font-weight:700;margin:8px 0 4px">${nombreDeOrigen(origin)} ${T_CONSENT.title}:</div>
-        <div style="opacity:.55;font-size:12px;margin-bottom:6px">${String(origin).replace(/^https?:\/\//, '')}</div>
+        <div style="font-weight:700;margin:8px 0 4px">${onBehalfOf ? escaparTexto(onBehalfOf) : nombreDeOrigen(origin)} ${T_CONSENT.title}:</div>
+        <div style="opacity:.55;font-size:12px;margin-bottom:6px">${onBehalfOf ? T_CONSENT.via + ' ' : ''}${String(origin).replace(/^https?:\/\//, '')}</div>
         <ul style="margin:6px 0 12px 18px;padding:0">${lista}</ul>
         <div style="opacity:.7;font-size:12px;margin-bottom:12px">${T_CONSENT.once}</div>
         <div style="display:flex;gap:8px">