@dotrino/remote-agent 0.12.1 → 0.14.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`):

package/package.json

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

package/src/agent.js

@@ -23,6 +23,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { verifyChain, signWithDevice, verifyDeviceSig, pubkeyId } from '@dotrino/identity/capabilities'
 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 { HS, ACK, DATA, PING, PONG, ERROR, VMSG, SIGN_SCOPE, SESSION_TTL_MS, REVOKE_REFRESH_MS } from '../protocol.js'
@@ -157,7 +158,7 @@ export async function startRemoteAgent (opts = {}) {
       revokedSet = new Set((res.revoked || []).map((r) => r.nonce || r))
       // El acta viaja con la lista. Apuntar su `seq` es lo que dispara la renovación en el
       // mismo tic si el dueño nos cambió los permisos.
-      anotarActa(res.acta)
+      await anotarActa(res.acta)
     } catch (e) {
       if (!opts.quiet) console.error('[remote-agent] could not refresh revocations (using cache):', e.message)
     }
@@ -210,23 +211,43 @@ export async function startRemoteAgent (opts = {}) {
   }
 
   /**
-   * Guarda el acta que manda la bóveda. Hace dos cosas, y las dos hacen falta:
+   * Guarda el acta que manda la bóveda, SOLO SI SE PUEDE COMPROBAR (`record.js`). Hace dos
+   * cosas, y las dos hacen falta:
    *   · dispara la renovación cuando su `seq` pasa al del papel que tenemos;
    *   · es CON LO QUE SE JUZGA a quien nos habla — quien firma tiene que ser selladora de
    *     este perfil, y eso solo lo dice el acta. Por eso se PERSISTE: si viviera en memoria,
    *     al reiniciar el agente no podría atender a nadie hasta el primer tic.
+   *
+   * Antes se guardaba lo que llegara, de quien llegara: la respuesta de la bóveda no trae
+   * remitente comprobable, así que cualquiera que conociera la llave de esta máquina podía
+   * mandar un acta inventada y nombrarse miembro. Ahora el acta tiene que encadenar desde la
+   * que ya se dio por buena, o venir firmada por la bóveda con la que se enroló.
    */
-  function anotarActa (acta) {
-    if (typeof acta?.seq !== 'number' || link.acta?.seq === acta.seq) return
+  async function anotarActa (acta) {
+    if (typeof acta?.seq !== 'number') return
+    const r = await adoptRecord({ link, candidate: acta, me: myPub })
+    if (!r.adopt) {
+      if (r.reason !== 'misma-acta') {
+        audit('record-rejected', { seq: acta.seq, reason: r.reason })
+        if (!opts.quiet) console.error(`[remote-agent] record #${acta.seq} rejected (${r.reason}); keeping the one already trusted`)
+      }
+      return
+    }
     link.acta = acta
     link.actaSeq = acta.seq
+    link.actaTrusted = true
     try { saveLink(dir, link) } catch (_) {}
   }
 
-  /** El acta con la que se juzga un papel. Sin ella no se atiende a nadie. */
-  const contextoActa = () => (link.acta
-    ? { actaSeq: link.acta.seq, sealers: sealersOf(link.acta) }
-    : { actaSeq: null, sealers: null })
+  /**
+   * El acta con la que se juzga un papel. Sin ella no se atiende a nadie — y un acta que
+   * nunca se comprobó (la que guardó una versión anterior) cuenta como no tenerla.
+   */
+  const actaDeConfianza = () => (link.actaTrusted === true && link.acta ? link.acta : null)
+  const contextoActa = () => {
+    const acta = actaDeConfianza()
+    return acta ? { actaSeq: acta.seq, sealers: sealersOf(acta) } : { actaSeq: null, sealers: null }
+  }
 
   const vaultTick = async () => { await refreshRevocations(); await renewCertIfNeeded() }
   vaultTick()
