@dotrino/vaultd 0.145.0 → 0.146.0

package/package.json

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

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)
@@ -158,6 +163,18 @@ function cmdStatus () {
   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) {
@@ -631,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
@@ -1794,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')
 
@@ -2174,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

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)
@@ -101,6 +102,7 @@ export async function runDaemon () {
   // 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, {
@@ -114,6 +116,9 @@ export async function runDaemon () {
       // 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()
     })
   }
@@ -1103,35 +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).
      *
-     * 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.
+     * 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.
      *
-     * 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).
+     * 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.
+     *
+     * 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 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`)
+    // 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 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)
+    // 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 = []
+    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.
@@ -1142,22 +1151,25 @@ 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) {
           const antes = pedidoSinRespuesta?.version === r.version ? pedidoSinRespuesta : null
-          pedidoSinRespuesta = { version: r.version, since: antes?.since || Date.now(), asks: (antes?.asks || 0) + 1 }
+          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 (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 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) })

package/src/notifiable.js

@@ -2,24 +2,25 @@
  * 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).
+ * 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 y sale sola de la cuenta.
+ * desinstala deja de renovarlo.
  *
- * 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.
+ * 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» (eso saltaría la aprobación): se lanza.
+ * puede recibir avisos»: se lanza.
  */
 import fs from 'node:fs'
 import path from 'node:path'

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)}`) : '')

package/src/tui/i18n.js

@@ -272,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',
@@ -719,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

@@ -263,7 +263,7 @@ 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.
+  // 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 }
@@ -1320,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.
@@ -4036,7 +4037,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return (record.members || [])
         .filter((m) => Acta.memberCan(record, m.pub, 'approve'))
         // `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.
+        // 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
@@ -4176,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 || [])
         }))
       }