@dotrino/vaultd 0.156.0 → 0.157.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 = {
@@ -37,7 +40,7 @@ const es = {
   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 +193,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 +491,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 +507,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).',
@@ -534,7 +545,7 @@ const en = {
   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 +678,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 +945,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 +960,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

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