@dotrino/identity 0.104.1 → 0.105.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.104.1",
+  "version": "0.105.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

@@ -348,6 +348,8 @@ export class Identity {
 
   /** Cambia las capacidades de un miembro (solo el master). */
   async setCaps (pub, caps) { return this._call('setCaps', { pub, caps }) }
+  /** Cambia las capacidades de VARIOS miembros en una sola acta: `[{ pub, caps }]`. */
+  async setCapsMany (changes) { return this._call('setCapsMany', { changes }) }
   async setLabel (pub, label) { return this._call('setLabel', { pub, label }) }
 
   /** Expulsa a un miembro (solo el master; al master no se le puede expulsar). */

package/src/node.js

@@ -228,6 +228,7 @@ export class Identity {
   /** Registra la llave de cifrado de un miembro ya admitido (evita re-enrolarlo). */
   setMemberEncPub (args) { return this._h('setMemberEncPub', args) }
   setCaps (pub, caps) { return this._h('setCaps', { pub, caps }) }
+  setCapsMany (changes) { return this._h('setCapsMany', { changes }) }
   setLabel (pub, label) { return this._h('setLabel', { pub, label }) }
   removeMember (pub) { return this._h('removeMember', { pub }) }
   handoverMaster (to, member = null) { return this._h('handoverMaster', { to, member }) }

package/vault/core.js

@@ -973,19 +973,6 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     keyring: loadActa()?.keyring, myPub: publickeyJwkStr, myEncPrivateKey: encKeypair.privateKey
   })
 
