@dotrino/vault 0.85.0 → 0.86.0

package/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/core/commKey.js

@@ -0,0 +1,68 @@
+/**
+ * commKey.js — LA LLAVE DE COMUNICACIÓN de esta bóveda.
+ *
+ * La maestra tiene dos trabajos y ninguno más: **sellar el acta y reenvolver los sobres**
+ * (dueño, 2026-08-31). Hablar por la red no es suyo. Todo lo demás —identificarse ante el
+ * proxio, firmar lo que se sirve— lo hace esta llave, y **su autoridad la dice el acta**,
+ * donde entra como un miembro más.
+ *
+ * Por qué eso importa y no es un rodeo: mientras la maestra fuera la que se identificaba,
+ * no podía vivir bajo llave — `identify` firma en cada conexión y en cada reconexión, así
+ * que una bóveda cerrada no habría existido en la red. Sacándola de ahí, la maestra solo
+ * sale con el perfil abierto y el candado deja de ser una bandera.
+ *
+ * Tres propiedades, y las tres son a propósito:
+ *
+ *   · **Firmar no es leer.** No abre ningún valor. Por eso puede vivir cifrada en reposo
+ *     con la llave de la máquina y usarse SIN la frase — que es lo que hace que la bóveda
+ *     siga sirviendo con el candado echado.
+ *   · **ESTABLE.** No rota con cada acta, al revés que la vieja `sealPub`: es un miembro,
+ *     y un miembro no cambia de llave cada vez que se toca el acta. Rota cuando se decide,
+ *     como cualquier aparato.
+ *   · **Acotada por `cn`.** Entra con `cn: 'vault'`, así que el acta la trata como un
+ *     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 { 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. */
+export const COMM_CN = 'vault'
+/** Lo que puede: firmar (acotado por su `cn`). Nada de leer, guardar ni sellar. */
+export const COMM_CAPS = Object.freeze(['sign'])
+
+/** Abre (o estrena) la llave de comunicación del perfil. */
+export function openCommKey (disk) {
+  const file = 'commkey.json'
+  let data = readJson(disk, file, null)
+  if (!data || typeof data !== 'object' || !data.pub) data = null
+
+  return {
+    /** La pública, o `null` si todavía no se ha estrenado. */
+    pub: () => data?.pub || null,
+
+    /**
+     * Estrena la llave si no existe y devuelve su pública. Idempotente: llamarla dos veces
+     * NO cambia de llave — cambiarla dejaría al acta nombrando una que ya no tenemos y a la
+     * bóveda sin poder identificarse hasta el siguiente sellado.
+     */
+    async ensure () {
+      if (data?.pub) return data.pub
+      const pair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify'])
+      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(disk, file, data)
+      return pub
+    },
+
+    /** Firma un cuerpo. `null` si aún no hay llave (no se estrena una al vuelo: ver `ensure`). */
+    async sign (body) {
+      if (!data?.priv) return null
+      const { signature } = await signWithDevice({ privateJwk: data.priv, publickey: data.pub, data: body })
+      return signature
+    }
+  }
+}
+
+export default { openCommKey, COMM_CN, COMM_CAPS }

package/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/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/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/core/notices.js

