@dotrino/identity 0.114.1 → 0.115.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.114.1",
+  "version": "0.115.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -22,6 +22,9 @@
     },
     "./vault/core.js": "./vault/core.js",
     "./vault/remote.js": "./vault/remote.js",
+    "./machine": {
+      "import": "./vault/machine.js"
+    },
     "./acta": {
       "import": "./vault/acta.js"
     },

package/src/index.js

@@ -7,6 +7,8 @@
  * use this library share identity even across different origins.
  */
 
+import { browserMachine } from '../vault/machine.js'
+
 const DEFAULT_VAULT_URL = 'https://id.dotrino.com/'
 
 let singleton = null
@@ -125,6 +127,9 @@ export class Identity {
           this._me = msg.me || null
           this._locked = !!msg.locked
           this._readyResolve(this)
+          // Dónde corre esta página (`vault/machine.js`), para los pedidos a la bóveda. Un
+          // iframe viejo no conoce el método: no pasa nada, solo no se manda.
+          this._call('setMachine', { machine: browserMachine() }).catch(() => {})
           return
         }
 
@@ -427,7 +432,9 @@ export class Identity {
    * @returns {Promise<{ ok:boolean, deviceId:string, master:string, exp:number, scope:string[] }>}
    */
   async enrollDevice (qr, { label = '', join = 'current' } = {}) {
-    return this._call('vaultPair', { qr, label, join }, 200000)
+    // DÓNDE CORRE se mira AQUÍ, en la página, y no dentro del iframe: el iframe no ve si la
+    // página es una extensión o la app nativa (`vault/machine.js`).
+    return this._call('vaultPair', { qr, label, join, machine: browserMachine() }, 200000)
   }
 
   /** Estado de emparejamiento: { paired, deviceId?, master?, scope?, exp?, pairedAt? }. */
@@ -853,4 +860,5 @@ export { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, ve
 // PARA QUIÉN vale una firma, y hasta cuándo. Verificar NO necesita el iframe ni la clave
 // de nadie, así que un servicio puede importarlo suelto (`@dotrino/identity/assertion`, que
 // no arrastra el cliente del vault); aquí se reexporta para quien ya tiene esto cargado.
+export { cleanMachine, machineLine, browserMachine, MACHINE_KINDS } from '../vault/machine.js'
 export { verifyAssertion, verifySignedFor, newAssertionNonce, cleanScopes, claimsAllowed, assertionBody, SCOPES, SCOPE_CLAIMS, ASSERTION_MAX_TTL_MS, ASSERTION_DEFAULT_TTL_MS, ASSERTION_MAX_SKEW_MS } from '../vault/assertion.js'

package/vault/acta.js

@@ -36,6 +36,8 @@
  */
 import { canonicalStringify } from './core.js'
 import { signWithDevice, verifyDeviceSig, verifyDelegation, pubkeyId } from './capabilities.js'
+import { cleanMachine } from './machine.js'
+export { cleanMachine }
 
 export const ACTA_V = 5
 
@@ -816,7 +818,9 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
           addedAt: now,
           cert: m.cert || null,
           // Puente con la identidad que este miembro traía de antes (ver makeContinuity).
-          ...(m.continuity ? { continuity: m.continuity } : {})
+          ...(m.continuity ? { continuity: m.continuity } : {}),
+          // DÓNDE CORRE (`machine.js`): lo que dijo al emparejar, para reconocerlo en la lista.
+          ...(cleanMachine(m.machine) ? { machine: cleanMachine(m.machine) } : {})
         })
         break
       }

package/vault/core.js

@@ -791,7 +791,16 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
   const encKeyId = async (encPub) => (await pubkeyIdOf(encPub)).slice(0, 16)
 
   const loadVaultCert = () => { try { return JSON.parse(kv.getItem(VAULT_CERT_STORAGE) || 'null') } catch (_) { return null } }
