@dotrino/vaultd 0.154.1 → 0.156.0

package/lib/src/browser.js

@@ -0,0 +1,167 @@
+/**
+ * LA BÓVEDA EN EL NAVEGADOR: la pestaña (`vault.dotrino.com`, dentro del iframe de
+ * identidad) y la extensión del gestor de contraseñas corren el MISMO núcleo que el
+ * binario (`./core/vault.js`). Lo único distinto es lo que pone la plataforma:
+ *
+ *   · el disco es IndexedDB cifrado (`./core/browserDisk.js`), uno por perfil;
+ *   · la identidad es la que ya tiene abierta la pestaña o la extensión;
+ *   · no hay `/proc` ni socket de archivo: lo que declara quien pide se queda como
+ *     declarado, y los servicios de la misma máquina llegan por el proxio.
+ *
+ * Y lo que sí suma: la consola que corre en este mismo navegador administra esta bóveda
+ * por un canal local (`core.setSelfVault`), con el MISMO protocolo y las mismas
+ * comprobaciones que contra el binario.
+ *
+ * Lo que el binario tiene y el navegador no, por su contexto: actualizarse solo (la pestaña
+ * se sirve siempre al día y la extensión la actualiza su tienda), las llaves de hardware
+ * como puerta del perfil y el candado que cifra la maestra con la contraseña. Ver
+ * `docs/three-versions.md`.
+ */
+import { startVault } from './core/vault.js'
+import { openBrowserDisk } from './core/browserDisk.js'
+import { LIB_VERSION } from './core/libVersion.js'
+import { IdentityFacade } from '@dotrino/identity/facade'
+import { memberScopes } from '@dotrino/identity/acta'
+import { deviceIdOf } from './enroll.js'
+
+const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
+/** Cada cuánto se rehace el papel con el que la consola local administra esta bóveda. */
+const SELF_CERT_EVERY_MS = 60_000
+
+/**
+ * @param {object} opts
+ * @param {object} opts.core  el núcleo de identidad ya abierto (`createIdentityCore`)
+ * @param {string} [opts.proxyUrl]
+ * @param {Function} [opts.makeClient]  quién crea el cliente del proxio. La extensión lo
+ *   pasa siempre: un service worker no puede hacer `import()`.
+ * @param {Function} [opts.legacyLogins]  los inicios de sesión que esta pestaña guardaba
+ *   antes de correr el núcleo (`{ state, drop }` o `null`). Se traen UNA vez.
+ * @param {Function} [opts.onPendingChange]  un aparato espera aprobación, o dejó de esperar
+ * @param {Function} [opts.onAdopted]
+ * @param {Function} [opts.log]
+ * @param {object} [opts.opaque]  el servidor de OPAQUE, si el del paquete no se puede cargar aquí
+ *   (la extensión: su CSP no deja WASM en la página de la bóveda).
+ * @param {boolean} [opts.servePasswords]  `false` si las contraseñas las atiende quien monta
+ *   la bóveda (la extensión, con su worker); decide con `passwordsNeedApproval`/`approvePasswordRequest`.
+ * @param {Function} [opts.openDisk]  `(name) => disk`. Solo para las pruebas (Node no tiene
+ *   IndexedDB); por defecto, `openBrowserDisk`.
+ */
+export async function startBrowserVault ({ core, proxyUrl = DEFAULT_PROXY, makeClient = null, legacyLogins = null, onPendingChange = () => {}, onAdopted = () => {}, log = console.log, openDisk = openBrowserDisk, opaque = null, servePasswords = true } = {}) {
+  if (!core?.handlers) throw Object.assign(new Error('startBrowserVault: the identity core is required'), { code: 'no-identity' })
+  const identity = new IdentityFacade(core)
+  if (!identity.me?.publickey) throw Object.assign(new Error('no identity: create or unlock your profile before using this browser as a vault'), { code: 'no-identity' })
+  const { id: pid } = await identity.currentProfile()
+  if (!pid) throw Object.assign(new Error('no profile: the vault belongs to an account'), { code: 'no-profile' })
+
+  const disk = await openDisk(`dotrino-vault.${pid}`)
+
+  // LOS INICIOS DE SESIÓN QUE YA HABÍA. Antes de correr el núcleo, la pestaña guardaba los
+  // usuarios y contraseñas de la cuenta en su propio almacén. Se traen una vez —si el disco
+  // ya tiene los suyos, mandan esos— y después se borra lo viejo: dos copias acaban diciendo
+  // cosas distintas.
+  if (legacyLogins && !disk.exists('logins.json')) {
+    const old = await legacyLogins()
+    if (old?.state) {
+      disk.write('logins.json', disk.atRest.encrypt(JSON.stringify(old.state)))
+      await disk.flush()
+      try { await old.drop?.() } catch (_) {}
+      log('[vault] password logins moved into the vault storage')
+    }
+  }
+
+  const avisar = () => { try { onPendingChange() } catch (_) {} }
+  const vault = await startVault({
+    platform: {
+      disk,
+      product: 'vault',
+      version: LIB_VERSION,
+      openIdentity: async () => identity,
+      makeClient,
+      noticeGroupMs: 3000,
+      ...(opaque ? { opaque } : {}),
+      servePasswords
+    },
+    proxyUrl,
+    log,
+    isLocked: () => !!core.masterLocked,
+    // El navegador no tiene la contraseña del perfil con la que el binario cierra la copia
+    // de recuperación: se cierra con la llave de este almacén, y el núcleo lo dice.
+    hasPassword: () => false,
+    onEnrollChallenge: avisar,
+    onAdopted: (info) => { try { onAdopted(info) } catch (_) {} }
+  })
+
+  // EL PAPEL CON EL QUE LA CONSOLA DE ESTE NAVEGADOR ADMINISTRA ESTA BÓVEDA: la llave del
+  // perfil firmándose a sí misma con lo que el acta le deja hoy. Se rehace cada minuto
+  // porque el acta cambia (un permiso que te quitas, un sellado nuevo).
+  const master = identity.me.publickey
+  const selfCert = async () => {
+    const acta = (await identity.profileActa().catch(() => null))?.acta || null
+    if (!acta) return null
+    const scope = memberScopes(acta, master)
+    if (!scope.length) return null
+    return (await identity.signDelegation(master, scope, { label: 'self' })).cert
+  }
+  /**
+   * EL DUEÑO EN SU MÁQUINA ADMINISTRA. En el binario eso es la TUI, que no necesita ningún
+   * permiso del acta; aquí la consola habla el protocolo de la consola remota, que exige
+   * `admin`. Así que la llave de la cuenta se lo da a sí misma, una vez y a la vista en el
+   * acta: es verdad que este navegador administra la cuenta. `aprueba` NO, a propósito: con
+   * él los servicios pasarían a esperar el visto bueno de una pestaña que puede no estar.
+   */
+  const asegurarAdmin = async () => {
+    if (core.masterLocked) return
+    const acta = (await identity.profileActa().catch(() => null))?.acta || null
+    const yo = (acta?.members || []).find((m) => m.pub === master)
+    if (!yo || (yo.caps || []).includes('admin')) return
+    if (!(await identity.isMaster().catch(() => false))) return
+    await identity.setCaps(master, [...yo.caps, 'admin'])
+    log('[vault] this browser administers the account: admin added to its own key')
+  }
+  const open = (onReply) => vault.localChannel(onReply)
+  const presentar = async () => {
+    try {
+      await asegurarAdmin()
+      const cert = await selfCert()
+      core.setSelfVault?.(cert ? { cert, proxy: proxyUrl, open } : null)
+    } catch (e) { log('[vault] the console in this browser cannot administer this vault yet: ' + (e?.message || e)) }
+  }
+  await presentar()
+  const refresco = setInterval(presentar, SELF_CERT_EVERY_MS)
+
+  return {
+    ...vault,
+    iss: master,
+    proxy: proxyUrl,
+    disk,
+    /** Aprueba TIPEANDO el código que muestra el aparato (el núcleo comprueba el compromiso). */
+    approve: async (_deviceId, code) => { try { return await vault.approveDevice(code) } finally { avisar() } },
+    reject: (deviceId) => { try { return vault.rejectDevice(deviceId) } finally { avisar() } },
+    /**
+     * Las máquinas con papel de firma de esta cuenta (excluye los navegadores enrolados con
+     * etiqueta `cli`, que no atienden pedidos). Se queda el papel del acta más nueva.
+     */
+    async listMachines () {
+      const { issued } = await identity.listDelegations()
+      const bySub = new Map()
+      for (const x of (issued || [])) {
+        if (!x.sub || x.revokedAt) continue
+        if (!Array.isArray(x.scope) || !x.scope.includes('vault:sign')) continue
+        if (!x.label || x.label === 'cli' || x.label === 'self') continue
+        if (!bySub.has(x.sub) || (x.seq || 0) > (bySub.get(x.sub).seq || 0)) bySub.set(x.sub, x)
+      }
+      return Promise.all([...bySub.values()].map(async (x) => ({ ...x, deviceId: await deviceIdOf(x.sub) })))
+    },
+    revokeDevice: (sub) => vault.revokeDevice({ sub }),
+    revoke: (nonce) => vault.revokeDevice(nonce),
+    async close () {
+      clearInterval(refresco)
+      try { core.setSelfVault?.(null) } catch (_) {}
+      vault.close()
+      try { await disk.flush() } catch (e) { log('[vault] some changes could not be saved: ' + (e?.message || e)) }
+      disk.close()
+    }
+  }
+}
+
+export default { startBrowserVault }

