@dotrino/terminal-agent 0.55.0 → 0.56.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/access.js +3 -136
- package/bin/terminal.js +9 -55
- package/index.js +9 -21
- package/package.json +3 -3
package/access.js
CHANGED
|
@@ -1,138 +1,5 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* access.js — la CLAVE de esta máquina
|
|
3
|
-
*
|
|
4
|
-
* Sin clave puesta no cambia nada: abre una consola cualquier aparato de la cuenta con `sign`,
|
|
5
|
-
* como siempre. Con clave, además de ser de la cuenta hay que escribirla en cada conexión
|
|
6
|
-
* remota. Las ventanas de ESTA máquina (el socket local) no la piden: son del mismo usuario
|
|
7
|
-
* que ya puede leer este archivo.
|
|
8
|
-
*
|
|
9
|
-
* En el disco queda la sal y el resumen (scrypt), nunca la clave. La clave viaja dentro de la
|
|
10
|
-
* sesión cifrada entre el aparato y el agente, así que el proxio no la ve.
|
|
11
|
-
*
|
|
12
|
-
* Los fallos se frenan POR AGENTE y no por sesión: quien prueba claves puede abrir otra
|
|
13
|
-
* conexión, y eso no le da intentos nuevos. A los TRES seguidos (dueño, 2026-10-07) empieza
|
|
14
|
-
* la espera, que se dobla con cada fallo más: es un bloqueo LOCAL de este servicio, nada más.
|
|
15
|
-
*
|
|
16
|
-
* Y a los tres fallos seguidos de UN MISMO aparato se avisa (`onIncident`): la bóveda se lo
|
|
17
|
-
* pone en la mesa a quien aprueba, que bloquea o ignora desde el teléfono. Avisar no decide
|
|
18
|
-
* nada aquí; el freno de arriba sigue igual.
|
|
2
|
+
* access.js — la CLAVE de esta máquina. La pieza es común (`@dotrino/remote-agent/access`, la
|
|
3
|
+
* usa también el escritorio remoto); se reexporta aquí para quien la importa por esta ruta.
|
|
19
4
|
*/
|
|
20
|
-
|
|
21
|
-
import fs from 'node:fs'
|
|
22
|
-
import path from 'node:path'
|
|
23
|
-
|
|
24
|
-
export const ACCESS_FILE = 'access.json'
|
|
25
|
-
export const MIN_LENGTH = 4
|
|
26
|
-
/** Fallos seguidos que se dejan pasar sin esperar: al tercero empieza la espera. */
|
|
27
|
-
export const FREE_TRIES = 3
|
|
28
|
-
/** Fallos seguidos de un mismo aparato que disparan el aviso a la bóveda. */
|
|
29
|
-
export const INCIDENT_AFTER = 3
|
|
30
|
-
const BASE_WAIT_MS = 30_000
|
|
31
|
-
const MAX_WAIT_MS = 60 * 60_000
|
|
32
|
-
const SCRYPT = { N: 1 << 15, r: 8, p: 1, maxmem: 64 * 1024 * 1024 }
|
|
33
|
-
|
|
34
|
-
/** @type {(code: string, message: string, extra?: object) => Error & { code: string }} */
|
|
35
|
-
const fail = (code, message, extra = {}) => Object.assign(new Error(message), { code, ...extra })
|
|
36
|
-
/** @param {string} dir */
|
|
37
|
-
const file = (dir) => path.join(dir, ACCESS_FILE)
|
|
38
|
-
/** @type {(secret: unknown, salt: Buffer, params: import('node:crypto').ScryptOptions) => Buffer} */
|
|
39
|
-
const digest = (secret, salt, params) => crypto.scryptSync(String(secret).normalize('NFKC'), salt, 32, params)
|
|
40
|
-
|
|
41
|
-
/** Si esta máquina tiene clave. Un archivo que existe y no se puede leer NO es «sin clave»: se lanza. */
|
|
42
|
-
/** @param {string} dir */
|
|
43
|
-
export function hasAccessCode (dir) {
|
|
44
|
-
return readRecord(dir) !== null
|
|
45
|
-
}
|
|
46
|
-
|
|
47
|
-
/**
|
|
48
|
-
* @param {string} dir
|
|
49
|
-
* @returns {{ v: 1, salt: string, hash: string, params: import('node:crypto').ScryptOptions } | null}
|
|
50
|
-
*/
|
|
51
|
-
function readRecord (dir) {
|
|
52
|
-
let raw
|
|
53
|
-
try { raw = fs.readFileSync(file(dir), 'utf8') } catch (e) {
|
|
54
|
-
if (/** @type {Thrown} */ (e).code === 'ENOENT') return null
|
|
55
|
-
throw fail('access-unreadable', `cannot read ${ACCESS_FILE}: ${/** @type {Thrown} */ (e).message}`)
|
|
56
|
-
}
|
|
57
|
-
let r
|
|
58
|
-
try { r = JSON.parse(raw) } catch (_) { throw fail('access-unreadable', `${ACCESS_FILE} is not valid JSON`) }
|
|
59
|
-
if (r?.v !== 1 || typeof r.salt !== 'string' || typeof r.hash !== 'string' || !r.params) {
|
|
60
|
-
throw fail('access-unreadable', `${ACCESS_FILE} has an unknown shape`)
|
|
61
|
-
}
|
|
62
|
-
return r
|
|
63
|
-
}
|
|
64
|
-
|
|
65
|
-
/**
|
|
66
|
-
* Pone o cambia la clave.
|
|
67
|
-
* @param {string} dir
|
|
68
|
-
* @param {unknown} secret
|
|
69
|
-
*/
|
|
70
|
-
export function setAccessCode (dir, secret) {
|
|
71
|
-
if (typeof secret !== 'string' || secret.length < MIN_LENGTH) throw fail('too-short', `the code needs at least ${MIN_LENGTH} characters`)
|
|
72
|
-
const salt = crypto.randomBytes(16)
|
|
73
|
-
const record = { v: 1, salt: salt.toString('base64'), hash: digest(secret, salt, SCRYPT).toString('base64'), params: SCRYPT }
|
|
74
|
-
const tmp = file(dir) + '.tmp'
|
|
75
|
-
fs.writeFileSync(tmp, JSON.stringify(record), { mode: 0o600 })
|
|
76
|
-
fs.renameSync(tmp, file(dir))
|
|
77
|
-
}
|
|
78
|
-
|
|
79
|
-
/**
|
|
80
|
-
* Quita la clave.
|
|
81
|
-
* @param {string} dir
|
|
82
|
-
*/
|
|
83
|
-
export function clearAccessCode (dir) {
|
|
84
|
-
fs.rmSync(file(dir), { force: true })
|
|
85
|
-
}
|
|
86
|
-
|
|
87
|
-
/**
|
|
88
|
-
* Si `secret` es la clave de esta máquina. Sin frenos: para la orden local que la cambia.
|
|
89
|
-
* @param {string} dir
|
|
90
|
-
* @param {unknown} secret
|
|
91
|
-
*/
|
|
92
|
-
export function checkAccessCode (dir, secret) {
|
|
93
|
-
const r = readRecord(dir)
|
|
94
|
-
if (!r) throw fail('no-access-code', 'this machine has no code')
|
|
95
|
-
const want = Buffer.from(r.hash, 'base64')
|
|
96
|
-
const got = digest(secret ?? '', Buffer.from(r.salt, 'base64'), r.params)
|
|
97
|
-
return want.length === got.length && crypto.timingSafeEqual(want, got)
|
|
98
|
-
}
|
|
99
|
-
|
|
100
|
-
/**
|
|
101
|
-
* La puerta de un agente: comprueba la clave y frena los fallos seguidos. Una por agente,
|
|
102
|
-
* compartida por todas sus sesiones.
|
|
103
|
-
* @param {string} dir
|
|
104
|
-
* @param {{ now?: () => number, onIncident?: ((i: { device: string, tries: number }) => void) | null }} [opts]
|
|
105
|
-
* `onIncident`: un mismo aparato (`device`, su pubkey) falló `INCIDENT_AFTER` veces seguidas.
|
|
106
|
-
* Se llama UNA vez por racha; la racha se corta al acertar.
|
|
107
|
-
*/
|
|
108
|
-
export function makeGate (dir, { now = Date.now, onIncident = null } = {}) {
|
|
109
|
-
let fails = 0
|
|
110
|
-
let until = 0
|
|
111
|
-
/** Fallos seguidos por aparato: el aviso es sobre QUIÉN, y el freno sobre el agente. */
|
|
112
|
-
const byDevice = new Map()
|
|
113
|
-
return {
|
|
114
|
-
/** Si hay que escribir la clave para entrar. Lanza `access-unreadable` si no se puede saber. */
|
|
115
|
-
required: () => hasAccessCode(dir),
|
|
116
|
-
/**
|
|
117
|
-
* Lanza `wait` (con `retryMs`) o `bad-code`; si no lanza, la clave era la buena.
|
|
118
|
-
* `device` es quién la escribió (pubkey), para contar sus fallos y avisar.
|
|
119
|
-
*/
|
|
120
|
-
/**
|
|
121
|
-
* @param {unknown} secret
|
|
122
|
-
* @param {string | null} [device]
|
|
123
|
-
*/
|
|
124
|
-
check (secret, device = null) {
|
|
125
|
-
const left = until - now()
|
|
126
|
-
if (left > 0) throw fail('wait', 'too many wrong codes', { retryMs: left })
|
|
127
|
-
if (checkAccessCode(dir, secret)) { fails = 0; until = 0; if (device) byDevice.delete(device); return }
|
|
128
|
-
fails++
|
|
129
|
-
if (fails >= FREE_TRIES) until = now() + Math.min(BASE_WAIT_MS * 2 ** (fails - FREE_TRIES), MAX_WAIT_MS)
|
|
130
|
-
if (device) {
|
|
131
|
-
const n = (byDevice.get(device) || 0) + 1
|
|
132
|
-
byDevice.set(device, n)
|
|
133
|
-
if (n === INCIDENT_AFTER && onIncident) { try { onIncident({ device, tries: n }) } catch (_) {} }
|
|
134
|
-
}
|
|
135
|
-
throw fail('bad-code', 'wrong code', until ? { retryMs: until - now() } : {})
|
|
136
|
-
}
|
|
137
|
-
}
|
|
138
|
-
}
|
|
5
|
+
export * from '@dotrino/remote-agent/access'
|
package/bin/terminal.js
CHANGED
|
@@ -52,7 +52,7 @@ import { connectLocal } from '../local.js'
|
|
|
52
52
|
import { titleFilter } from '../title.js'
|
|
53
53
|
import { clipboardImage, uploadImage, typedPath } from '../clipboard.js'
|
|
54
54
|
import { farMessage as farMessageFor } from '../far-messages.js'
|
|
55
|
-
import {
|
|
55
|
+
import { lockCommand, askHidden as askHiddenOrFail } from '../access.js'
|
|
56
56
|
import { configureEditors, terminalProfile } from '../editors.js'
|
|
57
57
|
|
|
58
58
|
/** @type {{ version: string }} */
|
|
@@ -630,37 +630,6 @@ function ask (q) {
|
|
|
630
630
|
return new Promise((resolve) => rl.question(q, (a) => { rl.close(); resolve(a.trim()) }))
|
|
631
631
|
}
|
|
632
632
|
|
|
633
|
-
/**
|
|
634
|
-
* Pregunta algo que no debe verse al teclearlo. Solo en una TTY: una clave no se pasa por una tubería.
|
|
635
|
-
* @param {string} q
|
|
636
|
-
* @returns {Promise<string>}
|
|
637
|
-
*/
|
|
638
|
-
function askHidden (q) {
|
|
639
|
-
if (!process.stdin.isTTY) die(t('la clave se teclea: hace falta una terminal', 'the code is typed: a terminal is needed'))
|
|
640
|
-
process.stdout.write(q)
|
|
641
|
-
process.stdin.setRawMode(true)
|
|
642
|
-
process.stdin.resume()
|
|
643
|
-
return new Promise((resolve) => {
|
|
644
|
-
let typed = ''
|
|
645
|
-
const onData = (/** @type {Buffer} */ b) => {
|
|
646
|
-
// Una tecla que no es texto (flechas, Fin, el teclado numérico SIN Bloq Num) llega como una
|
|
647
|
-
// secuencia de escape: se descarta entera. Antes solo se saltaba el ESC y el resto («[F»)
|
|
648
|
-
// entraba en la clave sin que se viera, así que la clave guardada no era la tecleada.
|
|
649
|
-
const typedText = b.toString('utf8').replace(/\x1b(?:\[[0-9;?]*[ -/]*[@-~]|O.|.)?/g, '')
|
|
650
|
-
for (const ch of typedText) {
|
|
651
|
-
if (ch === '\r' || ch === '\n') {
|
|
652
|
-
process.stdin.off('data', onData); process.stdin.setRawMode(false); process.stdin.pause()
|
|
653
|
-
process.stdout.write('\n'); resolve(typed); return
|
|
654
|
-
}
|
|
655
|
-
if (ch === '\x03') { process.stdin.setRawMode(false); process.stdout.write('\n'); process.exit(130) }
|
|
656
|
-
if (ch === '\x7f' || ch === '\b') typed = typed.slice(0, -1)
|
|
657
|
-
else if (ch >= ' ') typed += ch
|
|
658
|
-
}
|
|
659
|
-
}
|
|
660
|
-
process.stdin.on('data', onData)
|
|
661
|
-
})
|
|
662
|
-
}
|
|
663
|
-
|
|
664
633
|
/**
|
|
665
634
|
* La clave de esta máquina (access.js). Se pone AQUÍ, en la máquina, y la piden solo los otros
|
|
666
635
|
* aparatos: quien está sentado delante ya es el usuario que puede leer y borrar el archivo, así
|
|
@@ -668,28 +637,13 @@ function askHidden (q) {
|
|
|
668
637
|
*/
|
|
669
638
|
async function lock () {
|
|
670
639
|
const dir = opt('--dir') || dataDir(opt('--name'))
|
|
671
|
-
|
|
672
|
-
console.log(
|
|
673
|
-
|
|
674
|
-
:
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
if (!hasAccessCode(dir)) { console.log(t('Esta máquina no tenía clave.', 'This machine had no code.')); return }
|
|
679
|
-
clearAccessCode(dir)
|
|
680
|
-
console.log(t('Clave quitada. Cualquier aparato de tu cuenta vuelve a abrir consolas aquí.', 'Code removed. Any device of your account opens consoles here again.'))
|
|
681
|
-
return
|
|
682
|
-
}
|
|
683
|
-
fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
|
|
684
|
-
const changing = hasAccessCode(dir)
|
|
685
|
-
const first = await askHidden(t(`Clave nueva (PIN o contraseña, mínimo ${MIN_LENGTH}): `, `New code (PIN or password, at least ${MIN_LENGTH}): `))
|
|
686
|
-
if (first.length < MIN_LENGTH) die(t(`demasiado corta: mínimo ${MIN_LENGTH} caracteres`, `too short: at least ${MIN_LENGTH} characters`))
|
|
687
|
-
const again = await askHidden(t('Otra vez: ', 'Again: '))
|
|
688
|
-
if (again !== first) die(t('no coinciden. No se cambió nada.', 'they do not match. Nothing was changed.'))
|
|
689
|
-
setAccessCode(dir, first)
|
|
690
|
-
console.log(changing
|
|
691
|
-
? t('Clave cambiada. Los aparatos que ya estaban dentro siguen hasta que se desconecten.', 'Code changed. Devices already in stay until they disconnect.')
|
|
692
|
-
: t('Clave puesta. Tus otros aparatos la escriben para abrir consolas en esta máquina; las ventanas de esta máquina no la piden.', 'Code set. Your other devices type it to open consoles on this machine; this machine\'s own windows do not ask for it.'))
|
|
640
|
+
try {
|
|
641
|
+
console.log(await lockCommand({
|
|
642
|
+
dir, args, lang: /** @type {'es' | 'en'} */ (t('es', 'en')),
|
|
643
|
+
what: { es: 'abrir consolas', en: 'open consoles' },
|
|
644
|
+
localNote: { es: 'Las ventanas de esta máquina no la piden.', en: "This machine's own windows do not ask for it." }
|
|
645
|
+
}))
|
|
646
|
+
} catch (e) { die(/** @type {Thrown} */ (e).message) }
|
|
693
647
|
}
|
|
694
648
|
|
|
695
649
|
/**
|
|
@@ -835,7 +789,7 @@ async function goVia (conn, ref) {
|
|
|
835
789
|
// Lo tecleado aquí es la clave, no entrada para la consola.
|
|
836
790
|
process.stdin.off('data', earlyTap)
|
|
837
791
|
early.length = 0
|
|
838
|
-
const code = await
|
|
792
|
+
const code = await askHiddenOrFail(t(`Clave de ${name}: `, `Code for ${name}: `)).catch(() => die(t('la clave se teclea: hace falta una terminal', 'the code is typed: a terminal is needed')))
|
|
839
793
|
if (!code) die(t('sin clave no se entra.', 'no code, no entry.'))
|
|
840
794
|
probe = await farRequest(conn, { type: 'unlock', code }, 'unlocked')
|
|
841
795
|
if (probe.type === 'unlocked') break
|
package/index.js
CHANGED
|
@@ -46,7 +46,7 @@ import { listTransports, netReport } from '@dotrino/proxy-client'
|
|
|
46
46
|
import { shortId } from './far.js'
|
|
47
47
|
import { ConsoleHub, pieces, isTyped, cwdOf } from './consoles.js'
|
|
48
48
|
import { listenLocal } from './local.js'
|
|
49
|
-
import { makeGate } from './access.js'
|
|
49
|
+
import { makeGate, makeLock } from './access.js'
|
|
50
50
|
import { makeFar } from './far.js'
|
|
51
51
|
import { makeUploads } from './uploads.js'
|
|
52
52
|
import { readPiece } from './downloads.js'
|
|
@@ -151,17 +151,10 @@ export function serveSession (session, hub, { origin = 'remote', gate = null, up
|
|
|
151
151
|
const release = () => { if (current) { current.detach(viewer); current = null } }
|
|
152
152
|
/** @type {(code: string, message: string, extra?: object) => unknown} */
|
|
153
153
|
const fail = (code, message, extra = {}) => session.send({ type: 'fail', code, message, ...extra })
|
|
154
|
-
// La clave de la máquina: una vez escrita vale para ESTA
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
const mayPass = () =>
|
|
158
|
-
if (origin !== 'remote' || !gate || unlocked) return true
|
|
159
|
-
try {
|
|
160
|
-
if (!gate.required()) return true
|
|
161
|
-
} catch (e) { fail(/** @type {Thrown} */ (e).code || 'access-unreadable', /** @type {Thrown} */ (e).message); return false }
|
|
162
|
-
fail('locked', 'this machine asks for its code')
|
|
163
|
-
return false
|
|
164
|
-
}
|
|
154
|
+
// La clave de la máquina (`@dotrino/remote-agent/access`): una vez escrita vale para ESTA
|
|
155
|
+
// conexión. Solo la piden las sesiones remotas; no saber si hay clave = no pasa.
|
|
156
|
+
const lock = makeLock({ gate: origin === 'remote' ? gate : null, device: viewer.device, send: (m) => session.send(m) })
|
|
157
|
+
const mayPass = () => lock.mayPass()
|
|
165
158
|
/** @param {any} msg lo que llegó de la sesión */
|
|
166
159
|
const takeSize = (msg) => { if (msg.cols && msg.rows) { size = { cols: msg.cols, rows: msg.rows }; viewer.size = size } }
|
|
167
160
|
// La etiqueta con la que se presenta quien mira (una ventana de la app de escritorio).
|
|
@@ -223,15 +216,7 @@ export function serveSession (session, hub, { origin = 'remote', gate = null, up
|
|
|
223
216
|
|
|
224
217
|
session.on('message', (msg) => {
|
|
225
218
|
if (!msg || typeof msg !== 'object') return
|
|
226
|
-
if (msg
|
|
227
|
-
if (origin !== 'remote' || !gate) { session.send({ type: 'unlocked' }); return }
|
|
228
|
-
try {
|
|
229
|
-
if (gate.required()) gate.check(msg.code, viewer.device)
|
|
230
|
-
unlocked = true
|
|
231
|
-
session.send({ type: 'unlocked' })
|
|
232
|
-
} catch (e) { fail(/** @type {Thrown} */ (e).code || 'access-unreadable', /** @type {Thrown} */ (e).message, /** @type {Thrown} */ (e).retryMs ? { retryMs: /** @type {Thrown} */ (e).retryMs } : {}) }
|
|
233
|
-
return
|
|
234
|
-
}
|
|
219
|
+
if (lock.handle(msg)) return
|
|
235
220
|
if (!mayPass()) return
|
|
236
221
|
// Qué versión corre: tras actualizar el paquete, el agente en marcha sigue con la anterior.
|
|
237
222
|
if (msg.type === 'version') { session.send({ type: 'version', version: VERSION }); return }
|
|
@@ -399,6 +384,9 @@ export async function startAgent (opts = {}) {
|
|
|
399
384
|
let stopped = false
|
|
400
385
|
const startRemote = () => startRemoteAgent({
|
|
401
386
|
label: LABEL,
|
|
387
|
+
// Solo quien tenga `terminal` en el acta abre consolas (auditoría del 2026-11-16): con `sign`
|
|
388
|
+
// bastaba, y cualquier aparato de la cuenta —un bot, un navegador prestado— abría una shell.
|
|
389
|
+
needs: ['terminal'],
|
|
402
390
|
dir,
|
|
403
391
|
proxyUrl: opts.proxyUrl,
|
|
404
392
|
quiet: opts.quiet,
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@dotrino/terminal-agent",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.56.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": {
|
|
@@ -37,9 +37,9 @@
|
|
|
37
37
|
"type-check": "tsc --noEmit"
|
|
38
38
|
},
|
|
39
39
|
"dependencies": {
|
|
40
|
-
"@dotrino/identity": "0.
|
|
40
|
+
"@dotrino/identity": "0.139.0",
|
|
41
41
|
"@dotrino/proxy-client": "0.49.1",
|
|
42
|
-
"@dotrino/remote-agent": "0.
|
|
42
|
+
"@dotrino/remote-agent": "0.39.2",
|
|
43
43
|
"@dotrino/update": "0.9.4",
|
|
44
44
|
"@dotrino/vault": "0.121.2",
|
|
45
45
|
"@xterm/addon-serialize": "0.13.0",
|