@dotrino/terminal-agent 0.34.1 → 0.36.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 +19 -0
- package/bin/terminal.js +57 -2
- package/consoles.js +35 -55
- package/index.js +24 -12
- package/package.json +3 -2
- package/skills/dotrino-terminal-note/SKILL.md +57 -0
package/README.md
CHANGED
|
@@ -83,6 +83,25 @@ carpeta concreta. El `link.json` guarda la llave privada: trátalo como una llav
|
|
|
83
83
|
|
|
84
84
|
MIT.
|
|
85
85
|
|
|
86
|
+
## La nota de una consola (de qué va)
|
|
87
|
+
|
|
88
|
+
Cada consola lleva una nota de texto libre: la tarea en curso, lo que falta. Sale en una tarjeta
|
|
89
|
+
flotante sobre la consola (junto con su título) y, su primera línea, en la lista de consolas. La
|
|
90
|
+
edita la persona desde la tarjeta, o el programa que corre dentro:
|
|
91
|
+
|
|
92
|
+
```bash
|
|
93
|
+
dotrino-terminal note # la enseña
|
|
94
|
+
dotrino-terminal note "texto" # la reemplaza («-» la lee de la entrada estándar)
|
|
95
|
+
dotrino-terminal note --add "línea" # le añade una línea
|
|
96
|
+
dotrino-terminal note --clear # la borra
|
|
97
|
+
```
|
|
98
|
+
|
|
99
|
+
Sin `--id`, es la consola en la que corre la orden: el agente pone su id en
|
|
100
|
+
`DOTRINO_TERMINAL_CONSOLE`. Vive en memoria, como la consola: se va con ella. Hasta 4000 caracteres.
|
|
101
|
+
|
|
102
|
+
Para que un agente de IA la mantenga al día, el paquete trae un skill de Claude Code en
|
|
103
|
+
`skills/dotrino-terminal-note/`: se copia a `~/.claude/skills/`.
|
|
104
|
+
|
|
86
105
|
## Clave de la máquina (opcional)
|
|
87
106
|
|
|
88
107
|
Por defecto, cualquier aparato de tu cuenta con permiso abre consolas en esta máquina. Si
|
package/bin/terminal.js
CHANGED
|
@@ -6,6 +6,7 @@
|
|
|
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 note [texto] la nota de esta consola (de qué va): la lee o la cambia
|
|
9
10
|
* dotrino-terminal profiles [--json] los perfiles de esta máquina (enlazados o no)
|
|
10
11
|
* dotrino-terminal link [--name <n>] enlaza un perfil con tu bóveda
|
|
11
12
|
* dotrino-terminal rename <perfil> [nuevo] renombra un perfil (para su agente si corre)
|
|
@@ -55,6 +56,11 @@ if (args.includes('-h') || args.includes('--help')) {
|
|
|
55
56
|
dotrino-terminal attach <id> [--name <n>] se engancha a una consola abierta
|
|
56
57
|
dotrino-terminal ls [--name <n>] [--json] las consolas abiertas
|
|
57
58
|
dotrino-terminal kill <id> [--name <n>] cierra una consola
|
|
59
|
+
dotrino-terminal note enseña la nota de esta consola (de qué va)
|
|
60
|
+
dotrino-terminal note <texto> la reemplaza («-» la lee de la entrada estándar)
|
|
61
|
+
dotrino-terminal note --add <texto> le añade una línea
|
|
62
|
+
dotrino-terminal note --clear la borra
|
|
63
|
+
(--id <id> para otra consola; --json para leerla una máquina)
|
|
58
64
|
dotrino-terminal profiles [--json] los perfiles de esta máquina
|
|
59
65
|
dotrino-terminal link [--name <n>] enlaza un perfil con tu bóveda
|
|
60
66
|
dotrino-terminal rename <perfil> [nuevo] renombra un perfil (para su agente: cierra sus consolas)
|
|
@@ -74,6 +80,11 @@ Cerrar la ventana no cierra la consola: sigue abierta y se retoma después.`, `u
|
|
|
74
80
|
dotrino-terminal attach <id> [--name <n>] attach to an open console
|
|
75
81
|
dotrino-terminal ls [--name <n>] [--json] list open consoles
|
|
76
82
|
dotrino-terminal kill <id> [--name <n>] close a console
|
|
83
|
+
dotrino-terminal note show this console's note (what it is about)
|
|
84
|
+
dotrino-terminal note <text> replace it ("-" reads it from standard input)
|
|
85
|
+
dotrino-terminal note --add <text> append a line
|
|
86
|
+
dotrino-terminal note --clear clear it
|
|
87
|
+
(--id <id> for another console; --json for a machine to read)
|
|
77
88
|
dotrino-terminal profiles [--json] this machine's profiles
|
|
78
89
|
dotrino-terminal link [--name <n>] link a profile with your vault
|
|
79
90
|
dotrino-terminal rename <profile> [new] rename a profile (stops its agent: closes its consoles)
|
|
@@ -372,6 +383,49 @@ async function list (conn) {
|
|
|
372
383
|
}
|
|
373
384
|
}
|
|
374
385
|
|
|
386
|
+
/**
|
|
387
|
+
* La nota de una consola: de qué va. Sin `--id` es la consola en la que corre esta orden (el
|
|
388
|
+
* agente pone su id en `DOTRINO_TERMINAL_CONSOLE`), que es como la cambia un programa desde dentro.
|
|
389
|
+
* No levanta ningún agente: sin agente no hay consola a la que ponerle nota.
|
|
390
|
+
*/
|
|
391
|
+
async function note () {
|
|
392
|
+
const id = opt('--id') || process.env.DOTRINO_TERMINAL_CONSOLE
|
|
393
|
+
if (!id) die(t('no sé de qué consola: esta shell no corre dentro de Dotrino Terminal. Usa --id <id> (mira «dotrino-terminal ls»).', 'no console to act on: this shell is not running inside Dotrino Terminal. Use --id <id> (see "dotrino-terminal ls").'))
|
|
394
|
+
// Dentro de una consola, el perfil es el de esa consola, no el `default`.
|
|
395
|
+
const dir = opt('--dir') || (opt('--name') ? dataDir(opt('--name')) : process.env.DOTRINO_TERMINAL_PROFILE_DIR || dataDir())
|
|
396
|
+
const valued = new Set(['--id', '--dir', '--name', '--add'])
|
|
397
|
+
const words = []
|
|
398
|
+
for (let i = 1; i < args.length; i++) {
|
|
399
|
+
if (valued.has(args[i])) { i++; continue }
|
|
400
|
+
if (args[i] === '-' || !args[i].startsWith('-')) words.push(args[i])
|
|
401
|
+
}
|
|
402
|
+
const stdin = () => fs.readFileSync(0, 'utf8').replace(/\n+$/, '')
|
|
403
|
+
const given = words.length ? (words.length === 1 && words[0] === '-' ? stdin() : words.join(' ')) : null
|
|
404
|
+
const add = opt('--add') === '-' ? stdin() : opt('--add')
|
|
405
|
+
let conn
|
|
406
|
+
try { conn = await connectLocal(dir) } catch (e) {
|
|
407
|
+
if (e.code !== 'ENOAGENT') throw e
|
|
408
|
+
die(t('el agente de este perfil no está corriendo.', 'this profile\'s agent is not running.'))
|
|
409
|
+
}
|
|
410
|
+
const ask = async (msg) => {
|
|
411
|
+
const r = await Promise.race([request(conn, msg, 'noted'), new Promise((resolve) => setTimeout(() => resolve(null), 5000))])
|
|
412
|
+
// Un agente anterior a la 0.36 no conoce la orden y no contesta: se dice, no se da por hecho.
|
|
413
|
+
if (!r) die(t('el agente no contestó: es anterior a la 0.36.0 y no tiene notas. Actualízalo y reinícialo.', 'the agent did not answer: it predates 0.36.0 and has no notes. Update and restart it.'))
|
|
414
|
+
if (r.type === 'fail') die(`dotrino-terminal: ${r.message} (${r.code})`)
|
|
415
|
+
return r.console
|
|
416
|
+
}
|
|
417
|
+
let c
|
|
418
|
+
if (args.includes('--clear')) c = await ask({ type: 'note', id, text: '' })
|
|
419
|
+
else if (add !== undefined) {
|
|
420
|
+
const before = (await ask({ type: 'note', id })).note || ''
|
|
421
|
+
c = await ask({ type: 'note', id, text: before ? `${before}\n${add}` : add })
|
|
422
|
+
} else if (given !== null) c = await ask({ type: 'note', id, text: given })
|
|
423
|
+
else c = await ask({ type: 'note', id })
|
|
424
|
+
conn.close()
|
|
425
|
+
if (args.includes('--json')) console.log(JSON.stringify({ id: c.id, n: c.n, title: c.title, note: c.note }, null, 2))
|
|
426
|
+
else if (c.note) console.log(c.note)
|
|
427
|
+
}
|
|
428
|
+
|
|
375
429
|
/** La ventana: la TTY enganchada a una consola del agente. */
|
|
376
430
|
function interactive (conn, first, dir) {
|
|
377
431
|
// Hasta que el agente diga `attached` no hay consola a la que escribir: se guarda.
|
|
@@ -521,8 +575,8 @@ function interactive (conn, first, dir) {
|
|
|
521
575
|
// «r»: esta ventana manda en el tamaño de la consola (la app la usa al ganar el foco: con
|
|
522
576
|
// varias ventanas de tamaños distintos en la misma consola, se ajusta a la que miras).
|
|
523
577
|
if (ch === 'r') { conn.send({ type: 'resize', ...size() }); continue }
|
|
524
|
-
// «p
|
|
525
|
-
if (ch === 'p'
|
|
578
|
+
// «p»: ⤢, la consola toma ahora el tamaño de esta ventana.
|
|
579
|
+
if (ch === 'p') { conn.send({ type: 'resize', ...size() }); conn.send({ type: 'take' }); continue }
|
|
526
580
|
if (ch === 'n') {
|
|
527
581
|
if (send) { input(send); send = '' }
|
|
528
582
|
switchTo({ type: 'open', cwd: first.cwd || path.resolve(process.cwd()) })
|
|
@@ -550,6 +604,7 @@ try {
|
|
|
550
604
|
if (cmd === 'rename') { await rename(); process.exit(0) }
|
|
551
605
|
if (cmd === 'lock') { await lock(); process.exit(0) }
|
|
552
606
|
if (cmd === 'vscode') { vscode(); process.exit(0) }
|
|
607
|
+
if (cmd === 'note') { await note(); process.exit(0) }
|
|
553
608
|
const dir = opt('--dir') || dataDir(opt('--name'))
|
|
554
609
|
if (cmd === 'open' || cmd === 'attach') captureEarly()
|
|
555
610
|
const conn = await agent(dir)
|
package/consoles.js
CHANGED
|
@@ -43,6 +43,8 @@ const MIN_TASK_MS = 3000 // menos que esto no fue «una tarea»: no se marca c
|
|
|
43
43
|
// Cerrar una consola: SIGHUP al momento y, si la shell sigue viva, SIGTERM y luego SIGKILL.
|
|
44
44
|
export const KILL_TERM_MS = 1500
|
|
45
45
|
export const KILL_KILL_MS = 3000
|
|
46
|
+
/** Lo más largo que puede ser la nota de una consola. Viaja con cada `info`: tiene que ser corta. */
|
|
47
|
+
export const NOTE_MAX = 4000
|
|
46
48
|
|
|
47
49
|
/**
|
|
48
50
|
* La carpeta en la que está AHORA el proceso de una consola (la shell), con `~` por la carpeta
|
|
@@ -78,17 +80,19 @@ class Console {
|
|
|
78
80
|
this.pty = pty
|
|
79
81
|
this.origin = origin // 'local' (una ventana de esta máquina) | 'remote' (otro aparato)
|
|
80
82
|
this.title = '' // el que pone la shell (OSC 0/2), para reconocerla en la lista
|
|
83
|
+
// DE QUÉ VA esta consola: una nota libre que escribe la persona desde cualquier pantalla, o el
|
|
84
|
+
// programa que corre dentro (`dotrino-terminal note`). En memoria, como todo lo de la consola.
|
|
85
|
+
this.note = ''
|
|
81
86
|
this.cols = cols
|
|
82
87
|
this.rows = rows
|
|
83
88
|
this.createdAt = Date.now()
|
|
84
89
|
this.lastActive = Date.now()
|
|
85
90
|
this.viewers = new Set() // sesiones mirando: { onOut(data), onExit(code), onMeta?(info), origin, device?, tag?, size? }
|
|
86
|
-
// QUIÉN
|
|
87
|
-
//
|
|
88
|
-
//
|
|
89
|
-
//
|
|
90
|
-
//
|
|
91
|
-
this.pinKey = null
|
|
91
|
+
// QUIÉN PUSO EL TAMAÑO. Lo gana una pantalla en cuatro momentos y solo en esos: al abrir la
|
|
92
|
+
// consola, al cambiarse a ella, al pulsar ⤢ y al teclear. Se ajusta en ese instante y nada
|
|
93
|
+
// queda fijado: la siguiente pantalla que haga una de las cuatro cosas lo cambia. `holder` es la última que lo
|
|
94
|
+
// hizo; solo a ella se le sigue la pantalla (redimensionar la ventana, girar el teléfono).
|
|
95
|
+
// Volver a conectarse o que otra pantalla se vaya no cambia el tamaño.
|
|
92
96
|
this.holder = null
|
|
93
97
|
this.exited = false
|
|
94
98
|
this.screen = new Terminal({ cols, rows, scrollback: SCROLLBACK, allowProposedApi: true })
|
|
@@ -140,7 +144,15 @@ class Console {
|
|
|
140
144
|
this._meta()
|
|
141
145
|
}
|
|
142
146
|
|
|
143
|
-
/**
|
|
147
|
+
/** Cambia la nota. Lo ve al momento quien mira la consola; los demás, en la lista. */
|
|
148
|
+
setNote (text) {
|
|
149
|
+
const note = String(text ?? '').slice(0, NOTE_MAX)
|
|
150
|
+
if (note === this.note) return
|
|
151
|
+
this.note = note
|
|
152
|
+
this._meta()
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
/** Avisa a todos los que miran de que cambió quién mira, el título o la nota. */
|
|
144
156
|
_meta () {
|
|
145
157
|
const info = this.info()
|
|
146
158
|
for (const v of this.viewers) v.onMeta?.(info)
|
|
@@ -222,56 +234,24 @@ class Console {
|
|
|
222
234
|
|
|
223
235
|
detach (viewer) {
|
|
224
236
|
if (!this.viewers.has(viewer)) return
|
|
225
|
-
// Quién decidía, ANTES de quitarlo: si era él, hay que pasar el tamaño a otro.
|
|
226
|
-
const before = this.decider()
|
|
227
237
|
this.viewers.delete(viewer)
|
|
228
|
-
//
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
const d = this.decider()
|
|
232
|
-
if (d !== before && d?.size) this.resize(d.size.cols, d.size.rows)
|
|
238
|
+
// Irse no cambia el tamaño ni se lo pasa a otra pantalla: se queda como está hasta que
|
|
239
|
+
// alguien abra la consola, se cambie a ella, pulse ⤢ o teclee.
|
|
240
|
+
if (this.holder === viewer) this.holder = null
|
|
233
241
|
this._meta()
|
|
234
242
|
}
|
|
235
243
|
|
|
236
|
-
/**
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
/** La pantalla que eligió el tamaño, si está mirando ahora. */
|
|
240
|
-
pinnedViewer () {
|
|
241
|
-
if (!this.pinKey) return null
|
|
242
|
-
return [...this.viewers].filter((v) => viewerKey(v) === this.pinKey).pop() || null
|
|
243
|
-
}
|
|
244
|
-
|
|
245
|
-
/**
|
|
246
|
-
* `viewer` dice su tamaño (al engancharse, `attaching`, o porque cambió su pantalla). Se aplica
|
|
247
|
-
* solo si es quien decide; engancharse lo hace decidir si nadie lo tiene fijado.
|
|
248
|
-
*/
|
|
249
|
-
sizeFrom (viewer, { attaching = false } = {}) {
|
|
250
|
-
if (attaching) this.holder = viewer
|
|
251
|
-
if (this.decider() === viewer && viewer.size) this.resize(viewer.size.cols, viewer.size.rows)
|
|
252
|
-
else this._meta()
|
|
253
|
-
}
|
|
254
|
-
|
|
255
|
-
/**
|
|
256
|
-
* `viewer` tecleó: pasa a decidir el tamaño, también sobre una pantalla que lo tenía fijado
|
|
257
|
-
* (deja de estarlo). Es la única forma de ganarlo que tiene quien no puede fijarlo, como la
|
|
258
|
-
* terminal embebida de un editor.
|
|
259
|
-
*/
|
|
260
|
-
typed (viewer) {
|
|
261
|
-
if (!this.viewers.has(viewer) || this.decider() === viewer) return
|
|
244
|
+
/** `viewer` toma el tamaño AHORA: abrió la consola, se cambió a ella, pulsó ⤢ o tecleó. */
|
|
245
|
+
take (viewer) {
|
|
246
|
+
if (!this.viewers.has(viewer)) return
|
|
262
247
|
this.holder = viewer
|
|
263
|
-
if (this.pinKey !== viewerKey(viewer)) this.pinKey = null
|
|
264
248
|
if (viewer.size) this.resize(viewer.size.cols, viewer.size.rows)
|
|
265
249
|
else this._meta()
|
|
266
250
|
}
|
|
267
251
|
|
|
268
|
-
/**
|
|
269
|
-
|
|
270
|
-
if (
|
|
271
|
-
else if (this.pinKey === viewerKey(viewer)) this.pinKey = null
|
|
272
|
-
const d = this.decider()
|
|
273
|
-
if (d?.size) this.resize(d.size.cols, d.size.rows)
|
|
274
|
-
this._meta()
|
|
252
|
+
/** Cambió la pantalla de `viewer` (ventana, giro). Solo se sigue a quien puso el tamaño. */
|
|
253
|
+
sizeFrom (viewer) {
|
|
254
|
+
if (this.holder === viewer && viewer.size) this.resize(viewer.size.cols, viewer.size.rows)
|
|
275
255
|
}
|
|
276
256
|
|
|
277
257
|
/**
|
|
@@ -281,9 +261,9 @@ class Console {
|
|
|
281
261
|
*/
|
|
282
262
|
info () {
|
|
283
263
|
const watchers = [...this.viewers].filter((v) => v.origin).map((v) => ({ origin: v.origin, device: v.device || null, tag: v.tag || null }))
|
|
284
|
-
const d = this.
|
|
285
|
-
const sizeBy = d ? { origin: d.origin || null, device: d.device || null, tag: d.tag || null
|
|
286
|
-
return { id: this.id, n: this.n, activity: this.busy ? 'busy' : 'idle', doneAt: this.doneAt, sizeBy, origin: this.origin, title: this.title, host: HOST, cwd: cwdOf(this.pty?.pid), cols: this.cols, rows: this.rows, createdAt: this.createdAt, lastActive: this.lastActive, viewers: this.viewers.size, watchers }
|
|
264
|
+
const d = this.holder
|
|
265
|
+
const sizeBy = d ? { origin: d.origin || null, device: d.device || null, tag: d.tag || null } : null
|
|
266
|
+
return { id: this.id, n: this.n, activity: this.busy ? 'busy' : 'idle', doneAt: this.doneAt, sizeBy, origin: this.origin, title: this.title, note: this.note, host: HOST, cwd: cwdOf(this.pty?.pid), cols: this.cols, rows: this.rows, createdAt: this.createdAt, lastActive: this.lastActive, viewers: this.viewers.size, watchers }
|
|
287
267
|
}
|
|
288
268
|
}
|
|
289
269
|
|
|
@@ -305,13 +285,13 @@ const REPORTS = new RegExp([
|
|
|
305
285
|
/** ¿Hay algo TECLEADO en `data`, o es solo lo que la terminal contesta por su cuenta? */
|
|
306
286
|
export function isTyped (data) { return String(data).replace(REPORTS, '') !== '' }
|
|
307
287
|
|
|
308
|
-
function viewerKey (v) { return `${v.origin || ''}|${v.device || ''}|${v.tag || ''}` }
|
|
309
288
|
|
|
310
289
|
/** Las consolas de este agente. */
|
|
311
290
|
export class ConsoleHub {
|
|
312
291
|
/**
|
|
313
|
-
* @param {{ spawn:(opts:{cols:number,rows:number,cwd:string|null})=>any }} opts
|
|
314
|
-
* `spawn` lanza la shell (un PTY con `onData`, `onExit`, `write`, `resize`, `kill`).
|
|
292
|
+
* @param {{ spawn:(opts:{cols:number,rows:number,cwd:string|null,id:string})=>any }} opts
|
|
293
|
+
* `spawn` lanza la shell (un PTY con `onData`, `onExit`, `write`, `resize`, `kill`). `id` es el de
|
|
294
|
+
* la consola: va en el entorno de la shell para que lo que corre dentro sepa cuál es la suya.
|
|
315
295
|
*/
|
|
316
296
|
constructor ({ spawn, quietMs = QUIET_MS }) {
|
|
317
297
|
this._spawn = spawn
|
|
@@ -329,7 +309,7 @@ export class ConsoleHub {
|
|
|
329
309
|
const used = new Set([...this.consoles.values()].map((c) => c.n))
|
|
330
310
|
let n = 1
|
|
331
311
|
while (used.has(n)) n++
|
|
332
|
-
const pty = this._spawn({ cols, rows, cwd })
|
|
312
|
+
const pty = this._spawn({ cols, rows, cwd, id })
|
|
333
313
|
const c = new Console({ id, n, pty, cols, rows, origin, quietMs: this._quietMs })
|
|
334
314
|
pty.onData((d) => c._out(d))
|
|
335
315
|
pty.onExit(({ exitCode }) => {
|
package/index.js
CHANGED
|
@@ -11,15 +11,17 @@
|
|
|
11
11
|
*
|
|
12
12
|
* Payloads de dominio (van cifrados dentro de la sesión, el proxio no los ve):
|
|
13
13
|
* cliente → agente: { type:'list' } · { type:'open', cols, rows, cwd?, tag? } ·
|
|
14
|
-
* { type:'attach', id, cols, rows } · { type:'detach' } ·
|
|
15
|
-
* { type:'input', data } · { type:'resize', cols, rows } · { type:'
|
|
14
|
+
* { type:'attach', id, cols, rows, keep? } · { type:'detach' } ·
|
|
15
|
+
* { type:'input', data } · { type:'resize', cols, rows } · { type:'take' } ·
|
|
16
16
|
* { type:'close' } (mata la consola enganchada) · { type:'kill', id } ·
|
|
17
17
|
* { type:'move', id, before? } (el orden del panel; contesta con `consoles`) ·
|
|
18
|
+
* { type:'note', id?, text? } (la nota de una consola: sin `id`, la enganchada;
|
|
19
|
+
* sin `text`, solo la lee; contesta con `noted`) ·
|
|
18
20
|
* { type:'unlock', code } (la clave de la máquina, si tiene: access.js)
|
|
19
21
|
* agente → cliente: { type:'consoles', list } · { type:'attached', id, fresh } ·
|
|
20
22
|
* { type:'replay', id, data, last } · { type:'out', data } ·
|
|
21
23
|
* { type:'exit', code, closedBy? } · { type:'fail', code, message, retryMs? } ·
|
|
22
|
-
* { type:'unlocked' }
|
|
24
|
+
* { type:'unlocked' } · { type:'noted', console }
|
|
23
25
|
*
|
|
24
26
|
* Con clave puesta, una sesión remota que no la ha escrito recibe `fail` con `code:'locked'`
|
|
25
27
|
* a todo lo que pida; tras `unlock` vale para esa conexión. `bad-code` y `wait` traen
|
|
@@ -64,12 +66,13 @@ export function makeHub (pty, opts = {}) {
|
|
|
64
66
|
const shell = opts.shell || process.env.SHELL || (process.platform === 'win32' ? 'powershell.exe' : 'bash')
|
|
65
67
|
return new ConsoleHub({
|
|
66
68
|
...(opts.quietMs ? { quietMs: opts.quietMs } : {}),
|
|
67
|
-
spawn: ({ cols, rows, cwd }) => pty.spawn(shell, [], {
|
|
69
|
+
spawn: ({ cols, rows, cwd, id }) => pty.spawn(shell, [], {
|
|
68
70
|
name: 'xterm-256color', cols, rows,
|
|
69
71
|
cwd: cwd || os.homedir(),
|
|
70
72
|
// La carpeta del perfil viaja a la shell: `dotrino-terminal rename` sabe así si corre
|
|
71
73
|
// dentro del mismo perfil que renombra (y que parar su agente cerraría su consola).
|
|
72
|
-
|
|
74
|
+
// El id de la consola también: `dotrino-terminal note` sabe así cuál es la suya.
|
|
75
|
+
env: { ...process.env, TERM: 'xterm-256color', DOTRINO_TERMINAL_CONSOLE: id, ...(opts.dir ? { DOTRINO_TERMINAL_PROFILE_DIR: opts.dir } : {}) }
|
|
73
76
|
})
|
|
74
77
|
})
|
|
75
78
|
}
|
|
@@ -120,7 +123,7 @@ export function serveSession (session, hub, { origin = 'remote', gate = null } =
|
|
|
120
123
|
// La etiqueta con la que se presenta quien mira (una ventana de la app de escritorio).
|
|
121
124
|
const takeTag = (msg) => { if (typeof msg.tag === 'string') viewer.tag = msg.tag.slice(0, 64) }
|
|
122
125
|
|
|
123
|
-
async function attachTo (c, { fresh }) {
|
|
126
|
+
async function attachTo (c, { fresh, keep = false }) {
|
|
124
127
|
release()
|
|
125
128
|
current = c
|
|
126
129
|
// SI EL CANAL DIRECTO AÚN NO ABRIÓ, PRIMERO SOLO LA PANTALLA. La foto con su historial
|
|
@@ -133,7 +136,8 @@ export function serveSession (session, hub, { origin = 'remote', gate = null } =
|
|
|
133
136
|
// suya. Quedarse enganchado dejaba un mirón FANTASMA (la consola salía «abierta en otro
|
|
134
137
|
// aparato» sin nadie mirando, y nadie la elegía como libre).
|
|
135
138
|
if (current !== c) { c.detach(viewer); return }
|
|
136
|
-
|
|
139
|
+
// Volver a engancharse tras una reconexión (`keep`) no es abrir ni cambiarse: no toca el tamaño.
|
|
140
|
+
if (!keep) c.take(viewer)
|
|
137
141
|
// La pantalla va en trozos: el proxio corta los mensajes a 1 MB.
|
|
138
142
|
for (let i = 0; i < snapshot.length || i === 0; i += REPLAY_CHUNK) {
|
|
139
143
|
await session.send({ type: 'replay', id: c.id, data: snapshot.slice(i, i + REPLAY_CHUNK), last: i + REPLAY_CHUNK >= snapshot.length })
|
|
@@ -185,23 +189,31 @@ export function serveSession (session, hub, { origin = 'remote', gate = null } =
|
|
|
185
189
|
if (!c) return fail('no-console', 'that console no longer exists')
|
|
186
190
|
takeSize(msg)
|
|
187
191
|
takeTag(msg)
|
|
188
|
-
attachTo(c, { fresh: false })
|
|
192
|
+
attachTo(c, { fresh: false, keep: msg.keep === true })
|
|
189
193
|
return
|
|
190
194
|
}
|
|
191
195
|
if (msg.type === 'detach') { release(); return }
|
|
192
196
|
if (msg.type === 'input') {
|
|
193
197
|
if (!current) return
|
|
194
198
|
const data = String(msg.data ?? '')
|
|
195
|
-
// Quien teclea
|
|
196
|
-
if (isTyped(data)) current.
|
|
199
|
+
// Quien teclea toma el tamaño. Lo que la terminal contesta sola no cuenta.
|
|
200
|
+
if (isTyped(data) && current.holder !== viewer) current.take(viewer)
|
|
197
201
|
current.write(data)
|
|
198
202
|
return
|
|
199
203
|
}
|
|
200
204
|
if (msg.type === 'resize') { takeSize(msg); current?.sizeFrom(viewer); return }
|
|
201
|
-
// ⤢ «
|
|
202
|
-
if (msg.type === '
|
|
205
|
+
// ⤢ «Usar el tamaño de esta pantalla»: se ajusta ahora, sin dejar nada fijado.
|
|
206
|
+
if (msg.type === 'take') { current?.take(viewer); return }
|
|
203
207
|
if (msg.type === 'close') { if (current) hub.kill(current.id, viewer); return }
|
|
204
208
|
if (msg.type === 'kill') { if (!hub.kill(msg.id, viewer)) fail('no-console', 'that console no longer exists'); return }
|
|
209
|
+
// La nota de una consola (de qué va): la escribe cualquier pantalla, o lo que corre dentro.
|
|
210
|
+
if (msg.type === 'note') {
|
|
211
|
+
const c = msg.id == null ? current : hub.get(String(msg.id))
|
|
212
|
+
if (!c) return fail('no-console', 'that console no longer exists')
|
|
213
|
+
if (typeof msg.text === 'string') c.setNote(msg.text)
|
|
214
|
+
session.send({ type: 'noted', console: c.info() })
|
|
215
|
+
return
|
|
216
|
+
}
|
|
205
217
|
// El orden del panel: es de la máquina, así que lo ve igual cualquier pantalla.
|
|
206
218
|
if (msg.type === 'move') {
|
|
207
219
|
if (!hub.move(String(msg.id), msg.before == null ? null : String(msg.before))) return fail('no-console', 'that console no longer exists')
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@dotrino/terminal-agent",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.36.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": {
|
|
@@ -19,7 +19,8 @@
|
|
|
19
19
|
"local.js",
|
|
20
20
|
"title.js",
|
|
21
21
|
"update.js",
|
|
22
|
-
"bin"
|
|
22
|
+
"bin",
|
|
23
|
+
"skills"
|
|
23
24
|
],
|
|
24
25
|
"scripts": {
|
|
25
26
|
"start": "node bin/cli.js",
|
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
---
|
|
2
|
+
name: dotrino-terminal-note
|
|
3
|
+
description: Mantiene al día la tarjeta «de qué va» de la consola de Dotrino Terminal en la que corres (la ve el dueño flotando sobre la consola, en todas sus pantallas). Úsalo AL EMPEZAR cada tarea, cuando la tarea cambia de rumbo, y al terminar o quedar esperando al usuario, siempre que exista la variable de entorno DOTRINO_TERMINAL_CONSOLE. También cuando el usuario diga «nota de la consola», «el flotante», «la tarjeta», «de qué va este chat» o pida anotar algo en la consola. Orden: `dotrino-terminal note`.
|
|
4
|
+
---
|
|
5
|
+
|
|
6
|
+
# La nota de la consola (Dotrino Terminal)
|
|
7
|
+
|
|
8
|
+
Cada consola de Dotrino Terminal tiene una **nota**: texto libre que sale en una tarjeta flotante
|
|
9
|
+
sobre la consola y, su primera línea, en la lista de consolas. Existe para que el dueño, con varias
|
|
10
|
+
consolas abiertas, sepa **de qué va la tarea en curso de cada una** sin entrar a leerla. La escribes
|
|
11
|
+
tú y también la edita él a mano: es de los dos.
|
|
12
|
+
|
|
13
|
+
## Cuándo
|
|
14
|
+
|
|
15
|
+
1. Comprueba que corres dentro de una consola: `echo "$DOTRINO_TERMINAL_CONSOLE"`. Vacío = no hay
|
|
16
|
+
consola ni tarjeta: no hagas nada y no lo menciones.
|
|
17
|
+
2. **Al empezar una tarea**: escribe la nota.
|
|
18
|
+
3. **Cuando cambia** (otra tarea, otro rumbo, un bloqueo): reescríbela.
|
|
19
|
+
4. **Al terminar o al quedar esperando al usuario**: déjalo dicho en la primera línea.
|
|
20
|
+
|
|
21
|
+
Una orden por momento, sin anunciarlo ni comentarlo en la respuesta.
|
|
22
|
+
|
|
23
|
+
## Cómo
|
|
24
|
+
|
|
25
|
+
```bash
|
|
26
|
+
dotrino-terminal note # la enseña (léela ANTES de reemplazarla)
|
|
27
|
+
dotrino-terminal note "texto" # la reemplaza
|
|
28
|
+
dotrino-terminal note - <<'EOF_NOTE' # varias líneas, por la entrada estándar
|
|
29
|
+
Arreglando el login de facturero
|
|
30
|
+
Falta: probar con firma real
|
|
31
|
+
EOF_NOTE
|
|
32
|
+
dotrino-terminal note --add "línea" # le añade una línea al final
|
|
33
|
+
dotrino-terminal note --clear # la borra
|
|
34
|
+
dotrino-terminal note --json # { id, n, title, note }
|
|
35
|
+
```
|
|
36
|
+
|
|
37
|
+
No hace falta decir qué consola: es la tuya. `--id <id>` apunta a otra (`dotrino-terminal ls`).
|
|
38
|
+
|
|
39
|
+
## Qué escribir
|
|
40
|
+
|
|
41
|
+
- **Primera línea = la tarea, en una frase corta** (hasta ~60 caracteres): es lo único que se ve en
|
|
42
|
+
la lista. «Tarjeta de notas en dotrino-terminal», no «Trabajando en lo que pidió el usuario».
|
|
43
|
+
- Debajo, solo lo que ayuda a retomar: el estado (`Hecho:` / `Falta:` / `Espera: tu visto bueno`).
|
|
44
|
+
Tres o cuatro líneas; el máximo son 4000 caracteres.
|
|
45
|
+
- En el idioma del usuario. Sin secretos, llaves ni rutas con credenciales: la nota la ven todos
|
|
46
|
+
los aparatos de la cuenta.
|
|
47
|
+
- **Lo que escribió el dueño se respeta.** Lee la nota antes: si hay líneas que no son tuyas,
|
|
48
|
+
consérvalas (reescribe las tuyas y deja las suyas, o usa `--add`). No la borres al terminar: di
|
|
49
|
+
que terminó.
|
|
50
|
+
|
|
51
|
+
## Si falla
|
|
52
|
+
|
|
53
|
+
- `no console to act on` / «no sé de qué consola»: no corres dentro de Dotrino Terminal. Sigue sin nota.
|
|
54
|
+
- «el agente no contestó: es anterior a la 0.36.0»: el agente de esta máquina es viejo. Díselo al
|
|
55
|
+
usuario una vez (se arregla con `npm i -g @dotrino/terminal-agent@latest` y reiniciándolo él:
|
|
56
|
+
reiniciar el agente cierra sus consolas, **incluida esta**) y no lo reintentes en esa sesión.
|
|
57
|
+
- **Nunca reinicies ni actualices el agente tú**: corres dentro de él.
|