@dotrino/vaultd 0.12.0 → 0.14.0

package/src/daemon.js

@@ -42,10 +42,10 @@ function comprobarInstanciaUnica (dir) {
   const pid = Number(s?.pid)
   if (!pid || pid === process.pid) return
   try { process.kill(pid, 0) } catch (_) { return } // no existe: el candado es de un muerto
-  console.error('Ya hay una bóveda corriendo sobre estos datos (proceso %d).', pid)
-  console.error('  datos: %s', dir)
-  console.error('Dos bóvedas sobre el mismo directorio se pisan: párá la otra, o usa')
-  console.error('DOTRINO_VAULT_DIR para darle a esta un directorio propio.')
+  console.error('A vault is already running on this data (process %d).', pid)
+  console.error('  data: %s', dir)
+  console.error('Two vaults on the same directory step on each other: stop the other one,')
+  console.error('or use DOTRINO_VAULT_DIR to give this one its own directory.')
   process.exit(3)
 }
 
@@ -91,7 +91,7 @@ export async function runDaemon () {
     try {
       const id = req?.profile ? mgr.resolve(req.profile) : mgr.currentId()
       return { id, vault: mgr.get(id) }
-    } catch (e) { console.error('[vault] perfil inválido en la petición:', e.message); return null }
+    } catch (e) { console.error('[vault] invalid profile in the request:', e.message); return null }
   }
   const targetOf = (req) => resolveTarget(req)?.vault || null
 
@@ -139,7 +139,7 @@ export async function runDaemon () {
         const cur = readJsonSafe(pairFile)
         if (cur?.qr?.token === tok) rm(pairFile)
       }, expiresInMs + 1000).unref?.()
-      console.log('[vault] emparejamiento iniciado (válido %d min)', expiresInMs / 60000)
+      console.log('[vault] pairing started (valid for %d min)', expiresInMs / 60000)
     } catch (e) {
       console.error('[vault] no se pudo iniciar emparejamiento:', e.message)
     }