@@ -268,8 +289,9 @@ export async function startRemoteAgent (opts = {}) {
     // abrir sesión con otro agente. El bot social se pasó así el 1 de septiembre, con un
     // node de contenido encendido a su lado que le contestaba «ese aparato no firma por este
     // perfil». Se le pide lo que corresponde: que el acta lo nombre y le reconozca `sign`.
-    const isMember = (link.acta?.members || []).some((m) => m?.pub === chk.device)
-    if (!isMember || !memberCan(link.acta, chk.device, 'sign')) {
+    const acta = actaDeConfianza()
+    const isMember = (acta?.members || []).some((m) => m?.pub === chk.device)
+    if (!acta || !isMember || !memberCan(acta, chk.device, 'sign')) {
       return send(from, { type: ERROR, error: 'no autorizado: acta — este perfil no reconoce a ese aparato' })
     }
     if (data.op !== HS || typeof data.eph !== 'string') return send(from, { type: ERROR, error: 'handshake inválido' })
@@ -295,7 +317,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,11 @@ export class RemoteAgentClient {
     this.client = null
     this.key = null
     this.sid = null
-    this._h = { message: [], error: [] }
+    this._h = { message: [], error: [], resumed: [] }
+    this._resuming = null
   }
 
-  /** 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)
@@ -101,10 +102,40 @@ export class RemoteAgentClient {
       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
@@ -151,11 +182,12 @@ 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 })
   }

package/src/link.js

@@ -19,6 +19,7 @@ import os from 'node:os'
 import { signWithDevice, pubkeyId } from '@dotrino/identity/capabilities'
 import { requestDevices, requestRenew } from '@dotrino/identity/vault/remote.js'
 import { installNodeGlobals } from '../node-globals.js'
+import { adoptRecord } from './record.js'
 
 export function dataDir (name = 'dotrino-remote-agent') {
   if (process.env.DOTRINO_REMOTE_AGENT_DIR) return process.env.DOTRINO_REMOTE_AGENT_DIR
@@ -177,8 +178,13 @@ export async function renewLink (link, { dir = dataDir(), force = false } = {})
     // esto no se persiste la máquina se queda usando uno revocado y fuera para siempre. Le
     // pasó al registro de selladores en la migración, y por eso está dicho aquí.
     link.cert = cert
-    link.acta = acta
     link.actaSeq = acta.seq
+    // El acta que viaja con el papel se guarda SOLO si se puede comprobar (`record.js`): es
+    // la que decide quién abre sesión con este agente. El papel sí se guarda siempre.
+    if ((await adoptRecord({ link, candidate: acta, me: link.device.publickey })).adopt) {
+      link.acta = acta
+      link.actaTrusted = true
+    }
     saveLink(dir, link)
     return { renewed: true, seq: cert.seq }
   } catch (e) {

package/src/record.js

@@ -0,0 +1,37 @@
+/**
+ * record.js — ¿se puede dar por buena el acta que acaba de llegar?
+ *
+ * El acta decide quién abre sesión con el agente, así que no se guarda ninguna que no se
+ * pueda comprobar. Hay dos casos y ninguno más:
+ *
+ *   · YA HAY una de confianza → la nueva tiene que encadenar desde ella (`canAdopt` del
+ *     pilar: misma cuenta, bien firmada, sellada por quien la anterior nombra selladora, y
+ *     nunca hacia atrás).
+ *   · TODAVÍA NO (recién enrolado, o el acta la guardó una versión que no comprobaba nada)
+ *     → solo vale una firmada por LA BÓVEDA CON LA QUE SE ENROLÓ (`link.iss`, la única llave
+ *     que esta máquina tiene fijada), que nombre a esta máquina y no sea anterior a su papel.
+ *     Si la última acta de la cuenta la selló otra selladora, no hay con qué comprobarla
+ *     desde aquí: no se adopta, y toca enrolar de nuevo.
+ *
+ * Sin dependencias de Node: lo usa el agente y se prueba solo.
+ */
+import { canAdopt, verifyActa, samePubkey } from '@dotrino/identity/acta'
+
+/**
+ * @param {{ link: any, candidate: any, me: string }} args  `me` = la llave pública de esta máquina.
+ * @returns {Promise<{ adopt: boolean, reason: string }>}
+ */
+export async function adoptRecord ({ link, candidate, me }) {
+  if (!candidate || typeof candidate.seq !== 'number') return { adopt: false, reason: 'shape' }
+  if (link?.actaTrusted === true && link.acta) return canAdopt({ candidate, current: link.acta })
+
+  if (typeof link?.iss !== 'string') return { adopt: false, reason: 'no-pinned-vault' }
+  const v = await verifyActa({ acta: candidate })
+  if (!v.ok) return { adopt: false, reason: v.reason }
+  if (!samePubkey(candidate.sealedBy, link.iss)) return { adopt: false, reason: 'not-sealed-by-pinned-vault' }
+  if (!(candidate.members || []).some((m) => samePubkey(m?.pub, me))) return { adopt: false, reason: 'not-a-member' }
+  if (typeof link.cert?.seq === 'number' && candidate.seq < link.cert.seq) return { adopt: false, reason: 'older-than-cert' }
+  return { adopt: true, reason: 'sealed-by-pinned-vault' }
+}
+
+export default { adoptRecord }