@dotrino/vaultd 0.160.3 → 0.162.0

package/lib/src/core/backup.js

@@ -0,0 +1,244 @@
+/**
+ * EL RESPALDO DE LA BÓVEDA: un archivo cifrado con una contraseña, con lo que hay en los
+ * cajones y en la bóveda de contraseñas. Diseño: `docs/respaldo.md`.
+ *
+ * QUÉ LLEVA Y QUÉ NO (dueño, 2026-10-16: «como las llaves son de dispositivo, solo se
+ * respalda el contenido de sobres y cajones»):
+ *
+ *   · SÍ: los VALORES de cada cajón (`ns:<scope>`, `dev:<aparato>`, el perfil `@me`) y las
+ *     entradas de la bóveda de contraseñas, abiertos y vueltos a cerrar con la contraseña
+ *     del respaldo.
+ *   · NO: ninguna llave. Ni la maestra, ni la de comunicación, ni las de los aparatos, ni
+ *     el acta. Una llave es de su aparato; quien restaura en otra bóveda la reparte con sus
+ *     propias llaves, a los aparatos de SU acta.
+ *   · NO: el histórico. Un respaldo es lo vigente.
+ *
+ * Por qué los valores en claro (dentro del archivo cifrado) y no los sobres tal cual: los
+ * sobres van envueltos a los aparatos de ESTA cuenta y a su copia de recuperación. En otra
+ * bóveda no los abre nadie, y mover un cajón de una bóveda a otra es la mitad de lo que esto
+ * tiene que hacer.
+ *
+ * LAS DOS PUNTAS EXIGEN LA BÓVEDA ABIERTA. Exportar es leer —lo que guarda la frase—, e
+ * importar compara con lo que ya hay, que también es leer.
+ *
+ * CONFLICTOS. Importar NUNCA pisa en silencio: primero se hace un PLAN (`planImport`) que
+ * dice, valor por valor, qué es nuevo, qué es igual y qué choca. Si algo choca y quien
+ * importa no dijo qué hacer, no se escribe NADA y se devuelve la lista (`BACKUP_CONFLICTS`).
+ * Las dos respuestas posibles son `keep` (se queda lo de la bóveda) y `replace` (gana el
+ * respaldo), para todo de una vez o para cada choque.
+ *
+ * El cifrado del archivo es el de `@dotrino/passmanager` (PBKDF2-SHA256 600 000 + AES-GCM):
+ * corre igual en el navegador y en Node, así que lo que exporta una versión de la bóveda lo
+ * abre cualquiera de las otras (regla de las tres versiones).
+ */
+import { deriveKeyFromPassword, makeSalt, makeVerifier, checkVerifier, sealValue, openValue, toBase64, fromBase64 } from '@dotrino/passmanager'
+
+export const BACKUP_FORMAT = 'dotrino-vault-backup'
+export const BACKUP_VERSION = 1
+/** El nombre del cajón de las contraseñas en un respaldo. No choca con un `ns:`/`dev:`. */
+export const PASSWORDS_DRAWER = 'passwords'
+/** Mínimo de la contraseña del respaldo: el archivo se ataca fuera de línea, sin freno. */
+export const BACKUP_PWD_MIN = 12
+const KDF_ITERATIONS = 600_000
+const AAD = 'dotrino-vault-backup/v1'
+
+const coded = (message, code, extra = {}) => Object.assign(new Error(message), { code, ...extra })
+
+// --- el archivo ----------------------------------------------------------------
+
+/**
+ * CIERRA un respaldo con su contraseña. Devuelve el objeto que se escribe al archivo.
+ * Lo único en claro es el formato y la fecha: ni los nombres de los cajones salen.
+ */
+export async function sealBackup (payload, password) {
+  if (typeof password !== 'string' || password.length < BACKUP_PWD_MIN) {
+    throw coded(`the backup password must be at least ${BACKUP_PWD_MIN} characters`, 'WEAK_PASSWORD')
+  }
+  const salt = makeSalt()
+  const key = await deriveKeyFromPassword(password, salt, KDF_ITERATIONS)
+  return {
+    format: BACKUP_FORMAT,
+    v: BACKUP_VERSION,
+    createdAt: payload.createdAt,
+    kdf: { name: 'PBKDF2-SHA256', iterations: KDF_ITERATIONS, salt: toBase64(salt) },
+    verifier: await makeVerifier(key),
+    box: await sealValue(key, JSON.stringify(payload), AAD)
+  }
+}
+
+/**
+ * ABRE un respaldo. Distingue «no es un respaldo», «esa contraseña no es» y «está roto»,
+ * porque se arreglan de formas distintas.
+ */
+export async function openBackup (file, password) {
+  if (!file || file.format !== BACKUP_FORMAT) throw coded('this is not a vault backup file', 'NOT_A_BACKUP')
+  if (file.v !== BACKUP_VERSION) throw coded(`unknown backup version v${file.v}: update the vault`, 'BACKUP_VERSION')
+  if (file.kdf?.name !== 'PBKDF2-SHA256' || !file.kdf.salt || !file.kdf.iterations) {
+    throw coded('the backup file has no usable key derivation', 'BACKUP_CORRUPT')
+  }
+  const key = await deriveKeyFromPassword(String(password || ''), fromBase64(file.kdf.salt), file.kdf.iterations)
+  if (!(await checkVerifier(key, file.verifier))) throw coded('that password does not open this backup', 'WRONG_PASSWORD')
+  let payload
+  try { payload = JSON.parse(await openValue(key, file.box, AAD)) } catch (_) {
+    throw coded('the backup opens but its content cannot be read', 'BACKUP_CORRUPT')
+  }
+  if (!Array.isArray(payload?.drawers)) throw coded('the backup has no drawers', 'BACKUP_CORRUPT')
+  return payload
+}
+
+// --- qué cajones -----------------------------------------------------------------
+
+/**
+ * ¿Entra este cajón? `selected` es la lista que pidió quien exporta o importa (`null` =
+ * todos). Vale el dueño entero (`ns:proxy`, `dev:<pub>`, `passwords`) y `@me` como atajo.
+ */
+export function wants (selected, owner) {
+  if (!selected || !selected.length) return true
+  return selected.some((s) => s === owner || (s === '@me' && owner === 'ns:@me'))
+}
+
+/** Valida que todo lo pedido exista: pedir un cajón que no está no es «nada que hacer». */
+export function assertSelected (selected, available) {
+  if (!selected || !selected.length) return
+  const missing = selected.filter((s) => !available.some((o) => wants([s], o)))
+  if (missing.length) throw coded(`no such drawer: ${missing.join(', ')}`, 'NO_SUCH_DRAWER', { missing })
+}
+
+// --- importar: el plan -----------------------------------------------------------
+
+/** Lo que identifica un valor dentro de un plan: `<cajón destino> <clave>`. */
+export const itemRef = (owner, key) => `${owner} ${key}`
+
+/**
+ * EL PLAN DE IMPORTACIÓN. Puro: no lee ni escribe nada, recibe lo que hay.
+ *
+ * @param {object} payload el respaldo ya abierto
+ * @param {object} o
+ *   `selected`  qué cajones del respaldo (`null` = todos)
+ *   `map`       `{ <cajón del respaldo>: <cajón destino> }` para moverlo de nombre o de
+ *               aparato. Sin entrada, va al mismo nombre.
+ *   `current`   `{ <cajón destino>: { KEY: {value, public} } | null }` lo que ya hay
+ *   `devices`   pubs de los aparatos del acta de destino: un `dev:` solo entra si su
+ *               aparato existe aquí
+ *   `passwords` `{ entries: [...] }` lo que ya hay en la bóveda de contraseñas, abierto
+ */
+export function planImport (payload, { selected = null, map = {}, current = {}, devices = [], passwords = null } = {}) {
+  const available = payload.drawers.map((d) => d.owner)
+  assertSelected(selected, available)
+  const withDevice = new Set(devices)
+  const plan = { drawers: [], counts: { new: 0, same: 0, conflict: 0, skipped: 0 } }
+  for (const d of payload.drawers) {
+    if (!wants(selected, d.owner)) continue
+    const to = map[d.owner] || d.owner
+    if (d.owner === PASSWORDS_DRAWER) {
+      plan.drawers.push(planPasswords(d, passwords, plan.counts))
+      continue
+    }
+    const out = { from: d.owner, to, label: d.label || null, status: 'ok', items: [] }
+    if (to.startsWith('dev:') && !withDevice.has(to.slice(4))) {
+      // EL APARATO NO ESTÁ EN ESTA CUENTA. No se guarda «por si acaso»: un cajón de aparato
+      // sin aparato no lo lee nadie, y reaparecería solo si un día entra esa llave. Se dice,
+      // y se puede mover a otro aparato con `map`.
+      out.status = 'no-device'
+      plan.counts.skipped += Object.keys(d.vars || {}).length
+      plan.drawers.push(out)
+      continue
+    }
+    const have = current[to] || {}
+    for (const [key, v] of Object.entries(d.vars || {})) {
+      const existing = have[key]
+      const status = !existing ? 'new' : (existing.value === v.value ? 'same' : 'conflict')
+      plan.counts[status]++
+      out.items.push({ key, status, public: !!v.public, ...(existing ? { currentPublic: !!existing.public } : {}) })
+    }
+    plan.drawers.push(out)
+  }
+  return plan
+}
+
+/**
+ * Lo que dice que una entrada de contraseñas es «la misma» que otra: el mismo id, o los
+ * mismos sitios y el mismo usuario (una credencial por sitio y usuario).
+ */
+const sitesKey = (e) => [...(e.sites || [])].map((s) => String(s).toLowerCase()).sort().join(' ')
+const whoKey = (e) => `${sitesKey(e)}\u0000${String(e.username || '').toLowerCase()}\u0000${e.sites?.length ? '' : String(e.title || '')}`
+/** Lo que se compara para decir «igual»: el contenido, sin fechas. */
+export const entryContent = (e) => JSON.stringify({
+  type: e.type || 'login', title: e.title || '', sites: [...(e.sites || [])].sort(),
+  name: e.name || '', username: e.username || '', secret: e.secret || '', totp: e.totp || '',
+  notes: e.notes || '', fields: e.fields || '[]', webauthn: e.webauthn || null
+})
+
+function planPasswords (d, passwords, counts) {
+  const out = { from: PASSWORDS_DRAWER, to: PASSWORDS_DRAWER, status: 'ok', items: [] }
+  if (!passwords) {
+    // Sin bóveda de contraseñas en el destino no hay con quién comparar ni dónde guardar:
+    // se dice. No se inventa una llave de perfil a medias.
+    out.status = 'no-passwords'
+    counts.skipped += (d.entries || []).length
+    return out
+  }
+  const byId = new Map(passwords.entries.map((e) => [e.id, e]))
+  const byWho = new Map(passwords.entries.map((e) => [whoKey(e), e]))
+  for (const e of d.entries || []) {
+    const existing = byId.get(e.id) || byWho.get(whoKey(e)) || null
+    const status = !existing ? 'new' : (entryContent(existing) === entryContent(e) ? 'same' : 'conflict')
+    counts[status]++
+    out.items.push({ key: e.id, title: e.title || (e.sites || [])[0] || '', username: e.username || '', status, ...(existing ? { currentId: existing.id } : {}) })
+  }
+  return out
+}
+
+/**
+ * LA DECISIÓN DE CADA CHOQUE. `onConflict` vale para todos; `decisions` (por `itemRef`) manda
+ * sobre él. Si queda alguno sin decidir, se para con la lista entera: importar a medias y
+ * descubrir el resto después es peor que no importar.
+ */
+export function resolvePlan (plan, { onConflict = null, decisions = {} } = {}) {
+  if (onConflict && onConflict !== 'keep' && onConflict !== 'replace') {
+    throw coded(`unknown conflict policy "${onConflict}" (use keep or replace)`, 'BAD_POLICY')
+  }
+  const pending = []
+  for (const d of plan.drawers) {
+    for (const it of d.items) {
+      if (it.status !== 'conflict') continue
+      const r = decisions[itemRef(d.to, it.key)] || onConflict
+      if (r !== 'keep' && r !== 'replace') { pending.push({ drawer: d.to, key: it.key, ...(it.title ? { title: it.title } : {}) }); continue }
+      it.resolution = r
+    }
+  }
+  if (pending.length) {
+    throw coded(`${pending.length} conflict(s) without a decision: nothing was imported`, 'BACKUP_CONFLICTS', { conflicts: pending, plan })
+  }
+  return plan
+}
+
+/**
+ * LO QUE HAY QUE ESCRIBIR, ya resuelto: `[{ to, key, value, public }]` para los cajones y
+ * `[{ entry, replaces }]` para las contraseñas. Lo `same` y lo `keep` no se tocan.
+ *
+ * La VISIBILIDAD: si lo que había era privado, se queda privado aunque el respaldo diga
+ * público. Hacer público un secreto no puede colarse en una importación (es la misma regla
+ * de `PrivateStaysPrivate`), y se anota para decirlo.
+ */
+export function writesOf (plan, payload) {
+  const vars = []
+  const entries = []
+  const byOwner = new Map(payload.drawers.map((d) => [d.owner, d]))
+  for (const d of plan.drawers) {
+    if (d.status !== 'ok') continue
+    const src = byOwner.get(d.from)
+    for (const it of d.items) {
+      if (it.status === 'same' || (it.status === 'conflict' && it.resolution !== 'replace')) continue
+      if (d.from === PASSWORDS_DRAWER) {
+        const entry = src.entries.find((e) => e.id === it.key)
+        entries.push({ entry, replaces: it.status === 'conflict' ? it.currentId : null })
+        continue
+      }
+      const v = src.vars[it.key]
+      const keptPrivate = it.currentPublic === false && !!v.public
+      vars.push({ to: d.to, key: it.key, value: v.value, public: keptPrivate ? false : !!v.public, ...(keptPrivate ? { keptPrivate: true } : {}) })
+    }
+  }
+  return { vars, entries }
+}

