@dotrino/identity 0.88.0 → 0.89.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.88.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,10 +167,16 @@ 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`). */
+  /**
+   * 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: any[]; error?: string }>>
+  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
@@ -323,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/vault/core.js

@@ -563,6 +563,66 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     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
@@ -2565,8 +2625,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       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) }
     },
 
     /**
@@ -2607,7 +2672,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         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 : [] }
+          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' }
         }

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