@dotrino/identity 0.37.1 → 0.39.0

package/package.json

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

@@ -278,6 +278,7 @@ export class Identity {
 
   /** Cambia las capacidades de un miembro (solo el master). */
   async setCaps (pub, caps) { return this._call('setCaps', { pub, caps }) }
+  async setLabel (pub, label) { return this._call('setLabel', { pub, label }) }
 
   /** Expulsa a un miembro (solo el master; al master no se le puede expulsar). */
   async removeMember (pub) { return this._call('removeMember', { pub }) }
@@ -371,6 +372,24 @@ export class Identity {
     return this._call('vaultStore', { method, args }, 20000)
   }
 
+  /**
+   * CONSOLA REMOTA: administra el perfil desde este dispositivo, contra la bóveda
+   * (`dotrino-vault/docs/consola-remota.md`). `op`: `pending` · `pair` · `approve` ·
+   * `reject` · `revoke` · `audit`.
+   *
+   * Requiere que el cert de este aparato lleve `vault:admin`, que **no se recibe al
+   * emparejar**: se concede a mano en la bóveda. Cambiar permisos y traspasar el mando
+   * NO se administran a distancia — siguen siendo del master, en su máquina.
+   */
+  async vaultAdmin (op, args) {
+    return this._call('vaultAdmin', { op, ...(args || {}) }, 20000)
+  }
+
+  /** ¿El cert de este dispositivo le permite administrar el perfil a distancia? */
+  async canAdminVault () {
+    return this._call('canAdminVault', {}, 20000)
+  }
+
   /** Lista (solo lectura) los dispositivos enrolados en tu vault: { devices, revoked }. */
   async listVaultDevices () {
     return this._call('listVaultDevices', {}, 20000)

package/src/node.js

@@ -168,6 +168,7 @@ export class Identity {
   isMaster () { return this._h('isMaster') }
   admitMember (member) { return this._h('admitMember', member) }
   setCaps (pub, caps) { return this._h('setCaps', { pub, caps }) }
+  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 }) }
   renounceCaps (caps) { return this._h('renounceCaps', { caps }) }

package/vault/acta.js

@@ -35,13 +35,26 @@ export const ACTA_V = 1
 /**
  * Lista CERRADA de capacidades. Sellar y admitir no están: eso es ser el master.
  *
- * `secrets` es distinta de las otras tres: solo la pueden tener los miembros con **CN**
+ * `secrets` es distinta de las otras: solo la pueden tener los miembros con **CN**
  * (los servicios), y lo que abre es únicamente el cajón de SU nombre. Ver `cn` abajo.
+ *
+ * `admin` es la rendija que se le abre a la consola remota (`dotrino-vault/docs/
+ * consola-remota.md`): deja **admitir y expulsar** miembros a distancia, y nada más.
+ * NO deja cambiar permisos, traspasar el mando ni conceder `admin` — eso sigue siendo
+ * 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', 'secrets'])
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin'])
 
 /** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
-export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read'])
+export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin'])
+
+/**
+ * Lo que recibe un dispositivo recién emparejado. `admin` **no está**: no se
+ * empareja, se concede después y a mano (`dotrino-vault caps <ID> +admin`), para que
+ * ningún QR que circule pueda otorgar administración.
+ */
+export const PAIRED_CAPS = Object.freeze(['sign', 'store', 'read'])
 
 /** Capacidades de un SERVICIO (con CN): solo su propio cajón de secretos. */
 export const SERVICE_CAPS = Object.freeze(['secrets'])
@@ -58,12 +71,13 @@ export function capScope (cap, cn = null) {
   if (cap === 'sign') return 'vault:sign'
   if (cap === 'store') return 'vault:store'
   if (cap === 'read') return 'vault:read'
+  if (cap === 'admin') return 'vault:admin'
   if (cap === 'secrets') return isValidCn(cn) ? 'vault:secrets:' + cn : null
   return null
 }
 
-/** Compat: el mapa directo, para las tres capacidades de dispositivo. */
-export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read' })
+/** Compat: el mapa directo, para las capacidades de dispositivo. */
+export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read', admin: 'vault:admin' })
 
 const enc = (s) => new TextEncoder().encode(s)
 const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('')
