@dotrino/remote-agent 0.14.0 → 0.15.1

package/README.md

@@ -182,6 +182,19 @@ extraerlo luego a este paquete.
 - **Auditoría** local de cada sesión abierta.
 - El relay de transporte (`proxy.dotrino.com`) **solo ve bytes cifrados**.
 
+## Por dónde viaja: el camino más directo (0.15.0+)
+
+El saludo sale por el proxio, dirigido a la pubkey del agente. En cuanto el agente contesta,
+las dos puntas se hablan **por token**, y el pilar sube solo a un canal WebRTC: en la misma
+red los datos de la sesión no salen a internet. Si el canal no sale, sigue por el proxio.
+
+- **En Node hace falta una implementación de WebRTC.** El agente que quiera canal directo
+  declara `@dotrino/webrtc` en sus `optionalDependencies`; sin él, todo sigue por el proxio.
+- **Quién puede negociar un canal directo:** en el agente, solo un token con sesión abierta;
+  en el cliente, solo el token que contestó su saludo.
+- Si el agente se reinicia, su token muere: el mensaje sale por su pubkey, el agente
+  contesta `unknown-session` y el cliente vuelve a saludar.
+
 ## Dependencias
 
 - `@dotrino/identity` (capabilities: `verifyChain`, `signWithDevice`, `verifyDeviceSig`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/remote-agent",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "Middleware compartido del ecosistema Dotrino para apps de agente remoto cifrado punto a punto (handshake E2E, emparejamiento SAS con vault, revocación, descubrimiento). Lo consumen dotrino-terminal (PTY) y dotrino-ia (chat con IA).",
   "type": "module",
   "main": "./index.js",
@@ -47,12 +47,12 @@
   ],
   "peerDependencies": {
     "@dotrino/identity": ">=0.92.0",
-    "@dotrino/proxy-client": ">=0.18.2",
+    "@dotrino/proxy-client": ">=0.29.0",
     "@dotrino/vault": ">=0.64.0"
   },
   "devDependencies": {
     "@dotrino/identity": "0.105.0",
-    "@dotrino/proxy-client": "0.25.0",
+    "@dotrino/proxy-client": "0.29.0",
     "@dotrino/vault": "0.75.0"
   }
 }

package/src/agent.js

@@ -26,6 +26,7 @@ import { sealersOf, memberCan, checkVaultReply } from '@dotrino/identity/acta'
 import { adoptRecord } from './record.js'
 import { installNodeGlobals } from '../node-globals.js'
 import { makeEphemeral, deriveKey, seal, open } from '../e2e.js'
+import { makeCatchUp } from './catch-up.js'
 import { HS, ACK, DATA, PING, PONG, ERROR, VMSG, SIGN_SCOPE, SESSION_TTL_MS, REVOKE_REFRESH_MS } from '../protocol.js'
 import { loadLink, saveLink, dataDir } from './link.js'
 
