@dotrino/remote-agent 0.30.0 → 0.32.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +3 -3
- package/src/agent.js +31 -1
- package/src/client.js +41 -4
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@dotrino/remote-agent",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.32.1",
|
|
4
4
|
"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).",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"main": "./index.js",
|
|
@@ -49,12 +49,12 @@
|
|
|
49
49
|
],
|
|
50
50
|
"peerDependencies": {
|
|
51
51
|
"@dotrino/identity": ">=0.121.7",
|
|
52
|
-
"@dotrino/proxy-client": ">=0.
|
|
52
|
+
"@dotrino/proxy-client": ">=0.46.0",
|
|
53
53
|
"@dotrino/vault": ">=0.115.0"
|
|
54
54
|
},
|
|
55
55
|
"devDependencies": {
|
|
56
56
|
"@dotrino/identity": "0.135.0",
|
|
57
|
-
"@dotrino/proxy-client": "0.
|
|
57
|
+
"@dotrino/proxy-client": "0.46.0",
|
|
58
58
|
"@dotrino/vault": "0.115.0"
|
|
59
59
|
}
|
|
60
60
|
}
|
package/src/agent.js
CHANGED
|
@@ -332,9 +332,38 @@ export async function startRemoteAgent (opts = {}) {
|
|
|
332
332
|
link.actaTrusted = true
|
|
333
333
|
try { saveLink(dir, link) } catch (_) {}
|
|
334
334
|
evictOutsiders()
|
|
335
|
+
shareActa(acta)
|
|
335
336
|
return true
|
|
336
337
|
}
|
|
337
338
|
|
|
339
|
+
/**
|
|
340
|
+
* LA CACHÉ DE ACTAS DEL PROXIO (websocket-proxy ≥ 1.10.0). Quien adopta un acta nueva se la
|
|
341
|
+
* deja al proxio, así el siguiente aparato de la cuenta se entera sin despertar a la bóveda;
|
|
342
|
+
* y antes de preguntarle a la bóveda se mira ahí. Lo que llega del proxio pasa por
|
|
343
|
+
* `recordActa`, o sea que se adopta solo si encadena desde la de confianza: el proxio no
|
|
344
|
+
* puede colar nada, como mucho no tener la más nueva.
|
|
345
|
+
*/
|
|
346
|
+
const actaCacheProblems = new Set()
|
|
347
|
+
function noteActaCache (what, e) {
|
|
348
|
+
const code = e?.code || 'error'
|
|
349
|
+
if (actaCacheProblems.has(what + code)) return
|
|
350
|
+
actaCacheProblems.add(what + code)
|
|
351
|
+
if (!opts.quiet) console.error(`[remote-agent] record cache on the proxy (${what}): ${code} · ${e?.message || ''}`)
|
|
352
|
+
}
|
|
353
|
+
function shareActa (acta) {
|
|
354
|
+
// Por detrás y sin tumbar a quien adopta: si falla, se dice una vez y sigue.
|
|
355
|
+
Promise.resolve().then(() => client.putActa(acta)).catch((e) => noteActaCache('put', e))
|
|
356
|
+
}
|
|
357
|
+
/** Adopta la más nueva del proxio que encadene. `true` si el acta avanzó. */
|
|
358
|
+
async function actaFromProxy () {
|
|
359
|
+
const profileId = trustedActa()?.profileId
|
|
360
|
+
if (!profileId) return false
|
|
361
|
+
let list
|
|
362
|
+
try { list = await client.getActas(profileId, { sinceSeq: link.actaSeq ?? -1 }) } catch (e) { noteActaCache('get', e); return false }
|
|
363
|
+
for (const a of list) if (await recordActa(a)) return true
|
|
364
|
+
return false
|
|
365
|
+
}
|
|
366
|
+
|
|
338
367
|
/**
|
|
339
368
|
* CIERRA LAS SESIONES DE QUIEN YA NO PUEDE ESTAR: el acta de confianza ya no lo nombra (o
|
|
340
369
|
* le quitó `sign`), o su papel se retiró. Se juzgaba solo al saludar, así que un aparato
|
|
@@ -366,7 +395,8 @@ export async function startRemoteAgent (opts = {}) {
|
|
|
366
395
|
|
|
367
396
|
const vaultTick = async () => { await refreshRevocations(); await renewCertIfNeeded() }
|
|
368
397
|
/** Trae el acta ahora (con freno) y dice si AVANZÓ: solo entonces merece juzgar otra vez. */
|
|
369
|
-
|
|
398
|
+
// Ponerse al día mira primero la caché del proxio y, si no trae nada que encadene, la bóveda.
|
|
399
|
+
const catchUp = makeCatchUp({ refresh: async () => { if (!await actaFromProxy()) await vaultTick() }, seq: () => link.actaSeq })
|
|
370
400
|
vaultTick()
|
|
371
401
|
const revTimer = setInterval(vaultTick, REVOKE_REFRESH_MS); revTimer.unref?.()
|
|
372
402
|
|
package/src/client.js
CHANGED
|
@@ -21,7 +21,7 @@
|
|
|
21
21
|
* `on('message', cb)` recibe los payloads del agente, ya descifrados.
|
|
22
22
|
*/
|
|
23
23
|
import { verifyChain } from '@dotrino/identity/capabilities'
|
|
24
|
-
import { sealersOf, samePubkey } from '@dotrino/identity/acta'
|
|
24
|
+
import { sealersOf, samePubkey, canAdopt } from '@dotrino/identity/acta'
|
|
25
25
|
import { makeEphemeral, deriveKey, seal, open } from '../e2e.js'
|
|
26
26
|
import { canGreet } from './membership.js'
|
|
27
27
|
import { HS, ACK, DATA, PING, PONG, ERROR, DEFAULT_PROXY } from '../protocol.js'
|
|
@@ -34,9 +34,14 @@ export class RemoteAgentClient {
|
|
|
34
34
|
* @param {object} opts
|
|
35
35
|
* @param {string} opts.agentPubkey dirección (pubkey) del agente destino.
|
|
36
36
|
* @param {string} [opts.proxyUrl] override del proxy del enlace.
|
|
37
|
+
* @param {() => object|null} [opts.trustedActa] un acta ya COMPROBADA y que alguien mantiene
|
|
38
|
+
* al día (un agente de Node: la de su enlace, que refresca cada 5 min y con los avisos de la
|
|
39
|
+
* bóveda). Con ella el saludo no espera a la bóveda; si no pasa, se le pregunta y se juzga
|
|
40
|
+
* otra vez. Sin ella, la bóveda en cada saludo, como siempre.
|
|
37
41
|
*/
|
|
38
|
-
constructor (link, { agentPubkey, proxyUrl } = {}) {
|
|
42
|
+
constructor (link, { agentPubkey, proxyUrl, trustedActa = null } = {}) {
|
|
39
43
|
this.link = link // { id, cert, iss, proxy, mode? }
|
|
44
|
+
this.trustedActa = trustedActa
|
|
40
45
|
this.agentPubkey = agentPubkey // pubkey del agente destino
|
|
41
46
|
this.proxyUrl = proxyUrl || link.proxy || DEFAULT_PROXY
|
|
42
47
|
this.client = null
|
|
@@ -193,6 +198,39 @@ export class RemoteAgentClient {
|
|
|
193
198
|
|
|
194
199
|
/** Comprueba el ack y deja `sid` y `key`. */
|
|
195
200
|
async _checkAck (res, eph) {
|
|
201
|
+
// PRIMERO EL ACTA QUE YA SE TIENE (`trustedActa`), y la bóveda solo si con esa no pasa.
|
|
202
|
+
// Preguntarle en cada saludo hacía esperar a la ventana 4-17 s antes de pedir la clave de
|
|
203
|
+
// otra máquina (2026-11-04): el ack llega en medio segundo, el acta tardaba el resto. Si
|
|
204
|
+
// no pasa puede ser que el acta guardada vaya atrás (una máquina recién emparejada): se
|
|
205
|
+
// pregunta a la bóveda y se juzga otra vez, una sola, como hace el agente con un saludo.
|
|
206
|
+
let local = null
|
|
207
|
+
try { local = this.trustedActa?.() || null } catch (_) {}
|
|
208
|
+
if (local) {
|
|
209
|
+
try { return await this._judgeAck(res, eph, local) } catch (e) { if (e.code !== 'unauthorized') throw e }
|
|
210
|
+
// Va atrás: antes que la bóveda, la caché de actas del proxio (websocket-proxy ≥ 1.10.0).
|
|
211
|
+
const newer = await this._actaFromProxy(local)
|
|
212
|
+
if (newer) {
|
|
213
|
+
try { return await this._judgeAck(res, eph, newer) } catch (e) { if (e.code !== 'unauthorized') throw e }
|
|
214
|
+
}
|
|
215
|
+
}
|
|
216
|
+
return this._judgeAck(res, eph, await this._acta())
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
/**
|
|
220
|
+
* La más nueva de la caché del proxio que ENCADENE desde `trusted` (`canAdopt`), o `null`.
|
|
221
|
+
* El proxio no es de fiar: lo que no encadena se ignora. Si no se pudo preguntar, el motivo
|
|
222
|
+
* queda en `actaCacheError` y se sigue con la bóveda, que es quien manda.
|
|
223
|
+
*/
|
|
224
|
+
async _actaFromProxy (trusted) {
|
|
225
|
+
if (!trusted?.profileId) return null
|
|
226
|
+
let list
|
|
227
|
+
try { list = await this.client.getActas(trusted.profileId, { sinceSeq: trusted.seq }) } catch (e) { this.actaCacheError = e; return null }
|
|
228
|
+
for (const a of list) if ((await canAdopt({ candidate: a, current: trusted })).adopt) return a
|
|
229
|
+
return null
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
/** Juzga el ack con `acta` y, si pasa, deja `sid` y `key`. */
|
|
233
|
+
async _judgeAck (res, eph, acta) {
|
|
196
234
|
|
|
197
235
|
// El ack debe: (1) encadenar a NUESTRA maestra, (2) estar firmado por el agente
|
|
198
236
|
// que apuntamos, (3) atar nuestra pub efímera y el sid.
|
|
@@ -203,8 +241,7 @@ export class RemoteAgentClient {
|
|
|
203
241
|
// decir «vale» sin haber comprobado nada es como entraba un papel viejo. Aquí no se le
|
|
204
242
|
// pasaba: el lado del agente sí lo hacía (`contextoActa`) y este lado se quedó atrás,
|
|
205
243
|
// así que TODA sesión moría con «el agente no está certificado por tu vault: no-record».
|
|
206
|
-
// `clientLink` no trae el acta, así que se le pide a la bóveda
|
|
207
|
-
const acta = await this._acta()
|
|
244
|
+
// `clientLink` no trae el acta, así que se le pide a la bóveda (`_acta`) o llega hecha.
|
|
208
245
|
const chk = await verifyChain({
|
|
209
246
|
data: res.ack, signature: res.signature, cert: res.cert,
|
|
210
247
|
actaSeq: acta?.seq ?? null, sealers: acta ? sealersOf(acta) : null
|