+  // DÓNDE CORRE ESTE APARATO (`machine.js`). Lo dice la PÁGINA al conectar (`setMachine`),
+  // porque el iframe no ve si está dentro de una extensión o de la app nativa, y viaja con
+  // cada pedido firmado a la bóveda para que su lista lo enseñe al día. Sin página que lo
+  // diga (Node, un cliente viejo) no se manda nada: mejor ningún dato que uno equivocado.
+  let pageMachine = null
   const loadVaultDevice = () => {
+    const d = loadVaultDeviceKey()
+    return d && pageMachine ? { ...d, machine: pageMachine } : d
+  }
+  const loadVaultDeviceKey = () => {
     try {
       const d = JSON.parse(kv.getItem(VAULT_DEVICE_STORAGE) || 'null')
       if (!d) return null
@@ -1293,7 +1302,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
    * cert contra la bóveda y entra a su cuenta. Aparte para que la decisión de CUÁL cuenta y
    * el deshacerla si esto falla vivan juntos arriba, y aquí solo quede el trámite.
    */
-  async function pairWithVault ({ qr, label = '' }) {
+  async function pairWithVault ({ qr, label = '', machine = undefined }) {
     // Usa la PROPIA llave de identidad de este navegador como dispositivo: el cert delega
     // TU identidad (P) desde la maestra M → una sola identidad (signData/identify/cert = P).
     // La privada es la CryptoKey del perfil (no extractable): se pasa como `privateKey`
@@ -1307,7 +1316,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     const continuity = (mine && mine.members.length === 1 && !isPendingJoin())
       ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mine.profileId, privateKey: masterKey() })
       : null
-    const res = await remoteEnroll({ qr, device, continuity, encPub: encPublickeyJwkStr, label: label || me?.nickname || '', onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
+    const res = await remoteEnroll({ qr, device, continuity, encPub: encPublickeyJwkStr, label: label || me?.nickname || '', machine: machine === undefined && pageMachine ? pageMachine : machine, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
     kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: publickeyJwkStr }))
     kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ cert: res.cert, master: res.master, proxy: res.proxy, deviceId: res.deviceId, pairedAt: Date.now() }))
     // Conectarse a una bóveda es ENTRAR A SU CUENTA: el acta viene con el cert.
@@ -2560,6 +2569,8 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         isService: !!m.cn,
         caps: Acta.effectiveCaps(acta, m.pub, pend),
         addedAt: m.addedAt || null,
+        // Dónde corre, según dijo al emparejarse (`machine.js`). `null` si entró antes.
+        machine: m.machine || null,
         isMe: m.pub === publickeyJwkStr,
         isMaster: Acta.canSeal(acta, m.pub),
         // La llave de CIFRADO del miembro y, derivado, si se le puede envolver algo.
@@ -2605,7 +2616,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * Admite un miembro (solo el master). El cert lo emite quien llama, antes o después.
      * `continuity`: si esa identidad ya existía por su cuenta, su puente firmado (F3).
      */
-    async admitMember ({ pub, encPub = null, label = '', cn = null, caps = null, cert = null, continuity = null } = {}) {
+    async admitMember ({ pub, encPub = null, label = '', cn = null, caps = null, cert = null, continuity = null, machine = null } = {}) {
       // `cn`: si viene, este miembro es un SERVICIO: abre el cajón de secretos de ESE nombre
       // por llevarlo, sin permiso aparte, y no ve nada más del usuario. Sin `cn` es un dispositivo.
       const finales = caps || (cn ? [] : ['store', 'read'])
@@ -2622,7 +2633,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         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] : [])])
+      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, cn, caps: finales, cert, continuity, machine } }, ...(wrap ? [wrap] : [])])
       return { ok: true, seq: acta.seq, wrapped: !!wrap }
     },
 
@@ -2898,8 +2909,8 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      *                   master: si esta cuenta ya la manda otra bóveda, no hay nada que
      *                   regalar y falla en voz alta.
      */