@@ -154,6 +154,16 @@ export async function runDaemon () {
   const secretsListFile = path.join(dir, 'secrets-list.json')
   const profileReqFile = path.join(dir, 'profile-request.json')
   const dumpReqFile = path.join(dir, 'dump-request.json')
+  const meReqFile = path.join(dir, 'me-request.json')
+  const meFile = path.join(dir, 'me.json')
+
+  /** Resumen de la foto de perfil: qué es y cuánto pesa, nunca los bytes. */
+  function avatarInfo (avatar) {
+    if (typeof avatar !== 'string' || !avatar) return null
+    const m = /^data:([^;,]+)?(?:;base64)?,(.*)$/s.exec(avatar)
+    if (!m) return { type: null, bytes: avatar.length }
+    return { type: m[1] || 'desconocido', bytes: Math.floor(m[2].length * 3 / 4) }
+  }
 
   /**
    * Órdenes de perfil (crear/renombrar/borrar/activar) y del candado
@@ -175,7 +185,7 @@ export async function runDaemon () {
       case 'lock': { mgr.profiles.lock(ref()); return { done: 'perfil bloqueado' } }
       case 'password-set': { await mgr.profiles.setPassword(ref(), req.password); return { done: 'contraseña guardada' } }
       case 'password-rm': { mgr.profiles.removePassword(ref()); return { done: 'contraseña quitada' } }
-      default: throw new Error('operación de perfil desconocida: ' + req.op)
+      default: throw new Error('unknown profile operation: ' + req.op)
     }
   }
 
@@ -186,7 +196,7 @@ export async function runDaemon () {
         try {
           const vault = targetOf(appr)
           const r = await vault.approveDevice(appr.code); rm(pendingEnrollFile); rm(pairFile); console.log('[vault] aprobado %s', r.deviceId)
-        } catch (e) { console.error('[vault] aprobación falló:', e.message) }
+        } catch (e) { console.error('[vault] approval failed:', e.message) }
         rm(approveReqFile)
       }
       const rej = readJsonSafe(rejectReqFile)
@@ -200,13 +210,13 @@ export async function runDaemon () {
         rm(path.join(dir, 'caps-request.json'))
         try {
           await targetOf(capsReq)?.setCaps(capsReq.pub, capsReq.caps)
-          console.log('[vault] permisos actualizados: %s', capsReq.caps.join(', ') || '(ninguno)')
-        } catch (e) { console.error('[vault] no se pudieron cambiar los permisos:', e.message) }
+          console.log('[vault] permissions updated: %s', capsReq.caps.join(', ') || '(ninguno)')
+        } catch (e) { console.error('[vault] could not change permissions:', e.message) }
       }
       const req = readJsonSafe(revokeReqFile)
       if (req?.nonce) {
-        try { await targetOf(req)?.revokeDevice(req.nonce); console.log('[vault] revocado nonce=%s', req.nonce) }
-        catch (e) { console.error('[vault] revocación falló:', e.message) }
+        try { await targetOf(req)?.revokeDevice(req.nonce); console.log('[vault] revoked nonce=%s', req.nonce) }
+        catch (e) { console.error('[vault] revocation failed:', e.message) }
         rm(revokeReqFile)
       }
       // Secretos de servicios: `secret set/rm` del CLI. El archivo con el valor
@@ -216,9 +226,9 @@ export async function runDaemon () {
         rm(secretReqFile)
         try {
           const vault = targetOf(sec)
-          if (sec.op === 'set') { vault.setSecret(sec.ns, sec.key, sec.value); console.log('[vault] secreto guardado: %s/%s', sec.ns, sec.key) }
-          else if (sec.op === 'rm') { vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secreto borrado: %s/%s', sec.ns, sec.key) }
-        } catch (e) { console.error('[vault] secreto falló:', e.message) }
+          if (sec.op === 'set') { vault.setSecret(sec.ns, sec.key, sec.value); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
+          else if (sec.op === 'rm') { vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
+        } catch (e) { console.error('[vault] secret failed:', e.message) }
       }
       // Perfiles / candado.
       const preq = readJsonSafe(profileReqFile)
@@ -228,7 +238,7 @@ export async function runDaemon () {
         try { extra = await handleProfileRequest(preq) }
         // `code`: la TUI es bilingüe y traduce por código (un freno como el D12 tiene
         // que leerse en el idioma de quien lo lee, no en el del daemon).
-        catch (e) { extra = { error: e.message, ...(e.code ? { code: e.code } : {}) }; console.error('[vault] perfil: %s', e.message) }
+        catch (e) { extra = { error: e.message, ...(e.code ? { code: e.code } : {}) }; console.error('[vault] profile: %s', e.message) }
         dumpProfiles(extra)
       } else {
         dumpProfiles()
@@ -242,8 +252,32 @@ export async function runDaemon () {
       writeJson(devFile, { v: 1, at: Date.now(), profile: t.id, ...(await t.vault.listDevices()) })
       // Acta del perfil: quién es del perfil y qué puede hacer cada uno (`members`/`caps`).
       try { writeJson(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), profile: t.id, ...(await t.vault.profileMembers()) }) } catch (_) {}
+
+      // PERFIL del usuario (apodo, foto, datos) tal como lo tiene la bóveda: `dotrino-vault me`.
+      // Solo se vuelca cuando se PIDE, no en cada señal: es contenido del usuario y no tiene
+      // por qué quedar escrito en un archivo suelto cada vez que alguien mira los miembros.
+      // La FOTO no entra en el volcado (son hasta ~90 KB de data-URI que nadie va a leer en
+      // una terminal): se resume, y si la quieres, `--foto <archivo>` la escribe donde digas.
+      const meReq = readJsonSafe(meReqFile)
+      if (meReq) {
+        rm(meReqFile)
+        try {
+          const tm = resolveTarget(meReq) || { id: mgr.currentId(), vault: mgr.current() }
+          const { me } = tm.vault.threads.methods.profileGet()
+          const { avatar, ...resto } = me || {}
+          let guardada = null
+          if (meReq.avatarPath && typeof avatar === 'string') {
+            const m = /^data:([^;,]+)?(?:;base64)?,(.*)$/s.exec(avatar)
+            if (m) {
+              fs.writeFileSync(meReq.avatarPath, Buffer.from(m[2], 'base64'), { mode: 0o600 })
+              guardada = meReq.avatarPath
+            }
+          }
+          writeJson(meFile, { v: 1, at: Date.now(), profile: tm.id, me: me ? { ...resto, avatar: avatarInfo(avatar) } : null, avatarGuardada: guardada })
+        } catch (e) { console.error('[vault] could not dump the profile:', e.message) }
+      }
     } catch (e) {
-      console.error('[vault] error en señal de control:', e.message)
+      console.error('[vault] error handling a control signal:', e.message)
     }
   }
 
@@ -272,14 +306,14 @@ export async function runDaemon () {
       // atiende cuando el archivo YA parsea; si no, lo recoge el repaso de 2 s.
       if (readJsonSafe(pairReqFile)) await atenderEmparejamiento()
       await atenderPeticiones()
-    } catch (e) { console.error('[vault] error atendiendo una petición:', e.message) }
+    } catch (e) { console.error('[vault] error serving a request:', e.message) }
     finally { atendiendo = false }
   }
 
   try {
     fs.watch(dir, (_ev, file) => { if (!file || /-request\.json$/.test(file)) atender() })
   } catch (e) {
-    console.error('[vault] no se pudo vigilar %s (%s); se atenderá solo por repaso', dir, e.message)
+    console.error('[vault] could not watch %s (%s); will be served by polling only', dir, e.message)
   }
   const repaso = setInterval(atender, REPASO_MS)
   repaso.unref?.()

package/src/manager.js

@@ -72,7 +72,7 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
 
   const get = (id) => {
     const v = running.get(id)
-    if (!v) throw new Error('el perfil no está abierto: ' + id)
+    if (!v) throw new Error('profile is not open: ' + id)
     return v
   }
 
@@ -120,7 +120,7 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
         ])
         assertCanRemove({ isMaster: soyMaster, memberCount: (acta?.members || []).length, name: profiles.get(id)?.name || id })
       } else {
-        log('[vault] perfil %s no está abierto: se borra sin poder comprobar su acta', id)
+        log('[vault] profile %s is not open: deleting without being able to check its record', id)
       }
       const res = profiles.remove(id) // valida: no es el único, no está bloqueado
       try { running.get(id)?.close() } catch (_) {}

package/src/paths.js

@@ -1,8 +1,14 @@
 /**
  * Resolución del directorio de datos y escritura de archivos con permisos
- * restrictivos (0600). En v1 la clave maestra va en claro dentro de este dir
- * (la guarda `@dotrino/identity` en `identity.json`); 0600 evita que sea
- * world-readable. v2 añadirá cifrado en reposo con contraseña maestra.
+ * restrictivos (0600) **y cifrados en reposo**.
+ *
+ * `readJson`/`writeJson` aceptan un códec de reposo (`atRestFor(dir)`, ver
+ * `atrest.js`): con él, el contenido del archivo NO queda en claro en el disco.
+ * Lo usan TODOS los archivos de datos del vault —identidad, árbol de contenido
+ * (`vault.json`), hilos y perfil (`threads.json`) y secretos de servicios
+ * (`secrets.json`)—, no solo la identidad: el contenido del usuario merece el
+ * mismo trato que la maestra. `decrypt` deja pasar el texto en claro, así que
+ * una instalación anterior se lee igual y queda cifrada en la primera escritura.
  */
 import os from 'node:os'
 import path from 'node:path'
@@ -33,15 +39,25 @@ export function ensureDir (dir) {
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
 }
 
-export function readJson (file, fallback) {
-  try { return JSON.parse(fs.readFileSync(file, 'utf8')) } catch (_) { return fallback }
+/** @param {{decrypt:(t:string)=>string}} [atRest] códec de reposo (`atRestFor(dir)`). */
+export function readJson (file, fallback, atRest) {
+  try {
+    let text = fs.readFileSync(file, 'utf8')
+    if (atRest) text = atRest.decrypt(text)
+    return JSON.parse(text)
+  } catch (_) { return fallback }
 }
 
-/** Escritura atómica (tmp + rename) con modo 0600. */
-export function writeJson (file, obj) {
+/**
+ * Escritura atómica (tmp + rename) con modo 0600. Con `atRest`, el archivo se
+ * escribe CIFRADO (nunca toca el disco en claro: se cifra antes del tmp).
+ * @param {{encrypt:(t:string)=>string}} [atRest]
+ */
+export function writeJson (file, obj, atRest) {
   ensureDir(path.dirname(file))
+  const text = JSON.stringify(obj, null, 2)
   const tmp = file + '.tmp'
-  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2), { mode: 0o600 })
+  fs.writeFileSync(tmp, atRest ? atRest.encrypt(text) : text, { mode: 0o600 })
   fs.renameSync(tmp, file)
   try { fs.chmodSync(file, 0o600) } catch (_) {}
 }

package/src/profiles.js

@@ -28,8 +28,14 @@ const REGISTRY = 'profiles.json'
 const PWD_ITER = 300000 // mismo coste que el candado del navegador
 const MAX_NAME = 40
 
-/** Archivos de un perfil que en la versión mono-perfil vivían sueltos en la raíz. */
-const LEGACY_FILES = ['identity.json', 'peers.json', 'vault.json', 'threads.json', 'secrets.json', 'activity.log']
+/**
+ * Archivos de un perfil que en la versión mono-perfil vivían sueltos en la raíz.
+ *
+ * `atrest.salt` va en la lista y NO es un detalle: los datos van cifrados con una clave
+ * derivada del salt que vive JUNTO a ellos, así que mover los archivos sin el salt los
+ * dejaría ilegibles (la clave se derivaría de un salt nuevo). Se mudan juntos.
+ */
+const LEGACY_FILES = ['identity.json', 'peers.json', 'vault.json', 'threads.json', 'secrets.json', 'activity.log', 'atrest.salt']
 
 const b64 = (buf) => Buffer.from(new Uint8Array(buf)).toString('base64')
 
@@ -70,7 +76,7 @@ export function openProfiles (root = dataDir()) {
 
   function assertExists (id) {
     const p = find(id)
-    if (!p) throw new Error('el perfil no existe: ' + id)
+    if (!p) throw new Error('profile does not exist: ' + id)
     return p
   }
 
@@ -92,7 +98,7 @@ export function openProfiles (root = dataDir()) {
       const hits = data.profiles.filter((p) => (p.name || '').toLowerCase() === needle)
       if (hits.length === 1) return hits[0].id
       if (hits.length > 1) throw new Error(`hay ${hits.length} perfiles llamados "${ref}"; usa su id (dotrino-vault profile ls)`)
-      throw new Error('el perfil no existe: ' + ref)
+      throw new Error('profile does not exist: ' + ref)
     },
 
     /**
@@ -162,7 +168,7 @@ export function openProfiles (root = dataDir()) {
     /** Borra el perfil y TODOS sus datos (incluida su maestra). Irreversible. */
     remove (id) {
       const p = assertExists(id)
-      if (data.profiles.length <= 1) throw new Error('no se puede borrar el único perfil')
+      if (data.profiles.length <= 1) throw new Error('cannot delete the only profile')
       api.assertUnlocked(id)
       data.profiles = data.profiles.filter((x) => x.id !== id)
       if (data.current === id) data.current = data.profiles[0].id
@@ -177,7 +183,7 @@ export function openProfiles (root = dataDir()) {
     isProtected: (id) => !!find(id)?.pwd,
     isLocked: (id) => { const p = find(id); return !!p?.pwd && !unlocked.has(id) },
     assertUnlocked (id) {
-      if (api.isLocked(id)) throw new Error('perfil bloqueado: desbloquéalo con tu contraseña (dotrino-vault unlock)')
+      if (api.isLocked(id)) throw new Error('profile locked: unlock it with your password (dotrino-vault unlock)')
     },
 
     async unlock (id, password) {
@@ -193,7 +199,7 @@ export function openProfiles (root = dataDir()) {
       if (proof !== p.pwd.verifier) {
         p.tries = { n: tries.n + 1, at: Date.now() }
         save()
-        throw new Error('contraseña incorrecta')
+        throw new Error('wrong password')
       }
       delete p.tries
       save()
@@ -207,7 +213,7 @@ export function openProfiles (root = dataDir()) {
     async setPassword (id, password) {
       const p = assertExists(id)
       api.assertUnlocked(id)
-      if (!password || String(password).length < 4) throw new Error('la contraseña debe tener al menos 4 caracteres')
+      if (!password || String(password).length < 4) throw new Error('password must be at least 4 characters')
       const salt = b64(crypto.getRandomValues(new Uint8Array(16)))
       p.pwd = { v: 1, salt, iter: PWD_ITER, verifier: await derivePwd(password, salt, PWD_ITER) }
       delete p.tries

package/src/secretsStore.js

@@ -1,12 +1,14 @@
 /**
  * Store de SECRETOS de servicios (`secrets.json`, 0600, mismo dir 0700 que la
- * maestra — mismo dominio de confianza, v1 en claro en reposo igual que
- * `identity.json`; el cifrado en reposo con contraseña llega con v2 para todo
- * el dir). Organizado por NAMESPACE de servicio (`proxy`, `geo`, `bots`…):
- * un cert `vault:secrets:<ns>` solo puede leer SU ns.
+ * maestra — mismo dominio de confianza, y **cifrado en reposo** con la misma
+ * clave ligada a la máquina que la identidad, ver `atrest.js`: son tokens y
+ * llaves de producción, no pueden quedar en claro en el disco). Organizado por
+ * NAMESPACE de servicio (`proxy`, `geo`, `bots`…): un cert
+ * `vault:secrets:<ns>` solo puede leer SU ns.
  */
 import path from 'node:path'
 import { readJson, writeJson } from './paths.js'
+import { atRestFor } from './atrest.js'
 import { isValidSecretsNs } from './protocol.js'
 
 const SCHEMA_VERSION = 1
@@ -15,15 +17,16 @@ const KEY_RE = /^[A-Z0-9_]{1,64}$/
 
 export function openSecretsStore (dir) {
   const file = path.join(dir, 'secrets.json')
-  let data = readJson(file, null)
+  const atRest = atRestFor(dir)
+  let data = readJson(file, null, atRest)
   if (!data || data.schemaVersion !== SCHEMA_VERSION) {
     data = { schemaVersion: SCHEMA_VERSION, ns: {} }
-    writeJson(file, data)
   }
-  const save = () => writeJson(file, data)
+  writeJson(file, data, atRest) // reescribe al abrir: cifra lo que venía en claro
+  const save = () => writeJson(file, data, atRest)
 
   const assertNs = (ns) => {
-    if (!isValidSecretsNs(ns)) throw new Error('namespace inválido (usa [a-z0-9-]{1,32}, p.ej. "proxy")')
+    if (!isValidSecretsNs(ns)) throw new Error('invalid namespace (use [a-z0-9-]{1,32}, e.g. "proxy")')
   }
 
   return {
@@ -34,9 +37,9 @@ export function openSecretsStore (dir) {
     },
     set (ns, key, value) {
       assertNs(ns)
-      if (!KEY_RE.test(String(key || ''))) throw new Error('clave inválida (usa MAYUSCULAS_CON_GUION_BAJO, p.ej. TURN_KEY_ID)')
-      if (typeof value !== 'string' || !value) throw new Error('el valor debe ser un string no vacío')
-      if (value.length > MAX_VALUE_LEN) throw new Error(`valor demasiado largo (máx ${MAX_VALUE_LEN})`)
+      if (!KEY_RE.test(String(key || ''))) throw new Error('invalid key (use UPPERCASE_WITH_UNDERSCORES, e.g. TURN_KEY_ID)')
+      if (typeof value !== 'string' || !value) throw new Error('value must be a non-empty string')
+      if (value.length > MAX_VALUE_LEN) throw new Error(`value too long (max ${MAX_VALUE_LEN})`)
       if (!data.ns[ns]) data.ns[ns] = {}
       data.ns[ns][key] = value
       save()

package/src/store.js

@@ -1,12 +1,14 @@
 /**
- * Store del árbol de contenidos del vault (`vault.json`). Versionado con
- * `schemaVersion` para que v2 pueda introducir cifrado en reposo sin migración
- * dolorosa. NO guarda identidad/dispositivos/certs: de eso se encarga
+ * Store del árbol de contenidos del vault (`vault.json`). **Cifrado en reposo**
+ * con la misma clave ligada a la máquina que la identidad (`atrest.js`): el
+ * contenido del usuario no es menos sensible que la maestra. NO guarda
+ * identidad/dispositivos/certs: de eso se encarga
  * `@dotrino/identity` dentro del mismo dir (keypair, contactos, delegaciones,
  * revocaciones). Aquí vive solo lo del usuario: el árbol y los settings.
  */
 import path from 'node:path'
 import { readJson, writeJson } from './paths.js'
+import { atRestFor } from './atrest.js'
 
 const SCHEMA_VERSION = 1
 
@@ -28,12 +30,15 @@ function findNode (node, id) {
 
 export function openStore (dir) {
   const file = path.join(dir, 'vault.json')
-  let data = readJson(file, null)
+  const atRest = atRestFor(dir)
+  let data = readJson(file, null, atRest)
   if (!data || data.schemaVersion !== SCHEMA_VERSION) {
     data = { schemaVersion: SCHEMA_VERSION, tree: newTree(), settings: {} }
-    writeJson(file, data)
   }
-  const save = () => writeJson(file, data)
+  // Se reescribe SIEMPRE al abrir: así un archivo de una instalación anterior
+  // (en claro) queda cifrado sin pedirle nada al usuario.
+  writeJson(file, data, atRest)
+  const save = () => writeJson(file, data, atRest)
 
   return {
     get raw () { return data },
@@ -41,7 +46,7 @@ export function openStore (dir) {
     getNode (id) { return findNode(data.tree, id || 'root') },
     addNode (parentId, node) {
       const parent = findNode(data.tree, parentId || 'root')
-      if (!parent) throw new Error('nodo padre no encontrado: ' + parentId)
+      if (!parent) throw new Error('parent node not found: ' + parentId)
       if (!Array.isArray(parent.children)) parent.children = []
       parent.children.push(node)
       save()

package/src/threadStore.js

@@ -9,19 +9,32 @@
  *
  * File-backed (`threads.json`), síncrono y simple (sin cuota/IndexedDB). Es el
  * backend autoritativo; el navegador usa su IndexedDB como caché y sincroniza.
+ * **Cifrado en reposo** con la clave ligada a la máquina (`atrest.js`): aquí
+ * vive el contenido de las apps y el perfil del usuario, que es exactamente lo
+ * que el ecosistema promete que no queda en claro en ningún disco.
  */
 import path from 'node:path'
 import { readJson, writeJson } from './paths.js'
+import { atRestFor } from './atrest.js'
 
 const MAX_PER_THREAD = 1000
 
+// 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,
+// notas, un documento corto) y ridículos para un abuso.
+const MAX_SECURE_ITEMS = 2000
+const MAX_SECURE_BLOB = 64 * 1024   // por campo sellado (meta y valor)
+
 export function openThreadStore (dir) {
   const file = path.join(dir, 'threads.json')
-  let data = readJson(file, null)
+  const atRest = atRestFor(dir)
+  let data = readJson(file, null, atRest)
   if (!data || typeof data !== 'object') data = { v: 1, threads: {}, opens: {} }
   if (!data.threads) data.threads = {}
   if (!data.opens) data.opens = {}
-  const save = () => writeJson(file, data)
+  if (!data.secure) data.secure = {}
+  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 methods = {
@@ -89,16 +102,75 @@ export function openThreadStore (dir) {
       save(); return { ok: true, updatedAt: data.profile.updatedAt }
     },
     profileGet () { return { me: data.profile || null } },
+
+    // ----- DATOS SENSIBLES del usuario (F4, docs/consola-remota.md §6) -----
+    //
+    // Contraseñas, notas, documentos: van al contenido del perfil, cifrados con la
+    // CEK de la cuenta y accesibles con `vault:store` — el mismo camino que hilos y
+    // perfil. NO tocan `secrets.json`: ese es el cajón de los SERVICIOS (proxy, geo),
+    // acotado por CN y con clave ligada a la máquina. Mismo nombre coloquial, distinto
+    // dueño.
+    //
+    // La bóveda guarda DOS SOBRES OPACOS por ficha y no abre ninguno:
+    //   `meta` — lo que hace falta para pintar la lista (nombre, tipo, carpeta)
+    //   `enc`  — el valor en sí, que solo viaja cuando abres la ficha
+    // Los sella el dispositivo con la clave de contenido (`identity.sealContent`). Que
+    // sean dos y no uno es lo que permite listar sin bajar todas las contraseñas, y que
+    // el nombre («Banco») tampoco quede legible aquí.
+    //
+    // Alcance: esto es el ALMACÉN. Una app de contraseñas con generador y
+    // autocompletado es otra cosa y no vive aquí.
+    'secure.list' () {
+      return Object.values(data.secure)
+        .map(({ enc, ...rest }) => rest)   // el valor NO viaja al listar
+        .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0))
+    },
+    'secure.get' ({ id }) {
+      if (!id || typeof id !== 'string') throw new Error('id required')
+      return data.secure[id] || null
+    },
+    'secure.put' ({ id, meta, enc }) {
+      if (typeof enc !== 'string' || !enc) throw new Error('enc required (sealed value)')
+      if (meta != null && typeof meta !== 'string') throw new Error('meta must be a sealed string')
+      // Se comprueba el TAMAÑO, nunca el contenido: son sobres cerrados.
+      if (enc.length > MAX_SECURE_BLOB || (meta || '').length > MAX_SECURE_BLOB) throw new Error('secure: item too large')
+      const prev = id ? data.secure[id] : null
+      if (!prev && Object.keys(data.secure).length >= MAX_SECURE_ITEMS) throw new Error('secure: too many items')
+      const rec = {
+        id: prev?.id || id || crypto.randomUUID(),
+        ts: prev?.ts || Date.now(),
+        updatedAt: Date.now(),
+        meta: meta ?? prev?.meta ?? null,
+        enc
+      }
+      data.secure[rec.id] = rec
+      save()
+      return { id: rec.id, updatedAt: rec.updatedAt }
+    },
+    'secure.del' ({ id }) {
+      if (!id || typeof id !== 'string') throw new Error('id required')
+      const had = !!data.secure[id]
+      delete data.secure[id]
+      if (had) save()
+      return { removed: had ? 1 : 0 }
+    },
+
     getStats () {
       const threads = {}
       for (const [k, arr] of Object.entries(data.threads)) threads[k] = { count: arr.length }
-      return { threadCount: Object.keys(data.threads).length, threads, opensCount: Object.keys(data.opens).length }
+      return { threadCount: Object.keys(data.threads).length, threads, opensCount: Object.keys(data.opens).length, secureCount: Object.keys(data.secure).length }
     }
   }
   return { methods, raw: () => data }
 }
 
-/** Métodos del store que son de SOLO LECTURA (para decidir el scope necesario). */
+/**
+ * Métodos del store que son de SOLO LECTURA (para decidir el scope necesario).
+ *
+ * `secure.list`/`secure.get` NO están aquí a propósito, aunque sean lecturas: los datos
+ * sensibles piden `vault:store` (doc §6), que es MÁS estricto que `vault:read`. Un
+ * 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'
 ])