@dotrino/identity 0.108.0 → 0.110.0

package/package.json

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

@@ -187,9 +187,9 @@ export class Identity {
    * 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>
+  vaultApprovals (op: 'approvals' | 'approve' | 'deny', args?: { id?: string; profile?: string; notify?: boolean }): 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 }>>
+  vaultApprovalsAll (args?: { notify?: boolean }): Promise<Array<{ profile: string; name: string; current: boolean; items: ApprovalRequest[]; error?: string }>>
   canApproveVault (): Promise<boolean>
   getVaultCert (): Promise<any>
   onVault (handler: (payload: any) => void): () => void

package/src/index.js

@@ -476,6 +476,10 @@ 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.notify` (solo con `approvals`): `true`/`false` según a este aparato le lleguen los
+   * avisos de pedidos. La bóveda lo apunta, y para actualizarse solo pide permiso si hay un
+   * aprobador que pueda enterarse. No pasarlo no cambia lo ya dicho.
+   *
    * `args.profile` apunta a OTRA cuenta de este dispositivo (la que diga
    * `vaultApprovalsAll`); sin él es la activa.
    */
@@ -494,8 +498,8 @@ export class Identity {
    *
    * Aprobar uno de otra cuenta: `vaultApprovals('approve', { id, profile })`.
    */
-  async vaultApprovalsAll () {
-    return this._call('vaultApprovalsAll', {}, 30000)
+  async vaultApprovalsAll (args) {
+    return this._call('vaultApprovalsAll', args || {}, 30000)
   }
 
   /** Registra el token de push de la app nativa (FCM/APNs) bajo la llave de este aparato. */

package/src/node.js

@@ -263,7 +263,7 @@ export class Identity {
   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') }
+  vaultApprovalsAll (args) { return this._h('vaultApprovalsAll', args || {}) }
   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

@@ -1121,9 +1121,22 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       // se hace al generar una propia — quién puede hacer qué con esta llave lo decide esta
       // casa, no una etiqueta que viajó dentro del paquete.
       const sinTopes = (jwk) => { const { key_ops: _o, ...resto } = jwk || {}; return resto }
-      await adoptJwkPair('sign', KEY_STORAGE, sinTopes(entrada.keys.sign), JSON.parse(entrada.publickey))
-      if (entrada.keys.enc && entrada.encPublickey) {
-        await adoptJwkPair('enc', ENC_KEY_STORAGE, sinTopes(entrada.keys.enc), JSON.parse(entrada.encPublickey))
+      if (keyStore?.importPair) {
+        // DENTRO DE UNA APP NATIVA: la llave que entrega la bóveda la guarda la app (cifrada
+        // con una llave del chip) y firma ella. Van las dos mitades juntas, bajo un mismo id.
+        if (!entrada.keys.enc || !entrada.encPublickey) {
+          throw Object.assign(new Error('this login has no encryption key: the phone needs both'), { code: 'native-import-needs-enc' })
+        }
+        await keyStore.importPair({
+          sign: { name: _scoped(KEY_STORAGE), privateJwk: sinTopes(entrada.keys.sign), publickey: entrada.publickey },
+          enc: { name: _scoped(ENC_KEY_STORAGE), privateJwk: sinTopes(entrada.keys.enc), publickey: entrada.encPublickey }
+        })
+        kv.removeItem(KEY_STORAGE); kv.removeItem(ENC_KEY_STORAGE)
+      } else {
+        await adoptJwkPair('sign', KEY_STORAGE, sinTopes(entrada.keys.sign), JSON.parse(entrada.publickey))
+        if (entrada.keys.enc && entrada.encPublickey) {
+          await adoptJwkPair('enc', ENC_KEY_STORAGE, sinTopes(entrada.keys.enc), JSON.parse(entrada.encPublickey))
+        }
       }
       saveActa(entrada.acta)
       kv.setItem(ACTA_HISTORY_STORAGE, '[]')
@@ -1147,6 +1160,18 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       list.push({ id: pid, name: entrada.user, pubkey: publickeyJwkStr })
       saveProfiles(list)
       emitVault({ phase: 'login', address: entrada.address, volatile: !remember })
+      // En una app nativa, la cuenta pasa también a su pantalla de Pedidos, con el mismo papel
+      // (como al emparejar). Si la app no la guarda, se dice: la entrada en sí ya está hecha.
+      if (keypair?.privateKey?.external) {
+        keypair.privateKey.paired({
+          cert: entrada.cert, vault: entrada.iss, proxy: proxy || DEFAULT_PROXY,
+          deviceId: await deviceIdDe(entrada.publickey),
+          name: entrada.acta?.name || entrada.address, profileId: entrada.acta?.profileId || null
+        }).then(
+          () => emitVault({ phase: 'native-account', ok: true }),
+          (e) => { console.warn('[identity] the phone did not save the account: ' + e.message); emitVault({ phase: 'native-account', ok: false, code: e.code || 'native-error', reason: e.message }) }
+        )
+      }
       return { id: pid, name: entrada.user, address: entrada.address, user: entrada.user, sid: entrada.sid, volatile: !remember }
     } catch (e) {
       // NADA DE MEDIAS CUENTAS: si algo falla, no se queda una identidad a medio adoptar en
@@ -3057,12 +3082,12 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * `profile` apunta a OTRA cuenta de este mismo dispositivo (ver `vaultApprovalsAll`):
      * sin él es la activa, como siempre.
      */
-    async vaultApprovals ({ op, id, profile = null } = {}) {
+    async vaultApprovals ({ op, id, profile = null, notify } = {}) {
       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()
-      const ask = (cert) => remoteApproval({ master: v.master, proxy: v.proxy, device, cert, op, id, onRevoked: wipeVaultLink })
+      const ask = (cert) => remoteApproval({ master: v.master, proxy: v.proxy, device, cert, op, id, notify, onRevoked: wipeVaultLink })
       try {
         let r
         try { r = await ask(v.cert) } catch (e) {
@@ -3104,7 +3129,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * @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 () {
+    async vaultApprovalsAll ({ notify } = {}) {
       // La activa sí se pone al día: es la única en la que esta pantalla puede escribir.
       try { maybeRenewVaultCert() } catch (_) {}
       const perfiles = loadProfiles()
@@ -3119,7 +3144,9 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         }
         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' })
+          // `notify` habla de la cuenta ACTIVA: los avisos se suscriben bajo SU llave. De las
+          // demás no se dice nada, que no es lo mismo que decir que no.
+          const r = await remoteApproval({ master: v.master, proxy: v.proxy, device, cert: v.cert, op: 'approvals', ...(p.id === currentPid ? { notify } : {}) })
           const items = Array.isArray(r?.items) ? await abrirContextos(r.items, p.id) : []
           return { ...base, items }
         } catch (e) {

package/vault/externalKeys.js

@@ -78,6 +78,21 @@ export function withExternalKeys (keyStore, bridge) {
       const other = sib ? await keyStore.get(sib) : null
       if (rec?.external && !(other?.external === rec.external)) await bridge.call('remove', { kid: rec.external })
     },
+    /**
+     * UNA LLAVE QUE YA EXISTE (entrar con usuario y contraseña): la bóveda la entrega y no se
+     * puede meter en el chip, así que la app la guarda cifrada con una llave del chip y firma
+     * ella. Desde aquí es una llave externa más: la página no se queda con la privada.
+     * `sign` y `enc`: `{ name, privateJwk, publickey }`, con la pública TAL CUAL la escribe el
+     * acta (es la cadena con la que esa llave es miembro).
+     */
+    async importPair ({ sign, enc }) {
+      const k = await bridge.call('import', {
+        sign: sign.privateJwk, enc: enc.privateJwk, publickey: sign.publickey, encPub: enc.publickey
+      })
+      if (!k?.kid) throw Object.assign(new Error('the phone did not keep the key'), { code: 'native-no-key' })
+      await keyStore.set(sign.name, { external: k.kid, kind: 'sign', publicJwk: JSON.parse(sign.publickey) })
+      await keyStore.set(enc.name, { external: k.kid, kind: 'enc', publicJwk: JSON.parse(enc.publickey) })
+    },
     async create (kind, name) {
       // Las dos mitades del perfil van bajo la MISMA llave del chip: si la otra ya nació
       // allí, se reutiliza; si no, se crea una nueva.

package/vault/nativeStore.js

@@ -28,8 +28,9 @@ function plainKeyRecord (rec) {
   if (rec && typeof rec.external === 'string' && rec.publicJwk && (rec.kind === 'sign' || rec.kind === 'enc')) {
     return { external: rec.external, kind: rec.kind, publicJwk: rec.publicJwk }
   }
-  // Una llave de SOFTWARE (adoptar un perfil, entrar con contraseña) no cabe en el chip, y
-  // guardarla a medias sería perder la cuenta sin decirlo. Se para aquí y se dice.
+  // Una llave de SOFTWARE no se guarda aquí: guardarla a medias sería perder la cuenta sin
+  // decirlo. La de entrar con contraseña no llega a este punto: la guarda la app, cifrada con
+  // una llave del chip (`importPair` de `externalKeys.js`), y aquí queda su registro externo.
   throw Object.assign(new Error('this app keeps keys in the phone chip only: a software key cannot be stored here'), { code: 'native-no-import' })
 }
 

package/vault/remote.js

@@ -452,11 +452,16 @@ export async function requestAdmin ({ master, proxy, device, cert, op, onRevoked
  * `vault:approve` — que, como `admin`, no se recibe al emparejar: se concede a mano.
  * La bóveda contesta un cuerpo firmado por la maestra (`{ op, items | ok }`).
  */
-export async function requestApproval ({ master, proxy, device, cert, op, id, onRevoked } = {}) {
+export async function requestApproval ({ master, proxy, device, cert, op, id, notify, onRevoked } = {}) {
+  // `notify`: al pedir la lista, este aparato dice si le llegan los avisos. La bóveda lo
+  // apunta y es lo que mira para saber si hay a quién pedirle permiso antes de actualizarse.
+  // Solo va si quien llama lo SABE (true o false): no decir nada no cambia lo ya dicho.
+  const data = id ? { op, id } : { op }
+  if (op === 'approvals' && typeof notify === 'boolean') data.notify = notify
   const res = await vaultRpc({
     master, proxy, device, cert, onRevoked,
     sendType: MSG.SECRETS, okType: MSG.SECRETS_RESULT,
-    data: id ? { op, id } : { op }
+    data
   })
   return res.body
 }

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

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.28.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc,stats}.js).
+Copia vendorizada de @dotrino/proxy-client@0.30.4 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc,stats,stats-log}.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/proxy-client/client.js

@@ -545,6 +545,27 @@ export class WebSocketProxyClient {
     this.send(tokens, sobre)
   }
 
+  /**
+   * Mandar POR TOKEN algo que la app YA CIFRÓ por su cuenta (un canal de sesión propio,
+   * como el de `@dotrino/remote-agent`), con la misma red que `sendSealedTo`: sube al
+   * canal directo si lo hay, y si el token murió el mismo mensaje sale por `peerPubkey`
+   * y se avisa con `token_gone`.
+   *
+   * Existe porque `sendByPubkey` NUNCA sube de escalón —la cola es del proxio— y `send`
+   * a secas pierde en silencio lo que va a un token que ya no existe. Con `requireSealed`
+   * se niega igual que los demás: esto no abre una puerta para ir en claro.
+   *
+   * @param {string} token
+   * @param {any} payload
+   * @param {{ peerPubkey:string }} opts
+   */
+  sendToOrQueue (token, payload, { peerPubkey } = /** @type {any} */ ({})) {
+    if (!token || !peerPubkey) {
+      throw errorCon('sendToOrQueue: needs the token and whose it is (peerPubkey)', 'no-peer-identity')
+    }
+    this._sendToTokenOrQueue(token, payload, peerPubkey)
+  }
+
   /**
    * UN TOKEN MUERTO NO SE TRAGA EL MENSAJE. Un token es una conexión, y cuando la otra punta
    * reinicia la app su token deja de existir; la app que lo tenía apuntado sigue mandando ahí

package/vault/vendor/proxy-client/index.js

@@ -11,6 +11,7 @@ export {
 } from './encpub.js'
 
 export { listTransports, routeOf } from './stats.js'
+export { logStats, formatStats } from './stats-log.js'
 
 import { WebSocketProxyClient } from './client.js'
 

package/vault/vendor/proxy-client/stats-log.js

@@ -0,0 +1,107 @@
+/**
+ * LAS ESTADÍSTICAS DE RED, AL LOG. Para lo que no tiene pantalla: un daemon, un agente, un
+ * servicio bajo pm2.
+ *
+ * En el navegador las enseña el topbar (su modal de red lee el registro de clientes). Un
+ * proceso de Node no tiene dónde, así que «¿esto va por WebRTC o sigue dando la vuelta por
+ * el proxio?» solo se contestaba con una prueba en contenedores. Esto escribe lo mismo que
+ * pinta el modal, una línea cada tanto, con el `log` que el servicio ya usa.
+ *
+ * Lee el MISMO registro que el topbar (`listTransports`), así que el servicio no le pasa
+ * sus clientes: los que haya en el proceso, salen.
+ *
+ * Tres cosas a propósito:
+ *  - Solo escribe si algo cambió. Un servicio quieto no llena el log de líneas iguales.
+ *  - Los contadores son ACUMULADOS desde `since`: dos líneas se restan, y una sola ya dice
+ *    si hubo tráfico directo alguna vez.
+ *  - De la otra punta solo sale el TOKEN, que es efímero. La pubkey no: con quién habla
+ *    una máquina es justo lo que no se deja escrito en un disco.
+ */
+import { listTransports, PATHS } from './stats.js'
+
+const sum = (peers, dir) => {
+  const t = { proxy: 0, direct: 0, turn: 0, webrtc: 0 }
+  for (const p of peers) for (const k of PATHS) t[k] += p[dir][k]
+  return t
+}
+
+const pairs = (prefix, o) => PATHS.map((k) => `${prefix}.${k}=${o[k]}`).join(' ')
+
+/**
+ * Las líneas de UN cliente, a partir de lo que devuelve `client.stats()`.
+ * La primera es el resumen; después, una por conexión.
+ *
+ * @param {object} s lo que devuelve `client.stats()` (`TransportStats` en los tipos)
+ * @param {{ label?: string }} [opts]
+ * @returns {string[]}
+ */
+export function formatStats (s, opts = {}) {
+  const tag = opts.label ? `[net] ${opts.label}` : '[net]'
+  // QUIÉN CONTESTÓ Y QUIÉN NO. Un sondeo (un ping a cada aparato del acta) deja una entrada
+  // por destinatario aunque nadie responda: esas no son conexiones y van resumidas
+  // (`unanswered`), igual que en el informe del topbar y de las apps nativas.
+  // `unknown`: quien nos escribió, nunca recibió respuesta y no sabemos su llave (otro aparato
+  // sondeando qué máquinas están encendidas). Tampoco es una conexión.
+  const isUnknown = (p) => p.msgsIn > 0 && !(p.msgsOut > 0) && !p.pubkey
+  const unknown = s.peers.filter(isUnknown)
+  const talking = s.peers.filter((p) => p.msgsIn > 0 && !isUnknown(p))
+  const silent = s.peers.filter((p) => !(p.msgsIn > 0))
+  const routes = {}
+  for (const p of talking) routes[p.route] = (routes[p.route] || 0) + 1
+  const routeList = Object.keys(routes).sort().map((r) => `${r}=${routes[r]}`).join(',') || 'none'
+  const lines = [
+    `${tag} url=${s.url} connected=${s.connected ? 'yes' : 'no'} webrtc=${s.webrtc ? 'on' : 'off'}` +
+    ` ws.in=${s.proxy.bytesIn} ws.out=${s.proxy.bytesOut}` +
+    ` ${pairs('in', sum(s.peers, 'bytesIn'))} ${pairs('out', sum(s.peers, 'bytesOut'))}` +
+    ` peers=${talking.length} routes=${routeList}` +
+    (silent.length ? ` unanswered=${silent.length} unanswered.out=${silent.reduce((n, p) => n + PATHS.reduce((m, k) => m + p.bytesOut[k], 0), 0)}` : '') +
+    (unknown.length ? ` unknown=${unknown.length} unknown.in=${unknown.reduce((n, p) => n + PATHS.reduce((m, k) => m + p.bytesIn[k], 0), 0)}` : '')
+  ]
+  for (const p of talking) {
+    lines.push(
+      `${tag}   peer=${p.token || 'by-key'} route=${p.route}` +
+      ` ${pairs('in', p.bytesIn)} ${pairs('out', p.bytesOut)} msgs.in=${p.msgsIn} msgs.out=${p.msgsOut}`
+    )
+  }
+  return lines
+}
+
+/**
+ * Escribe las estadísticas de todos los clientes del proceso cada `everyMs`, si cambiaron.
+ *
+ * @param {{ log?: (line: string) => void, everyMs?: number, label?: string }} [opts]
+ * @returns {{ stop: () => Promise<void>, flush: () => Promise<void> }}
+ *   `flush` escribe ya (si cambió algo); `stop` escribe una última vez y para.
+ */
+export function logStats (opts = {}) {
+  const log = opts.log || ((line) => console.log(line))
+  const everyMs = opts.everyMs || 5 * 60 * 1000
+  /** cliente → lo último que se escribió de él */
+  const last = new WeakMap()
+
+  const flush = async () => {
+    for (const client of listTransports()) {
+      if (typeof client.stats !== 'function') continue
+      let lines
+      try {
+        lines = formatStats(await client.stats(), opts)
+      } catch (e) {
+        // No poder leer NO es «no hubo tráfico»: se dice, para que no parezca silencio.
+        lines = [`${opts.label ? `[net] ${opts.label}` : '[net]'} could not read stats: ${e?.message || e}`]
+      }
+      const text = lines.join('\n')
+      if (last.get(client) === text) continue
+      last.set(client, text)
+      for (const line of lines) log(line)
+    }
+  }
+
+  const timer = setInterval(() => { flush() }, everyMs)
+  // El log no puede ser lo que mantiene vivo un proceso que ya terminó.
+  if (typeof timer.unref === 'function') timer.unref()
+
+  return {
+    flush,
+    stop: async () => { clearInterval(timer); await flush() }
+  }
+}

package/vault/vendor/vault/VERSION.txt

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

@@ -103,6 +103,13 @@ export const MSG = Object.freeze({
   // una forma de echar a alguien de su cuenta.
   LOGIN_CLOSE: 'vault.login.close',           // aparato → vault: { data:{op,user,sid,publickey,ts}, signature }
   LOGIN_CLOSED: 'vault.login.closed',         // vault → aparato: { ok }
+  // INCIDENTE: un agente de la cuenta (la terminal) avisa de que OTRO aparato de la cuenta
+  // se equivocó de clave tres veces seguidas. La bóveda lo apunta como un pedido más
+  // (`kind: 'incident'`), timbra a quien aprueba, y el aprobador bloquea o ignora. Bloquear
+  // no toca el acta: es una lista de la bóveda (`blocked.json`) que viaja a los agentes con
+  // `vault.devices.result` (`blocked`) y se deshace con `dotrino-vault unblock <ID>`.
+  INCIDENT: 'vault.incident',                 // agente → vault: { data:{op:'incident',kind,about,tries,publickey,ts}, signature, cert }
+  INCIDENT_RESULT: 'vault.incident.result',   // vault → agente: { id, approvers, blocked }
   ERROR: 'vault.error'                        // vault → dispositivo: { error }
 })