@dotrino/remote-agent 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/remote-agent",
-  "version": "0.12.0",
+  "version": "0.13.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",
@@ -51,8 +51,8 @@
     "@dotrino/vault": ">=0.64.0"
   },
   "devDependencies": {
-    "@dotrino/identity": "0.92.0",
-    "@dotrino/proxy-client": "0.18.2",
-    "@dotrino/vault": "0.64.0"
+    "@dotrino/identity": "0.105.0",
+    "@dotrino/proxy-client": "0.25.0",
+    "@dotrino/vault": "0.75.0"
   }
 }

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' })

package/src/client.js

@@ -169,7 +169,8 @@ export class RemoteAgentClient {
       })
       setTimeout(() => { off(); resolve(false) }, timeoutMs)
     })
-    this.client.sendByPubkey(this.agentPubkey, { type: PING, n })
+    // Efímero, como `probeAgents`: si no está, no se encola ni se le timbra.
+    this.client.sendByPubkey(this.agentPubkey, { type: PING, n }, { ephemeral: true })
     return got
   }
 

package/src/discover.js

@@ -73,7 +73,11 @@ export function probeAgents (client, subs, { timeoutMs = 3000 } = {}) {
     for (const sub of subs) {
       const n = [...crypto.getRandomValues(new Uint8Array(8))].map((x) => x.toString(16).padStart(2, '0')).join('')
       bySub.set(n, sub)
-      try { client.sendByPubkey(sub, { type: PING, n }) } catch (_) {}
+      // EFÍMERO: una pregunta de «¿estás ahí?» solo vale en vivo. Sin esto el proxio la
+      // ENCOLABA para quien no estaba conectado y le tocaba el timbre: la app preguntaba a
+      // todos los aparatos de la cuenta y el teléfono sonaba cada minuto sin ningún pedido
+      // detrás (2026-09-30). Quien no contesta ahora, no está; eso es la respuesta.
+      try { client.sendByPubkey(sub, { type: PING, n }, { ephemeral: true }) } catch (_) {}
     }
     setTimeout(() => { try { off() } catch (_) {} resolve(found) }, timeoutMs)
   })

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 }