-  /** Envuelve la clave vigente para un miembro recién admitido (no hace falta rotar). */
-  async function wrapForNewMember (pub) {
-    const acta = loadActa()
-    const gen = (acta?.keyring || []).at(-1)
-    const m = acta?.members.find((x) => x.pub === pub)
-    if (!gen || !m?.encPub) return false
-    const mine = await myCek()
-    if (!mine) return false
-    const wrap = await Content.wrapForMember({ cek: mine.cek, memberEncPub: m.encPub })
-    await sealChanges([{ op: 'wrap', gen: mine.gen, pub, wrap }])
-    return true
-  }
-
   /**
    * QUITAR UN APARATO, entero y de una vez.
    *
@@ -2571,12 +2558,21 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       // `cn`: si viene, este miembro es un SERVICIO y su único permiso es abrir el cajón de
       // secretos de ESE nombre — no ve nada más del usuario. Sin `cn` es un dispositivo.
       const finales = caps || (cn ? ['secrets'] : ['store', 'read'])
-      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, cn, caps: finales, cert, continuity } }])
       // Que entre al perfil incluye poder LEER lo que ya hay: se le envuelve la clave
       // vigente (no hace falta rotar; rotar es para cuando alguien SALE).
-      let wrapped = false
-      try { wrapped = await wrapForNewMember(pub) } catch (_) {}
-      return { ok: true, seq: acta.seq, wrapped }
+      //
+      // EN LA MISMA ACTA que la admisión (dueño, 2026-09-26: nada de actas inútiles). Antes
+      // se sellaba una para admitir y otra para envolver, y cada acta es un aviso a todos
+      // los aparatos. La envoltura solo necesita la llave de cifrado del que entra, que ya
+      // viene aquí. Si no se puede envolver (sin clave propia, sin `encPub`), entra igual y
+      // `wrapped` lo dice — lo mismo que antes.
+      let wrap = null
+      try {
+        const mine = encPub ? await myCek() : null
+        if (mine) wrap = { op: 'wrap', gen: mine.gen, pub, wrap: await Content.wrapForMember({ cek: mine.cek, memberEncPub: encPub }) }
+      } catch (_) { wrap = null }
+      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, cn, caps: finales, cert, continuity } }, ...(wrap ? [wrap] : [])])
+      return { ok: true, seq: acta.seq, wrapped: !!wrap }
     },
 
     async setCaps ({ pub, caps } = {}) {
@@ -2584,6 +2580,18 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       return { ok: true, seq: acta.seq }
     },
 
+    /**
+     * LOS PERMISOS DE VARIOS APARATOS EN UNA SOLA ACTA (dueño, 2026-09-26). Editar tres
+     * aparatos eran tres actas y tres avisos; ahora el borrador entero se sella de golpe.
+     * `changes`: `[{ pub, caps }]`, cada `caps` la lista COMPLETA de ese aparato.
+     * @param {{ changes?: Array<{ pub: string, caps: string[] }> }} [args]
+     */
+    async setCapsMany ({ changes } = {}) {
+      if (!Array.isArray(changes) || !changes.length) throw new Error('setCapsMany: no changes')
+      const acta = await sealChanges(changes.map(({ pub, caps }) => ({ op: 'caps', pub, caps })))
+      return { ok: true, seq: acta.seq }
+    },
+
     /**
      * RENOMBRA un miembro (el nombre con el que lo reconoces). Se escribe en el acta y
      * TAMBIÉN en la delegación: son dos registros distintos —el acta dice quién es del

package/vault/nativeStore.js

@@ -79,83 +79,3 @@ export async function nativeBackends (bridge) {
   return { kv, keyStore, peers, flush: () => chain }
 }
 
-const PROFILES = 'dotrino.identity.profiles'
-const CURRENT = 'dotrino.identity.current'
-const scopedKey = (pid, k) => `dotrino.identity.p.${pid}.${k}`
-
-/**
- * LOS PERFILES QUE SE QUEDARON EN LA PÁGINA pasan a la app (dueño, 2026-09-26: «todas las
- * pestañas usan el mismo perfil, pero NO es el de Dotrino que está en Pedidos»).
- *
- * Antes de `nativeStore` cada página guardaba la identidad aparte, así que la cuenta que se
- * emparejó en `vault.dotrino.com/d` quedó en el almacén de ESA página: su llave está en el
- * chip (Pedidos la usa), pero su acta, su papel y su nombre no llegaron a la app, y la app
- * estrenó un perfil vacío. Esto la trae.
- *
- * Solo se trae un perfil cuya llave VIVE en el chip (`open` contesta): uno de software no
- * cabe, y uno cuya llave ya se borró no sirve para nada. Lo que la app ya tiene no se pisa.
- * Y si el perfil activo de la app no está emparejado y el traído sí, pasa a ser el activo:
- * el vacío se inventó justo porque faltaba este.
- *
- * `page`: lo que hay en el almacén de ESTA página — `kv` (entradas del localStorage),
- * `keys` (registros del IndexedDB de llaves) y `peers` (libros de contactos).
- */
-export async function adoptPageProfiles (native, bridge, page) {
-  const mine = JSON.parse(native.kv.getItem(PROFILES) || '[]')
-  const theirs = JSON.parse(page.kv.get(PROFILES) || '[]')
-  const adopted = []
-  for (const p of theirs) {
-    if (!p?.id || mine.some((m) => m.id === p.id)) continue
-    const sign = page.keys.get(scopedKey(p.id, 'keypair'))
-    const enc = page.keys.get(scopedKey(p.id, 'enc-keypair'))
-    if (!sign?.external) continue
-    try { await bridge.call('open', { kid: sign.external }) } catch (_) { continue }
-    const prefix = `dotrino.identity.p.${p.id}.`
-    for (const [k, v] of page.kv) if (k.startsWith(prefix)) native.kv.setItem(k, v)
-    await native.keyStore.set(scopedKey(p.id, 'keypair'), sign)
-    if (enc?.external) await native.keyStore.set(scopedKey(p.id, 'enc-keypair'), enc)
-    const book = page.peers.get(`peers.${p.id}.v1`)
-    if (book) await native.peers.put(`peers.${p.id}.v1`, book)
-    mine.push(p)
-    adopted.push(p.id)
-  }
-  if (!adopted.length) return adopted
-  native.kv.setItem(PROFILES, JSON.stringify(mine))
-  const cur = native.kv.getItem(CURRENT)
-  const paired = (pid) => !!native.kv.getItem(scopedKey(pid, 'vault.cert'))
-  if (!cur || !paired(cur)) {
-    const next = adopted.find(paired)
-    if (next) native.kv.setItem(CURRENT, next)
-  }
-  console.info(`[cc-identity] adopted ${adopted.length} profile(s) from this page's storage into the app: ${adopted.join(', ')}`)
-  return adopted
-}
-
-/** Todo lo que la identidad guardó en el almacén de ESTA página (localStorage + sus dos IndexedDB). */
-export async function readPageStorage () {
-  const kv = new Map()
-  for (let i = 0; i < localStorage.length; i++) {
-    const k = localStorage.key(i)
-    if (k && k.startsWith('dotrino.identity.')) kv.set(k, localStorage.getItem(k))
-  }
-  return { kv, keys: await idbAll('dotrino-identity-keys', 'keys'), peers: await idbAll('cc-identity', 'kv') }
-}
-
-function idbAll (dbName, store) {
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open(dbName)
-    req.onupgradeneeded = () => { if (!req.result.objectStoreNames.contains(store)) req.result.createObjectStore(store) }
-    req.onerror = () => reject(req.error)
-    req.onsuccess = () => {
-      const db = req.result
-      if (!db.objectStoreNames.contains(store)) { db.close(); resolve(new Map()); return }
-      const out = new Map()
-      const cur = db.transaction(store, 'readonly').objectStore(store).openCursor()
-      cur.onsuccess = () => {
-        const c = cur.result
-        if (c) { out.set(String(c.key), c.value); c.continue() } else { db.close(); resolve(out) }
-      }
-      cur.onerror = () => reject(cur.error)
-    }
-  })
-}

package/vault/vault.js