@@ -97,14 +98,23 @@ export async function startRemoteAgent (opts = {}) {
 
   installNodeGlobals(dir)
 
+  // sid -> AgentSession
+  const sessions = new Map()
+  const hasSessionFrom = (token) => { for (const s of sessions.values()) if (s.from === token) return true; return false }
+
   const proxyUrl = opts.proxyUrl || process.env.PROXY_URL || link.proxy || 'wss://proxy.dotrino.com'
   // `client` inyectado: solo para las pruebas (transporte de mentira). En producción se
   // levanta el del ecosistema — no hay otro transporte.
   const client = opts.client || await (async () => {
     const { getWebSocketProxyClient } = await import('@dotrino/proxy-client')
+    // SIEMPRE EL CAMINO MÁS DIRECTO: WebRTC encendido (si la máquina tiene con qué: el
+    // pilar carga `@dotrino/webrtc` si está instalado, y si no sigue por el proxio).
+    // Solo negocia canal directo quien YA tiene una sesión abierta: negociar arranca
+    // DTLS/ICE/SCTP, y eso no lo dispara cualquiera que conozca el token.
     const c = getWebSocketProxyClient({
-      url: proxyUrl, enableWebRTC: false, autoReconnect: true,
-      maxReconnectAttempts: 100000, reconnectDelay: 4000
+      url: proxyUrl, autoReconnect: true,
+      maxReconnectAttempts: 100000, reconnectDelay: 4000,
+      acceptDirectFrom: (token) => hasSessionFrom(token)
     })
     await c.connect()
     return c
@@ -250,11 +260,11 @@ export async function startRemoteAgent (opts = {}) {
   }
 
   const vaultTick = async () => { await refreshRevocations(); await renewCertIfNeeded() }
+  /** Trae el acta ahora (con freno) y dice si AVANZÓ: solo entonces merece juzgar otra vez. */
+  const catchUp = makeCatchUp({ refresh: vaultTick, seq: () => link.actaSeq })
   vaultTick()
   const revTimer = setInterval(vaultTick, REVOKE_REFRESH_MS); revTimer.unref?.()
 
-  // sid -> AgentSession
-  const sessions = new Map()
   const sweeper = setInterval(() => {
     const now = Date.now()
     for (const [sid, s] of sessions) {
@@ -273,8 +283,25 @@ export async function startRemoteAgent (opts = {}) {
     // Manda el acta, no una llave fija: con varias selladoras el papel de un peer puede
     // venir firmado por otra bóveda del mismo perfil. Sin acta no se atiende — no hay con
     // qué decidir, así que no se decide que sí.
-    const chk = await verifyChain({ data, signature, cert, expectedScope: SIGN_SCOPE, ...contextoActa(), revoked: revokedSet })
-    if (!chk.ok) return send(from, { type: ERROR, error: 'no autorizado: ' + chk.reason })
+    // SE JUZGA, Y SI NO PASA SE PREGUNTA A LA BÓVEDA ANTES DE DECIR QUE NO. El acta se trae cada
+    // `REVOKE_REFRESH_MS` (5 min), así que un aparato recién emparejado era un desconocido hasta
+    // el siguiente tic: «este perfil no reconoce a ese aparato» nada más emparejar (un iPhone, el
+    // 2026-10-07). Ahora, ante un rechazo, se trae el acta EN EL MOMENTO y se juzga otra vez, una
+    // sola — y solo si el acta avanzó. Con freno (`catchUp`): cualquiera puede mandar saludos, y
+    // no por eso se le pregunta a la bóveda cada vez.
+    const judge = async () => {
+      const chk = await verifyChain({ data, signature, cert, expectedScope: SIGN_SCOPE, ...contextoActa(), revoked: revokedSet })
+      if (!chk.ok) return { error: 'no autorizado: ' + chk.reason }
+      return { chk }
+    }
+    let verdict = await judge()
+    const known = (v) => {
+      const acta = actaDeConfianza()
+      return !!acta && (acta.members || []).some((m) => m?.pub === v.chk.device) && memberCan(acta, v.chk.device, 'sign')
+    }
+    if ((verdict.error || !known(verdict)) && await catchUp()) verdict = await judge()
+    if (verdict.error) return send(from, { type: ERROR, error: verdict.error })
+    const chk = verdict.chk
     // CERT ∩ ACTA. `verifyChain` comprueba QUIÉN EMITIÓ el papel; que el APARATO siga siendo
     // isMember y pueda firmar lo dice el acta, y hay que preguntárselo aparte. Sin esto, un
     // papel bien firmado por una selladora abría sesión aunque el acta no nombrara a ese

package/src/catch-up.js

@@ -0,0 +1,29 @@
+/**
+ * catch-up.js — ponerse al día con la bóveda ANTES de rechazar a alguien.
+ *
+ * El agente trae el acta cada pocos minutos. Entre un tic y el siguiente no sabe de un aparato
+ * recién emparejado, y lo rechazaba. `makeCatchUp` da una función que trae el acta en el momento
+ * y contesta si avanzó — con un freno, porque un saludo lo puede mandar cualquiera y no por eso se
+ * le pregunta a la bóveda cada vez.
+ *
+ * @param {{ refresh: () => Promise<void>, seq: () => (number|null|undefined), minGapMs?: number, now?: () => number }} o
+ * @returns {() => Promise<boolean>} true si el acta avanzó (y vale la pena juzgar otra vez).
+ */
+export const CATCH_UP_GAP_MS = 10_000
+
+export function makeCatchUp ({ refresh, seq, minGapMs = CATCH_UP_GAP_MS, now = Date.now }) {
+  let last = -Infinity
+  let running = null
+  return async () => {
+    // Uno a la vez: los saludos que lleguen mientras tanto esperan a ese mismo y usan su resultado.
+    if (running) return running
+    if (now() - last < minGapMs) return false
+    last = now()
+    const before = seq()
+    running = (async () => {
+      try { await refresh() } catch (_) { return false }
+      return seq() !== before
+    })().finally(() => { running = null })
+    return running
+  }
+}

package/src/client.js

@@ -43,6 +43,10 @@ export class RemoteAgentClient {
     this.sid = null
     this._h = { message: [], error: [], resumed: [] }
     this._resuming = null
+    // El token del agente: una vez que contesta el saludo se le habla POR TOKEN, que es lo
+    // único que sube a WebRTC. `null` es «todavía no lo sé» y se va por su pubkey.
+    this.agentToken = null
+    this._directPeers = new Set()
   }
 
   /** Suscribe a eventos. Devuelve un `off()` para desuscribir. Eventos: message, error, resumed. */
@@ -90,13 +94,27 @@ export class RemoteAgentClient {
   async connect () {
     if (!this.agentPubkey) throw new Error('falta la dirección del agente destino')
     const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-    this.client = new WebSocketProxyClient({ url: this.proxyUrl, enableWebRTC: false, autoReconnect: true })
+    // SIEMPRE EL CAMINO MÁS DIRECTO: WebRTC encendido. Estuvo en `false` desde el 0.1.0
+    // porque entonces Node no tenía con qué; se quedó así cuando ya lo tuvo, y dos equipos
+    // en la misma red se hablaban dando la vuelta por el proxio.
+    // Solo negocia canal directo quien contestó NUESTRO saludo.
+    this.client = new WebSocketProxyClient({
+      url: this.proxyUrl, autoReconnect: true,
+      acceptDirectFrom: (token) => this._directPeers.has(token)
+    })
     await this.client.connect()
     await this._identify()
     if (this.link.mode !== 'self') {
       this.client.on('token', () => { this._identify().catch(() => {}) })
     }
 
+    // El agente se reinició: su token ya no existe. El pilar ya mandó ese mensaje por su
+    // pubkey; aquí solo se deja de usar el token hasta el próximo saludo.
+    this.client.on('token_gone', (token) => {
+      this._directPeers.delete(token)
+      if (token === this.agentToken) this.agentToken = null
+    })
+
     this.client.on('message', async (_from, p) => {
       if (!p || typeof p !== 'object') return
       if (p.type === DATA && p.sid === this.sid) {
@@ -151,15 +169,23 @@ export class RemoteAgentClient {
     // varias sesiones simultáneas (varios RemoteAgentClient sobre la misma pubkey)
     // no se roban el ACK de la otra.
     const acked = new Promise((resolve, reject) => {
-      const off = this.client.on('message', (_from, p) => {
+      const off = this.client.on('message', (from, p) => {
         if (!p || typeof p !== 'object') return
-        if (p.type === ACK && p.ack && p.ack.ceph === eph.pub) { off(); resolve(p) }
+        // El token se apunta AQUÍ, en el mismo tic: si el agente es quien abre el canal
+        // directo, su oferta llega justo detrás del ack y tiene que encontrarlo ya.
+        if (p.type === ACK && p.ack && p.ack.ceph === eph.pub) { off(); if (from) this._directPeers.add(from); resolve({ ...p, from }) }
         else if (p.type === ERROR) { off(); reject(new Error(p.error)) }
       })
       setTimeout(() => { off(); reject(new Error('el agente no respondió (¿está corriendo allí?)')) }, 20000)
     })
     this.client.sendByPubkey(this.agentPubkey, { type: HS, data, signature, cert })
     const res = await acked
+    try { await this._checkAck(res, eph) } catch (e) { this._directPeers.delete(res.from); throw e }
+    this.agentToken = res.from || null
+  }
+
+  /** Comprueba el ack y deja `sid` y `key`. */
+  async _checkAck (res, eph) {
 
     // El ack debe: (1) encadenar a NUESTRA maestra, (2) estar firmado por el agente
     // que apuntamos, (3) atar nuestra pub efímera y el sid.
@@ -189,7 +215,11 @@ export class RemoteAgentClient {
     if (this._resuming) await this._resuming
     if (!this.key) throw Object.assign(new Error('no session with the agent'), { code: 'no-session' })
     const env = await seal(this.key, payload)
-    this.client.sendByPubkey(this.agentPubkey, { type: DATA, sid: this.sid, env })
+    const msg = { type: DATA, sid: this.sid, env }
+    // Por token en cuanto se sabe: sube al canal directo, y si el token murió el pilar lo
+    // saca por la pubkey. Por pubkey solo mientras no hay token.
+    if (this.agentToken) this.client.sendToOrQueue(this.agentToken, msg, { peerPubkey: this.agentPubkey })
+    else this.client.sendByPubkey(this.agentPubkey, msg)
   }
 
   /** Sonda de presencia (liveness) sin abrir sesión. Devuelve true si responde. */