@dotrino/identity 0.92.0 → 0.94.0

package/package.json

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

@@ -126,8 +126,11 @@ export class Identity {
   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; 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 }>
+  /**
+   * Retirar lo concedido a una aplicación: la próxima vez que pida, se vuelve a preguntar.
+   * `onBehalfOf` identifica a una aplicación que entra por el puente (el mismo origen para todas).
+   */
+  revokeGrant (origin: string, onBehalfOf?: string): Promise<{ ok: boolean }>
   setMyNickname (nickname: string): Promise<{ me: Me }>
   getEncryptionPubkey (): Promise<string>
   encrypt (recipients: EncryptRecipient[], plaintext: string): Promise<EnvelopeV1>

package/src/index.js

@@ -274,8 +274,12 @@ export class Identity {
    */
   /** Qué le has concedido a cada aplicación. Sin esto, conceder no significaría nada. */
   async listGrants () { return this._call('listGrants') }
-  /** Retirar lo concedido a un origen: la próxima vez que pida, se vuelve a preguntar. */
-  async revokeGrant (origin) { return this._call('revokeGrant', { origin }) }
+  /**
+   * Retirar lo concedido a una aplicación: la próxima vez que pida, se vuelve a preguntar.
+   * Las que entran por el puente llegan todas desde el mismo origen, así que a esas se las
+   * nombra con `onBehalfOf` (el que trae su fila de `listGrants`).
+   */
+  async revokeGrant (origin, onBehalfOf) { return this._call('revokeGrant', { origin, ...(onBehalfOf ? { onBehalfOf } : {}) }) }
 
   async requestAssertion ({ audience, nonce, scopes, ttlMs, onBehalfOf } = {}) {
     // ESPERA LO QUE TARDE UNA PERSONA. Los cinco segundos de siempre valen para una

package/vault/core.js

@@ -725,13 +725,34 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // `acta.js`, que es puro y está probado aparte.
   // ----- PERMISO POR ORIGEN: qué le concedió el usuario a cada aplicación -----
   //
-  // `{ [origin]: { scopes: [...], at } }`. Vive en el kv del PERFIL, así que cambiar de
-  // perfil cambia lo concedido: lo que le diste a una aplicación desde tu cuenta de trabajo
-  // no vale para la personal.
-  const loadGrants = () => { try { return JSON.parse(kv.getItem(GRANTS_STORAGE) || '{}') } catch (_) { return {} } }
+  // `{ [grantKey]: { scopes: [...], at, lastUsed, onBehalfOf? } }`. Vive en el kv del
+  // PERFIL, así que cambiar de perfil cambia lo concedido: lo que le diste a una aplicación
+  // desde tu cuenta de trabajo no vale para la personal.
+  //
+  // LA CLAVE ES EL ORIGEN Y, SI PIDE POR OTRO, TAMBIÉN EN NOMBRE DE QUIÉN (dueño,
+  // 2026-09-17). Hasta 0.92 era solo el origen, y todas las aplicaciones que entran por el
+  // puente OIDC llegan desde el MISMO: `sso.dotrino.com`. Lo que el usuario le concedía a
+  // una lo heredaban todas las demás sin que saliera el panel, y en «dónde se usó mi
+  // identidad» se veían como una sola fila con el nombre de la última.
+  //
+  // Separar por `onBehalfOf` no le da a nadie más de lo que tenía: el nombre lo pone el
+  // origen, así que un origen que mintiera solo conseguiría una concesión aparte —vacía—,
+  // nunca la de otro origen. `|` no aparece en un origen, así que la clave no es ambigua.
+  const grantKey = (origin, onBehalfOf) => onBehalfOf ? `${origin}|${onBehalfOf}` : origin
+  const behalfName = (onBehalfOf) => onBehalfOf ? String(onBehalfOf).slice(0, 60) : ''
+  const loadGrants = () => {
+    let g
+    try { g = JSON.parse(kv.getItem(GRANTS_STORAGE) || '{}') } catch (_) { return {} }
+    // MIGRACIÓN DECLARADA (identity 0.93.0) — quitar después del 2026-10-17.
+    // Una entrada guardada bajo el origen A SECAS pero con `onBehalfOf` es de antes de 0.93:
+    // la compartían todas las aplicaciones del puente, así que no se puede atribuir a
+    // ninguna. Se tira, y cada aplicación vuelve a preguntar — que es el lado seguro.
+    for (const k of Object.keys(g)) if (!k.includes('|') && g[k]?.onBehalfOf) delete g[k]
+    return g
+  }
   const saveGrants = (g) => { try { kv.setItem(GRANTS_STORAGE, JSON.stringify(g)) } catch (_) {} }
-  /** Lo concedido a un origen, hoy. */
-  const grantedTo = (origin) => (loadGrants()[String(origin || '')]?.scopes) || []
+  /** Lo concedido a un origen (y a nombre de quién pide), hoy. */
+  const grantedTo = (key) => (loadGrants()[key]?.scopes) || []
 
   const loadActa = () => { try { return JSON.parse(kv.getItem(ACTA_STORAGE) || 'null') } catch (_) { return null } }
   const saveActa = (a) => kv.setItem(ACTA_STORAGE, JSON.stringify(a))
@@ -1537,6 +1558,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    */
   async function consentFor (origin, pedidos, onBehalfOf = null) {
     const org = String(origin || '').trim()
+    const behalf = behalfName(onBehalfOf)
+    const key = grantKey(org, behalf)
     // 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
@@ -1544,8 +1567,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     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) } : {}) }
+      const prev = g[key] || { scopes: [], at: Date.now() }
+      g[key] = { ...prev, lastUsed: Date.now(), ...(behalf ? { onBehalfOf: behalf } : {}) }
       saveGrants(g)
     }
     const base = pedidos.filter((s) => s === 'id:whoami')