package/{src → lib/src/core}/approvals.js

@@ -31,7 +31,7 @@
  * protección por la que esto existe. No se le busque un sustituto del comando para que
  * entre en la ventana.
  */
-import { commandFingerprint } from '../lib/src/proc.js'
+import { commandFingerprint } from '../procContext.js'
 
 const rnd = () => [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.toString(16).padStart(2, '0')).join('')
 

package/{src → lib/src/core}/blocked.js

@@ -12,27 +12,26 @@
  * Se carga UNA vez: un archivo que existe y no se puede leer NO es «nadie bloqueado» — se
  * lanza, y la bóveda no arranca con una lista que no puede saber.
  */
-import fs from 'node:fs'
-import path from 'node:path'
 
 export const BLOCKED_FILE = 'blocked.json'
 
 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
+ * @param {{ disk: object, now?: () => number }} opts
  */
-export function openBlocked ({ dir, atRest, now = Date.now }) {
-  const file = path.join(dir, BLOCKED_FILE)
+export function openBlocked ({ disk, now = Date.now }) {
+  const file = BLOCKED_FILE
+  const atRest = disk.atRest
   /** pub → { deviceId, label, since, by, reason } */
   let items = load()
 
   function load () {
     let raw
-    try { raw = fs.readFileSync(file, 'utf8') } catch (e) {
-      if (e.code === 'ENOENT') return new Map()
+    try { raw = disk.read(file) } catch (e) {
       throw fail('blocked-unreadable', `cannot read ${BLOCKED_FILE}: ${e.message}`)
     }
+    if (raw == null) return new Map()
     let d
     try { d = JSON.parse(atRest.decrypt(raw)) } catch (e) { throw fail('blocked-unreadable', `${BLOCKED_FILE} cannot be opened: ${e.message}`) }
     if (d?.v !== 1 || !d.items || typeof d.items !== 'object') throw fail('blocked-unreadable', `${BLOCKED_FILE} has an unknown shape`)
@@ -40,9 +39,7 @@ export function openBlocked ({ dir, atRest, now = Date.now }) {
   }
 
   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)
+    disk.write(file, atRest.encrypt(JSON.stringify({ v: 1, items: Object.fromEntries(items) })))
   }
 
   const publicOf = (pub, b) => ({ pub, deviceId: b.deviceId || null, label: b.label || '', since: b.since, by: b.by || null, reason: b.reason || null })

package/lib/src/core/browserDisk.js

@@ -0,0 +1,109 @@
+/**
+ * EL DISCO DE LA BÓVEDA EN EL NAVEGADOR (pestaña y extensión).
+ *
+ * El núcleo lee y escribe de forma síncrona (`./disk.js`), y en el navegador el único
+ * almacén que aguanta es IndexedDB, que es asíncrono. Así que al abrir se cargan TODOS los
+ * archivos del perfil a memoria, y cada escritura se guarda por detrás. Son una docena de
+ * archivos pequeños: caben de sobra.
+ *
+ * NADA EN CLARO EN EL DISCO. Cada archivo se guarda cifrado con AES-GCM bajo una llave que
+ * se crea aquí NO EXTRAÍBLE y vive en la misma base: el navegador la puede usar y nadie la
+ * puede leer, que es lo más parecido que hay en un navegador a la llave ligada a la máquina
+ * del binario. Por eso el cifrado en reposo del núcleo (`atRest`) aquí no hace nada: lo hace
+ * el almacén entero, archivo por archivo.
+ *
+ * LO QUE NO PROMETE, dicho: una escritura que no llegó a IndexedDB antes de cerrar la
+ * pestaña se pierde. Se guarda en cuanto se escribe (sin esperar a juntar), y `flush()`
+ * espera a que todo esté guardado.
+ */
+import { memoryDisk } from './disk.js'
+
+const STORE = 'files'
+const KEY_ID = '\u0000key'
+
+function idb (req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result)
+    req.onerror = () => reject(req.error)
+  })
+}
+
+function openDb (name) {
+  const req = indexedDB.open(name, 1)
+  req.onupgradeneeded = () => { req.result.createObjectStore(STORE) }
+  return idb(req)
+}
+
+const tx = (db, mode) => db.transaction(STORE, mode).objectStore(STORE)
+
+/**
+ * @param {string} name  la base de este perfil (`dotrino-vault.<perfil>`)
+ * @returns {Promise<object>} un disco (`./disk.js`) con `flush()` y `close()`
+ */
+export async function openBrowserDisk (name) {
+  if (typeof indexedDB === 'undefined') throw Object.assign(new Error('this browser has no IndexedDB: the vault cannot keep anything here'), { code: 'no-indexeddb' })
+  const db = await openDb(name)
+
+  let key = await idb(tx(db, 'readonly').get(KEY_ID))
+  if (!key) {
+    key = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt'])
+    await idb(tx(db, 'readwrite').put(key, KEY_ID))
+  }
+
+  // Todo a memoria. Un archivo que está y no se abre NO se salta: el núcleo decidiría con
+  // un archivo vacío (una lista de bloqueados vacía, un acta sin cajones), y eso es justo
+  // el repliegue que no se pone. Se para y se dice cuál.
+  const files = new Map()
+  const names = await idb(tx(db, 'readonly').getAllKeys())
+  for (const n of names) {
+    if (n === KEY_ID) continue
+    const rec = await idb(tx(db, 'readonly').get(n))
+    try {
+      const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: rec.iv }, key, rec.ct)
+      files.set(n, new TextDecoder().decode(plain))
+    } catch (e) {
+      throw Object.assign(new Error(`vault storage: ${n} cannot be opened (${e?.message || e})`), { code: 'disk-unreadable', file: n })
+    }
+  }
+
+  // Las escrituras van en orden y una detrás de otra: la última manda.
+  let queue = Promise.resolve()
+  let lastError = null
+  const persist = (n) => {
+    queue = queue.then(async () => {
+      if (!files.has(n)) { await idb(tx(db, 'readwrite').delete(n)); return }
+      const iv = crypto.getRandomValues(new Uint8Array(12))
+      const ct = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, new TextEncoder().encode(files.get(n)))
+      await idb(tx(db, 'readwrite').put({ iv, ct }, n))
+    }).catch((e) => {
+      lastError = e
+      console.error(`[vault] could not save ${n} in this browser: ${e?.message || e}`)
+    })
+  }
+
+  // LA LLAVE DE LA MÁQUINA (`machineKey`): 32 bytes al azar, creados una vez. Es con lo que
+  // el núcleo cierra lo que tiene que abrirse con el perfil cerrado; aquí vale lo que vale
+  // este almacén, igual que en el binario vale lo que vale su disco.
+  const MACHINE = 'machine.key'
+  if (!files.has(MACHINE)) {
+    const raw = crypto.getRandomValues(new Uint8Array(32))
+    let s = ''; for (const b of raw) s += String.fromCharCode(b)
+    files.set(MACHINE, btoa(s))
+    persist(MACHINE)
+  }
+  const machineKey = () => Uint8Array.from(atob(files.get(MACHINE)), (c) => c.charCodeAt(0))
+
+  const disk = memoryDisk({ files, machineKey, onChange: persist })
+  return {
+    ...disk,
+    name,
+    /** Espera a que lo escrito esté en IndexedDB. Lanza si algo no se pudo guardar. */
+    async flush () {
+      await queue
+      if (lastError) { const e = lastError; lastError = null; throw e }
+    },
+    close () { try { db.close() } catch (_) {} }
+  }
+}
+
+export default { openBrowserDisk }

