@dotrino/vaultd 0.144.0 → 0.146.0

package/package.json

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

@@ -131,6 +131,11 @@ function deviceIdOf (sub) {
   return pubkeyId(sub).then((id) => id.slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'))
 }
 
+/** Lo que dijo un aprobador sobre sus avisos, para enseñarlo. No decide nada. */
+function avisosTxt (notifiedAt) {
+  return notifiedAt ? `dijo que le llegan los avisos (${fechaCorta(notifiedAt)})` : 'no ha dicho que le lleguen los avisos'
+}
+
 function cmdStatus () {
   const s = readState()
   const up = alive(s.pid)
@@ -153,6 +158,24 @@ 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')
+    // A QUIÉN SE LE PIDIÓ, y si dijo que le llegan los avisos: el que no lo ha dicho es el
+    // primer sitio donde mirar cuando nadie contesta.
+    for (const a of s.updateAsk.approvers || []) {
+      console.log('      %s  %s · %s', a.id, a.label || '(sin nombre)', avisosTxt(a.notifiedAt))
+    }
+  }
+  // CÓMO SE ACTUALIZA. Va siempre, también al día: es un ajuste y se mira aquí.
+  if (up && 'updateApproval' in s) {
+    console.log('  actualizar  : %s', s.updateApproval === null
+      ? `${R}no se pudo leer el ajuste: no se actualiza${Z} · ponlo de nuevo con:  dotrino-vault update --approval on|off`
+      : s.updateApproval ? 'pide aprobación (dotrino-vault update --approval off para que lo haga sola)'
+        : 'sola, sin pedir aprobación (dotrino-vault update --approval on para que pida)')
+  }
   const profiles = s.profiles || []
   if (profiles.length) {
     console.log('  perfiles    : %d', profiles.length)
@@ -625,6 +648,9 @@ async function cmdMembers () {
     // Solo si LEE variables (`secrets`). La llave de comunicación de la bóveda entra con
     // `cn: 'vault'` y solo `firma`, y no tiene llave de cifrado a propósito: salía marcada
     // en rojo «NO puede leer sus variables» cuando no tiene ninguna que leer.
+    // SI LE LLEGAN LOS AVISOS, en quien aprueba. No cambia a quién se le pide —se le pide a
+    // todos—: es para ver a cuál no le suena el pedido.
+    if (m.caps.includes('approve') && 'notifiedAt' in m) console.log('      %s%s%s', D, avisosTxt(m.notifiedAt), Z)
     if (m.cn && !m.canSeal && m.caps.includes('secrets')) console.log('      %ssin llave de cifrado: NO puede leer sus variables%s', R, Z)
     // QUÉ CORRE, y si cuadra con esta bóveda (CONVENCIONES §14). Sin esto una
     // incompatibilidad de versiones se ve como que ese aparato «no responde», que es el
@@ -1788,6 +1814,19 @@ async function waitForService (version, { timeoutMs = 4 * 60_000 } = {}) {
 }
 
 async function cmdUpdate (args = []) {
+  // PEDIR PERMISO PARA ACTUALIZARSE es un ajuste, apagado por defecto. Se guarda aquí y el
+  // servicio lo lee la próxima vez que mire si hay versión nueva: no hace falta reiniciarlo.
+  const iAp = args.indexOf('--approval')
+  if (iAp !== -1) {
+    const { readSettings, writeSettings } = await import('./settings.js')
+    const v = args[iAp + 1]
+    if (v === 'on' || v === 'off') writeSettings(dir, { updateApproval: v === 'on' })
+    else if (v !== undefined) { console.error('uso: dotrino-vault update --approval [on|off]'); process.exit(2) }
+    console.log(readSettings(dir).updateApproval
+      ? 'Esta bóveda pide aprobación antes de actualizarse (a los aparatos con «aprueba»).'
+      : 'Esta bóveda se actualiza sola, sin pedir aprobación.')
+    return
+  }
   const { latestRelease, assetFor, download, verifyArtifact, isNewer, isUserInstall, installUserRelease } = await import('./update.js')
   const soloMirar = args.includes('--check')
 
@@ -2168,6 +2207,9 @@ function help () {
   status | info       estado del servicio + fingerprint + el id de cada perfil
   update [--check]   trae la versión nueva (verificando la firma) y espera a que el
                      servicio la arranque · --check solo mira · --no-wait no espera
+  update --approval [on|off]
+                     el servicio se actualiza solo; con «on» antes pide aprobación a los
+                     aparatos con «aprueba» · sin valor, dice cómo está
   pair [--save <f>]   inicia un emparejamiento (QR + espera); --save escribe la invitación (.dpair)
   pair --kms <config.json>
                       el sitio que se cree (--adopt o --new-account) NACE con su clave
@@ -2380,6 +2422,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

@@ -27,6 +27,7 @@ import { capScope } from '@dotrino/identity/acta'
 import { watchBinary } from './selfupdate.js'
 import { latestRelease, isNewer, CHECK_EVERY_MS, isUserInstall, installUserRelease } from './update.js'
 import { VERSION } from './version.js'
+import { readSettings } from './settings.js'
 import crypto from 'node:crypto'
 
 const readJsonSafe = (f) => ipcRead(f, null)
@@ -92,9 +93,16 @@ 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`.
+  const ajusteActualizar = () => { try { return readSettings(dir).updateApproval } catch (_) { return null } }
   const writeState = () => {
     const cur = mgr.summary().find((p) => p.current) || {}
     ipcWrite(stateFile, {
@@ -107,6 +115,10 @@ 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 } : {}),
+      // Si para actualizarse pide permiso (`src/settings.js`). `null` = el ajuste no se
+      // pudo leer, que `status` dice distinto de «no».
+      updateApproval: ajusteActualizar(),
       current: mgr.currentId(), profiles: mgr.summary()
     })
   }
@@ -1096,19 +1108,39 @@ export async function runDaemon () {
     if (!isNewer(r.version, daemonVersion)) return
 
     /**
-     * PIDE PERMISO SOLO SI HAY A QUIÉN PEDÍRSELO (dueño, 2026-09-20).
+     * SE ACTUALIZA SOLA. PEDIR PERMISO ES UN AJUSTE (dueño, 2026-10-08).
+     *
+     * Por defecto no se le pregunta a nadie: lo que se baja se verifica contra la
+     * atestación del release antes de tocar el disco, y eso no depende de que alguien
+     * conteste. Antes se pedía permiso según quién hubiera en el acta y según si decía que
+     * le llegan los avisos; eran condiciones que explicar y que se desalineaban, y una
+     * bóveda podía quedarse atrás sin que nadie lo viera.
      *
-     * La bóveda es la pieza sensible del ecosistema: quien le cuele una actualización se
-     * lleva la maestra, y eso no se rota — se pierde la cuenta. Por eso no se actualiza
-     * sola mientras haya un aparato con `aprueba` que pueda decidirlo, igual que ya pasa
-     * con las claves privadas.
+     * Quien quiera decidir cada actualización lo enciende: `dotrino-vault update --approval
+     * on` (`src/settings.js`). Entonces se le pide a TODO el que tenga `aprueba`, reciba
+     * avisos o no, y sin un sí no se instala. Si en el acta no aprueba nadie, se actualiza
+     * igual: esperar un sí que nadie puede dar sería no actualizarse nunca.
      *
-     * Y si NO hay aprobadores, esperar un sí que nadie puede dar sería condenarla a no
-     * actualizarse nunca. Entonces se actualiza sola, que es lo que hace el resto del
-     * ecosistema (§15).
+     * Lo que cada aprobador dijo de sus avisos (`notifiedAt`, `src/notifiable.js`) no
+     * decide nada: se enseña junto al pedido sin respuesta, para ver a cuál no le suena.
      */
+    // SI EL AJUSTE NO SE PUEDE LEER, NO SE ACTUALIZA: el valor por defecto es no preguntar,
+    // así que suponerlo sería saltarse la aprobación que el dueño pidió.
+    let pedirPermiso
+    try { pedirPermiso = readSettings(dir).updateApproval } catch (e) {
+      console.log(`[vault] version ${r.version} is out, but the settings could not be read (${e?.message || e}) · not updating`)
+      return
+    }
+    // Y si hay que pedir y no se puede saber a quién, tampoco: lista vacía sería «nadie
+    // aprueba, adelante», el repliegue que abre la puerta justo cuando algo se rompió.
     let quienAprueba = []
-    try { quienAprueba = (await mgr.current()?.approvers?.()) || [] } catch (_) {}
+    if (pedirPermiso) {
+      try { quienAprueba = 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
+      }
+    }
+    const conAvisos = quienAprueba.filter((a) => a.notifiedAt).length
 
     // 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.
@@ -1119,15 +1151,27 @@ export async function runDaemon () {
     if (actualizando) return
     actualizando = true
     try {
-      // PIDE PERMISO SOLO SI HAY A QUIÉN PEDÍRSELO (dueño, 2026-09-20); sin aprobadores
-      // no se necesita aprobación (dueño, 2026-09-24).
       if (quienAprueba.length) {
-        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · asking one of ${quienAprueba.length} approver(s)`)
+        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · asking one of ${quienAprueba.length} approver(s) · ${conAvisos} of them said notifications reach it`)
         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,
+            // A QUIÉN SE LE PIDIÓ, y si dijo que le llegan los avisos: es lo que hay que mirar
+            // cuando nadie contesta.
+            approvers: quienAprueba.map((a) => ({ id: a.id, label: a.label, notifiedAt: a.notifiedAt }))
+          }
+          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 (pedirPermiso) {
+        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · approval is on but no approver in the record: 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`)
+        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · 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,76 @@
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * NO DECIDE NADA: SE ENSEÑA (dueño, 2026-10-08). Un día decidió si la bóveda pedía permiso
+ * para actualizarse —sin nadie que lo hubiera dicho, se actualizaba sola— y se quitó: era
+ * una condición más, y el silencio de un aprobador abría la puerta. Quién aprueba lo dice
+ * el acta y nada más; los avisos salen a todos los que tienen `approve`, lo hayan dicho o
+ * no. Esto sirve para VER a cuál no le está sonando el pedido (`members`, `status`, la
+ * consola).
+ *
+ * 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»: 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/settings.js

@@ -0,0 +1,37 @@
+/**
+ * AJUSTES DE ESTA BÓVEDA: lo que el dueño elige distinto del comportamiento por defecto.
+ *
+ * Hoy es uno: `updateApproval`. Por defecto la bóveda se actualiza sola (lo que baja se
+ * verifica contra la atestación del release, se pida permiso o no); con `updateApproval:
+ * true` antes le pide permiso a los aparatos con `approve` (dueño, 2026-10-08).
+ *
+ * Va por el canal local (`ipc.js`): lo escribe la CLI (`dotrino-vault update --approval
+ * on|off`) y lo lee el daemon cada vez que mira si hay versión nueva, sin señal ni reinicio.
+ *
+ * UN ARCHIVO QUE EXISTE Y NO SE PUEDE LEER NO ES «EL VALOR POR DEFECTO»: el por defecto es
+ * actualizarse sin preguntar, así que tragarse el fallo sería saltarse la aprobación que el
+ * dueño pidió justo cuando algo se rompió. Se lanza.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { ipcRead, ipcWrite } from './ipc.js'
+
+export const SETTINGS_FILE = 'settings.json'
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/** @returns {{ updateApproval: boolean }} */
+export function readSettings (dir) {
+  const file = path.join(dir, SETTINGS_FILE)
+  if (!fs.existsSync(file)) return { updateApproval: false }
+  const raw = ipcRead(file, null)
+  if (!raw || typeof raw !== 'object' || typeof raw.updateApproval !== 'boolean') {
+    throw fail('settings-unreadable', `${SETTINGS_FILE} exists but cannot be read`)
+  }
+  return { updateApproval: raw.updateApproval }
+}
+
+export function writeSettings (dir, { updateApproval }) {
+  if (typeof updateApproval !== 'boolean') throw fail('bad-setting', 'updateApproval must be true or false')
+  ipcWrite(path.join(dir, SETTINGS_FILE), { v: 1, updateApproval })
+}

package/src/tui/app.js

@@ -155,7 +155,9 @@ function mergeMembersAndCerts (members, issued) {
       noAccess: !cert && !m.isMaster && !m.cn,
       // QUÉ CORRE ESE APARATO (CONVENCIONES §14). Lo apunta la bóveda cuando le habla, así
       // que aquí solo hay que dejarlo pasar — que es justo lo que le faltaba a `addedAt`.
-      running: m.running || null
+      running: m.running || null,
+      // SI LE LLEGAN LOS AVISOS, solo en quien aprueba (`undefined` = no aprueba, no se pinta).
+      notifiedAt: (m.caps || []).includes('approve') && 'notifiedAt' in m ? m.notifiedAt : undefined
     }
   })
 }
