@dotrino/remote-agent 0.17.0 → 0.18.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/remote-agent",
-  "version": "0.17.0",
+  "version": "0.18.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",

package/protocol.js

@@ -39,6 +39,11 @@ export const SIGN_SCOPE = 'vault:sign'
 /** Vigencia de una sesión inactiva y refresco de la lista de revocados. */
 export const SESSION_TTL_MS = 30 * 60 * 1000
 export const REVOKE_REFRESH_MS = 5 * 60 * 1000
+/**
+ * Cuánto se espera a un cliente cuya conexión se fue antes de cerrarle la sesión. Un cliente
+ * que reconecta sigue con su sesión desde un token nuevo: si en este plazo manda algo, se queda.
+ */
+export const SESSION_GONE_MS = 20 * 1000
 
 /**
  * RENOVACIÓN del cert de esta máquina. El cert dura 30 días; se pide uno fresco

package/src/agent.js

@@ -27,17 +27,18 @@ 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 { HS, ACK, DATA, PING, PONG, ERROR, VMSG, SIGN_SCOPE, SESSION_TTL_MS, SESSION_GONE_MS, REVOKE_REFRESH_MS } from '../protocol.js'
 import { loadLink, saveLink, dataDir } from './link.js'
 
 /** Sesión cifrada con un dispositivo cliente. La app recibe esto en `onSession`. */
 class AgentSession {
-  constructor ({ sid, key, from, device, send }) {
+  constructor ({ sid, key, from, device, send, isDirect = null }) {
     this.sid = sid
     this.key = key
     this.from = from                  // token del cliente en el proxy
     this.device = device              // pubkey del dispositivo cliente
     this._send = send                 // (to, obj) => void
+    this._isDirect = isDirect         // (token) => boolean, o null si el transporte no lo sabe
     this._h = { message: [], close: [] }
     this._closed = false
   }
@@ -49,6 +50,33 @@ class AgentSession {
     if (env) this._send(this.from, { type: DATA, sid: this.sid, env })
   }
 
+  /**
+   * ¿VA YA POR EL CANAL DIRECTO (WebRTC) lo que se le mande a este cliente? Mientras sea
+   * `false`, cada `send` da la vuelta por el proxio. Sirve para que la app decida qué manda
+   * YA y qué puede esperar: nunca para dejar de mandar (subir de escalón no bloquea).
+   */
+  direct () {
+    if (this._closed || !this._isDirect) return false
+    try { return !!this._isDirect(this.from) } catch (_) { return false }
+  }
+
+  /**
+   * Espera a que abra el canal directo, como mucho `ms`. Resuelve `true` si abrió y `false`
+   * si se acabó el plazo o la sesión se cerró — en los dos casos se sigue, por donde haya.
+   */
+  whenDirect (ms = 8000) {
+    return new Promise((resolve) => {
+      const until = Date.now() + ms
+      const look = () => {
+        if (this.direct()) return resolve(true)
+        if (this._closed || Date.now() >= until) return resolve(false)
+        const t = setTimeout(look, 100)
+        t.unref?.()
+      }
+      look()
+    })
+  }
+
   on (ev, cb) { this._h[ev]?.push(cb); return this }
 
   async _ingest (env) {
@@ -60,6 +88,7 @@ class AgentSession {
   close () {
     if (this._closed) return
     this._closed = true
+    clearTimeout(this._gone)
     for (const h of this._h.close) { try { h() } catch (_) {} }
   }
 }
@@ -77,6 +106,7 @@ class AgentSession {
  * @param {()=>void} [opts.onRevoked] se llamó al auto-borrarse por revocación.
  * @param {()=>void} [opts.onReady]   agente listo y escuchando.
  * @param {boolean} [opts.quiet]      sin logs.
+ * @param {number} [opts.sessionGoneMs]  cuánto se espera a un cliente cuya conexión se fue (`SESSION_GONE_MS`).
  * @param {number} [opts.netLogMs]    cada cuánto van al log las estadísticas de red (5 min).
  * @param {object} [opts.client]      transporte ya conectado (SOLO pruebas).
  *
@@ -375,7 +405,7 @@ export async function startRemoteAgent (opts = {}) {
     const ack = { op: ACK, sid, seph: eph.pub, ceph: data.eph, machine: myPub, publickey: myPub, ts: Date.now() }
     const { signature: ackSig } = await signWithDevice({ privateJwk: link.device.privateJwk, data: ack })
 
-    const session = new AgentSession({ sid, key, from, device: chk.device, send })
+    const session = new AgentSession({ sid, key, from, device: chk.device, send, isDirect: typeof client.isWebRTCOpen === 'function' ? (t) => client.isWebRTCOpen(t) : null })
     session._exp = Date.now() + SESSION_TTL_MS
     sessions.set(sid, session)
     audit('session-open', { sid: sid.slice(0, 8), device: (await pubkeyId(chk.device)).slice(0, 8).toUpperCase() })
@@ -392,9 +422,27 @@ export async function startRemoteAgent (opts = {}) {
     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
+    if (s._gone) { clearTimeout(s._gone); s._gone = null }
     s._ingest(p.env).catch(() => send(from, { type: ERROR, error: 'sobre inválido' }))
   }
 
+  // LA CONEXIÓN DEL CLIENTE SE FUE: su sesión no se queda 30 minutos. El proxio avisa de que ese
+  // token murió (`peer_disconnected`); un token no vuelve, así que quien sigue vivo manda desde
+  // otro y la sesión se queda (`handleData`). Si en `SESSION_GONE_MS` no llega nada, se cierra.
+  // Antes solo vencía por `SESSION_TTL_MS`: un teléfono que volvía del fondo abría sesión nueva
+  // y la vieja seguía enganchada a su consola (seis del mismo aparato en una, el 2026-10-09).
+  const goneMs = opts.sessionGoneMs ?? SESSION_GONE_MS
+  client.on('peer_disconnected', (token) => {
+    for (const [sid, s] of sessions) {
+      if (s.from !== token || s._gone) continue
+      s._gone = setTimeout(() => {
+        s.close(); sessions.delete(sid)
+        audit('session-gone', { sid: sid.slice(0, 8) })
+      }, goneMs)
+      s._gone.unref?.()
+    }
+  })
+
   // POR DÓNDE VA EL TRÁFICO, AL LOG. Un agente no tiene topbar: sin esto, saber si una
   // sesión subió a WebRTC o sigue dando la vuelta por el proxio pedía una prueba aparte.
   // Lo escribe el pilar (`logStats`), que lee los clientes del proceso; aquí solo se enciende.