@dotrino/identity 0.108.0 → 0.109.0

package/package.json

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

@@ -3057,12 +3057,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 +3104,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 +3119,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/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.1 (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,96 @@
+/**
+ * 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]'
+  const routes = {}
+  for (const p of s.peers) 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=${s.peers.length} routes=${routeList}`
+  ]
+  for (const p of s.peers) {
+    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.80.0 (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 }
 })