@dotrino/identity 0.86.2 → 0.87.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.87.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 }>

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
   }
 

package/vault/core.js

@@ -1415,31 +1415,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 +1726,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 +1741,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) {

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">