@dotrino/terminal-agent 0.37.1 → 0.38.0

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/README.md CHANGED
@@ -44,6 +44,8 @@ dotrino-terminal --name casa # en el agente del perfil «casa»
44
44
  dotrino-terminal ls # las consolas abiertas: id, origen, título, quién mira
45
45
  dotrino-terminal attach <id> # retomar una
46
46
  dotrino-terminal kill <id>
47
+ dotrino-terminal machines [--json] # las OTRAS máquinas de la cuenta que están encendidas, y sus consolas
48
+ dotrino-terminal --machine <id|nombre> # abrir / attach / ls / kill, pero en otra máquina (≥ 0.38)
47
49
  dotrino-terminal profiles [--json] # los perfiles (agentes con nombre) de esta máquina
48
50
  dotrino-terminal link [--name <n>] # enlazar un perfil con tu bóveda
49
51
  dotrino-terminal rename <perfil> [nuevo] # renombrarlo (mueve su carpeta y para su agente; mismo aparato)
@@ -58,6 +60,16 @@ título. Sin enlace el agente atiende solo a las ventanas locales; al enlazarlo
58
60
  (`dotrino-terminal link`) enciende la parte remota sin reiniciarse. La app de escritorio
59
61
  (`desktop/` del repo) es una ventana nativa que corre este mismo cliente.
60
62
 
63
+ **Las consolas de las otras máquinas** (`far.js`, ≥ 0.38). El agente de esta máquina hace de
64
+ CLIENTE de los otros agentes de la cuenta, con su propio enlace (`clientLink` de
65
+ `@dotrino/remote-agent`): es un aparato del acta y entra con lo que el acta le reconozca
66
+ (`sign`) y con la clave de la otra máquina si la tiene. Por el socket local se suman tres
67
+ mensajes: `{ type:'machines' }` (qué máquinas hay y sus consolas; contesta de memoria y
68
+ refresca por detrás), `{ type:'via', machine }` como PRIMER mensaje (la conexión pasa a hablar
69
+ con esa máquina, con el mismo protocolo) y `{ type:'far', machine, msg }` (una orden suelta).
70
+ La clave de una máquina se recuerda solo en memoria, cuando una ventana la escribió bien.
71
+ Solo esta máquina necesita la 0.38: las otras atienden como a cualquier aparato.
72
+
61
73
  `dotrino-terminal vscode` escribe el perfil de terminal «Dotrino» en el `settings.json` de VS Code,
62
74
  VS Code Insiders, VSCodium y Cursor (los que haya, Linux y macOS) y lo deja por defecto; conserva
63
75
  los comentarios y el resto del archivo (`editors.js`, con `jsonc-parser`). El perfil apunta a Node
package/bin/terminal.js CHANGED
@@ -6,6 +6,8 @@
6
6
  * dotrino-terminal attach <id> [--name <n>] se engancha a una consola que ya existe
7
7
  * dotrino-terminal ls [--name <n>] [--json] las consolas abiertas en el agente
8
8
  * dotrino-terminal kill <id> [--name <n>] cierra una consola
9
+ * dotrino-terminal machines [--json] tus OTRAS máquinas encendidas y sus consolas
10
+ * dotrino-terminal … --machine <id|nombre> lo mismo (abrir, attach, ls, kill) en otra máquina
9
11
  * dotrino-terminal note [texto] la nota de esta consola (de qué va): la lee o la cambia
10
12
  * dotrino-terminal profiles [--json] los perfiles de esta máquina (enlazados o no)
11
13
  * dotrino-terminal link [--name <n>] enlaza un perfil con tu bóveda
@@ -56,6 +58,9 @@ if (args.includes('-h') || args.includes('--help')) {
56
58
  dotrino-terminal attach <id> [--name <n>] se engancha a una consola abierta
57
59
  dotrino-terminal ls [--name <n>] [--json] las consolas abiertas
58
60
  dotrino-terminal kill <id> [--name <n>] cierra una consola
61
+ dotrino-terminal machines [--json] tus otras máquinas encendidas y sus consolas
62
+ dotrino-terminal … --machine <id|nombre> abrir, attach, ls y kill, pero en otra máquina tuya
63
+ (su id o su nombre salen en «machines»)
59
64
  dotrino-terminal note enseña la nota de esta consola (de qué va)
60
65
  dotrino-terminal note <texto> la reemplaza («-» la lee de la entrada estándar)
61
66
  dotrino-terminal note --add <texto> le añade una línea
@@ -82,6 +87,9 @@ Cerrar la ventana no cierra la consola: sigue abierta y se retoma después.`, `u
82
87
  dotrino-terminal attach <id> [--name <n>] attach to an open console
83
88
  dotrino-terminal ls [--name <n>] [--json] list open consoles
84
89
  dotrino-terminal kill <id> [--name <n>] close a console
90
+ dotrino-terminal machines [--json] your other machines that are on, and their consoles
91
+ dotrino-terminal … --machine <id|name> open, attach, ls and kill, but on another machine of yours
92
+ (its id or name show up in "machines")
85
93
  dotrino-terminal note show this console's note (what it is about)
86
94
  dotrino-terminal note <text> replace it ("-" reads it from standard input)
87
95
  dotrino-terminal note --add <text> append a line
@@ -371,6 +379,57 @@ function request (conn, msg, type) {
371
379
  })
