@dotrino/vaultd 0.156.0 → 0.158.0

package/src/tui/gui.js

@@ -0,0 +1,214 @@
+/**
+ * gui.js — el PUENTE entre la ventana de escritorio y la pantalla de control.
+ *
+ * La ventana (`desktop/`, Rust + iced) no sabe nada de la bóveda: lanza
+ * `dotrino-vault gui-bridge` (el mismo binario) y le habla por stdin/stdout, una línea JSON
+ * por mensaje. Este proceso corre LA MISMA sesión que la TUI —`newSession`, `handleKey`,
+ * `viewModel` de `app.js`— y le manda a la ventana lo que tiene que pintar. Así la ventana
+ * tiene exactamente las pantallas, los textos y las acciones de la TUI, y una acción nueva
+ * aparece en las dos sin tocar la otra.
+ *
+ * No abre ningún puerto: el canal son las tuberías del proceso hijo, que solo ve quien lo
+ * lanzó. Y como la TUI, no toca la identidad ni la red: le habla al daemon por su carpeta.
+ *
+ * Mensajes de la ventana (uno por línea):
+ *   {"key":{"name":"char","ch":"p"}}   una tecla, con los mismos nombres que `term.js`
+ *   {"select":3}                        señalar la fila 3 (entre las seleccionables)
+ *   {"activate":3}                      señalarla y pulsar Enter
+ *   {"tab":"secrets"}                   ir a una pestaña de la bóveda entrada
+ *   {"submit":"texto"}                  responder la pregunta abierta con ese texto
+ *   {"confirm":true|false}              responder la confirmación abierta
+ *   {"quit":true}                       salir (cerrando lo que se abrió aquí)
+ *
+ * Mensajes a la ventana:
+ *   {"t":"view","v":{…}}                qué pintar (ver `viewModel`/`downModel`)
+ *   {"t":"bye","relaunch":bool}         se terminó; con `relaunch`, volver a lanzar el puente
+ *                                       (se instaló una versión nueva)
+ *
+ * Los textos llevan sus estilos como tramos: `[{"t":"…","c":"muted","b":true}]`.
+ */
+import * as vc from '../vaultControl.js'
+import { makeTheme } from './term.js'
+import {
+  newSession, startSession, beforeRender, tickFor, handleKey, endSession,
+  viewModel, downModel, selectRow, openTab, onKeyDown
+} from './app.js'
+
+// stdout es el canal: cualquier `console.log` suelto lo rompería. Va a stderr.
+console.log = (...a) => console.error(...a)
+
+// ----------------------------- estilos → tramos ------------------------------
+
+/** Color del tema de la TUI (`makeTheme`) → nombre que entiende la ventana. */
+const COLORS = { 44: 'accent', 114: 'ok', 214: 'warn', 203: 'danger', 244: 'muted', 81: 'title' }
+
+/** Un texto con escapes SGR → tramos `{t, c?, b?}`. */
+export function spans (str) {
+  const out = []
+  let bold = false
+  let color = null
+  let buf = ''
+  const flush = () => {
+    if (!buf) return
+    const sp = { t: buf }
+    if (color) sp.c = color
+    if (bold) sp.b = true
+    out.push(sp)
+    buf = ''
+  }
+  const re = /\x1b\[([0-9;]*)m/g
+  const s = String(str ?? '')
+  let last = 0
+  let m
+  while ((m = re.exec(s))) {
+    buf += s.slice(last, m.index)
+    last = re.lastIndex
+    flush()
+    const codes = m[1] === '' ? [0] : m[1].split(';').map(Number)
+    for (let k = 0; k < codes.length; k++) {
+      const c = codes[k]
+      if (c === 0) { bold = false; color = null } else if (c === 1) bold = true
+      else if (c === 38 && codes[k + 1] === 5) { color = COLORS[codes[k + 2]] || null; k += 2 }
+    }
+  }
+  buf += s.slice(last)
+  flush()
+  return out
+}
+
+/** Pasa a tramos todos los textos que el modelo trae con estilos. */
+function toWire (vm) {
+  const v = { ...vm }
+  if (v.rows) v.rows = v.rows.map((r) => ({ ...r, text: spans(r.text) }))
+  if (v.body) v.body = v.body.map(spans)
+  for (const k of ['title', 'notice', 'status']) {
+    if (v[k] && typeof v[k] === 'object' && 'text' in v[k]) v[k] = { ...v[k], text: spans(v[k].text) }
+  }
+  if (v.confirm) v.confirm = { ...v.confirm, text: spans(v.confirm.text) }
+  // «p emparejar» → { key: 'p', label: 'emparejar' }. La tecla es el mnemónico de la TUI, y
+  // la ventana la usa como atajo de teclado y la manda al pulsar el botón.
+  v.help = (v.help || []).map((seg) => {
+    const sp = String(seg).indexOf(' ')
+    return sp < 0 ? { key: seg, label: '' } : { key: seg.slice(0, sp), label: seg.slice(sp + 1) }
+  })
+  return v
+}
+
+// --------------------------------- el bucle ---------------------------------
+
+export async function runGuiBridge ({ input = process.stdin, output = process.stdout } = {}) {
+  const t = makeTheme({ color: true })
+  const st = newSession()
+  const queue = []
+  let waiter = null
+
+  const push = (ev) => { if (waiter) { const w = waiter; waiter = null; w(ev) } else queue.push(ev) }
+
+  let pending = ''
+  input.setEncoding('utf8')
+  input.on('data', (chunk) => {
+    pending += chunk
+    let nl
+    while ((nl = pending.indexOf('\n')) >= 0) {
+      const line = pending.slice(0, nl).trim()
+      pending = pending.slice(nl + 1)
+      if (!line) continue
+      try { push(JSON.parse(line)) } catch (e) { console.error('[gui-bridge] bad message:', e.message) }
+    }
+  })
+  // La ventana se cerró (o murió): se sale igual que con `q`, cerrando lo abierto aquí.
+  input.on('end', () => push({ quit: true }))
+  input.on('error', () => push({ quit: true }))
+
+  const next = (ms) => {
+    if (queue.length) return Promise.resolve(queue.shift())
+    return new Promise((resolve) => {
+      let timer = null
+      waiter = (ev) => { if (timer) clearTimeout(timer); resolve(ev) }
+      if (ms) timer = setTimeout(() => { waiter = null; resolve({ key: { name: 'tick' } }) }, ms)
+    })
+  }
+
+  // Si la ventana ya no está, escribir da EPIPE: no es un fallo de la sesión, y no puede
+  // tumbar el cierre ordenado (que es el que vuelve a cerrar las bóvedas).
+  let gone = false
+  output.on?.('error', () => { gone = true })
+  let lastSent = ''
+  const send = (msg) => {
+    if (gone) return
+    const line = JSON.stringify(msg)
+    if (msg.t === 'view' && line === lastSent) return
+    if (msg.t === 'view') lastSent = line
+    output.write(line + '\n')
+  }
+  const sendView = () => send({ t: 'view', v: toWire(st.down ? downModel(st) : viewModel(st, t)) })
+
+  // La sesión pinta también a mitad de una operación (`guard` pone «Guardando…»): el
+  // «terminal» de la ventana solo avisa de que hay algo nuevo.
+  const term = {
+    t,
+    gui: () => sendView(),
+    size: () => ({ cols: 200, rows: 60 }),
+    render: () => sendView(),
+    readKey: async () => ({ name: 'tick' }),
+    close: () => {}
+  }
+
+  /** Un mensaje de la ventana → la tecla (o las teclas) que equivale. */
+  const toKeys = (ev) => {
+    if (ev.key) return [ev.key]
+    if (typeof ev.select === 'number') { selectRow(st, ev.select); return [] }
+    if (typeof ev.activate === 'number') { selectRow(st, ev.activate); return [{ name: 'enter' }] }
+    if (typeof ev.submit === 'string') {
+      if (st.input) st.input.value = ev.submit
+      return [{ name: 'enter' }]
+    }
+    if (typeof ev.confirm === 'boolean') return [{ name: 'char', ch: ev.confirm ? 'y' : 'n' }]
+    return []
+  }
+
+  let relaunch = false
+  let inSession = false
+  try {
+    while (true) {
+      if (!vc.daemonAlive()) {
+        // SIN SERVICIO: la pantalla de arrancarlo. Si se cae a mitad de sesión, se vuelve
+        // aquí en vez de dejar una ventana que contesta errores a todo.
+        st.down = true
+        sendView()
+        const ev = await next(3000)
+        if (ev.quit) break
+        if (ev.key?.name === 'tick') continue
+        const keys = toKeys(ev)
+        let r = null
+        for (const k of keys) r = await onKeyDown(st, k, sendView)
+        if (r === false) break
+        continue
+      }
+      if (st.down || !inSession) {
+        st.down = false
+        await startSession(term, st)
+        inSession = true
+      }
+      await beforeRender(term, st)
+      sendView()
+      const ev = await next(tickFor(st) || 2000)
+      if (ev.quit) break
+      if (ev.tab) { await openTab(term, st, ev.tab); continue }
+      let running = true
+      for (const k of toKeys(ev)) {
+        // Un tick sin pantalla que lo espere no hace nada; solo sirve para repintar.
+        running = await handleKey(term, st, k)
+        if (!running) break
+      }
+      if (!running) { relaunch = !!st.relaunch; break }
+    }
+  } finally {
+    await endSession(st)
+    send({ t: 'bye', relaunch })
+    // La entrada sigue abierta si quien salió fue la propia sesión (`q`, o tras actualizar):
+    // sin soltarla, el proceso se quedaba vivo esperando líneas que ya nadie iba a leer.
+    input.pause()
+    input.destroy?.()
+  }
+}

package/src/tui/i18n.js

@@ -15,6 +15,9 @@
 import path from 'node:path'
 import { dataDir, readJson, writeJson } from '../paths.js'
 
+// Solo Linux tiene la unidad de systemd: en Windows y macOS nombrarla manda a un comando que no existe.
+const LINUX = process.platform === 'linux'
+
 // --------------------------------- español ---------------------------------
 
 const es = {
@@ -33,11 +36,12 @@ const es = {
   updateInstalling: (version) => `Bajando la ${version} y comprobando la firma…`,
   updateFailed: (reason) => `No se instaló nada: ${reason}`,
   updateNeedsCommand: 'Esta instalación no se puede cambiar desde aquí. Sal y corre:  dotrino-vault update',
+  updateWindowsInstalling: (v) => `Instalando la ${v}: esta pantalla se cierra un momento y la bóveda vuelve sola.`,
   updateNoteFailed: (reason) => `Instalada, pero no se pudo dejar el aviso para tus aprobadores: ${reason}`,
   updateRestartOffer: (version) => `Instalada la ${version}. ¿Reiniciar ahora la bóveda y esta pantalla? Cierra las bóvedas abiertas`,
   updateRestarting: 'Reiniciando la bóveda…',
   updateRestartLater: (version) => `La ${version} queda instalada: la bóveda se reinicia sola en un par de minutos`,
-  daemonStale: (running, installed) => `⚠ el servicio corre ${running} y el binario instalado es ${installed}: reinícialo (systemctl --user restart dotrino-vault)`,
+  daemonStale: (running, installed) => `⚠ el servicio corre ${running} y el binario instalado es ${installed}: reinícialo${LINUX ? ' (systemctl --user restart dotrino-vault)' : ''}`,
   activeVault: 'Bóveda activa: ',
   noName: '(sin nombre)',
   tooSmall: 'Terminal muy pequeño',
@@ -190,6 +194,14 @@ const es = {
   settingUpdateNowAsks: 'Hecho: pide aprobación antes de actualizarse.',
   settingUpdateNowAlone: 'Hecho: se actualiza sola.',
   settingSaveFailed: (m) => `No se pudo guardar el ajuste: ${m}`,
+  settingAutostartOn: 'La bóveda arranca sola al iniciar sesión en esta computadora.',
+  settingAutostartOff: 'La bóveda no arranca sola: hay que abrirla cada vez.',
+  settingAutostartUnknown: 'No se sabe si la bóveda arranca sola al iniciar sesión.',
+  settingAutostartHint: 'Sin ella encendida, tus aparatos no pueden pedirle nada a esta bóveda.',
+  settingAutostartNoUnit: 'Para que arranque sola, instálala con el paquete de tu sistema (.deb o .rpm).',
+  settingAutostartSaving: 'Guardando…',
+  settingAutostartNowOn: 'Hecho: arranca sola al iniciar sesión.',
+  settingAutostartNowOff: 'Hecho: ya no arranca sola.',
   doorsIntro: (name) => `Con qué se abre «${name}». Abre cualquiera de estas.`,
   doorsNone: 'Sin candado: se abre sola en esta máquina.',
   doorPassword: 'contraseña',
@@ -480,7 +492,7 @@ const es = {
 
   // pantalla "daemon caído"
   downTitle: 'El daemon del vault no está corriendo.',
-  downBody1: 'La TUI le da órdenes al daemon (custodio de tu clave). Sin él no puede',
+  downBody1: 'Esta pantalla le da órdenes al servicio de la bóveda (el que guarda tu llave). Sin él no puede',
   downBody2: 'crear bóvedas, listar dispositivos ni tocar secretos.',
   downStart: '  intentar arrancarlo:  ',
   downRecheck: '  volver a comprobar',
@@ -496,7 +508,7 @@ const es = {
   startFailed: (err) => `No se pudo arrancar: ${err}`,
 
   // errores
-  errDaemonDown: 'El daemon no está corriendo. Arráncalo: systemctl --user start dotrino-vault (o reinicia la TUI).',
+  errDaemonDown: LINUX ? 'El daemon no está corriendo. Arráncalo: systemctl --user start dotrino-vault (o reinicia la TUI).' : 'El servicio de la bóveda no está corriendo. Cierra esta pantalla y vuelve a abrirla para arrancarlo.',
   errNoReply: 'El daemon no respondió.',
   errNotApplied: 'El daemon no aplicó el cambio (revisa los logs del servicio).',
   errNotDeleted: 'El daemon no borró la variable (revisa los logs del servicio).',
@@ -530,11 +542,12 @@ const en = {
   updateInstalling: (version) => `Downloading ${version} and checking its signature…`,
   updateFailed: (reason) => `Nothing was installed: ${reason}`,
   updateNeedsCommand: 'This install cannot be changed from here. Quit and run:  dotrino-vault update',
+  updateWindowsInstalling: (v) => `Installing ${v}: this screen closes for a moment and the vault comes back on its own.`,
   updateNoteFailed: (reason) => `Installed, but the note for your approvers could not be written: ${reason}`,
   updateRestartOffer: (version) => `${version} is installed. Restart the vault and this screen now? It locks the open vaults`,
   updateRestarting: 'Restarting the vault…',
   updateRestartLater: (version) => `${version} is installed: the vault restarts by itself in a couple of minutes`,
-  daemonStale: (running, installed) => `⚠ the service runs ${running} but the installed binary is ${installed}: restart it (systemctl --user restart dotrino-vault)`,
+  daemonStale: (running, installed) => `⚠ the service runs ${running} but the installed binary is ${installed}: restart it${LINUX ? ' (systemctl --user restart dotrino-vault)' : ''}`,
   activeVault: 'Active vault: ',
   tooSmall: 'Terminal too small',
   tooSmallHint: (cols, rows) => `Resize to ≥ 24×9 (now ${cols}×${rows}).`,
@@ -667,6 +680,14 @@ const en = {
   settingUpdateNowAsks: 'Done: it asks for approval before updating.',
   settingUpdateNowAlone: 'Done: it updates on its own.',
   settingSaveFailed: (m) => `The setting could not be saved: ${m}`,
+  settingAutostartOn: 'The vault starts on its own when you sign in to this computer.',
+  settingAutostartOff: 'The vault does not start on its own: you have to open it every time.',
+  settingAutostartUnknown: 'It is not known whether the vault starts on its own when you sign in.',
+  settingAutostartHint: 'While it is off, your devices cannot ask this vault for anything.',
+  settingAutostartNoUnit: 'To have it start on its own, install it with your system package (.deb or .rpm).',
+  settingAutostartSaving: 'Saving…',
+  settingAutostartNowOn: 'Done: it starts on its own when you sign in.',
+  settingAutostartNowOff: 'Done: it no longer starts on its own.',
   doorsIntro: (name) => `What opens “${name}”. Any of these opens it.`,
   doorsNone: 'No lock: it opens by itself on this machine.',
   doorPassword: 'password',
@@ -926,7 +947,7 @@ const en = {
   helpJoin: ['Esc vaults', 'l Español', 'q quit'],
 
   downTitle: 'The vault daemon is not running.',
-  downBody1: 'The TUI gives orders to the daemon (the keeper of your key). Without it',
+  downBody1: 'This screen gives orders to the vault service (the keeper of your key). Without it',
   downBody2: 'it cannot create vaults, list devices or touch secrets.',
   downStart: '  try to start it:  ',
   downRecheck: '  check again',
@@ -941,7 +962,7 @@ const en = {
   startedNotReady: 'It started but does not answer yet; press R',
   startFailed: (err) => `Could not start it: ${err}`,
 
-  errDaemonDown: 'The daemon is not running. Start it: systemctl --user start dotrino-vault (or restart the TUI).',
+  errDaemonDown: LINUX ? 'The daemon is not running. Start it: systemctl --user start dotrino-vault (or restart the TUI).' : 'The vault service is not running. Close this screen and open it again to start it.',
   errNoReply: 'The daemon did not answer.',
   errNotApplied: 'The daemon did not apply the change (check the service logs).',
   errNotDeleted: 'The daemon did not delete the variable (check the service logs).',

package/src/tui/term.js

@@ -87,8 +87,13 @@ export function padEnd (s, width) {
 
 // ------------------------------- tema/estilos -------------------------------
 
-export function makeTheme () {
-  const on = supportsColor()
+/**
+ * `color: true` fuerza los estilos aunque no haya terminal: lo usa el puente de la ventana
+ * (`gui.js`), que convierte esos mismos escapes en tramos con estilo. Así las filas que
+ * pinta la TUI son, carácter a carácter, las que pinta la ventana.
+ */
+export function makeTheme ({ color } = {}) {
+  const on = color ?? supportsColor()
   const sgr = (...c) => (on ? CSI + c.join(';') + 'm' : '')
   const R = on ? CSI + '0m' : ''
   const wrap = (open) => (s) => on ? open + s + R : s

package/src/update.js

@@ -12,7 +12,7 @@
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
-import { execFileSync } from 'node:child_process'
+import { execFileSync, spawn } from 'node:child_process'
 import { latestVersion, isNewer, CHECK_EVERY_MS } from '@dotrino/update'
 import { pickAsset, download, verifyArtifact as verify, fetchVerified } from '@dotrino/update/fetch'
 import { VERSION } from './version.js'
@@ -124,8 +124,12 @@ async function instalarDesde (work, pick, release, { binDir, log, fetchVerifiedI
   const src = fs.readdirSync(work).map((d) => path.join(work, d)).find((d) => fs.existsSync(path.join(d, 'dotrino-vaultd')))
   if (!src) return { ok: false, code: 'BAD_TARBALL', reason: 'the tarball has no dotrino-vaultd inside' }
   fs.mkdirSync(binDir, { recursive: true })
+  // LA VENTANA se pone al día con la bóveda, pero solo donde ya estaba: una bóveda de
+  // servidor no tiene por qué recibir un programa de escritorio que nadie instaló.
+  const names = ['dotrino-vault', 'dotrino-vaultd']
+  if (fs.existsSync(path.join(binDir, 'dotrino-vault-desktop')) && fs.existsSync(path.join(src, 'dotrino-vault-desktop'))) names.unshift('dotrino-vault-desktop')
   // El CLI primero y el daemon al final: cambiar el daemon es lo que dispara el reinicio.
-  for (const name of ['dotrino-vault', 'dotrino-vaultd']) {
+  for (const name of names) {
     const tmp = path.join(binDir, `.${name}.new`)
     fs.copyFileSync(path.join(src, name), tmp)
     fs.chmodSync(tmp, 0o755)
@@ -133,3 +137,143 @@ async function instalarDesde (work, pick, release, { binDir, log, fetchVerifiedI
   }
   return { ok: true, version: release.version }
 }
+
+// ------------------------- Windows y macOS ---------------------------------
+
+/**
+ * CÓMO ESTÁ INSTALADO ESTE BINARIO, y por tanto si puede actualizarse solo (CONVENCIONES §15).
+ *
+ *   'user'    Linux, instalación de usuario (`~/.local/share/dotrino/bin`): cambia sus binarios.
+ *   'inno'    Windows, el instalador por usuario (`unins000.exe` al lado): corre el instalador
+ *             nuevo en silencio, que cierra la bóveda, la reemplaza y la vuelve a arrancar.
+ *   'app'     macOS, dentro de `Dotrino Vault.app` en una carpeta que se puede escribir: se
+ *             cambia la app entera (nunca un binario suelto: la app es un conjunto firmado).
+ *   'system'  un paquete de root (.deb/.rpm), o una app en una carpeta que no es tuya.
+ *   'other'   npm, Docker, un checkout: se actualiza por su propia vía.
+ */
+export function installKind ({ platform = process.platform, execPath = process.execPath, home = os.homedir(), exists = fs.existsSync, writable = canWrite } = {}) {
+  const sea = /^dotrino-vaultd(\.exe)?$/.test(path.basename(execPath))
+  if (!sea) return 'other'
+  if (platform === 'linux') return isUserInstall(execPath, home) ? 'user' : execPath.startsWith('/usr/') ? 'system' : 'other'
+  if (platform === 'win32') return exists(path.join(path.dirname(execPath), 'unins000.exe')) ? 'inno' : 'other'
+  if (platform === 'darwin') {
+    const app = appBundleOf(execPath)
+    if (!app) return 'other'
+    return writable(path.dirname(app)) ? 'app' : 'system'
+  }
+  return 'other'
+}
+
+/** ¿Puede este binario instalar él mismo la versión nueva? */
+export const canSelfUpdate = (opts) => ['user', 'inno', 'app'].includes(installKind(opts))
+
+/** `/Applications/Dotrino Vault.app` a partir de su `Contents/MacOS/dotrino-vaultd`. */
+export function appBundleOf (execPath) {
+  const m = /^(.*\.app)\/Contents\/MacOS\/dotrino-vaultd$/.exec(execPath)
+  return m ? m[1] : null
+}
+
+function canWrite (dir) { try { fs.accessSync(dir, fs.constants.W_OK); return true } catch { return false } }
+
+/** Carpeta de trabajo de las descargas: la de los datos de Dotrino del usuario, no `/tmp`. */
+function updateWorkDir (platform = process.platform) {
+  if (platform === 'win32') return path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'Dotrino', 'update')
+  return path.join(os.homedir(), '.local', 'share', 'dotrino', 'update')
+}
+
+/**
+ * INSTALA la versión nueva por la vía de este sistema. Lo que se baja se verifica contra la
+ * atestación del release antes de tocar nada; si no cuadra, no se toca nada y se dice.
+ *
+ * `then` dice qué tiene que hacer quien llamó:
+ *   'watch'  Linux: el binario cambió en su sitio; el vigilante (o systemd) lo reinicia.
+ *   'exit'   el proceso que corre la bóveda tiene que irse YA. En Windows el instalador lo
+ *            cierra y lo vuelve a arrancar; en macOS lo levanta launchd o el relanzador.
+ *
+ * @returns {Promise<{ok:true, version:string, then:'watch'|'exit'} | {ok:false, code?:string, reason:string, file?:string}>}
+ */
+export async function installRelease (release, { log = () => {}, kind = installKind(), fetchVerifiedImpl = fetchVerified, run = spawnDetached, execPath = process.execPath, pid = null } = {}) {
+  if (kind === 'user') {
+    const r = await installUserRelease(release, { log, fetchVerifiedImpl })
+    return r.ok ? { ...r, then: 'watch' } : r
+  }
+  if (kind === 'inno') return installWindows(release, { log, fetchVerifiedImpl, run })
+  if (kind === 'app') return installMac(release, { log, fetchVerifiedImpl, run, execPath, pid })
+  return { ok: false, code: 'CANNOT_SELF_UPDATE', reason: kind === 'system' ? 'installed as a system package (root): update it with the system installer' : 'not installed with an installer: update it the way you installed it (npm, Docker…)' }
+}
+
+function spawnDetached (cmd, args, { log } = {}) {
+  const child = spawn(cmd, args, { detached: true, windowsHide: true, stdio: 'ignore' })
+  child.on('error', (e) => log?.(`[vault] update: could not start ${cmd}: ${e.message}`))
+  child.unref()
+}
+
+/** Baja y verifica un archivo del release a una carpeta propia (que se vacía antes). */
+async function bajarVerificado (release, re, { log, fetchVerifiedImpl, work }) {
+  const pick = pickAsset(release.assets, [{ kind: 'asset', re }])
+  if (!pick.ok) return pick
+  fs.rmSync(work, { recursive: true, force: true })
+  fs.mkdirSync(work, { recursive: true, mode: 0o700 })
+  const got = await fetchVerifiedImpl(pick.asset, { repo: REPO, product: 'dotrino-vault', version: VERSION, dir: work })
+  if (got.ok) log(`[vault] update: ${pick.asset.name} verified against its attestation`)
+  return got
+}
+
+/**
+ * WINDOWS: el instalador nuevo, en silencio. Es lo único que puede cambiar los archivos: un
+ * .exe en marcha no se sobrescribe. El instalador cierra lo que los usa (la bóveda, y la
+ * ventana si está abierta), los reemplaza y vuelve a arrancar la bóveda (`--start-daemon`).
+ * Las tareas elegidas al instalar (arrancar al iniciar sesión) se conservan.
+ */
+async function installWindows (release, { log, fetchVerifiedImpl, run }) {
+  const work = updateWorkDir('win32')
+  const got = await bajarVerificado(release, /-windows-x64-setup\.exe$/, { log, fetchVerifiedImpl, work })
+  if (!got.ok) return got
+  run(got.file, ['/VERYSILENT', '/SUPPRESSMSGBOXES', '/NORESTART', '/FORCECLOSEAPPLICATIONS', `/LOG=${path.join(work, 'setup.log')}`], { log })
+  log(`[vault] update: installer for ${release.version} started; it restarts the vault when it finishes`)
+  return { ok: true, version: release.version, then: 'exit' }
+}
+
+/**
+ * macOS: la app entera. Se descomprime al lado de la actual (misma carpeta, así el cambio es
+ * un renombrado y no una copia a medias), se aparta la vieja, se pone la nueva y se borra la
+ * vieja. Lo que está corriendo sigue con su copia hasta que se reinicia.
+ *
+ * Quien la levanta: launchd si la bóveda corre como agente (KeepAlive); si corre suelta, un
+ * relanzador que espera a que este proceso se vaya y arranca el binario nuevo.
+ */
+async function installMac (release, { log, fetchVerifiedImpl, run, execPath, pid }) {
+  const app = appBundleOf(execPath)
+  if (!app) return { ok: false, code: 'CANNOT_SELF_UPDATE', reason: 'not running from Dotrino Vault.app' }
+  const work = updateWorkDir('darwin')
+  const got = await bajarVerificado(release, /-macos-universal\.zip$/, { log, fetchVerifiedImpl, work })
+  if (!got.ok) return got
+  const parent = path.dirname(app)
+  const stage = path.join(parent, `.dotrino-vault-update-${process.pid}`)
+  fs.rmSync(stage, { recursive: true, force: true })
+  try {
+    try { execFileSync('ditto', ['-x', '-k', got.file, stage], { stdio: ['ignore', 'ignore', 'pipe'] }) } catch (e) {
+      return { ok: false, code: 'UNPACK_FAILED', reason: `could not unpack the release: ${String(e.stderr || e.message).trim().split('\n').slice(-2).join(' · ')}` }
+    }
+    const nueva = path.join(stage, 'Dotrino Vault.app')
+    if (!fs.existsSync(path.join(nueva, 'Contents', 'MacOS', 'dotrino-vaultd'))) return { ok: false, code: 'BAD_ARCHIVE', reason: 'the archive has no Dotrino Vault.app inside' }
+    const vieja = `${app}.old-${process.pid}`
+    fs.renameSync(app, vieja)
+    try { fs.renameSync(nueva, app) } catch (e) {
+      fs.renameSync(vieja, app) // se deja como estaba
+      return { ok: false, code: 'SWAP_FAILED', reason: `could not put the new app in place: ${e.message}` }
+    }
+    fs.rmSync(vieja, { recursive: true, force: true })
+  } finally {
+    fs.rmSync(stage, { recursive: true, force: true })
+    fs.rmSync(work, { recursive: true, force: true })
+  }
+  // Suelta (sin launchd): el relanzador espera a que `pid` se vaya y arranca el nuevo.
+  if (pid && process.env.XPC_SERVICE_NAME !== 'com.dotrino.vault') {
+    const bin = path.join(app, 'Contents', 'MacOS', 'dotrino-vaultd')
+    const logFile = path.join(os.homedir(), '.local', 'share', 'dotrino', 'vault', 'daemon.log')
+    run('/bin/sh', ['-c', 'while kill -0 "$1" 2>/dev/null; do sleep 0.5; done; exec "$2" >>"$3" 2>&1', 'relaunch', String(pid), bin, logFile], { log })
+  }
+  log(`[vault] update: ${release.version} installed in ${app}`)
+  return { ok: true, version: release.version, then: 'exit' }
+}