@dotrino/remote-agent 0.13.0 → 0.15.0

package/README.md

@@ -141,6 +141,16 @@ chat.send({ type: 'msg', text: 'arreglá el bug en auth.js' })
 const online = await chat.ping()  // liveness sin abrir sesión
 ```
 
+**Si el agente se reinicia, el cliente vuelve a saludar solo** (≥ 0.14.0). Las sesiones viven
+en la memoria del agente: tras reiniciarse contesta `unknown-session` a lo que le llegue con un
+`sid` viejo, el cliente abre otra sesión y avisa con `resumed`. Lo que la app tenía abierto allí
+(una consola, una conversación) puede no existir ya: eso lo decide la app en ese evento. Lo que
+se mande mientras tanto sale con la sesión nueva.
+
+```js
+chat.on('resumed', () => volverAEngancharme())   // p. ej. la terminal: attach, u open si ya no está
+```
+
 **Encontrar los agentes de UN tipo: pregúntaselo a ellos, no al nombre del acta.** El label
 del acta lo pone el dueño al emparejar («TerminalLocal»), así que filtrar por él no encuentra
 nada. El pong de cada agente dice qué es (el `label` con que arrancó `startRemoteAgent`):
@@ -172,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.13.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) {
@@ -317,7 +324,10 @@ export async function startRemoteAgent (opts = {}) {
 
   function handleData (from, p) {
     const s = sessions.get(p.sid)
-    if (!s) return send(from, { type: ERROR, error: 'sesión desconocida o expirada' })
+    // Con `code` y el `sid`: así el cliente sabe que es SU sesión la que se perdió (el agente
+    // se reinició, o venció) y vuelve a saludar solo, en vez de quedarse con un error. Se
+    // comprueba por el código, no por la frase.
+    if (!s) return send(from, { type: ERROR, code: 'unknown-session', sid: p.sid, error: 'sesión desconocida o expirada' })
     s._exp = Date.now() + SESSION_TTL_MS
     s.from = from
     s._ingest(p.env).catch(() => send(from, { type: ERROR, error: 'sobre inválido' }))

package/src/client.js

@@ -41,10 +41,15 @@ export class RemoteAgentClient {
     this.client = null
     this.key = null
     this.sid = null
-    this._h = { message: [], error: [] }
+    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. */
+  /** Suscribe a eventos. Devuelve un `off()` para desuscribir. Eventos: message, error, resumed. */
   on (ev, cb) {
     if (!this._h[ev]) this._h[ev] = []
     this._h[ev].push(cb)
@@ -89,22 +94,66 @@ 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) {
         try { const m = await open(this.key, p.env); this._emit('message', m) } catch {}
       } else if (p.type === ERROR) {
-        this._emit('error', new Error(p.error))
+        this._onAgentError(p)
       }
     })
 
+    await this._handshake()
+    return this
+  }
+
+  /**
+   * Un error del agente. Si es que ya no conoce NUESTRA sesión (se reinició: las sesiones
+   * viven en su memoria), se vuelve a saludar solo y se avisa con `resumed`; lo que la app
+   * tenía abierto allí lo decide la app. Cualquier otro error, o no poder volver a saludar,
+   * sale por `error`. Un `unknown-session` de un `sid` que ya no es el nuestro (llegó tarde,
+   * de antes de volver a saludar) no dice nada nuevo y se ignora.
+   */
+  _onAgentError (p) {
+    if (p.code !== 'unknown-session') { this._emit('error', Object.assign(new Error(p.error), { code: p.code })); return }
+    if (p.sid !== this.sid) return
+    this._resume()
+  }
+
+  /** Vuelve a saludar, una sola vez aunque lleguen varios errores seguidos. */
+  _resume () {
+    if (this._resuming) return this._resuming
+    this.key = null
+    this._resuming = this._handshake()
+      .then(() => { this._emit('resumed', { sid: this.sid }) })
+      .catch((e) => { this._emit('error', e) })
+      .finally(() => { this._resuming = null })
+    return this._resuming
+  }
+
+  /** El saludo: abre una sesión con el agente y deja `sid` y `key`. */
+  async _handshake () {
     const eph = await makeEphemeral()
     // El self-cert P←P del modo self puede vencerse (24 h): refrescarlo si hace falta.
     let cert = this.link.cert
@@ -120,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.
@@ -151,13 +208,18 @@ export class RemoteAgentClient {
 
     this.sid = res.sid
     this.key = await deriveKey(eph.privateKey, res.ack.seph, res.sid)
-    return this
   }
 
-  /** Envía un payload de dominio cifrado al agente. */
+  /** Envía un payload de dominio cifrado al agente (si se está volviendo a saludar, después). */
   async send (payload) {
+    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. */