@dotrino/vaultd 0.152.0 → 0.153.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.152.0",
+  "version": "0.153.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": {
@@ -25,7 +25,7 @@
     "@dotrino/identity": "^0.111.0",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.17.0",
-    "@dotrino/proxy-client": "0.30.1",
+    "@dotrino/proxy-client": "^0.31.1",
     "@dotrino/roadmap": "0.3.19",
     "@dotrino/store": "0.11.0",
     "@dotrino/update": "0.5.1",

package/src/ctl.js

@@ -1832,8 +1832,8 @@ async function waitForService (version, { timeoutMs = 4 * 60_000 } = {}) {
  * marcador que deja el servicio cuando se actualiza solo. Si no se puede escribir se dice:
  * la actualización está hecha, lo que se pierde es el aviso.
  */
-function noteUpdated (to) {
-  try { ipcWrite(path.join(dir, 'updated.json'), { v: 1, from: readState().version || VERSION, to, at: Date.now() }) } catch (e) {
+async function noteUpdated (to) {
+  try { (await import('./update.js')).noteUpdated(dir, { from: readState().version || VERSION, to }) } catch (e) {
     console.error('No se pudo dejar el aviso de actualización para tus aprobadores: %s', e.message)
   }
 }
@@ -1883,8 +1883,23 @@ async function cmdUpdate (args = []) {
     }
     console.log('firmada por el release de %s ✓', 'imdotrino/dotrino-vault')
     console.log('Instalada la %s.', res.version)
-    noteUpdated(res.version)
-    if (!args.includes('--no-wait')) await waitForService(res.version)
+    await noteUpdated(res.version)
+    if (args.includes('--no-wait')) return
+    // AL TERMINAR SE OFRECE REINICIAR (dueño, 2026-10-13). El servicio se reinicia solo al
+    // ver el binario nuevo, pero espera a verlo quieto dos minutos: quien está delante puede
+    // no querer esperar. Solo se pregunta con alguien delante y con systemd; si no, se espera.
+    const s = ipcRead(stateFile, null)
+    if (s && alive(s.pid) && s.version !== res.version && process.stdin.isTTY && process.platform === 'linux' && !IN_DOCKER) {
+      const resp = (await askText('¿Reiniciar la bóveda ahora para usarla? Cierra las bóvedas abiertas. [s/N] ')).trim().toLowerCase()
+      if (resp === 's' || resp === 'y') {
+        try { execFileSync('systemctl', ['--user', 'restart', 'dotrino-vault'], { stdio: 'inherit' }) } catch (e) {
+          console.error('No se pudo reiniciar: %s', e.message)
+          console.error('Hazlo a mano:  %s', RESTART_HINT)
+          process.exit(1)
+        }
+      }
+    }
+    await waitForService(res.version)
     return
   }
 
@@ -1924,7 +1939,7 @@ async function cmdUpdate (args = []) {
       B, file, r.version, Z)
     return
   }
-  noteUpdated(r.version)
+  await noteUpdated(r.version)
   console.log('Listo. El servicio se reinicia solo; compruébalo con:  dotrino-vault status')
 }
 

package/src/tui/app.js

@@ -30,7 +30,7 @@
  * que entrar antes), el candado es `k` (la `l` es el idioma) y la contraseña `c`.
  */
 import fs from 'node:fs'
-import { execFile } from 'node:child_process'
+import { execFile, spawnSync } from 'node:child_process'
 import { parseEnvInput } from '../../lib/src/envtext.js'
 import { createTerm, widthOf } from './term.js'
 import { qrToString } from '../qr.js'
@@ -39,6 +39,7 @@ import * as vc from '../vaultControl.js'
 import { readSettings, writeSettings } from '../settings.js'
 import * as hw from '../hwkeys.js'
 import { VERSION } from '../version.js'
+import * as up from '../update.js'
 import { DEVICE_CAPS } from '@dotrino/identity/acta'
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
@@ -184,6 +185,65 @@ function lockGlyph (p) {
   return p.locked ? '🔒' : '🔓'
 }
 