package/lib/src/core/libVersion.js

@@ -5,4 +5,4 @@
  * 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.88.2'
+export const LIB_VERSION = '0.90.0'

package/lib/src/core/passwords.js

@@ -52,18 +52,7 @@ export function createPasswordDesk (opts = {}) {
     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 sealed = openSealedPasswords({ store, members, canWrite })
 
   const responder = new SealedResponder({
     client,
@@ -103,6 +92,30 @@ export function createPasswordDesk (opts = {}) {
   }
 }
 
+/**
+ * EL ALMACÉN SELLADO DE LAS CONTRASEÑAS, sin el mostrador. Lo usa el mostrador y lo usa el
+ * respaldo (`backup.js`): el respaldo tiene que poder leer y escribir aunque ningún aparato
+ * tenga todavía `passwords` y el mostrador no se haya levantado. Una sola pieza, para que
+ * la regla de quién puede escribir no se escriba dos veces.
+ */
+/**
+ * @param {{ store?: any, members?: (kind: string) => any[], canWrite?: (pub: string) => boolean }} [o]
+ */
+export function openSealedPasswords ({ store, members = () => [], canWrite = () => false } = {}) {
+  return 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 })
+    },
+  })
+}
+
 /**
  * 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
@@ -122,3 +135,66 @@ export async function convertPasswords ({ store, sealed, cek, recipients, author
     log: (m) => log('[vault] ' + m)
   })
 }
+
+/**
+ * LAS CONTRASEÑAS DEL RESPALDO, abiertas con la copia de recuperación (`backup.js`).
+ *
+ * Es lectura, así que pide lo mismo que ver una variable: `openRecovery(wrap)` → la CEK, que
+ * solo funciona con la bóveda abierta. Cada entrada sale entera, con la forma de siempre
+ * (`newEntry`), para poder volver a sellarla en OTRA bóveda con sus propias llaves.
+ *
+ * Lo que no abre la copia de recuperación no se calla: `unreadable` cuenta las entradas sin
+ * envoltura `#recovery` (guardadas antes de que existiera), y `withheld` los campos sueltos
+ * que tampoco la tienen. Un respaldo que se deja cosas tiene que decirlo.
+ */
+export async function exportPasswordEntries ({ sealed, openRecovery }) {
+  const { RECOVERY, openSealedEntry } = await import('@dotrino/passmanager/sealed')
+  const { decryptWithCek } = await import('@dotrino/identity/content')
+  const stats = await sealed.stats()
+  if (!stats.sealed) return { entries: [], unreadable: stats.entries, withheld: 0 }
+  const openSealed = async ({ wrap, envelope }) => decryptWithCek({ cek: await openRecovery(wrap), envelope })
+  const views = await sealed.views({ pub: RECOVERY })
+  const entries = []
+  let withheld = 0
+  for (const v of views) {
+    const got = await sealed.get(v.id, { pub: RECOVERY })
+    const { withheld: lost = [], ...plain } = await openSealedEntry({ got, openSealed })
+    withheld += lost.length
+    entries.push(plain)
+  }
+  return { entries, unreadable: stats.entries - views.length, withheld }
+}
+
+/**
+ * VUELVE A SELLAR entradas de un respaldo en ESTA bóveda: a los aparatos de su acta y a su
+ * copia de recuperación, con la llave del perfil de aquí (la que hace las huellas de sitio).
+ *
+ * Si esta bóveda todavía no tiene llave de perfil (nunca guardó una contraseña), se estrena
+ * aquí: es lo mismo que haría al convertir, y sin ella no hay dónde guardar.
+ *
+ * `writes`: `[{ entry, replaces }]` de `writesOf`. `replaces` es el id de la entrada de aquí
+ * que se pisa; la entrada nueva toma ese id, así que el almacén la reemplaza en su sitio.
+ * `author` firma cada entrada (`{ publickey, sign }`), como cualquier aparato que escribe.
+ */
+export async function importPasswordEntries ({ sealed, openRecovery, recipients, author, writes = [] }) {
+  if (!writes.length) return { written: 0 }
+  const { RECOVERY, profileKeys, buildSealedEntry, buildProfileKey } = await import('@dotrino/passmanager/sealed')
+  const { decryptWithCek } = await import('@dotrino/identity/content')
+  let base
+  if ((await sealed.stats()).sealed) {
+    const p = await sealed.profile({ pub: RECOVERY })
+    base = await decryptWithCek({ cek: await openRecovery(p.wrap), envelope: p.envelope })
+  } else {
+    const k = await buildProfileKey({ recipients })
+    await sealed.setProfile({ envelope: k.envelope, wraps: k.wraps })
+    base = k.base
+  }
+  const keys = await profileKeys(base)
+  let written = 0
+  for (const { entry, replaces } of writes) {
+    const built = await buildSealedEntry({ plain: { ...entry, id: replaces || entry.id }, keys, recipients, author })
+    await sealed.putSealed({ ...built, by: author.publickey })
+    written++
+  }
+  return { written }
+}