@@ -1555,7 +1578,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // 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 yaTiene = grantedTo(key)
     const faltan = extra.filter((s) => !yaTiene.includes(s))
     if (!faltan.length) { marcarUso(); return pedidos }
 
@@ -1565,17 +1588,17 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return conocidos.length ? conocidos : ['id:whoami']
     }
     let ok = false
-    try { ok = !!(await askConsent({ origin: org, scopes: faltan, already: yaTiene, onBehalfOf })) } catch (_) { ok = false }
+    try { ok = !!(await askConsent({ origin: org, scopes: faltan, already: yaTiene, onBehalfOf: behalf || null })) } 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] = {
+    g[key] = {
       scopes: [...new Set([...yaTiene, ...faltan])].sort(),
-      at: (g[org]?.at) || Date.now(), lastUsed: Date.now(),
-      ...(onBehalfOf ? { onBehalfOf: String(onBehalfOf).slice(0, 60) } : {})
+      at: (g[key]?.at) || Date.now(), lastUsed: Date.now(),
+      ...(behalf ? { onBehalfOf: behalf } : {})
     }
     saveGrants(g)
     return pedidos
@@ -1846,18 +1869,22 @@ 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,
+      return Object.entries(g).map(([key, v]) => ({
+        origin: key.split('|')[0], 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 } = {}) {
+    /**
+     * Retirar lo concedido a una aplicación. La próxima vez que pida, se vuelve a preguntar.
+     * `onBehalfOf` es obligatorio para las que piden por otro (el puente): retirar el permiso
+     * de UNA no puede quitárselo a todas las que entran por el mismo sitio.
+     */
+    async revokeGrant ({ origin, onBehalfOf } = {}) {
       const g = loadGrants()
-      const org = String(origin || '')
-      if (!(org in g)) return { ok: false }
-      delete g[org]; saveGrants(g)
+      const key = grantKey(String(origin || ''), behalfName(onBehalfOf))
+      if (!(key in g)) return { ok: false }
+      delete g[key]; saveGrants(g)
       return { ok: true }
     },
 

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.63.0 (dotrino-vault/lib/src/{index,enroll,protocol}.js).
+Copia vendorizada de @dotrino/vault@0.65.0 (dotrino-vault/lib/src/{index,enroll,protocol}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 index.js importa ./enroll.js y ./protocol.js (relativos, van en esta misma copia),
 @dotrino/identity/{capabilities,acta} (= ../../{capabilities,acta}.js) y

package/vault/vendor/vault/enroll.js

@@ -349,23 +349,50 @@ export function createEnrollDesk ({
       return { ok: true, deviceId: pend.deviceId, adopting: true }
     }
 
-    const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
-
     // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
     // credencial y el acta es la política, y no tiene sentido emitir una sin la otra.
     // Las capacidades salen del scope que se pidió al emparejar (cert ∩ acta, §2.3).
-    let record = null
+    //
+    // NADA DE REPLIEGUES (2026-09-17). Esto antes estaba envuelto en un `catch` que solo
+    // anotaba el error, y además se saltaba en silencio si la identidad no sabía admitir o si
+    // el scope no daba ninguna capacidad: el aparato recibía su certificado SIN estar en el
+    // acta, y el fallo aparecía después y en otro sitio. Ahora, si no se puede admitir, no
+    // se entrega nada y se dice.
+    if (typeof identity.admitMember !== 'function') {
+      throw Object.assign(new Error('this vault cannot add devices to the account record: no certificate was issued'), { code: 'admit-unavailable' })
+    }
+    // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
+    // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
+    // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
+    const cn = scopeToCn(pend.scope)
+    const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
+    if (!caps.length) {
+      throw Object.assign(new Error('the pairing scope grants no permission: no certificate was issued'), { code: 'empty-scope' })
+    }
+
+    const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
+
     try {
-      if (typeof identity.admitMember === 'function') {
-        // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
-        // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
-        // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
-        const cn = scopeToCn(pend.scope)
-        const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
-        if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
+      await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
+    } catch (e) {
+      // El certificado ya está firmado y no se entrega: se revoca, para que no quede uno
+      // válido suelto. Si ni eso sale, se dice también.
+      let revoked = true
+      try { await identity.revokeDelegation(cert.nonce) } catch (re) {
+        revoked = false
+        log('[vault] could not revoke the undelivered certificate %s: %s', cert.nonce, re.message)
       }
-      record = (await identity.profileActa?.())?.acta || null
-    } catch (e) { log('[vault] could not admit into the record:', e.message) }
+      audit('rejected', { what: 'approve', device: pend.deviceId, reason: 'admit-failed' })
+      reply(pend.from, { type: MSG_ERROR, error: 'the vault could not add this device to the account: pairing failed, try again' })
+      pending.delete(pend.token)
+      fire(onPendingChange)
+      log('[vault] could not add %s to the record, no certificate was delivered: %s', pend.deviceId, e.message)
+      throw Object.assign(
+        new Error(`could not add the device to the account record (${e.message}): no certificate was delivered${revoked ? '' : ', and the signed one could not be revoked'}`),
+        { code: 'admit-failed', cause: e }
+      )
+    }
+    const record = (await identity.profileActa?.())?.acta || null
 
     audit('enroll', { device: pend.deviceId, label: pend.label || '', scope: pend.scope })
     // Echamos el código tipeado junto al cert: el DISPOSITIVO acepta solo si coincide