@dotrino/identity 0.117.2 → 0.119.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.117.2",
+  "version": "0.119.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -601,6 +601,20 @@ export class Identity {
   /** Cambia la contraseña: hace falta la vieja, y lo que estuviera abierto se cierra. */
   async selfVaultLoginPasswd (opts) { return this._call('selfVaultLoginPasswd', opts || {}, 60000) }
 
+  // ----- el RESPALDO, cuando la bóveda es ESTA pestaña (solo desde la consola) -----
+  //
+  // Bóveda abierta y origen de la consola (`vault.dotrino.com`): cualquier otro recibe
+  // `code: 'not-the-console'`. El archivo vuelve YA CIFRADO con la contraseña dada.
+
+  /** Los cajones que hay: `[{ owner, count, device? }]`. */
+  async selfVaultBackupDrawers () { return this._call('selfVaultBackupDrawers', {}, 30000) }
+  /** Exporta todo (`drawers: null`) o esos cajones. Devuelve `{ file, summary }`. */
+  async selfVaultBackupExport (opts) { return this._call('selfVaultBackupExport', opts || {}, 120000) }
+  /** El plan de importar `file` (qué es nuevo, igual o choca). No escribe nada. */
+  async selfVaultBackupPlan (opts) { return this._call('selfVaultBackupPlan', opts || {}, 120000) }
+  /** Importa. Con un choque sin decidir lanza `BACKUP_CONFLICTS` y no escribe nada. */
+  async selfVaultBackupImport (opts) { return this._call('selfVaultBackupImport', opts || {}, 120000) }
+
   /** Cierra un inicio de sesión abierto (sin `sid`, todos los de ese usuario). */
   async selfVaultLoginClose (opts) { return this._call('selfVaultLoginClose', opts || {}) }
 

package/vault/acta.js

@@ -105,7 +105,7 @@ const conCampoSellador = (acta) => Number(acta?.v) < V_SIN_CAMPO_SELLADOR
  * el rol de master, que no se delega. Así un dispositivo con `admin` robado hace daño
  * acotado y **reversible** (se le revoca), en vez de poder dejarte fuera de tu cuenta.
  */
-export const CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'passkeys', 'sealer', 'unattended', 'replica'])
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica'])
 
 /** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
 /**
@@ -119,14 +119,12 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve',
  * pedirle algo a la bóveda es exactamente lo que decide el acta — tener dos registros
  * de lo mismo obliga a acordarse de los dos al quitar un aparato.
  *
- * `passkeys` es ABRIR LA PRIVADA DE UNA PASSKEY. Una passkey no se parece a una
- * contraseña: es una llave privada que firma el reto de un sitio, y si se copia sirve
- * **hasta que la borres en cada sitio** donde la registraste — no hay nada que «cambiar».
- * Por eso su envoltura solo se le hace a quien tenga `passwords` **y** esto
- * (`dotrino-passmanager/docs/sealed-passwords.md` §2.8).
- *
- * Sin `passwords` no significa nada: la passkey vive en una entrada de contraseñas. Y una
- * SESIÓN no lo lleva nunca, como `passwords` (`session.js`).
+ * Y `passwords` cubre TAMBIÉN LAS PASSKEYS (dueño, 2026-10-16: «realmente deberían ser uno
+ * solo»). Hasta la 0.117 había un `passkeys` aparte para abrir la privada de una passkey;
+ * se fusionó en este. Un acta vieja que todavía lo nombre sigue valiendo: un permiso
+ * desconocido se ignora (ver `checkShape`), y al siguiente cambio del acta desaparece.
+ * Lo que distingue una passkey es la POLÍTICA de la bóveda, no un permiso: añadirla es
+ * directo, reemplazarla o borrarla pide aprobación (`@dotrino/passmanager`).
  *
  * `replica` es REPARTIR, NO DECIDIR. Un replicador no tiene maestra: guarda el acta y los
  * sobres —que ya vienen sellados a su destinatario, así que tampoco puede abrirlos— y los
@@ -151,7 +149,7 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve',
  * de la cuenta, se ve en la pantalla de permisos como los demás, y se quita quitándolo —
  * sin acordarse de un segundo registro escondido.
  */