@@ -99,7 +113,7 @@ export const isHandover = (acta) => !!acta && acta.sealer !== acta.sealedBy
  * estable para siempre y coincide con la identidad que el usuario ya tenía (cero migración).
  */
 export function genesisActa ({ pub, encPub = null, label = '', now = Date.now() }) {
-  if (!isPub(pub)) throw new Error('genesisActa: falta la pubkey de la génesis')
+  if (!isPub(pub)) throw new Error('genesisActa: missing genesis pubkey')
   return {
     v: ACTA_V,
     profileId: pub,
@@ -107,7 +121,7 @@ export function genesisActa ({ pub, encPub = null, label = '', now = Date.now()
     sealedBy: pub,
     seq: 1,
     prev: null,
-    members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...DEVICE_CAPS], addedAt: now, cert: null }],
+    members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...PAIRED_CAPS], addedAt: now, cert: null }],
     revoked: [],
     renounced: [],
     // Llavero del contenido: una entrada por generación, con la clave del perfil ENVUELTA
@@ -147,7 +161,7 @@ export function checkShape (acta) {
 /** Sella (firma) un acta. `privateKey` puede ser una CryptoKey no extractable. */
 export async function sealActa ({ acta, privateKey, privateJwk }) {
   const shape = checkShape(acta)
-  if (shape) throw new Error('acta inválida: ' + shape)
+  if (shape) throw new Error('invalid record: ' + shape)
   const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: acta.sealedBy, data: actaBody(acta) })
   const sealed = { ...acta, sig: signature }
   // La TARJETA se firma en el mismo gesto y viaja con el acta: así cualquier miembro puede