@@ -386,6 +388,9 @@ function deviceRows (st, t) {
     const extra = (d.certCount > 1 ? t.muted(`  certs:${d.certCount}`) : '') +
       (vars ? t.muted(`  vars:${vars}`) : '') +
       corre +
+      // En quien aprueba: si dijo que le llegan los avisos. No cambia a quién se le pide
+      // (a todos); deja ver a cuál no le suena el pedido. Es un dato, va en gris.
+      (d.notifiedAt === undefined ? '' : t.muted(`  ${d.notifiedAt ? i.notifyYes : i.notifyUnknown}`)) +
       // EN DEUDA: en el acta y sin poder abrir lo suyo. Va en color de aviso al lado de
       // sus variables, que es donde se mira cuando algo no arranca.
       (debt ? t.warn(`  ${i.deviceDebt(debt)}`) : '')
@@ -2438,6 +2443,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)',
@@ -271,6 +272,8 @@ const es = {
   revokedCount: (n) => `  Revocados: ${n}`,
   startingPairing: 'Iniciando emparejamiento…',
   deviceSince: 'desde',
+  notifyYes: 'le llegan avisos',
+  notifyUnknown: 'no ha dicho si le llegan avisos',
   nameDeviceLabel: '¿Cómo se va a llamar este aparato?',
   nameDeviceHint: 'Enter para dejar que lo diga él (usará tu apodo, y así no se distinguen)',
   noPending: 'No hay ningún dispositivo pendiente',
@@ -498,6 +501,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',
@@ -717,6 +721,8 @@ const en = {
   revokedCount: (n) => `  Revoked: ${n}`,
   startingPairing: 'Starting pairing…',
   deviceSince: 'since',
+  notifyYes: 'gets notifications',
+  notifyUnknown: 'has not said if notifications reach it',
   nameDeviceLabel: 'What will this device be called?',
   nameDeviceHint: 'Enter to let it say (it will use your nickname, and then they all look alike)',
   noPending: 'No device is waiting',

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`). No decide nada: se enseña.
+  const notifiable = openNotifiable({ dir, atRest: passwordsAtRest })
   const readPasswordsFile = () => {
     try { return JSON.parse(passwordsAtRest.decrypt(fs.readFileSync(passwordsFile, 'utf8'))) } catch (_) { return null }
   }
@@ -1317,7 +1320,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // que arrancamos», que es distinto de «no declara» — y se dice distinto.
     const devices = await Promise.all(issued.map(async (x) => ({
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce,
-      running: x.sub ? versionDe(x.sub) : null
+      running: x.sub ? versionDe(x.sub) : null,
+      notifiedAt: x.sub ? notifiable.since(x.sub) : null
     })))
     // LA SUBACTA VIAJA CON EL ACTA. Es la mitad de «se comparte entre todos los
     // dispositivos»: sin esto, una renuncia sin sellar solo la respeta esta máquina.
@@ -1763,6 +1767,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 +4036,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ó). No decide si se pide: se enseña junto al pedido sin respuesta.
+        .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.
@@ -4166,6 +4177,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         members: (r?.members || []).map((m) => ({
           ...m,
           running: versionDe(m.pub),
+          // Cuándo dijo que le llegan los avisos (null = no lo ha dicho, o caducó). Solo
+          // tiene sentido en quien aprueba, y es un dato para enseñar: no decide nada.
+          notifiedAt: notifiable.since(m.pub),
           renounced: subacta.forMember(m.pub).flatMap((e) => e.caps || [])
         }))
       }