-export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'passkeys', 'sealer', 'unattended', 'replica'])
+export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica'])
 
 /**
  * Lo que recibe un dispositivo recién emparejado. `admin` **no está**: no se

package/vault/index.html

@@ -168,6 +168,7 @@
     "@dotrino/identity/machine": "./machine.js",
     "@dotrino/vault/password-logins": "./vendor/vault/passwordLogins.js",
     "@dotrino/vault/login-client": "./vendor/vault/loginClient.js",
+    "@dotrino/vault/backup": "./vendor/vault/core/backup.js",
     "@dotrino/opaque": "./vendor/opaque/src/index.js",
     "@dotrino/identity/capabilities": "./capabilities.js",
     "@dotrino/identity/acta": "./acta.js",

package/vault/session.js

@@ -57,7 +57,7 @@ export const SESSION_SCOPES = Object.freeze(['id:whoami', 'vault:store'])
  * blanca a propósito: si mañana alguien añade un alcance a `SESSION_SCOPES` sin pensarlo,
  * esto sigue cortando lo que no puede pasar.
  */
-export const SESSION_FORBIDDEN = Object.freeze(['secrets', 'admin', 'approve', 'sealer', 'passwords', 'passkeys', 'unattended', 'replica'])
+export const SESSION_FORBIDDEN = Object.freeze(['secrets', 'admin', 'approve', 'sealer', 'passwords', 'unattended', 'replica'])
 
 /** Qué capacidad del acta hace falta para conceder cada alcance de sesión. */
 const SCOPE_NEEDS = Object.freeze({ 'id:whoami': null, 'vault:store': 'store' })

package/vault/vault.js

@@ -469,6 +469,45 @@ import { useBackend as usePeerBackend } from './peerStore.js'
         }
       }
       return { ...r, deviceId: fila?.deviceId || null }
+    },
+
+    // ----- EL RESPALDO (`dotrino-vault/docs/respaldo.md`), cuando la bóveda es ESTA pestaña -----
+    //
+    // Exportar e importar, con la bóveda abierta (lo comprueba el núcleo: `VAULT_LOCKED`).
+    // Y SOLO DESDE LA CONSOLA: este iframe atiende a cualquier `*.dotrino.com`, y quien exporta
+    // elige la contraseña del respaldo — o sea, puede leerlo todo. Un fallo en cualquiera de
+    // las apps no puede convertirse en sacar los secretos de la cuenta.
+    // El archivo se cierra AQUÍ: a la consola le llega ya cifrado.
+    selfVaultBackupDrawers: async ({ __origin } = {}) => {
+      soloConsola(__origin)
+      return pidaDaemon().backupDrawers()
+    },
+    selfVaultBackupExport: async ({ drawers = null, password, __origin } = {}) => {
+      soloConsola(__origin)
+      const { sealBackup } = await import('@dotrino/vault/backup')
+      const { payload, summary } = await pidaDaemon().exportBackup({ drawers })
+      return { file: await sealBackup(payload, password), summary }
+    },
+    selfVaultBackupPlan: async ({ file, password, drawers = null, map = {}, __origin } = {}) => {
+      soloConsola(__origin)
+      const { openBackup } = await import('@dotrino/vault/backup')
+      return pidaDaemon().planBackupImport(await openBackup(file, password), { drawers, map })
+    },
+    selfVaultBackupImport: async ({ file, password, drawers = null, map = {}, onConflict = null, decisions = {}, __origin } = {}) => {
+      soloConsola(__origin)
+      const { openBackup } = await import('@dotrino/vault/backup')
+      return pidaDaemon().importBackup(await openBackup(file, password), { drawers, map, onConflict, decisions })
+    }
+  }
+
+  /**
+   * ¿ES LA CONSOLA? `vault.dotrino.com`, o un origen de desarrollo (localhost / LAN privada),
+   * que es donde se prueba. Lo demás del ecosistema no puede pedir un respaldo.
+   */
+  const CONSOLE_ORIGIN = /^(https:\/\/vault\.dotrino\.com|https?:\/\/(localhost|127\.0\.0\.1|192\.168\.\d{1,3}\.\d{1,3}|10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3})(:\d+)?)$/
+  function soloConsola (origin) {
+    if (!CONSOLE_ORIGIN.test(String(origin || ''))) {
+      throw Object.assign(new Error('only the vault console (vault.dotrino.com) can back up or restore'), { code: 'not-the-console' })
     }
   }
 

