@dotrino/identity 0.111.0 → 0.112.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.111.0",
+  "version": "0.112.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/vault/remote.js

@@ -374,7 +374,9 @@ export async function requestStore ({ master, proxy, device, cert, method, args,
 export async function requestDevices ({ master, proxy, device, cert, sinceSeq, onRevoked } = {}) {
   const data = typeof sinceSeq === 'number' ? { op: 'devices', sinceSeq } : { op: 'devices' }
   const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.devices', okType: 'vault.devices.result', data })
-  return { devices: res.devices || [], revoked: res.revoked || [], acta: res.acta || null, chain: res.chain || null }
+  // `sealerChain`: [génesis, …cambios de sellador…, actual], lo que una firma de este aparato
+  // tiene que llevar para que `verifySignedFor` la ate a la cuenta (vaultd ≥ 0.154.0).
+  return { devices: res.devices || [], revoked: res.revoked || [], acta: res.acta || null, chain: res.chain || null, sealerChain: res.sealerChain || null }
 }
 
 /**

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

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

@@ -1,7 +1,7 @@
 import { buildSignedChannel, getPublicKeyJwk, signData, samePubkey } from './signature.js'
 import { seal, open, isSealed } from './sealing.js'
 import { buildEncPubStatement, readEncPubStatement, isEncPub } from './encpub.js'
-import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, resolvePeerConnection } from './webrtc.js'
+import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, resolvePeerConnection, pinTurnToIPv4 } from './webrtc.js'
 import { TrafficStats, utf8Length, registerTransport, unregisterTransport } from './stats.js'
 
 /**
@@ -1002,9 +1002,35 @@ export class WebSocketProxyClient {
       clearTimeout(this._turnTimer)
       this._turnTimer = null
     }
-    const res = await this.getTurnCredentials({ publicKey, sign })
-    if (!res.enabled || !res.iceServers) return false
-    this._rtc.setIceServers([...res.iceServers, ...DEFAULT_ICE_SERVERS])
+    let res
+    try {
+      res = await this.getTurnCredentials({ publicKey, sign })
+    } catch (e) {
+      if (e?.status !== 429) throw e
+      // 429: EL PROXIO DICE «AHORA NO» (tope diario de tráfico, cuota por hora, o no puede
+      // leer el consumo). No es un fallo: se sigue por el proxio, que es el escalón que
+      // siempre funciona. Se quita el relevo que hubiera (sus credenciales ya no se
+      // renuevan), se dice por un evento y en `stats()`, y se vuelve a pedir cuando el
+      // proxio dice que se puede — si no, un aparato que pasó por un día con el tope
+      // alcanzado se quedaría sin relevo hasta su siguiente reconexión.
+      this._rtc.setIceServers(DEFAULT_ICE_SERVERS)
+      const retryAfterMs = Math.max(60000, Number(e.retryAfterMs) || 0)
+      this._turn = { active: false, code: e.code || null, retryAt: Date.now() + retryAfterMs }
+      this._emit('turn_unavailable', { code: e.code || null, retryAfterMs })
+      this._turnTimer = setTimeout(() => {
+        this._turnTimer = null
+        this.enableTurn({ publicKey, sign }).catch(() => {})
+      }, retryAfterMs)
+      return false
+    }
+    if (!res.enabled || !res.iceServers) {
+      this._turn = { active: false, code: 'turn-disabled', retryAt: null }
+      return false
+    }
+    this._turn = { active: true, code: null, expiresAt: res.expiresAt || null }
+    // En Node el relevo va con su dirección IPv4 ya escrita (ver `pinTurnToIPv4`).
+    const turnServers = await pinTurnToIPv4(res.iceServers)
+    this._rtc.setIceServers([...turnServers, ...DEFAULT_ICE_SERVERS])
     // Renovar con margen antes de expirar (mínimo 30 s entre renovaciones)
     const refreshIn = Math.max(30000, (res.expiresAt || 0) - Date.now() - 60000)
     this._turnTimer = setTimeout(() => {
@@ -1523,6 +1549,8 @@ export class WebSocketProxyClient {
       publickey: this.myPublickey,
       connected: this._connected,
       webrtc: !!this._rtc,
+      // El relevo: null si nunca se pidió; si no, activo o por qué no (`code`, `retryAt`).
+      turn: this._turn ? { ...this._turn } : null,
       since: t.since,
       proxy: { ...t.proxy },
       peers
@@ -1566,7 +1594,11 @@ export class WebSocketProxyClient {
     this._pending.delete(id)
     // Con su `code`: quien llama distingue los casos por él, no por la frase (que el proxio
     // puede cambiar o traducir). Antes se perdía aquí y solo quedaba comparar el texto.
-    entry.reject(errorCon(data.error || 'Server error', data.code || null))
+    const e = errorCon(data.error || 'Server error', data.code || null)
+    // «Ahora no» (429) y cuánto esperar, cuando el proxio lo dice.
+    if (data.status) e.status = data.status
+    if (data.retry_after_ms) e.retryAfterMs = data.retry_after_ms
+    entry.reject(e)
   }
 
   _emit (event, ...args) {

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

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

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

@@ -54,6 +54,7 @@ export function formatStats (s, opts = {}) {
     ` 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}` +
+    (s.turn ? ` turn=${s.turn.active ? 'on' : `off(${s.turn.code || '?'})`}` : '') +
     (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)}` : '')
   ]
@@ -105,3 +106,63 @@ export function logStats (opts = {}) {
     stop: async () => { clearInterval(timer); await flush() }
   }
 }
+
+/** Bytes para el informe de texto: `B`, `KB` con un decimal, `MB` con dos. */
+const rBytes = (n) => (n < 1024 ? `${n} B` : n < 1024 * 1024 ? `${(n / 1024).toFixed(1)} KB` : `${(n / 1024 / 1024).toFixed(2)} MB`)
+const rPaths = (o) => {
+  const parts = PATHS.filter((k) => (o?.[k] || 0) > 0).map((k) => `${k} ${rBytes(o[k])}`)
+  return parts.length ? parts.join(', ') : '0 B'
+}
+
+/**
+ * Los que contestaron algo (`talking`) y los que solo recibieron (`silent`, resumidos): a un
+ * aparato apagado al que se le mandó un ping no se le llama conexión. `unknown`: quien nos
+ * escribió, nunca recibió respuesta y no sabemos su llave. Tampoco es una conexión.
+ *
+ * @param {Array<object>} peers `TransportStats.peers`
+ */
+export function splitPeers (peers) {
+  const total = (o) => PATHS.reduce((n, k) => n + (o?.[k] || 0), 0)
+  const talking = []
+  const silent = { count: 0, bytesOut: 0, msgsOut: 0 }
+  const unknown = { count: 0, bytesIn: 0, msgsIn: 0 }
+  for (const p of peers) {
+    if (!((p.msgsIn || 0) > 0)) { silent.count++; silent.bytesOut += total(p.bytesOut); silent.msgsOut += p.msgsOut || 0 } else if (!p.pubkey && !((p.msgsOut || 0) > 0)) { unknown.count++; unknown.bytesIn += total(p.bytesIn); unknown.msgsIn += p.msgsIn || 0 } else talking.push(p)
+  }
+  return { talking, silent, unknown }
+}
+
+/**
+ * EL INFORME DE RED COMO TEXTO, para que lo lea una persona: las mismas líneas que el modal de
+ * red del topbar y que las apps nativas (`NetworkStats.report`). A diferencia de `formatStats`
+ * (que va a un log en disco y por eso calla la llave), este se enseña en pantalla a quien lo
+ * pidió, y dice con quién es cada conexión.
+ *
+ * @param {Array<object>} list lo que devolvió `client.stats()` de cada cliente (o `{ url, error }`)
+ * @param {{ label?: (pubkey: string) => string | Promise<string>, now?: Date }} [opts]
+ *   `label`: cómo se nombra un aparato a partir de su llave (su id `AB12-CD34`, su nombre).
+ *   Sin él, o si falla, sale `?`: nunca un trozo de la llave.
+ * @returns {Promise<string>}
+ */
+export async function netReport (list, opts = {}) {
+  const now = opts.now || new Date()
+  let out = `Dotrino network stats · ${now.toISOString().replace(/\.\d{3}Z$/, 'Z')}\n`
+  if (!list.length) out += '(no transports)\n'
+  for (const s of list) {
+    if (s.error) { out += `Proxy ${s.url} | error: ${s.error}\n`; continue }
+    const hhmm = new Date(s.since).toTimeString().slice(0, 8)
+    out += `Proxy ${s.url}${s.app ? ` | app=${s.app}` : ''}${s.node ? ` | node=${s.node}` : ''} | ${s.connected ? 'connected' : 'disconnected'} | since ${hhmm}\n`
+    out += `  proxy total: in ${rBytes(s.proxy.bytesIn)} / out ${rBytes(s.proxy.bytesOut)} (frames ${s.proxy.framesIn ?? '?'}/${s.proxy.framesOut ?? '?'})\n`
+    const { talking, silent, unknown } = splitPeers(s.peers)
+    out += `  peers: ${talking.length}\n`
+    for (const p of talking) {
+      let who = '?'
+      if (p.pubkey && opts.label) { try { who = (await opts.label(p.pubkey)) || '?' } catch (_) { who = '?' } }
+      const tok = p.token ? ` (token ${p.token})` : ''
+      out += `  - ${who}${tok} | route=${p.route} | in: ${rPaths(p.bytesIn)} | out: ${rPaths(p.bytesOut)} | ${(p.msgsIn || 0) + (p.msgsOut || 0)} msgs\n`
+    }
+    if (silent.count) out += `  no answer: ${silent.count} (out ${rBytes(silent.bytesOut)}, ${silent.msgsOut} msgs)\n`
+    if (unknown.count) out += `  unknown senders: ${unknown.count} (in ${rBytes(unknown.bytesIn)}, ${unknown.msgsIn} msgs)\n`
+  }
+  return out
+}

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

@@ -6,7 +6,7 @@
  *   `send()` payloads tagged with `_rtc`.
  * - Once the DataChannel is open, payloads from `client.send(token, ...)`
  *   travel P2P; before that (or on failure) they fall back to the proxy.
- * - STUN-only (no TURN). Symmetric NATs will simply stay on the proxy.
+ * - STUN by default; `client.enableTurn()` adds the proxy's temporary TURN servers.
  *
  * Glare resolution: the peer with the lexicographically smaller token is
  * the "polite" one (rolls back on collision).
@@ -76,6 +76,55 @@ export async function loadNodePeerConnection () {
   return _PC
 }
 
+/**
+ * EL RELEVO, FIJADO A IPv4 — solo fuera del navegador.
+ *
+ * La implementación de Node (`@dotrino/webrtc`, o sea werift) abre el socket UDP hacia el
+ * relevo en IPv4 y nada más, pero resuelve el nombre sin pedir familia. En una máquina con
+ * las dos, el nombre sale en IPv6: el pedido se manda a una dirección que ese socket no
+ * alcanza, se reintenta siete veces (6,4 s medidos) y solo entonces se cae a TCP. Y como la
+ * oferta espera a que termine de reunir candidatos, CADA negociación arrancaba 6,4 s tarde
+ * por punta — una sesión más corta que eso no salía nunca del proxio.
+ *
+ * Con la dirección ya escrita no hay nada que resolver: 30 ms, y el relevo va por UDP.
+ *
+ * Solo las `turn:`. Una `turns:` necesita el nombre para comprobar el certificado, y a un
+ * `stun:` no le pasa esto. Se envuelve desde aquí y no se toca la librería, que es una poda
+ * sin cambios de lógica (README de `dotrino-webrtc`).
+ *
+ * Si el nombre no tiene dirección IPv4, se deja como vino: esa máquina no tiene por dónde
+ * llegar en UDP, y con el nombre la librería todavía llega por TCP.
+ *
+ * @param {any[]} iceServers
+ * @param {{ native?: boolean, lookup?: (host: string) => Promise<string> }} [opts]
+ * @returns {Promise<any[]>}
+ */
+export async function pinTurnToIPv4 (iceServers, opts = {}) {
+  const native = opts.native ?? (typeof globalThis.RTCPeerConnection === 'function')
+  if (native || !Array.isArray(iceServers)) return iceServers
+  let lookup = opts.lookup
+  if (!lookup) {
+    // El nombre va en una variable para que ningún empaquetador lo siga: esto lo importan
+    // las apps de navegador, donde `node:dns` no existe (y donde no se llega hasta aquí).
+    const mod = 'node:dns'
+    const dns = await import(mod)
+    lookup = async (host) => (await dns.promises.lookup(host, { family: 4 })).address
+  }
+  const cache = new Map()
+  const pin = async (url) => {
+    const m = /^(turn:)([^:?[\]]+)((?::\d+)?(?:\?.*)?)$/i.exec(String(url).trim())
+    if (!m || /^[\d.]+$/.test(m[2])) return url
+    if (!cache.has(m[2])) cache.set(m[2], lookup(m[2]).catch(() => null))
+    const ip = await cache.get(m[2])
+    return ip ? m[1] + ip + m[3] : url
+  }
+  return Promise.all(iceServers.map(async (s) => {
+    if (!s || s.urls == null) return s
+    const urls = Array.isArray(s.urls) ? await Promise.all(s.urls.map(pin)) : await pin(s.urls)
+    return { ...s, urls }
+  }))
+}
+
 export class WebRTCManager {
   /**
    * @param {object} opts

package/vault/vendor/vault/VERSION.txt

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

@@ -217,7 +217,10 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null,
       label: x.label || '', scope: x.scope, seq: x.seq, nonce: x.nonce
     })))
-    send(from, { type: MSG.DEVICES_RESULT, devices, revoked: (revoked || []).map((r) => r.nonce || r) })
+    // La cadena de selladores va con la lista (como en el daemon): es lo que un aparato de
+    // Node necesita para firmar a nombre de la cuenta de forma que un extraño lo compruebe.
+    const sealerChain = await identity.sealerChain?.().catch(() => null) || null
+    send(from, { type: MSG.DEVICES_RESULT, devices, revoked: (revoked || []).map((r) => r.nonce || r), sealerChain })
     // ¿el que consulta es una máquina revocada que reapareció? → re-emite el REVOKED firmado.
     // Se busca en `revokedCerts`: desde que `issued` solo trae lo vigente, los retirados
     // ya no están ahí y este aviso dejaba de dispararse (se caía en silencio).