@@ -181,9 +195,9 @@ export async function verifyActa ({ acta, expectedProfileId } = {}) {
  */
 export async function applyChanges (acta, changes, { by, now = Date.now() } = {}) {
   const shape = checkShape(acta)
-  if (shape) throw new Error('acta inválida: ' + shape)
-  if (!by) throw new Error('applyChanges: falta `by` (quién sella)')
-  if (by !== acta.sealer) throw new Error('solo el master puede cambiar el acta; este dispositivo no lo es')
+  if (shape) throw new Error('invalid record: ' + shape)
+  if (!by) throw new Error('applyChanges: missing `by` (who seals)')
+  if (by !== acta.sealer) throw new Error('only the master can change the record; this device is not the master')
 
   const list = Array.isArray(changes) ? changes : [changes]
   if (list.length === 0) throw new Error('applyChanges: no hay cambios')
@@ -208,9 +222,9 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
       case 'admit': {
         const m = ch.member
         if (!isPub(m?.pub)) throw new Error('admit: falta la pubkey del miembro')
-        if (find(m.pub)) throw new Error('admit: ese miembro ya está en el acta')
+        if (find(m.pub)) throw new Error('admit: that member is already in the record')
         const cn = m.cn != null ? String(m.cn) : null
-        if (cn !== null && !isValidCn(cn)) throw new Error('admit: CN inválido (minúsculas, números y guiones)')
+        if (cn !== null && !isValidCn(cn)) throw new Error('admit: invalid CN (lowercase, digits and hyphens)')
         next.members.push({
           pub: m.pub,
           encPub: m.encPub || null,
@@ -227,16 +241,27 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
       }
       case 'caps': {
         const m = find(ch.pub)
-        if (!m) throw new Error('caps: ese miembro no está en el acta')
+        if (!m) throw new Error('caps: that member is not in the record')
         // No se puede ascender un servicio a dispositivo cambiándole las capacidades: para
         // eso hay que sacarlo y volver a admitirlo, que es un gesto visible.
         m.caps = cleanCaps(ch.caps).filter((c) => (m.cn ? SERVICE_CAPS : DEVICE_CAPS).includes(c))
         break
       }
+      case 'label': {
+        // RENOMBRAR un miembro. La etiqueta se escribía solo al admitir, con lo que el
+        // aparato se quedaba para siempre con el nombre que tuviera el día que entró
+        // (normalmente el apodo del usuario en ese momento), y para cambiarlo había que
+        // revocarlo y volver a emparejarlo. Es un nombre para el humano: no toca permisos
+        // ni llaves, pero se sella y se firma como cualquier otro cambio del acta.
+        const m = find(ch.pub)
+        if (!m) throw new Error('label: that member is not in the record')
+        m.label = String(ch.label || '').slice(0, 60)
+        break
+      }
       case 'remove': {
         const i = next.members.findIndex((m) => m.pub === ch.pub)
-        if (i < 0) throw new Error('remove: ese miembro no está en el acta')
-        if (next.members[i].pub === next.sealer) throw new Error('remove: no puedes expulsar al master; primero traspasa el sellado')
+        if (i < 0) throw new Error('remove: that member is not in the record')
+        if (next.members[i].pub === next.sealer) throw new Error('remove: cannot remove the master; hand the sealing over first')
         const fuera = next.members.splice(i, 1)[0]
         // Sus envolturas se van con él: sin ellas no puede abrir ninguna generación. (El
         // acceso al contenido FUTURO se corta rotando, ver content.js; lo ya leído no vuelve.)
@@ -247,21 +272,21 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         break
       }
       case 'handover': {
-        if (!find(ch.to)) throw new Error('handover: el nuevo master tiene que ser miembro (admítelo en el mismo cambio)')
+        if (!find(ch.to)) throw new Error('handover: the new master must be a member (admit them in the same change)')
         next.sealer = ch.to
         break
       }
       case 'keyring': {
         // Generación NUEVA de la clave de contenido (al rotar: expulsar a alguien).
         const g = ch.generation
-        if (!g || !Number.isInteger(g.gen)) throw new Error('keyring: generación inválida')
+        if (!g || !Number.isInteger(g.gen)) throw new Error('keyring: invalid generation')
         next.keyring = [...next.keyring.filter((x) => x.gen !== g.gen), g].sort((a, b) => a.gen - b.gen)
         break
       }
       case 'wrap': {
         // Envolver la clave YA existente para un miembro nuevo (al admitir: no hace falta rotar).
         const g = next.keyring.find((x) => x.gen === ch.gen)
-        if (!g) throw new Error('wrap: esa generación no está en el llavero')
+        if (!g) throw new Error('wrap: that generation is not in the keyring')
         g.wraps = { ...g.wraps, [ch.pub]: ch.wrap }
         break
       }
@@ -290,10 +315,10 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
 
   // Reglas de cierre: sin firmante no se puede operar, y sin sellador no se puede cambiar.
   if (!next.members.some((m) => m.caps.includes('sign'))) {
-    throw new Error('el cambio dejaría el perfil sin ningún miembro que pueda firmar')
+    throw new Error('the change would leave the profile with no member able to sign')
   }
   if (!next.members.some((m) => m.pub === next.sealer)) {
-    throw new Error('el cambio dejaría el acta sin master')
+    throw new Error('the change would leave the record with no master')
   }
   return next
 }

package/vault/content.js

@@ -70,7 +70,7 @@ export async function wrapForMember ({ cek, memberEncPub }) {
 
 /** Abre la envoltura con la llave de cifrado privada de ESTE miembro. */
 export async function openWrap ({ wrap, myEncPrivateKey }) {
-  if (!wrap?.epk || !wrap?.iv || !wrap?.ct) throw new Error('envoltura inválida')
+  if (!wrap?.epk || !wrap?.iv || !wrap?.ct) throw new Error('invalid wrap')
   const key = await sharedKey(myEncPrivateKey, wrap.epk)
   const pt = await subtle.decrypt({ name: 'AES-GCM', iv: fromB64(wrap.iv) }, key, fromB64(wrap.ct))
   return new TextDecoder().decode(pt)
@@ -119,7 +119,7 @@ export async function encryptWithCek ({ cek, gen, plaintext }) {
 export async function decryptWithKeyring ({ envelope, keyring, myPub, myEncPrivateKey }) {
   const g = (keyring || []).find((x) => x.gen === envelope?.gen)
   const w = g?.wraps?.[myPub]
-  if (!w) throw new Error('este dispositivo no tiene la llave de esa generación de contenido')
+  if (!w) throw new Error('this device does not hold the key for that content generation')
   const cek = await openWrap({ wrap: w, myEncPrivateKey })
   const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['decrypt'])
   const pt = await subtle.decrypt({ name: 'AES-GCM', iv: fromB64(envelope.iv) }, k, fromB64(envelope.ct))

package/vault/core.js

@@ -22,7 +22,7 @@ import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './
 import * as Acta from './acta.js'
 import * as Content from './content.js'
 import { pubkeyId as pubkeyIdOf } from './capabilities.js'
-import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew } from './remote.js'
+import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
 export const ENC_KEY_STORAGE = 'dotrino.identity.enc-keypair'
@@ -400,7 +400,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    */
   async function sealChanges (changes) {
     const acta = loadActa()
-    if (!acta) throw new Error('este perfil todavía no tiene acta')
+    if (!acta) throw new Error('this profile has no record yet')
     const next = await Acta.applyChanges(acta, changes, { by: publickeyJwkStr })
     const sealed = await seal(next)
     pushHistory(acta) // la que deja de ser vigente entra en la ventana de retención
@@ -815,7 +815,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const proof = await derivePwd(password, pwd.salt, pwd.iter)
       if (proof !== pwd.verifier) {
         kv.setItem('dotrino.identity.pwd.tries', JSON.stringify({ n: tries.n + 1, at: Date.now() }))
-        throw new Error('contraseña incorrecta')
+        throw new Error('wrong password')
       }
       kv.removeItem('dotrino.identity.pwd.tries')
       try { sessionKv?.setItem(_scoped(PWD_SESSION), proof) } catch (_) {}
@@ -825,7 +825,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // Poner/cambiar contraseña (requiere estar desbloqueado; cambiar exige la actual vía unlock previo).
     async setProfilePassword ({ password }) {
       if (locked) throw new Error('perfil bloqueado')
-      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)))
       const verifier = await derivePwd(password, salt, PWD_ITER)
       kv.setItem(PWD_STORAGE, JSON.stringify({ v: 1, salt, iter: PWD_ITER, verifier }))
@@ -1004,7 +1004,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) {
-        throw new Error('perfil-sin-firmante: este dispositivo ya no firma por ti y no está conectado a ninguna bóveda que pueda hacerlo')
+        throw new Error('profile-without-signer: this device no longer signs for you and is not connected to any vault that can')
       }
       maybeRenewVaultCert()
       try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload: data, onRevoked: wipeVaultLink }) }