package/{src → lib/src/core}/commKey.js

@@ -23,9 +23,7 @@
  *     SERVICIO: `memberCanSign` sin cajón le dice que no. Puede hablar por la bóveda, no
  *     firmar por la persona. Si alguien se lleva el disco, se lleva eso y nada más.
  */
-import path from 'node:path'
-import { readJson, writeJson } from './paths.js'
-import { atRestFor } from './atrest.js'
+import { readJson, writeJson } from './disk.js'
 import { signWithDevice } from '@dotrino/identity/capabilities'
 
 /** El `cn` con el que entra en el acta. Es un servicio del perfil, no un aparato tuyo. */
@@ -34,10 +32,9 @@ export const COMM_CN = 'vault'
 export const COMM_CAPS = Object.freeze(['sign'])
 
 /** Abre (o estrena) la llave de comunicación del perfil. */
-export function openCommKey (dir) {
-  const file = path.join(dir, 'commkey.json')
-  const atRest = atRestFor(dir)
-  let data = readJson(file, null, atRest)
+export function openCommKey (disk) {
+  const file = 'commkey.json'
+  let data = readJson(disk, file, null)
   if (!data || typeof data !== 'object' || !data.pub) data = null
 
   return {
@@ -55,7 +52,7 @@ export function openCommKey (dir) {
       const pub = JSON.stringify(await crypto.subtle.exportKey('jwk', pair.publicKey))
       const priv = await crypto.subtle.exportKey('jwk', pair.privateKey)
       data = { v: 1, pub, priv, createdAt: Date.now() }
-      writeJson(file, data, atRest)
+      writeJson(disk, file, data)
       return pub
     },
 

package/lib/src/core/disk.js

@@ -0,0 +1,65 @@
+/**
+ * EL DISCO DE UNA BÓVEDA, el mismo para el binario y para el navegador.
+ *
+ * La bóveda guarda una docena de archivos pequeños (`vault.json`, `secrets.json`,
+ * `blocked.json`, la bitácora…) y los lee y escribe de forma SÍNCRONA: se consultan por
+ * cada mensaje que entra, y convertir cada lectura en un `await` cambiaría el orden en que
+ * pasan las cosas en todo el núcleo. Por eso el disco es una interfaz síncrona, y quien
+ * monta la bóveda pone la suya:
+ *
+ *   · el binario, archivos de verdad bajo el directorio del perfil (`src/disk.js`);
+ *   · el navegador, una copia en memoria que se guarda cifrada en IndexedDB por detrás
+ *     (`./browserDisk.js`).
+ *
+ * Interfaz (nombres relativos al perfil, nunca rutas):
+ *
+ *   read(name)          → el texto, o `null` si no existe. Otro fallo LANZA: un archivo
+ *                         que está y no se puede leer no es un archivo vacío.
+ *   write(name, text)   → reemplaza entero, de golpe (a medio escribir no queda nada).
+ *   append(name, text)  → añade al final.
+ *   exists(name), remove(name), rename(from, to), size(name)
+ *   atRest              → `{ encrypt(text), decrypt(text) }`, síncronos: el cifrado en
+ *                         reposo de ESTE disco. En el binario va ligado a la máquina; en el
+ *                         navegador el cifrado lo hace el almacén entero y aquí no se toca.
+ *   machineKey()        → 32 bytes: la llave de la máquina (`kekFor`). Es con lo que se
+ *                         cierra lo que tiene que abrirse con el perfil cerrado.
+ */
+
+/** Lee un JSON cifrado en reposo. Lo que no está o no se puede leer devuelve `fallback`. */
+export function readJson (disk, name, fallback) {
+  try {
+    const raw = disk.read(name)
+    if (raw == null) return fallback
+    return JSON.parse(disk.atRest.decrypt(raw))
+  } catch (_) { return fallback }
+}
+
+/** Escribe un JSON cifrado en reposo, entero y de golpe. */
+export function writeJson (disk, name, obj) {
+  disk.write(name, disk.atRest.encrypt(JSON.stringify(obj, null, 2)))
+}
+
+/**
+ * Un disco en memoria, sin nada detrás. Es la base del del navegador (que lo vuelca a
+ * IndexedDB) y el de las pruebas. `files` es un `Map` nombre → texto.
+ */
+export function memoryDisk ({ files = new Map(), atRest = null, machineKey = null, onChange = () => {} } = {}) {
+  const key = machineKey || (() => { throw Object.assign(new Error('this disk has no machine key'), { code: 'no-machine-key' }) })
+  return {
+    files,
+    read: (name) => (files.has(name) ? files.get(name) : null),
+    write: (name, text) => { files.set(name, String(text)); onChange(name) },
+    append: (name, text) => { files.set(name, (files.get(name) || '') + String(text)); onChange(name) },
+    exists: (name) => files.has(name),
+    remove: (name) => { if (files.delete(name)) onChange(name) },
+    rename: (from, to) => {
+      if (!files.has(from)) throw Object.assign(new Error(`rename: ${from} does not exist`), { code: 'ENOENT' })
+      files.set(to, files.get(from)); files.delete(from); onChange(from); onChange(to)
+    },
+    size: (name) => (files.has(name) ? new TextEncoder().encode(files.get(name)).length : 0),
+    atRest: atRest || { encrypt: (t) => t, decrypt: (t) => t },
+    machineKey: key
+  }
+}
+
+export default { readJson, writeJson, memoryDisk }

package/lib/src/core/libVersion.js

@@ -0,0 +1,8 @@
+/**
+ * LA VERSIÓN DE `@dotrino/vault`, escrita aquí porque el navegador no puede leer el
+ * `package.json`. Con esta se anuncia la bóveda de la pestaña y de la extensión
+ * (`@dotrino/compat`). Una prueba (`test/version-del-navegador.test.mjs`) para el release
+ * si no coincide con la del paquete: una versión anunciada que no es la que corre es peor
+ * que no anunciar ninguna.
+ */
+export const LIB_VERSION = '0.86.0'

package/lib/src/core/machines.js

@@ -0,0 +1,66 @@
+/**
+ * DÓNDE CORRE CADA APARATO, según lo último que dijo (`@dotrino/identity/machine`).
+ *
+ * El acta guarda lo que el aparato dijo AL EMPAREJARSE, y eso no cambia sin una firma de la
+ * maestra. Aquí va lo que dice en cada pedido firmado: así un aparato que entró antes de que
+ * existiera el campo aparece con su máquina en cuanto se actualiza y habla, y uno que cambió
+ * de sistema sale al día. La lista enseña esto primero y, si no hay, lo del acta.
+ *
+ * NO DECIDE NADA: se enseña. Lo dice el propio aparato, dentro de lo que firma; nadie más lo
+ * puede escribir por él, pero tampoco prueba nada.
+ *
+ * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer se lanza.
+ */
+import { cleanMachine, sameMachine } from '@dotrino/identity/machine'
+
+export const MACHINES_FILE = 'machines.json'
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * @param {{ disk: object, now?: () => number }} opts
+ */
+export function openMachines ({ disk, now = Date.now }) {
+  const file = MACHINES_FILE
+  const atRest = disk.atRest
+  /** pub → { kind, os, name, at } */
+  const items = load()
+
+  function load () {
+    let raw
+    try { raw = disk.read(file) } catch (e) {
+      throw fail('machines-unreadable', `cannot read ${MACHINES_FILE}: ${e.message}`)
+    }
+    if (raw == null) return new Map()
+    let d
+    try { d = JSON.parse(atRest.decrypt(raw)) } catch (e) { throw fail('machines-unreadable', `${MACHINES_FILE} cannot be opened: ${e.message}`) }
+    if (d?.v !== 1 || !d.items || typeof d.items !== 'object') throw fail('machines-unreadable', `${MACHINES_FILE} has an unknown shape`)
+    return new Map(Object.entries(d.items))
+  }
+
+  function save () {
+    disk.write(file, atRest.encrypt(JSON.stringify({ v: 1, items: Object.fromEntries(items) })))
+  }
+
+  return {
+    /**
+     * Lo que acaba de decir un aparato. Solo se escribe si cambió: casi todos los pedidos
+     * repiten lo de siempre, y reescribir el archivo en cada uno sería disco para nada.
+     * Lo que no tiene forma de máquina no borra lo que ya había.
+     */
+    note (pub, raw) {
+      if (typeof pub !== 'string' || !pub) throw fail('bad-pub', 'note: a device key is required')
+      const m = cleanMachine(raw)
+      if (!m) return false
+      if (sameMachine(items.get(pub), m)) return false
+      items.set(pub, { ...m, at: now() })
+      save()
+      return true
+    },
+    /** Lo último que dijo, o `null` si nunca dijo nada. */
+    of (pub) {
+      const m = items.get(pub)
+      return m ? { ...m } : null
+    }
+  }
+}

package/{src → lib/src/core}/notices.js

@@ -12,9 +12,6 @@
  * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer se LANZA: callar
  * sería decir «no pasó nada» de algo que sí pasó.
  */
-import fs from 'node:fs'
-import path from 'node:path'
-import crypto from 'node:crypto'
 
 export const NOTICES_FILE = 'notices.json'
 /** Cuánto se sigue contando un aviso. */
@@ -25,25 +22,24 @@ export const NOTICE_EVS = ['updated', 'update-needs-root']
 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
+ * @param {{ disk: object, now?: () => number }} opts
  */
-export function openNotices ({ dir, atRest, now = Date.now }) {
-  const file = path.join(dir, NOTICES_FILE)
+export function openNotices ({ disk, now = Date.now }) {
+  const file = NOTICES_FILE
+  const atRest = disk.atRest
   let items = load()
 
   function load () {
-    if (!fs.existsSync(file)) return []
+    if (!disk.exists(file)) return []
     try {
-      const d = JSON.parse(atRest.decrypt(fs.readFileSync(file, 'utf8')))
+      const d = JSON.parse(atRest.decrypt(disk.read(file)))
       if (!d || !Array.isArray(d.items)) throw new Error('not a list')
       return d.items.filter((n) => n && typeof n.id === 'string' && typeof n.ts === 'number')
     } catch (e) { throw fail('notices-unreadable', `${NOTICES_FILE} cannot be read: ${e.message}`) }
   }
 
   function save () {
-    const tmp = file + '.tmp'
-    fs.writeFileSync(tmp, atRest.encrypt(JSON.stringify({ v: 1, items })), { mode: 0o600 })
-    fs.renameSync(tmp, file)
+    disk.write(file, atRest.encrypt(JSON.stringify({ v: 1, items })))
   }
 
   const alive = (n) => now() - n.ts < NOTICE_TTL_MS
@@ -60,7 +56,7 @@ export function openNotices ({ dir, atRest, now = Date.now }) {
       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, product, version, from: typeof from === 'string' ? from : null,
+        id: [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.toString(16).padStart(2, '0')).join(''), ev, product, version, from: typeof from === 'string' ? from : null,
         ...(typeof deviceId === 'string' && deviceId ? { deviceId, label: typeof label === 'string' ? label : '' } : {}),
         ts: now()
       }

package/{src → lib/src/core}/notifiable.js

@@ -22,8 +22,6 @@
  * 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. */
@@ -32,19 +30,20 @@ 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
+ * @param {{ disk: object, now?: () => number }} opts
  */
-export function openNotifiable ({ dir, atRest, now = Date.now }) {
-  const file = path.join(dir, NOTIFIABLE_FILE)
+export function openNotifiable ({ disk, now = Date.now }) {
+  const file = NOTIFIABLE_FILE
+  const atRest = disk.atRest
   /** 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()
+    try { raw = disk.read(file) } catch (e) {
       throw fail('notifiable-unreadable', `cannot read ${NOTIFIABLE_FILE}: ${e.message}`)
     }
+    if (raw == null) return new Map()
     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`)
@@ -52,9 +51,7 @@ export function openNotifiable ({ dir, atRest, now = Date.now }) {
   }
 
   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)
+    disk.write(file, atRest.encrypt(JSON.stringify({ v: 1, items: Object.fromEntries(items) })))
   }
 
   return {

package/{src → lib/src/core}/sealKey.js

@@ -17,9 +17,7 @@
  * No guarda ninguna correspondencia con `seq`: quién mandaba y cuándo lo dice el acta
  * (`sealKeys` con su tramo). Aquí solo están las privadas, indexadas por su pública.
  */
-import path from 'node:path'
-import { readJson, writeJson } from './paths.js'
-import { atRestFor } from './atrest.js'
+import { readJson, writeJson } from './disk.js'
 import { signWithDevice } from '@dotrino/identity/capabilities'
 
 /**
@@ -30,13 +28,12 @@ import { signWithDevice } from '@dotrino/identity/capabilities'
 const MAX_KEYS = 8
 
 /** Abre (o estrena) el llavero de sellado del perfil. */
-export function openSealKeys (dir) {
-  const file = path.join(dir, 'sealkeys.json')
-  const atRest = atRestFor(dir)
-  const data = readJson(file, null, atRest) || { v: 1, keys: [] }
+export function openSealKeys (disk) {
+  const file = 'sealkeys.json'
+  const data = readJson(disk, file, null) || { v: 1, keys: [] }
   if (!Array.isArray(data.keys)) data.keys = []
 
-  const save = () => writeJson(file, data, atRest)
+  const save = () => writeJson(disk, file, data)
   const find = (pub) => data.keys.find((k) => k.pub === pub) || null
 
   return {