@dotrino/remote-agent 0.35.0 → 0.37.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 +22 -0
- package/package.json +19 -4
- package/src/service.js +442 -0
- package/src/update.js +103 -0
- package/types/src/service.d.ts +170 -0
- package/types/src/update.d.ts +59 -0
package/README.md
CHANGED
|
@@ -40,7 +40,9 @@ Provee lo común — y **solo** eso:
|
|
|
40
40
|
| `@dotrino/remote-agent/client` | navegador | `RemoteAgentClient` |
|
|
41
41
|
| `@dotrino/remote-agent/link` | Node | `enroll`, `enrollInteractive` (pregunta la invitación en la terminal, 0.35.0), `selfLink`, `isSelfLink`, `loadLink`, `saveLink`, `dataDir`, `parseQr`, `identityFromLink`, `clientLink`, `renewLink` |
|
|
42
42
|
| `@dotrino/remote-agent/discover` | navegador | `listAgentsByLabel`, `probeAgents` |
|
|
43
|
+
| `@dotrino/remote-agent/update` | Node | `startSelfUpdate`, `vaultHooks`: el agente se actualiza solo (CONVENCIONES §15) y se reinicia cuando está libre (0.36.0; necesita `@dotrino/update`) |
|
|
43
44
|
| `@dotrino/remote-agent/instances` | Node | `resolveInstance`, `listInstances`, `lockInstance`, `instancesRoot` |
|
|
45
|
+
| `@dotrino/remote-agent/service` | Node | `makeService`: el agente como servicio del usuario (systemd de usuario o inicio automático del escritorio en Linux, LaunchAgent en macOS, `HKCU\…\Run` + supervisor en Windows). Sin `sudo` (0.37.0) |
|
|
44
46
|
|
|
45
47
|
## Uso
|
|
46
48
|
|
|
@@ -149,6 +151,26 @@ Sin nombre: si no hay ninguno enlazado es `default`; si hay uno, ese; si hay var
|
|
|
149
151
|
para y dice cuáles hay (la misma regla que `dotrino-env`). La raíz común se cambia con
|
|
150
152
|
`DOTRINO_AGENT_HOME`.
|
|
151
153
|
|
|
154
|
+
### Como servicio del usuario (`/service`, 0.37.0)
|
|
155
|
+
|
|
156
|
+
```js
|
|
157
|
+
import { makeService } from '@dotrino/remote-agent/service'
|
|
158
|
+
const svc = makeService({
|
|
159
|
+
id: 'remote-desktop-agent', // dotrino-<id>-<perfil>.service / .desktop, com.dotrino.<id>.<perfil>
|
|
160
|
+
title: 'Dotrino Remote Desktop agent',
|
|
161
|
+
runPrefix: 'DotrinoRemoteDesktopAgent', // el valor de HKCU\…\Run
|
|
162
|
+
agentArgs: (name) => ['--name', name], // cómo se corre el agente sin TTY
|
|
163
|
+
linux: 'autostart' // o 'systemd' (por defecto)
|
|
164
|
+
})
|
|
165
|
+
svc.installService({ name, cli, dir }) // también uninstallService, serviceStatus, startService
|
|
166
|
+
// y en el CLI: `supervise --name <n>` → svc.superviseCommand({ name, dir, cli })
|
|
167
|
+
```
|
|
168
|
+
|
|
169
|
+
`linux: 'systemd'` arranca al encender (con *linger*), sin sesión gráfica: vale para un agente
|
|
170
|
+
que solo necesita una shell (Terminal). `linux: 'autostart'` arranca con la sesión gráfica, que
|
|
171
|
+
es lo que necesita un agente que mira el escritorio. Los dos casos con supervisor (Windows y
|
|
172
|
+
`autostart`) le ponen `DOTRINO_SUPERVISED=1` al agente, así que `/update` puede reiniciarlo.
|
|
173
|
+
|
|
152
174
|
### Un agente como CLIENTE de otro agente (Node)
|
|
153
175
|
|
|
154
176
|
Un agente Node también puede hablar con otro agente —un bot que guarda en el node de
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@dotrino/remote-agent",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.37.0",
|
|
4
4
|
"description": "Middleware compartido del ecosistema Dotrino para apps de agente remoto cifrado punto a punto (handshake E2E, emparejamiento SAS con vault, revocación, descubrimiento). Lo consumen dotrino-terminal (PTY) y dotrino-ia (chat con IA).",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"main": "./index.js",
|
|
@@ -37,6 +37,14 @@
|
|
|
37
37
|
"./instances": {
|
|
38
38
|
"types": "./types/src/instances.d.ts",
|
|
39
39
|
"import": "./src/instances.js"
|
|
40
|
+
},
|
|
41
|
+
"./update": {
|
|
42
|
+
"types": "./types/src/update.d.ts",
|
|
43
|
+
"import": "./src/update.js"
|
|
44
|
+
},
|
|
45
|
+
"./service": {
|
|
46
|
+
"types": "./types/src/service.d.ts",
|
|
47
|
+
"import": "./src/service.js"
|
|
40
48
|
}
|
|
41
49
|
},
|
|
42
50
|
"files": [
|
|
@@ -77,14 +85,21 @@
|
|
|
77
85
|
"peerDependencies": {
|
|
78
86
|
"@dotrino/identity": ">=0.136.0",
|
|
79
87
|
"@dotrino/proxy-client": ">=0.46.0",
|
|
80
|
-
"@dotrino/vault": ">=0.115.0"
|
|
88
|
+
"@dotrino/vault": ">=0.115.0",
|
|
89
|
+
"@dotrino/update": ">=0.9.4"
|
|
81
90
|
},
|
|
82
91
|
"devDependencies": {
|
|
83
92
|
"@dotrino/identity": "0.136.0",
|
|
84
93
|
"@dotrino/proxy-client": "0.49.0",
|
|
85
|
-
"@dotrino/vault": "0.
|
|
94
|
+
"@dotrino/vault": "0.121.2",
|
|
86
95
|
"@types/node": "22.20.1",
|
|
87
96
|
"@types/ws": "8.18.1",
|
|
88
|
-
"typescript": "5.9.3"
|
|
97
|
+
"typescript": "5.9.3",
|
|
98
|
+
"@dotrino/update": "0.9.4"
|
|
99
|
+
},
|
|
100
|
+
"peerDependenciesMeta": {
|
|
101
|
+
"@dotrino/update": {
|
|
102
|
+
"optional": true
|
|
103
|
+
}
|
|
89
104
|
}
|
|
90
105
|
}
|
package/src/service.js
ADDED
|
@@ -0,0 +1,442 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* service.js — un agente como SERVICIO del usuario: arranca solo con la máquina o con la sesión.
|
|
3
|
+
*
|
|
4
|
+
* Venía de `dotrino-terminal/agent/service.js` y ahora es común (CLAUDE.md: reusar es la norma):
|
|
5
|
+
* lo usan el agente de Terminal y el del escritorio remoto. Cada uno lo configura con
|
|
6
|
+
* `makeService({ id, title, runPrefix, agentArgs, linux })` y recibe las órdenes de siempre.
|
|
7
|
+
*
|
|
8
|
+
* · Linux, `linux: 'systemd'` — una unidad de systemd DEL USUARIO (`~/.config/systemd/user`),
|
|
9
|
+
* sin `sudo`. Con «linger» arranca al encender, antes de que nadie inicie sesión.
|
|
10
|
+
* · Linux, `linux: 'autostart'` — el inicio automático del escritorio
|
|
11
|
+
* (`~/.config/autostart/*.desktop`, XDG) lanza un SUPERVISOR que levanta el agente cada vez
|
|
12
|
+
* que sale. Para un agente que necesita la SESIÓN GRÁFICA (el escritorio remoto: `DISPLAY`,
|
|
13
|
+
* el bus de sesión, la accesibilidad): una unidad que arranca al encender no tiene nada de
|
|
14
|
+
* eso, y `graphical-session.target` no lo activan todos los escritorios (XFCE no siempre).
|
|
15
|
+
* · macOS — un LaunchAgent (`~/Library/LaunchAgents`): arranca al iniciar sesión.
|
|
16
|
+
* · Windows — una entrada en `HKCU\…\Run` que lanza el mismo supervisor sin ventana. No es el
|
|
17
|
+
* Programador de tareas ni un servicio de Windows: los dos piden derechos de administrador.
|
|
18
|
+
*
|
|
19
|
+
* Es de usuario a propósito (CONVENCIONES §15): así el agente se sigue actualizando solo, y con
|
|
20
|
+
* alguien que lo levante (`DOTRINO_SUPERVISED`) ya puede reiniciarse para estrenar la versión.
|
|
21
|
+
*
|
|
22
|
+
* Una unidad por PERFIL: cada perfil es un agente con su enlace.
|
|
23
|
+
*/
|
|
24
|
+
import fs from 'node:fs'
|
|
25
|
+
import os from 'node:os'
|
|
26
|
+
import path from 'node:path'
|
|
27
|
+
import { execFileSync, spawn as childSpawn } from 'node:child_process'
|
|
28
|
+
|
|
29
|
+
/** @typedef {Error & { code?: string, stderr?: string | Buffer }} Thrown */
|
|
30
|
+
|
|
31
|
+
/** @type {(code: string, message: string) => Error & { code: string }} */
|
|
32
|
+
const fail = (code, message) => Object.assign(new Error(message), { code })
|
|
33
|
+
|
|
34
|
+
/** Correr una orden del sistema (`execFileSync`, o su doble en las pruebas). */
|
|
35
|
+
/** @typedef {(cmd: string, args: string[], opts?: import('node:child_process').ExecFileSyncOptions) => unknown} RunFn */
|
|
36
|
+
/** Lanzar un proceso (`spawn`, o su doble en las pruebas). */
|
|
37
|
+
/** @typedef {typeof childSpawn} SpawnFn */
|
|
38
|
+
/** Lo que comparten las órdenes de servicio: el perfil, y Node y el CLI con que se lanza. */
|
|
39
|
+
/** @typedef {{ name: string, node: string, cli: string }} Launch */
|
|
40
|
+
/** @typedef {'systemd' | 'autostart' | 'launchd' | 'run-key'} ServiceKind */
|
|
41
|
+
|
|
42
|
+
/**
|
|
43
|
+
* Qué agente es.
|
|
44
|
+
* @typedef {object} Product
|
|
45
|
+
* @property {string} id `terminal-agent` → `dotrino-terminal-agent-<perfil>.service`, `com.dotrino.terminal-agent.<perfil>`
|
|
46
|
+
* @property {string} title para la descripción de la unidad: `Dotrino Terminal agent`
|
|
47
|
+
* @property {string} runPrefix el valor de `HKCU\…\Run`: `DotrinoTerminalAgent` → `DotrinoTerminalAgent-<perfil>`
|
|
48
|
+
* @property {(name: string) => string[]} agentArgs con qué argumentos se corre el agente sin TTY
|
|
49
|
+
* @property {'systemd' | 'autostart'} [linux] cómo se pone en Linux (por defecto, systemd)
|
|
50
|
+
*/
|
|
51
|
+
|
|
52
|
+
/** Windows: la clave de lo que arranca al iniciar sesión. */
|
|
53
|
+
export const RUN_KEY = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run'
|
|
54
|
+
/** Cuánto espera el supervisor antes de volver a levantar el agente (como `RestartSec`). */
|
|
55
|
+
export const RESTART_MS = 3000
|
|
56
|
+
/** @param {string} dir */
|
|
57
|
+
export const supervisorPidFile = (dir) => path.join(dir, 'supervisor.pid')
|
|
58
|
+
|
|
59
|
+
/** systemd parte `ExecStart` por espacios: lo que los lleve va entre comillas. */
|
|
60
|
+
/** @param {string} s */
|
|
61
|
+
const unitArg = (s) => (/[\s"'\\$%]/.test(s) ? `"${s.replace(/[\\"]/g, '\\$&').replace(/%/g, '%%').replace(/\$/g, '$$$$')}"` : s)
|
|
62
|
+
|
|
63
|
+
/**
|
|
64
|
+
* Un argumento de `Exec=` de un `.desktop` (especificación XDG): entre comillas dobles si lleva
|
|
65
|
+
* algo reservado, con `"`, `` ` ``, `$` y `\` escapados, y el `%` doblado (son los códigos de campo).
|
|
66
|
+
* La barra va cuádruple: primero se aplica el escape de las cadenas y después el de las comillas.
|
|
67
|
+
* @param {string} s
|
|
68
|
+
*/
|
|
69
|
+
export const desktopArg = (s) => {
|
|
70
|
+
const v = s.replace(/%/g, '%%')
|
|
71
|
+
if (!/[\s"'\\$`<>~|&;*?#()]/.test(v)) return v
|
|
72
|
+
return `"${v.replace(/\\/g, '\\\\\\\\').replace(/["`$]/g, '\\$&')}"`
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
/** @param {unknown} s */
|
|
76
|
+
const xml = (s) => String(s).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>')
|
|
77
|
+
|
|
78
|
+
/**
|
|
79
|
+
* @param {RunFn} run
|
|
80
|
+
* @param {string} cmd
|
|
81
|
+
* @param {string[]} args
|
|
82
|
+
* @returns {{ ok: true } | { ok: false, reason: string | undefined }}
|
|
83
|
+
*/
|
|
84
|
+
function quiet (run, cmd, args) {
|
|
85
|
+
try { run(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' }); return { ok: true } } catch (e) {
|
|
86
|
+
return { ok: false, reason: String(/** @type {Thrown} */ (e).stderr || /** @type {Thrown} */ (e).message).trim().split('\n').pop() }
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
/**
|
|
91
|
+
* @param {RunFn} run
|
|
92
|
+
* @param {string} cmd
|
|
93
|
+
* @param {string[]} args
|
|
94
|
+
*/
|
|
95
|
+
function must (run, cmd, args) {
|
|
96
|
+
const r = quiet(run, cmd, args)
|
|
97
|
+
if (!r.ok) throw fail('service-command-failed', `${cmd} ${args.join(' ')}: ${r.reason}`)
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
const LINGER_DIR = '/var/lib/systemd/linger'
|
|
101
|
+
/** ¿Ya arrancan los servicios de ese usuario al encender? systemd lo apunta con un archivo. */
|
|
102
|
+
/** @type {(user: string, root?: string) => boolean} */
|
|
103
|
+
const lingers = (user, root = LINGER_DIR) => fs.existsSync(path.join(root, user))
|
|
104
|
+
|
|
105
|
+
/** @type {(file: string) => number} */
|
|
106
|
+
const readPid = (file) => { try { return Number(fs.readFileSync(file, 'utf8')) || 0 } catch (e) { if (/** @type {Thrown} */ (e).code === 'ENOENT') return 0; throw e } }
|
|
107
|
+
/** @type {(pid: number) => boolean} */
|
|
108
|
+
const alive = (pid) => { try { process.kill(pid, 0); return true } catch (e) { return /** @type {Thrown} */ (e).code === 'EPERM' } }
|
|
109
|
+
|
|
110
|
+
/** PowerShell: una cadena entre comillas simples. */
|
|
111
|
+
/** @param {string} s */
|
|
112
|
+
const psQuote = (s) => `'${String(s).replace(/'/g, "''")}'`
|
|
113
|
+
|
|
114
|
+
/** ¿Hay sesión gráfica en este entorno? Sin ella, un agente de `autostart` no puede arrancar ahora. */
|
|
115
|
+
/** @param {NodeJS.ProcessEnv} env */
|
|
116
|
+
const graphical = (env) => !!(env.DISPLAY || env.WAYLAND_DISPLAY)
|
|
117
|
+
|
|
118
|
+
/**
|
|
119
|
+
* El supervisor: levanta el agente del perfil y lo vuelve a levantar cada vez que sale (también
|
|
120
|
+
* cuando se reinicia para estrenar una versión: §15, `DOTRINO_SUPERVISED`). Uno por perfil: si
|
|
121
|
+
* ya hay otro vivo, lanza `already-supervised`.
|
|
122
|
+
* @param {{ name: string, dir: string, node?: string, cli: string, args: string[], spawn?: SpawnFn }} o
|
|
123
|
+
*/
|
|
124
|
+
export function supervise ({ name, dir, node = process.execPath, cli, args, spawn = childSpawn }) {
|
|
125
|
+
fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
|
|
126
|
+
const pidFile = supervisorPidFile(dir)
|
|
127
|
+
const other = readPid(pidFile)
|
|
128
|
+
if (other && other !== process.pid && alive(other)) throw fail('already-supervised', `profile ${name} already has a supervisor (pid ${other})`)
|
|
129
|
+
fs.writeFileSync(pidFile, String(process.pid))
|
|
130
|
+
let stopped = false
|
|
131
|
+
/** @type {import('node:child_process').ChildProcess | null} */
|
|
132
|
+
let child = null
|
|
133
|
+
const start = () => {
|
|
134
|
+
const fd = fs.openSync(path.join(dir, 'agent.log'), 'a', 0o600)
|
|
135
|
+
child = spawn(node, [cli, ...args], { windowsHide: true, stdio: ['ignore', fd, fd], env: { ...process.env, DOTRINO_SUPERVISED: '1' } })
|
|
136
|
+
fs.closeSync(fd)
|
|
137
|
+
child.on('exit', () => { child = null; if (!stopped) setTimeout(start, RESTART_MS) })
|
|
138
|
+
}
|
|
139
|
+
start()
|
|
140
|
+
return {
|
|
141
|
+
stop: () => {
|
|
142
|
+
stopped = true
|
|
143
|
+
try { child?.kill() } catch (_) {}
|
|
144
|
+
try { if (readPid(pidFile) === process.pid) fs.rmSync(pidFile) } catch (_) {}
|
|
145
|
+
}
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
/**
|
|
150
|
+
* Para el supervisor y después el agente. En Windows matar el supervisor no se lleva al hijo
|
|
151
|
+
* (no hay señales: `agent.pid`, si el agente lo escribe); en Linux el supervisor para a su hijo
|
|
152
|
+
* al recibir SIGTERM.
|
|
153
|
+
* @param {string} dir
|
|
154
|
+
*/
|
|
155
|
+
function stopSupervised (dir) {
|
|
156
|
+
for (const file of [supervisorPidFile(dir), path.join(dir, 'agent.pid')]) {
|
|
157
|
+
const pid = readPid(file)
|
|
158
|
+
if (pid && alive(pid)) process.kill(pid)
|
|
159
|
+
}
|
|
160
|
+
fs.rmSync(supervisorPidFile(dir), { force: true })
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
/**
|
|
164
|
+
* Las órdenes de servicio de un agente.
|
|
165
|
+
* @param {Product} product
|
|
166
|
+
*/
|
|
167
|
+
export function makeService ({ id, title, runPrefix, agentArgs, linux = 'systemd' }) {
|
|
168
|
+
/** @param {string} name */
|
|
169
|
+
const unitName = (name) => `dotrino-${id}-${name}.service`
|
|
170
|
+
/** @param {string} name */
|
|
171
|
+
const plistLabel = (name) => `com.dotrino.${id}.${name}`
|
|
172
|
+
/** @param {string} name */
|
|
173
|
+
const runValue = (name) => `${runPrefix}-${name}`
|
|
174
|
+
/** @param {string} name @param {string} [home] */
|
|
175
|
+
const unitPath = (name, home = os.homedir()) => path.join(home, '.config', 'systemd', 'user', unitName(name))
|
|
176
|
+
/** @param {string} name @param {string} [home] */
|
|
177
|
+
const plistPath = (name, home = os.homedir()) => path.join(home, 'Library', 'LaunchAgents', `${plistLabel(name)}.plist`)
|
|
178
|
+
/** @param {string} name @param {string} [home] */
|
|
179
|
+
const autostartPath = (name, home = os.homedir()) => path.join(home, '.config', 'autostart', `dotrino-${id}-${name}.desktop`)
|
|
180
|
+
/** Lo que se apunta en la clave de Windows: Node, el CLI y el supervisor del perfil. */
|
|
181
|
+
/** @param {Launch} o */
|
|
182
|
+
const runCommand = ({ name, node, cli }) => `"${node}" "${cli}" supervise --name ${name}`
|
|
183
|
+
/** @param {string} name */
|
|
184
|
+
const runKeyFile = (name) => `${RUN_KEY}\\${runValue(name)}`
|
|
185
|
+
/** @type {(name: string, run: RunFn) => boolean} */
|
|
186
|
+
const hasRunKey = (name, run) => quiet(run, 'reg', ['query', RUN_KEY, '/v', runValue(name)]).ok
|
|
187
|
+
|
|
188
|
+
/**
|
|
189
|
+
* La unidad de systemd. El PATH es el de quien instala: el de un servicio de usuario es mínimo
|
|
190
|
+
* y no trae el Node de nvm ni las herramientas que el agente espera encontrar.
|
|
191
|
+
* @param {Launch & { pathEnv: string }} o
|
|
192
|
+
*/
|
|
193
|
+
function unitText ({ name, node, cli, pathEnv }) {
|
|
194
|
+
return `[Unit]
|
|
195
|
+
Description=${title} (${name})
|
|
196
|
+
After=network-online.target
|
|
197
|
+
Wants=network-online.target
|
|
198
|
+
|
|
199
|
+
[Service]
|
|
200
|
+
ExecStart=${[node, cli, ...agentArgs(name)].map(unitArg).join(' ')}
|
|
201
|
+
Environment=${unitArg(`PATH=${pathEnv}`)}
|
|
202
|
+
Restart=always
|
|
203
|
+
RestartSec=3
|
|
204
|
+
|
|
205
|
+
[Install]
|
|
206
|
+
WantedBy=default.target
|
|
207
|
+
`
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
/**
|
|
211
|
+
* La entrada del inicio automático del escritorio: lanza el supervisor del perfil. El entorno
|
|
212
|
+
* (PATH, DISPLAY, el bus de sesión) es el de la sesión, que es justo lo que hace falta.
|
|
213
|
+
* @param {Launch} o
|
|
214
|
+
*/
|
|
215
|
+
function autostartText ({ name, node, cli }) {
|
|
216
|
+
return `[Desktop Entry]
|
|
217
|
+
Type=Application
|
|
218
|
+
Name=${title} (${name})
|
|
219
|
+
Exec=${[node, cli, 'supervise', '--name', name].map(desktopArg).join(' ')}
|
|
220
|
+
Terminal=false
|
|
221
|
+
NoDisplay=true
|
|
222
|
+
X-GNOME-Autostart-enabled=true
|
|
223
|
+
`
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
/**
|
|
227
|
+
* El LaunchAgent de macOS. `DOTRINO_SUPERVISED`: launchd lo levanta si sale (§15).
|
|
228
|
+
* @param {Launch & { pathEnv: string, log: string }} o
|
|
229
|
+
*/
|
|
230
|
+
function plistText ({ name, node, cli, pathEnv, log }) {
|
|
231
|
+
const args = [node, cli, ...agentArgs(name)].map((a) => ` <string>${xml(a)}</string>`).join('\n')
|
|
232
|
+
return `<?xml version="1.0" encoding="UTF-8"?>
|
|
233
|
+
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
|
234
|
+
<plist version="1.0"><dict>
|
|
235
|
+
<key>Label</key><string>${xml(plistLabel(name))}</string>
|
|
236
|
+
<key>ProgramArguments</key>
|
|
237
|
+
<array>
|
|
238
|
+
${args}
|
|
239
|
+
</array>
|
|
240
|
+
<key>EnvironmentVariables</key>
|
|
241
|
+
<dict>
|
|
242
|
+
<key>PATH</key><string>${xml(pathEnv)}</string>
|
|
243
|
+
<key>DOTRINO_SUPERVISED</key><string>1</string>
|
|
244
|
+
</dict>
|
|
245
|
+
<key>RunAtLoad</key><true/>
|
|
246
|
+
<key>KeepAlive</key><true/>
|
|
247
|
+
<key>StandardOutPath</key><string>${xml(log)}</string>
|
|
248
|
+
<key>StandardErrorPath</key><string>${xml(log)}</string>
|
|
249
|
+
</dict></plist>
|
|
250
|
+
`
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
/**
|
|
254
|
+
* ¿Deja este sistema instalar el servicio? Lanza con el motivo si no.
|
|
255
|
+
* @param {{ platform: string, run: RunFn }} o
|
|
256
|
+
* @returns {ServiceKind}
|
|
257
|
+
*/
|
|
258
|
+
function platformOf ({ platform, run }) {
|
|
259
|
+
if (platform === 'darwin') return 'launchd'
|
|
260
|
+
if (platform === 'win32') return 'run-key'
|
|
261
|
+
if (platform !== 'linux') throw fail('unsupported-platform', `there is no service support for ${platform}`)
|
|
262
|
+
if (linux === 'autostart') return 'autostart'
|
|
263
|
+
// Sin systemd de usuario (un contenedor, WSL sin systemd, otra init) no hay dónde ponerlo.
|
|
264
|
+
if (!quiet(run, 'systemctl', ['--user', 'show-environment']).ok) throw fail('no-user-systemd', 'this session has no systemd user manager')
|
|
265
|
+
return 'systemd'
|
|
266
|
+
}
|
|
267
|
+
|
|
268
|
+
/**
|
|
269
|
+
* Lanza el supervisor del perfil, ya suelto (sin ventana en Windows, en su propia sesión en Linux).
|
|
270
|
+
*
|
|
271
|
+
* Windows desde SSH no vale un proceso aparte: sshd mete la sesión en un objeto de trabajo y al
|
|
272
|
+
* cerrarla mata todo lo que lanzó. Ahí lo crea WMI (`Win32_Process.Create`) con la misma línea
|
|
273
|
+
* que queda en `HKCU\…\Run`; una cuenta sin administrador no puede, y se devuelve el motivo.
|
|
274
|
+
*
|
|
275
|
+
* Linux (`autostart`) sin sesión gráfica en este entorno (por SSH): el agente no arrancaría.
|
|
276
|
+
* No se lanza nada y se dice; el inicio automático lo arranca al iniciar sesión.
|
|
277
|
+
*
|
|
278
|
+
* @param {Launch & { platform: string, spawn: SpawnFn, run: RunFn, env: NodeJS.ProcessEnv }} o
|
|
279
|
+
* @returns {{ ok: true } | { ok: false, reason: string }}
|
|
280
|
+
*/
|
|
281
|
+
function spawnSupervisor ({ name, node, cli, platform, spawn, run, env }) {
|
|
282
|
+
if (platform === 'win32' && (env.SSH_CONNECTION || env.SSH_CLIENT)) {
|
|
283
|
+
const script = `$r = Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{ CommandLine = ${psQuote(runCommand({ name, node, cli }))} }; if ($r.ReturnValue -ne 0) { throw "Win32_Process.Create returned $($r.ReturnValue)" }`
|
|
284
|
+
const r = quiet(run, 'powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script])
|
|
285
|
+
return r.ok ? { ok: true } : { ok: false, reason: 'Windows (WMI) does not let this account start it from SSH' }
|
|
286
|
+
}
|
|
287
|
+
if (platform === 'linux' && !graphical(env)) return { ok: false, reason: 'there is no graphical session here (DISPLAY / WAYLAND_DISPLAY)' }
|
|
288
|
+
const child = spawn(node, [cli, 'supervise', '--name', name], { detached: true, windowsHide: true, stdio: 'ignore', env: { ...env, DOTRINO_SUPERVISOR: '1' } })
|
|
289
|
+
child.unref()
|
|
290
|
+
return { ok: true }
|
|
291
|
+
}
|
|
292
|
+
|
|
293
|
+
/**
|
|
294
|
+
* La orden `supervise` del CLI del agente. La lanza el sistema (la entrada de `Run`, el inicio
|
|
295
|
+
* automático del escritorio): primero se vuelve a lanzar suelto y sale (en Windows se abre CON
|
|
296
|
+
* ventana), y ese segundo proceso es el supervisor. Para con SIGINT/SIGTERM y se lleva al agente.
|
|
297
|
+
* @param {{ name: string, dir: string, cli: string, node?: string, spawn?: SpawnFn, env?: NodeJS.ProcessEnv }} o
|
|
298
|
+
*/
|
|
299
|
+
function superviseCommand ({ name, dir, cli, node = process.execPath, spawn = childSpawn, env = process.env }) {
|
|
300
|
+
if (!env.DOTRINO_SUPERVISOR) {
|
|
301
|
+
spawn(node, [cli, 'supervise', '--name', name], { detached: true, windowsHide: true, stdio: 'ignore', env: { ...env, DOTRINO_SUPERVISOR: '1' } }).unref()
|
|
302
|
+
return { relaunched: true }
|
|
303
|
+
}
|
|
304
|
+
const s = supervise({ name, dir, node, cli, args: agentArgs(name), spawn })
|
|
305
|
+
const bye = () => { s.stop(); process.exit(0) }
|
|
306
|
+
process.on('SIGINT', bye); process.on('SIGTERM', bye)
|
|
307
|
+
return { relaunched: false, stop: s.stop }
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
/**
|
|
311
|
+
* Instala y enciende el servicio del perfil `name`.
|
|
312
|
+
*
|
|
313
|
+
* `running`: ya hay un agente de ese perfil corriendo por su cuenta. Dos agentes con el mismo
|
|
314
|
+
* enlace son la misma llave: el servicio queda puesto y toma el relevo cuando ese termine o al
|
|
315
|
+
* próximo arranque.
|
|
316
|
+
*
|
|
317
|
+
* @param {{ name: string, node?: string, cli: string, dir: string, running?: boolean, pathEnv?: string, platform?: string, home?: string,
|
|
318
|
+
* user?: string, uid?: number, run?: RunFn, spawn?: SpawnFn, env?: NodeJS.ProcessEnv }} o
|
|
319
|
+
* @returns {{ kind: ServiceKind, file: string, started: boolean, boot?: boolean, lingerReason?: string, startReason?: string }}
|
|
320
|
+
*/
|
|
321
|
+
function installService ({ name, node = process.execPath, cli, dir, running = false, pathEnv = process.env.PATH || '', platform = process.platform, home = os.homedir(), user = os.userInfo().username, uid = process.getuid?.(), run = execFileSync, spawn = childSpawn, env = process.env }) {
|
|
322
|
+
const kind = platformOf({ platform, run })
|
|
323
|
+
if (kind === 'run-key' || kind === 'autostart') {
|
|
324
|
+
let file
|
|
325
|
+
if (kind === 'run-key') {
|
|
326
|
+
must(run, 'reg', ['add', RUN_KEY, '/v', runValue(name), '/t', 'REG_SZ', '/d', runCommand({ name, node, cli }), '/f'])
|
|
327
|
+
file = runKeyFile(name)
|
|
328
|
+
} else {
|
|
329
|
+
file = autostartPath(name, home)
|
|
330
|
+
fs.mkdirSync(path.dirname(file), { recursive: true })
|
|
331
|
+
fs.writeFileSync(file, autostartText({ name, node, cli }), { mode: 0o644 })
|
|
332
|
+
}
|
|
333
|
+
if (running) return { kind, file, started: false }
|
|
334
|
+
const pid = readPid(supervisorPidFile(dir))
|
|
335
|
+
if (pid && alive(pid)) return { kind, file, started: true }
|
|
336
|
+
const s = spawnSupervisor({ name, node, cli, platform, spawn, run, env })
|
|
337
|
+
return { kind, file, started: s.ok, ...(s.ok ? {} : { startReason: s.reason }) }
|
|
338
|
+
}
|
|
339
|
+
if (kind === 'launchd') {
|
|
340
|
+
const file = plistPath(name, home)
|
|
341
|
+
fs.mkdirSync(path.dirname(file), { recursive: true })
|
|
342
|
+
fs.writeFileSync(file, plistText({ name, node, cli, pathEnv, log: path.join(dir, 'agent.log') }), { mode: 0o644 })
|
|
343
|
+
if (running) return { kind, file, started: false }
|
|
344
|
+
// Si ya estaba cargado (una instalación anterior), se recarga con el archivo nuevo.
|
|
345
|
+
quiet(run, 'launchctl', ['bootout', `gui/${uid}/${plistLabel(name)}`])
|
|
346
|
+
must(run, 'launchctl', ['bootstrap', `gui/${uid}`, file])
|
|
347
|
+
return { kind, file, started: true }
|
|
348
|
+
}
|
|
349
|
+
const file = unitPath(name, home)
|
|
350
|
+
fs.mkdirSync(path.dirname(file), { recursive: true })
|
|
351
|
+
fs.writeFileSync(file, unitText({ name, node, cli, pathEnv }), { mode: 0o644 })
|
|
352
|
+
must(run, 'systemctl', ['--user', 'daemon-reload'])
|
|
353
|
+
must(run, 'systemctl', ['--user', 'enable', unitName(name)])
|
|
354
|
+
if (!running) must(run, 'systemctl', ['--user', 'restart', unitName(name)])
|
|
355
|
+
// Arrancar al ENCENDER, sin que nadie inicie sesión. Si el sistema no lo deja sin
|
|
356
|
+
// administrador, el servicio arranca al iniciar sesión, y se dice.
|
|
357
|
+
if (lingers(user)) return { kind, file, started: !running, boot: true }
|
|
358
|
+
const linger = quiet(run, 'loginctl', ['enable-linger', user])
|
|
359
|
+
return { kind, file, started: !running, boot: linger.ok, ...(linger.ok ? {} : { lingerReason: linger.reason }) }
|
|
360
|
+
}
|
|
361
|
+
|
|
362
|
+
/**
|
|
363
|
+
* Arranca el servicio ya instalado de ese perfil. `false` si el perfil no tiene servicio (o no
|
|
364
|
+
* se puede dejar corriendo desde aquí): entonces quien llama levanta el agente él mismo.
|
|
365
|
+
* @param {{ name: string, dir: string, node?: string, cli: string, platform?: string, home?: string, uid?: number,
|
|
366
|
+
* run?: RunFn, spawn?: SpawnFn, env?: NodeJS.ProcessEnv }} o
|
|
367
|
+
* @returns {boolean}
|
|
368
|
+
*/
|
|
369
|
+
function startService ({ name, dir, node = process.execPath, cli, platform = process.platform, home = os.homedir(), uid = process.getuid?.(), run = execFileSync, spawn = childSpawn, env = process.env }) {
|
|
370
|
+
if (platform === 'win32' || (platform === 'linux' && linux === 'autostart')) {
|
|
371
|
+
if (platform === 'win32' ? !hasRunKey(name, run) : !fs.existsSync(autostartPath(name, home))) return false
|
|
372
|
+
const pid = readPid(supervisorPidFile(dir))
|
|
373
|
+
if (pid && alive(pid)) return true
|
|
374
|
+
return spawnSupervisor({ name, node, cli, platform, spawn, run, env }).ok
|
|
375
|
+
}
|
|
376
|
+
if (platform === 'darwin') {
|
|
377
|
+
const file = plistPath(name, home)
|
|
378
|
+
if (!fs.existsSync(file)) return false
|
|
379
|
+
// Cargado y parado no puede estar (KeepAlive): si no corre, es que no está cargado.
|
|
380
|
+
quiet(run, 'launchctl', ['bootout', `gui/${uid}/${plistLabel(name)}`])
|
|
381
|
+
must(run, 'launchctl', ['bootstrap', `gui/${uid}`, file])
|
|
382
|
+
return true
|
|
383
|
+
}
|
|
384
|
+
if (platform !== 'linux' || !fs.existsSync(unitPath(name, home))) return false
|
|
385
|
+
must(run, 'systemctl', ['--user', 'start', unitName(name)])
|
|
386
|
+
return true
|
|
387
|
+
}
|
|
388
|
+
|
|
389
|
+
/**
|
|
390
|
+
* Para el servicio y lo quita. El enlace y los ajustes del perfil no se tocan.
|
|
391
|
+
* @param {{ name: string, dir: string, platform?: string, home?: string, uid?: number, run?: RunFn }} o
|
|
392
|
+
* @returns {{ kind: ServiceKind, file: string, removed: boolean }}
|
|
393
|
+
*/
|
|
394
|
+
function uninstallService ({ name, dir, platform = process.platform, home = os.homedir(), uid = process.getuid?.(), run = execFileSync }) {
|
|
395
|
+
const kind = platformOf({ platform, run })
|
|
396
|
+
if (kind === 'run-key') {
|
|
397
|
+
if (!hasRunKey(name, run)) return { kind, file: runKeyFile(name), removed: false }
|
|
398
|
+
stopSupervised(dir)
|
|
399
|
+
must(run, 'reg', ['delete', RUN_KEY, '/v', runValue(name), '/f'])
|
|
400
|
+
return { kind, file: runKeyFile(name), removed: true }
|
|
401
|
+
}
|
|
402
|
+
if (kind === 'autostart') {
|
|
403
|
+
const file = autostartPath(name, home)
|
|
404
|
+
if (!fs.existsSync(file)) return { kind, file, removed: false }
|
|
405
|
+
stopSupervised(dir)
|
|
406
|
+
fs.rmSync(file)
|
|
407
|
+
return { kind, file, removed: true }
|
|
408
|
+
}
|
|
409
|
+
const file = kind === 'launchd' ? plistPath(name, home) : unitPath(name, home)
|
|
410
|
+
if (!fs.existsSync(file)) return { kind, file, removed: false }
|
|
411
|
+
if (kind === 'launchd') quiet(run, 'launchctl', ['bootout', `gui/${uid}/${plistLabel(name)}`])
|
|
412
|
+
else must(run, 'systemctl', ['--user', 'disable', '--now', unitName(name)])
|
|
413
|
+
fs.rmSync(file)
|
|
414
|
+
if (kind === 'systemd') must(run, 'systemctl', ['--user', 'daemon-reload'])
|
|
415
|
+
return { kind, file, removed: true }
|
|
416
|
+
}
|
|
417
|
+
|
|
418
|
+
/**
|
|
419
|
+
* ¿Está puesto, y está corriendo ahora bajo el sistema?
|
|
420
|
+
* @param {{ name: string, dir: string, platform?: string, home?: string, uid?: number, run?: RunFn }} o
|
|
421
|
+
* @returns {{ kind: ServiceKind, file: string, installed: boolean, active: boolean }}
|
|
422
|
+
*/
|
|
423
|
+
function serviceStatus ({ name, dir, platform = process.platform, home = os.homedir(), uid = process.getuid?.(), run = execFileSync }) {
|
|
424
|
+
const kind = platformOf({ platform, run })
|
|
425
|
+
if (kind === 'run-key' || kind === 'autostart') {
|
|
426
|
+
const installed = kind === 'run-key' ? hasRunKey(name, run) : fs.existsSync(autostartPath(name, home))
|
|
427
|
+
const pid = installed ? readPid(supervisorPidFile(dir)) : 0
|
|
428
|
+
return { kind, file: kind === 'run-key' ? runKeyFile(name) : autostartPath(name, home), installed, active: !!pid && alive(pid) }
|
|
429
|
+
}
|
|
430
|
+
const file = kind === 'launchd' ? plistPath(name, home) : unitPath(name, home)
|
|
431
|
+
const installed = fs.existsSync(file)
|
|
432
|
+
const active = installed && (kind === 'launchd'
|
|
433
|
+
? quiet(run, 'launchctl', ['print', `gui/${uid}/${plistLabel(name)}`]).ok
|
|
434
|
+
: quiet(run, 'systemctl', ['--user', 'is-active', '--quiet', unitName(name)]).ok)
|
|
435
|
+
return { kind, file, installed, active }
|
|
436
|
+
}
|
|
437
|
+
|
|
438
|
+
return {
|
|
439
|
+
installService, uninstallService, serviceStatus, startService, superviseCommand,
|
|
440
|
+
unitText, autostartText, plistText, unitName, unitPath, plistLabel, plistPath, autostartPath, runValue, runCommand
|
|
441
|
+
}
|
|
442
|
+
}
|
package/src/update.js
ADDED
|
@@ -0,0 +1,103 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* update.js — un agente SE ACTUALIZA SOLO (CONVENCIONES §15, dueño 2026-10-08).
|
|
3
|
+
*
|
|
4
|
+
* Lo común de todos los agentes que se instalan por npm (`terminal-agent`,
|
|
5
|
+
* `remote-desktop-agent`…): mirar, verificar e instalar lo hace `@dotrino/update/npm`; a quién
|
|
6
|
+
* se pregunta y a quién se avisa, `@dotrino/vault/service`. Aquí se juntan las dos piezas con
|
|
7
|
+
* lo que sí es común a los agentes: el enlace vive en una carpeta y se lee en cada llamada, y
|
|
8
|
+
* el agente solo se reinicia cuando no está atendiendo a nadie.
|
|
9
|
+
*
|
|
10
|
+
* Lo propio de cada agente se le pasa: su paquete, su repo, cómo se llaman sus releases y
|
|
11
|
+
* cuándo está ocupado (`busy`: la terminal cuenta consolas abiertas; el escritorio, gente
|
|
12
|
+
* mirando).
|
|
13
|
+
*/
|
|
14
|
+
import { watchSelfUpdateNpm } from '@dotrino/update/npm'
|
|
15
|
+
import { vaultUpdateHooks } from '@dotrino/vault/service'
|
|
16
|
+
import { loadLink } from './link.js'
|
|
17
|
+
|
|
18
|
+
/** Cada cuánto se mira si ya está libre para reiniciar con la versión instalada. */
|
|
19
|
+
export const IDLE_CHECK_MS = 60_000
|
|
20
|
+
|
|
21
|
+
/** @type {(code: string, message: string) => Error & { code: string }} */
|
|
22
|
+
const fail = (code, message) => Object.assign(new Error(message), { code })
|
|
23
|
+
|
|
24
|
+
/**
|
|
25
|
+
* Lo que un agente le dice a SU bóveda sobre actualizarse: los tres ganchos de
|
|
26
|
+
* `vaultUpdateHooks`, armados EN CADA LLAMADA con el enlace leído del disco. El papel se renueva
|
|
27
|
+
* mientras el agente corre, y el agente puede arrancar sin enlace y enlazarse después: una
|
|
28
|
+
* conexión fijada al arrancar se quedaría vieja.
|
|
29
|
+
*
|
|
30
|
+
* @param {{ dir: string, product: string, log?: (m: string) => void, load?: (dir: string) => any, make?: typeof vaultUpdateHooks }} o
|
|
31
|
+
* @returns {import('@dotrino/vault/service').UpdateHooks}
|
|
32
|
+
*/
|
|
33
|
+
export function vaultHooks ({ dir, product, log = console.log, load = loadLink, make = vaultUpdateHooks }) {
|
|
34
|
+
const now = () => {
|
|
35
|
+
const link = load(dir)
|
|
36
|
+
if (!link?.device || !link.cert || !link.iss) return null
|
|
37
|
+
return make({ product, log, proxyUrl: link.proxy || 'wss://proxy.dotrino.com', masterPubkey: link.iss, device: link.device, cert: link.cert })
|
|
38
|
+
}
|
|
39
|
+
return {
|
|
40
|
+
// true = sí · false = no, o pasó el día sin respuesta · lanza = no se pudo preguntar.
|
|
41
|
+
/** @param {import('@dotrino/vault/service').UpdateInfo} u */
|
|
42
|
+
async mayUpdate (u) {
|
|
43
|
+
const h = now()
|
|
44
|
+
// Sin enlace no hay a quién preguntar. No es un «no»: se dice y se reintenta.
|
|
45
|
+
if (!h) throw fail('not-linked', 'this agent is not linked to a vault, so there is nobody to ask')
|
|
46
|
+
return h.mayUpdate(u)
|
|
47
|
+
},
|
|
48
|
+
// Sin enlace no hay bóveda a la que contárselo: no es un fallo que reintentar.
|
|
49
|
+
/** @param {import('@dotrino/vault/service').UpdateInfo} u */
|
|
50
|
+
async onUpdated (u) { await now()?.onUpdated(u) },
|
|
51
|
+
/** @param {import('@dotrino/vault/service').UpdateInfo} u */
|
|
52
|
+
async onNeedsRoot (u) { await now()?.onNeedsRoot(u) }
|
|
53
|
+
}
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
/**
|
|
57
|
+
* Enciende la autoactualización de un agente que ya corre.
|
|
58
|
+
*
|
|
59
|
+
* La versión nueva se instala en cuanto sale, pero el agente solo se va cuando `busy()` da 0:
|
|
60
|
+
* tumbarle a alguien lo que está usando para estrenar una versión es justo lo contrario de lo
|
|
61
|
+
* que se quiere. Y sin quien lo levante (systemd, pm2) no se va nunca: irse sería apagarle el
|
|
62
|
+
* servicio al usuario.
|
|
63
|
+
*
|
|
64
|
+
* @param {{
|
|
65
|
+
* pkg: string, repo: string, tag: (version: string) => string, label: string,
|
|
66
|
+
* dir: string, version: string, busy: () => number, close: () => unknown,
|
|
67
|
+
* exit?: (code: number) => void, log?: (m: string) => void, watch?: typeof watchSelfUpdateNpm,
|
|
68
|
+
* hooks?: import('@dotrino/vault/service').UpdateHooks, idleCheckMs?: number
|
|
69
|
+
* }} o
|
|
70
|
+
* `label`: con qué se presenta en el log (`terminal-agent`). `busy`: cuánto está atendiendo
|
|
71
|
+
* ahora (consolas, gente mirando). `close`: cerrar lo suyo antes de salir.
|
|
72
|
+
* @returns {() => void} para dejar de mirar
|
|
73
|
+
*/
|
|
74
|
+
export function startSelfUpdate ({ pkg, repo, tag, label, dir, version, busy, close, exit = (code) => process.exit(code), log = console.log, watch = watchSelfUpdateNpm, hooks = vaultHooks({ dir, product: pkg, log }), idleCheckMs = IDLE_CHECK_MS }) {
|
|
75
|
+
/** @type {ReturnType<typeof setInterval> | null} */
|
|
76
|
+
let waiting = null
|
|
77
|
+
/** @param {string} v */
|
|
78
|
+
const restart = async (v) => {
|
|
79
|
+
log(`[${label}] restarting to run ${v}`)
|
|
80
|
+
try { await close() } catch (_) {}
|
|
81
|
+
exit(0)
|
|
82
|
+
}
|
|
83
|
+
const stop = watch({
|
|
84
|
+
pkg,
|
|
85
|
+
current: version,
|
|
86
|
+
repo,
|
|
87
|
+
tag,
|
|
88
|
+
dir,
|
|
89
|
+
...hooks,
|
|
90
|
+
onInstalled: ({ version: v, restart: supervised }) => {
|
|
91
|
+
if (!supervised) return
|
|
92
|
+
if (!busy()) { restart(v); return }
|
|
93
|
+
if (waiting) return
|
|
94
|
+
log(`[${label}] ${v} is installed · busy (${busy()}), so it restarts when it is free`)
|
|
95
|
+
const timer = waiting = setInterval(() => { if (!busy()) { clearInterval(timer); waiting = null; restart(v) } }, idleCheckMs)
|
|
96
|
+
timer.unref?.()
|
|
97
|
+
},
|
|
98
|
+
log
|
|
99
|
+
})
|
|
100
|
+
return () => { if (waiting) { clearInterval(waiting); waiting = null } stop?.() }
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
export default { startSelfUpdate, vaultHooks, IDLE_CHECK_MS }
|
|
@@ -0,0 +1,170 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* El supervisor: levanta el agente del perfil y lo vuelve a levantar cada vez que sale (también
|
|
3
|
+
* cuando se reinicia para estrenar una versión: §15, `DOTRINO_SUPERVISED`). Uno por perfil: si
|
|
4
|
+
* ya hay otro vivo, lanza `already-supervised`.
|
|
5
|
+
* @param {{ name: string, dir: string, node?: string, cli: string, args: string[], spawn?: SpawnFn }} o
|
|
6
|
+
*/
|
|
7
|
+
export function supervise({ name, dir, node, cli, args, spawn }: {
|
|
8
|
+
name: string;
|
|
9
|
+
dir: string;
|
|
10
|
+
node?: string;
|
|
11
|
+
cli: string;
|
|
12
|
+
args: string[];
|
|
13
|
+
spawn?: SpawnFn;
|
|
14
|
+
}): {
|
|
15
|
+
stop: () => void;
|
|
16
|
+
};
|
|
17
|
+
/**
|
|
18
|
+
* Las órdenes de servicio de un agente.
|
|
19
|
+
* @param {Product} product
|
|
20
|
+
*/
|
|
21
|
+
export function makeService({ id, title, runPrefix, agentArgs, linux }: Product): {
|
|
22
|
+
installService: ({ name, node, cli, dir, running, pathEnv, platform, home, user, uid, run, spawn, env }: {
|
|
23
|
+
name: string;
|
|
24
|
+
node?: string;
|
|
25
|
+
cli: string;
|
|
26
|
+
dir: string;
|
|
27
|
+
running?: boolean;
|
|
28
|
+
pathEnv?: string;
|
|
29
|
+
platform?: string;
|
|
30
|
+
home?: string;
|
|
31
|
+
user?: string;
|
|
32
|
+
uid?: number;
|
|
33
|
+
run?: RunFn;
|
|
34
|
+
spawn?: SpawnFn;
|
|
35
|
+
env?: NodeJS.ProcessEnv;
|
|
36
|
+
}) => {
|
|
37
|
+
kind: ServiceKind;
|
|
38
|
+
file: string;
|
|
39
|
+
started: boolean;
|
|
40
|
+
boot?: boolean;
|
|
41
|
+
lingerReason?: string;
|
|
42
|
+
startReason?: string;
|
|
43
|
+
};
|
|
44
|
+
uninstallService: ({ name, dir, platform, home, uid, run }: {
|
|
45
|
+
name: string;
|
|
46
|
+
dir: string;
|
|
47
|
+
platform?: string;
|
|
48
|
+
home?: string;
|
|
49
|
+
uid?: number;
|
|
50
|
+
run?: RunFn;
|
|
51
|
+
}) => {
|
|
52
|
+
kind: ServiceKind;
|
|
53
|
+
file: string;
|
|
54
|
+
removed: boolean;
|
|
55
|
+
};
|
|
56
|
+
serviceStatus: ({ name, dir, platform, home, uid, run }: {
|
|
57
|
+
name: string;
|
|
58
|
+
dir: string;
|
|
59
|
+
platform?: string;
|
|
60
|
+
home?: string;
|
|
61
|
+
uid?: number;
|
|
62
|
+
run?: RunFn;
|
|
63
|
+
}) => {
|
|
64
|
+
kind: ServiceKind;
|
|
65
|
+
file: string;
|
|
66
|
+
installed: boolean;
|
|
67
|
+
active: boolean;
|
|
68
|
+
};
|
|
69
|
+
startService: ({ name, dir, node, cli, platform, home, uid, run, spawn, env }: {
|
|
70
|
+
name: string;
|
|
71
|
+
dir: string;
|
|
72
|
+
node?: string;
|
|
73
|
+
cli: string;
|
|
74
|
+
platform?: string;
|
|
75
|
+
home?: string;
|
|
76
|
+
uid?: number;
|
|
77
|
+
run?: RunFn;
|
|
78
|
+
spawn?: SpawnFn;
|
|
79
|
+
env?: NodeJS.ProcessEnv;
|
|
80
|
+
}) => boolean;
|
|
81
|
+
superviseCommand: ({ name, dir, cli, node, spawn, env }: {
|
|
82
|
+
name: string;
|
|
83
|
+
dir: string;
|
|
84
|
+
cli: string;
|
|
85
|
+
node?: string;
|
|
86
|
+
spawn?: SpawnFn;
|
|
87
|
+
env?: NodeJS.ProcessEnv;
|
|
88
|
+
}) => {
|
|
89
|
+
relaunched: boolean;
|
|
90
|
+
stop?: undefined;
|
|
91
|
+
} | {
|
|
92
|
+
relaunched: boolean;
|
|
93
|
+
stop: () => void;
|
|
94
|
+
};
|
|
95
|
+
unitText: ({ name, node, cli, pathEnv }: Launch & {
|
|
96
|
+
pathEnv: string;
|
|
97
|
+
}) => string;
|
|
98
|
+
autostartText: ({ name, node, cli }: Launch) => string;
|
|
99
|
+
plistText: ({ name, node, cli, pathEnv, log }: Launch & {
|
|
100
|
+
pathEnv: string;
|
|
101
|
+
log: string;
|
|
102
|
+
}) => string;
|
|
103
|
+
unitName: (name: string) => string;
|
|
104
|
+
unitPath: (name: string, home?: string) => string;
|
|
105
|
+
plistLabel: (name: string) => string;
|
|
106
|
+
plistPath: (name: string, home?: string) => string;
|
|
107
|
+
autostartPath: (name: string, home?: string) => string;
|
|
108
|
+
runValue: (name: string) => string;
|
|
109
|
+
runCommand: ({ name, node, cli }: Launch) => string;
|
|
110
|
+
};
|
|
111
|
+
/** Correr una orden del sistema (`execFileSync`, o su doble en las pruebas). */
|
|
112
|
+
/** @typedef {(cmd: string, args: string[], opts?: import('node:child_process').ExecFileSyncOptions) => unknown} RunFn */
|
|
113
|
+
/** Lanzar un proceso (`spawn`, o su doble en las pruebas). */
|
|
114
|
+
/** @typedef {typeof childSpawn} SpawnFn */
|
|
115
|
+
/** Lo que comparten las órdenes de servicio: el perfil, y Node y el CLI con que se lanza. */
|
|
116
|
+
/** @typedef {{ name: string, node: string, cli: string }} Launch */
|
|
117
|
+
/** @typedef {'systemd' | 'autostart' | 'launchd' | 'run-key'} ServiceKind */
|
|
118
|
+
/**
|
|
119
|
+
* Qué agente es.
|
|
120
|
+
* @typedef {object} Product
|
|
121
|
+
* @property {string} id `terminal-agent` → `dotrino-terminal-agent-<perfil>.service`, `com.dotrino.terminal-agent.<perfil>`
|
|
122
|
+
* @property {string} title para la descripción de la unidad: `Dotrino Terminal agent`
|
|
123
|
+
* @property {string} runPrefix el valor de `HKCU\…\Run`: `DotrinoTerminalAgent` → `DotrinoTerminalAgent-<perfil>`
|
|
124
|
+
* @property {(name: string) => string[]} agentArgs con qué argumentos se corre el agente sin TTY
|
|
125
|
+
* @property {'systemd' | 'autostart'} [linux] cómo se pone en Linux (por defecto, systemd)
|
|
126
|
+
*/
|
|
127
|
+
/** Windows: la clave de lo que arranca al iniciar sesión. */
|
|
128
|
+
export const RUN_KEY: "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
|
|
129
|
+
/** Cuánto espera el supervisor antes de volver a levantar el agente (como `RestartSec`). */
|
|
130
|
+
export const RESTART_MS: 3000;
|
|
131
|
+
export function supervisorPidFile(dir: string): string;
|
|
132
|
+
export function desktopArg(s: string): string;
|
|
133
|
+
export type Thrown = Error & {
|
|
134
|
+
code?: string;
|
|
135
|
+
stderr?: string | Buffer;
|
|
136
|
+
};
|
|
137
|
+
export type RunFn = (cmd: string, args: string[], opts?: import("node:child_process").ExecFileSyncOptions) => unknown;
|
|
138
|
+
export type SpawnFn = typeof childSpawn;
|
|
139
|
+
export type Launch = {
|
|
140
|
+
name: string;
|
|
141
|
+
node: string;
|
|
142
|
+
cli: string;
|
|
143
|
+
};
|
|
144
|
+
export type ServiceKind = "systemd" | "autostart" | "launchd" | "run-key";
|
|
145
|
+
/**
|
|
146
|
+
* Qué agente es.
|
|
147
|
+
*/
|
|
148
|
+
export type Product = {
|
|
149
|
+
/**
|
|
150
|
+
* `terminal-agent` → `dotrino-terminal-agent-<perfil>.service`, `com.dotrino.terminal-agent.<perfil>`
|
|
151
|
+
*/
|
|
152
|
+
id: string;
|
|
153
|
+
/**
|
|
154
|
+
* para la descripción de la unidad: `Dotrino Terminal agent`
|
|
155
|
+
*/
|
|
156
|
+
title: string;
|
|
157
|
+
/**
|
|
158
|
+
* el valor de `HKCU\…\Run`: `DotrinoTerminalAgent` → `DotrinoTerminalAgent-<perfil>`
|
|
159
|
+
*/
|
|
160
|
+
runPrefix: string;
|
|
161
|
+
/**
|
|
162
|
+
* con qué argumentos se corre el agente sin TTY
|
|
163
|
+
*/
|
|
164
|
+
agentArgs: (name: string) => string[];
|
|
165
|
+
/**
|
|
166
|
+
* cómo se pone en Linux (por defecto, systemd)
|
|
167
|
+
*/
|
|
168
|
+
linux?: "systemd" | "autostart" | undefined;
|
|
169
|
+
};
|
|
170
|
+
import { spawn as childSpawn } from 'node:child_process';
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Lo que un agente le dice a SU bóveda sobre actualizarse: los tres ganchos de
|
|
3
|
+
* `vaultUpdateHooks`, armados EN CADA LLAMADA con el enlace leído del disco. El papel se renueva
|
|
4
|
+
* mientras el agente corre, y el agente puede arrancar sin enlace y enlazarse después: una
|
|
5
|
+
* conexión fijada al arrancar se quedaría vieja.
|
|
6
|
+
*
|
|
7
|
+
* @param {{ dir: string, product: string, log?: (m: string) => void, load?: (dir: string) => any, make?: typeof vaultUpdateHooks }} o
|
|
8
|
+
* @returns {import('@dotrino/vault/service').UpdateHooks}
|
|
9
|
+
*/
|
|
10
|
+
export function vaultHooks({ dir, product, log, load, make }: {
|
|
11
|
+
dir: string;
|
|
12
|
+
product: string;
|
|
13
|
+
log?: (m: string) => void;
|
|
14
|
+
load?: (dir: string) => any;
|
|
15
|
+
make?: typeof vaultUpdateHooks;
|
|
16
|
+
}): import("@dotrino/vault/service").UpdateHooks;
|
|
17
|
+
/**
|
|
18
|
+
* Enciende la autoactualización de un agente que ya corre.
|
|
19
|
+
*
|
|
20
|
+
* La versión nueva se instala en cuanto sale, pero el agente solo se va cuando `busy()` da 0:
|
|
21
|
+
* tumbarle a alguien lo que está usando para estrenar una versión es justo lo contrario de lo
|
|
22
|
+
* que se quiere. Y sin quien lo levante (systemd, pm2) no se va nunca: irse sería apagarle el
|
|
23
|
+
* servicio al usuario.
|
|
24
|
+
*
|
|
25
|
+
* @param {{
|
|
26
|
+
* pkg: string, repo: string, tag: (version: string) => string, label: string,
|
|
27
|
+
* dir: string, version: string, busy: () => number, close: () => unknown,
|
|
28
|
+
* exit?: (code: number) => void, log?: (m: string) => void, watch?: typeof watchSelfUpdateNpm,
|
|
29
|
+
* hooks?: import('@dotrino/vault/service').UpdateHooks, idleCheckMs?: number
|
|
30
|
+
* }} o
|
|
31
|
+
* `label`: con qué se presenta en el log (`terminal-agent`). `busy`: cuánto está atendiendo
|
|
32
|
+
* ahora (consolas, gente mirando). `close`: cerrar lo suyo antes de salir.
|
|
33
|
+
* @returns {() => void} para dejar de mirar
|
|
34
|
+
*/
|
|
35
|
+
export function startSelfUpdate({ pkg, repo, tag, label, dir, version, busy, close, exit, log, watch, hooks, idleCheckMs }: {
|
|
36
|
+
pkg: string;
|
|
37
|
+
repo: string;
|
|
38
|
+
tag: (version: string) => string;
|
|
39
|
+
label: string;
|
|
40
|
+
dir: string;
|
|
41
|
+
version: string;
|
|
42
|
+
busy: () => number;
|
|
43
|
+
close: () => unknown;
|
|
44
|
+
exit?: (code: number) => void;
|
|
45
|
+
log?: (m: string) => void;
|
|
46
|
+
watch?: typeof watchSelfUpdateNpm;
|
|
47
|
+
hooks?: import("@dotrino/vault/service").UpdateHooks;
|
|
48
|
+
idleCheckMs?: number;
|
|
49
|
+
}): () => void;
|
|
50
|
+
/** Cada cuánto se mira si ya está libre para reiniciar con la versión instalada. */
|
|
51
|
+
export const IDLE_CHECK_MS: 60000;
|
|
52
|
+
declare namespace _default {
|
|
53
|
+
export { startSelfUpdate };
|
|
54
|
+
export { vaultHooks };
|
|
55
|
+
export { IDLE_CHECK_MS };
|
|
56
|
+
}
|
|
57
|
+
export default _default;
|
|
58
|
+
import { vaultUpdateHooks } from '@dotrino/vault/service';
|
|
59
|
+
import { watchSelfUpdateNpm } from '@dotrino/update/npm';
|