@dotrino/vaultd 0.147.0 → 0.148.0

package/lib/src/service.js

@@ -707,28 +707,82 @@ export async function askUpdateApproval ({ product, version, from = null, dir, p
  * @param {object} o  `product`, `version`, `from` y la conexión, como en `askUpdateApproval`
  * @returns {Promise<{ ok: true }>}
  */
-export async function reportUpdated ({ product, version, from = null, dir, proxyUrl, masterPubkey, device, cert, timeoutMs = 30000 } = {}) {
+export function reportUpdated (o = {}) { return reportToVault('update-done', o) }
+
+/**
+ * HAY VERSIÓN NUEVA Y NO PUEDO INSTALARLA SOLO: necesita permisos de administrador (el
+ * servicio está instalado para todo el sistema, no como usuario). El aparato se lo dice a su
+ * bóveda y ella avisa a quien aprueba, que es quien puede ir a esa máquina e instalarla a
+ * mano (dueño, 2026-10-08). No instala nada ni pide permiso: solo avisa.
+ *
+ * Mismos parámetros y errores que `reportUpdated`. Avisar una sola vez por versión es cosa
+ * de quien llama.
+ * @returns {Promise<{ ok: true }>}
+ */
+export function reportUpdateNeedsRoot (o = {}) { return reportToVault('update-needs-root', o) }
+
+/**
+ * LOS TRES GANCHOS DE ACTUALIZACIÓN, YA ARMADOS para pasárselos a `watchSelfUpdateNpm` de
+ * `@dotrino/update/npm`: una pieza, para que cada agente no lo escriba por su cuenta. No
+ * depende de ese paquete: solo devuelve funciones con la forma que él espera.
+ *
+ *   · `mayUpdate({ version, from })` → pregunta a la bóveda y devuelve si se puede. Si la
+ *     bóveda NO CONTESTA, lanza: para quien llama eso es «no pude preguntar» y se reintenta.
+ *     Si el pedido VENCE sin respuesta devuelve `false`: vencido es no, y no se repite.
+ *   · `onUpdated({ version, from })` → le dice a la bóveda que se actualizó. Deja pasar el
+ *     error, para que quien llama conserve su marcador y lo reintente.
+ *   · `onNeedsRoot({ version, from })` → le dice que hay versión nueva y necesita permisos de
+ *     administrador. Igual.
+ *
+ * @param {object} o
+ * @param {string} o.product  nombre npm de la pieza
+ * @param {(m: string) => void} [o.log]
+ *   …y la conexión como en los demás: `dir`, o `proxyUrl` + `masterPubkey` + `device` + `cert`.
+ * @returns {{ mayUpdate: (u: { version: string, from?: string }) => Promise<boolean>,
+ *   onUpdated: (u: { version: string, from?: string }) => Promise<void>,
+ *   onNeedsRoot: (u: { version: string, from?: string }) => Promise<void> }}
+ */
+export function vaultUpdateHooks ({ product, log = () => {}, dir, proxyUrl, masterPubkey, device, cert, _ask = askUpdateApproval, _done = reportUpdated, _root = reportUpdateNeedsRoot } = {}) {
+  if (typeof product !== 'string' || !product) throw new Error('vaultUpdateHooks: needs product')
+  const conn = { dir, proxyUrl, masterPubkey, device, cert }
+  return {
+    async mayUpdate ({ version, from = null } = {}) {
+      let r
+      try { r = await _ask({ ...conn, product, version, from, onPending: () => log(`[update] ${product} ${version}: waiting for approval on your vault`) }) } catch (e) {
+        if (e?.code === 'unanswered') { log(`[update] ${product} ${version}: nobody answered in time, so it is a no`); return false }
+        throw e
+      }
+      log(`[update] ${product} ${version}: ${r.ok ? (r.asked ? 'approved' : 'no approval needed') : 'not approved'}`)
+      return r.ok === true
+    },
+    async onUpdated ({ version, from = null } = {}) { await _done({ ...conn, product, version, from }) },
+    async onNeedsRoot ({ version, from = null } = {}) { await _root({ ...conn, product, version, from }) }
+  }
+}
+
+/** Lo común de los dos avisos: firmar, mandar, y comprobar quién contesta. */
+async function reportToVault (op, { product, version, from = null, dir, proxyUrl, masterPubkey, device, cert, timeoutMs = 30000 } = {}) {
   const saved = dir ? readServiceIdentity(dir) : null
   proxyUrl = proxyUrl || saved?.proxy
   masterPubkey = masterPubkey || saved?.iss
   device = device || saved?.device
   cert = cert || saved?.cert
-  if (typeof product !== 'string' || !product || typeof version !== 'string' || !version) throw new Error('reportUpdated: needs product and version')
+  if (typeof product !== 'string' || !product || typeof version !== 'string' || !version) throw new Error(`${op}: needs product and version`)
   if (!proxyUrl || !masterPubkey || !device || !cert) throw new Error('service not enrolled')
   const client = await freshClient(proxyUrl, 20000, masterPubkey)
   try {
     await identifyAsService(client, device)
-    const data = { op: 'update-done', product, version, ...(typeof from === 'string' && from ? { from } : {}), publickey: device.publickey, ts: Date.now() }
+    const data = { op, product, version, ...(typeof from === 'string' && from ? { from } : {}), publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
-    const pending = waitForMsg(client, (p) => p.type === MSG.ERROR || (p.type === MSG.SECRETS_RESULT && p.body?.op === 'update-done' && p.body.product === product && p.body.version === version), timeoutMs)
+    const pending = waitForMsg(client, (p) => p.type === MSG.ERROR || (p.type === MSG.SECRETS_RESULT && p.body?.op === op && p.body.product === product && p.body.version === version), timeoutMs)
     client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
     const res = await pending.catch((e) => {
-      if (/timeout/.test(e.message)) throw Object.assign(new Error('update-done: the vault did not answer'), { code: 'vault-no-reply' })
+      if (/timeout/.test(e.message)) throw Object.assign(new Error(`${op}: the vault did not answer`), { code: 'vault-no-reply' })
       throw e
     })
     if (res.type === MSG.ERROR) throw vaultError(res)
     await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey, knownSeq: saved?.actaSeq ?? null })
-    if (res.body.ok !== true) throw new Error('malformed update-done reply')
+    if (res.body.ok !== true) throw new Error(`malformed ${op} reply`)
     return { ok: true }
   } finally { client.close() }
 }

package/package.json

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

@@ -28,7 +28,7 @@ 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 { approversOfAll, firstYes, readAsked, writeAsked, clearAsked, shouldAsk, resultOfNo } from './updateApproval.js'
+import { approversOfAll, firstYes, readAsked, writeAsked, clearAsked, shouldAsk, resultOfNo, readRootTold, writeRootTold, shouldTellRoot } from './updateApproval.js'
 import { UPDATE_TTL_MS } from './approvals.js'
 import crypto from 'node:crypto'
 
@@ -1161,6 +1161,25 @@ export async function runDaemon () {
     // proceso no puede tocarlo. Se dice, con las dos salidas, y no se intenta nada.
     if (!isUserInstall()) {
       console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · installed as a system package, so it cannot update itself: \`dotrino-vault update\` (needs sudo), or move to a user install with the tarball's install.sh`)
+      // …Y SE LE DICE A QUIEN APRUEBA, en todos los perfiles (dueño, 2026-10-08: «si se
+      // requiere root por algún motivo, simplemente se notifica al aprobador que hay
+      // actualización y necesita root»). El log no lo lee nadie; el teléfono sí. UNA vez por
+      // versión, apuntado para que un reinicio no lo repita (`update-root-told.json`).
+      let dicho
+      try { dicho = readRootTold(dir) } catch (e) {
+        console.log(`[vault] update: whether the approvers were already told could not be read (${e?.message || e}) · not telling them again`)
+        return
+      }
+      if (shouldTellRoot(dicho, r.version, isNewer) && avisandoRoot !== r.version) {
+        avisandoRoot = r.version
+        contarATodos({ ev: 'update-needs-root', version: r.version, from: daemonVersion }, ({ todos, alguno }) => {
+          avisandoRoot = null
+          // Con que salió en algún perfil ya está dicho: repetirlo mañana a los que sí lo
+          // oyeron por uno que no pudo sería timbrar de más.
+          if (todos || alguno) { try { writeRootTold(dir, { version: r.version, at: Date.now() }) } catch (e) { console.log(`[vault] update: could not note that the approvers were told: ${e.message}`) } }
+          else console.log(`[vault] update: the approvers could not be told that ${r.version} needs administrator rights · it will try again on the next check`)
+        })
+      }
       return
     }
     if (actualizando) return
@@ -1245,6 +1264,7 @@ export async function runDaemon () {
   }
   let actualizando = false
   let aprobada = null
+  let avisandoRoot = null
 
   /**
    * «ME ACTUALICÉ»: se lo cuenta a quien aprueba la versión NUEVA, ya corriendo (dueño,
@@ -1263,6 +1283,18 @@ export async function runDaemon () {
       if (isNewer(daemonVersion, m.to)) rm(updatedFile)
       return   // todavía no corre esa versión: se anuncia cuando arranque
     }
+    contarATodos({ version: m.to, from: typeof m.from === 'string' ? m.from : null }, ({ todos }) => {
+      if (todos) rm(updatedFile)
+      else console.log('[vault] update: some approvers were not told · it will try again on the next start')
+    })
+  }
+
+  /**
+   * Cuenta algo a quien aprueba en TODOS los perfiles en marcha (`announceUpdate`), cada uno
+   * en cuanto está identificado en el proxio: reintenta cada pocos segundos hasta que salió
+   * en todos o se agotan los intentos. `alTerminar({ todos, alguno })`.
+   */
+  function contarATodos (aviso, alTerminar) {
     const hechos = new Set()
     let intentos = 0
     const intento = async () => {
@@ -1271,13 +1303,13 @@ export async function runDaemon () {
       for (const p of perfilesEnMarcha()) {
         if (hechos.has(p.id)) continue
         if (!p.vault.isIdentified?.()) { falta = true; continue }
-        try { await p.vault.announceUpdate({ version: m.to, from: typeof m.from === 'string' ? m.from : null }); hechos.add(p.id) } catch (e) {
+        try { await p.vault.announceUpdate(aviso); hechos.add(p.id) } catch (e) {
           falta = true
           if (intentos === 1 || intentos === ANNOUNCE_TRIES) console.log(`[vault] update: profile ${p.name} could not tell its approvers yet: ${e?.message || e}`)
         }
       }
-      if (!falta) { rm(updatedFile); return }
-      if (intentos >= ANNOUNCE_TRIES) { console.log('[vault] update: some approvers were not told · it will try again on the next start'); return }
+      if (!falta) return alTerminar({ todos: true, alguno: hechos.size > 0 })
+      if (intentos >= ANNOUNCE_TRIES) return alTerminar({ todos: false, alguno: hechos.size > 0 })
       setTimeout(intento, ANNOUNCE_EVERY_MS).unref?.()
     }
     setTimeout(intento, ANNOUNCE_EVERY_MS).unref?.()

package/src/notices.js

@@ -1,7 +1,8 @@
 /**
  * LO QUE LA BÓVEDA TIENE QUE CONTARLE A QUIEN APRUEBA, y que no es un pedido.
  *
- * Hoy es uno: «me actualicé» —la bóveda o uno de sus aparatos— (`ev: 'updated'`, dueño 2026-10-08: «las actualizaciones, que se
+ * Son dos, de la bóveda o de uno de sus aparatos: «me actualicé» y «hay versión nueva y
+ * necesita permisos de administrador: instálala a mano» (`update-needs-root`). (`ev: 'updated'`, dueño 2026-10-08: «las actualizaciones, que se
  * envíe una notificación de que ocurrieron a los aprobadores»). Sale como aviso por el
  * proxio, pero el timbre de una app nativa llega VACÍO —lo leen Google y Apple—, así que la
  * app pregunta por su lista (`op: 'approvals'`) y lo lee de aquí, en `notices`.
@@ -18,6 +19,8 @@ import crypto from 'node:crypto'
 export const NOTICES_FILE = 'notices.json'
 /** Cuánto se sigue contando un aviso. */
 export const NOTICE_TTL_MS = 24 * 60 * 60 * 1000
+/** Los avisos que existen. */
+export const NOTICE_EVS = ['updated', 'update-needs-root']
 
 const fail = (code, message) => Object.assign(new Error(message), { code })
 
@@ -47,14 +50,17 @@ export function openNotices ({ dir, atRest, now = Date.now }) {
 
   return {
     /**
-     * Apunta que algo se actualizó. Devuelve el aviso tal como viaja. `product`: qué
-     * (`@dotrino/vaultd` es la propia bóveda); `deviceId`/`label`: el aparato, si fue uno.
+     * Apunta un aviso y lo devuelve tal como viaja. `ev`: `updated` (se actualizó) o
+     * `update-needs-root` (hay versión nueva y hay que instalarla a mano, con permisos de
+     * administrador). `product`: qué (`@dotrino/vaultd` es la propia bóveda);
+     * `deviceId`/`label`: el aparato, si fue uno.
      */
-    updated ({ version, from = null, product = '@dotrino/vaultd', deviceId = null, label = null }) {
-      if (typeof version !== 'string' || !version) throw fail('bad-notice', 'updated: a version is required')
-      if (typeof product !== 'string' || !product) throw fail('bad-notice', 'updated: a product is required')
+    add (ev, { version, from = null, product = '@dotrino/vaultd', deviceId = null, label = null }) {
+      if (!NOTICE_EVS.includes(ev)) throw fail('bad-notice', `unknown notice: ${ev}`)
+      if (typeof version !== 'string' || !version) throw fail('bad-notice', `${ev}: a version is required`)
+      if (typeof product !== 'string' || !product) throw fail('bad-notice', `${ev}: a product is required`)
       const n = {
-        id: crypto.randomBytes(8).toString('hex'), ev: 'updated', product, version, from: typeof from === 'string' ? from : null,
+        id: crypto.randomBytes(8).toString('hex'), ev, product, version, from: typeof from === 'string' ? from : null,
         ...(typeof deviceId === 'string' && deviceId ? { deviceId, label: typeof label === 'string' ? label : '' } : {}),
         ts: now()
       }
@@ -62,6 +68,7 @@ export function openNotices ({ dir, atRest, now = Date.now }) {
       save()
       return n
     },
+    updated (o) { return this.add('updated', o) },
     /** Los avisos vivos, del más viejo al más nuevo. */
     list () { return items.filter(alive).map((n) => ({ ...n })) }
   }

package/src/updateApproval.js

@@ -108,3 +108,32 @@ export function shouldAsk (asked, version, isNewer) {
 export function resultOfNo (askedAt, ttlMs, now = Date.now()) {
   return now - askedAt >= ttlMs - 60_000 ? 'expired' : 'denied'
 }
+
+/**
+ * «NECESITO PERMISOS DE ADMINISTRADOR» SE DICE UNA VEZ POR VERSIÓN. Una bóveda instalada como
+ * paquete del sistema no puede cambiarse el binario: avisa a quien aprueba y espera a que
+ * alguien la instale a mano. Sin apuntarlo, lo repetiría en cada pasada y en cada reinicio.
+ *
+ * Mismas reglas que lo preguntado: sobrevive al reinicio, y un archivo que existe y no se
+ * puede leer se LANZA (ni «ya se dijo» ni «dilo otra vez»).
+ */
+export const ROOT_TOLD_FILE = 'update-root-told.json'
+
+/** @returns {{ version: string, at: number } | null} */
+export function readRootTold (dir) {
+  const file = path.join(dir, ROOT_TOLD_FILE)
+  if (!fs.existsSync(file)) return null
+  const d = ipcRead(file, null)
+  if (!d || typeof d.version !== 'string' || !d.version || typeof d.at !== 'number') throw fail('root-told-unreadable', `${ROOT_TOLD_FILE} exists but cannot be read`)
+  return { version: d.version, at: d.at }
+}
+
+export function writeRootTold (dir, { version, at }) {
+  if (typeof version !== 'string' || !version || typeof at !== 'number') throw fail('bad-root-told', 'writeRootTold: version and at are required')
+  ipcWrite(path.join(dir, ROOT_TOLD_FILE), { v: 1, version, at })
+}
+
+/** ¿Hay que avisar por `version`? Solo si nunca se avisó, o si es MÁS NUEVA que la avisada. */
+export function shouldTellRoot (told, version, isNewer) {
+  return !told || isNewer(version, told.version)
+}

package/src/vault.js

@@ -1617,31 +1617,36 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * aprueba en este perfil, por el mismo camino que su propio «me actualicé». Si el agente
    * avisa o no lo decide él (su interruptor); aquí solo se reparte.
    *
+   * Y su hermano `op: 'update-needs-root'`: el aparato vio una versión nueva y no puede
+   * instalarla solo porque necesita permisos de administrador. Mismo reparto, otro `ev`.
+   *
    * QUIÉN ES lo dice el acta (id y nombre), no lo que el aparato cuente de sí mismo.
    */
   async function handleUpdateDone (from, p) {
+    const op = p.data.op
+    const ev = op === 'update-needs-root' ? 'update-needs-root' : 'updated'
     const chk = await verifyChain({
       data: p.data, signature: p.signature, cert: p.cert,
       ...(await contextoActa()), revoked: await revocationSet()
     })
-    if (!chk.ok) return denyChain(from, chk, p, 'update-done')
+    if (!chk.ok) return denyChain(from, chk, p, op)
     const record = (await identity.profileActa?.().catch(() => null))?.acta
     const member = (record?.members || []).find((m) => m.pub === chk.device)
     if (!member) {
-      audit('rejected', { what: 'update-done', reason: record ? 'acta' : 'sin-acta' })
+      audit('rejected', { what: op, reason: record ? 'acta' : 'sin-acta' })
       return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this device is not in the record' })
     }
     const product = cut(p.data?.product, 128)
     const version = cut(p.data?.version, 64)
-    if (!product || !version) return reply(from, { type: MSG.ERROR, code: 'bad-request', error: 'update-done: needs `product` and `version`' })
+    if (!product || !version) return reply(from, { type: MSG.ERROR, code: 'bad-request', error: `${op}: needs \`product\` and \`version\`` })
     const deviceId = await deviceIdOf(chk.device).catch(() => null)
     try {
-      await announceUpdate({ version, from: cut(p.data?.from, 64), product, deviceId, label: member.label || '' })
+      await announceUpdate({ ev, version, from: cut(p.data?.from, 64), product, deviceId, label: member.label || '' })
     } catch (e) {
-      log(`[vault] update-done: ${deviceId || '????-????'} updated ${product} to ${version}, but the approvers could not be told: ${e.message}`)
-      return reply(from, { type: MSG.ERROR, code: e.code || 'announce-failed', error: 'update-done: the approvers could not be told' })
+      log(`[vault] ${op}: ${deviceId || '????-????'} reported ${product} ${version}, but the approvers could not be told: ${e.message}`)
+      return reply(from, { type: MSG.ERROR, code: e.code || 'announce-failed', error: `${op}: the approvers could not be told` })
     }
-    const body = { op: 'update-done', ok: true, product, version, ts: Date.now() }
+    const body = { op, ok: true, product, version, ts: Date.now() }
     reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
   }
 
@@ -1713,7 +1718,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (p.data?.op === 'store.recipients' || p.data?.op === 'store') return handleVarStore(from, p)
     if (p.data?.op === 'digest') return handleDigest(from, p)
     if (p.data?.op === 'update-ask') return handleUpdateAsk(from, p)
-    if (p.data?.op === 'update-done') return handleUpdateDone(from, p)
+    if (p.data?.op === 'update-done' || p.data?.op === 'update-needs-root') return handleUpdateDone(from, p)
     if (['approvals', 'approve', 'deny', 'grants', 'grant-revoke', 'block', 'blocked'].includes(p.data?.op)) return handleApproval(from, p)
     const ns = p.data?.ns
     if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'secrets: invalid namespace' })
@@ -2083,18 +2088,22 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * También reparte el «me actualicé» de un APARATO (`op: 'update-done'`): entonces lleva su
    * `product`, `deviceId` y `label`.
    *
+   * Y con `ev: 'update-needs-root'` cuenta lo contrario: hay versión nueva y NO se instaló
+   * sola porque necesita permisos de administrador (dueño, 2026-10-08: «si se requiere root
+   * por algún motivo, simplemente se notifica al aprobador»). Mismo camino, otro `ev`.
+   *
    * A diferencia de `notifyApprovers`, aquí el fallo SE LANZA: quien llama guarda el
    * marcador hasta que el aviso salió, y tragarlo sería borrarlo sin haber avisado.
    * @returns {Promise<{ approvers: number, sent: number, notice: object|null }>}
    */
-  async function announceUpdate ({ version, from = null, product = '@dotrino/vaultd', deviceId = null, label = null }) {
+  async function announceUpdate ({ version, from = null, product = '@dotrino/vaultd', deviceId = null, label = null, ev = 'updated' }) {
     const record = await refreshActa()
     const who = (record?.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve')).map((m) => m.pub)
     if (!who.length) return { approvers: 0, sent: 0, notice: null }
     // `deviceId`/`label`: solo cuando quien se actualizó es un APARATO (`update-done`). El
     // aviso de la propia bóveda no los lleva.
-    const notice = notices.updated({ version, from, product, ...(deviceId ? { deviceId, label: label || '' } : {}) })
-    const { id, ev, ts, ...rest } = notice
+    const notice = notices.add(ev, { version, from, product, ...(deviceId ? { deviceId, label: label || '' } : {}) })
+    const { id, ev: _ev, ts, ...rest } = notice
     const body = { ev, id, ...rest, ts }
     const seal = await sealOrFail(body)
     let sent = 0
@@ -2102,8 +2111,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, seal }, { app: 'vault' }); sent++ }
       catch (e) { log(`[vault] could not tell ${pub.slice(0, 24)}… about the update of ${product} to ${version}: ${e.message}`) }
     }
-    audit('update.announced', { product, version, from: notice.from, device: deviceId, approvers: who.length, sent })
-    log(`[vault] update: told ${sent} of ${who.length} approver(s) that ${deviceId ? `${deviceId} runs ${product}` : 'this vault now runs'} ${version}`)
+    audit(ev === 'updated' ? 'update.announced' : 'update.needs-root', { product, version, from: notice.from, device: deviceId, approvers: who.length, sent })
+    log(`[vault] update: told ${sent} of ${who.length} approver(s) that ${deviceId ? `${deviceId} (${product})` : 'this vault'} ${ev === 'updated' ? 'now runs' : 'needs administrator rights to install'} ${version}`)
     if (!sent) throw Object.assign(new Error('no approver could be told'), { code: 'announce-failed' })
     return { approvers: who.length, sent, notice }
   }