@dotrino/vaultd 0.114.0 → 0.116.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.114.0",
+  "version": "0.116.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": {
@@ -26,6 +26,7 @@
     "@dotrino/passmanager": "^0.10.1",
     "@dotrino/proxy-client": "0.18.2",
     "@dotrino/roadmap": "0.2.0",
+    "@dotrino/store": "0.11.0",
     "ws": "^8.18.0"
   },
   "license": "MIT",

package/src/approvals.js

@@ -23,6 +23,13 @@
  * otra máquina por el proxio, donde mandarlo en claro filtraría las rutas del dueño— no
  * tiene huella con la que emparejarse, y entonces se pide aprobación cada vez. No se
  * inventa una huella «vacía» que valdría para todo: eso sería exactamente un repliegue.
+ *
+ * Y PARA EL GESTOR DE CONTRASEÑAS ESO ES LO QUE SE QUIERE, no una carencia que arreglar
+ * (dueño, 2026-09-11: «para el gestor de contraseñas es perfecto»). La extensión es un
+ * navegador hablando por el proxio, no un proceso con línea de comandos, así que nunca va a
+ * traer huella — y así cada acceso a una credencial vuelve a pasar por tu mano, que es la
+ * 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'
 

package/src/client.js

@@ -11,7 +11,8 @@
  * estrictamente (firmado por la maestra que vio en el QR, y para SU clave) antes de
  * guardarlo. La maestra nunca sale del vault.
  */