@@ -1109,7 +1109,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     },
     async deleteProfile ({ id } = {}) {
       let list = loadProfiles()
-      if (list.length <= 1) throw new Error('no se puede borrar el único perfil')
+      if (list.length <= 1) throw new Error('cannot delete the only profile')
       if (!list.find((p) => p.id === id)) throw new Error('perfil no existe')
       list = list.filter((p) => p.id !== id); saveProfiles(list)
       // Borrado directo del namespace del perfil (incluye su store del vault si lo tuviera).
@@ -1191,6 +1191,22 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       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
+     * perfil, las delegaciones qué certs se emitieron— y las listas de dispositivos leen
+     * la segunda, así que tocar solo una deja el nombre viejo a la vista.
+     */
+    async setLabel ({ pub, label } = {}) {
+      const limpio = String(label || '').slice(0, 60)
+      const acta = await sealChanges([{ op: 'label', pub, label: limpio }])
+      const store = loadDelegations()
+      let tocadas = 0
+      for (const d of Object.values(store)) { if (d.sub === pub) { d.label = limpio; tocadas++ } }
+      if (tocadas) saveDelegations(store)
+      return { ok: true, seq: acta.seq, label: limpio, delegations: tocadas }
+    },
+
     async removeMember ({ pub } = {}) {
       const acta = await sealChanges([{ op: 'remove', pub }])
       // Expulsar rota la clave: el que sale no podrá abrir el contenido NUEVO. Lo que ya
@@ -1220,7 +1236,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async renounceCaps ({ caps } = {}) {
       const acta = loadActa()
-      if (!acta) throw new Error('este perfil todavía no tiene acta')
+      if (!acta) throw new Error('this profile has no record yet')
       const record = await Acta.makeRenounce({ member: publickeyJwkStr, caps, privateKey: keypair.privateKey })
       const pend = loadRenounces().filter((r) => r.member !== publickeyJwkStr)
       pend.push(record)
@@ -1233,7 +1249,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     /** Absorbe en el acta una renuncia ajena ya verificada (solo el master). */
     async absorbRenounce ({ record } = {}) {
-      if (!(await Acta.verifyRenounce(record))) throw new Error('renuncia inválida: la firma no es del propio miembro')
+      if (!(await Acta.verifyRenounce(record))) throw new Error('invalid renounce: the signature is not the member own')
       const acta = await sealChanges([{ op: 'renounce', record }])
       return { ok: true, seq: acta.seq }
     },
@@ -1250,7 +1266,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async sealContent ({ plaintext } = {}) {
       const mine = await myCek()
-      if (!mine) throw new Error('este dispositivo todavía no tiene la clave de contenido del perfil')
+      if (!mine) throw new Error('this device does not hold the profile content key yet')
       return Content.encryptWithCek({ cek: mine.cek, gen: mine.gen, plaintext: String(plaintext) })
     },
 
@@ -1294,7 +1310,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * y la firmó el mismo master. Si el master cambió, se avisa en vez de aceptarlo callando.
      */
     async adoptPeerCard ({ card } = {}) {
-      if (!card?.profileId) throw new Error('tarjeta inválida')
+      if (!card?.profileId) throw new Error('invalid card')
       const peers = loadPeers()
       const prev = peers[card.profileId]?.card || null
       const r = await Acta.canAdoptCard({ card, current: prev })
@@ -1339,7 +1355,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       } else {
         const yaConEsta = loadVaultCert()?.master === qr?.iss
         if (loadActa() && !isPendingJoin() && !yaConEsta) {
-          throw new Error('este aparato ya está usando una cuenta: para usar también la de tu bóveda, crea una cuenta nueva aquí (la que tienes abierta no se toca)')
+          throw new Error('this device is already using an account: to also use your vault account, create a new account here (the open one is untouched)')
         }
       }
       // Usa la PROPIA llave de identidad de este navegador como dispositivo: el cert delega
@@ -1381,8 +1397,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async vaultAdopt ({ qr, label = '' } = {}) {
       const mio = loadActa()
-      if (!mio) throw new Error('este aparato todavía no tiene ninguna cuenta que entregar')
-      if (!amMaster()) throw new Error('no-eres-el-master: esta cuenta ya la manda otro dispositivo o bóveda; el traspaso se hace desde ahí')
+      if (!mio) throw new Error('this device has no account to hand over yet')
+      if (!amMaster()) throw new Error('not-the-master: another device or vault is in charge of this account; the handover is done from there')
 
       const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
       const res = await remoteEnroll({
@@ -1417,7 +1433,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const r = await adoptActa(res.acta)
       const ok = r.adopted || r.reason === 'misma-acta'
       emitVault({ phase: 'adopted', master: res.master, seq: res.acta?.seq, ok })
-      if (!ok) throw new Error('la bóveda devolvió un acta que no encaja: ' + r.reason)
+      if (!ok) throw new Error('the vault returned a record that does not fit: ' + r.reason)
       return { ok: true, adopted: true, profileId: mio.profileId, seq: r.seq ?? res.acta?.seq, master: res.master, deviceId: res.deviceId }
     },
 
@@ -1454,7 +1470,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // así nada se rompe si no estás emparejado o si el vault está apagado.
     async vaultSign ({ payload }) {
       const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
       maybeRenewVaultCert()
       try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload, onRevoked: wipeVaultLink }) }
       catch (e) { return handleVaultError(e) }
@@ -1470,7 +1486,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async vaultStore ({ method, args }) {
       const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
       maybeRenewVaultCert()
       const mine = await myCek().catch(() => null)
       let payload = { method, args }
@@ -1489,10 +1505,38 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       } catch (e) { return handleVaultError(e) }
     },
 
+    /**
+     * CONSOLA REMOTA: administrar el perfil desde este dispositivo (ver
+     * `dotrino-vault/docs/consola-remota.md`). Requiere que el cert de este aparato
+     * lleve `vault:admin`, que **no se recibe al emparejar**: se concede a mano en la
+     * bóveda (`dotrino-vault caps <ID> +administra`).
+     *
+     * `op`: `pending` · `pair` · `approve` · `reject` · `revoke` · `audit`. Cambiar
+     * permisos y traspasar el mando NO están, y no es un olvido: eso sigue siendo del
+     * master, en su máquina.
+     */
+    async vaultAdmin ({ op, ...rest } = {}) {
+      const v = loadVaultCert(); const device = loadVaultDevice()
+      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
+      maybeRenewVaultCert()
+      try { return await remoteAdmin({ master: v.master, proxy: v.proxy, device, cert: v.cert, op, ...rest, onRevoked: wipeVaultLink }) }
+      catch (e) { return handleVaultError(e) }
+    },
+
+    /**
+     * ¿Puede ESTE dispositivo administrar el perfil a distancia? Sale del scope del
+     * cert que le dio la bóveda, no de una preferencia: la interfaz pregunta para
+     * saber qué pintar, pero quien decide es la bóveda al recibir la petición.
+     */
+    canAdminVault () {
+      const v = loadVaultCert()
+      return !!v?.cert && (v.cert.scope || []).includes('vault:admin')
+    },
+
     // Lista (solo lectura) de dispositivos enrolados en tu vault.
     async listVaultDevices () {
       const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
       maybeRenewVaultCert()
       try {
         const res = await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert, sinceSeq: loadActa()?.seq ?? 0, onRevoked: wipeVaultLink })
@@ -1603,7 +1647,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       if (!envelope || (envelope.v !== 1 && envelope.v !== 2)) throw new Error('Unsupported envelope')
       const myId = await encKeyId(encPublickeyJwkStr)
       const myEntry = envelope.wrap && (envelope.wrap[myId] || (myToken ? envelope.wrap[myToken] : null))
-      if (!myEntry) throw new Error('este dispositivo no está entre los destinatarios del mensaje')
+      if (!myEntry) throw new Error('this device is not among the message recipients')
       const senderPub = await importPeerEncPubkey(senderEncryptionPubkey)
       const sharedKey = await deriveSharedAesKey(encKeypair.privateKey, senderPub)
       const kRaw = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: base64ToBuf(myEntry.iv) }, sharedKey, base64ToBuf(myEntry.ct))