-    async vaultPair ({ qr, label = '', join = 'current' }) {
-      if (join === 'adopt') return handlers.vaultAdopt({ qr, label })
+    async vaultPair ({ qr, label = '', join = 'current', machine = undefined }) {
+      if (join === 'adopt') return handlers.vaultAdopt({ qr, label, machine })
       // La cuenta abierta AQUÍ y la que se cree para este intento. `born` es la que hay que
       // tirar si el emparejamiento no llega a término: nació para él y no tiene nada dentro.
       const from = currentPid
@@ -2929,7 +2940,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         }
       }
       try {
-        return await pairWithVault({ qr, label })
+        return await pairWithVault({ qr, label, machine })
       } catch (e) {
         // El intento falló (código vencido, la bóveda dijo que no, se agotó la espera): la
         // cuenta que nació para él se va con él. Si no, cada reintento dejaba una cuenta
@@ -2953,7 +2964,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * bóveda, este aparato no puede regalar lo que no tiene; el traspaso se hace desde la
      * que manda hoy.
      */
-    async vaultAdopt ({ qr, label = '' } = {}) {
+    async vaultAdopt ({ qr, label = '', machine = undefined } = {}) {
       const mine = loadActa()
       if (!mine) 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')
@@ -2963,6 +2974,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         qr,
         device,
         intent: 'adopt',
+        machine,
         profileId: mine.profileId,
         encPub: encPublickeyJwkStr,
         label: label || me?.nickname || '',
@@ -3009,6 +3021,15 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       return { ok: true, pending: true }
     },
 
+    /**
+     * La página dice dónde corre (`machine.js`); se manda con los pedidos a la bóveda.
+     * @param {any} [args]
+     */
+    async setMachine ({ machine } = {}) {
+      pageMachine = Acta.cleanMachine(machine)
+      return { ok: true }
+    },
+
     async vaultStatus () {
       const v = loadVaultCert()
       if (!v?.cert) return { paired: false }

package/vault/machine.js

@@ -0,0 +1,95 @@
+/**
+ * QUÉ MÁQUINA ES CADA APARATO: dónde corre, y nada más.
+ *
+ * En la lista de aparatos de la bóveda solo había un ID (`AB12-CD34`), una etiqueta que pone
+ * el propio aparato —muchas veces el apodo del usuario, igual en todos— y la fecha de alta.
+ * Con tres navegadores y dos agentes no había forma de saber cuál era cuál (dueño,
+ * 2026-10-15). Esto es lo que lo distingue a simple vista:
+ *
+ *   · `kind` — qué es: `node` (un agente o un comando), `browser`, `extension`, `ios`, `android`.
+ *   · `os`   — el sistema donde corre (`Linux 7.0.0`, `Windows`, `macOS`, `Android 14`).
+ *   · `name` — en Node, el hostname; en un navegador, el navegador (`Chrome`). Un navegador no
+ *     sabe el nombre de la máquina, y lo que no se sabe no se inventa.
+ *
+ * Lo DICE el aparato y va dentro de lo que firma, así que nadie más puede escribirlo por él.
+ * Tampoco es una prueba de nada: un aparato puede llamarse como quiera. Sirve para reconocerlo,
+ * no para decidir — ninguna puerta mira esto.
+ *
+ * Una sola pieza para las dos puntas: lo limpia igual quien lo manda y quien lo guarda (el acta,
+ * la bóveda), para que un campo de más o una cadena de un megabyte no entren por ningún lado.
+ */
+
+export const MACHINE_KINDS = ['node', 'browser', 'extension', 'ios', 'android']
+
+const clip = (s, n) => (typeof s === 'string' ? s.replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, n) : '')
+
+/**
+ * Lo deja en la forma de siempre, o `null` si no dice nada que valga. Nunca lanza: un aparato
+ * viejo o raro no puede tumbar un emparejamiento por cómo describe su máquina.
+ * @param {any} raw
+ * @returns {{ kind: string, os: string, name: string } | null}
+ */
+export function cleanMachine (raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const kind = MACHINE_KINDS.includes(raw.kind) ? raw.kind : ''
+  const os = clip(raw.os, 40)
+  const name = clip(raw.name, 64)
+  if (!kind && !os && !name) return null
+  return { kind, os, name }
+}
+
+/** Una línea para enseñarlo: `node · Linux 7.0.0 · mi-pc`. Vacía si no hay nada. */
+export function machineLine (m) {
+  const c = cleanMachine(m)
+  return c ? [c.kind, c.os, c.name].filter(Boolean).join(' · ') : ''
+}
+
+/** ¿Dicen lo mismo? Para no reescribir un archivo cada vez que un aparato repite lo de siempre. */
+export const sameMachine = (a, b) => machineLine(a) === machineLine(b)
+
+/** @type {Array<[RegExp, (v: string) => string]>} */
+const UA_OS = [
+  [/Android ([\d.]+)/, (v) => 'Android ' + v.split('.')[0]],
+  [/(?:iPhone|iPad|iPod).*? OS (\d+)/, (v) => 'iOS ' + v],
+  [/Windows NT/, () => 'Windows'],
+  [/CrOS/, () => 'ChromeOS'],
+  [/Mac OS X/, () => 'macOS'],
+  [/Linux/, () => 'Linux']
+]
+/** @type {Array<[RegExp, string]>} */
+const UA_BROWSER = [
+  [/Edg\//, 'Edge'], [/OPR\//, 'Opera'], [/Firefox\//, 'Firefox'], [/SamsungBrowser\//, 'Samsung Internet'],
+  [/Chrome\//, 'Chrome'], [/Safari\//, 'Safari']
+]
+
+/**
+ * La máquina de ESTE navegador. `env` se inyecta en las pruebas; en la página es `globalThis`.
+ * Lo nativo se reconoce por el puente de `dotrino-native` (`DotrinoNative.platform()`), la
+ * extensión por tener `chrome.runtime.id`, y el resto es un navegador.
+ * @param {any} [env]
+ */
+export function browserMachine (env = globalThis) {
+  /** @type {any} */
+  const nav = env?.navigator || {}
+  const ua = String(nav.userAgent || '')
+  // Node también tiene `navigator` (`Node.js/22`): no es un navegador, y su máquina la dice
+  // quien sabe mirarla (`selfMachine` de `@dotrino/vault`). Aquí no se inventa.
+  if (env?.process?.versions?.node || !ua || ua.startsWith('Node.js')) return null
+  let kind = 'browser'
+  try {
+    const p = env?.DotrinoNative?.platform?.()
+    if (p === 'ios' || p === 'android') kind = p
+    else if (env?.chrome?.runtime?.id) kind = 'extension'
+  } catch (_) { /* un puente roto no cambia qué navegador es: se queda en `browser` */ }
+  let os = ''
+  for (const [re, fmt] of UA_OS) { const m = ua.match(re); if (m) { os = fmt(m[1] || ''); break } }
+  // iPadOS se presenta como un Mac de escritorio: lo delata la pantalla táctil.
+  if (os === 'macOS' && nav.maxTouchPoints > 1) os = 'iPadOS'
+  let name = ''
+  if (kind === 'browser' || kind === 'extension') {
+    for (const [re, n] of UA_BROWSER) if (re.test(ua)) { name = n; break }
+  }
+  return cleanMachine({ kind, os, name })
+}
+
+export default { MACHINE_KINDS, cleanMachine, machineLine, sameMachine, browserMachine }

package/vault/remote.js

@@ -15,6 +15,7 @@
  */
 import { makeDeviceKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
 import { checkVaultReply } from './acta.js'
+import { cleanMachine, browserMachine } from './machine.js'
 
 const MSG = {
   HELLO: 'vault.hello',
@@ -130,7 +131,7 @@ async function askVault (client, qr) {
  * @param {number} [opts.approveTimeoutMs]  Espera de la aprobación humana (def 3 min).
  * @returns {Promise<{device, cert, master:string, proxy:string, deviceId:string, account:string}>}
  */
-export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, encPub = null, approveTimeoutMs = 180000, intent = 'join', profileId = null, onAdopt = null } = {}) {
+export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, encPub = null, approveTimeoutMs = 180000, intent = 'join', profileId = null, onAdopt = null, machine = undefined } = {}) {
   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 })
@@ -162,12 +163,16 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // rechaza el que no coincida con el modo con el que ella abrió el emparejamiento. Así
     // ninguno de los dos puede hacer, a mitad de camino, algo distinto de lo que el humano
     // vio anunciado en las dos pantallas.
+    // DÓNDE CORRE (`machine.js`), para que la bóveda lo reconozca en su lista. Quien llama
+    // puede pasarlo (lo sabe mejor); si no, se mira el navegador. `null` es no decir nada.
+    const maquina = cleanMachine(machine === undefined ? browserMachine() : machine)
     const adopting = intent === 'adopt'
     if (adopting && typeof onAdopt !== 'function') throw new Error('enrollDevice(adopt): missing onAdopt')
     const data = {
       op: 'enroll', dpub: dev.publickey, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now(), intent,
       ...(adopting && profileId ? { profileId } : {}),
-      ...(continuity ? { continuity } : {}), ...(encPub ? { encPub } : {})
+      ...(continuity ? { continuity } : {}), ...(encPub ? { encPub } : {}),
+      ...(maquina ? { machine: maquina } : {})
     }
     // `dev.sign`: la llave vive fuera (el chip del teléfono) y solo se le pide la firma.
     const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, sign: dev.sign, data })
@@ -283,7 +288,7 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
   await client.connect()
   try {
     try { await identifyAsDevice(client, device, { cert, acta }) } catch (_) { /* sin identify seguimos: solo perdemos la cola */ }
-    const signed = { ...data, publickey: device.publickey, ts: Date.now() }
+    const signed = { ...data, publickey: device.publickey, ts: Date.now(), ...(cleanMachine(device.machine) ? { machine: cleanMachine(device.machine) } : {}) }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, sign: device.sign, data: signed })
     const pending = new Promise((resolve, reject) => {
       let graceTimer = null
@@ -338,7 +343,7 @@ export async function checkMembership ({ master, proxy, device, onRevoked, timeo
     // Identificarse hace además que el proxy entregue lo ENCOLADO (un aviso de cuando
     // estaba apagado, si todavía está dentro de las 24 h).
     try { await identifyAsDevice(client, device) } catch (_) {}
-    const data = { op: 'check', publickey: device.publickey, ts: Date.now() }
+    const data = { op: 'check', publickey: device.publickey, ts: Date.now(), ...(cleanMachine(device.machine) ? { machine: cleanMachine(device.machine) } : {}) }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, sign: device.sign, data })
     const res = await new Promise((resolve) => {
       let settled = false