@dotrino/terminal-agent 0.37.1 → 0.39.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,10 +44,13 @@ 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)
50
52
  dotrino-terminal vscode [--name <n>] # la terminal embebida de VS Code abre consolas de aquí (--off lo deshace)
53
+ dotrino-terminal desktop update [--check] # actualiza la app de escritorio: baja, verifica la firma e instala
51
54
  ```
52
55
 
53
56
  Cerrar la ventana no cierra la consola: sigue viva en el agente y se retoma después (se cierra
@@ -58,6 +61,16 @@ título. Sin enlace el agente atiende solo a las ventanas locales; al enlazarlo
58
61
  (`dotrino-terminal link`) enciende la parte remota sin reiniciarse. La app de escritorio
59
62
  (`desktop/` del repo) es una ventana nativa que corre este mismo cliente.
60
63
 
64
+ **Las consolas de las otras máquinas** (`far.js`, ≥ 0.38). El agente de esta máquina hace de
65
+ CLIENTE de los otros agentes de la cuenta, con su propio enlace (`clientLink` de
66
+ `@dotrino/remote-agent`): es un aparato del acta y entra con lo que el acta le reconozca
67
+ (`sign`) y con la clave de la otra máquina si la tiene. Por el socket local se suman tres
68
+ mensajes: `{ type:'machines' }` (qué máquinas hay y sus consolas; contesta de memoria y
69
+ refresca por detrás), `{ type:'via', machine }` como PRIMER mensaje (la conexión pasa a hablar
70
+ con esa máquina, con el mismo protocolo) y `{ type:'far', machine, msg }` (una orden suelta).
71
+ La clave de una máquina se recuerda solo en memoria, cuando una ventana la escribió bien.
72
+ Solo esta máquina necesita la 0.38: las otras atienden como a cualquier aparato.
73
+
61
74
  `dotrino-terminal vscode` escribe el perfil de terminal «Dotrino» en el `settings.json` de VS Code,
62
75
  VS Code Insiders, VSCodium y Cursor (los que haya, Linux y macOS) y lo deja por defecto; conserva
63
76
  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
@@ -14,6 +16,7 @@
14
16
  * dotrino-terminal lock --off [--name <n>] la quita
15
17
  * dotrino-terminal vscode [--name <n>] la terminal embebida de VS Code abre consolas de aquí
16
18
  * dotrino-terminal vscode --off lo deshace
19
+ * dotrino-terminal desktop update [--check] actualiza la app de escritorio (la ventana)
17
20
  *
18
21
  * Un PERFIL es un agente con nombre (`~/.dotrino/agent/terminal-agent/<nombre>/`), enlazado a
19
22
  * una bóveda o solo local. Cada consola vive en el agente de un perfil.
@@ -56,6 +59,9 @@ if (args.includes('-h') || args.includes('--help')) {
56
59
  dotrino-terminal attach <id> [--name <n>] se engancha a una consola abierta
57
60
  dotrino-terminal ls [--name <n>] [--json] las consolas abiertas
58
61
  dotrino-terminal kill <id> [--name <n>] cierra una consola
62
+ dotrino-terminal machines [--json] tus otras máquinas encendidas y sus consolas
63
+ dotrino-terminal … --machine <id|nombre> abrir, attach, ls y kill, pero en otra máquina tuya
64
+ (su id o su nombre salen en «machines»)
59
65
  dotrino-terminal note enseña la nota de esta consola (de qué va)
60
66
  dotrino-terminal note <texto> la reemplaza («-» la lee de la entrada estándar)
61
67
  dotrino-terminal note --add <texto> le añade una línea
@@ -73,6 +79,9 @@ if (args.includes('-h') || args.includes('--help')) {
73
79
  dotrino-terminal vscode [--name <n>] hace que la terminal embebida de VS Code (y de
74
80
  VS Code Insiders, VSCodium y Cursor) abra consolas de aquí
75
81
  dotrino-terminal vscode --off lo deshace
82
+ dotrino-terminal desktop update actualiza la app de escritorio (la ventana): baja la
83
+ versión nueva, comprueba su firma y la instala
84
+ (--check solo mira si hay una)
76
85
 
77
86
  Dentro de una consola: Ctrl+] y luego d la suelta sin cerrarla; Ctrl+] n abre otra
78
87
  (y suelta la actual); Ctrl+] a <id> Enter pasa a esa consola; Ctrl+] p fija el tamaño de la
@@ -82,6 +91,9 @@ Cerrar la ventana no cierra la consola: sigue abierta y se retoma después.`, `u
82
91
  dotrino-terminal attach <id> [--name <n>] attach to an open console
83
92
  dotrino-terminal ls [--name <n>] [--json] list open consoles
84
93
  dotrino-terminal kill <id> [--name <n>] close a console
94
+ dotrino-terminal machines [--json] your other machines that are on, and their consoles
95
+ dotrino-terminal … --machine <id|name> open, attach, ls and kill, but on another machine of yours
96
+ (its id or name show up in "machines")
85
97
  dotrino-terminal note show this console's note (what it is about)
86
98
  dotrino-terminal note <text> replace it ("-" reads it from standard input)
87
99
  dotrino-terminal note --add <text> append a line
@@ -99,6 +111,9 @@ Cerrar la ventana no cierra la consola: sigue abierta y se retoma después.`, `u
99
111
  dotrino-terminal vscode [--name <n>] make the integrated terminal of VS Code (and VS Code
100
112
  Insiders, VSCodium and Cursor) open consoles from here
101
113
  dotrino-terminal vscode --off undo it
114
+ dotrino-terminal desktop update update the desktop app (the window): downloads the
115
+ new version, checks its signature and installs it
116
+ (--check only looks for one)
102
117
 
103
118
  Inside a console: Ctrl+] then d detaches without closing it; Ctrl+] n opens another
104
119
  (detaching the current one); Ctrl+] a <id> Enter switches to that console; Ctrl+] p pins the
@@ -207,6 +222,49 @@ function vscode () {
207
222
  if (!off) console.log(t('\nLas terminales nuevas del editor ya abren aquí. Si actualizas o cambias de Node, vuelve a correr esta orden.', '\nNew terminals in the editor now open here. If you update or switch Node, run this command again.'))
208
223
  }
209
224
 
225
+ /** Dónde está la app de escritorio, si no lo dijo quien llama: la del PATH. */
226
+ function findDesktop (name) {
227
+ for (const d of (process.env.PATH || '').split(path.delimiter)) {
228
+ if (!d) continue
229
+ const f = path.join(d, name)
230
+ try { fs.accessSync(f, fs.constants.X_OK); return fs.realpathSync(f) } catch (_) {}
231
+ }
232
+ return null
233
+ }
234
+
235
+ /**
236
+ * Actualiza la app de escritorio. La app lo corre desde su menú con `--current` (su versión)
237
+ * y `--exe` (su binario); a mano basta `dotrino-terminal desktop update`.
238
+ */
239
+ async function desktop () {
240
+ if (args[1] !== 'update') die(t('uso: dotrino-terminal desktop update [--check]', 'usage: dotrino-terminal desktop update [--check]'))
241
+ const { updateDesktop, BINARY } = await import('../desktop.js')
242
+ const current = opt('--current')
243
+ const exe = opt('--exe') || findDesktop(BINARY)
244
+ const check = args.includes('--check')
245
+ if (!exe && !check) die(t(`no encontré ${BINARY} en esta máquina. Bájala de https://terminal.dotrino.com/`, `could not find ${BINARY} on this machine. Get it from https://terminal.dotrino.com/`))
246
+ const say = (step, d) => {
247
+ if (step === 'latest') console.log(d.current ? t(`Publicada: ${d.version} · esta: ${d.current}`, `Published: ${d.version} · this one: ${d.current}`) : t(`Publicada: ${d.version}`, `Published: ${d.version}`))
248
+ if (step === 'download') console.log(t(`Bajando ${d.name} y comprobando su firma…`, `Downloading ${d.name} and checking its signature…`))
249
+ if (step === 'verified') console.log(t(`Firmado por la release de ${d.repo} ✓`, `Signed by the release of ${d.repo} ✓`))
250
+ if (step === 'install' && (d.kind === 'deb' || d.kind === 'rpm') && process.getuid?.() !== 0) console.log(t('Instalar un paquete del sistema pide tu contraseña:', 'Installing a system package asks for your password:'))
251
+ }
252
+ console.log(t('Mirando qué hay publicado…', 'Checking what is published…'))
253
+ const r = await updateDesktop({ exe, current, check, say })
254
+ if (!r.ok) {
255
+ const why = {
256
+ 'could-not-check': t(`No se pudo mirar (${r.reason}). No es que estés al día: es que no se sabe.`, `Could not check (${r.reason}). That does not mean you are up to date: it is unknown.`),
257
+ NO_GH: t('NO se instala nada: falta GitHub CLI (gh), que es con lo que se comprueba la firma. Instálalo (https://cli.github.com; no hace falta iniciar sesión) y repite.', 'Nothing is installed: GitHub CLI (gh) is missing, and it is what checks the signature. Install it (https://cli.github.com; no login needed) and try again.'),
258
+ GH_TOO_OLD: t('NO se instala nada: este gh es anterior a la 2.49 y no sabe comprobar firmas. Actualiza GitHub CLI y repite.', 'Nothing is installed: this gh predates 2.49 and cannot check signatures. Update GitHub CLI and try again.'),
259
+ 'not-writable': t(`NO se instala nada: no puedo escribir donde está la app (${r.reason}). Bájala de https://terminal.dotrino.com/`, `Nothing is installed: I cannot write where the app is (${r.reason}). Get it from https://terminal.dotrino.com/`)
260
+ }[r.code] || t(`NO se instala nada: ${r.reason}`, `Nothing is installed: ${r.reason}`)
261
+ die(r.file ? `${why}\n${t('El archivo, ya comprobado, quedó en', 'The file, already checked, is at')} ${r.file}` : why)
262
+ }
263
+ if (r.updated) console.log(t(`\nInstalada la ${r.version}. Las ventanas abiertas siguen con la anterior: cierra Dotrino Terminal y vuelve a abrirla. Tus consolas no se cierran.`, `\nInstalled ${r.version}. Open windows keep the old one: quit Dotrino Terminal and open it again. Your consoles stay open.`))
264
+ else if (r.newer) console.log(t('Hay versión nueva. Tráela con: dotrino-terminal desktop update', 'There is a new version. Get it with: dotrino-terminal desktop update'))
265
+ else console.log(t(`La app está al día (${current}).`, `The app is up to date (${current}).`))
266
+ }
267
+
210
268
  /** Enlaza un perfil. Sin `--name`, lo pregunta. Uno ya enlazado no se pisa: eso es `enroll`. */