@@ -1615,7 +1659,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     async exportIdentity () {
       const raw = kv.getItem(KEY_STORAGE)
       if (!raw) {
-        throw new Error('Este perfil guarda su llave de forma NO exportable (protección contra robo). ' +
+        throw new Error('This profile stores its key as NON-exportable (theft protection). ' +
           'Para usar tu identidad en otro navegador, conecta ese navegador a tu bóveda (vault) desde profile.dotrino.com.')
       }
       const keys = JSON.parse(raw)
@@ -1758,7 +1802,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     const fn = handlers[name]
     handlers[name] = async (params) => {
       if (locked) refreshLockState() // otra pestaña pudo desbloquear… no: session es por pestaña; re-chequea por si se quitó el pwd
-      if (locked) throw new Error('perfil bloqueado: desbloquéalo con tu contraseña (unlockProfile)')
+      if (locked) throw new Error('profile locked: unlock it with your password (unlockProfile)')
       return fn(params)
     }
   }

package/vault/index.html

@@ -25,7 +25,8 @@
   { "imports": {
     "@dotrino/proxy-client": "./vendor/proxy-client/index.js",
     "@dotrino/vault": "./vendor/vault/index.js",
-    "@dotrino/identity/capabilities": "./capabilities.js"
+    "@dotrino/identity/capabilities": "./capabilities.js",
+    "@dotrino/identity/acta": "./acta.js"
   } }
   </script>
   <script type="module" src="./vault.js"></script>

package/vault/peerStore.js

@@ -96,7 +96,7 @@ export async function initPeerStorage () {
     const stored = await idbGet(_idb, peersKey()) // peer book DEL perfil activo (namespaceado)
     _peers = (stored && typeof stored === 'object') ? stored : {}
   } catch (e) {
-    console.warn('[cc-identity] IndexedDB no disponible, uso localStorage:', e?.message)
+    console.warn('[cc-identity] IndexedDB unavailable, falling back to localStorage:', e?.message)
     _fallback = true
     _idb = null
     try { const raw = localStorage.getItem(peersKey()); _peers = raw ? (JSON.parse(raw) || {}) : {} }
@@ -109,13 +109,13 @@ function persistPeers () {
   const key = peersKey()
   if (_fallback || !_idb) {
     try { localStorage.setItem(key, JSON.stringify(_peers)) }
-    catch (e) { console.warn('[cc-identity] persist (ls) falló:', e?.message) }
+    catch (e) { console.warn('[cc-identity] persist (ls) failed:', e?.message) }
     return _writeChain
   }
   const snapshot = _peers
   _writeChain = _writeChain
     .then(() => idbPut(_idb, key, snapshot))
-    .catch(e => console.warn('[cc-identity] persist (idb) falló:', e?.message))
+    .catch(e => console.warn('[cc-identity] persist (idb) failed:', e?.message))
   return _writeChain
 }
 

package/vault/remote.js

@@ -28,6 +28,10 @@ const MSG = {
   ACTA_SEALED: 'vault.acta.sealed',
   ACTA_ADOPTED: 'vault.acta.adopted',
   REVOKED: 'vault.revoked',
+  // Consola remota: administrar el perfil desde un dispositivo (scope `vault:admin`).
+  ADMIN: 'vault.admin',
+  ADMIN_RESULT: 'vault.admin.result',
+  ADMIN_EVENT: 'vault.admin.event',
   ERROR: 'vault.error'
 }
 export { MSG as VAULT_MSG }
@@ -68,9 +72,9 @@ async function identifyAsDevice (client, device, { cert = null, acta = null } =
  */
 async function verificarHola (p, sn) {
   const b = p?.body
-  if (!b?.iss || b.sn !== sn) throw new Error('la bóveda contestó a otro emparejamiento')
+  if (!b?.iss || b.sn !== sn) throw new Error('the vault answered a different pairing')
   if (!(await verifyDeviceSig({ publickey: b.iss, data: b, signature: p.signature }))) {
-    throw new Error('la respuesta de la bóveda no está bien firmada')
+    throw new Error('the vault reply is not properly signed')
   }
   return b
 }
@@ -82,7 +86,7 @@ async function verificarHola (p, sn) {
  */
 async function canjearCita (client, code) {
   const r = await client.redeemPairingCode(code)
-  if (!r?.ok || !r.instance) throw new Error(r?.error || 'ese código de emparejamiento ya no vale')
+  if (!r?.ok || !r.instance) throw new Error(r?.error || 'that pairing code is no longer valid')
   return r.instance
 }
 
@@ -94,7 +98,7 @@ async function askVault (client, qr) {
       if (p?.type === MSG.HELLO_OK) { fin(); verificarHola(p, qr.sn).then((b) => resolve({ iss: b.iss, proxy: b.proxy || qr.proxy, acct: b.acct || '', m: b.m || qr.m }), reject) }
       else if (p?.type === MSG.ERROR) { fin(); reject(new Error(p.error)) }
     })
-    const t = setTimeout(() => { fin(); reject(new Error('la bóveda no contestó: ese código pudo caducar')) }, 15000)
+    const t = setTimeout(() => { fin(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
     const fin = () => { off(); clearTimeout(t) }
     try { client.send(destino, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { fin(); reject(e) }
   })
@@ -109,7 +113,7 @@ async function askVault (client, qr) {
  * @returns {Promise<{device, cert, master:string, proxy:string, deviceId:string}>}
  */
 export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, encPub = null, approveTimeoutMs = 180000, intent = 'join', profileId = null, onAdopt = null } = {}) {
-  if (!qr?.sn || !(qr.iss || qr.conn)) throw new Error('qr inválido: falta la bóveda o el nonce')
+  if (!qr?.sn || !(qr.iss || qr.conn)) throw new Error('invalid qr: missing vault or nonce')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: qr.proxy || 'wss://proxy.dotrino.com', enableWebRTC: false, autoReconnect: false })
   await client.connect()
@@ -172,7 +176,7 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
         else if (p.type === MSG.ACTA_ADOPTED && adoptar) { cleanup(); resolve(p) }
         else if (p.type === MSG.ERROR) { cleanup(); reject(new Error(p.error)) }
       })
-      const t = setTimeout(() => { cleanup(); reject(new Error('timeout esperando la aprobación en el vault')) }, approveTimeoutMs)
+      const t = setTimeout(() => { cleanup(); reject(new Error('timeout waiting for approval at the vault')) }, approveTimeoutMs)
       const cleanup = () => { off(); clearTimeout(t) }
     })
     client.sendByPubkey(qr.iss, { type: MSG.ENROLL, data, signature })