@@ -15,7 +15,7 @@ import {
 import { createIdentityCore } from './core.js'
 import { pubkeyId } from './capabilities.js'
 import { withExternalKeys, appBridge } from './externalKeys.js'
-import { nativeBackends, adoptPageProfiles, readPageStorage } from './nativeStore.js'
+import { nativeBackends } from './nativeStore.js'
 import { useBackend as usePeerBackend } from './peerStore.js'
 
 ;(async () => {
@@ -25,14 +25,7 @@ import { useBackend as usePeerBackend } from './peerStore.js'
   // Y si la app GUARDA la identidad (`storage`, la de iOS): todo vive allí, uno para todas
   // las páginas, porque WebKit parte el almacén de este iframe por página (`./nativeStore.js`).
   const native = bridge && idKeys.storage === true ? await nativeBackends(bridge) : null
-  if (native) {
-    usePeerBackend(native.peers)
-    // Lo que se emparejó cuando la identidad aún vivía en la página, a la app. Si no se puede
-    // leer el almacén de la página se dice (con su error) y se sigue: la identidad de la app
-    // funciona igual, solo que sin ese perfil.
-    try { await adoptPageProfiles(native, bridge, await readPageStorage()) }
-    catch (e) { console.error('[cc-identity] could not bring this page\'s profiles into the app:', e?.message || e) }
-  }
+  if (native) usePeerBackend(native.peers)
 
   // kv estilo localStorage (síncrono) para me, nonces, delegaciones, certs.
   const kv = native ? native.kv : {

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.73.0 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,loginClient,b64}.js).
+Copia vendorizada de @dotrino/vault@0.74.0 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,loginClient,b64}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 index.js importa ./enroll.js y ./protocol.js (relativos, van en esta misma copia),
 @dotrino/identity/{capabilities,acta} (= ../../{capabilities,acta}.js) y

package/vault/vendor/vault/enroll.js

@@ -30,7 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
-import { verifyContinuity, canSeal } from '@dotrino/identity/acta'
+import { verifyContinuity, canSeal, DEVICE_CAPS } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -159,8 +159,24 @@ export function createEnrollDesk ({
    *   · `account`       → cómo se llama la cuenta de la bóveda, para nombrarla en el
    *                       aviso. Es ORIENTATIVO (un nombre que puso su dueño); la
    *                       identidad de verdad de la cuenta es `iss`.
+   *   · `caps`          → LOS PERMISOS con los que entra al acta, elegidos por quien
+   *                       empareja (dueño, 2026-09-26: «al emparejar debería escoger los
+   *                       permisos, caso contrario estoy obligado a hacer dos actas»). Sin
+   *                       esto el aparato entraba con lo que da el scope y cualquier otro
+   *                       permiso —`admin`, `approve`…— costaba una segunda acta. Se quedan
+   *                       AQUÍ, en la sesión de la bóveda: NO viajan en el QR, así que la
+   *                       invitación que circula no concede nada; lo concede quien teclea
+   *                       el código, igual que hacía `caps` después.
    */
-  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
+  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '', caps = null } = {}) {
+    if (caps != null) {
+      if (!Array.isArray(caps)) throw Object.assign(new Error('caps must be a list'), { code: 'bad-caps' })
+      const cn = scopeToCn(scope)
+      const bad = caps.filter((c) => !(DEVICE_CAPS.includes(c) || (c === 'secrets' && cn)))
+      if (bad.length) throw Object.assign(new Error('unknown permission(s): ' + bad.join(', ')), { code: 'bad-caps' })
+      if (!caps.length) throw Object.assign(new Error('the pairing grants no permission'), { code: 'empty-scope' })
+      caps = [...new Set(caps)]
+    }
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
     const acct = String(account || '').slice(0, 40)
     // INVITACIÓN CORTA: si sabemos cómo alcanzarnos, el QR lleva solo eso y el
@@ -176,12 +192,12 @@ export function createEnrollDesk ({
     const conn = typeof connToken === 'function' ? await connToken() : connToken
     if (conn) {
       const sn = randToken(8)
-      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, caps, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
       return { token: sn, qr: { v: 2, conn, sn, m: mode, proxy }, expiresInMs: PAIRING_TTL_MS }
     }
     const token = randToken(PAIR_TOKEN_BYTES)
     const sn = randToken(PAIR_TOKEN_BYTES)
-    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, caps, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
     return { token, qr: { v: 2, iss, proxy, token, sn, m: mode, ...(acct ? { acct } : {}) }, expiresInMs: PAIRING_TTL_MS }
   }
 
@@ -364,8 +380,10 @@ export function createEnrollDesk ({
     // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
     // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
     // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
+    // Si quien emparejó ELIGIÓ los permisos (`startPairing({ caps })`), entran esos y en
+    // esta misma acta; si no, los que da el scope.
     const cn = scopeToCn(pend.scope)
-    const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
+    const caps = [...new Set([...(pend.caps || scopeToCaps(pend.scope)), ...(cn ? ['secrets'] : [])])]
     if (!caps.length) {
       throw Object.assign(new Error('the pairing scope grants no permission: no certificate was issued'), { code: 'empty-scope' })
     }