@dotrino/vaultd 0.144.0 → 0.145.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.144.0",
+  "version": "0.145.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": {
@@ -25,7 +25,7 @@
     "@dotrino/identity": "^0.107.1",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.17.0",
-    "@dotrino/proxy-client": "0.30.0",
+    "@dotrino/proxy-client": "0.30.1",
     "@dotrino/roadmap": "0.3.19",
     "@dotrino/store": "0.11.0",
     "@dotrino/update": "0.2.2",

package/src/ctl.js

@@ -153,6 +153,12 @@ function cmdStatus () {
     console.log('  %s⬆ hay %s publicada%s (esta es la %s) · tráela con:  dotrino-vault update',
       B, s.latest.version, Z, VERSION)
   }
+  // …Y LLEVA DÍAS PIDIENDO PERMISO SIN RESPUESTA. Es un bloqueo que desde fuera no se ve:
+  // la bóveda parece normal y simplemente no se actualiza.
+  if (s.updateAsk?.version && isNewer(s.updateAsk.version, VERSION)) {
+    console.log('    pidió permiso para instalarla %s (%d %s) y nadie lo ha aprobado · mira Pedidos en tu teléfono',
+      hace(s.updateAsk.since), s.updateAsk.asks, s.updateAsk.asks === 1 ? 'vez' : 'veces')
+  }
   const profiles = s.profiles || []
   if (profiles.length) {
     console.log('  perfiles    : %d', profiles.length)
@@ -2380,6 +2386,14 @@ async function cmdReplica (args) {
   process.exit(2)
 }
 
+/** «hace 3 días», «hace 5 horas»: para decir desde cuándo espera algo. */
+function hace (ms) {
+  const h = Math.max(0, Math.floor((Date.now() - ms) / 3600000))
+  if (h < 1) return 'hace menos de una hora'
+  if (h < 48) return `hace ${h} ${h === 1 ? 'hora' : 'horas'}`
+  return `hace ${Math.floor(h / 24)} días`
+}
+
 export async function runCtl (argv) {
   const [cmd, ...rest] = takeProfileFlag(argv)
   // `--help` EN CUALQUIER COMANDO ENSEÑA LA AYUDA Y NO HACE NADA. Ningún subcomando lo miraba,

package/src/daemon.js

@@ -92,6 +92,12 @@ export async function runDaemon () {
   const daemonVersion = VERSION
   /** `{ version, checkedAt }` de la última consulta que salió bien, o null si aún ninguna. */
   let ultimaPublicada = null
+  /**
+   * EL PEDIDO DE ACTUALIZACIÓN QUE NADIE HA CONTESTADO: `{ version, since, asks }`, o null.
+   * Va en la foto para que `status` y la TUI lo DIGAN. Sin esto, una bóveda que lleva días
+   * pidiendo permiso y sin respuesta se veía igual que una al día.
+   */
+  let pedidoSinRespuesta = null
   // Los campos de la raíz (fingerprint/iss) son los del perfil ACTIVO: los leen el
   // instalador y la web, que son anteriores al multi-perfil. La lista completa va
   // en `profiles`.
@@ -107,6 +113,7 @@ export async function runDaemon () {
       // sin salir a la red: una pantalla de estado tiene que contestar al instante y
       // también sin conexión.
       ...(ultimaPublicada ? { latest: ultimaPublicada } : {}),
+      ...(pedidoSinRespuesta ? { updateAsk: pedidoSinRespuesta } : {}),
       current: mgr.currentId(), profiles: mgr.summary()
     })
   }
@@ -1107,8 +1114,24 @@ export async function runDaemon () {
      * actualizarse nunca. Entonces se actualiza sola, que es lo que hace el resto del
      * ecosistema (§15).
      */
-    let quienAprueba = []
-    try { quienAprueba = (await mgr.current()?.approvers?.()) || [] } catch (_) {}
+    // SI NO SE PUEDE SABER QUIÉN APRUEBA, NO SE ACTUALIZA. Antes un fallo aquí dejaba la
+    // lista vacía, y lista vacía es «nadie aprueba, adelante»: el repliegue que abre la
+    // puerta justo cuando algo se rompió. Se dice y se vuelve a mirar en la próxima pasada.
+    let enElActa
+    try { enElActa = await mgr.current().approvers() } catch (e) {
+      console.log(`[vault] version ${r.version} is out, but the approvers could not be read (${e?.message || e}) · not updating`)
+      return
+    }
+    /**
+     * Y SOLO CUENTA EL APROBADOR QUE PUEDE ENTERARSE (dueño, 2026-10-07). Uno que no recibe
+     * avisos no ve el pedido si no abre la app por su cuenta: la bóveda pedía cada día y se
+     * quedaba atrás para siempre, que es el mismo bloqueo de «sin aprobadores» un paso
+     * después. Lo dice el propio aparato, firmado, y caduca (`src/notifiable.js`).
+     *
+     * Esto vale SOLO para actualizarse. Lo que se instala se verifica igual contra la
+     * atestación del release, se haya pedido permiso o no.
+     */
+    const quienAprueba = enElActa.filter((a) => a.notifiedAt)
 
     // INSTALADA COMO PAQUETE DEL SISTEMA (.deb 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.
@@ -1124,10 +1147,19 @@ export async function runDaemon () {
       if (quienAprueba.length) {
         console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · asking one of ${quienAprueba.length} approver(s)`)
         const si = await mgr.current().askUpdateApproval({ version: r.version })
-        if (!si) { console.log(`[vault] update to ${r.version}: not approved (denied or expired) · it will ask again`); return }
+        if (!si) {
+          const antes = pedidoSinRespuesta?.version === r.version ? pedidoSinRespuesta : null
+          pedidoSinRespuesta = { version: r.version, since: antes?.since || Date.now(), asks: (antes?.asks || 0) + 1 }
+          writeState()
+          console.log(`[vault] update to ${r.version}: not approved (denied or expired) · asked ${pedidoSinRespuesta.asks} time(s) since ${new Date(pedidoSinRespuesta.since).toISOString()} · it will ask again`)
+          return
+        }
+      } else if (enElActa.length) {
+        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · ${enElActa.length} approver(s) in the record but none receives notifications: updating on its own`)
       } else {
         console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · no approver in the record: updating on its own`)
       }
+      if (pedidoSinRespuesta) { pedidoSinRespuesta = null; writeState() }
       const res = await installUserRelease(r, { log: (m) => console.log(m) })
       if (!res.ok) {
         // Lo que NO cuadra no se instala, y se dice por qué: el archivo queda a mano.

package/src/notifiable.js

@@ -0,0 +1,75 @@
+/**
+ * QUÉ APROBADORES PUEDEN RECIBIR UN AVISO: lo dice cada uno, y caduca.
+ *
+ * Un aparato con `approve` que no recibe avisos es un aprobador solo en el papel: el pedido
+ * no le suena y solo lo ve si abre la app por su cuenta. Para la ACTUALIZACIÓN eso era un
+ * bloqueo mudo — la bóveda pedía cada día, nadie se enteraba y se quedaba atrás para siempre
+ * (dueño, 2026-10-07).
+ *
+ * Así que el aprobador lo declara: al pedir su lista de pedidos (`op: 'approvals'`, que ya
+ * manda firmado cada vez que se abre) dice `notify: true` si tiene los avisos encendidos.
+ * Aquí se apunta CUÁNDO lo dijo por última vez, y vale `NOTIFIABLE_TTL_MS`: una app que se
+ * desinstala deja de renovarlo y sale sola de la cuenta.
+ *
+ * SOLO DECIDE LA ACTUALIZACIÓN. Las claves, las contraseñas y guardar variables siguen
+ * pidiendo aprobación mientras haya un aparato con `approve` en el acta, pueda o no recibir
+ * avisos: ahí «nadie se entera» se resuelve esperando, no entregando.
+ *
+ * Y NO SE LE PREGUNTA AL PROXIO, que es quien guarda las suscripciones: es la pieza de la
+ * que el diseño no se fía, y creerle sería dejarle decidir cuándo no hace falta permiso.
+ *
+ * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer NO es «nadie
+ * puede recibir avisos» (eso saltaría la aprobación): se lanza.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+
+export const NOTIFIABLE_FILE = 'notifiable.json'
+/** Cuánto vale un «puedo recibir avisos» sin renovarse. */
+export const NOTIFIABLE_TTL_MS = 30 * 24 * 60 * 60 * 1000
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * @param {{ dir: string, atRest: { encrypt: (s: string) => string, decrypt: (s: string) => string }, now?: () => number }} opts
+ */
+export function openNotifiable ({ dir, atRest, now = Date.now }) {
+  const file = path.join(dir, NOTIFIABLE_FILE)
+  /** pub → ms de la última vez que dijo que sí */
+  const items = load()
+
+  function load () {
+    let raw
+    try { raw = fs.readFileSync(file, 'utf8') } catch (e) {
+      if (e.code === 'ENOENT') return new Map()
+      throw fail('notifiable-unreadable', `cannot read ${NOTIFIABLE_FILE}: ${e.message}`)
+    }
+    let d
+    try { d = JSON.parse(atRest.decrypt(raw)) } catch (e) { throw fail('notifiable-unreadable', `${NOTIFIABLE_FILE} cannot be opened: ${e.message}`) }
+    if (d?.v !== 1 || !d.items || typeof d.items !== 'object') throw fail('notifiable-unreadable', `${NOTIFIABLE_FILE} has an unknown shape`)
+    return new Map(Object.entries(d.items))
+  }
+
+  function save () {
+    const tmp = file + '.tmp'
+    fs.writeFileSync(tmp, atRest.encrypt(JSON.stringify({ v: 1, items: Object.fromEntries(items) })), { mode: 0o600 })
+    fs.renameSync(tmp, file)
+  }
+
+  return {
+    /**
+     * Lo que acaba de decir un aprobador. `true` lo apunta (o lo renueva); `false` lo quita
+     * ya, sin esperar a que caduque. Cualquier otra cosa no dice nada y no cambia nada: un
+     * cliente viejo, que no manda el campo, no borra lo que dijo uno nuevo.
+     */
+    declare (pub, canNotify) {
+      if (typeof pub !== 'string' || !pub) throw fail('bad-pub', 'declare: a device key is required')
+      if (canNotify === true) { items.set(pub, now()); save() } else if (canNotify === false && items.delete(pub)) save()
+    },
+    /** Cuándo lo dijo por última vez, o `null` si nunca o si ya caducó. */
+    since (pub) {
+      const t = items.get(pub)
+      return typeof t === 'number' && now() - t < NOTIFIABLE_TTL_MS ? t : null
+    }
+  }
+}

package/src/tui/app.js

@@ -2438,6 +2438,11 @@ function render (term, st) {
   // instalar, peor: el daemon se queda con el binario viejo, ya borrado, y hay dos copias
   // en RAM). `status` ya lo avisa; aquí también, que es donde uno se queda mirando.
   lines[2] = (up && s?.version && VERSION !== 'dev' && s.version !== VERSION) ? ' ' + t.warn(i.daemonStale(s.version, VERSION)) : ''
+  // Una actualización que lleva tiempo pidiendo permiso sin respuesta: la bóveda parece
+  // normal y simplemente no se actualiza, así que se dice aquí.
+  if (!lines[2] && up && s?.updateAsk?.version) {
+    lines[2] = ' ' + t.warn(i.updateUnanswered(s.updateAsk.version, Math.floor((Date.now() - s.updateAsk.since) / 86400000)))
+  }
   // 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))

package/src/tui/i18n.js

@@ -26,6 +26,7 @@ const es = {
   // encabezado / estado
   daemonRunning: 'corriendo',
   daemonStopped: 'DETENIDO',
+  updateUnanswered: (version, days) => `⬆ la ${version} espera tu aprobación desde hace ${days < 1 ? 'menos de un día' : days === 1 ? '1 día' : days + ' días'}: mira Pedidos en tu teléfono`,
   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)',
@@ -498,6 +499,7 @@ const en = {
 
   daemonRunning: 'running',
   daemonStopped: 'STOPPED',
+  updateUnanswered: (version, days) => `⬆ ${version} has been waiting for your approval for ${days < 1 ? 'less than a day' : days === 1 ? '1 day' : days + ' days'}: check Requests on your phone`,
   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/vault.js

@@ -30,6 +30,7 @@ import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './thr
 import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER } from './secretsStore.js'
 import { openSubacta } from './subacta.js'
 import { openBlocked } from './blocked.js'
+import { openNotifiable } from './notifiable.js'
 import { makeEphemeralKey, openSealed } from '../lib/src/sealed.js'
 import { VERSION } from './version.js'
 import { declare as compatDeclare, check as compatCheck, annotate as compatAnnotate } from '@dotrino/compat'
@@ -262,6 +263,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const passwordsAtRest = atRestFor(dir)
   // Los aparatos BLOQUEADOS por un aprobador (`src/blocked.js`). Cifrado en reposo como lo demás.
   const blocked = openBlocked({ dir, atRest: passwordsAtRest })
+  // Qué aprobadores dijeron que pueden recibir avisos (`src/notifiable.js`): solo lo mira la actualización.
+  const notifiable = openNotifiable({ dir, atRest: passwordsAtRest })
   const readPasswordsFile = () => {
     try { return JSON.parse(passwordsAtRest.decrypt(fs.readFileSync(passwordsFile, 'utf8'))) } catch (_) { return null }
   }
@@ -1763,6 +1766,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       body = { ...body, ts: Date.now() }
       reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body) })
     }
+    // AL PEDIR SU LISTA, EL APROBADOR DICE SI LE LLEGAN LOS AVISOS (`notify`). Va dentro de lo
+    // que ya firma, así que no hay mensaje nuevo ni nada que el proxio pueda inventar.
+    if (op === 'approvals' && typeof p.data?.notify === 'boolean') {
+      try { notifiable.declare(chk.device, p.data.notify) } catch (e) { log(`[vault] could not record whether ${by || '????-????'} can be notified: ${e.message}`) }
+    }
     if (op === 'approvals') return answer({ op: 'approvals', items: await conContextoSellado(approvals.list(), chk.device, record) })
     // LO QUE YA ESTÁ APROBADO SE VE Y SE CORTA DESDE DONDE SE APROBÓ. Una concesión que se
     // renueva con cada uso puede durar indefinidamente: si no se puede mirar ni quitar desde
@@ -4027,7 +4035,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (!record) return []
       return (record.members || [])
         .filter((m) => Acta.memberCan(record, m.pub, 'approve'))
-        .map((m) => ({ id: m.id, label: m.label || '', pub: m.pub }))
+        // `notifiedAt`: cuándo dijo por última vez que le llegan los avisos (null = no lo ha
+        // dicho, o caducó). Solo lo usa la actualización para saber si hay a quién pedirle.
+        .map((m) => ({ id: m.id, label: m.label || '', pub: m.pub, notifiedAt: notifiable.since(m.pub) }))
     },
     // La bóveda de contraseñas (`passwords.js`). Aquí SÍ se lista: es donde está la
     // llave. Lo que no puede es listarla un aparato.