@@ -181,14 +185,14 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // Camino A: aquí no hay cert que validar — este aparato NO delega su identidad, sigue
     // siendo la cuenta. Lo que vuelve es el acta ya sellada por la bóveda.
     if (adoptar) {
-      if (!res.acta) throw new Error('la bóveda no devolvió el acta adoptada')
-      if (res.acta.sealer !== qr.iss) throw new Error('el acta la sella una bóveda distinta a la que viste')
+      if (!res.acta) throw new Error('the vault did not return the adopted record')
+      if (res.acta.sealer !== qr.iss) throw new Error('the record is sealed by a vault other than the one you saw')
       return { device: dev, cert: null, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta, adopted: true }
     }
 
     // Validación estricta antes de guardar (cierra inyección de cert / sustitución de maestra).
     const v = await verifyDelegation({ cert: res.cert, expectedSub: dev.publickey })
-    if (!v.ok) throw new Error('cert inválido: ' + v.reason)
+    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
     if (res.cert.iss !== qr.iss) throw new Error('cert firmado por una maestra distinta a la que viste')
     if (res.cert.sub !== dev.publickey) throw new Error('cert emitido para otro dispositivo')
     return { device: dev, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta || null }
@@ -237,7 +241,7 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
         if (p.type === okType) { cleanup(); resolve(p) }
         else if (p.type === 'vault.error') { cleanup(); reject(new Error(p.error)) }
       })
