@dotrino/remote-agent 0.9.2 → 0.11.0

package/README.md

@@ -34,7 +34,7 @@ Provee lo común — y **solo** eso:
 | `@dotrino/remote-agent/agent` | Node | `startRemoteAgent(opts)` |
 | `@dotrino/remote-agent/client` | navegador | `RemoteAgentClient` |
 | `@dotrino/remote-agent/link` | Node | `enroll`, `loadLink`, `saveLink`, `dataDir`, `parseQr`, `identityFromLink`, `clientLink`, `renewLink` |
-| `@dotrino/remote-agent/discover` | navegador | `listAgentsByLabel` |
+| `@dotrino/remote-agent/discover` | navegador | `listAgentsByLabel`, `probeAgents` |
 
 ## Uso
 
@@ -123,6 +123,20 @@ chat.send({ type: 'msg', text: 'arreglá el bug en auth.js' })
 const online = await chat.ping()  // liveness sin abrir sesión
 ```
 
+**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`):
+
+```js
+import { listAgentsByLabel, probeAgents } from '@dotrino/remote-agent/discover'
+const miembros = await listAgentsByLabel(id)                    // todos, sin filtrar
+const vivos = await probeAgents(proxyClient, miembros.map((m) => m.sub))
+const terminales = miembros.filter((m) => vivos.get(m.sub)?.kind === 'terminal-agent')
+```
+
+Un agente apagado no contesta y no sale: sin preguntarle no se sabe qué es. El pong con
+`kind` existe desde 0.11.0; uno más viejo contesta con `kind: null`.
+
 ### `link` (la PWA lo obtiene del vault)
 
 Ver `dotrino-terminal/src/vault.js` (`getLink` / `getSelfLink`) como referencia: es

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/remote-agent",
-  "version": "0.9.2",
+  "version": "0.11.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",
@@ -45,13 +45,13 @@
     "p2p"
   ],
   "peerDependencies": {
-    "@dotrino/identity": ">=0.73.1",
+    "@dotrino/identity": ">=0.92.0",
     "@dotrino/proxy-client": ">=0.18.2",
-    "@dotrino/vault": ">=0.30.0"
+    "@dotrino/vault": ">=0.64.0"
   },
   "devDependencies": {
-    "@dotrino/identity": "0.73.0",
+    "@dotrino/identity": "0.92.0",
     "@dotrino/proxy-client": "0.18.2",
-    "@dotrino/vault": "0.35.0"
+    "@dotrino/vault": "0.64.0"
   }
 }

package/src/agent.js

@@ -21,8 +21,8 @@
  */
 import fs from 'node:fs'
 import path from 'node:path'
-import { verifyChain, signWithDevice, verifyDeviceSig, verifyDelegation, pubkeyId } from '@dotrino/identity/capabilities'
-import { sealersOf, memberCan } from '@dotrino/identity/acta'
+import { verifyChain, signWithDevice, verifyDeviceSig, pubkeyId } from '@dotrino/identity/capabilities'
+import { sealersOf, memberCan, checkVaultReply } from '@dotrino/identity/acta'
 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'
