@dotrino/vaultd 0.9.0 → 0.11.0

package/lib/src/enroll.js

@@ -39,9 +39,15 @@ export const FRESH_WINDOW_MS = 5 * 60 * 1000
 /** Vida por defecto del cert de un dispositivo (tope duro de `MAX_DELEGATION_MS`). */
 export const DEVICE_TTL_MS = 30 * 24 * 60 * 60 * 1000
 
+export const MSG_HELLO = 'vault.hello'
+export const MSG_HELLO_OK = 'vault.hello.ok'
 export const MSG_ENROLL = 'vault.enroll'
 export const MSG_ENROLL_CHALLENGE = 'vault.enroll.challenge'
 export const MSG_ENROLLED = 'vault.enrolled'
+// --- camino A: la cuenta del aparato pasa a vivir en la bóveda ---
+export const MSG_ENROLL_ADOPT = 'vault.enroll.adopt'
+export const MSG_ACTA_SEALED = 'vault.acta.sealed'
+export const MSG_ACTA_ADOPTED = 'vault.acta.adopted'
 export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
@@ -104,8 +110,14 @@ export async function deviceIdOf (pub) {
 export function createEnrollDesk ({
   identity, iss, proxy, send, sendByPubkey,
   audit = () => {}, log = () => {},
-  onChallenge = () => {}, onPendingChange = () => {},
-  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS
+  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {},
+  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS,
+  // Camino A: lo que ESTA bóveda le manda al aparato para que la meta en su acta. `encPub`
+  // es su llave de CIFRADO — sin ella entra mandando pero sin poder leer el contenido.
+  encPub = null, vaultLabel = '',
+  // Token de CONEXIÓN de esta bóveda en el proxy (4 chars): su dirección. Es lo
+  // único que necesita el QR corto para que el aparato le hable punto a punto.
+  connToken = null
 } = {}) {
   if (!identity) throw new Error('createEnrollDesk: falta identity')
   if (!iss) throw new Error('createEnrollDesk: falta iss (pubkey de la maestra)')
@@ -136,9 +148,19 @@ export function createEnrollDesk ({
    */
   function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
     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 nuestra dirección en el proxy, el QR lleva solo
+    // eso y el nonce de la sesión (13 bytes). La llave, el proxy y el nombre de la
+    // cuenta los pide el aparato por la red presentando el `sn`. El nonce hace de
+    // identificador de sesión: no hace falta un token de emparejamiento aparte.
+    const conn = typeof connToken === 'function' ? 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' })
+      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)
-    const acct = String(account || '').slice(0, 40)
     pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, 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 }
   }
@@ -158,6 +180,28 @@ export function createEnrollDesk ({
     return null
   }
 
+  /**
+   * «¿Quién eres?» — la respuesta al QR corto. Solo se contesta a quien presente el
+   * `sn` de una sesión VIVA: el token de conexión son 4 caracteres y se puede acertar
+   * a ciegas, el `sn` no. Fuera de un emparejamiento no hay ninguna sesión y por lo
+   * tanto no hay respuesta: la puerta solo está abierta mientras dura el `pair`.
+   */
+  async function handleHello (from, p) {
+    const pend = pending.get(String(p?.sn || ''))
+    if (!pend || Date.now() > pend.exp) {
+      audit('rejected', { what: 'hello', reason: 'sin-sesion' })
+      return reply(from, { type: MSG_ERROR, error: 'no hay ningún emparejamiento abierto con ese código' })
+    }
+    // La respuesta va FIRMADA por la maestra y el `sn` va dentro de lo firmado. Eso ata
+    // la respuesta a ESTA sesión: no se puede reutilizar la de otro emparejamiento ni la
+    // de otra bóveda. Lo que NO hace es demostrar que sea TU bóveda —cualquiera puede
+    // firmar con una llave suya—; eso solo lo demuestra el código de 6 dígitos.
+    const body = { op: 'hello', sn: pend.sn, iss, proxy, acct: pend.account || '', m: pend.mode || 'join', ts: Date.now() }
+    const { signature } = await identity.signData(body)
+    reply(from, { type: MSG_HELLO_OK, body, signature })
+    return { ok: true }
+  }
+
   /**
    * ENROLL: el dispositivo prueba posesión de `D` firmando el sobre y deja el
    * COMPROMISO de su código. Todavía NO se firma ningún cert.
@@ -172,6 +216,17 @@ export function createEnrollDesk ({
       return reply(from, { type: MSG_ERROR, error: 'token de emparejamiento inválido o expirado' })
     }
     if (d.sn !== pend.sn) return reply(from, { type: MSG_ERROR, error: 'sesión inválida' })
+    // V7 · la INTENCIÓN viaja firmada y tiene que coincidir con el modo con el que ESTA
+    // bóveda abrió el emparejamiento. Es lo que garantiza que lo que pasa es lo que el
+    // humano vio anunciado en las dos pantallas, y no algo que se decidió a mitad de camino.
+    const intent = d.intent || 'join'
+    if (intent !== 'join' && intent !== 'adopt') {
+      return reply(from, { type: MSG_ERROR, error: 'intención desconocida: ' + intent })
+    }
+    if (intent !== (pend.mode || 'join')) {
+      audit('rejected', { what: 'enroll', reason: 'intent-mismatch' })
+      return reply(from, { type: MSG_ERROR, error: `este emparejamiento se abrió para «${pend.mode || 'join'}» y el dispositivo pidió «${intent}»` })
+    }
     if (!isFresh(d)) {
       audit('rejected', { what: 'enroll', reason: 'stale' })
       return reply(from, { type: MSG_ERROR, error: 'petición vencida: ts fuera de la ventana ±5 min (posible replay, o el reloj del dispositivo está desfasado)' })
@@ -208,9 +263,12 @@ export function createEnrollDesk ({
     }
     pend.from = from // la bóveda NO conoce el código: lo aprende cuando lo tipeas
     if (d.label) pend.label = String(d.label).slice(0, 60)
+    // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
+    // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
+    if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
 
     reply(from, { type: MSG_ENROLL_CHALLENGE, deviceId })
-    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '' })
+    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', mode: pend.mode || 'join' })
     fire(onPendingChange)
     return { deviceId }
   }
@@ -246,6 +304,20 @@ export function createEnrollDesk ({
       throw new Error('el código no coincide con el que muestra el dispositivo: no se emitió ningún certificado. Vuelve a mirarlo y prueba otra vez.')
     }
 
+    // CAMINO A · aquí la bóveda no entrega un cert: entrega SU IDENTIDAD para que el
+    // aparato la meta en el acta de la cuenta que le está pasando. El código de vuelta es
+    // la misma defensa de siempre, en el otro sentido: el aparato solo hace caso a una
+    // bóveda que demuestre que un humano la aprobó.
+    if ((pend.mode || 'join') === 'adopt') {
+      audit('adopt-approve', { device: pend.deviceId, profile: pend.profileId || null })
+      pend.state = 'AWAITING_ACTA'
+      pend.approvedAt = Date.now()
+      reply(pend.from, { type: MSG_ENROLL_ADOPT, code, pub: iss, encPub: encPub || null, label: vaultLabel || '' })
+      log('[vault] adopción aprobada para %s: esperando el acta sellada', pend.deviceId)
+      fire(onPendingChange)
+      return { ok: true, deviceId: pend.deviceId, adopting: true }
+    }
+
     const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
 
     // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
@@ -273,6 +345,60 @@ export function createEnrollDesk ({
     return { ok: true, deviceId: pend.deviceId, cert }
   }
 
+  /**
+   * CAMINO A · paso 6: llega el acta que el aparato acaba de sellar, con la bóveda dentro
+   * como miembro, la clave de contenido envuelta para ella y el mando ya traspasado.
+   *
+   * Lo que se comprueba antes de guardar nada (y por qué):
+   *   · que el sellador sea ESTA bóveda — si no, no es un traspaso, es un acta ajena;
+   *   · que la selle el aparato que estaba en este emparejamiento — cierra que un tercero
+   *     que vea pasar el mensaje cuele la suya;
+   *   · que sea la cuenta que ese aparato declaró al enrolarse (`profileId`) — cierra el
+   *     cambiazo de cuenta entre el anuncio que leyó el humano y lo que llega después.
+   *
+   * Adoptar la cuenta de otro solo procede sobre un perfil que **nació para eso** (la marca
+   * de `prepareForAdoption`). Es la misma regla del navegador: sin la marca, adoptar sería
+   * pisar una cuenta con datos, y eso no puede pasar por accidente.
+   */
+  async function handleActaSealed (from, p) {
+    const acta = p?.acta
+    const pend = [...pending.values()].find((x) => x.state === 'AWAITING_ACTA' && (x.from === from || x.dpub))
+    if (!pend) return reply(from, { type: MSG_ERROR, error: 'no hay ninguna adopción esperando un acta' })
+    if (!acta || typeof acta !== 'object') return reply(from, { type: MSG_ERROR, error: 'acta ausente o ilegible' })
+    if (acta.sealer !== iss) {
+      audit('rejected', { what: 'adopt', reason: 'not-sealer' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta no nombra a esta bóveda como quien manda' })
+    }
+    if (acta.sealedBy !== pend.dpub) {
+      audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta no la selló el dispositivo de este emparejamiento' })
+    }
+    if (pend.profileId && acta.profileId !== pend.profileId) {
+      audit('rejected', { what: 'adopt', reason: 'other-profile' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta es de otra cuenta distinta a la que anunció el dispositivo' })
+    }
+
+    try {
+      const r = await identity.joinProfile(acta)
+      if (!r?.joined) throw new Error(r?.reason || 'no se pudo adoptar')
+      audit('adopt', { device: pend.deviceId, profile: acta.profileId, seq: acta.seq })
+      // El acta que vuelve es la que la bóveda tiene guardada: el aparato la adopta y los
+      // dos quedan en la misma versión.
+      const mia = (await identity.profileActa?.())?.acta || acta
+      reply(pend.from, { type: MSG_ACTA_ADOPTED, code: p.code, acta: mia })
+      pend.state = 'DONE'
+      pending.delete(pend.token)
+      fire(onPendingChange)
+      fire(onAdopted, { deviceId: pend.deviceId, profileId: acta.profileId, seq: mia.seq })
+      log('[vault] cuenta adoptada del dispositivo %s (perfil %s)', pend.deviceId, acta.profileId?.slice(0, 12))
+      return { ok: true, adopted: true, profileId: acta.profileId, seq: mia.seq }
+    } catch (e) {
+      log('[vault] no se pudo adoptar la cuenta: %s', e.message)
+      reply(pend.from, { type: MSG_ERROR, error: 'la bóveda no pudo adoptar la cuenta: ' + e.message })
+      return { ok: false, error: e.message }
+    }
+  }
+
   /** Rechaza un enrolamiento pendiente. */
   function reject (deviceId) {
     const pend = deviceId
@@ -310,7 +436,7 @@ export function createEnrollDesk ({
   }
 
   return {
-    startPairing, stopPairing, handleEnroll, approve, reject,
+    startPairing, stopPairing, handleEnroll, handleActaSealed, handleHello, approve, reject,
     listPending, findPending, emitRevoke, revoke,
     get pendingCount () { return pending.size }
   }

package/lib/src/invite.js

@@ -49,6 +49,18 @@
 export const FMT_JSON = 'j'
 export const FMT_B64 = 'b'
 export const FMT_COMPACT = 'c'
+/**
+ * `t` — la invitación CORTA: solo la dirección y el nonce de la sesión. La llave
+ * maestra ya no viaja; el aparato se la pide a la bóveda por la red presentando el
+ * `sn`, y la comprueba con la firma del certificado y con el código de 6 dígitos,
+ * que es lo único que de verdad decide. Esconderla no aportaba nada —una pública es
+ * pública— y ocupaba 44 de los ~100 caracteres.
+ *
+ * `token` aquí NO es el de la sesión de emparejamiento: es el **token de conexión**
+ * que el proxy le da a la bóveda (4 caracteres), o sea su dirección. Con eso el
+ * aparato le habla directo, punto a punto, sin resolver nada.
+ */
+export const FMT_SHORT = 't'
 
 /** El proxy del ecosistema: si es este, no viaja en la invitación compacta. */
 export const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
@@ -266,6 +278,57 @@ function compactDecode (text) {
 // API
 // ---------------------------------------------------------------------------
 
+/**
+ * Blob de la forma CORTA (`t`): cabecera(1) ‖ token de conexión(4 ASCII) ‖ sn(8)
+ * ‖ [len+proxy].
+ *   bits 0-2  versión · bit 3  modo (join/adopt) · bit 4  lleva proxy propio
+ *
+ * Sin llave y sin nombre de cuenta: eso llega en la respuesta de la bóveda, así que
+ * un nombre largo ya no agranda el QR. 13 bytes → 18 caracteres.
+ *
+ * El PROXY sí viaja cuando no es el del ecosistema, y no es opcional: el token de
+ * conexión solo tiene sentido **en el proxy donde se emitió**. Quitarlo hacía que un
+ * aparato se conectara al proxy público y le hablara a un token de otro servidor —
+ * el mensaje no llegaba a ninguna parte y el emparejamiento se quedaba esperando.
+ * Le pasa a cualquiera con proxy propio (y lo cazó el E2E de secretos, que levanta
+ * uno local).
+ */
+const CONN_TOKEN_LEN = 4
+
+function shortEncode (qr) {
+  if (!qr || qr.v !== 2) return null
+  const mode = MODES.indexOf(qr.m)
+  if (mode < 0) return null
+  const conn = String(qr.conn || '')
+  if (conn.length !== CONN_TOKEN_LEN || !/^[\x21-\x7e]+$/.test(conn)) return null
+  if (!/^[0-9a-f]{16}$/.test(qr.sn || '')) return null // 8 bytes
+  const known = new Set(['v', 'conn', 'sn', 'm', 'proxy'])
+  if (Object.keys(qr).some((k) => !known.has(k))) return null
+  const ownProxy = qr.proxy && qr.proxy !== DEFAULT_PROXY
+  const proxy = ownProxy ? utf8(String(qr.proxy)) : null
+  if (proxy && proxy.length > 255) return null
+  const out = [qr.v | (mode << 3) | (ownProxy ? 0x10 : 0), ...[...conn].map((c) => c.charCodeAt(0)), ...hexToBytes(qr.sn)]
+  if (proxy) out.push(proxy.length, ...proxy)
+  return bytesToB64url(Uint8Array.from(out))
+}
+
+function shortDecode (text) {
+  const b = b64urlToBytes(text)
+  if (!b || b.length < 1 + CONN_TOKEN_LEN + 8) return null
+  const head = b[0]
+  if (head & 0xe0) return null
+  let i = 1 + CONN_TOKEN_LEN + 8
+  let proxy = DEFAULT_PROXY
+  if (head & 0x10) {
+    if (i >= b.length) return null
+    const n = b[i]; i += 1
+    if (i + n !== b.length) return null
+    proxy = fromUtf8(b.subarray(i, i + n)); i += n
+  } else if (i !== b.length) return null
+  const conn = String.fromCharCode(...b.subarray(1, 1 + CONN_TOKEN_LEN))
+  return { v: head & 7, conn, sn: bytesToHex(b.subarray(1 + CONN_TOKEN_LEN, 1 + CONN_TOKEN_LEN + 8)), m: MODES[(head >> 3) & 1], proxy }
+}
+
 /** Comparación por contenido, sin depender del orden de las claves. */
 const canon = (o) => JSON.stringify(Object.keys(o).sort().map((k) => [k, o[k]]))
 
@@ -278,6 +341,11 @@ const canon = (o) => JSON.stringify(Object.keys(o).sort().map((k) => [k, o[k]]))
  */
 export function encodeInvite (qr, fmt = FMT_COMPACT) {
   const json = JSON.stringify(qr)
+  // La forma corta se emite cuando el QR trae dirección en vez de llave.
+  if (qr && qr.conn) {
+    const t = shortEncode(qr)
+    if (t) { const back = shortDecode(t); if (back && canon(back) === canon(qr)) return FMT_SHORT + t }
+  }
   if (fmt === FMT_JSON) return FMT_JSON + json
   if (fmt === FMT_COMPACT) {
     const c = compactEncode(qr)
@@ -320,6 +388,7 @@ export function parseInvite (text) {
 
   const marca = payload[0]
   const resto = payload.slice(1)
+  if (marca === FMT_SHORT) { const o = shortDecode(resto); if (o) return o }
   if (marca === FMT_COMPACT) { const o = compactDecode(resto); if (o) return o }
   if (marca === FMT_JSON) { const o = parse(undoUrl(resto)) || parse(resto); if (o) return o }
   if (marca === FMT_B64) { const s = b64urlDecodeStr(resto); const o = s && parse(s); if (o) return o }
@@ -331,4 +400,4 @@ export function parseInvite (text) {
   return s ? parse(s) : null
 }
 
-export default { encodeInvite, inviteUrl, parseInvite, FMT_JSON, FMT_B64, FMT_COMPACT, PAIR_URL, DEFAULT_PROXY }
+export default { encodeInvite, inviteUrl, parseInvite, FMT_JSON, FMT_B64, FMT_COMPACT, FMT_SHORT, PAIR_URL, DEFAULT_PROXY }

package/lib/src/protocol.js

@@ -17,9 +17,21 @@
  * pineada (cierra el wipe-DoS; un ERROR plano jamas borra).
  */
 export const MSG = Object.freeze({
+  // La invitación corta no lleva la llave: el aparato la pide presentando el `sn` de
+  // la sesión. Una pública es pública — esto no la esconde, solo evita abrirle la
+  // puerta a quien acertó el token de conexión a ciegas.
+  HELLO: 'vault.hello',                       // dispositivo → vault: { sn }
+  HELLO_OK: 'vault.hello.ok',                 // vault → dispositivo: { iss, acct }
   ENROLL: 'vault.enroll',                     // dispositivo → vault: { data, signature }
   ENROLL_CHALLENGE: 'vault.enroll.challenge', // vault → dispositivo: { deviceId, sas }
   ENROLLED: 'vault.enrolled',                 // vault → dispositivo (tras aprobar): { cert, iss, sas }
+  // Camino A (la cuenta del aparato pasa a vivir en la bóveda): en vez de un cert, la
+  // bóveda manda QUIÉN es para que el aparato la admita, le envuelva la clave de
+  // contenido y le traspase el mando; el aparato devuelve el acta sellada y la bóveda
+  // responde con la definitiva. Ver docs/vinculacion-de-cuentas.md §2.
+  ENROLL_ADOPT: 'vault.enroll.adopt',         // vault → dispositivo: { code, pub, encPub, label }
+  ACTA_SEALED: 'vault.acta.sealed',           // dispositivo → vault: { acta, code }
+  ACTA_ADOPTED: 'vault.acta.adopted',         // vault → dispositivo: { acta }
   REVOKED: 'vault.revoked',                   // vault → dispositivo: { body:{op,sub,nonce,iat,exp}, signature }
   SIGN: 'vault.sign',                         // dispositivo → vault: { data, signature, cert }
   SIGNED: 'vault.signed',                     // vault → dispositivo: { signature, publickey, device }

package/lib/src/service.js

@@ -60,6 +60,23 @@ function installNodeGlobals () {
   }
 }
 
+
+/**
+ * La respuesta al `hello` va firmada y con el `sn` DENTRO de lo firmado. Comprobarlo
+ * ata la respuesta a ESTA sesión: no vale la de otro emparejamiento ni la de otra
+ * bóveda. Ojo con lo que NO prueba: cualquiera puede firmar con una llave suya, así
+ * que esto no dice que sea TU bóveda — eso lo dice el código de 6 dígitos, que solo
+ * aprende la bóveda donde tú lo tecleas.
+ */
+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 (!(await verifyDeviceSig({ publickey: b.iss, data: b, signature: p.signature }))) {
+    throw new Error('la respuesta de la bóveda no está bien firmada')
+  }
+  return b
+}
+
 async function freshClient (proxyUrl, connectTimeoutMs = 20000) {
   installNodeGlobals()
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
@@ -132,12 +149,25 @@ function writeServiceIdentity (dir, obj) {
  */
 export async function enrollService ({ qr, ns, dir, label, onCode, approveTimeoutMs = 180000 } = {}) {
   if (typeof qr === 'string') { try { qr = JSON.parse(qr) } catch (_) { throw new Error('qr inválido: no es JSON') } }
-  if (!qr?.iss || !qr?.proxy || !qr?.token || !qr?.sn) throw new Error('qr inválido (v2): faltan iss/proxy/token/sn')
+  if (!qr?.sn || !(qr.iss || qr.conn)) throw new Error('qr inválido: falta la bóveda o el nonce')
   if (!isValidSecretsNs(ns)) throw new Error('ns inválido (usa [a-z0-9-]{1,32}, p.ej. "proxy")')
   if (!dir) throw new Error('falta dir (dónde persistir la identidad del servicio)')
   label = label || 'servicio:' + ns
 
-  const client = await freshClient(qr.proxy)
+  const client = await freshClient(qr.proxy || 'wss://proxy.dotrino.com')
+  // QR CORTO: se le pregunta a la bóveda quién es, punto a punto, presentando el `sn`.
+  if (!qr.iss) {
+    const hola = await new Promise((resolve, reject) => {
+      const off = client.on('message', (_f, p) => {
+        if (p?.type === MSG.HELLO_OK) { fin(); verificarHola(p, qr.sn).then(resolve, 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 fin = () => { off(); clearTimeout(t) }
+      try { client.send(qr.conn, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { fin(); reject(e) }
+    })
+    qr = { ...qr, iss: hola.iss, proxy: hola.proxy || qr.proxy }
+  }
   try {
     const device = await makeDeviceKey({ label })
     const deviceId = (await pubkeyId(device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
@@ -147,7 +177,7 @@ export async function enrollService ({ qr, ns, dir, label, onCode, approveTimeou
     // El COMPROMISO del código (nunca el código): la bóveda lo recompone con lo que
     // tipeas y solo entonces firma el cert → aprobar exige haber leído esta pantalla.
     const commit = await commitCode({ code, dpub: device.publickey, sn: qr.sn })
-    const data = { op: 'enroll', dpub: device.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now() }
+    const data = { op: 'enroll', dpub: device.publickey, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -19,7 +19,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.34.0",
+    "@dotrino/identity": "^0.36.0",
     "@dotrino/proxy-client": "0.8.0",
     "ws": "^8.18.0"
   },

package/src/ctl.js

@@ -166,9 +166,24 @@ async function cmdPair (args = []) {
     PROFILE = d.id // el emparejamiento y los comandos siguientes apuntan a ELLA
     console.log('Cuenta nueva: %s  (%s)', name, d.id)
   }
+  // `--adopt [nombre]`: la TERCERA respuesta a «¿de qué cuenta hablamos?» — el camino A.
+  // Aquí la cuenta NO sale de esta bóveda: la trae el aparato y esta bóveda pasa a
+  // guardarla y a mandarla. Por eso se crea un perfil VACÍO, que nace a la espera de
+  // adoptarla; sin ese sitio no habría dónde meterla.
+  const adIdx = args.findIndex((a) => a === '--adopt')
+  const adopt = adIdx >= 0
+  if (adopt) {
+    const next = args[adIdx + 1]
+    const name = (next && !next.startsWith('-')) ? next : `cuenta del dispositivo`
+    const d = await profileRequest('add', { name, adopt: true })
+    if (d.error) { console.error('%s', d.error); process.exit(1) }
+    if (!d.id) { console.error('El daemon no dijo qué cuenta creó.'); process.exit(1) }
+    PROFILE = d.id
+    console.log('Cuenta a la espera de adoptar la del dispositivo: %s  (%s)', name, d.id)
+  }
   // La petición se escribe SIEMPRE (aunque no haya --service): lleva a qué perfil
   // se empareja el dispositivo.
-  writeReq('pair-request.json', service ? { service } : {})
+  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(adopt ? { mode: 'adopt' } : {}) })
   avisar(s.pid, 'SIGUSR1')
 
   let pair = null

package/src/daemon.js

@@ -123,7 +123,14 @@ export async function runDaemon () {
       // TAMBIÉN dentro del QR (`acct`) para que el dispositivo pueda anunciar qué va
       // a pasar antes de hacerlo (V9 de docs/vinculacion-de-cuentas.md).
       const profileName = mgr.profiles.get(profileId)?.name || ''
-      const { qr, expiresInMs } = vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode: 'join', account: profileName })
+      // MODO (V9): lo decide la bóveda y viaja en el QR para que el aparato pueda decir
+      // qué va a pasar antes de hacerlo.
+      //   · `join`  → el dispositivo entra a esta cuenta de la bóveda.
+      //   · `adopt` → la bóveda se queda con la cuenta que trae el aparato (camino A). El
+      //               perfil de esta bóveda tiene que haber nacido para eso (`--adopt`
+      //               crea uno vacío), o no habría dónde meterla.
+      const mode = pairReq?.mode === 'adopt' ? 'adopt' : 'join'
+      const { qr, expiresInMs } = vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode, account: profileName })
       writeJson(pairFile, { v: 2, qr, expiresAt: Date.now() + expiresInMs, profile: profileId, profileName })
       // El token es un secreto efímero: no debe quedar en disco más allá de su
       // vida. Se borra al VENCER (aquí) y al APROBARSE (abajo, consumido).
@@ -160,7 +167,7 @@ export async function runDaemon () {
       case 'list': return {} // el volcado de perfiles ya se hace abajo
       // `id`: quien la crea necesita saber CUÁL quedó, no adivinar por nombre (dos
       // cuentas pueden llamarse igual). Lo usa «emparejar en una cuenta nueva».
-      case 'add': { const p = await mgr.add(req.name); return { done: `perfil creado: ${p.name || p.id}`, id: p.id } }
+      case 'add': { const p = await mgr.add(req.name, { adopt: !!req.adopt }); return { done: `perfil creado: ${p.name || p.id}`, id: p.id, adopt: !!req.adopt } }
       case 'rm': { const r = await mgr.remove(req.profile); return { done: `perfil borrado: ${r.name || r.id}` } }
       case 'rename': { const p = mgr.profiles.rename(ref(), req.name); return { done: `perfil renombrado: ${p.name}` } }
       case 'use': { const p = mgr.profiles.setCurrent(ref()); return { done: `perfil activo: ${p.name || p.id}` } }

package/src/manager.js

@@ -56,6 +56,10 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
       proxyUrl,
       log: (...a) => log(`[${tag}]`, ...a),
       isLocked: () => profiles.isLocked(id),
+      // Camino A: nació para adoptar la cuenta de un aparato (ver profiles.add).
+      forAdoption: !!p?.adopt,
+      // Ya adoptó: la marca se consume (no vuelve a estar «a la espera»).
+      onAdopted: () => { try { profiles.clearAdopt(id) } catch (_) {} },
       onEnrollChallenge: (info) => onEnrollChallenge?.({ ...info, profile: id, profileName: p?.name || '' })
     })
     running.set(id, v)
@@ -88,10 +92,15 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
     currentId: () => profiles.current(),
     resolve: (ref) => profiles.resolve(ref),
 
-    async add (name) {
-      const p = profiles.add(name)
+    /**
+     * Crea un perfil. Con `adopt: true` nace **vacío, esperando la cuenta de un aparato**
+     * (camino A): la bóveda pone el sitio y la llave que entrará como miembro, pero la
+     * cuenta la trae el dispositivo y se adopta al emparejar.
+     */
+    async add (name, { adopt = false } = {}) {
+      const p = profiles.add(name, { adopt })
       await open(p.id)
-      log('[vault] perfil creado: %s (%s)', p.name || '(sin nombre)', p.id)
+      log('[vault] perfil creado%s: %s (%s)', adopt ? ' (a la espera de adoptar una cuenta)' : '', p.name || '(sin nombre)', p.id)
       return profiles.get(p.id)
     },
 

package/src/profiles.js

@@ -63,7 +63,9 @@ export function openProfiles (root = dataDir()) {
     createdAt: p.createdAt || null,
     protected: !!p.pwd,
     locked: !!p.pwd && !unlocked.has(p.id),
-    current: p.id === data.current
+    current: p.id === data.current,
+    // Nació para adoptar la cuenta de un aparato (camino A) y todavía no lo ha hecho.
+    ...(p.adopt ? { adopt: true } : {})
   })
 
   function assertExists (id) {
@@ -123,15 +125,30 @@ export function openProfiles (root = dataDir()) {
       return { id, migrated: legacy }
     },
 
-    add (name) {
+    /**
+     * Crea un perfil. Con `adopt: true` nace **para adoptar la cuenta de un aparato**
+     * (camino A): la bóveda le hace sitio, pero la cuenta —el `profileId`, la reputación,
+     * lo ya firmado— la trae el dispositivo. La marca la consume `startVault`, que se la
+     * pasa a la identidad (`prepareForAdoption`); sin ella, adoptar una cuenta ajena se
+     * leería como pisar una cuenta con datos y se rechazaría, que es lo que tiene que
+     * pasar cuando nadie lo pidió.
+     */
+    add (name, { adopt = false } = {}) {
       const id = newId()
       ensureDir(dirOf(id))
-      data.profiles.push({ id, name: cleanName(name), createdAt: Date.now() })
+      data.profiles.push({ id, name: cleanName(name), createdAt: Date.now(), ...(adopt ? { adopt: true } : {}) })
       if (!data.current) data.current = id
       save()
       return entry(find(id))
     },
 
+    /** Quita la marca de «nació para adoptar» (ya adoptó, o se canceló). */
+    clearAdopt (id) {
+      const p = find(id)
+      if (p?.adopt) { delete p.adopt; save() }
+      return !!p
+    },
+
     rename (id, name) {
       const p = assertExists(id)
       api.assertUnlocked(id)

package/src/qr.js

@@ -27,9 +27,14 @@ const qrcode = typeof qrcodeMod === 'function' ? qrcodeMod : qrcodeMod.default
  * módulos por línea) y siempre con el contraste correcto.
  *
  * @param {string} text  Contenido a codificar (modo byte / UTF-8).
- * @param {number} [quiet=4]  Zona de silencio en módulos (mín. recomendado: 4).
+ * @param {number} [quiet=5]  Zona de silencio en módulos.
+ *
+ * La norma pide 4 como MÍNIMO; aquí va uno más a propósito. En una terminal el blanco
+ * que dibujamos es lo único que separa el código del fondo oscuro y del texto de la
+ * línea de arriba, y un módulo de margen cuesta 2 columnas y 1 fila — mucho menos que
+ * un QR que no engancha. Ir por debajo de 4 no se hace ni para ganar filas.
  */
-export function qrToString (text, quiet = 4) {
+export function qrToString (text, quiet = 5) {
   // typeNumber 0 = autoseleccionar la versión mínima; EC level 'L' (más capacidad).
   const qr = qrcode(0, 'L')
   qr.addData(text) // 'Byte' por defecto para datos no numéricos/alfanuméricos

package/src/tui/app.js

@@ -694,10 +694,8 @@ function pairingBody (st, t, cols, height) {
   // en la cuenta equivocada sin enterarse.
   const ap = activeProfile(st)
   const acct = info.profileName || ap?.name || info.profile || ap?.id || '—'
-  lines.push(t.bold(i.pairAccount(acct)))
   const left = Math.max(0, Math.round((info.expiresAt - Date.now()) / 60000))
-  lines.push(t.muted(i.pairValid(left)))
-  lines.push('')
+  lines.push(t.bold(i.pairAccount(acct, left)))
   // QR: se dibuja siempre que quepa de ancho; si es más alto que la pantalla se
   // puede hacer scroll hacia arriba/abajo para verlo completo.
   let qr = ''
@@ -711,6 +709,7 @@ function pairingBody (st, t, cols, height) {
     lines.push(t.warn(i.pairQrTooNarrow(cols, qrWidth)))
     lines.push('')
   }
+  lines.push(t.muted(i.pairScan))
   lines.push(t.bold(i.pairUrl) + info.url)
   lines.push('')
   lines.push(t.muted(i.pairPaste))

package/src/tui/i18n.js

@@ -134,8 +134,10 @@ const es = {
   newAccountLabel: 'Nombre de la cuenta nueva',
   newAccountHint: 'nace vacía; el dispositivo será su primer invitado',
   accountCreated: (name) => `Cuenta creada: ${name}`,
-  pairAccount: (name) => `Cuenta que se comparte: ${name}`,
-  pairValid: (min) => `Válido ~${min} min. Escanéalo o abre la URL en el dispositivo.`,
+  // Cuenta + vigencia en UNA línea: cada línea de cabecera es una fila menos de QR
+  // visible antes de tener que hacer scroll.
+  pairAccount: (name, min) => `Cuenta que se comparte: ${name}  ·  válido ~${min} min`,
+  pairScan: 'Escanéalo, o abre esta dirección en el dispositivo:',
   pairUrl: 'URL: ',
   pairPaste: 'O pega este código en vault.dotrino.com/dispositivos:',
   pairWarning: '⚠ Este código deja LEER tus datos y FIRMAR con tu identidad. No lo compartas.',
@@ -297,8 +299,8 @@ const en = {
   newAccountLabel: 'Name of the new account',
   newAccountHint: 'born empty; the device will be its first guest',
   accountCreated: (name) => `Account created: ${name}`,
-  pairAccount: (name) => `Account being shared: ${name}`,
-  pairValid: (min) => `Valid ~${min} min. Scan it or open the URL on the device.`,
+  pairAccount: (name, min) => `Account being shared: ${name}  ·  valid ~${min} min`,
+  pairScan: 'Scan it, or open this address on the device:',
   pairUrl: 'URL: ',
   pairPaste: 'Or paste this code into vault.dotrino.com/dispositivos:',
   pairWarning: '⚠ This code lets someone READ your data and SIGN as you. Do not share it.',

package/src/vault.js

@@ -35,7 +35,7 @@ import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
  *   Solo bloquea EDITAR el perfil (`profileSet`): firmar/leer y el resto del store
  *   siguen sirviendo a los dispositivos enrolados aunque esté bloqueado.
  */
-export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false } = {}) {
+export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false, forAdoption = false, onAdopted } = {}) {
   ensureDir(dir)
   // CIFRADO EN REPOSO ligado a esta máquina: `identity.json` deja de estar en claro, así
   // que copiarlo a otro equipo no sirve de nada. No protege contra quien ya tiene ESTA
@@ -47,6 +47,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   } catch (e) { log('[vault] no se pudo cifrar la identidad en reposo:', e.message) }
   const identity = await Identity.connect({ dir, atRest: atRestFor(dir) })
   if (!identity.me?.publickey) await identity.setMyNickname('')
+  // CAMINO A: este perfil nació para adoptar la cuenta de un aparato. La identidad se crea
+  // igual (su llave es la que entrará como miembro), pero se marca para que `joinProfile`
+  // acepte cambiar su acta recién nacida por la que traiga el dispositivo. Sin la marca,
+  // adoptar sería pisar una cuenta con datos y se rechaza — que es lo correcto por defecto.
+  if (forAdoption) {
+    try { await identity.prepareForAdoption() } catch (e) { log('[vault] no se pudo preparar el perfil para adoptar:', e.message) }
+  }
 
   const store = openStore(dir)
   const threads = openThreadStore(dir)
@@ -101,6 +108,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     sendByPubkey: (pub, obj) => client.sendByPubkey(pub, obj),
     audit,
     log,
+    // Camino A: lo que esta bóveda le manda al aparato para entrar en SU acta. La llave de
+    // cifrado es lo que le permite leer el contenido de la cuenta que va a custodiar; sin
+    // ella entraría mandando una cuenta que no puede abrir.
+    encPub: identity.me?.encryptionPubkey || null,
+    vaultLabel: 'bóveda',
+    // Nuestra dirección en el proxy: lo único que lleva el QR corto.
+    connToken: () => client.token,
+    onAdopted: (info) => { try { onAdopted?.(info) } catch (_) {} },
     defaultScope: [SCOPE.READ],
     onChallenge ({ deviceId, scope }) {
       log(`\n[vault] Un dispositivo quiere conectarse:`)
@@ -262,7 +277,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   client.on('message', async (from, payload) => {
     if (!payload || typeof payload !== 'object') return
     try {
+      if (payload.type === MSG.HELLO) return desk.handleHello(from, payload)
       if (payload.type === MSG.ENROLL) return await desk.handleEnroll(from, payload)
+      if (payload.type === MSG.ACTA_SEALED) return await desk.handleActaSealed(from, payload)
       if (payload.type === MSG.SIGN) return await handleSign(from, payload)
       if (payload.type === MSG.GET) return await handleGet(from, payload)
       if (payload.type === MSG.STORE) return await handleStore(from, payload)