-import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
+import { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
+import { myContentKey, encryptWithCek, decryptWithKeyring } from '@dotrino/identity/content'
 import { sealersOf } from '@dotrino/identity/acta'
 
 /**
@@ -61,20 +62,25 @@ function waitFor (client, predicate, timeoutMs = 30000) {
  * @param {string} [opts.label]
  * @param {(c:{deviceId:string,code:string})=>void} [opts.onChallenge]  Para MOSTRAR el código que el usuario tipea en la bóveda.
  * @param {number} [opts.approveTimeoutMs]  Cuánto esperar la aprobación humana (def 3 min).
- * @returns {Promise<{ device, cert, iss:string }>}  GUARDAR `device` (incluye la privada) + `cert`. `iss` = qr.iss verificado.
+ * @returns {Promise<{ device, cert, iss:string, acta }>}  GUARDAR `device` (incluye las privadas de firma y de
+ *   cifrado), `cert` y `acta` (trae la clave de contenido envuelta para este aparato: sin ella el
+ *   almacén de la bóveda no se puede usar). `iss` = qr.iss verificado.
  */
 export async function enroll ({ qr, label = '', dir, onChallenge, approveTimeoutMs = 180000 } = {}) {
   if (!qr?.iss || !qr?.proxy || !qr?.token || !qr?.sn) throw new Error('invalid qr (v2): missing iss/proxy/token/sn')
   const client = await freshClient({ proxyUrl: qr.proxy, dir })
   try {
     const device = await makeDeviceKey({ label })
+    // La llave de CIFRADO del aparato: con su pública en el acta, la bóveda le envuelve la
+    // clave de contenido al admitirlo. Sin ella no podría usar el almacén, que solo entra cifrado.
+    const enc = await makeDeviceEncKey()
     const myDeviceId = (await pubkeyId(device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
     // ESTE dispositivo genera el código y lo MUESTRA; solo viaja su COMPROMISO. El vault
     // lo aprende cuando un humano lo tipea, y solo firma el cert si el compromiso coincide.
     const code = makePairingCode()
     const commit = await commitCode({ code, dpub: device.publickey, sn: qr.sn })
     // ENROLL firmado con D = prueba de posesión (un token robado ya no basta).
-    const data = { op: 'enroll', dpub: device.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now() }
+    const data = { op: 'enroll', dpub: device.publickey, encPub: enc.encPublickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {
@@ -102,7 +108,7 @@ export async function enroll ({ qr, label = '', dir, onChallenge, approveTimeout
     if (!v.ok) throw new Error('invalid cert: ' + v.reason)
     if (res.cert.sub !== device.publickey) throw new Error('cert issued for a different device')
     // OJO: devolvemos qr.iss (la maestra que el usuario VIO), NO res.iss.
-    return { device, cert: res.cert, iss: qr.iss }
+    return { device: { ...device, encPublickey: enc.encPublickey, encPrivateJwk: enc.encPrivateJwk }, cert: res.cert, iss: qr.iss, acta: res.acta }
   } finally { client.close() }
 }
 
@@ -171,17 +177,28 @@ export async function requestRenew ({ masterPubkey, proxyUrl, device, cert, dir
   } finally { client.close() }
 }
 
-/** Llama un método del store de hilos/aperturas del vault (scope vault:store). */
-export async function requestStore ({ masterPubkey, proxyUrl, device, cert, method, args, dir } = {}) {
+/**
+ * Llama un método del almacén de la bóveda (scope vault:store), CIFRADO de punta a punta con
+ * la clave de contenido del perfil: la bóveda no acepta el almacén en claro, porque el proxio
+ * no cifra. `acta` es la que devolvió `enroll` (o una más nueva): de su `keyring` sale la
+ * clave envuelta para este aparato.
+ */
+export async function requestStore ({ masterPubkey, proxyUrl, device, cert, acta, method, args, dir } = {}) {
+  if (!device?.encPrivateJwk) throw Object.assign(new Error('this device has no encryption key: enrol it again'), { code: 'no-enc-key' })
+  const myEncPrivateKey = await importDeviceEncKey(device.encPrivateJwk)
+  const mine = await myContentKey({ keyring: acta?.keyring, myPub: device.publickey, myEncPrivateKey })
+  if (!mine) throw Object.assign(new Error('this device does not hold the profile content key yet'), { code: 'no-content-key' })
+  const enc = await encryptWithCek({ cek: mine.cek, gen: mine.gen, plaintext: JSON.stringify(args ?? {}) })
   const client = await freshClient({ proxyUrl, dir })
   try {
-    const data = { op: 'store', method, args: args || {}, publickey: device.publickey, ts: Date.now() }
+    const data = { op: 'store', method, enc, publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
     const pending = waitFor(client, (p) => p.type === MSG.STORE_RESULT || p.type === MSG.ERROR)
     client.sendByPubkey(masterPubkey, { type: MSG.STORE, data, signature, cert })
     const res = await pending
-    if (res.type === MSG.ERROR) throw new Error(res.error)
-    return res.result
+    if (res.type === MSG.ERROR) throw Object.assign(new Error(res.error), res.code ? { code: res.code } : {})
+    if (!res.result?.__enc) throw Object.assign(new Error('the vault replied to the store without encrypting it'), { code: 'vault-reply-unsealed' })
+    return JSON.parse(await decryptWithKeyring({ envelope: res.result.__enc, keyring: acta.keyring, myPub: device.publickey, myEncPrivateKey }))
   } finally { client.close() }
 }
 

package/src/threadStore.js

@@ -14,10 +14,14 @@
  * que el ecosistema promete que no queda en claro en ningún disco.
  */
 import path from 'node:path'
+import * as core from '@dotrino/store/core'
 import { readJson, writeJson } from './paths.js'
 import { atRestFor } from './atrest.js'
 
-const MAX_PER_THREAD = 1000
+// El MISMO tope que acepta la página del almacén. Era 1000: una app que guarda más en un
+// hilo (los compradores de facturero, por ejemplo) perdía aquí lo más viejo sin decir nada,
+// y el navegador lo volvía a subir en cada sincronización.
+const MAX_PER_THREAD = core.MAX_PER_THREAD_LIMIT
 
 // DATOS SENSIBLES (F4): topes para que un dispositivo con `vault:store` no pueda
 // llenar el disco de la bóveda. Son generosos para el uso real (unas contraseñas,
@@ -33,24 +37,31 @@ export function openThreadStore (dir) {
   if (!data.threads) data.threads = {}
   if (!data.opens) data.opens = {}
   if (!data.secure) data.secure = {}
+  // Lápidas de lo borrado (`@dotrino/store/core`): sin ellas un borrado vuelve desde el
+  // primer aparato que todavía tenga la entrada.
+  if (!data.tombs) data.tombs = {}
+  core.pruneTombs(data.tombs, Date.now())
   const save = () => writeJson(file, data, atRest)
   save() // reescribe al abrir: cifra lo que venía en claro
-  const trim = (arr) => { if (arr.length > MAX_PER_THREAD) arr.splice(0, arr.length - MAX_PER_THREAD) }
+  const budget = (n) => Math.min(Math.max(Number(n) || core.PAGE_BYTES, 1024), core.PAGE_BYTES)
+  const needKeys = (keys) => {
+    if (!Array.isArray(keys) || !keys.every((k) => typeof k === 'string')) throw new Error('keys must be a list of thread keys')
+    return keys
+  }
+  const needMap = (value, what) => {
+    if (value == null) return {}
+    if (typeof value !== 'object' || Array.isArray(value)) throw new Error(`${what} must be an object`)
+    return value
+  }
 
   const methods = {
     appendMessage ({ threadKey, entry }) {
-      if (!threadKey || typeof threadKey !== 'string') throw new Error('threadKey required')
-      if (!entry || typeof entry !== 'object') throw new Error('entry required')
-      if (!entry.id) entry.id = crypto.randomUUID()
-      if (!entry.ts) entry.ts = Date.now()
-      const arr = data.threads[threadKey] || (data.threads[threadKey] = [])
-      const i = arr.findIndex((e) => e.id === entry.id)
-      if (i >= 0) arr[i] = { ...arr[i], ...entry }; else arr.push(entry)
-      trim(arr); save(); return entry
+      core.writeEntry(data.threads, data.tombs, threadKey, entry, { max: MAX_PER_THREAD, now: Date.now(), newId: () => crypto.randomUUID() })
+      save(); return entry
     },
     listThread ({ threadKey, limit, before }) {
-      if (!threadKey) return []
-      let arr = data.threads[threadKey] || []
+      if (!core.validKey(threadKey) || !Object.hasOwn(data.threads, threadKey)) return []
+      let arr = data.threads[threadKey]
       if (typeof before === 'number') arr = arr.filter((e) => (e.ts || 0) < before)
       if (typeof limit === 'number' && limit > 0) arr = arr.slice(-limit)
       return arr
@@ -62,14 +73,14 @@ export function openThreadStore (dir) {
       return out
     },
     removeThread ({ threadKey }) {
-      const removed = data.threads[threadKey]?.length || 0
-      delete data.threads[threadKey]; save(); return { removed }
+      const removed = core.removeWholeThread(data.threads, data.tombs, threadKey, Date.now())
+      if (removed) save()
+      return { removed }
     },
     removeMessage ({ threadKey, id }) {
-      const arr = data.threads[threadKey] || []; const before = arr.length
-      data.threads[threadKey] = arr.filter((e) => e.id !== id)
-      if (data.threads[threadKey].length === 0) delete data.threads[threadKey]
-      save(); return { removed: before - (data.threads[threadKey]?.length || 0) }
+      const removed = core.removeEntry(data.threads, data.tombs, threadKey, id, Date.now())
+      if (removed) save()
+      return { removed }
     },
     recordOpen ({ appId }) {
       if (!appId || typeof appId !== 'string') throw new Error('appId required')
@@ -79,17 +90,38 @@ export function openThreadStore (dir) {
     },
     getOpens () { return { ...data.opens } },
     clearOpens () { data.opens = {}; save(); return { ok: true } },
+    /** Mezcla el contador de un aparato (el mayor de cada lado) y devuelve el resultado. */
+    mergeOpens ({ opens }) {
+      if (core.mergeOpens(data.opens, needMap(opens, 'opens'))) save()
+      return { ...data.opens }
+    },
     exportThreads () { return { threads: data.threads } },
-    importThreads ({ threads, mode = 'merge' }) {
+    // ----- SINCRONIZAR POR PARTES (@dotrino/store ≥ 0.11) -----
+    // `exportThreads`/`importThreads` a secas mueven TODO en un mensaje, y el proxio corta
+    // los frames en 1 MB: con unos cientos de KB de datos la sincronización dejaba de caber.
+    // Con esto el aparato pregunta qué hilos difieren (una huella por hilo), baja su índice
+    // (id y ts) y pide solo las entradas que le faltan, todo por páginas con tope de bytes.
+    // Las reglas —huella, mezcla, lápidas— son las de `@dotrino/store/core`, las mismas que
+    // aplica el navegador: si cada lado llevara las suyas, las huellas no coincidirían nunca.
+    getThreadDigests ({ keys } = {}) {
+      return core.digestsOf(data.threads, keys == null ? undefined : needKeys(keys))
+    },
+    getThreadIndexes ({ keys, cursor, maxBytes }) {
+      return core.indexPage(data.threads, data.tombs, needKeys(keys), cursor || null, budget(maxBytes))
+    },
+    getEntries ({ refs, maxBytes }) {
+      return core.entriesPage(data.threads, needMap(refs, 'refs'), budget(maxBytes))
+    },
+    importThreads ({ threads, tombs, mode = 'merge' }) {
       if (!threads || typeof threads !== 'object') throw new Error('threads required')
       if (mode === 'replace') { data.threads = threads; save(); return { mode, count: Object.keys(threads).length } }
-      for (const [k, arr] of Object.entries(threads)) {
-        const cur = data.threads[k] || (data.threads[k] = [])
-        const byId = new Map(cur.map((e) => [e.id, e]))
-        for (const e of arr) { if (!e?.id) continue; const pr = byId.get(e.id); if (!pr || (e.ts || 0) > (pr.ts || 0)) byId.set(e.id, e) }
-        data.threads[k] = Array.from(byId.values()).sort((a, b) => (a.ts || 0) - (b.ts || 0)); trim(data.threads[k])
-      }
-      save(); return { mode, count: Object.keys(data.threads).length }
+      if (mode !== 'merge' && mode !== 'upsert') throw new Error(`unknown import mode: ${mode}`)
+      const now = Date.now()
+      const buried = core.applyTombs(data.threads, data.tombs, needMap(tombs, 'tombs'), now)
+      const merged = core.mergeEntries(data.threads, data.tombs, threads, { mode, max: MAX_PER_THREAD })
+      core.pruneTombs(data.tombs, now)
+      if (buried.tombsChanged || buried.changed.size || merged.size) save()
+      return { mode, count: Object.keys(data.threads).length, changed: [...new Set([...buried.changed, ...merged])] }
     },
     // ----- PERFIL del usuario (me): el vault es la copia AUTORITATIVA -----
     // Cada dispositivo emparejado lo empuja al editarlo y lo jala al arrancar →
@@ -182,7 +214,8 @@ export function openThreadStore (dir) {
  * dispositivo al que solo le diste «leer» no lee tus contraseñas.
  */
 export const STORE_READ_METHODS = new Set([
-  'listThread', 'listThreadKeys', 'getThreadSummaries', 'getOpens', 'exportThreads', 'getStats', 'profileGet'
+  'listThread', 'listThreadKeys', 'getThreadSummaries', 'getOpens', 'exportThreads', 'getStats', 'profileGet',
+  'getThreadDigests', 'getThreadIndexes', 'getEntries'
 ])
 
 /**

package/src/vault.js

@@ -936,7 +936,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // `method: 'toString'` (o cualquier miembro heredado de Object) pasaba el filtro y
     // se llamaba como si fuera del store.
     if (!d || typeof d.method !== 'string' || !Object.hasOwn(threads.methods, d.method)) {
-      return reply(from, { type: MSG.ERROR, error: 'store: invalid method' })
+      // Con `code`: un aparato más nuevo que esta bóveda pide métodos que aquí no existen, y
+      // tiene que poder decir «actualiza la bóveda» en vez de enseñar la frase.
+      return reply(from, { type: MSG.ERROR, error: 'store: invalid method', code: 'store-unknown-method' })
     }
     if (!isFresh(d)) return staleReply(from)
     // EL PERFIL VA POR OTRO CAMINO, y por eso se atiende antes que nada
@@ -949,6 +951,16 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     //     guardar un archivo en tu bóveda (dueño, 2026-09-03). El proxio tiene `guarda`
     //     para lo suyo y no debe poder cambiar quién eres.
     if (PROFILE_METHODS.has(d.method)) return await handleProfile(from, p, d)
+    // EL ALMACÉN SOLO ENTRA CIFRADO. Lo que va por aquí —hilos de las apps, contraseñas,
+    // el `me` heredado— viaja por el proxio, que no cifra; en claro lo leería quien lo
+    // opere. Los clientes del ecosistema cifran desde @dotrino/identity 0.91.0, y hasta
+    // entonces uno sin la clave de contenido mandaba en claro «como antes»: aceptarlo aquí
+    // era dejar ese camino abierto para cualquier cliente viejo. El perfil (arriba) va
+    // aparte a propósito: lo privado viaja en sobres y lo público es público.
+    if (!d.enc) {
+      audit('rejected', { what: 'store', method: d.method, reason: 'unsealed' })
+      return reply(from, { type: MSG.ERROR, error: 'store: requests must be sealed with the profile content key', code: 'store-unsealed' })
+    }
     // CANDADO del perfil (contraseña opcional): solo frena EDITAR el perfil heredado
     // (`profileSet`, el `me` plano). Un dispositivo enrolado puede seguir firmando,
     // leyendo y guardando contenido.
@@ -968,15 +980,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!await actaAllows(from, chk, chk.scope === SCOPE.READ ? SCOPE.READ : SCOPE.STORE, 'store')) return
     try {
       // CIFRADO de punta a punta con la clave de contenido del perfil: el proxy transporta
-      // pero no ve nada de lo que el usuario guarda. Si el dispositivo mandó `enc`, se abre
-      // aquí con la clave de la bóveda (que también es miembro) y la respuesta vuelve igual.
-      let args = d.args || {}
-      let cek = null
-      if (d.enc) {
-        cek = await identity.contentKey?.().catch(() => null)
-        if (!cek) return reply(from, { type: MSG.ERROR, error: 'store: this vault does not hold the profile content key' })
-        args = JSON.parse(await identity.openContent(d.enc))
-      }
+      // pero no ve nada de lo que el usuario guarda. Se abre aquí con la clave de la bóveda
+      // (que también es miembro) y la respuesta vuelve igual.
+      const cek = await identity.contentKey()
+      if (!cek) return reply(from, { type: MSG.ERROR, error: 'store: this vault does not hold the profile content key', code: 'vault-no-content-key' })
+      const args = JSON.parse(await identity.openContent(d.enc))
       const result = await threads.methods[d.method](args)
       // Que un aparato ESCRIBA en tu bóveda queda anotado. Antes solo se auditaba el
       // rechazo, así que la bitácora contaba quién entró pero no qué hizo después.
@@ -985,11 +993,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (!STORE_READ_METHODS.has(d.method)) {
         audit('store', { device: await deviceIdOf(chk.device), method: d.method })
       }
-      if (cek) {
-        const enc = await identity.sealContent(JSON.stringify(result ?? null))
-        return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: { __enc: enc } })
-      }
-      reply(from, { type: MSG.STORE_RESULT, method: d.method, result })
+      const enc = await identity.sealContent(JSON.stringify(result ?? null))
+      reply(from, { type: MSG.STORE_RESULT, method: d.method, result: { __enc: enc } })
     } catch (e) { reply(from, { type: MSG.ERROR, error: e.message }) }
   }