372
380
  }
373
381
 
382
+ /** Lo que se espera a que el agente conteste por otra máquina (descubrirla y saludarla). */
383
+ const FAR_WAIT_MS = 40_000
384
+ /** Una pregunta sobre las otras máquinas. Un agente anterior a la 0.38 no la entiende y calla: se dice. */
385
+ async function farRequest (conn, msg, type) {
386
+ const r = await Promise.race([request(conn, msg, type), new Promise((resolve) => setTimeout(() => resolve(null), FAR_WAIT_MS))])
387
+ if (!r) die(t('el agente de esta máquina no contestó. Si es anterior a la 0.38 no sabe de otras máquinas: actualízalo y reinícialo.', 'this machine\'s agent did not answer. If it predates 0.38 it knows nothing about other machines: update and restart it.'))
388
+ return r
389
+ }
390
+ const farMessage = (r) => ({
391
+ 'not-linked': t('esta máquina no está enlazada con tu bóveda, así que no ve tus otras máquinas. Enlázala con: dotrino-terminal link', 'this machine is not linked to your vault, so it cannot see your other machines. Link it with: dotrino-terminal link'),
392
+ 'no-machine': t('no hay ninguna máquina encendida con ese id o nombre (mira «dotrino-terminal machines»).', 'no machine with that id or name is on (see "dotrino-terminal machines").'),
393
+ 'ambiguous-machine': t('hay más de una máquina con ese nombre: usa su id (mira «dotrino-terminal machines»).', 'more than one machine has that name: use its id (see "dotrino-terminal machines").')
394
+ }[r.code] || `${r.message} (${r.code})`)
395
+
396
+ /** `dotrino-terminal machines`: las otras máquinas de la cuenta que están encendidas, y sus consolas. */
397
+ async function machines (conn) {
398
+ const r = await farRequest(conn, { type: 'machines' }, 'machines')
399
+ if (r.type === 'fail') die(`dotrino-terminal: ${farMessage(r)}`)
400
+ if (args.includes('--json')) { console.log(JSON.stringify(r.list, null, 2)); return }
401
+ if (!r.list.length) { console.log(t('No hay otras máquinas encendidas con Dotrino Terminal.', 'No other machines are on with Dotrino Terminal.')); return }
402
+ for (const m of r.list) {
403
+ const state = m.locked ? t('pide su clave', 'asks for its code') : m.error ? t('no contesta', 'not answering') : `${m.consoles.length} ${t('consolas', 'consoles')}`
404
+ console.log(`${m.id} ${m.name || ''} · ${state}`)
405
+ for (const c of m.consoles || []) console.log(` ${c.id} ${age(Date.now() - c.createdAt).padStart(4)} ${c.viewers} ${t('mirando', 'watching')} ${c.title || ''}`)
406
+ }
407
+ }
408
+
409
+ /**
410
+ * `--machine <id|nombre>`: esta conexión pasa a hablar con OTRA máquina de la cuenta (el agente
411
+ * de aquí hace de puente, `far.js`). A partir de ahí todo es igual que en local. Si la otra
412
+ * máquina tiene clave, se pide aquí, antes de seguir.
413
+ */
414
+ async function goVia (conn, ref) {
415
+ const r = await farRequest(conn, { type: 'via', machine: ref }, 'via')
416
+ if (r.type === 'fail') die(`dotrino-terminal: ${farMessage(r)}`)
417
+ let probe = await farRequest(conn, { type: 'list' }, 'consoles')
418
+ const name = r.machine.name || r.machine.id
419
+ while (probe.type === 'fail' && ['locked', 'bad-code', 'wait'].includes(probe.code)) {
420
+ if (probe.code === 'bad-code') console.error(t('Clave incorrecta.', 'Wrong code.'))
421
+ if (probe.code === 'wait') console.error(t(`Demasiados intentos: espera ${Math.ceil((probe.retryMs || 0) / 1000)} s.`, `Too many tries: wait ${Math.ceil((probe.retryMs || 0) / 1000)} s.`))
422
+ // Lo tecleado aquí es la clave, no entrada para la consola.
423
+ process.stdin.off('data', earlyTap)
424
+ early.length = 0
425
+ const code = await askHidden(t(`Clave de ${name}: `, `Code for ${name}: `))
426
+ if (!code) die(t('sin clave no se entra.', 'no code, no entry.'))
427
+ probe = await farRequest(conn, { type: 'unlock', code }, 'unlocked')
428
+ if (probe.type === 'unlocked') break
429
+ }
430
+ if (probe.type === 'fail') die(`dotrino-terminal: ${probe.message} (${probe.code})`)
431
+ }
432
+
374
433
  const age = (ms) => {
375
434
  const s = Math.round(ms / 1000)
376
435
  return s < 60 ? `${s}s` : s < 3600 ? `${Math.round(s / 60)}m` : `${Math.round(s / 3600)}h`
@@ -469,7 +528,14 @@ function interactive (conn, first, dir) {
469
528
  const onInfo = (info) => {
470
529
  if (!info) return
471
530
  shellTitle = info.title || ''
472
- const now = new Set(info.watchers.filter((w) => w.origin === 'remote').map((w) => w.device || '?'))
531
+ // En otra máquina (`--machine`) esta ventana es, para aquella, «otro aparato»: no se cuenta
532
+ // a sí misma (se reconoce por su etiqueta; sin etiqueta, es una de las que salen).
533
+ let far = info.watchers.filter((w) => w.origin === 'remote')
534
+ if (opt('--machine')) {
535
+ const mine = opt('--tag') ? far.findIndex((w) => w.tag === opt('--tag')) : 0
536
+ if (mine >= 0) far = far.filter((_, i) => i !== mine)
537
+ }
538
+ const now = new Set(far.map((w, i) => (opt('--machine') ? `${w.device || '?'}#${w.tag || i}` : w.device || '?')))
473
539
  const arrived = [...now].some((d) => !remote.has(d))
474
540
  remote = now
475
541
  if (arrived) out.write('\x07') // la campana: alguien entró desde fuera
@@ -627,6 +693,9 @@ try {
627
693
  const dir = opt('--dir') || dataDir(opt('--name'))
628
694
  if (cmd === 'open' || cmd === 'attach') captureEarly()
629
695
  const conn = await agent(dir)
696
+ const machine = opt('--machine')
697
+ if (cmd === 'machines') { await machines(conn); conn.close(); process.exit(0) }
698
+ if (machine) await goVia(conn, machine)
630
699
  if (cmd === 'ls' || cmd === 'list') { await list(conn); conn.close() } else if (cmd === 'kill') {
631
700
  if (!args[1]) die(t('falta el id: dotrino-terminal kill <id>', 'missing id: dotrino-terminal kill <id>'))
632
701
  conn.send({ type: 'kill', id: args[1] })
@@ -638,7 +707,9 @@ try {
638
707
  interactive(conn, { type: 'attach', id: args[1], ...tag() }, dir)
639
708
  } else if (cmd === 'open') {
640
709
  // Como cualquier terminal: la consola abre en la carpeta donde estás (o en `--cwd`).
641
- interactive(conn, { type: 'open', cwd: path.resolve(opt('--cwd') || process.cwd()), ...tag() }, dir)
710
+ // En otra máquina, la carpeta de aquí no existe: abre en su carpeta de inicio, salvo `--cwd`.
711
+ const cwd = machine ? (opt('--cwd') ? { cwd: opt('--cwd') } : {}) : { cwd: path.resolve(opt('--cwd') || process.cwd()) }
712
+ interactive(conn, { type: 'open', ...cwd, ...tag() }, dir)
642
713
  } else die(t(`orden desconocida: ${cmd} (mira --help)`, `unknown command: ${cmd} (see --help)`))
643
714
  } catch (e) {
644
715
  if (e !== HOLD) { try { die(`dotrino-terminal: ${e.message}`) } catch (_) {} }
package/far.js ADDED
@@ -0,0 +1,271 @@
1
+ /**
2
+ * far.js — las consolas de las OTRAS máquinas de la cuenta, para las ventanas de esta.
3
+ *
4
+ * El navegador y el teléfono ya abren consolas de cualquier máquina; las ventanas de esta
5
+ * (la app de escritorio, `dotrino-terminal`) solo veían las suyas. Aquí el agente de esta
6
+ * máquina hace de CLIENTE de los otros agentes, con su propio enlace (`clientLink`): es un
7
+ * aparato del acta y entra como cualquier otro, con lo que el acta le reconozca (`sign`) y
8
+ * con la clave de la otra máquina si la tiene.
9
+ *
10
+ * Tres cosas, las tres por el socket local (ver `serveLocal` en index.js):
11
+ *
12
+ * · `machines()` — qué máquinas hay encendidas y qué consolas tiene cada una. Se guarda y se
13
+ * refresca por detrás: quien pregunta no espera a la red más que la primera vez.
14
+ * · `via(session, machine)` — la ventana pasa a hablar con la OTRA máquina. Es un tubo: el
15
+ * protocolo es el mismo que el local (`serveSession`), así que el cliente no cambia.
16
+ * · `send(machine, msg)` — una orden suelta (cerrar, ordenar, la nota) sin abrir ventana.
17
+ *
18
+ * La clave de una máquina que la pide se recuerda SOLO en memoria, cuando una ventana la
19
+ * escribió bien: así el panel puede seguir listando sus consolas sin volver a preguntarla.
20
+ */
21
+ import { RemoteAgentClient } from '@dotrino/remote-agent/client'
22
+ import { clientLink } from '@dotrino/remote-agent/link'
23
+ import { listAgentsByLabel, probeAgents } from '@dotrino/remote-agent/discover'
24
+ import { pubkeyId } from '@dotrino/identity/capabilities'
25
+
26
+ /** Lo más seguido que se vuelve a preguntar a las máquinas por sus consolas. */
27
+ export const REFRESH_MS = 3000
28
+ /** Cada cuánto se vuelve a mirar QUÉ máquinas hay (el acta y quién contesta). */
29
+ export const DISCOVER_MS = 30_000
30
+ /** Sin que nadie pregunte durante este rato, se sueltan las conexiones. */
31
+ export const IDLE_MS = 60_000
32
+ /** Lo que se espera la respuesta de una máquina antes de darla por apagada. */
33
+ export const ANSWER_MS = 8000
34
+
35
+ const fail = (code, message) => Object.assign(new Error(message), { code })
36
+
37
+ /** `AB12-CD34`, como sale en `dotrino-vault members`. */
38
+ export async function shortId (sub) {
39
+ return (await pubkeyId(sub)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
40
+ }
41
+
42
+ /** Las máquinas con agente de terminal encendido, con el transporte de verdad. */
43
+ async function discoverReal ({ link, dir, kind, state }) {
44
+ const cl = clientLink(link, { dir })
45
+ const members = await listAgentsByLabel(cl.id)
46
+ if (!members.length) return []
47
+ if (!state.probe) {
48
+ const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
49
+ state.probe = new WebSocketProxyClient({ url: cl.proxy, enableWebRTC: false, autoReconnect: true })
50
+ await state.probe.connect()
51
+ }
52
+ const found = await probeAgents(state.probe, members.map((m) => m.sub))
53
+ const out = []
54
+ for (const m of members) {
55
+ if (found.get(m.sub)?.kind !== kind) continue
56
+ out.push({ sub: m.sub, id: await shortId(m.sub), name: m.label || '' })
57
+ }
58
+ return out
59
+ }
60
+
61
+ /** Una sesión con el agente de otra máquina. */
62
+ async function connectReal ({ link, dir, sub }) {
63
+ const rc = new RemoteAgentClient(clientLink(link, { dir }), { agentPubkey: sub })
64
+ await rc.connect()
65
+ return rc
66
+ }
67
+
68
+ /**
69
+ * @param {object} opts
70
+ * @param {string} opts.dir la carpeta del enlace de este agente.
71
+ * @param {() => object|null} opts.loadLink el enlace, leído cada vez (puede aparecer después).
72
+ * @param {string} opts.kind el tipo de agente que se busca (`terminal-agent`).
73
+ * @param {Function} [opts.discover] para las pruebas.
74
+ * @param {Function} [opts.connect] para las pruebas.
75
+ * @param {number} [opts.refreshMs]
76
+ * @param {number} [opts.discoverMs]
77
+ * @param {number} [opts.idleMs]
78
+ * @param {number} [opts.answerMs]
79
+ */
80
+ export function makeFar ({ dir, loadLink, kind, discover = discoverReal, connect = connectReal, refreshMs = REFRESH_MS, discoverMs = DISCOVER_MS, idleMs = IDLE_MS, answerMs = ANSWER_MS }) {
81
+ /** sub → { sub, id, name, rc, consoles, locked, error } */
82
+ const machines = new Map()
83
+ /** sub → la clave que una ventana escribió bien (solo en memoria). */
84
+ const codes = new Map()
85
+ const state = { probe: null }
86
+ let discoveredAt = 0
87
+ let refreshedAt = 0
88
+ let refreshing = null
89
+ let idle = null
90
+ let closed = false
91
+
92
+ const link = () => {
93
+ const l = loadLink()
94
+ if (!l) throw fail('not-linked', 'this machine is not linked to a vault, so it cannot see your other machines')
95
+ return l
96
+ }
97
+
98
+ /** Una pregunta por la conexión de control de una máquina, y su respuesta (o `fail`). */
99
+ function ask (rc, msg, type) {
100
+ return new Promise((resolve, reject) => {
101
+ const off = rc.on('message', (m) => { if (m?.type === type || m?.type === 'fail') { done(); resolve(m) } })
102
+ const offErr = rc.on('error', (e) => { done(); reject(e) })
103
+ const timer = setTimeout(() => { done(); reject(fail('no-answer', 'that machine did not answer')) }, answerMs)
104
+ const done = () => { off(); offErr(); clearTimeout(timer) }
105
+ rc.send(msg).catch((e) => { done(); reject(e) })
106
+ })
107
+ }
108
+
109
+ function drop (m) {
110
+ try { m.rc?.close() } catch (_) {}
111
+ m.rc = null
112
+ }
113
+
114
+ /** Las consolas de una máquina, abriendo su conexión de control si hace falta. */
115
+ async function readOne (m) {
116
+ try {
117
+ if (!m.rc) m.rc = await connect({ link: link(), dir, sub: m.sub })
118
+ let r = await ask(m.rc, { type: 'list' }, 'consoles')
119
+ if (r.type === 'fail' && r.code === 'locked' && codes.has(m.sub)) {
120
+ const u = await ask(m.rc, { type: 'unlock', code: codes.get(m.sub) }, 'unlocked')
121
+ // La clave cambió: la guardada ya no vale, se olvida y vuelve a pedirse en una ventana.
122
+ if (u.type === 'fail') codes.delete(m.sub)
123
+ else r = await ask(m.rc, { type: 'list' }, 'consoles')
124
+ }
125
+ if (r.type === 'fail') {
126
+ m.locked = r.code === 'locked'
127
+ m.consoles = null
128
+ m.error = m.locked ? null : { code: r.code, message: r.message }
129
+ return
130
+ }
131
+ m.locked = false; m.error = null; m.consoles = r.list
132
+ } catch (e) {
133
+ // No contestó o la sesión cayó: la conexión se suelta y la próxima pasada abre otra.
134
+ drop(m)
135
+ m.consoles = null; m.locked = false
136
+ m.error = { code: e.code || 'unreachable', message: e.message }
137
+ }
138
+ }
139
+
140
+ async function refresh () {
141
+ const now = Date.now()
142
+ if (now - discoveredAt >= discoverMs || !discoveredAt) {
143
+ const found = await discover({ link: link(), dir, kind, state })
144
+ discoveredAt = Date.now()
145
+ const alive = new Set(found.map((f) => f.sub))
146
+ for (const [sub, m] of machines) if (!alive.has(sub)) { drop(m); machines.delete(sub) }
147
+ for (const f of found) {
148
+ const m = machines.get(f.sub)
149
+ if (m) { m.id = f.id; m.name = f.name } else machines.set(f.sub, { ...f, rc: null, consoles: null, locked: false, error: null })
150
+ }
151
+ }
152
+ await Promise.all([...machines.values()].map(readOne))
153
+ refreshedAt = Date.now()
154
+ }
155
+
156
+ function touch () {
157
+ clearTimeout(idle)
158
+ idle = setTimeout(release, idleMs)
159
+ idle.unref?.()
160
+ }
161
+
162
+ /** Nadie pregunta: se sueltan las conexiones. La lista se olvida para no enseñar algo viejo. */
163
+ function release () {
164
+ for (const m of machines.values()) drop(m)
165
+ machines.clear()
166
+ try { state.probe?.close() } catch (_) {}
167
+ state.probe = null
168
+ discoveredAt = 0; refreshedAt = 0
169
+ }
170
+
171
+ const snapshot = () => [...machines.values()].map((m) => ({
172
+ sub: m.sub, id: m.id, name: m.name, locked: m.locked, ...(m.error ? { error: m.error } : {}), consoles: m.consoles
173
+ }))
174
+
175
+ function startRefresh () {
176
+ if (!refreshing) refreshing = refresh().finally(() => { refreshing = null })
177
+ return refreshing
178
+ }
179
+
180
+ /**
181
+ * Las otras máquinas y sus consolas. La primera vez espera a la red; después contesta con
182
+ * lo guardado y refresca por detrás (un fallo ahí se ve en la siguiente respuesta).
183
+ */
184
+ async function list () {
185
+ if (closed) throw fail('closed', 'the agent is stopping')
186
+ link()
187
+ touch()
188
+ if (!refreshedAt) await startRefresh()
189
+ else if (Date.now() - refreshedAt >= refreshMs) startRefresh().catch(() => {})
190
+ return snapshot()
191
+ }
192
+
193
+ /** La máquina que se nombró: por su llave, por su id (`AB12-CD34`) o por su nombre. */
194
+ async function resolve (ref) {
195
+ const want = String(ref || '').trim()
196
+ if (!want) throw fail('no-machine', 'which machine?')
197
+ const find = () => {
198
+ const all = [...machines.values()]
199
+ const low = want.toLowerCase()
200
+ const hits = all.filter((m) => m.sub === want || m.id.toLowerCase() === low || m.id.replace('-', '').toLowerCase() === low.replace('-', '') || (m.name && m.name.toLowerCase() === low))
201
+ if (hits.length > 1) throw fail('ambiguous-machine', `more than one machine is called "${want}": use its id`)
202
+ return hits[0] || null
203
+ }
204
+ let m = find()
205
+ if (!m) { touch(); discoveredAt = 0; await startRefresh(); m = find() }
206
+ if (!m) throw fail('no-machine', `no machine "${want}" is on with a terminal agent`)
207
+ return m
208
+ }
209
+
210
+ /**
211
+ * La ventana pasa a hablar con otra máquina: todo lo que mande va allí y todo lo que venga
212
+ * de allí vuelve, tal cual. Contesta `{ type:'via', machine }` cuando el tubo está puesto.
213
+ */
214
+ async function via (session, ref) {
215
+ const queue = []
216
+ let rc = null
217
+ let gone = false
218
+ let typed = null // la clave que se acaba de mandar, hasta saber si valió
219
+ // La ventana se cerró. Antes de cortar se SUELTA la consola: la otra máquina no ve caer
220
+ // esta conexión hasta que se le agota la espera, y mientras tanto la consola seguía
221
+ // saliendo «abierta desde otro aparato» sin nadie mirándola.
222
+ const bye = () => {
223
+ gone = true
224
+ if (!rc) return
225
+ const end = () => { try { rc.close() } catch (_) {} }
226
+ rc.send({ type: 'detach' }).then(end, end)
227
+ }
228
+ session.on('close', bye)
229
+ const forward = (msg) => {
230
+ if (msg?.type === 'unlock') typed = String(msg.code ?? '')
231
+ rc.send(msg).catch((e) => session.send({ type: 'fail', code: e.code || 'far-send', message: e.message }))
232
+ }
233
+ session.on('message', (msg) => { if (rc) forward(msg); else queue.push(msg) })
234
+ let m
235
+ try {
236
+ m = await resolve(ref)
237
+ rc = await connect({ link: link(), dir, sub: m.sub })
238
+ } catch (e) {
239
+ session.send({ type: 'fail', code: e.code || 'unreachable', message: e.message })
240
+ return
241
+ }
242
+ if (gone) { try { rc.close() } catch (_) {} return }
243
+ rc.on('message', (p) => {
244
+ if (p?.type === 'unlocked' && typed != null) { codes.set(m.sub, typed); typed = null }
245
+ if (p?.type === 'fail' && (p.code === 'bad-code' || p.code === 'wait')) typed = null
246
+ session.send(p)
247
+ })
248
+ rc.on('error', (e) => session.send({ type: 'fail', code: e.code || 'far-error', message: e.message }))
249
+ // La otra máquina se reinició: sus consolas ya no existen. Se dice; no se inventa otra.
250
+ rc.on('resumed', () => session.send({ type: 'fail', code: 'machine-restarted', message: 'that machine restarted: its consoles are gone' }))
251
+ session.send({ type: 'via', machine: { sub: m.sub, id: m.id, name: m.name } })
252
+ for (const msg of queue.splice(0)) forward(msg)
253
+ }
254
+
255
+ /** Una orden suelta a otra máquina (cerrar una consola, moverla, su nota), sin ventana. */
256
+ async function send (ref, msg) {
257
+ const m = await resolve(ref)
258
+ if (!m.rc) await readOne(m)
259
+ if (!m.rc) throw fail(m.error?.code || 'unreachable', m.error?.message || 'that machine did not answer')
260
+ await m.rc.send(msg)
261
+ // Lo que cambió se ve en la próxima lectura, sin esperar al refresco normal.
262
+ refreshedAt = 1
263
+ }
264
+
265
+ return {
266
+ list, via, send,
267
+ close: () => { closed = true; clearTimeout(idle); release() }
268
+ }
269
+ }
270
+
271
+ export default { makeFar }
package/index.js CHANGED
@@ -37,6 +37,7 @@ import { dataDir, loadLink, LABEL } from './link.js'
37
37
  import { ConsoleHub, REPLAY_CHUNK, isTyped } from './consoles.js'
38
38
  import { listenLocal } from './local.js'
39
39
  import { makeGate } from './access.js'
40
+ import { makeFar } from './far.js'
40
41
 
41
42
  const require = createRequire(import.meta.url)
42
43
 
@@ -225,6 +226,32 @@ export function serveSession (session, hub, { origin = 'remote', gate = null } =
225
226
  session.on('close', release)
226
227
  }
227
228
 
229
+ /**
230
+ * Una ventana de ESTA máquina (el socket local). Lo normal es que mire las consolas de aquí
231
+ * (`serveSession`); con `via` como primer mensaje pasa a mirar las de OTRA máquina de la
232
+ * cuenta (`far.js`), con el mismo protocolo. `machines` y `far` se atienden siempre: qué
233
+ * otras máquinas hay, y una orden suelta para una de ellas.
234
+ * Exportada para las pruebas.
235
+ */
236
+ export function serveLocal (session, hub, far) {
237
+ const h = { message: [], close: [] }
238
+ const inner = { device: null, send: (p) => session.send(p), on (ev, cb) { h[ev]?.push(cb); return this } }
239
+ const failed = (e) => session.send({ type: 'fail', code: e.code || 'far-error', message: e.message })
240
+ let mode = null
241
+ session.on('message', (msg) => {
242
+ if (!msg || typeof msg !== 'object') return
243
+ if (mode !== 'far' && msg.type === 'machines') { far.list().then((list) => session.send({ type: 'machines', list })).catch(failed); return }
244
+ if (mode !== 'far' && msg.type === 'far') { far.send(msg.machine, msg.msg).catch(failed); return }
245
+ if (!mode) {
246
+ if (msg.type === 'via') { mode = 'far'; far.via(inner, msg.machine).catch(failed); return }
247
+ mode = 'hub'
248
+ serveSession(inner, hub, { origin: 'local' })
249
+ }
250
+ for (const cb of h.message) { try { cb(msg) } catch (_) {} }
251
+ })
252
+ session.on('close', () => { for (const cb of h.close) { try { cb() } catch (_) {} } })
253
+ }
254
+
228
255
  /**
229
256
  * Arranca el agente: las consolas, el socket de las ventanas de esta máquina y, si la
230
257
  * máquina está enlazada con la bóveda, la parte remota (`startRemoteAgent`).
@@ -258,7 +285,9 @@ export async function startAgent (opts = {}) {
258
285
  .catch((e) => console.error(`[terminal-agent] could not report the incident: ${e.message}`))
259
286
  }
260
287
  })
261
- const local = await listenLocal({ dir, serve: (session) => serveSession(session, hub, { origin: 'local' }) })
288
+ // Las consolas de las otras máquinas de la cuenta, para las ventanas de esta (far.js).
289
+ const far = makeFar({ dir, loadLink: () => loadLink(dir), kind: LABEL })
290
+ const local = await listenLocal({ dir, serve: (session) => serveLocal(session, hub, far) })
262
291
  let stopped = false
263
292
  const startRemote = () => startRemoteAgent({
264
293
  label: LABEL,
@@ -291,7 +320,7 @@ export async function startAgent (opts = {}) {
291
320
  socket: local.path,
292
321
  get remote () { return remote },
293
322
  get machineId () { return remote?.machineId || null },
294
- close: () => { stopped = true; if (watcher) clearInterval(watcher); hub.killAll(); local.close(); remote?.close() }
323
+ close: () => { stopped = true; if (watcher) clearInterval(watcher); hub.killAll(); far.close(); local.close(); remote?.close() }
295
324
  }
296
325
  }
297
326
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@dotrino/terminal-agent",
3
- "version": "0.37.1",
3
+ "version": "0.38.0",
4
4
  "description": "Dotrino Terminal: las ventanas de esta máquina (dotrino-terminal) y su agente, que deja abrir esas mismas consolas desde los otros aparatos de tu cuenta, cifrado punto a punto.",
5
5
  "type": "module",
6
6
  "bin": {
@@ -13,6 +13,7 @@
13
13
  "files": [
14
14
  "index.js",
15
15
  "access.js",
16
+ "far.js",
16
17
  "editors.js",
17
18
  "consoles.js",
18
19
  "link.js",
@@ -32,19 +32,32 @@ No reescribas, ordenes, corrijas ni resumas lo que él escribió. Tampoco lo cop
32
32
  1. Comprueba que corres dentro de una consola: `echo "$DOTRINO_TERMINAL_CONSOLE"`. Vacío = no hay
33
33
  consola ni tarjeta: no hagas nada y no lo menciones.
34
34
  2. **Al empezar una tarea**: pon la tarea.
35
- 3. **Cuando cambia** (otra tarea, otro rumbo, un bloqueo): vuelve a ponerla.
36
- 4. **Al terminar o al quedar esperando al usuario**: dilo en la primera línea.
37
-
38
- Una orden por momento, sin anunciarlo ni comentarlo en la respuesta.
35
+ 3. **Mientras pasan cosas, no solo al principio y al final.** El dueño mira la tarjeta para saber
36
+ por dónde vas sin leer la consola: una tarjeta que dice lo de hace veinte minutos no le sirve.
37
+ Actualízala cada vez que:
38
+ - terminas un paso («Hecho: agente publicado»);
39
+ - publicas, despliegas o subes algo;
40
+ - algo falla o te bloquea;
41
+ - cambia el rumbo o llega otro encargo a mitad;
42
+ - quedas **esperando** algo (una compilación, CI, una prueba larga, su respuesta): dilo.
43
+ 4. **Al terminar**: dilo en la primera línea (`Terminado: …`) y deja lo que quede pendiente.
44
+
45
+ **Una tarjeta vieja es peor que una vacía.** Nunca termines un turno dejando un `Ahora:` que ya no
46
+ ocurre: lo último que haces antes de responder, si en el turno hiciste algo, es poner la tarea
47
+ como queda (`Terminado: …`, o qué esperas). Si ya no hay tarea, quítala (`--task ''`).
48
+
49
+ En una tarea larga eso son varias actualizaciones; es lo esperado. Una orden cada vez, sin
50
+ anunciarlo ni comentarlo en la respuesta.
39
51
 
40
52
  ## Cómo
41
53
 
42
54
  ```bash
43
- dotrino-terminal note --task "Arreglando el login de facturero"
44
-
45
55
  dotrino-terminal note --task - <<'EOF_TASK' # varias líneas, por la entrada estándar
46
56
  Arreglando el login de facturero
57
+ Hecho: el formulario
58
+ Ahora: la validación
47
59
  Falta: probar con firma real
60
+ Modelo: Opus 5.5
48
61
  EOF_TASK
49
62
 
50
63
  dotrino-terminal note --task '' # quita tu tarea (lo del dueño se queda)
@@ -57,8 +70,12 @@ No hace falta decir qué consola: es la tuya.
57
70
 
58
71
  - **Primera línea = la tarea, en una frase corta** (hasta ~60 caracteres): es lo que se ve en la
59
72
  lista. «Tarjeta de notas en dotrino-terminal», no «Trabajando en lo que pidió el usuario».
60
- - Debajo, solo lo que ayuda a retomar: `Hecho:` / `Falta:` / `Espera: tu visto bueno`. Tres o
61
- cuatro líneas en total.
73
+ - Debajo, el estado en tres o cuatro líneas: `Hecho:` (lo ya cerrado), `Ahora:` (lo que haces en
74
+ este momento), `Falta:` y, si aplica, `Espera:` (a qué). Reescríbela entera cada vez: es el
75
+ estado actual, no un historial.
76
+ - **La última línea dice qué modelo eres**: `Modelo: Opus 5.5` (el nombre con el que te presentas,
77
+ tal como lo dice tu contexto; no lo adivines ni pongas el identificador largo). Va siempre, en
78
+ cada actualización: el dueño tiene varias consolas con modelos distintos y quiere verlo ahí.
62
79
  - En el idioma del usuario. Sin secretos, llaves ni rutas con credenciales: la nota la ven todos
63
80
  los aparatos de la cuenta.
64
81
  - Al terminar no la quites: di que terminó (`Terminado: …`).