@dotrino/vaultd 0.157.0 → 0.158.1

package/README.md

@@ -159,12 +159,18 @@ con `dotrino-vault service autostart on|off`. Desinstalar no borra tus datos.
 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`).
 
-> Ni el instalador de Windows ni la app de macOS llevan la firma de un desarrollador
-> registrado: Windows enseña el aviso de SmartScreen («editor desconocido») y macOS el de
-> Gatekeeper 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`.
-> En Windows y macOS la bóveda todavía **no se actualiza sola**: se instala la versión nueva
-> encima.
+**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
@@ -893,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; que la bóveda de Windows y macOS se
-  actualice sola, como la de Linux; firma de Apple y de Microsoft; 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
 

package/bin/dotrino-vault-tui.js

@@ -23,6 +23,6 @@ if (!process.stdout.isTTY) {
 
 runTui().catch((e) => {
   // El finally de runTui ya restauró el terminal; aquí solo reportamos.
-  console.error('error en la TUI:', e?.stack || e?.message || e)
+  console.error('TUI error:', e?.stack || e?.message || e)
   process.exit(1)
 })

package/bin/sea-entry.js

@@ -16,11 +16,11 @@ if (argv[0] === '--tui') {
   // ni el proxy: habla con el daemon por el dir de datos + señales.
   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) })
+    .catch((e) => { console.error('TUI error:', 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) })
+    .catch((e) => { console.error('window bridge error:', 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).
@@ -29,5 +29,5 @@ if (argv[0] === '--tui') {
 } else {
   // Modo daemon (servicio).
   import('../src/daemon.js').then(({ runDaemon }) => runDaemon(argv))
-    .catch((e) => { console.error('error fatal del daemon:', e.message); process.exit(1) })
+    .catch((e) => { console.error('fatal daemon error:', e.message); process.exit(1) })
 }

package/lib/src/atrest.js

@@ -132,7 +132,7 @@ export function encryptText (plaintext, key) {
 
 export function decryptText (blob, key) {
   const [magic, iv, ct, tag] = String(blob).split('.')
-  if (magic !== MAGIC) throw new Error('at-rest: formato desconocido')
+  if (magic !== MAGIC) throw new Error('at-rest: unknown format')
   const d = crypto.createDecipheriv('aes-256-gcm', key, Buffer.from(iv, 'base64'))
   d.setAuthTag(Buffer.from(tag, 'base64'))
   return Buffer.concat([d.update(Buffer.from(ct, 'base64')), d.final()]).toString('utf8')
@@ -176,7 +176,7 @@ export function migrateFile (file, key) {
   try { text = fs.readFileSync(file, 'utf8') } catch (_) { return 'sin-archivo' }
   if (isEncrypted(text)) return 'ya-cifrado'
   const blob = encryptText(text, key)
-  if (decryptText(blob, key) !== text) throw new Error('at-rest: la comprobación falló, no se toca el original')
+  if (decryptText(blob, key) !== text) throw new Error('at-rest: verification failed, the original is untouched')
   const tmp = file + '.atrest.tmp'
   fs.writeFileSync(tmp, blob, { mode: 0o600 })
   fs.renameSync(tmp, file)

package/lib/src/core/libVersion.js

@@ -5,4 +5,4 @@
  * si no coincide con la del paquete: una versión anunciada que no es la que corre es peor
  * que no anunciar ninguna.
  */
-export const LIB_VERSION = '0.86.0'
+export const LIB_VERSION = '0.86.1'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.157.0",
+  "version": "0.158.1",
   "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

@@ -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… ')

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

@@ -93,7 +93,11 @@ 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 si se cae (no si se para a propósito). */
+/**
+ * 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"?>
@@ -109,16 +113,16 @@ ${argv}
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
-  <dict>
-    <key>SuccessfulExit</key>
-    <false/>
-  </dict>
+  <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>Background</string>
+  <string>Standard</string>
 </dict>
 </plist>
 `

package/src/tui/app.js

@@ -216,10 +216,11 @@ function offerUpdate (term, st) {
   setConfirm(st, { text: i.updateOffer(r.version, VERSION), onYes: () => installUpdate(term, st, r) })
 }
 
-async function installUpdate (term, st, release, { install = up.installUserRelease, userInstall = up.isUserInstall } = {}) {
+async function installUpdate (term, st, release, { install = (rel) => up.installRelease(rel), userInstall = up.canSelfUpdate } = {}) {
   const i = L(st)
-  // Solo la instalación de usuario se puede cambiar desde aquí. Un paquete del sistema es
-  // de root: no se pide la contraseña por dentro, se dice el comando.
+  // Solo una instalación que puede cambiarse sola (la de usuario de Linux, el instalador de
+  // Windows, la app de macOS) se cambia desde aquí. Un paquete del sistema es de root: no se
+  // pide la contraseña por dentro, se dice el comando.
   if (!userInstall()) { flash(st, i.updateNeedsCommand, 'warn'); return }
   const r = await guard(term, st, i.updateInstalling(release.version), () => install(release))
   if (!r.ok) return
@@ -228,6 +229,9 @@ async function installUpdate (term, st, release, { install = up.installUserRelea
     flash(st, i.updateNoteFailed(e.message), 'warn')
   }
   st.update = { installed: r.v.version }
+  // WINDOWS: el instalador ya corre; cierra la bóveda y esta pantalla (son el mismo .exe), las
+  // cambia y vuelve a arrancar la bóveda. La ventana vuelve sola. No hay nada que preguntar.
+  if (r.v.then === 'exit' && process.platform === 'win32') { flash(st, i.updateWindowsInstalling(r.v.version), 'warn'); return }
   // Reiniciar se PREGUNTA: cierra las bóvedas abiertas y corta lo que estén haciendo los
   // aparatos. Si dices que no, el servicio se reinicia solo en un par de minutos.
   setConfirm(st, {

package/src/tui/i18n.js

@@ -36,6 +36,7 @@ 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…',
@@ -541,6 +542,7 @@ 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…',

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'
@@ -137,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' }
+}