211
269
  async function link () {
212
270
  let name = opt('--name')
@@ -371,6 +429,57 @@ function request (conn, msg, type) {
371
429
  })
372
430
  }
373
431
 
432
+ /** Lo que se espera a que el agente conteste por otra máquina (descubrirla y saludarla). */
433
+ const FAR_WAIT_MS = 40_000
434
+ /** Una pregunta sobre las otras máquinas. Un agente anterior a la 0.38 no la entiende y calla: se dice. */
435
+ async function farRequest (conn, msg, type) {
436
+ const r = await Promise.race([request(conn, msg, type), new Promise((resolve) => setTimeout(() => resolve(null), FAR_WAIT_MS))])
437
+ 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.'))
438
+ return r
439
+ }
440
+ const farMessage = (r) => ({
441
+ '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'),
442
+ '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").'),
443
+ '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").')
444
+ }[r.code] || `${r.message} (${r.code})`)
445
+
446
+ /** `dotrino-terminal machines`: las otras máquinas de la cuenta que están encendidas, y sus consolas. */
447
+ async function machines (conn) {
448
+ const r = await farRequest(conn, { type: 'machines' }, 'machines')
449
+ if (r.type === 'fail') die(`dotrino-terminal: ${farMessage(r)}`)
450
+ if (args.includes('--json')) { console.log(JSON.stringify(r.list, null, 2)); return }
451
+ 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 }
452
+ for (const m of r.list) {
453
+ 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')}`
454
+ console.log(`${m.id} ${m.name || ''} · ${state}`)
455
+ for (const c of m.consoles || []) console.log(` ${c.id} ${age(Date.now() - c.createdAt).padStart(4)} ${c.viewers} ${t('mirando', 'watching')} ${c.title || ''}`)
456
+ }
457
+ }
458
+
459
+ /**
460
+ * `--machine <id|nombre>`: esta conexión pasa a hablar con OTRA máquina de la cuenta (el agente
461
+ * de aquí hace de puente, `far.js`). A partir de ahí todo es igual que en local. Si la otra
462
+ * máquina tiene clave, se pide aquí, antes de seguir.
463
+ */
464
+ async function goVia (conn, ref) {
465
+ const r = await farRequest(conn, { type: 'via', machine: ref }, 'via')
466
+ if (r.type === 'fail') die(`dotrino-terminal: ${farMessage(r)}`)
467
+ let probe = await farRequest(conn, { type: 'list' }, 'consoles')
468
+ const name = r.machine.name || r.machine.id
469
+ while (probe.type === 'fail' && ['locked', 'bad-code', 'wait'].includes(probe.code)) {
470
+ if (probe.code === 'bad-code') console.error(t('Clave incorrecta.', 'Wrong code.'))
471
+ 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.`))
472
+ // Lo tecleado aquí es la clave, no entrada para la consola.
473
+ process.stdin.off('data', earlyTap)
474
+ early.length = 0
475
+ const code = await askHidden(t(`Clave de ${name}: `, `Code for ${name}: `))
476
+ if (!code) die(t('sin clave no se entra.', 'no code, no entry.'))
477
+ probe = await farRequest(conn, { type: 'unlock', code }, 'unlocked')
478
+ if (probe.type === 'unlocked') break
479
+ }
480
+ if (probe.type === 'fail') die(`dotrino-terminal: ${probe.message} (${probe.code})`)
481
+ }
482
+
374
483
  const age = (ms) => {
375
484
  const s = Math.round(ms / 1000)
376
485
  return s < 60 ? `${s}s` : s < 3600 ? `${Math.round(s / 60)}m` : `${Math.round(s / 3600)}h`
@@ -469,7 +578,14 @@ function interactive (conn, first, dir) {
469
578
  const onInfo = (info) => {
470
579
  if (!info) return
471
580
  shellTitle = info.title || ''
472
- const now = new Set(info.watchers.filter((w) => w.origin === 'remote').map((w) => w.device || '?'))
581
+ // En otra máquina (`--machine`) esta ventana es, para aquella, «otro aparato»: no se cuenta
582
+ // a sí misma (se reconoce por su etiqueta; sin etiqueta, es una de las que salen).
583
+ let far = info.watchers.filter((w) => w.origin === 'remote')
584
+ if (opt('--machine')) {
585
+ const mine = opt('--tag') ? far.findIndex((w) => w.tag === opt('--tag')) : 0
586
+ if (mine >= 0) far = far.filter((_, i) => i !== mine)
587
+ }
588
+ const now = new Set(far.map((w, i) => (opt('--machine') ? `${w.device || '?'}#${w.tag || i}` : w.device || '?')))
473
589
  const arrived = [...now].some((d) => !remote.has(d))
474
590
  remote = now
475
591
  if (arrived) out.write('\x07') // la campana: alguien entró desde fuera
@@ -623,10 +739,14 @@ try {
623
739
  if (cmd === 'rename') { await rename(); process.exit(0) }
624
740
  if (cmd === 'lock') { await lock(); process.exit(0) }
625
741
  if (cmd === 'vscode') { vscode(); process.exit(0) }
742
+ if (cmd === 'desktop') { await desktop(); process.exit(0) }
626
743
  if (cmd === 'note') { await note(); process.exit(0) }
627
744
  const dir = opt('--dir') || dataDir(opt('--name'))
628
745
  if (cmd === 'open' || cmd === 'attach') captureEarly()
629
746
  const conn = await agent(dir)
747
+ const machine = opt('--machine')
748
+ if (cmd === 'machines') { await machines(conn); conn.close(); process.exit(0) }
749
+ if (machine) await goVia(conn, machine)
630
750
  if (cmd === 'ls' || cmd === 'list') { await list(conn); conn.close() } else if (cmd === 'kill') {
631
751
  if (!args[1]) die(t('falta el id: dotrino-terminal kill <id>', 'missing id: dotrino-terminal kill <id>'))
632
752
  conn.send({ type: 'kill', id: args[1] })
@@ -638,7 +758,9 @@ try {
638
758
  interactive(conn, { type: 'attach', id: args[1], ...tag() }, dir)
639
759
  } else if (cmd === 'open') {
640
760
  // 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)
761
+ // En otra máquina, la carpeta de aquí no existe: abre en su carpeta de inicio, salvo `--cwd`.
762
+ const cwd = machine ? (opt('--cwd') ? { cwd: opt('--cwd') } : {}) : { cwd: path.resolve(opt('--cwd') || process.cwd()) }
763
+ interactive(conn, { type: 'open', ...cwd, ...tag() }, dir)
642
764
  } else die(t(`orden desconocida: ${cmd} (mira --help)`, `unknown command: ${cmd} (see --help)`))
643
765
  } catch (e) {
644
766
  if (e !== HOLD) { try { die(`dotrino-terminal: ${e.message}`) } catch (_) {} }
package/desktop.js ADDED
@@ -0,0 +1,166 @@
1
+ /**
2
+ * desktop.js — actualizar la APP DE ESCRITORIO (la ventana, `dotrino-terminal-desktop`).
3
+ *
4
+ * La app es un binario de Rust sin red: no baja nada ella. Su menú corre
5
+ * `dotrino-terminal desktop update` en la ventana, a la vista, y esto hace el trabajo con la
6
+ * misma pieza que el resto del ecosistema (`@dotrino/update`, CONVENCIONES §15): mira la
7
+ * release, baja el archivo que le toca a esta máquina, lo VERIFICA contra su atestación y solo
8
+ * entonces lo instala. Sin con qué verificar, se para y se dice.
9
+ *
10
+ * Cómo se instala depende de cómo llegó la app:
11
+ *
12
+ * · `.deb` / `.rpm` — el binario es de root: `sudo dpkg -i` / `sudo rpm -U`, que pide la
13
+ * contraseña en esa misma ventana.
14
+ * · tarball — el binario es del usuario: se cambia por el nuevo, de forma atómica.
15
+ * · macOS — se cambia el `.app` entero.
16
+ *
17
+ * La ventana que ya corre sigue con la versión anterior hasta que se cierre y se vuelva a abrir.
18
+ */
19
+ import fs from 'node:fs'
20
+ import os from 'node:os'
21
+ import path from 'node:path'
22
+ import { execFileSync } from 'node:child_process'
23
+ import { latestVersion, isNewer } from '@dotrino/update'
24
+ import { pickAsset, fetchVerified } from '@dotrino/update/fetch'
25
+ import { REPO } from './update.js'
26
+
27
+ /** Este repo también lleva el agente y la PWA: las releases del escritorio van con prefijo. */
28
+ export const DESKTOP_TAG = 'desktop-v'
29
+ export const BINARY = 'dotrino-terminal-desktop'
30
+ const PRODUCT = 'dotrino-terminal-desktop'
31
+
32
+ const fail = (code, reason, extra = {}) => ({ ok: false, code, reason, ...extra })
33
+
34
+ /** La última release del escritorio. `{ ok:false }` si no se pudo mirar, que NO es «al día». */
35
+ export const latestDesktop = (opts = {}) =>
36
+ latestVersion({ source: 'github', repo: REPO, tagPrefix: DESKTOP_TAG, product: PRODUCT, ...opts })
37
+
38
+ /**
39
+ * Cómo está instalada la app que corre desde `exe`, que es lo que decide qué archivo se baja
40
+ * y cómo se pone. Se le pregunta al gestor de paquetes por ESE archivo: mirar solo qué
41
+ * gestor hay se equivoca con un tarball en una máquina con `dpkg`.
42
+ *
43
+ * @returns {{ok:true, kind:'deb'|'rpm'|'tar'|'mac', app?:string} | {ok:false, code:string, reason:string}}
44
+ */
45
+ export function installKind ({ exe, platform = process.platform, arch = process.arch, run = execFileSync, writable = canWrite } = {}) {
46
+ if (!exe) return fail('no-exe', 'the desktop app was not found')
47
+ if (platform === 'darwin') {
48
+ const m = /^(.+\.app)\/Contents\/MacOS\/[^/]+$/.exec(exe)
49
+ if (!m) return fail('not-a-bundle', `${exe} is not inside an .app bundle`)
50
+ if (!writable(path.dirname(m[1]))) return fail('not-writable', `cannot write in ${path.dirname(m[1])}`)
51
+ return { ok: true, kind: 'mac', app: m[1] }
52
+ }
53
+ if (platform !== 'linux') return fail('unsupported-platform', `there is no desktop app for ${platform}`)
54
+ if (arch !== 'x64') return fail('unsupported-arch', `there is no desktop app for ${arch}`)
55
+ const owns = (cmd, args) => { try { run(cmd, args, { stdio: 'ignore' }); return true } catch (_) { return false } }
56
+ if (owns('dpkg', ['-S', exe])) return { ok: true, kind: 'deb' }
57
+ if (owns('rpm', ['-qf', exe])) return { ok: true, kind: 'rpm' }
58
+ if (!writable(path.dirname(exe))) return fail('not-writable', `${exe} does not belong to a package and its folder is not writable`)
59
+ return { ok: true, kind: 'tar' }
60
+ }
61
+
62
+ function canWrite (dir) {
63
+ try { fs.accessSync(dir, fs.constants.W_OK); return true } catch (_) { return false }
64
+ }
65
+
66
+ const MATCH = {
67
+ deb: { kind: 'deb', re: /_amd64\.deb$/ },
68
+ rpm: { kind: 'rpm', re: /\.x86_64\.rpm$/ },
69
+ tar: { kind: 'tar', re: /-linux-x64\.tar\.gz$/ },
70
+ mac: { kind: 'mac', re: /-macos-universal\.zip$/ }
71
+ }
72
+
73
+ /** El archivo de la release que le toca a esa forma de instalación. */
74
+ export const assetFor = (assets, kind) => pickAsset(assets, [MATCH[kind]])
75
+
76
+ /** Como root no hace falta `sudo`; si no, se pide en la ventana. */
77
+ function asRoot (cmd, args, { run, uid }) {
78
+ const [c, a] = uid === 0 ? [cmd, args] : ['sudo', [cmd, ...args]]
79
+ run(c, a, { stdio: 'inherit' })
80
+ return [c, ...a].join(' ')
81
+ }
82
+
83
+ /**
84
+ * Pone el archivo ya verificado. Devuelve `{ ok:true }` o por qué no se pudo; si el archivo
85
+ * quedó bajado y sirve para instalarlo a mano, va en `file`.
86
+ */
87
+ export function install (file, how, { exe, run = execFileSync, uid = process.getuid?.() } = {}) {
88
+ try {
89
+ if (how.kind === 'deb') { asRoot('dpkg', ['-i', file], { run, uid }); return { ok: true } }
90
+ if (how.kind === 'rpm') { asRoot('rpm', ['-U', file], { run, uid }); return { ok: true } }
91
+ } catch (e) {
92
+ return fail('install-failed', `the package manager did not install it: ${e.message}`, { file })
93
+ }
94
+ if (how.kind === 'tar') {
95
+ const work = path.dirname(file)
96
+ try { run('tar', ['xzf', file, '-C', work], { stdio: ['ignore', 'ignore', 'pipe'] }) } catch (e) {
97
+ return fail('unpack-failed', `could not unpack the release: ${String(e.stderr || e.message).trim()}`, { file })
98
+ }
99
+ const src = fs.readdirSync(work).map((d) => path.join(work, d, BINARY)).find((f) => fs.existsSync(f))
100
+ if (!src) return fail('bad-tarball', `the tarball has no ${BINARY} inside`, { file })
101
+ // Al lado y renombrado encima: nunca queda un binario a medias, y la ventana que corre
102
+ // sigue con el suyo (el archivo viejo vive mientras alguien lo tenga abierto).
103
+ const tmp = path.join(path.dirname(exe), `.${path.basename(exe)}.new`)
104
+ fs.copyFileSync(src, tmp)
105
+ fs.chmodSync(tmp, 0o755)
106
+ fs.renameSync(tmp, exe)
107
+ return { ok: true }
108
+ }
109
+ if (how.kind === 'mac') {
110
+ // Se desempaqueta AL LADO del .app (mismo volumen) para poder cambiarlo renombrando.
111
+ const parent = path.dirname(how.app)
112
+ const work = fs.mkdtempSync(path.join(parent, '.dotrino-terminal-update-'))
113
+ try {
114
+ run('ditto', ['-x', '-k', file, work], { stdio: ['ignore', 'ignore', 'pipe'] })
115
+ const fresh = fs.readdirSync(work).map((d) => path.join(work, d)).find((d) => d.endsWith('.app') && fs.existsSync(path.join(d, 'Contents', 'MacOS', BINARY)))
116
+ if (!fresh) return fail('bad-zip', `the zip has no .app with ${BINARY} inside`, { file })
117
+ const old = path.join(work, 'old.app')
118
+ fs.renameSync(how.app, old)
119
+ try { fs.renameSync(fresh, how.app) } catch (e) { fs.renameSync(old, how.app); throw e }
120
+ return { ok: true }
121
+ } catch (e) {
122
+ return fail('install-failed', `could not replace the app: ${String(e.stderr || e.message).trim()}`, { file })
123
+ } finally {
124
+ fs.rmSync(work, { recursive: true, force: true })
125
+ }
126
+ }
127
+ return fail('unknown-kind', `unknown install kind: ${how.kind}`)
128
+ }
129
+
130
+ /**
131
+ * Todo el camino: mirar, bajar, verificar, instalar. `say(step, data)` va contando por dónde
132
+ * va, para que quien lo enseñe lo diga en su idioma.
133
+ *
134
+ * @returns {Promise<{ok:true, version:string, updated:boolean, kind?:string} | {ok:false, code:string, reason:string, file?:string}>}
135
+ */
136
+ export async function updateDesktop ({ exe, current, check = false, say = () => {}, latest = latestDesktop, fetchVerifiedImpl = fetchVerified, kindOf = installKind, installImpl = install } = {}) {
137
+ const r = await latest({ version: current })
138
+ if (!r.ok) return fail('could-not-check', r.reason)
139
+ say('latest', { version: r.version, current })
140
+ if (current && !isNewer(r.version, current)) return { ok: true, version: r.version, updated: false }
141
+ if (check) return { ok: true, version: r.version, updated: false, newer: true }
142
+ const how = kindOf({ exe })
143
+ if (!how.ok) return how
144
+ const pick = assetFor(r.assets, how.kind)
145
+ if (!pick.ok) return fail('no-asset', pick.reason)
146
+ say('download', { name: pick.asset.name })
147
+ const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'dotrino-terminal-update-'))
148
+ let keep = false
149
+ try {
150
+ let got
151
+ try { got = await fetchVerifiedImpl(pick.asset, { repo: REPO, product: PRODUCT, version: current, dir }) } catch (e) {
152
+ return fail(e.code || 'download-failed', e.message)
153
+ }
154
+ // Lo que no pasa la verificación no se deja en el disco: nadie debe instalarlo a mano.
155
+ if (!got.ok) return fail(got.code || 'not-verified', got.reason)
156
+ say('verified', { name: pick.asset.name, repo: REPO })
157
+ say('install', { kind: how.kind })
158
+ const done = installImpl(got.file, how, { exe })
159
+ if (!done.ok) { keep = !!done.file; return done }
160
+ return { ok: true, version: r.version, updated: true, kind: how.kind }
161
+ } finally {
162
+ if (!keep) fs.rmSync(dir, { recursive: true, force: true })
163
+ }
164
+ }
165
+
166
+ export default { updateDesktop, latestDesktop, installKind, assetFor, install, DESKTOP_TAG, BINARY }
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.39.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,8 +13,10 @@
13
13
  "files": [
14
14
  "index.js",
15
15
  "access.js",
16
+ "far.js",
16
17
  "editors.js",
17
18
  "consoles.js",
19
+ "desktop.js",
18
20
  "link.js",
19
21
  "local.js",
20
22
  "title.js",
@@ -31,7 +33,7 @@
31
33
  "@dotrino/identity": "0.107.2",
32
34
  "@dotrino/proxy-client": "0.30.3",
33
35
  "@dotrino/remote-agent": "0.18.1",
34
- "@dotrino/update": "0.5.1",
36
+ "@dotrino/update": "0.8.0",
35
37
  "@dotrino/vault": "0.82.1",
36
38
  "@xterm/addon-serialize": "0.13.0",
37
39
  "@xterm/headless": "5.5.0",
@@ -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: …`).