package/vault/vendor/passmanager/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/passmanager@0.17.0 (dotrino-passmanager/lib/src/{crypto,fields,generate,import,index,match,model,pubkey,sealed/convert,sealed/device,sealed/entry,sealed/index,sealed/keys,sealed/recovery,sealed/store,session-cache,totp,transport/protocol,transport/proxy,transport/sealed,vault/approval,vault/errors,vault/guard,vault/interface,vault/local,vault/remote,vault/responder,vault/sealed-local,vault/sealed-responder,vault/sealed,webauthn}.js).
+Copia vendorizada de @dotrino/passmanager@0.18.4 (dotrino-passmanager/lib/src/{crypto,fields,generate,import,index,match,model,pubkey,sealed/convert,sealed/device,sealed/entry,sealed/index,sealed/keys,sealed/recovery,sealed/store,session-cache,totp,transport/protocol,transport/proxy,transport/sealed,vault/approval,vault/errors,vault/guard,vault/interface,vault/local,vault/remote,vault/responder,vault/sealed-local,vault/sealed-responder,vault/sealed,webauthn}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 El sobre de las contraseñas, el mismo que usan el binario y la extensión. Importa @dotrino/identity/content.

package/vault/vendor/passmanager/model.js

@@ -324,6 +324,10 @@ export function mergePatch (base, changes = {}) {
     ...(changes.totp !== undefined ? { totp: changes.totp } : {}),
     ...(changes.notes !== undefined ? { notes: changes.notes } : {}),
     ...vaciados,
+    // El contador de una passkey sube en cada firma: cambiarlo no toca la llave.
+    ...(Number.isInteger(changes.signCount) && base.webauthn
+      ? { webauthn: { ...base.webauthn, signCount: changes.signCount } }
+      : {}),
     sites,
     fields: quedan,
     id: base.id,

package/vault/vendor/passmanager/sealed/entry.js

@@ -78,7 +78,7 @@ export async function sealEntry ({ plain, main, passkeys = null, keys }) {
     if (e.webauthn.privateKey) {
       if (!passkeys?.cek || typeof passkeys.gen !== 'number') {
         throw Object.assign(
-          new Error('this entry carries a passkey: it needs its own generation, wrapped only to devices with `passkeys`'),
+          new Error('this entry carries a passkey: it needs its own generation'),
           { code: 'passkeys-generation-missing' })
       }
       fields[PASSKEY_FIELD] = await sealV(passkeys.cek, passkeys.gen, e.webauthn.privateKey)

package/vault/vendor/passmanager/sealed/store.js

@@ -38,8 +38,9 @@ export class SealedStore {
    * @param {object} store  `{ get(k), set(k, v) }`
    * @param {object} opts
    *   `recipients(kind)` → `[{ pub, encPub }]` quién DEBE tener envoltura. `kind` es
-   *     `'main'` (los aparatos con `passwords`) o `'passkeys'` (los que además tienen
-   *     `passkeys`). Lo pone quien conoce el acta: esta pieza no la lee.
+   *     `'main'` o `'passkeys'` (la generación aparte de la privada de una passkey). Desde
+   *     2026-10-16 las dos son los aparatos con `passwords`: el permiso `passkeys` se fusionó
+   *     en ese. Lo pone quien conoce el acta: esta pieza no la lee.
    *   `verifyAuthor({ body, author })` → ¿la firmó quien dice, y puede escribir? Lo
    *     contesta quien tiene el acta. **No es opcional**: sin ella, cualquiera que llegue
    *     al almacén podría dejar una entrada a nombre de otro, y la bóveda no puede mirar
@@ -97,13 +98,12 @@ export class SealedStore {
         'the wraps must include the recovery one (#recovery), or this entry could never be handed out again')
     }
     const deben = (await this.recipients(kind)).filter((m) => m?.encPub).map((m) => m.pub)
-    // NADIE A QUIEN ENVOLVÉRSELA NO ES «CERO DESTINATARIOS», ES UN ERROR. Guardar una
-    // passkey que ningún aparato puede abrir la deja viva solo para la frase del perfil: no
-    // se pierde, pero no sirve, y el usuario se entera el día que la necesita. Se dice
-    // ahora, con un código que explica qué falta.
-    if (kind === 'passkeys' && !deben.length) {
+    // Una passkey no se guarda para NADIE: sin aparatos que puedan abrirla y sin copia de
+    // recuperación, se perdería entera. Con la copia basta: quien reciba el permiso después
+    // la recibe al re-repartir (`rewrapAll`).
+    if (kind === 'passkeys' && !deben.length && !wraps[RECOVERY]) {
       throw new SealedError('no-passkeys-device',
-        'no device in the account record can open passkeys: grant `passkeys` to one (`dotrino-vault caps <ID> +passkeys`) before saving it')
+        'nobody could ever open this passkey: no device has `passwords` and the account has no recovery copy')
     }
     const hay = Object.keys(wraps).filter((k) => k !== RECOVERY)
     if (!same(deben, hay)) {
@@ -127,7 +127,7 @@ export class SealedStore {
     // reparte una llave que nadie va a usar.
     if (llevaPasskey && !tienePasskeys) {
       throw new SealedError('passkeys-generation-missing',
-        'this entry carries a passkey: it needs its own wraps, only for devices with `passkeys`')
+        'this entry carries a passkey: it needs its own wraps (its own generation)')
     }
     if (!llevaPasskey && tienePasskeys) {
       throw new SealedError('passkeys-generation-unused', 'there is no passkey in this entry to wrap')
@@ -225,7 +225,7 @@ export class SealedStore {
     if (passkeys) await this.#checkWraps('passkeys', passkeys.wraps)
     if (fields[PASSKEY_FIELD] && !passkeys) {
       throw new SealedError('passkeys-generation-missing',
-        'that patch carries a passkey: it needs its own wraps, only for devices with `passkeys`')
+        'that patch carries a passkey: it needs its own wraps (its own generation)')
     }
 
     const s = await this.#state()
@@ -343,6 +343,12 @@ export class SealedStore {
     return s.entries.find((e) => e.id === id)?.priv || []
   }
 
+  /** ¿Esa entrada lleva una passkey? La bóveda lo sabe sin abrir nada: por su huella `wa`. */
+  async hasPasskey (id) {
+    const s = await this.#state()
+    return !!s.entries.find((e) => e.id === id)?.wa
+  }
+
   async remove (id) {
     const s = await this.#state()
     const antes = s.entries.length

package/vault/vendor/passmanager/vault/approval.js

@@ -11,6 +11,12 @@
 //   · una NEGATIVA no queda recordada como aprobación: la siguiente vuelve a preguntar
 //   · dos peticiones a la vez producen UN aviso, no dos
 //   · lo aprobado vive en memoria y muere con la bóveda: no se guarda en ninguna parte
+//   · y además CADUCA: una hora deslizante, como dotrino-env (dueño, 2026-10-16). Cada uso
+//     la renueva; una hora sin usarla y se vuelve a preguntar. Antes duraba hasta reiniciar
+//     la bóveda, o sea días, y un sí de la mañana servía para todo lo de la semana.
+
+/** Cuánto vale un sí sin usarse: una hora, deslizante. */
+export const GRANT_TTL_MS = 60 * 60 * 1000
 
 export class ApprovalGate {
   /**
@@ -22,27 +28,49 @@ export class ApprovalGate {
    *      aprobación es del aparato y no de cada credencial.
    *   `remember`  si un sí vale para los siguientes. En `false` la puerta sigue
    *      juntando las simultáneas, pero cada petición nueva vuelve a preguntar.
+   *   `ttlMs`  cuánto vale un sí sin usarse (deslizante: cada uso lo renueva). Una hora.
+   *   `now`  el reloj, para las pruebas.
    */
-  constructor ({ ask, scope, remember = true } = {}) {
+  constructor ({ ask, scope, remember = true, ttlMs = GRANT_TTL_MS, now = Date.now } = {}) {
     this.ask = ask || (async () => false)
     this.scope = scope || (() => null)
     this.remember = remember !== false
-    this._granted = new Set()
+    this.ttlMs = ttlMs
+    this.now = now
+    this._granted = new Map()   // llave → cuándo se usó por última vez
     this._asking = new Map()
   }
 
-  /** ¿Pasa? Pregunta si hace falta, y recuerda el sí si le toca recordarlo. */
+  /** ¿Sigue vivo el sí de esa llave? Si sí, se renueva (deslizante); si caducó, se olvida. */
+  #fresh (key) {
+    const last = this._granted.get(key)
+    if (last == null) return false
+    if (this.now() - last > this.ttlMs) { this._granted.delete(key); return false }
+    this._granted.set(key, this.now())
+    return true
+  }
+
+  /**
+   * ¿Pasa? Pregunta si hace falta, y recuerda el sí si le toca recordarlo.
+   *
+   * `req.remember === false`: ESTA petición pregunta siempre, y su sí no vale para las
+   * siguientes. Es la de lo que no se deshace (borrar o pisar una passkey): que el sí a
+   * leer, o a borrar otra cosa, la dejara pasar es borrar sin que nadie lo vea
+   * (pasó el 2026-10-16: un borrado aprobado dejó pasar el siguiente sin aviso).
+   */
   async allow (req = {}) {
     const key = this.scope(req)
-    if (this.remember && key != null && this._granted.has(key)) return true
+    const remember = this.remember && req.remember !== false
+    if (remember && key != null && this.#fresh(key)) return true
 
     // Dos pestañas abriendo el mismo sitio no deben hacer sonar el teléfono dos veces.
-    const junta = key == null ? `${req.op || ''}:${req.payload?.id || ''}` : String(key)
+    // Lo que pregunta siempre se junta solo con la MISMA petición, no con todo el aparato.
+    const junta = key == null || !remember ? `${key ?? ''}:${req.op || ''}:${req.payload?.id || ''}` : String(key)
     if (this._asking.has(junta)) return this._asking.get(junta)
 
     const p = Promise.resolve(this.ask(req))
       .then(ok => {
-        if (ok && this.remember && key != null) this._granted.add(key)
+        if (ok && remember && key != null) this._granted.set(key, this.now())
         return !!ok
       })
       .finally(() => this._asking.delete(junta))
@@ -52,7 +80,8 @@ export class ApprovalGate {
   }
 
   granted (key) {
-    return this._granted.has(key)
+    const last = this._granted.get(key)
+    return last != null && this.now() - last <= this.ttlMs
   }
 
   /** Retirar lo aprobado sin apagar la bóveda. Sin argumento, todo. */

package/vault/vendor/passmanager/vault/sealed-responder.js

@@ -107,7 +107,11 @@ export class SealedResponder {
         // `allow`, no `ask`: es el que RECUERDA el sí y junta las simultáneas. `ask` es la
         // función cruda de preguntar, y usarla directamente hacía sonar el teléfono en cada
         // petición — que es como se enseña a aprobar sin mirar.
-        const ok = await this.gate.allow({ op, payload, pubkey })
+        //
+        // Salvo borrar o pisar una passkey: eso no se deshace, así que pregunta CADA vez y
+        // ningún sí anterior del aparato lo cubre.
+        const remember = !(await this.replacesPasskey(op, payload))
+        const ok = await this.gate.allow({ op, payload, pubkey, remember })
         if (!ok) { anota('rejected'); return this.#send(from, pubkey, replyError(rid, CODES.NOT_APPROVED, 'not approved on the trusted device')) }
       }
       const result = await this.#run(op, payload, pubkey)
@@ -119,8 +123,25 @@ export class SealedResponder {
     }
   }
 
+  /**
+   * ¿CAMBIA O QUITA UNA PASSKEY QUE YA ESTÁ? Añadir es directo y no pregunta; reemplazarla o
+   * borrarla, sí — como las variables de `dotrino-env` (dueño, 2026-10-16). Una passkey
+   * borrada o pisada deja a alguien fuera de un sitio, y no hay forma de deshacerlo.
+   *
+   * Subir el contador al entrar NO es reemplazar: cambia la vista, no la llave.
+   */
+  async replacesPasskey (op, payload) {
+    if (op === 'pm2.remove') return this.store.hasPasskey(payload?.id)
+    if (op === 'pm2.put') return this.store.hasPasskey(payload?.entry?.id)
+    if (op === 'pm2.patch') {
+      return !!payload?.fields?.[PASSKEY_FIELD] || (payload?.drop || []).includes(PASSKEY_FIELD)
+    }
+    return false
+  }
+
   async #needsApproval (op, payload, pubkey) {
-    return await this.needsApproval(pubkey) && await this.wantsPrivate(op, payload)
+    if (!await this.needsApproval(pubkey)) return false
+    return await this.wantsPrivate(op, payload) || await this.replacesPasskey(op, payload)
   }
 
   async #run (op, payload = {}, pubkey) {

package/vault/vendor/passmanager/vault/sealed.js

@@ -262,7 +262,11 @@ export class SealedVault {
         fields: actual.fieldKeys.some((k) => !FIXED.includes(k)),
         webauthn: actual.hasWebauthn
       },
-      ...(actual.webauthn ? { webauthn: actual.webauthn } : {})
+      // El contador de la passkey sube en cada firma y vive en la vista: cambiarlo no toca
+      // la llave, así que no es reemplazarla (no pide aprobación).
+      ...(actual.webauthn
+        ? { webauthn: Number.isInteger(changes.signCount) ? { ...actual.webauthn, signCount: changes.signCount } : actual.webauthn }
+        : {})
     }
     const idx = sites ? await Promise.all(sites.map((s) => siteIndex(keys.kidx, s))) : null
     const parche = await buildSealedPatch({

package/vault/vendor/roadmap/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/roadmap@0.4.18 (dotrino-roadmap/src/{index,manifests}.js).
+Copia vendorizada de @dotrino/roadmap@0.4.29 (dotrino-roadmap/src/{index,manifests}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 El registro de versiones rotas que viaja con cada versión. Importa @dotrino/compat/ranges.