@dotrino/vaultd 0.155.0 → 0.157.0

package/README.md

@@ -128,10 +128,43 @@ firmado**. Se lee con `dotrino-vault activity`.
 
 ## Instalación
 
-Tres vías, y todas dejan la misma bóveda: **instalador de Linux** (queda como
-servicio), **un comando** (`npx`, en cualquier sistema con Node) y **Docker**. En
-Linux la primera es la cómoda; en Windows y macOS todavía no hay instalador de un
-clic, así que van por las otras dos.
+Todas las vías dejan la misma bóveda: **instalador** de Linux (`.deb`, `.rpm`,
+tarball), de **Windows** (`-setup.exe`) y de **macOS** (`Dotrino Vault.app`), **un
+comando** (`npx`, en cualquier sistema con Node) y **Docker**. Los instaladores traen
+además **la ventana** (ver abajo); `npx` y Docker, la TUI.
+
+### La ventana (`desktop/`)
+
+Una app de escritorio con **las mismas pantallas que la TUI**: bóvedas, aparatos,
+emparejar (con el QR como imagen), permisos, cajones y variables, inicios de sesión, mi
+perfil, llaves de seguridad y ajustes. No reimplementa nada: lanza `dotrino-vaultd
+--gui-bridge` y pinta el modelo que le manda el puente (`src/tui/gui.js`), que corre la
+misma sesión que la TUI. Una acción nueva en la TUI aparece en la ventana sin tocarla. Sin
+puertos: el canal son las tuberías del proceso hijo. Rust + `iced`, con el tema del
+ecosistema (Quicksand/Comfortaa, claro u oscuro según el sistema).
+
+Busca la bóveda al lado de su ejecutable (así la ponen los instaladores), luego en el
+`PATH` (`dotrino-vaultd`, o el `dotrino-vault` de npm). Para desarrollo:
+`DOTRINO_VAULT_BRIDGE="node bin/dotrino-vault.js" cargo run` en `desktop/`.
+
+**Windows — instalador:** `dotrino-vault-X.Y.Z-windows-x64-setup.exe` desde
+[Releases](https://github.com/imdotrino/dotrino-vault/releases/latest). Se instala para
+tu usuario, sin administrador, en `%LOCALAPPDATA%\Programs\Dotrino Vault`, con su entrada
+en el menú Inicio, y deja la bóveda **arrancando al iniciar sesión** (una entrada `Run`
+que lanza `dotrino-vault-desktop.exe --start-daemon`, sin ventana). Se cambia en Ajustes o
+con `dotrino-vault service autostart on|off`. Desinstalar no borra tus datos.
+
+**macOS — `Dotrino Vault.app`:** el `.zip` universal (Apple Silicon e Intel) desde
+[Releases](https://github.com/imdotrino/dotrino-vault/releases/latest); arrástrala a
+Aplicaciones. Dentro van la ventana y la bóveda. Para que arranque al iniciar sesión, en
+Ajustes (un LaunchAgent de tu usuario, `~/Library/LaunchAgents/com.dotrino.vault.plist`).
+
+> Ni el instalador de Windows ni la app de macOS llevan la firma de un desarrollador
+> registrado: Windows enseña el aviso de SmartScreen («editor desconocido») y macOS el de
+> Gatekeeper la primera vez (clic derecho → Abrir). Lo que prueba de dónde salieron es la
+> atestación de sigstore: `gh attestation verify <archivo> --repo imdotrino/dotrino-vault`.
+> En Windows y macOS la bóveda todavía **no se actualiza sola**: se instala la versión nueva
+> encima.
 
 **Ubuntu / Debian — `.deb`:** descarga el `.deb` (versionado) desde
 [Releases](https://github.com/imdotrino/dotrino-vault/releases/latest) y haz doble
@@ -196,7 +229,7 @@ npx -y @dotrino/vaultd          # Node ≥ 20
 npx -y @dotrino/vaultd --tui    # la bóveda y su pantalla de control en la misma ventana
 ```
 
-Es la vía normal en **Windows y macOS**, y sirve igual en Linux. Arranca en primer
+Sirve en cualquier sistema (y es la vía en ARM fuera de Docker). Arranca en primer
 plano: la bóveda vive mientras dejes esa ventana abierta. Los comandos de control se
 anteponen con `npx -p @dotrino/vaultd` (por ejemplo, `npx -p @dotrino/vaultd
 dotrino-vault pair`). Si no tienes Node, el instalador del ecosistema lo baja en tu
@@ -228,9 +261,9 @@ recupera.
 
 > Sin firma de código: tu sistema puede advertir que el binario no está firmado. Es
 > autohospedado y de código abierto; en Linux solo necesita permiso de ejecución (el
-> instalador lo da). Hay un build de Windows (`packaging/build-win.sh`) pero **no se
-> publica**: se construye desde Linux y no se ha probado en un Windows de verdad, y
-> la inyección del blob invalida la firma de Microsoft, así que saltaría SmartScreen.
+> instalador lo da). El daemon de Windows (`packaging/build-win.sh`) se construye desde
+> Linux y va dentro del instalador de Windows; el de macOS (`packaging/build-mac.sh`) se
+> construye en un Mac y va dentro de la app.
 
 **Dónde vive todo y cómo se para.** Tus datos —llave incluida— viven en
 `~/.local/share/dotrino/vault` (Linux y macOS), `%LOCALAPPDATA%\Dotrino\vault`
@@ -848,8 +881,10 @@ ed25519 en formato OpenSSH (sin frase: la bóveda es el candado) y RSA/P-256 en
 ## Alcance
 
 - **v1 (este):** daemon headless en Node, **multi-perfil**. En **Linux** queda como
-  servicio `systemd --user` (binario único Node SEA: `.deb` y tarball); en **Windows y
-  macOS** se corre con `npx`, en primer plano; y en cualquier sistema, con **Docker**
+  servicio `systemd --user` (binario único Node SEA: `.deb`, `.rpm` y tarball); en
+  **Windows** con un instalador por usuario y en **macOS** como `Dotrino Vault.app`, los
+  dos con arranque al iniciar sesión; en los tres, con **una ventana** que tiene las
+  pantallas de la TUI (`desktop/`); y en cualquier sistema, con `npx` o **Docker**
   (imagen amd64/arm64 en GHCR). Identidad **cifrada en reposo y ligada a esta
   máquina**. Emparejamiento endurecido con los dos caminos de vinculación, acta del
   perfil (miembros, capacidades y `cn` de servicio), firma delegada, renovación
@@ -858,9 +893,9 @@ ed25519 en formato OpenSSH (sin frase: la bóveda es el candado) y RSA/P-256 en
   actividad. Contraseña opcional por perfil, **para editarlo** (verificador PBKDF2).
 - **v2:** cifrado en reposo **con la contraseña del perfil** (hoy la clave sale solo de
   la máquina) y atado a tu cuenta del sistema —DPAPI en Windows, Keychain en macOS— o
-  al TPM; cifrar también los secretos y el store; **instalador de un clic para Windows
-  y macOS**; UI de escritorio (Tauri) como cliente del daemon; firma de documentos con
-  sellado de tiempo (`dotrino-signer`).
+  al TPM; cifrar también los secretos y el store; que la bóveda de Windows y macOS se
+  actualice sola, como la de Linux; firma de Apple y de Microsoft; firma de documentos
+  con sellado de tiempo (`dotrino-signer`).
 
 ## Estructura
 
@@ -870,7 +905,9 @@ ed25519 en formato OpenSSH (sin frase: la bóveda es el candado) y RSA/P-256 en
 - `src/daemon.js` — modo servicio: `state.json`, control por archivos + señales, apagado limpio.
 - `src/ctl.js` — CLI de control (habla con el daemon por archivos + señales, sin socket).
 - `src/vaultControl.js` — API de control programática (misma vía que la CLI); la usa la TUI.
-- `src/tui/` — interfaz de terminal, sin dependencias (`term.js` primitivas ANSI/raw-mode; `app.js` pantallas; `i18n.js` los textos es/en).
+- `src/tui/` — interfaz de terminal, sin dependencias (`term.js` primitivas ANSI/raw-mode; `app.js` pantallas; `i18n.js` los textos es/en; `gui.js` el puente de la ventana).
+- `src/service.js` — arrancar, reiniciar y arrancar al iniciar sesión en Linux, Windows y macOS.
+- `desktop/` — la ventana (Rust + `iced`): pinta lo que le manda `gui.js`.
 - `src/transport.js` — conexión headless al proxy + `identify` firmado (con el acta).
 - `src/threadStore.js` — el store del usuario: hilos, "recientes" y perfil (`threads.json`).
 - `src/store.js` — árbol de contenidos (`vault.json`, versionado). Hoy es un esqueleto: se lee, nadie escribe.

package/bin/sea-entry.js

@@ -17,6 +17,10 @@ if (argv[0] === '--tui') {
   if (!process.stdout.isTTY) { console.error('la TUI necesita un terminal interactivo (TTY).'); process.exit(2) }
   import('../src/tui/app.js').then(({ runTui }) => runTui())
     .catch((e) => { console.error('error en la TUI:', e.message); process.exit(1) })
+} else if (argv[0] === '--gui-bridge') {
+  // El canal de la ventana de escritorio (JSON por stdin/stdout, ver src/tui/gui.js).
+  import('../src/tui/gui.js').then(({ runGuiBridge }) => runGuiBridge()).then(() => process.exit(0))
+    .catch((e) => { console.error('error en el puente de la ventana:', e.message); process.exit(1) })
 } else if (argv[0] === '--ctl') {
   // CLI de control: NO toca la identidad ni el proxy; habla con el daemon vía
   // el dir de datos (state.json) y señales (SIGUSR1 para emparejar).

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/{src → lib/src/core}/machines.js

@@ -11,8 +11,6 @@
  *
  * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer se lanza.
  */
-import fs from 'node:fs'
-import path from 'node:path'
 import { cleanMachine, sameMachine } from '@dotrino/identity/machine'
 
 export const MACHINES_FILE = 'machines.json'
@@ -20,19 +18,20 @@ export const MACHINES_FILE = 'machines.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 openMachines ({ dir, atRest, now = Date.now }) {
-  const file = path.join(dir, MACHINES_FILE)
+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 = fs.readFileSync(file, 'utf8') } catch (e) {
-      if (e.code === 'ENOENT') return new Map()
+    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`)
@@ -40,9 +39,7 @@ export function openMachines ({ 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 {