@@ -66,7 +66,8 @@ class AgentSession {
  * Arranca el agente. Devuelve `{ machine, machineId, master, close }`.
  *
  * @param {object} opts
- * @param {string} [opts.label]       label del dispositivo (para logging; el real vive en link.json).
+ * @param {string} [opts.label]       qué agente es (`terminal-agent`, `ia-agent`…): lo contesta el pong
+ *   para que las apps lo encuentren (`probeAgents`). El nombre del acta es del dueño.
  * @param {string} [opts.proxyUrl]    default wss://proxy.dotrino.com.
  * @param {string} [opts.dir]         dir del enlace (default dataDir()).
  * @param {object} [opts.link]        enlace ya cargado (override de dir).
@@ -191,14 +192,10 @@ export async function startRemoteAgent (opts = {}) {
       const res = await vaultRpc(VMSG.RENEW, VMSG.RENEWED, { op: 'renew', publickey: myPub, ts: Date.now() })
       const cert = res?.cert
       const acta = res?.acta
-      if (!cert || cert.sub !== myPub) throw new Error('the vault returned a cert that is not for this machine')
-      if (!acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
-      if (acta.profileId !== master) throw new Error('the record is from a profile other than the pinned one')
-      const v = await verifyDelegation({
-        cert, expectedSub: myPub, expectedScope: SIGN_SCOPE,
-        actaSeq: acta.seq, sealers: sealersOf(acta)
-      })
-      if (!v.ok) throw new Error(v.reason)
+      // La regla del pilar, contra la bóveda a la que se le pidió (`master`). Aquí se exigía
+      // `acta.profileId === master`, que con una segunda bóveda nunca es verdad.
+      const chk = await checkVaultReply({ acta, cert, vault: master, sub: myPub, scope: SIGN_SCOPE })
+      if (!chk.ok) throw new Error('invalid renewed cert: ' + chk.reason)
       link.cert = cert
       link.actaSeq = acta.seq
       saveLink(dir, link)
@@ -333,7 +330,9 @@ export async function startRemoteAgent (opts = {}) {
     else if (payload.type === DATA) handleData(from, payload)
     // Sonda de presencia (liveness): el cliente hace ping y respondemos pong con el
     // mismo nonce → así la app sabe que el agente está online (sin abrir sesión).
-    else if (payload.type === PING) send(from, { type: PONG, n: payload.n })
+    // El pong dice además QUÉ agente es (`kind`, el label con que arrancó): el nombre que
+    // tiene en el acta lo pone el dueño al emparejar y no sirve para saber qué atiende.
+    else if (payload.type === PING) send(from, { type: PONG, n: payload.n, kind: opts.label || null })
     else if (payload.type === VMSG.REVOKED) handleRevoked(payload).catch(() => {})
   })
 

package/src/discover.js

@@ -21,6 +21,8 @@
  * después son sus miembros.
  */
 
+import { PING, PONG } from '../protocol.js'
+
 /**
  * @param {object} id   instancia de Identity (del vault) ya conectada.
  * @param {string} [label]  filtrar por servicio/label exacto (p. ej. `'content'`,
@@ -44,4 +46,37 @@ export async function listAgentsByLabel (id, label) {
     .map((m) => ({ sub: m.pub, label: m.label || m.cn || '', cn: m.cn || null }))
 }
 
-export default { listAgentsByLabel }
+/**
+ * QUÉ AGENTE ES CADA UNO, preguntándoselo. Manda un `ra.ping` a cada pubkey por el
+ * transporte que se le pase y devuelve los que contestan, con el `kind` que declara el
+ * agente al arrancar (`startRemoteAgent({ label })`).
+ *
+ * Existe porque buscar por el label del ACTA no sirve: ese nombre lo pone el dueño al
+ * emparejar («TerminalLocal», «el PC de la oficina»), así que una app que buscaba
+ * `terminal-agent` no encontraba nada. Lo que un agente atiende lo sabe el agente.
+ *
+ * Un agente apagado no contesta y no sale: no se puede saber qué es sin preguntarle.
+ *
+ * @param {{ on:Function, sendByPubkey:Function }} client  un WebSocketProxyClient conectado.
+ * @param {string[]} subs  pubkeys a preguntar (p. ej. las de `listAgentsByLabel(id)`).
+ * @param {{ timeoutMs?: number }} [opts]
+ * @returns {Promise<Map<string, { kind: string|null }>>} sub → lo que contestó.
+ */
+export function probeAgents (client, subs, { timeoutMs = 3000 } = {}) {
+  return new Promise((resolve) => {
+    const found = new Map()
+    if (!client || !subs?.length) return resolve(found)
+    const bySub = new Map()
+    const off = client.on('message', (_from, p) => {
+      if (p?.type === PONG && bySub.has(p.n)) found.set(bySub.get(p.n), { kind: p.kind ?? null })
+    })
+    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 (_) {}
+    }
+    setTimeout(() => { try { off() } catch (_) {} resolve(found) }, timeoutMs)
+  })
+}
+
+export default { listAgentsByLabel, probeAgents }

package/src/link.js

@@ -16,8 +16,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
-import { signWithDevice, pubkeyId, verifyDelegation } from '@dotrino/identity/capabilities'
-import { sealersOf } from '@dotrino/identity/acta'
+import { signWithDevice, pubkeyId } from '@dotrino/identity/capabilities'
 import { requestDevices, requestRenew } from '@dotrino/identity/vault/remote.js'
 import { installNodeGlobals } from '../node-globals.js'
 
@@ -169,17 +168,11 @@ export async function renewLink (link, { dir = dataDir(), force = false } = {})
   if (!force && !legado && !atrasado) return { renewed: false, seq: link.cert.seq, reason: 'not due' }
   installNodeGlobals(dir)
   try {
-    const res = await requestRenew({ master: link.iss, proxy: link.proxy || 'wss://proxy.dotrino.com', device: link.device, cert: link.cert })
-    const cert = res?.cert
-    const acta = res?.acta
-    if (!cert || cert.sub !== link.device.publickey) throw new Error('the vault returned a cert that is not for this machine')
-    // El acta viaja con el papel y hace falta para juzgarlo: quien lo firmó tiene que ser
-    // SELLADORA de este perfil. Ya no se compara `cert.iss` con una llave fija — con varias
-    // bóvedas el emisor puede ser otra del mismo perfil; lo que se fija es el PERFIL.
-    if (!acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
-    if (acta.profileId !== link.iss) throw new Error('the record is from a profile other than the pinned one')
-    const v = await verifyDelegation({ cert, expectedSub: link.device.publickey, actaSeq: acta.seq, sealers: sealersOf(acta) })
-    if (!v.ok) throw new Error(v.reason)
+    // `requestRenew` ya JUZGA lo que devuelve (`checkVaultReply` del pilar: acta bien
+    // firmada, esta bóveda puede sellarla, el papel lo firmó ella y es para esta llave) y
+    // lanza si no cuadra. Aquí se comparaba `acta.profileId` con `link.iss`, que solo vale
+    // en una cuenta que nació en esa bóveda: con una segunda bóveda no renovaba nunca.
+    const { cert, acta } = await requestRenew({ master: link.iss, proxy: link.proxy || 'wss://proxy.dotrino.com', device: link.device, cert: link.cert })
     // SE GUARDA ANTES DE DAR NADA POR BUENO. Emitir un papel RETIRA el anterior, así que si
     // 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í.