@dotrino/identity 0.87.0 → 0.89.0

package/package.json

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

@@ -167,6 +167,17 @@ 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`).
+   *
+   * Cada pedido trae `ctx` —qué comando está pidiendo las claves y desde qué carpeta— ya
+   * abierto: viaja sellado a la llave de cifrado de este aparato y se descifra aquí dentro.
+   * `ctxError` si no se pudo abrir; sin ninguno de los dos, el pedido no dijo qué corría.
+   */
+  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: ApprovalRequest[]; 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)
@@ -318,3 +329,33 @@ export function signSession (args: { sid: string; s: string; by: string; origin:
 export function verifySession (paper: SessionPaper, opts: { chain: any[]; expectedProfileId?: string | null; origin?: string | null; now?: number; maxSkewMs?: number }): Promise<VerifiedSession>
 /** ¿Firmó esta sesión esto, y su papel lo cubría? */
 export function verifySessionSigned (args: { data: any; signature: string; session: SessionPaper; chain: any[]; scope?: SessionScope | null; origin?: string | null; expectedProfileId?: string | null; now?: number }): Promise<VerifiedSession>
+
+/** Un pedido de aprobación tal y como lo ve la pantalla que dice que sí o que no. */
+export interface ApprovalRequest {
+  id: string
+  ns: string
+  deviceId: string | null
+  label: string
+  ts: number
+  exp: number
+  /** Qué comando está pidiendo las claves, ya descifrado. `null`/ausente si no lo dijo. */
+  ctx?: ProcessContext | null
+  /** Por qué no se pudo abrir el comando (`no-key`, `profile-locked`, `cannot-open`). */
+  ctxError?: string
+  /** La bóveda no pudo sellarlo para este aparato (`no-enc-key`, `seal-failed`). */
+  ctxSealed?: boolean
+  ctxReason?: string
+}
+
+/** Qué proceso pide, y si lo comprobó el kernel (`proc`) o solo lo dice él (`declared`). */
+export interface ProcessContext {
+  pid: number | null
+  uid: number | null
+  exe: string
+  cwd: string
+  argv: string[]
+  truncated: boolean
+  user: string
+  host: string
+  verified: 'proc' | 'declared'
+}

package/src/index.js

@@ -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,102 @@ 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 LLAVE DE CIFRADO DE OTRA CUENTA DE ESTE DISPOSITIVO, sin abrirla ni ponerla activa.
+   *
+   * El par de `signerForProfile`, y por el mismo motivo: la pantalla de Pedidos enseña los
+   * de TODAS las cuentas a la vez, y desde 2026-09-11 cada pedido trae **qué comando está
+   * pidiendo las claves** dentro de un sobre cerrado a la llave de ESA cuenta. Sin esto, los
+   * pedidos de las demás cuentas se verían sin comando — que es justo el dato por el que se
+   * mira la pantalla.
+   *
+   * Mismas tres reglas que allí: no se mueve `currentPid`, no se genera ninguna llave (si no
+   * está, se dice) y una cuenta sellada bajo su contraseña se contesta `profile-locked`.
+   */
+  async function encKeyForProfile (pid) {
+    if (pid === currentPid) return encKeypair?.privateKey || null
+    const { algo, privUses } = ALGO_OF.enc
+    const nombre = ENC_KEY_STORAGE.replace(/^dotrino\.identity\./, `dotrino.identity.p.${pid}.`)
+    if (keyStore) {
+      const guardado = await keyStore.get(nombre).catch(() => null)
+      if (guardado?.privateKey) return 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 encryption key is sealed under its password'), { code: 'profile-locked' })
+      if (g?.privateJwk) return crypto.subtle.importKey('jwk', g.privateJwk, algo, true, privUses)
+    }
+    throw Object.assign(new Error('no encryption key stored for that profile'), { code: 'no-key' })
+  }
+
+  /**
+   * ABRE EL COMANDO DE CADA PEDIDO, aquí dentro, donde están las llaves.
+   *
+   * La bóveda manda el comando y el path sellados a la llave de cifrado del aparato que
+   * pregunta (no los manda en claro: el camino hasta aquí es el proxio, que no cifra). Se
+   * abren en el iframe y salen a la página ya legibles: la página no ve ninguna llave, y el
+   * único tramo en claro es el `postMessage` entre dos ventanas del mismo navegador.
+   *
+   * Lo que no se puede abrir se dice (`ctxError`) en vez de quedarse como un pedido sin
+   * comando: son cosas distintas y en la pantalla hay que poder distinguirlas.
+   */
+  async function abrirContextos (items, pid) {
+    if (!Array.isArray(items) || !items.length) return items
+    let priv = null
+    let fallo = null
+    try { priv = await encKeyForProfile(pid) } catch (e) { fallo = e?.code || 'no-key' }
+    const salida = []
+    for (const raw of items) {
+      const { ctxWrap, ctxEnvelope, ...it } = raw || {}
+      if (!ctxWrap || !ctxEnvelope) { salida.push(it); continue }
+      if (!priv) { salida.push({ ...it, ctxError: fallo || 'no-key' }); continue }
+      try {
+        const cek = await Content.openWrap({ wrap: ctxWrap, myEncPrivateKey: priv })
+        salida.push({ ...it, ctx: JSON.parse(await Content.decryptWithCek({ cek, envelope: ctxEnvelope })) })
+      } catch (e) {
+        salida.push({ ...it, ctxError: e?.code || 'cannot-open' })
+      }
+    }
+    return salida
+  }
+
   /** 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 +671,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)
 
@@ -2501,13 +2616,69 @@ 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()
-      try { return await remoteApproval({ master: v.master, proxy: v.proxy, device, cert: v.cert, op, id, onRevoked: wipeVaultLink }) }
-      catch (e) { return handleVaultError(e) }
+      try {
+        const r = await remoteApproval({ master: v.master, proxy: v.proxy, device, cert: v.cert, op, id, onRevoked: wipeVaultLink })
+        // El comando de cada pedido viene sellado a este aparato: se abre aquí, que es
+        // donde está la llave, y sale ya legible.
+        if (Array.isArray(r?.items)) return { ...r, items: await abrirContextos(r.items, currentPid) }
+        return r
+      } 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' })
+          const items = Array.isArray(r?.items) ? await abrirContextos(r.items, p.id) : []
+          return { ...base, items }
+        } catch (e) {
+          return { ...base, items: [], error: e?.code || e?.message || 'error' }
+        }
+      }))
+      return salida.filter(Boolean)
     },
 
     /**

package/vault/vendor/proxy-client/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.18.2 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,webrtc}.js).
+Copia vendorizada de @dotrino/proxy-client@0.19.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,webrtc}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 sealing.js resuelve @dotrino/identity/content de forma PEREZOSA (= ../../content.js
 por el import map): solo se carga si de verdad se sella algo.

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.62.1 (dotrino-vault/lib/src/{index,enroll,protocol}.js).
+Copia vendorizada de @dotrino/vault@0.63.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