package/lib/src/core/secretsStore.js

@@ -96,6 +96,16 @@ export function assertProfileKey (key) {
   }
 }
 
+/** Lo más largo que puede ser un dato del perfil (una foto pequeña cabe). */
+const MAX_PROFILE_LEN = 200000
+
+/** Valida un dato del perfil: su nombre (`assertProfileKey`) y su valor. */
+export function assertProfileValue (key, value) {
+  assertProfileKey(key)
+  if (typeof value !== 'string' || !value) throw new Error('value must be a non-empty string')
+  if (value.length > MAX_PROFILE_LEN) throw new Error(`profile value too long (max ${MAX_PROFILE_LEN})`)
+}
+
 /** Cuántas versiones anteriores se conservan, en total. Ver «EL HISTÓRICO» arriba. */
 const MAX_HISTORY = 500
 
@@ -555,6 +565,52 @@ export function openSecretsStore (disk, { sealer = null, recipients = null, sign
       return out
     },
 
+    /**
+     * UN CAJÓN ENTERO, ABIERTO. Es para el RESPALDO (`backup.js`), y por eso pide lo mismo
+     * que ver un valor: la copia de recuperación, o sea la bóveda abierta. Se abre UNA vez
+     * y se usa para todas las variables.
+     *
+     * Lo público del perfil (`cls: 'public'`) no tiene sobre: se guarda en claro y firmado,
+     * y sale tal cual. El histórico no sale: un respaldo es lo vigente.
+     *
+     * @returns {Promise<Object<string,{value:string, public:boolean}>|null>} `null` si el
+     *   cajón no existe.
+     */
+    async exportDrawer (owner, adminKey = null) {
+      const [kind, k] = splitOwner(owner)
+      const bag = kind === 'ns' ? data.ns : data.dev
+      if (!bag[k]) return null
+      if (needsMigration()) throw new NeedsMigration()
+      const vars = varsOf(bag, k)
+      /** @type {Object<string,{value:string, public:boolean}>} */
+      const out = {}
+      let priv = null
+      for (const [key, e] of Object.entries(vars)) {
+        if (e?.cls === 'public' && typeof e.pubv === 'string') { out[key] = { value: e.pubv, public: true }; continue }
+        if (isLegacy()) { out[key] = { value: e.v, public: !!e.pub }; continue }
+        if (!priv) priv = await openRecovery(adminKey)
+        out[key] = { value: await sealer.openValue(await this._cekOf(bag, k, e.gen, priv), e.e), public: !!e.pub }
+      }
+      return out
+    },
+
+    /**
+     * ESCRIBE UN VALOR IMPORTADO en cualquier cajón, también en el del perfil.
+     *
+     * Es escribir y nada más (no pide la frase): lo de `@me` público va por
+     * `profilePutPublic`, como lo escribiría un aparato; lo demás, por el mismo camino que
+     * `set`. Lo que decide si se escribe —el conflicto con lo que ya había— lo decide
+     * `backup.js` antes de llegar aquí.
+     */
+    async importValue (owner, key, value, isPublic, { by = null } = {}) {
+      if (owner === PROFILE_OWNER && isPublic) return this.profilePutPublic(key, value, { by })
+      const [kind, k] = splitOwner(owner)
+      if (kind === 'ns' && owner !== PROFILE_OWNER) assertNs(k)
+      else if (kind === 'dev') assertPub(k)
+      else if (kind !== 'ns') throw new Error('invalid drawer: expected "ns:<name>" or "dev:<pubkey>"')
+      return this._put(kind === 'ns' ? data.ns : data.dev, k, owner, key, value, isPublic, by)
+    },
+
     // --- escritura: NO pide la frase (§8.1) --------------------------------------
     /**
      * Escribe en un cajón. `isPublic` es OPCIONAL a propósito: sin decir nada se
@@ -575,7 +631,10 @@ export function openSecretsStore (disk, { sealer = null, recipients = null, sign
     async _put (...a) { return enFila(() => this._putRaw(...a)) },
     /** @private El cuerpo, ya en fila (ver `enFila`). */
     async _putRaw (bag, k, owner, key, value, isPublic, by) {
-      assertKeyValue(key, value)
+      // El cajón del perfil tiene su propio alfabeto (`nickname`, no `NICKNAME`). Por aquí
+      // solo llega con `importValue`: `set` ya rechaza `@me` como nombre de cajón.
+      if (owner === PROFILE_OWNER) assertProfileValue(key, value)
+      else assertKeyValue(key, value)
       const vars = ensureBag(bag, k)
       const before = vars[key]
       const pub = isPublic === undefined ? !!before?.pub : !!isPublic
@@ -949,7 +1008,7 @@ export function openSecretsStore (disk, { sealer = null, recipients = null, sign
         if (isLegacy()) throw new Error('profile: this store is still v3 (run `migrate` first)')
         if (needsMigration()) throw new NeedsMigration()
         assertProfileKey(key)
-        if (typeof value !== 'string' || value.length > 200000) {
+        if (typeof value !== 'string' || value.length > MAX_PROFILE_LEN) {
           throw new Error('a public profile field must be a string of at most 200 kB')
         }
         const vars = ensureBag(data.ns, PROFILE_NS)

package/lib/src/core/vault.js

@@ -40,6 +40,7 @@ import { createApprovals, createGrants, lastApproverGone, PENDING_TTL_MS, GRANT_
 import { sanitizeContext, commandFingerprint, commandLine } from '../procContext.js'
 import { makeContentKey, encryptWithCek, wrapForMember } from '@dotrino/identity/content'
 import { makeSealer } from './sealer.js'
+import { BACKUP_VERSION, PASSWORDS_DRAWER, wants, assertSelected, planImport, resolvePlan, writesOf } from './backup.js'
 import { openSealKeys } from './sealKey.js'
 import { openCommKey, COMM_CN, COMM_CAPS } from './commKey.js'
 import { seal } from '../sealed.js'
@@ -317,6 +318,14 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
    * queda fuera y se ve en `incompleteMembers`.
    */
   const noEsLaBoveda = (pub) => pub !== master && pub !== commKey.pub()
+  /**
+   * ¿PUEDE ESCRIBIR UNA CONTRASEÑA? Un aparato del acta con `passwords`… y la MAESTRA de esta
+   * bóveda, que es quien reescribe al convertir (`sealPasswords`) y al importar un respaldo.
+   * Las dos cosas pasan con la bóveda abierta y son rehacer sobres, su segundo trabajo. Sin
+   * ella, las dos fallaban con `bad-author`: firmaban con la maestra y la regla solo miraba
+   * el acta. Escribir no le da a la bóveda ninguna envoltura: sigue sin poder leer nada.
+   */
+  const canWritePasswords = (pub) => !!pub && (pub === master || (!!actaCache && Acta.memberCan(actaCache, pub, 'passwords')))
   const passwordRecipients = (_kind = 'main') => (actaCache?.members || [])
     .filter((m) => m.encPub && noEsLaBoveda(m.pub) && Acta.memberCan(actaCache, m.pub, 'passwords'))
     .map((m) => ({ pub: m.pub, encPub: m.encPub }))
@@ -2330,7 +2339,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
       // aparato—. Ninguna de las dos abre nada por sí sola.
       members: (kind) => passwordRecipients(kind),
       recoveryPub: () => secrets.recoveryPub(),
-      canWrite: (pub) => !!actaCache && !!pub && Acta.memberCan(actaCache, pub, 'passwords'),
+      canWrite: canWritePasswords,
       // UNA sola condición, y es del ACTA: el aparato tiene la capacidad `passwords`.
       // Quitársela —o quitar el aparato— le corta esto en la siguiente pasada, sin
       // que haya una segunda lista que acordarse de tocar.
@@ -3946,6 +3955,163 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     return secrets.openBundle(ns, devicePub, adminKey)
   }
 
+  // --- EL RESPALDO (`backup.js`, `docs/respaldo.md`) ------------------------------------
+  //
+  // Las dos puntas son de BÓVEDA ABIERTA (dueño, 2026-10-16): exportar lee todo, e importar
+  // compara con lo que ya hay. Cerrada se para y se dice, sin intentar con la llave de la
+  // máquina.
+
+  const needOpen = () => {
+    if (isLocked()) throw Object.assign(new Error('the vault is locked: open it to back up or restore'), { code: 'VAULT_LOCKED' })
+  }
+  /** El almacén sellado de las contraseñas: el del mostrador si está, o uno igual. */
+  const sealedPasswords = async () => {
+    if (passwords?.sealed) return passwords.sealed
+    const { openSealedPasswords } = await import('./passwords.js')
+    return openSealedPasswords({ store: passwordsStore, members: (kind) => passwordRecipients(kind), canWrite: canWritePasswords })
+  }
+  const passwordsRecovery = (adminKey) => (wrap) => secrets.openRecoveryWrap(wrap, adminKey)
+  /** Lo que hay en las contraseñas, abierto. `null` si no hay ni una. */
+  async function passwordEntries (adminKey) {
+    const { exportPasswordEntries } = await import('./passwords.js')
+    return exportPasswordEntries({ sealed: await sealedPasswords(), openRecovery: passwordsRecovery(adminKey) })
+  }
+  /** Cómo se llama un cajón para quien lo lee: el del aparato, con su ID y su nombre. */
+  const drawerLabel = (owner) => {
+    if (!owner.startsWith('dev:')) return null
+    const pub = owner.slice(4)
+    const m = (actaCache?.members || []).find((x) => x.pub === pub)
+    return { id: pubkeyId(pub), label: m?.label || m?.cn || null }
+  }
+
+  /**
+   * LOS CAJONES QUE HAY, con cuántos valores tiene cada uno. Es lo que se enseña antes de
+   * elegir qué respaldar: nombres y cuentas, nunca valores.
+   */
+  async function backupDrawers () {
+    const out = secrets.owners().map((owner) => ({
+      owner,
+      count: owner.startsWith('dev:')
+        ? (secrets.listDevices()[owner.slice(4)] || []).length
+        : (secrets.list()[owner.slice(3)] || []).length,
+      ...(drawerLabel(owner) ? { device: drawerLabel(owner) } : {})
+    }))
+    const st = await (await sealedPasswords()).stats()
+    if (st.entries) out.push({ owner: PASSWORDS_DRAWER, count: st.entries })
+    return out
+  }
+
+  /**
+   * EXPORTA un respaldo: todo, o los cajones pedidos (`drawers`). Devuelve lo que se va a
+   * cifrar (`payload`) y el resumen de lo que lleva — quien llama lo cifra con la contraseña
+   * del respaldo (`sealBackup`), que no tiene por qué pasar por aquí.
+   */
+  async function exportBackup ({ drawers = null, adminKey = null } = {}) {
+    needOpen()
+    await refreshActa()
+    const owners = secrets.owners()
+    const pwd = (!drawers || wants(drawers, PASSWORDS_DRAWER)) ? await passwordEntries(adminKey) : null
+    const available = [...owners, ...(pwd && (pwd.entries.length || pwd.unreadable) ? [PASSWORDS_DRAWER] : [])]
+    assertSelected(drawers, available)
+    /** @type {Array<{owner: string, label?: any, vars?: Object<string,{value:string, public:boolean}>, entries?: any[]}>} */
+    const out = []
+    for (const owner of owners) {
+      if (!wants(drawers, owner)) continue
+      const vars = await secrets.exportDrawer(owner, adminKey)
+      if (!vars) continue
+      const label = drawerLabel(owner)
+      out.push({ owner, ...(label ? { label } : {}), vars })
+    }
+    if (pwd && wants(drawers, PASSWORDS_DRAWER) && pwd.entries.length) out.push({ owner: PASSWORDS_DRAWER, entries: pwd.entries })
+    const payload = { v: BACKUP_VERSION, createdAt: Date.now(), account: fp || null, drawers: out }
+    const summary = {
+      drawers: out.map((d) => ({ owner: d.owner, count: d.entries ? d.entries.length : Object.keys(d.vars).length, ...(d.label ? { device: d.label } : {}) })),
+      ...(pwd?.unreadable ? { passwordsUnreadable: pwd.unreadable } : {}),
+      ...(pwd?.withheld ? { passwordFieldsWithheld: pwd.withheld } : {})
+    }
+    audit('backup.export', { drawers: out.length })
+    return { payload, summary }
+  }
+
+  /** Lo que ya hay en los cajones de destino del plan, abierto, para compararlo. */
+  async function currentFor (payload, { selected, map, adminKey }) {
+    const current = {}
+    for (const d of payload.drawers) {
+      if (d.owner === PASSWORDS_DRAWER || !wants(selected, d.owner)) continue
+      const to = map[d.owner] || d.owner
+      if (!(to in current)) current[to] = await secrets.exportDrawer(to, adminKey)
+    }
+    return current
+  }
+
+  /**
+   * EL PLAN de importar un respaldo ya abierto: qué es nuevo, qué es igual y qué choca. No
+   * escribe nada. `map` mueve un cajón a otro nombre (o a otro aparato).
+   */
+  async function planBackupImport (payload, { drawers = null, map = {}, adminKey = null } = {}) {
+    needOpen()
+    await refreshActa()
+    const current = await currentFor(payload, { selected: drawers, map, adminKey })
+    const withPasswords = payload.drawers.some((d) => d.owner === PASSWORDS_DRAWER && wants(drawers, d.owner))
+    const pwd = withPasswords ? await passwordEntries(adminKey) : null
+    return planImport(payload, {
+      selected: drawers,
+      map,
+      current,
+      devices: (actaCache?.members || []).map((m) => m.pub),
+      passwords: pwd ? { entries: pwd.entries } : null
+    })
+  }
+
+  /**
+   * IMPORTA. Rehace el plan aquí mismo —no se fía de uno viejo: entre el plan y el sí, la
+   * bóveda pudo cambiar— y si queda algún choque sin decidir no escribe nada
+   * (`BACKUP_CONFLICTS`, con la lista).
+   *
+   * Todo lo de los cajones entra en UN guardado por cajón y con un solo aviso a sus
+   * servicios, como una carga en grupo.
+   */
+  async function importBackup (payload, { drawers = null, map = {}, onConflict = null, decisions = {}, adminKey = null } = {}) {
+    const plan = resolvePlan(await planBackupImport(payload, { drawers, map, adminKey }), { onConflict, decisions })
+    const { vars, entries } = writesOf(plan, payload)
+    const touched = new Set()
+    await secrets.batch(async () => {
+      for (const w of vars) {
+        await secrets.importValue(w.to, w.key, w.value, w.public, { by: null })
+        touched.add(w.to)
+      }
+    })
+    let pwdWritten = 0
+    if (entries.length) {
+      const { importPasswordEntries } = await import('./passwords.js')
+      const r = await importPasswordEntries({
+        sealed: await sealedPasswords(),
+        openRecovery: passwordsRecovery(adminKey),
+        recipients: { recoveryPub: secrets.recoveryPub(), main: passwordRecipients('main'), passkeys: passwordRecipients('passkeys') },
+        // LA MAESTRA FIRMA LO QUE ESCRIBE, igual que al convertir (`sealPasswords`): la bóveda
+        // está abierta y esto es rehacer sobres. Lo que se le envuelve sigue siendo nada.
+        author: { publickey: master, sign: (body) => identity.signData(body) },
+        writes: entries
+      })
+      pwdWritten = r.written
+    }
+    // Como cualquier carga en grupo: saldar lo que se deba y un solo aviso por cajón.
+    for (const owner of touched) {
+      await settleDebts(owner)
+      if (owner.startsWith('dev:')) scheduleDeviceNotice(owner.slice(4))
+      else if (owner !== PROFILE_OWNER) scheduleNotice(owner.slice(3))
+    }
+    const result = {
+      written: vars.length + pwdWritten,
+      kept: plan.drawers.reduce((n, d) => n + d.items.filter((i) => i.resolution === 'keep').length, 0),
+      same: plan.counts.same,
+      skipped: plan.drawers.filter((d) => d.status !== 'ok').map((d) => ({ from: d.from, to: d.to, status: d.status })),
+      keptPrivate: vars.filter((w) => w.keptPrivate).map((w) => ({ drawer: w.to, key: w.key }))
+    }
+    audit('backup.import', { written: result.written, kept: result.kept, drawers: touched.size + (pwdWritten ? 1 : 0) })
+    return result
+  }
+
   /**
    * CAMBIA LOS PERMISOS DE UNO O VARIOS APARATOS EN UNA SOLA ACTA. `changes`: `[{ pub, caps }]`,
    * cada `caps` la lista COMPLETA de ese aparato.
@@ -4274,6 +4440,8 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     // frontera de verdad (que el valor de una privada no salga ni dentro del sobre).
     vars: varsDesk,
     setSecret, deleteSecret, renameSecret, renameDeviceSecret, listSecrets, setSecretVisibility, openSecrets,
+    // El respaldo: exportar, ver el plan e importar. Las tres con la bóveda abierta.
+    backupDrawers, exportBackup, planBackupImport, importBackup,
     // Sella un `secrets.json` v3 entero. Es el punto de no retorno del despliegue y
     // por eso es una operación con nombre propio, no algo que ocurra de refilón al
     // desbloquear: deja `secrets.json.v3.bak` para poder volver.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.160.3",
+  "version": "0.162.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": {