+function restartDaemonService () {
+  return new Promise((res, rej) => {
+    execFile('systemctl', ['--user', 'restart', 'dotrino-vault'], { timeout: 20000 }, (err, so, se) => {
+      if (err) rej(new Error(String(se || '').trim() || err.message)); else res()
+    })
+  })
+}
+
+/**
+ * AL ENTRAR SE DICE SI HAY VERSIÓN NUEVA, Y SE OFRECE INSTALARLA (dueño, 2026-10-13: como
+ * hace la app de Terminal). El servicio ya se actualiza solo; esto es para quien está
+ * mirando: enterarse ahí mismo, instalarla sin salir y, al terminar, reiniciar.
+ *
+ * Se mira EN SEGUNDO PLANO: la pantalla sale al momento y el aviso llega cuando el registro
+ * contesta. «No se pudo mirar» no es «estás al día»: no se dice nada y queda en `st.update`.
+ */
+function checkForUpdate (st, { latest = up.latestRelease } = {}) {
+  if (VERSION === 'dev') return
+  st.update = { checking: true }
+  Promise.resolve().then(() => latest()).then((r) => {
+    if (!r?.ok) { st.update = { failed: r?.reason || 'unknown' }; return }
+    st.update = up.isNewer(r.version, VERSION) ? { release: r, offer: true } : { current: true }
+  }).catch((e) => { st.update = { failed: e?.message || String(e) } })
+}
+
+/** Pregunta UNA vez por sesión. Decir que no deja el aviso arriba, sin volver a preguntar. */
+function offerUpdate (term, st) {
+  const i = L(st)
+  const r = st.update.release
+  st.update = { release: r }
+  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 } = {}) {
+  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.
+  if (!userInstall()) { flash(st, i.updateNeedsCommand, 'warn'); return }
+  const r = await guard(term, st, i.updateInstalling(release.version), () => install(release))
+  if (!r.ok) return
+  if (!r.v.ok) { flash(st, i.updateFailed(r.v.reason), 'danger'); return }
+  try { up.noteUpdated(vc.vaultDir(), { from: st.state?.version || VERSION, to: r.v.version }) } catch (e) {
+    flash(st, i.updateNoteFailed(e.message), 'warn')
+  }
+  st.update = { installed: r.v.version }
+  // 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, {
+    text: i.updateRestartOffer(r.v.version),
+    onYes: async () => {
+      const rr = await guard(term, st, i.updateRestarting, () => restartDaemonService())
+      if (!rr.ok) return
+      st.relaunch = true
+      st.quit = true
+    },
+    onNo: () => { flash(st, i.updateRestartLater(r.v.version)) }
+  })
+}
+
 function startDaemonService () {
   return new Promise((res) => {
     execFile('systemctl', ['--user', 'start', 'dotrino-vault'], { timeout: 8000 }, (err, so, se) => {
@@ -2502,6 +2562,8 @@ function render (term, st) {
       ? t.muted(i.updateWaiting(u.version, dia(u.askedAt + 24 * 60 * 60 * 1000)))
       : t.warn(i.updateNotApproved(u.version, dia(u.askedAt))))
   }
+  // Hay versión nueva y se dijo que no (o todavía no se preguntó): se queda dicho aquí.
+  if (!lines[2] && st.update?.release) lines[2] = ' ' + t.warn(i.updateAvailable(st.update.release.version))
   // Dispositivos/Scopes son pestañas de la bóveda activa (se entra desde Bóvedas);
   // el resto muestra su título simple.
   lines[3] = INNER_TABS.includes(st.screen) ? ' ' + renderTabs(st, t) : ' ' + t.title('» ' + title(i, st.screen))
@@ -2642,11 +2704,14 @@ export async function runTui () {
     st.state = vc.readState()
     st.daemonUp = true
     await refreshAll(term, st)
+    checkForUpdate(st)
 
     let running = true
     while (running) {
       st.state = vc.readState()
       st.daemonUp = vc.daemonAlive()
+      // El aviso de versión nueva sale cuando no hay otra cosa preguntando.
+      if (st.update?.offer && !st.input && !st.confirm) offerUpdate(term, st)
       // ¿Se cerró sola mientras nadie miraba? Olvida su contraseña y sal de su contenido.
       await forgetAutoLocked(term, st)
       // caducar el flash a los ~4 s
@@ -2656,7 +2721,10 @@ export async function runTui () {
       const base = (st.screen === 'pairing' || st.screen === 'join' || (st.screen === 'devices' && !st.input && !st.confirm)) ? 800 : 0
       // Despertar a tiempo del bloqueo automático, además del sondeo de la pantalla.
       const wake = autoLockWakeIn(st)
-      const tick = base && wake ? Math.min(base, wake) : (base || wake)
+      let tick = base && wake ? Math.min(base, wake) : (base || wake)
+      // Mientras se mira si hay versión nueva hay que despertar sin tecla, o el aviso no
+      // saldría hasta que tocaras algo.
+      if (st.update?.checking) tick = tick ? Math.min(tick, 500) : 500
       const key = await term.readKey(tick)
 
       if (key.name === 'resize') continue
@@ -2728,7 +2796,13 @@ export async function runTui () {
     for (const id of st.unlockedHere) { try { await vc.lockProfile(id) } catch (_) {} }
     term.close()
   }
+  // TRAS ACTUALIZAR Y REINICIAR, esta pantalla también se vuelve a abrir: es el binario
+  // anterior el que sigue en memoria. Se lanza el nuevo en esta misma terminal.
+  if (st.relaunch) {
+    const r = spawnSync(process.execPath, process.argv.slice(1), { stdio: 'inherit' })
+    process.exit(r.status ?? 0)
+  }
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, settingsRows, onKeySettings, doorRows, onKeyDoors, pairCapsRows, onKeyPairCaps, onKeyDevices, draftChanges, saveCapsDrafts, onKeySecrets, loginRows, onKeyLogins, refreshLogins, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }
+export const __test = { checkForUpdate, offerUpdate, installUpdate, render, settingsRows, onKeySettings, doorRows, onKeyDoors, pairCapsRows, onKeyPairCaps, onKeyDevices, draftChanges, saveCapsDrafts, onKeySecrets, loginRows, onKeyLogins, refreshLogins, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }

package/src/tui/i18n.js

@@ -28,6 +28,15 @@ const es = {
   daemonStopped: 'DETENIDO',
   updateWaiting: (version, until) => `⬆ la ${version} espera tu aprobación hasta ${until} UTC: mira Pedidos en tu teléfono`,
   updateNotApproved: (version, when) => `⬆ se pidió permiso para la ${version} el ${when} UTC y no se aprobó: no se vuelve a pedir · dotrino-vault update`,
+  updateAvailable: (version) => `⬆ hay la versión ${version}: instálala con  dotrino-vault update`,
+  updateOffer: (version, current) => `Hay la versión ${version} y esta es la ${current}. ¿Instalarla ahora?`,
+  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',
+  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)`,
   activeVault: 'Bóveda activa: ',
   noName: '(sin nombre)',
@@ -516,6 +525,15 @@ const en = {
   daemonStopped: 'STOPPED',
   updateWaiting: (version, until) => `⬆ ${version} is waiting for your approval until ${until} UTC: check Requests on your phone`,
   updateNotApproved: (version, when) => `⬆ approval for ${version} was asked on ${when} UTC and not given: it will not ask again · dotrino-vault update`,
+  updateAvailable: (version) => `⬆ version ${version} is out: install it with  dotrino-vault update`,
+  updateOffer: (version, current) => `Version ${version} is out and this is ${current}. Install it now?`,
+  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',
+  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)`,
   activeVault: 'Active vault: ',
   tooSmall: 'Terminal too small',

package/src/update.js

@@ -16,11 +16,22 @@ import { execFileSync } 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'
+import { ipcWrite } from './ipc.js'
 
 export const REPO = 'imdotrino/dotrino-vault'
 export { isNewer, CHECK_EVERY_MS, download }
 
 /** La última release del vault. `{ ok:false, reason }` si no se pudo mirar, que NO es «al día». */
+/**
+ * DEJA DICHO QUE SE INSTALÓ una versión nueva, para que el servicio se lo cuente a quien
+ * aprueba cuando arranque con ella (`anunciarActualizacion` en daemon.js). Es el mismo
+ * marcador que deja el servicio cuando se actualiza solo, y lo dejan igual el comando
+ * `update` y la TUI.
+ */
+export function noteUpdated (dir, { from, to }) {
+  ipcWrite(path.join(dir, 'updated.json'), { v: 1, from, to, at: Date.now() })
+}
+
 export const latestRelease = (opts = {}) =>
   latestVersion({ source: 'github', repo: REPO, product: 'dotrino-vault', version: VERSION, ...opts })