@dotrino/remote-agent 0.14.0 → 0.15.0

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.0",
   "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

@@ -97,14 +97,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
@@ -253,8 +262,6 @@ export async function startRemoteAgent (opts = {}) {
   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) {

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. */