@dotrino/remote-agent 0.18.2 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/remote-agent",
-  "version": "0.18.2",
+  "version": "0.19.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",
@@ -46,12 +46,12 @@
     "p2p"
   ],
   "peerDependencies": {
-    "@dotrino/identity": ">=0.92.0",
+    "@dotrino/identity": ">=0.112.0",
     "@dotrino/proxy-client": ">=0.30.0",
     "@dotrino/vault": ">=0.64.0"
   },
   "devDependencies": {
-    "@dotrino/identity": "0.105.0",
+    "@dotrino/identity": "0.112.0",
     "@dotrino/proxy-client": "0.30.0",
     "@dotrino/vault": "0.75.0"
   }

package/src/agent.js

@@ -31,7 +31,7 @@ import { HS, ACK, DATA, PING, PONG, ERROR, VMSG, SIGN_SCOPE, SESSION_TTL_MS, SES
 import { loadLink, saveLink, dataDir } from './link.js'
 
 /** Sesión cifrada con un dispositivo cliente. La app recibe esto en `onSession`. */
-class AgentSession {
+export class AgentSession {
   constructor ({ sid, key, from, device, send, isDirect = null }) {
     this.sid = sid
     this.key = key
@@ -44,10 +44,16 @@ class AgentSession {
   }
 
   /** Envía un payload de dominio cifrado al cliente. */
-  async send (payload) {
-    if (this._closed) return
-    const env = await seal(this.key, payload).catch(() => null)
-    if (env) this._send(this.from, { type: DATA, sid: this.sid, env })
+  send (payload) {
+    if (this._closed) return Promise.resolve()
+    // SALEN EN EL ORDEN EN QUE SE PIDIERON. Cifrar tarda según el tamaño: sin esta cola, un
+    // mensaje pequeño adelantaba a uno grande pedido antes (en la terminal, lo que la consola
+    // pintaba llegaba antes que su pantalla inicial, y esta lo tapaba después).
+    const sealed = seal(this.key, payload).catch(() => null)
+    this._out = (this._out || Promise.resolve()).then(() => sealed).then((env) => {
+      if (env && !this._closed) this._send(this.from, { type: DATA, sid: this.sid, env })
+    })
+    return this._out
   }
 
   /**
@@ -79,10 +85,13 @@ class AgentSession {
 
   on (ev, cb) { this._h[ev]?.push(cb); return this }
 
-  async _ingest (env) {
-    let msg
-    try { msg = await open(this.key, env) } catch { return }
-    for (const h of this._h.message) { try { h(msg) } catch (_) {} }
+  /** Lo que llega se entrega en el orden en que llegó, tarde lo que tarde en descifrarse cada uno. */
+  _ingest (env) {
+    const opened = open(this.key, env).then((msg) => ({ msg }), () => null)
+    this._in = (this._in || Promise.resolve()).then(() => opened).then((r) => {
+      if (r) for (const h of this._h.message) { try { h(r.msg) } catch (_) {} }
+    })
+    return this._in
   }
 
   close () {

package/src/client.js

@@ -115,10 +115,13 @@ export class RemoteAgentClient {
       if (token === this.agentToken) this.agentToken = null
     })
 
-    this.client.on('message', async (_from, p) => {
+    this.client.on('message', (_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 {}
+        // Se entregan en el orden en que llegaron: descifrar tarda según el tamaño, y sin
+        // esta cola un mensaje pequeño adelantaba a uno grande que llegó antes.
+        const opened = open(this.key, p.env).then((m) => ({ m }), () => null)
+        this._in = (this._in || Promise.resolve()).then(() => opened).then((r) => { if (r) this._emit('message', r.m) })
       } else if (p.type === ERROR) {
         this._onAgentError(p)
       }
@@ -214,12 +217,18 @@ export class RemoteAgentClient {
   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)
-    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)
+    // Salen en el orden en que se pidieron, tarde lo que tarde en cifrarse cada uno.
+    const sid = this.sid
+    const sealed = seal(this.key, payload)
+    const turn = (this._out || Promise.resolve()).then(() => sealed).then((env) => {
+      const msg = { type: DATA, 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)
+    })
+    this._out = turn.catch(() => {})
+    return turn
   }
 
   /** Sonda de presencia (liveness) sin abrir sesión. Devuelve true si responde. */

package/src/link.js

@@ -20,6 +20,7 @@ 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'
+import { verifySealerChain } from '@dotrino/identity/acta'
 
 export function dataDir (name = 'dotrino-remote-agent') {
   if (process.env.DOTRINO_REMOTE_AGENT_DIR) return process.env.DOTRINO_REMOTE_AGENT_DIR
@@ -116,7 +117,12 @@ export function identityFromLink (link, { dir = dataDir() } = {}) {
   return {
     me: { publickey: device.publickey },
     async signData (data) {
-      return signWithDevice({ privateJwk: device.privateJwk, publickey: device.publickey, data })
+      const firmado = await signWithDevice({ privateJwk: device.privateJwk, publickey: device.publickey, data })
+      // A NOMBRE DE QUIÉN VA, igual que en el navegador: el `profileId` y la cadena de
+      // selladores que lo prueba (`refreshChain`). Sin cadena la firma vale ante la bóveda
+      // (que conoce el papel) pero no ante un extraño que use `verifySignedFor`.
+      const chain = Array.isArray(link.sealerChain) && link.sealerChain.length ? link.sealerChain : null
+      return { ...firmado, profileId: chain ? chain[0].profileId : null, chain }
     },
     async getVaultCert () { return { cert: link.cert } },
     async vaultStatus () {
@@ -192,9 +198,41 @@ export async function renewLink (link, { dir = dataDir(), force = false } = {})
   }
 }
 
+/**
+ * TRAE LA CADENA DE SELLADORES de la cuenta y la guarda en el enlace: con ella `signData`
+ * firma a nombre de la cuenta de forma que `verifySignedFor` lo compruebe desde el génesis.
+ * Se comprueba ANTES de guardarla (`verifySealerChain`): una cadena que no encadena o que es
+ * de otra cuenta no entra. Un agente que firma de cara a terceros la pide al arrancar y la
+ * refresca de vez en cuando. No lanza: devuelve qué pasó.
+ *
+ * @returns {Promise<{ ok: boolean, seq?: number, reason?: string }>}
+ */
+export async function refreshChain (link, { dir = dataDir() } = {}) {
+  if (!link?.device?.privateJwk || !link?.cert || !link?.iss) return { ok: false, reason: 'invalid link' }
+  installNodeGlobals(dir)
+  try {
+    const res = await requestDevices({ master: link.iss, proxy: link.proxy || 'wss://proxy.dotrino.com', device: link.device, cert: link.cert })
+    const chain = res.sealerChain
+    if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'the vault sent no sealer chain (vaultd < 0.154.0?)' }
+    const expected = link.sealerChain?.[0]?.profileId ?? link.acta?.profileId ?? null
+    const v = await verifySealerChain(chain, { expectedProfileId: expected })
+    if (!v.ok) return { ok: false, reason: 'bad sealer chain: ' + v.reason }
+    const head = chain[chain.length - 1]
+    if (typeof link.sealerChain?.[link.sealerChain.length - 1]?.seq === 'number' && head.seq < link.sealerChain[link.sealerChain.length - 1].seq) {
+      return { ok: false, reason: 'older than the chain already stored' }
+    }
+    link.sealerChain = chain
+    saveLink(dir, link)
+    return { ok: true, seq: head.seq }
+  } catch (e) {
+    // Un fallo de red llega a veces sin frase: se dice el código, o al menos que no se alcanzó.
+    return { ok: false, reason: e?.message || e?.code || 'unreachable' }
+  }
+}
+
 /** El enlace como lo esperan `ContentClient.connect({ link })` y `RemoteAgentClient`. */
 export function clientLink (link, opts) {
   return { id: identityFromLink(link, opts), cert: link.cert, iss: link.iss, proxy: link.proxy || 'wss://proxy.dotrino.com' }
 }
 
-export default { dataDir, loadLink, saveLink, parseQr, enroll, identityFromLink, clientLink, renewLink }
+export default { dataDir, loadLink, saveLink, parseQr, enroll, identityFromLink, clientLink, renewLink, refreshChain }