@@ -0,0 +1,71 @@
+/**
+ * LO QUE LA BÓVEDA TIENE QUE CONTARLE A QUIEN APRUEBA, y que no es un pedido.
+ *
+ * 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`.
+ *
+ * Caduca a las 24 h: es una noticia, no un registro (eso es la bitácora).
+ *
+ * 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ó.
+ */
+
+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 })
+
+/**
+ * @param {{ disk: object, now?: () => number }} opts
+ */
+export function openNotices ({ disk, now = Date.now }) {
+  const file = NOTICES_FILE
+  const atRest = disk.atRest
+  let items = load()
+
+  function load () {
+    if (!disk.exists(file)) return []
+    try {
+      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 () {
+    disk.write(file, atRest.encrypt(JSON.stringify({ v: 1, items })))
+  }
+
+  const alive = (n) => now() - n.ts < NOTICE_TTL_MS
+
+  return {
+    /**
+     * 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.
+     */
+    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.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()
+      }
+      items = [...items.filter(alive), n]
+      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/core/notifiable.js

@@ -0,0 +1,73 @@
+/**
+ * QUÉ APROBADORES PUEDEN RECIBIR UN AVISO: lo dice cada uno, y caduca.
+ *
+ * Un aparato con `approve` que no recibe avisos es un aprobador solo en el papel: el pedido
+ * no le suena y solo lo ve si abre la app por su cuenta.
+ *
+ * Así que el aprobador lo declara: al pedir su lista de pedidos (`op: 'approvals'`, que ya
+ * manda firmado cada vez que se abre) dice `notify: true` si tiene los avisos encendidos.
+ * Aquí se apunta CUÁNDO lo dijo por última vez, y vale `NOTIFIABLE_TTL_MS`: una app que se
+ * desinstala deja de renovarlo.
+ *
+ * NO DECIDE NADA: SE ENSEÑA (dueño, 2026-10-08). Un día decidió si la bóveda pedía permiso
+ * para actualizarse —sin nadie que lo hubiera dicho, se actualizaba sola— y se quitó: era
+ * una condición más, y el silencio de un aprobador abría la puerta. Quién aprueba lo dice
+ * el acta y nada más; los avisos salen a todos los que tienen `approve`, lo hayan dicho o
+ * no. Esto sirve para VER a cuál no le está sonando el pedido (`members`, `status`, la
+ * consola).
+ *
+ * Y NO SE LE PREGUNTA AL PROXIO, que es quien guarda las suscripciones: es la pieza de la
+ * que el diseño no se fía, y creerle sería dejarle decidir cuándo no hace falta permiso.
+ *
+ * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer NO es «nadie
+ * puede recibir avisos»: se lanza.
+ */
+
+export const NOTIFIABLE_FILE = 'notifiable.json'
+/** Cuánto vale un «puedo recibir avisos» sin renovarse. */
+export const NOTIFIABLE_TTL_MS = 30 * 24 * 60 * 60 * 1000
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * @param {{ disk: object, now?: () => number }} opts
+ */
+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 = 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`)
+    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 aprobador. `true` lo apunta (o lo renueva); `false` lo quita
+     * ya, sin esperar a que caduque. Cualquier otra cosa no dice nada y no cambia nada: un
+     * cliente viejo, que no manda el campo, no borra lo que dijo uno nuevo.
+     */
+    declare (pub, canNotify) {
+      if (typeof pub !== 'string' || !pub) throw fail('bad-pub', 'declare: a device key is required')
+      if (canNotify === true) { items.set(pub, now()); save() } else if (canNotify === false && items.delete(pub)) save()
+    },
+    /** Cuándo lo dijo por última vez, o `null` si nunca o si ya caducó. */
+    since (pub) {
+      const t = items.get(pub)
+      return typeof t === 'number' && now() - t < NOTIFIABLE_TTL_MS ? t : null
+    }
+  }
+}

package/src/core/passwords.js

@@ -0,0 +1,125 @@
+/**
+ * LA BÓVEDA DE CONTRASEÑAS del dueño, atendida por el vault — Y QUE EL VAULT NO PUEDE LEER.
+ *
+ * Hasta 0.122 esto tenía una llave propia (`passwordsKey()`) guardada **dentro del mismo
+ * archivo que las entradas**, cifrada con la llave de la máquina. O sea: el demonio con el
+ * perfil CERRADO seguía descifrando contraseñas, y cualquiera con una copia del disco las
+ * leía todas. Era el mismo esquema que tuvo la maestra hasta que se selló.
+ *
+ * Ahora la bóveda es un cartero también para las contraseñas
+ * (`dotrino-passmanager/docs/sealed-passwords.md`): guarda sobres dirigidos a los aparatos
+ * y envolturas que no puede abrir. Lo que sí hace, y es lo que sostiene el modelo:
+ *
+ *   · dice A QUIÉN hay que envolver cada llave —sale del acta, y **la bóveda nunca está en
+ *     esa lista**: ni su maestra, ni su llave de comunicación;
+ *   · comprueba que quien escribe sea un aparato del acta con `passwords`, por su firma;
+ *   · filtra por destinatario al entregar, y decide si hace falta un dedo encima.
+ *
+ * Lo que SIGUE igual: el protocolo es de a una credencial, `list` no existe en remoto, y la
+ * aprobación es la misma del resto del vault (`caps +aprueba`).
+ */
+
+import { SealedStore, SealedResponder } from '@dotrino/passmanager'
+import { verifyDeviceSig } from '@dotrino/identity/capabilities'
+
+export const PASSWORDS_CAP = 'passwords'
+export const PASSKEYS_CAP = 'passkeys'
+
+/**
+ * @param {object} opts
+ *   `client`      cliente del proxio del vault, ya identificado
+ *   `store`       `{ get(k), set(k,v) }` donde viven los sobres
+ *   `members(kind)`  → `[{ pub, encPub }]` a quién envolverle cada llave (`main`/`passkeys`),
+ *                  SIN la bóveda. Lo pone `vault.js`, que es quien lee el acta.
+ *   `recoveryPub()`  la pública de la copia de recuperación (la que abre la frase)
+ *   `canWrite(pubkey)`  ¿ese aparato puede ESCRIBIR contraseñas? (acta: `passwords`)
+ *   `isAllowed(pubkey)` ¿puede pedir? — lo decide el acta, no esto
+ *   `encPubOf(pubkey)`  su llave de cifrado, para sellarle la respuesta
+ *   `needsApproval(pubkey)`  (async) si ese aparato tiene que pedir aprobación (`unattended`)
+ *   `approve({ pubkey, op })`  pide el visto bueno (el teléfono) y espera
+ *   `audit(op, info)`  la bitácora del vault
+ */
+export function createPasswordDesk (opts = {}) {
+  const {
+    client, store,
+    members = () => [],
+    recoveryPub = () => null,
+    canWrite = () => false,
+    isAllowed = () => false,
+    encPubOf = () => null,
+    needsApproval = () => true,
+    approve = async () => false,
+    audit = () => {},
+    log = () => {},
+  } = opts
+
+  const sealed = new SealedStore(store, {
+    recipients: (kind) => members(kind),
+    /**
+     * ¿LA FIRMÓ QUIEN DICE, Y PUEDE ESCRIBIR? Es lo único que la bóveda puede comprobar
+     * sobre una entrada cuyo contenido no ve. Las dos mitades importan: la firma ata el
+     * sobre a una llave, y el acta dice si esa llave tiene algo que hacer aquí.
+     */
+    verifyAuthor: async ({ body, author }) => {
+      if (!canWrite(author?.pub)) return false
+      return verifyDeviceSig({ publickey: author.pub, data: body, signature: author.sig })
+    },
+  })
+
+  const responder = new SealedResponder({
+    client,
+    store: sealed,
+    recipients: async () => ({
+      recoveryPub: recoveryPub(),
+      main: await members('main'),
+      passkeys: await members('passkeys'),
+    }),
+    isAllowed,
+    encPubOf,
+    // Dos condiciones, y las dos tienen que darse: que ese APARATO esté marcado para
+    // aprobar, y que lo que pide sea PRIVADO. Rellenar un nombre no es sacar un secreto, y
+    // pedir permiso para todo enseña a decir que sí sin mirar.
+    needsApproval: async (pubkey) => await needsApproval(pubkey),
+    approve,
+    onRequest: (r) => {
+      // La bitácora NO lleva qué credencial se pidió: eso es contenido del usuario.
+      audit('passwords', { op: r.op, outcome: r.outcome, device: (r.from || '').slice(0, 24) })
+      if (r.outcome !== 'ok') log(`[vault] passwords: ${r.op} ${r.outcome}`)
+    },
+  })
+
+  return {
+    start () { responder.start(); return this },
+    stop () { responder.stop() },
+    /**
+     * EL CANDADO DEL PERFIL YA NO PINTA NADA AQUÍ, y eso es la noticia: esta bóveda no
+     * tiene ninguna llave que cerrar. Se conserva el método porque quien lo llama no tiene
+     * por qué saberlo, y porque decirlo en la bitácora ayuda a entender el cambio.
+     */
+    lock () { audit('passwords.lock', { sealed: true }) },
+    unlock () {},
+    /** Para la consola local y las pruebas. Aquí tampoco se abre nada. */
+    sealed,
+    responder,
+  }
+}
+
+/**
+ * CONVERTIR LO QUE HAY (§2.7). Es un acto único y es **segundo trabajo de la maestra**: se
+ * hace al ABRIR la bóveda, que es cuando la frase está a mano y hay con qué reescribirlo
+ * todo.
+ *
+ * El trabajo está en `@dotrino/passmanager/sealed` y no aquí, porque lo hacen las CUATRO
+ * bóvedas: esta, la pestaña, la de dentro de la extensión y `passmanager serve`. Cuatro
+ * copias serían cuatro formas sutilmente distintas de reescribir lo mismo, y la que se
+ * quedara atrás no fallaría al convertir — fallaría al leerlo otra bóveda, meses después.
+ *
+ * Lo que sí es de aquí: `dropOldKey`, porque dónde vive la llave vieja lo sabe cada una.
+ */
+export async function convertPasswords ({ store, sealed, cek, recipients, author, dropOldKey, log = () => {} } = {}) {
+  const { convertToSealed } = await import('@dotrino/passmanager/sealed')
+  return convertToSealed({
+    store, sealed, cek, recipients, author, dropOldKey,
+    log: (m) => log('[vault] ' + m)
+  })
+}

package/src/core/sealKey.js

@@ -0,0 +1,77 @@
+/**
+ * La LLAVE DE SELLADO de esta bóveda: con ella FIRMA los sobres de los secretos, para
+ * que se sepa que salieron de aquí. Diseño: `docs/secretos-sellados.md` §8.8 y §8.9.
+ *
+ * Tres cosas que la hacen distinta de todo lo demás que hay en este directorio:
+ *
+ *   · **Firmar no es leer.** Esta llave no abre ningún valor. Por eso puede vivir
+ *     cifrada en reposo con la llave de la máquina y usarse **sin la frase** — que es
+ *     justo lo que hace posible administrar sin contraseña.
+ *   · **Su autoridad la da el ACTA**, que la nombra (`sealPub`) y que sella únicamente
+ *     la maestra. Ella no se autoriza a sí misma.
+ *   · **Rota con el acta.** Cada acta nueva puede estrenar una, así que aquí se guarda
+ *     un puñado: la vigente para firmar, y las anteriores porque un sobre se firmó con
+ *     la que mandaba entonces y hay que poder seguir firmando… no, seguir
+ *     **identificando** cuál era. Verificar se hace con la pública que dice el acta.
+ *
+ * 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 { readJson, writeJson } from './disk.js'
+import { signWithDevice } from '@dotrino/identity/capabilities'
+
+/**
+ * Cuántas llaves anteriores se conservan. Firmar solo usa la vigente; las viejas se
+ * guardan por si hay que re-firmar algo sellado con ellas (recoger el histórico), y
+ * porque tirarlas no ahorra nada: son cuatro líneas de JSON.
+ */
+const MAX_KEYS = 8
+
+/** Abre (o estrena) el llavero de sellado del perfil. */
+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(disk, file, data)
+  const find = (pub) => data.keys.find((k) => k.pub === pub) || null
+
+  return {
+    /** La pública de la llave vigente (la última estrenada), o `null` si no hay ninguna. */
+    current: () => data.keys[data.keys.length - 1]?.pub || null,
+
+    /** ¿Tenemos la privada de esta pública? Es lo que decide si podemos firmar por ella. */
+    has: (pub) => !!find(pub),
+
+    /**
+     * Estrena una llave y devuelve su PÚBLICA, para que el acta la nombre. La privada
+     * se queda aquí; no sale de esta máquina ni viaja a ninguna parte.
+     *
+     * Es lo que se le pasa a `identity.setSealKeyProvider`, así que se llama una vez
+     * por acta sellada.
+     */
+    async mint () {
+      const pair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify'])
+      const pub = JSON.stringify(await crypto.subtle.exportKey('jwk', pair.publicKey))
+      const priv = await crypto.subtle.exportKey('jwk', pair.privateKey)
+      data.keys.push({ pub, priv, createdAt: Date.now() })
+      if (data.keys.length > MAX_KEYS) data.keys = data.keys.slice(-MAX_KEYS)
+      save()
+      return pub
+    },
+
+    /**
+     * Firma un cuerpo con la llave que el acta nombra. Devuelve `null` si esa llave no es
+     * nuestra —el disco se restauró, o el acta la puso otro master—: entonces el sobre
+     * sale SIN firma, que es peor que firmado pero mucho mejor que no poder guardar.
+     */
+    async sign (sealPub, body) {
+      const k = sealPub ? find(sealPub) : null
+      if (!k) return null
+      const { signature } = await signWithDevice({ privateJwk: k.priv, publickey: k.pub, data: body })
+      return signature
+    }
+  }
+}
+
+export default { openSealKeys }