-      const t = setTimeout(() => { cleanup(); reject(new Error('el vault no respondió (¿está encendido?)')) }, timeoutMs)
+      const t = setTimeout(() => { cleanup(); reject(new Error('the vault did not reply (is it running?)')) }, timeoutMs)
       const cleanup = () => { off(); clearTimeout(t) }
     })
     client.sendByPubkey(master, { type: sendType, data: signed, signature, cert })
@@ -267,6 +271,39 @@ export async function requestDevices ({ master, proxy, device, cert, sinceSeq, o
  */
 export async function requestRenew ({ master, proxy, device, cert, onRevoked } = {}) {
   const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.renew', okType: 'vault.renewed', data: { op: 'renew' } })
-  if (!res.cert || res.cert.sub !== device.publickey || res.cert.iss !== master) throw new Error('cert renovado inválido')
+  if (!res.cert || res.cert.sub !== device.publickey || res.cert.iss !== master) throw new Error('invalid renewed cert')
   return { cert: res.cert }
 }
+
+/**
+ * CONSOLA REMOTA (`dotrino-vault/docs/consola-remota.md`): administrar el perfil desde
+ * este dispositivo, sin ir al PC. Requiere un cert con scope `vault:admin`, que **no se
+ * recibe al emparejar** — se concede a mano en la bóveda.
+ *
+ * `op`: `pending` · `pair` · `approve` · `reject` · `revoke` · `audit`. Lo que NO existe
+ * aquí es tan importante como lo que sí: cambiar permisos, traspasar el mando y los
+ * secretos de servicios no se administran a distancia.
+ *
+ * El `nonce` de un solo uso va en cada petición porque `approve` y `revoke` cambian
+ * estado, y para eso la ventana de frescura de ±5 min no alcanza.
+ */
+export async function requestAdmin ({ master, proxy, device, cert, op, onRevoked, ...rest } = {}) {
+  const nonce = [...crypto.getRandomValues(new Uint8Array(16))]
+    .map((b) => b.toString(16).padStart(2, '0')).join('')
+  const res = await vaultRpc({
+    master, proxy, device, cert, onRevoked,
+    sendType: MSG.ADMIN, okType: MSG.ADMIN_RESULT,
+    data: { op, ...rest, nonce }
+  })
+  return res.result
+}
+
+/**
+ * ¿Es AUTÉNTICO este `vault.admin.event` (entró o salió alguien del perfil)? Solo si va
+ * firmado por la maestra PINEADA. Un aviso sin firma no se muestra: si no, cualquiera
+ * podría llenar de alarmas falsas los dispositivos del usuario.
+ */
+export async function isAuthenticAdminEvent ({ body, signature, master }) {
+  if (!body || typeof body.ev !== 'string') return false
+  return verifyDeviceSig({ publickey: master, data: body, signature })
+}