@dotrino/vaultd 0.156.0 → 0.158.0

package/README.md

@@ -128,10 +128,49 @@ firmado**. Se lee con `dotrino-vault activity`.
 
 ## Instalación
 
-Tres vías, y todas dejan la misma bóveda: **instalador de Linux** (queda como
-servicio), **un comando** (`npx`, en cualquier sistema con Node) y **Docker**. En
-Linux la primera es la cómoda; en Windows y macOS todavía no hay instalador de un
-clic, así que van por las otras dos.
+Todas las vías dejan la misma bóveda: **instalador** de Linux (`.deb`, `.rpm`,
+tarball), de **Windows** (`-setup.exe`) y de **macOS** (`Dotrino Vault.app`), **un
+comando** (`npx`, en cualquier sistema con Node) y **Docker**. Los instaladores traen
+además **la ventana** (ver abajo); `npx` y Docker, la TUI.
+
+### La ventana (`desktop/`)
+
+Una app de escritorio con **las mismas pantallas que la TUI**: bóvedas, aparatos,
+emparejar (con el QR como imagen), permisos, cajones y variables, inicios de sesión, mi
+perfil, llaves de seguridad y ajustes. No reimplementa nada: lanza `dotrino-vaultd
+--gui-bridge` y pinta el modelo que le manda el puente (`src/tui/gui.js`), que corre la
+misma sesión que la TUI. Una acción nueva en la TUI aparece en la ventana sin tocarla. Sin
+puertos: el canal son las tuberías del proceso hijo. Rust + `iced`, con el tema del
+ecosistema (Quicksand/Comfortaa, claro u oscuro según el sistema).
+
+Busca la bóveda al lado de su ejecutable (así la ponen los instaladores), luego en el
+`PATH` (`dotrino-vaultd`, o el `dotrino-vault` de npm). Para desarrollo:
+`DOTRINO_VAULT_BRIDGE="node bin/dotrino-vault.js" cargo run` en `desktop/`.
+
+**Windows — instalador:** `dotrino-vault-X.Y.Z-windows-x64-setup.exe` desde
+[Releases](https://github.com/imdotrino/dotrino-vault/releases/latest). Se instala para
+tu usuario, sin administrador, en `%LOCALAPPDATA%\Programs\Dotrino Vault`, con su entrada
+en el menú Inicio, y deja la bóveda **arrancando al iniciar sesión** (una entrada `Run`
+que lanza `dotrino-vault-desktop.exe --start-daemon`, sin ventana). Se cambia en Ajustes o
+con `dotrino-vault service autostart on|off`. Desinstalar no borra tus datos.
+
+**macOS — `Dotrino Vault.app`:** el `.zip` universal (Apple Silicon e Intel) desde
+[Releases](https://github.com/imdotrino/dotrino-vault/releases/latest); arrástrala a
+Aplicaciones. Dentro van la ventana y la bóveda. Para que arranque al iniciar sesión, en
+Ajustes (un LaunchAgent de tu usuario, `~/Library/LaunchAgents/com.dotrino.vault.plist`).
+
+**Se actualizan solas, como en Linux** (CONVENCIONES §15): una vez al día miran si hay versión
+nueva, bajan el instalador (Windows) o la app (macOS), lo **verifican contra la atestación de
+sigstore** del release —dentro del propio binario, sin `gh`— y lo instalan. En Windows el
+instalador cierra la bóveda, la cambia y la vuelve a arrancar (y vuelve a abrir la ventana si
+estaba abierta); en macOS se cambia la app entera y la levanta launchd o, suelta, un
+relanzador. La aprobación opcional (`update --approval on`) vale igual.
+
+> El instalador de Windows **no lleva firma de Microsoft, y no la va a llevar** (decisión del
+> dueño): Windows enseña el aviso de SmartScreen («editor desconocido»). La app de macOS
+> todavía no lleva la firma de Apple: Gatekeeper avisa la primera vez (clic derecho → Abrir).
+> Lo que prueba de dónde salieron es la atestación de sigstore:
+> `gh attestation verify <archivo> --repo imdotrino/dotrino-vault`.
 
 **Ubuntu / Debian — `.deb`:** descarga el `.deb` (versionado) desde
 [Releases](https://github.com/imdotrino/dotrino-vault/releases/latest) y haz doble
@@ -196,7 +235,7 @@ npx -y @dotrino/vaultd          # Node ≥ 20
 npx -y @dotrino/vaultd --tui    # la bóveda y su pantalla de control en la misma ventana
 ```
 
-Es la vía normal en **Windows y macOS**, y sirve igual en Linux. Arranca en primer
+Sirve en cualquier sistema (y es la vía en ARM fuera de Docker). Arranca en primer
 plano: la bóveda vive mientras dejes esa ventana abierta. Los comandos de control se
 anteponen con `npx -p @dotrino/vaultd` (por ejemplo, `npx -p @dotrino/vaultd
 dotrino-vault pair`). Si no tienes Node, el instalador del ecosistema lo baja en tu
@@ -228,9 +267,9 @@ recupera.
 
 > Sin firma de código: tu sistema puede advertir que el binario no está firmado. Es
 > autohospedado y de código abierto; en Linux solo necesita permiso de ejecución (el
-> instalador lo da). Hay un build de Windows (`packaging/build-win.sh`) pero **no se
-> publica**: se construye desde Linux y no se ha probado en un Windows de verdad, y
-> la inyección del blob invalida la firma de Microsoft, así que saltaría SmartScreen.
+> instalador lo da). El daemon de Windows (`packaging/build-win.sh`) se construye desde
+> Linux y va dentro del instalador de Windows; el de macOS (`packaging/build-mac.sh`) se
+> construye en un Mac y va dentro de la app.
 
 **Dónde vive todo y cómo se para.** Tus datos —llave incluida— viven en
 `~/.local/share/dotrino/vault` (Linux y macOS), `%LOCALAPPDATA%\Dotrino\vault`
@@ -848,8 +887,10 @@ ed25519 en formato OpenSSH (sin frase: la bóveda es el candado) y RSA/P-256 en
 ## Alcance
 
 - **v1 (este):** daemon headless en Node, **multi-perfil**. En **Linux** queda como
-  servicio `systemd --user` (binario único Node SEA: `.deb` y tarball); en **Windows y
-  macOS** se corre con `npx`, en primer plano; y en cualquier sistema, con **Docker**
+  servicio `systemd --user` (binario único Node SEA: `.deb`, `.rpm` y tarball); en
+  **Windows** con un instalador por usuario y en **macOS** como `Dotrino Vault.app`, los
+  dos con arranque al iniciar sesión; en los tres, con **una ventana** que tiene las
+  pantallas de la TUI (`desktop/`); y en cualquier sistema, con `npx` o **Docker**
   (imagen amd64/arm64 en GHCR). Identidad **cifrada en reposo y ligada a esta
   máquina**. Emparejamiento endurecido con los dos caminos de vinculación, acta del
   perfil (miembros, capacidades y `cn` de servicio), firma delegada, renovación
@@ -858,9 +899,8 @@ ed25519 en formato OpenSSH (sin frase: la bóveda es el candado) y RSA/P-256 en
   actividad. Contraseña opcional por perfil, **para editarlo** (verificador PBKDF2).
 - **v2:** cifrado en reposo **con la contraseña del perfil** (hoy la clave sale solo de
   la máquina) y atado a tu cuenta del sistema —DPAPI en Windows, Keychain en macOS— o
-  al TPM; cifrar también los secretos y el store; **instalador de un clic para Windows
-  y macOS**; UI de escritorio (Tauri) como cliente del daemon; firma de documentos con
-  sellado de tiempo (`dotrino-signer`).
+  al TPM; cifrar también los secretos y el store; firma y notarización de Apple para la app de
+  macOS; firma de documentos con sellado de tiempo (`dotrino-signer`).
 
 ## Estructura
 
@@ -870,7 +910,9 @@ ed25519 en formato OpenSSH (sin frase: la bóveda es el candado) y RSA/P-256 en
 - `src/daemon.js` — modo servicio: `state.json`, control por archivos + señales, apagado limpio.
 - `src/ctl.js` — CLI de control (habla con el daemon por archivos + señales, sin socket).
 - `src/vaultControl.js` — API de control programática (misma vía que la CLI); la usa la TUI.
-- `src/tui/` — interfaz de terminal, sin dependencias (`term.js` primitivas ANSI/raw-mode; `app.js` pantallas; `i18n.js` los textos es/en).
+- `src/tui/` — interfaz de terminal, sin dependencias (`term.js` primitivas ANSI/raw-mode; `app.js` pantallas; `i18n.js` los textos es/en; `gui.js` el puente de la ventana).
+- `src/service.js` — arrancar, reiniciar y arrancar al iniciar sesión en Linux, Windows y macOS.
+- `desktop/` — la ventana (Rust + `iced`): pinta lo que le manda `gui.js`.
 - `src/transport.js` — conexión headless al proxy + `identify` firmado (con el acta).
 - `src/threadStore.js` — el store del usuario: hilos, "recientes" y perfil (`threads.json`).
 - `src/store.js` — árbol de contenidos (`vault.json`, versionado). Hoy es un esqueleto: se lee, nadie escribe.

package/bin/sea-entry.js

@@ -17,6 +17,10 @@ if (argv[0] === '--tui') {
   if (!process.stdout.isTTY) { console.error('la TUI necesita un terminal interactivo (TTY).'); process.exit(2) }
   import('../src/tui/app.js').then(({ runTui }) => runTui())
     .catch((e) => { console.error('error en la TUI:', e.message); process.exit(1) })
+} else if (argv[0] === '--gui-bridge') {
+  // El canal de la ventana de escritorio (JSON por stdin/stdout, ver src/tui/gui.js).
+  import('../src/tui/gui.js').then(({ runGuiBridge }) => runGuiBridge()).then(() => process.exit(0))
+    .catch((e) => { console.error('error en el puente de la ventana:', e.message); process.exit(1) })
 } else if (argv[0] === '--ctl') {
   // CLI de control: NO toca la identidad ni el proxy; habla con el daemon vía
   // el dir de datos (state.json) y señales (SIGUSR1 para emparejar).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.156.0",
+  "version": "0.158.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -28,7 +28,8 @@
     "@dotrino/proxy-client": "^0.32.2",
     "@dotrino/roadmap": "0.4.13",
     "@dotrino/store": "0.11.0",
-    "@dotrino/update": "0.5.1",
+    "@dotrino/update": "0.9.0",
+    "sigstore": "5.0.0",
     "ws": "^8.18.0"
   },
   "license": "MIT",

package/src/ctl.js

@@ -102,7 +102,7 @@ const START_HINT = IN_DOCKER
   ? 'docker start dotrino-vault'
   : process.platform === 'linux'
     ? 'systemctl --user start dotrino-vault'
-    : 'dotrino-vaultd   (o: npx -y @dotrino/vaultd)'
+    : 'dotrino-vault service start   (o: npx -y @dotrino/vaultd)'
 const RESTART_HINT = IN_DOCKER
   ? 'docker restart dotrino-vault'
   : process.platform === 'linux'
@@ -1855,7 +1855,7 @@ async function cmdUpdate (args = []) {
       : 'Esta bóveda se actualiza sola, sin pedir aprobación.')
     return
   }
-  const { latestRelease, assetFor, download, verifyArtifact, isNewer, isUserInstall, installUserRelease } = await import('./update.js')
+  const { latestRelease, assetFor, download, verifyArtifact, isNewer, isUserInstall, installUserRelease, installKind, installRelease } = await import('./update.js')
   const soloMirar = args.includes('--check')
 
   process.stdout.write('Mirando qué hay publicado… ')
@@ -1874,6 +1874,38 @@ async function cmdUpdate (args = []) {
   console.log('%sHay %s y esta es la %s.%s', B, r.version, VERSION, Z)
   if (soloMirar) { console.log('Tráela con:  dotrino-vault update'); return }
 
+  // WINDOWS Y macOS: el instalador nuevo (Windows) o la app entera (macOS), verificados.
+  const kind = installKind()
+  if (kind === 'inno' || kind === 'app') {
+    process.stdout.write('Bajando y comprobando la firma… ')
+    const res = await installRelease(r, { kind })
+    if (!res.ok) {
+      console.log('')
+      console.error('%sNO se instala nada.%s %s', R, Z, res.reason)
+      if (res.file) console.error('El archivo quedó en %s, sin tocar nada.', res.file)
+      process.exit(1)
+    }
+    console.log('firmada por el release de %s ✓', 'imdotrino/dotrino-vault')
+    await noteUpdated(res.version)
+    if (kind === 'inno') {
+      // El instalador cierra la bóveda (y este mismo comando: es el mismo .exe), la cambia y
+      // la vuelve a arrancar. Aquí no queda nada que esperar.
+      console.log('Instalando la %s: la bóveda se cierra un momento y vuelve sola.', res.version)
+      return
+    }
+    // macOS: la app nueva ya está en su sitio; falta reiniciar la que corre.
+    const s = ipcRead(stateFile, null)
+    if (s && alive(s.pid)) {
+      const { restartDaemonService } = await import('./service.js')
+      try { await restartDaemonService({ pid: s.pid, alive: () => alive(s.pid) }) } catch (e) {
+        console.error('Instalada, pero no se pudo reiniciar: %s', e.message)
+        process.exit(1)
+      }
+      await waitForService(res.version)
+    } else console.log('Instalada la %s.', res.version)
+    return
+  }
+
   // Instalación de usuario: se verifica y se instala aquí mismo, sin sudo.
   if (isUserInstall()) {
     process.stdout.write('Bajando y comprobando la firma… ')
@@ -2240,6 +2272,36 @@ function cmdLogs () {
 }
 
 // Import dinámico: así `dotrino-vault status` (el caso común) no carga la TUI.
+/**
+ * `service start | autostart [on|off]`: arrancar el daemon y dejarlo arrancando al iniciar
+ * sesión, en los tres sistemas (`src/service.js`). En Linux es la unidad de systemd; en
+ * Windows una entrada de inicio de sesión; en macOS un LaunchAgent.
+ */
+async function cmdService (rest) {
+  const sv = await import('./service.js')
+  const [sub, val] = rest
+  if (sub === 'start') {
+    // `readState()` sale si no hay state.json, y sin state.json es justo cuando hay que arrancar.
+    const s = ipcRead(stateFile, null)
+    if (s && alive(s.pid)) { console.log('ya está corriendo (pid ' + s.pid + ')'); return }
+    const r = await sv.startDaemonService()
+    if (!r.ok) { console.error('no se pudo arrancar: ' + r.err); process.exit(1) }
+    console.log('arrancado · registro: ' + sv.daemonLogFile())
+    return
+  }
+  if (sub === 'autostart') {
+    if (val === 'on' || val === 'off') {
+      const r = val === 'on' ? await sv.enableAutostart() : await sv.disableAutostart()
+      if (!r.ok) { console.error('no se pudo: ' + r.err); process.exit(1) }
+    } else if (val !== undefined) { console.error('uso: dotrino-vault service autostart [on|off]'); process.exit(2) }
+    const st = await sv.autostartStatus()
+    console.log('arranca al iniciar sesión: ' + (st.on === null ? 'no se sabe en este sistema' : st.on ? 'sí' : 'no') + (st.how !== 'none' ? ` (${st.how})` : ''))
+    return
+  }
+  console.error('uso: dotrino-vault service start | autostart [on|off]')
+  process.exit(2)
+}
+
 async function cmdTui () {
   if (!process.stdout.isTTY) { console.error('la TUI necesita un terminal interactivo (TTY).'); process.exit(2) }
   const { runTui } = await import('./tui/app.js')
@@ -2250,6 +2312,10 @@ function help () {
   console.log(`dotrino-vault — control del certificador personal
 
   tui                 interfaz de terminal a pantalla completa (bóvedas, pares, secretos)
+  service start       arranca el servicio en segundo plano (sin ventana)
+  service autostart [on|off]
+                     que arranque solo al iniciar sesión (systemd en Linux, una entrada
+                     de inicio en Windows, un LaunchAgent en macOS) · sin valor, dice cómo está
   status | info       estado del servicio + fingerprint + el id de cada perfil
   update [--check]   trae la versión nueva (verificando la firma) y espera a que el
                      servicio la arranque · --check solo mira · --no-wait no espera
@@ -2485,6 +2551,10 @@ export async function runCtl (argv) {
   if (rest.includes('--help') || rest.includes('-h')) return help()
   switch (cmd) {
     case 'tui': return cmdTui()
+    // El canal de la ventana de escritorio (`desktop/`). No es para personas: habla JSON por
+    // stdin/stdout. Ver `src/tui/gui.js`.
+    case 'gui-bridge': { await (await import('./tui/gui.js')).runGuiBridge(); process.exit(0) }
+    case 'service': return cmdService(rest)
     case 'profile': return cmdProfile(rest)
     case 'unlock': return cmdUnlock(rest)
     case 'lock': return cmdLock()

package/src/daemon.js

@@ -25,7 +25,7 @@ import { parseInvite } from '../lib/src/invite.js'
 import { scopeToCaps, scopeToCn } from '../lib/src/enroll.js'
 import { capScope } from '@dotrino/identity/acta'
 import { watchBinary } from './selfupdate.js'
-import { latestRelease, isNewer, CHECK_EVERY_MS, isUserInstall, installUserRelease } from './update.js'
+import { latestRelease, isNewer, CHECK_EVERY_MS, installKind, installRelease } from './update.js'
 import { VERSION } from './version.js'
 import { readSettings } from './settings.js'
 import { approversOfAll, firstYes, readAsked, writeAsked, clearAsked, shouldAsk, resultOfNo, readRootTold, writeRootTold, shouldTellRoot } from './updateApproval.js'
@@ -1157,9 +1157,18 @@ export async function runDaemon () {
     }
     const conAvisos = quienAprueba.filter((a) => a.notifiedAt).length
 
-    // INSTALADA COMO PAQUETE DEL SISTEMA (.deb o .rpm en /usr/bin): el binario es de root y este
-    // proceso no puede tocarlo. Se dice, con las dos salidas, y no se intenta nada.
-    if (!isUserInstall()) {
+    // CÓMO SE INSTALÓ decide si puede instalar ella misma (update.js, `installKind`): la de
+    // usuario de Linux, el instalador de Windows y la app de macOS, sí. Por npm, Docker o un
+    // checkout se actualiza por su propia vía: se dice en el log y nada más (no es «hace
+    // falta root», y avisar eso al teléfono sería mentirle).
+    const kind = installKind()
+    if (kind === 'other') {
+      if (avisadoOtra !== r.version) { avisadoOtra = r.version; console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · update it the way you installed it (npm, Docker, git)`) }
+      return
+    }
+    // INSTALADA COMO PAQUETE DEL SISTEMA (.deb o .rpm en /usr/bin, o una app en una carpeta
+    // que no es tuya): este proceso no puede tocarla. Se dice, con las salidas, y no se intenta nada.
+    if (kind === 'system') {
       console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · installed as a system package, so it cannot update itself: \`dotrino-vault update\` (needs sudo), or move to a user install with the tarball's install.sh`)
       // …Y SE LE DICE A QUIEN APRUEBA, en todos los perfiles (dueño, 2026-10-08: «si se
       // requiere root por algún motivo, simplemente se notifica al aprobador que hay
@@ -1235,7 +1244,7 @@ export async function runDaemon () {
       }
       clearAsked(dir)
       if (pedidoSinRespuesta) { pedidoSinRespuesta = null; writeState() }
-      const res = await installUserRelease(r, { log: (m) => console.log(m) })
+      const res = await installRelease(r, { log: (m) => console.log(m), kind, pid: process.pid })
       if (!res.ok) {
         // Lo que NO cuadra no se instala, y se dice por qué: el archivo queda a mano.
         console.log(`[vault] update to ${r.version} NOT installed: ${res.reason}${res.file ? ` (file left at ${res.file})` : ''}`)
@@ -1252,7 +1261,12 @@ export async function runDaemon () {
       try { ipcWrite(updatedFile, { v: 1, from: daemonVersion, to: r.version, at: Date.now() }) } catch (e) {
         console.log(`[vault] update: ${r.version} installed, but the note to tell the approvers could not be written: ${e.message}`)
       }
-      if (vigia) {
+      // Windows y macOS: hay que irse YA. En Windows el instalador cierra la bóveda y la vuelve
+      // a arrancar; en macOS la levanta launchd o el relanzador que dejó la instalación.
+      if (res.then === 'exit') {
+        console.log(`[vault] update: ${r.version} installed · leaving so the new one starts`)
+        shutdown(`updated to ${r.version}`)
+      } else if (vigia) {
         console.log(`[vault] update: ${r.version} installed · restarting now to run it`)
         shutdown(`updated to ${r.version}`)
       } else {
@@ -1263,6 +1277,7 @@ export async function runDaemon () {
     } finally { actualizando = false }
   }
   let actualizando = false
+  let avisadoOtra = null
   let aprobada = null
   let avisandoRoot = null
 

package/src/service.js

@@ -0,0 +1,251 @@
+/**
+ * service.js — arrancar, reiniciar y dejar arrancando al iniciar sesión el daemon del vault,
+ * en los tres sistemas.
+ *
+ * Lo usan la TUI y la ventana (las dos ofrecen «arrancar el servicio» cuando no está) y el
+ * CLI (`dotrino-vault service`). Antes la TUI llamaba a `systemctl --user` a pelo, así que en
+ * Windows y macOS el botón de arrancar solo sabía fallar.
+ *
+ *   Linux    systemd --user si la unidad está instalada (el .deb y el tarball la ponen);
+ *            si no, el daemon suelto en segundo plano.
+ *   Windows  el daemon suelto, sin ventana. Al iniciar sesión: una entrada en
+ *            HKCU\…\Run que lo lanza con `conhost --headless` (sin consola a la vista).
+ *   macOS    un LaunchAgent del usuario (`~/Library/LaunchAgents/com.dotrino.vault.plist`)
+ *            que lo levanta al entrar y lo relanza si se cae; sin él, el daemon suelto.
+ *
+ * Todo es DEL USUARIO, sin permisos de administrador: es lo que deja que se actualice solo
+ * (CONVENCIONES §15).
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { execFile, spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { dataDir, ensureDir } from './paths.js'
+import { ipcRead } from './ipc.js'
+
+const run = (cmd, args, timeout = 15000) => new Promise((resolve) => {
+  execFile(cmd, args, { timeout, windowsHide: true }, (err, so, se) => {
+    resolve({ ok: !err, out: String(so || ''), err: err ? (String(se || '').trim() || err.message) : '' })
+  })
+})
+
+/**
+ * Cómo se lanza el daemon desde este mismo proceso. En el binario autosuficiente es el
+ * propio ejecutable sin argumentos; desde npm, `node bin/dotrino-vaultd.js`.
+ */
+export function daemonCommand () {
+  if (globalThis.__DOTRINO_SEA__) return { cmd: process.execPath, args: [] }
+  const here = path.dirname(fileURLToPath(import.meta.url))
+  return { cmd: process.execPath, args: [path.join(here, '..', 'bin', 'dotrino-vaultd.js')] }
+}
+
+/** Dónde escribe el daemon suelto lo que diría por consola. */
+export const daemonLogFile = () => path.join(dataDir(), 'daemon.log')
+
+/** Lanza el daemon suelto, en segundo plano y sin ventana, con su salida a `daemon.log`. */
+export function spawnDaemon () {
+  const { cmd, args } = daemonCommand()
+  ensureDir(dataDir())
+  const fd = fs.openSync(daemonLogFile(), 'a', 0o600)
+  try {
+    const child = spawn(cmd, args, { detached: true, windowsHide: true, stdio: ['ignore', fd, fd] })
+    child.unref()
+    return { ok: true, err: '', pid: child.pid }
+  } catch (e) {
+    return { ok: false, err: e.message }
+  } finally { fs.closeSync(fd) }
+}
+
+/**
+ * Para el daemon suelto que esté corriendo (el de `spawnDaemon`), y espera a que se vaya.
+ * Hace falta antes de dárselo a un supervisor: el candado del dir de datos solo deja uno,
+ * y el del supervisor saldría con error y se relanzaría en bucle.
+ */
+async function stopLooseDaemon () {
+  const pid = ipcRead(path.join(dataDir(), 'state.json'), null)?.pid
+  if (!pidAlive(pid)) return
+  try { process.kill(pid, 'SIGTERM') } catch (_) {}
+  await waitGone(pid)
+}
+
+const pidAlive = (pid) => { try { return !!pid && (process.kill(pid, 0) || true) } catch { return false } }
+
+/** Espera a que el proceso se vaya (y suelte el candado del dir de datos). */
+async function waitGone (pid) {
+  for (let n = 0; n < 40 && pidAlive(pid); n++) await new Promise((r) => setTimeout(r, 250))
+  if (pidAlive(pid)) throw new Error(`the running vault (pid ${pid}) did not stop`)
+}
+
+// ------------------------------- Linux ------------------------------------
+
+async function hasSystemdUnit () {
+  // Con una carpeta de datos propia, la unidad (que tiene la suya) arrancaría OTRA bóveda.
+  if (process.platform !== 'linux' || process.env.DOTRINO_VAULT_DIR) return false
+  return (await run('systemctl', ['--user', 'cat', 'dotrino-vault'], 5000)).ok
+}
+
+// ------------------------------- macOS ------------------------------------
+
+const LABEL = 'com.dotrino.vault'
+export const launchAgentFile = () => path.join(os.homedir(), 'Library', 'LaunchAgents', LABEL + '.plist')
+const guiDomain = () => `gui/${process.getuid?.() ?? 501}`
+
+const xml = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+
+/**
+ * El LaunchAgent: lo arranca al entrar y lo relanza siempre que se va, como `Restart=always`
+ * de systemd. Hace falta también cuando sale bien: tras instalar la versión nueva, la bóveda
+ * se va para que el agente arranque la nueva. Para pararla de verdad, `autostart off`.
+ */
+export function launchAgentPlist ({ cmd, args }, log = daemonLogFile()) {
+  const argv = [cmd, ...args].map((a) => `    <string>${xml(a)}</string>`).join('\n')
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argv}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xml(log)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml(log)}</string>
+  <!-- Standard y no Background: en Background macOS frena la red y la CPU, y la bóveda
+       atiende al teléfono (firmas, aprobaciones). Con Background una actualización tardaba
+       más de 5 minutos en bajar y la verificación se caía por tiempo. -->
+  <key>ProcessType</key>
+  <string>Standard</string>
+</dict>
+</plist>
+`
+}
+
+// ------------------------------- Windows ----------------------------------
+
+const RUN_KEY = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run'
+const RUN_VALUE = 'DotrinoVault'
+
+/**
+ * La línea que se guarda en `Run`. `conhost --headless` (Windows 10 1809 en adelante) corre
+ * una aplicación de consola sin abrirle ventana: sin eso, el daemon sacaría una consola
+ * negra cada vez que entras.
+ */
+export function windowsRunLine ({ cmd, args }) {
+  const q = (s) => `"${s}"`
+  // Con la ventana instalada al lado, ella lanza el daemon sin consola (`--start-daemon`):
+  // es una aplicación de ventanas y no depende de `conhost`.
+  const gui = path.join(path.dirname(cmd), 'dotrino-vault-desktop.exe')
+  if (globalThis.__DOTRINO_SEA__ && fs.existsSync(gui)) return `${q(gui)} --start-daemon`
+  return ['conhost.exe', '--headless', q(cmd), ...args.map(q)].join(' ')
+}
+
+// ------------------------------- común ------------------------------------
+
+/** ¿Arranca solo al iniciar sesión? `null` = no se sabe en este sistema. */
+export async function autostartStatus () {
+  if (process.platform === 'linux') {
+    if (!(await hasSystemdUnit())) return { on: false, how: 'none' }
+    const r = await run('systemctl', ['--user', 'is-enabled', 'dotrino-vault'], 5000)
+    return { on: r.out.trim() === 'enabled', how: 'systemd' }
+  }
+  if (process.platform === 'darwin') return { on: fs.existsSync(launchAgentFile()), how: 'launchd' }
+  if (process.platform === 'win32') {
+    const r = await run('reg', ['query', RUN_KEY, '/v', RUN_VALUE], 5000)
+    return { on: r.ok, how: 'run-key' }
+  }
+  return { on: null, how: 'unknown' }
+}
+
+/** Deja el daemon arrancando al iniciar sesión (y lo arranca ya, si no está). */
+export async function enableAutostart () {
+  const dc = daemonCommand()
+  if (process.platform === 'linux') {
+    if (!(await hasSystemdUnit())) return { ok: false, err: 'no systemd user unit installed (install the .deb, .rpm or the tarball)' }
+    return run('systemctl', ['--user', 'enable', '--now', 'dotrino-vault'])
+  }
+  if (process.platform === 'darwin') {
+    const file = launchAgentFile()
+    ensureDir(path.dirname(file))
+    fs.writeFileSync(file, launchAgentPlist(dc), { mode: 0o644 })
+    await run('launchctl', ['bootout', `${guiDomain()}/${LABEL}`], 5000)
+    // Si ya hay un daemon suelto corriendo, el agente lo encontraría ocupado y se
+    // relanzaría en bucle: el candado del dir de datos solo deja uno. Se para y lo levanta
+    // el agente, que es quien lo cuidará desde ahora.
+    try { await stopLooseDaemon() } catch (e) { return { ok: false, err: e.message } }
+    return run('launchctl', ['bootstrap', guiDomain(), file])
+  }
+  if (process.platform === 'win32') {
+    return run('reg', ['add', RUN_KEY, '/v', RUN_VALUE, '/t', 'REG_SZ', '/d', windowsRunLine(dc), '/f'])
+  }
+  return { ok: false, err: `unsupported platform: ${process.platform}` }
+}
+
+/** Deja de arrancarlo al iniciar sesión. NO lo para: eso es otra decisión. */
+export async function disableAutostart () {
+  if (process.platform === 'linux') return run('systemctl', ['--user', 'disable', 'dotrino-vault'])
+  if (process.platform === 'darwin') {
+    const file = launchAgentFile()
+    if (!fs.existsSync(file)) return { ok: true, err: '' }
+    // `bootout` también lo PARA. Se vuelve a lanzar suelto para no apagarle la bóveda a
+    // quien solo quería que no arrancara sola la próxima vez.
+    const wasRunning = (await run('launchctl', ['print', `${guiDomain()}/${LABEL}`], 5000)).ok
+    const pid = ipcRead(path.join(dataDir(), 'state.json'), null)?.pid
+    await run('launchctl', ['bootout', `${guiDomain()}/${LABEL}`], 5000)
+    fs.rmSync(file, { force: true })
+    if (!wasRunning) return { ok: true, err: '' }
+    // El suelto entra cuando el del agente ya soltó el candado; antes chocaría con él.
+    try { await waitGone(pid) } catch (e) { return { ok: false, err: e.message } }
+    return spawnDaemon()
+  }
+  if (process.platform === 'win32') {
+    const r = await run('reg', ['delete', RUN_KEY, '/v', RUN_VALUE, '/f'])
+    // Que no existiera no es un fallo: el resultado es el que se pedía.
+    return r.ok || /unable to find|no se puede encontrar|not find/i.test(r.err) ? { ok: true, err: '' } : r
+  }
+  return { ok: false, err: `unsupported platform: ${process.platform}` }
+}
+
+/** Arranca el daemon por el camino de este sistema. */
+export async function startDaemonService () {
+  if (await hasSystemdUnit()) return run('systemctl', ['--user', 'start', 'dotrino-vault'], 8000)
+  if (process.platform === 'darwin' && fs.existsSync(launchAgentFile())) {
+    const r = await run('launchctl', ['kickstart', `${guiDomain()}/${LABEL}`], 8000)
+    if (r.ok) return r
+    // El agente está escrito pero no cargado (se borró a mano de launchctl): se carga.
+    return run('launchctl', ['bootstrap', guiDomain(), launchAgentFile()], 8000)
+  }
+  return spawnDaemon()
+}
+
+/**
+ * Reinicia el daemon (tras actualizar). Con systemd o launchd lo hace el supervisor; suelto,
+ * se le pide que se vaya y se lanza el nuevo cuando ya no está — dos a la vez no pueden,
+ * el candado del dir de datos lo impide.
+ */
+export async function restartDaemonService ({ pid, alive } = {}) {
+  if (await hasSystemdUnit()) {
+    const r = await run('systemctl', ['--user', 'restart', 'dotrino-vault'], 20000)
+    if (!r.ok) throw new Error(r.err)
+    return
+  }
+  if (process.platform === 'darwin' && fs.existsSync(launchAgentFile())) {
+    const r = await run('launchctl', ['kickstart', '-k', `${guiDomain()}/${LABEL}`], 20000)
+    if (!r.ok) throw new Error(r.err)
+    return
+  }
+  if (pid) {
+    try { process.kill(pid, 'SIGTERM') } catch (_) {}
+    for (let n = 0; n < 40 && alive?.(); n++) await new Promise((r) => setTimeout(r, 250))
+    if (alive?.()) throw new Error('the old daemon did not stop')
+  }
+  const r = spawnDaemon()
+  if (!r.ok) throw new Error(r.err)
+}