@dotrino/vaultd 0.7.9 → 0.9.0

package/README.md

@@ -195,6 +195,15 @@ entre las dos pantallas y corras `approve`. Un código robado ya no alcanza para
 entrar; la revocación de un dispositivo le ordena **autoborrarse** (con firma de la
 maestra, no por un mensaje cualquiera).
 
+La invitación viaja **comprimida** (`lib/src/invite.js`): los datos van en binario y el
+binario en base64url, ~100 caracteres en vez de los ~340 del JSON. Eso baja el QR de 69
+módulos a 41 —de 77×39 a 49×25 en la terminal— y de paso deja un código pegable de una
+sola palabra. El grueso del ahorro es la llave maestra: en el QR va el **punto comprimido**
+de la curva (33 bytes) y el lector rearma la JWK con una plantilla, comprobando que sale
+**byte a byte** igual, porque el proxy direcciona por esa string exacta. Si una llave no
+encaja en ninguna plantilla, la invitación sale en su forma larga: se hace grande, nunca
+incorrecta.
+
 El servicio se gestiona con systemd `--user`
 (`systemctl --user {start,stop,restart} dotrino-vault`). Tus datos —clave maestra
 incluida— viven en `~/.local/share/dotrino/vault` (permisos `0600`/`0700`), con un
@@ -323,6 +332,7 @@ sin vault; solo la feature que los necesita (TURN) espera. Primer consumidor:
 - `src/store.js` — árbol de contenidos (`vault.json`, versionado).
 - `src/client.js` — helper de **dispositivo** (enrolar / pedir firma / leer).
 - `src/protocol.js` — tipos de mensaje y scopes. · `src/qr.js` — QR ASCII. · `src/paths.js` — dirs.
+- `lib/src/invite.js` — la invitación de emparejamiento: cómo se comprime y cómo se lee.
 - `bin/sea-entry.js` — entrypoint del binario único (multicall daemon / `--ctl` / `--tui`).
 - `bin/dotrino-vaultd.js` — entrypoint de desarrollo (node directo).
 - `bin/dotrino-vault-tui.js` — entrypoint de desarrollo de la TUI.

package/bin/dotrino-vaultd.js

@@ -39,7 +39,7 @@ if (process.argv.includes('--pair')) {
   const { qr, expiresInMs } = mgr.current().startPairing({ label: 'cli' })
   const { url, b64 } = pairUrl(qr)
   console.log(`\nEmparejá un dispositivo (válido ${expiresInMs / 60000} min):\n`)
-  console.log(qrToString(url, 2))
+  console.log(qrToString(url))
   console.log(url)
   console.log('\nO pegá este código:\n  ' + b64)
 }

package/lib/src/enroll.js

@@ -63,12 +63,22 @@ export function scopeToCn (scope) {
   return null
 }
 
-/** Token aleatorio de 128 bits en hex. */
-export function randToken () {
-  const b = crypto.getRandomValues(new Uint8Array(16))
+/**
+ * Token aleatorio en hex (16 bytes = 128 bits por defecto).
+ *
+ * El emparejamiento pide 12 (96 bits): son de un solo uso, valen 5 minutos y hay
+ * UNA sesión viva a la vez, así que adivinarlo es 2^95 intentos contra una bóveda
+ * que además exige el código de 6 dígitos. A cambio, cada byte de menos son ~1,4
+ * caracteres menos en el QR — y el QR se mide en filas de terminal.
+ */
+export function randToken (bytes = 16) {
+  const b = crypto.getRandomValues(new Uint8Array(bytes))
   return [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
 }
 
+/** Tamaño del token/nonce de una sesión de emparejamiento (ver `randToken`). */
+const PAIR_TOKEN_BYTES = 12
+
 /** deviceId legible (p. ej. `C440-AC0E`) a partir de una pubkey JWK. */
 export async function deviceIdOf (pub) {
   const id = (await pubkeyId(pub)).slice(0, 8).toUpperCase()
@@ -126,8 +136,8 @@ 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 token = randToken()
-    const sn = randToken()
+    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 }

package/lib/src/invite.js

@@ -0,0 +1,334 @@
+/**
+ * invite.js — la invitación de emparejamiento: cómo se escribe y cómo se lee.
+ *
+ * Una invitación viaja de dos maneras —un QR que se escanea y un código que se
+ * copia y se pega— y **las dos quieren lo mismo: que sea CORTA**. En un QR cada
+ * carácter son módulos, y los módulos son filas y columnas de terminal; en un
+ * código pegable, cada carácter es una oportunidad de que alguien lo corte mal.
+ *
+ * Por eso el formato vigente es **`c` (compacto)**: los datos van en BINARIO y el
+ * binario en base64url. Nada de JSON. Un JSON con la llave maestra dentro pesa
+ * ~340 caracteres (la llave es una JWK *serializada como string*, con sus comillas
+ * escapadas: 182 de esos 340 son ella sola); el mismo contenido en binario son ~75
+ * bytes → **~100 caracteres**. Medido en la práctica: el QR pasó de 69 módulos
+ * (77×39 en la terminal) a 41 (49×25), y el código pegable de 458 caracteres a 101.
+ *
+ * De dónde sale el ahorro, en orden de importancia:
+ *   · **La llave `iss`** (182 → 44 chars). Una pubkey P-256 son dos coordenadas de
+ *     32 bytes; en el QR va el **punto comprimido** de 33 bytes (SEC1: `02`/`03`
+ *     según la paridad de `y`, seguido de `x`) y el lector recupera `y` resolviendo
+ *     la curva. La JWK se rearma con una PLANTILLA (el índice va en la cabecera)
+ *     para que la string vuelva **byte a byte** igual: el proxy direcciona por esa
+ *     string exacta, así que una coma de más rompe el enrutamiento.
+ *   · **`token` y `sn`** (34+34 → 16+16 bytes): eran hexadecimal, que gasta dos
+ *     caracteres por byte.
+ *   · **`proxy`** (33 → 0): si es el del ecosistema no viaja; se sobreentiende.
+ *   · **`m` y `v`**: dos campos de JSON → dos grupos de bits de la cabecera.
+ *
+ * SEGURIDAD DEL AHORRO: `encodeInvite` **comprueba el viaje de vuelta** antes de
+ * entregar la forma compacta — decodifica lo que acaba de codificar y exige que sea
+ * idéntico al original. Si algo no encaja (una JWK con otra forma, un campo nuevo,
+ * un `token` que no es hex), devuelve la forma larga en base64. Así una llave rara
+ * no rompe un emparejamiento: como mucho lo hace más grande.
+ *
+ * Formatos que se leen (el primer carácter dice cuál es):
+ *   · `c` — compacto binario+base64url. **El que se emite hoy**, para el QR y para
+ *           el código pegable: es a la vez el más corto y una sola palabra sin
+ *           comillas ni llaves, que sobrevive a un doble clic y a un chat.
+ *   · `b` — base64url del JSON. Forma larga, de reserva.
+ *   · `j` — JSON crudo. Solo para leer enlaces ya emitidos.
+ *   · sin marca — anterior a la marca de formato (base64url, o JSON).
+ *
+ * GOTCHA que justifica el `decodeURIComponent`: el JSON crudo lleva `{`, `}` y `"`,
+ * que **no son legales en una URI**. Al abrir el enlace, el navegador los
+ * percent-codifica (`%22`…), así que lo que llega a `location.hash` NO es lo que se
+ * emitió. Medido en un navegador real (2026-07-28). El formato compacto no tiene
+ * ese problema —base64url ya es seguro en una URL—, pero `j` sigue por ahí.
+ */
+
+export const FMT_JSON = 'j'
+export const FMT_B64 = 'b'
+export const FMT_COMPACT = 'c'
+
+/** El proxy del ecosistema: si es este, no viaja en la invitación compacta. */
+export const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
+
+/**
+ * La base del enlace del QR. Corta a propósito (`/d#v=` en vez de
+ * `/dispositivos#vault=`): son 15 caracteres menos dentro del QR, y ahí los
+ * caracteres se pagan en módulos. `vault.dotrino.com/dispositivos` sigue
+ * funcionando —es la ruta que la gente ya tiene— y `parseInvite` lee las dos.
+ */
+export const PAIR_URL = 'https://vault.dotrino.com/d#v='
+
+// ---------------------------------------------------------------------------
+// Conversiones (sin dependencias: esto corre en el navegador, en Node y dentro
+// del binario SEA)
+// ---------------------------------------------------------------------------
+
+const B64_STD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
+function bytesToB64url (bytes) {
+  let out = ''
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i]; const b = bytes[i + 1]; const c = bytes[i + 2]
+    out += B64_STD[a >> 2]
+    out += B64_STD[((a & 3) << 4) | ((b ?? 0) >> 4)]
+    if (b === undefined) break
+    out += B64_STD[((b & 15) << 2) | ((c ?? 0) >> 6)]
+    if (c === undefined) break
+    out += B64_STD[c & 63]
+  }
+  return out.replace(/\+/g, '-').replace(/\//g, '_')
+}
+
+function b64urlToBytes (s) {
+  const clean = String(s).replace(/-/g, '+').replace(/_/g, '/').replace(/[^A-Za-z0-9+/]/g, '')
+  const out = []
+  let acc = 0; let bits = 0
+  for (const ch of clean) {
+    const v = B64_STD.indexOf(ch)
+    if (v < 0) return null
+    acc = (acc << 6) | v; bits += 6
+    if (bits >= 8) { bits -= 8; out.push((acc >> bits) & 0xff) }
+  }
+  return Uint8Array.from(out)
+}
+
+const utf8 = (s) => new TextEncoder().encode(s)
+const fromUtf8 = (b) => new TextDecoder().decode(b)
+
+/**
+ * `token` y `sn` son hexadecimal. Caben en la invitación en dos tamaños —12 o 16
+ * bytes— porque el hexadecimal gasta dos caracteres por byte y en un QR eso se
+ * paga: 12 bytes (96 bits, lo que emite hoy `startPairing`) son 11 caracteres
+ * menos que 16, y esos 11 caracteres son la diferencia entre que quepa un nombre
+ * de cuenta normal o que el QR suba una versión entera.
+ */
+const hexLen = (s) => (typeof s === 'string' && /^[0-9a-f]+$/.test(s) && (s.length === 24 || s.length === 32)) ? s.length / 2 : 0
+const hexToBytes = (s) => Uint8Array.from(s.match(/../g).map((h) => parseInt(h, 16)))
+const bytesToHex = (b) => [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
+
+const b64urlEncodeStr = (s) => bytesToB64url(utf8(s))
+const b64urlDecodeStr = (s) => { const b = b64urlToBytes(s); return b ? fromUtf8(b) : null }
+
+// ---------------------------------------------------------------------------
+// La llave maestra: JWK ⇄ punto comprimido de la curva P-256
+// ---------------------------------------------------------------------------
+
+/**
+ * Las formas de JWK que existen en el ecosistema. `JSON.stringify` de una JWK
+ * conserva el orden en que la exportó cada WebCrypto, y **ese orden es parte de la
+ * identidad**: el proxy direcciona por la string exacta. Por eso no se «normaliza»
+ * la JWK —eso cambiaría la dirección de la bóveda—, se rearma tal cual con la
+ * plantilla que le toca. El índice viaja en la cabecera (2 bits, hasta 4 formas).
+ */
+const JWK_TEMPLATES = [
+  // 0 — WebCrypto de Node (el daemon del PC): key_ops, ext, kty, x, y, crv
+  (x, y) => `{"key_ops":["verify"],"ext":true,"kty":"EC","x":"${x}","y":"${y}","crv":"P-256"}`,
+  // 1 — WebCrypto de navegador (Chrome/Firefox/Safari, alfabético): crv, ext, key_ops, kty, x, y
+  (x, y) => `{"crv":"P-256","ext":true,"key_ops":["verify"],"kty":"EC","x":"${x}","y":"${y}"}`,
+]
+
+// Parámetros de la curva P-256 (FIPS 186-4). `a` es −3.
+const P256_P = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffffn
+const P256_B = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604bn
+
+const modPow = (base, exp, m) => {
+  let r = 1n; let b = base % m
+  while (exp > 0n) { if (exp & 1n) r = (r * b) % m; b = (b * b) % m; exp >>= 1n }
+  return r
+}
+
+const bytesToBig = (b) => { let n = 0n; for (const x of b) n = (n << 8n) | BigInt(x); return n }
+const bigToBytes32 = (n) => { const out = new Uint8Array(32); for (let i = 31; i >= 0; i--) { out[i] = Number(n & 0xffn); n >>= 8n } return out }
+
+/** Coordenada de una JWK: base64url de 32 bytes exactos, o `null`. */
+function coordBytes (s) {
+  if (typeof s !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(s)) return null
+  const b = b64urlToBytes(s)
+  return b && b.length === 32 ? b : null
+}
+
+/**
+ * `iss` (JWK serializada) → `{ tpl, point }` con el punto comprimido de 33 bytes, o
+ * `null` si la llave no tiene una forma conocida (entonces la invitación va larga).
+ */
+function packPubkey (iss) {
+  if (typeof iss !== 'string') return null
+  let jwk
+  try { jwk = JSON.parse(iss) } catch { return null }
+  if (!jwk || jwk.kty !== 'EC' || jwk.crv !== 'P-256') return null
+  const xb = coordBytes(jwk.x); const yb = coordBytes(jwk.y)
+  if (!xb || !yb) return null
+
+  const tpl = JWK_TEMPLATES.findIndex((f) => f(jwk.x, jwk.y) === iss)
+  if (tpl < 0) return null // forma desconocida: no se puede rearmar igual → larga
+
+  const point = new Uint8Array(33)
+  point[0] = 2 + (yb[31] & 1) // 02 = y par, 03 = y impar
+  point.set(xb, 1)
+  return { tpl, point }
+}
+
+/** Punto comprimido + plantilla → la `iss` original (o `null` si el punto no es de la curva). */
+function unpackPubkey (point, tpl) {
+  const template = JWK_TEMPLATES[tpl]
+  if (!template || point.length !== 33 || (point[0] !== 2 && point[0] !== 3)) return null
+
+  const x = bytesToBig(point.subarray(1))
+  if (x >= P256_P) return null
+  // y² = x³ − 3x + b (mod p). Con p ≡ 3 (mod 4) la raíz es y = (y²)^((p+1)/4).
+  const y2 = (((x * x) % P256_P) * x - 3n * x + P256_B) % P256_P
+  const rhs = (y2 + P256_P) % P256_P
+  let y = modPow(rhs, (P256_P + 1n) / 4n, P256_P)
+  if ((y * y) % P256_P !== rhs) return null // x no está en la curva
+  if ((y & 1n) !== BigInt(point[0] & 1)) y = P256_P - y
+
+  return template(bytesToB64url(point.subarray(1)), bytesToB64url(bigToBytes32(y)))
+}
+
+// ---------------------------------------------------------------------------
+// El formato compacto
+// ---------------------------------------------------------------------------
+
+/**
+ * Cabecera (1 byte):
+ *   bits 0-2  versión del protocolo (`qr.v`, hoy 2)
+ *   bit  3    modo: 0 = `join` · 1 = `adopt`
+ *   bits 4-5  plantilla de la JWK (índice en `JWK_TEMPLATES`)
+ *   bit  6    lleva proxy propio (si no, el del ecosistema)
+ *   bit  7    `token`/`sn` de 12 bytes (si 0, de 16)
+ *
+ * Cuerpo: punto comprimido (33) ‖ token (n) ‖ sn (n) ‖ len+`acct` ‖ [len+`proxy`]
+ */
+const MODES = ['join', 'adopt']
+
+function compactEncode (qr) {
+  if (!qr || typeof qr !== 'object') return null
+  const v = qr.v
+  if (!Number.isInteger(v) || v < 0 || v > 7) return null
+  const mode = MODES.indexOf(qr.m)
+  if (mode < 0) return null
+  const n = hexLen(qr.token)
+  if (!n || hexLen(qr.sn) !== n) return null
+
+  const pub = packPubkey(qr.iss)
+  if (!pub || pub.tpl > 3) return null
+
+  const acct = utf8(String(qr.acct || ''))
+  if (acct.length > 255) 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
+
+  // Un campo que no se sepa escribir se perdería en silencio: eso NO se hace.
+  const known = new Set(['v', 'iss', 'proxy', 'token', 'sn', 'm', 'acct'])
+  if (Object.keys(qr).some((k) => !known.has(k))) return null
+
+  const head = v | (mode << 3) | (pub.tpl << 4) | (ownProxy ? 0x40 : 0) | (n === 12 ? 0x80 : 0)
+  const out = [head, ...pub.point, ...hexToBytes(qr.token), ...hexToBytes(qr.sn), acct.length, ...acct]
+  if (proxy) out.push(proxy.length, ...proxy)
+  return bytesToB64url(Uint8Array.from(out))
+}
+
+function compactDecode (text) {
+  const b = b64urlToBytes(text)
+  const n = (b && (b[0] & 0x80)) ? 12 : 16
+  if (!b || b.length < 35 + n * 2) return null
+  const head = b[0]
+
+  const iss = unpackPubkey(b.subarray(1, 34), (head >> 4) & 3)
+  if (!iss) return null
+
+  let i = 34
+  const token = bytesToHex(b.subarray(i, i + n)); i += n
+  const sn = bytesToHex(b.subarray(i, i + n)); i += n
+  const acctLen = b[i]; i += 1
+  if (i + acctLen > b.length) return null
+  const acct = acctLen ? fromUtf8(b.subarray(i, i + acctLen)) : ''
+  i += acctLen
+
+  let proxy = DEFAULT_PROXY
+  if (head & 0x40) {
+    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
+  }
+  if (i !== b.length) return null // sobran bytes: no es lo que creemos que es
+
+  // Mismo orden de campos que `startPairing`, para que las dos formas serialicen igual.
+  return { v: head & 7, iss, proxy, token, sn, m: MODES[(head >> 3) & 1], ...(acct ? { acct } : {}) }
+}
+
+// ---------------------------------------------------------------------------
+// API
+// ---------------------------------------------------------------------------
+
+/** 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]]))
+
+/**
+ * El payload marcado, listo para meter en el `#fragment` o para copiar y pegar.
+ *
+ * Por defecto **compacto**, que es lo más corto y a la vez pegable. Se cae a la
+ * forma larga (`b`) sola, sin avisar, si el compacto no reproduce el original
+ * exactamente: más vale un QR grande que uno que no empareja.
+ */
+export function encodeInvite (qr, fmt = FMT_COMPACT) {
+  const json = JSON.stringify(qr)
+  if (fmt === FMT_JSON) return FMT_JSON + json
+  if (fmt === FMT_COMPACT) {
+    const c = compactEncode(qr)
+    // El viaje de vuelta se comprueba SIEMPRE: es barato (una vez por
+    // emparejamiento) y es lo que permite comprimir sin jugarse el enrolamiento.
+    if (c) { const back = compactDecode(c); if (back && canon(back) === canon(qr)) return FMT_COMPACT + c }
+  }
+  return FMT_B64 + b64urlEncodeStr(json)
+}
+
+/** El enlace del QR: `https://vault.dotrino.com/d#v=<invitación>`. */
+export function inviteUrl (qr) { return PAIR_URL + encodeInvite(qr) }
+
+/**
+ * Corta el `#fragment` de una URL. `#vault=` es la forma larga histórica y `#v=` la
+ * corta de hoy; se prueba la larga primero porque `#vault=` empieza por `#v`.
+ */
+const cutFragment = (text) => {
+  const long = text.indexOf('#vault=')
+  if (long >= 0) return text.slice(long + 7)
+  const short = text.indexOf('#v=')
+  return short >= 0 ? text.slice(short + 3) : text
+}
+
+/**
+ * Lee una invitación venga como venga: URL con `#v=`/`#vault=`, el código suelto,
+ * con marca de formato o sin ella (formatos viejos). Devuelve el objeto del QR o
+ * `null` — nunca lanza, porque del otro lado hay alguien pegando texto a mano.
+ */
+export function parseInvite (text) {
+  if (!text) return null
+  const payload = cutFragment(String(text).trim())
+  if (!payload) return null
+
+  const parse = (s) => { try { const o = JSON.parse(s); return (o && typeof o === 'object') ? o : null } catch { return null } }
+  // El navegador percent-codifica el JSON del fragmento; deshacerlo es un no-op si
+  // no lo tocó. Si el texto trae un `%` suelto, `decodeURIComponent` lanza: se usa
+  // el original.
+  const undoUrl = (s) => { try { return decodeURIComponent(s) } catch { return s } }
+
+  const marca = payload[0]
+  const resto = payload.slice(1)
+  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 }
+
+  // --- sin marca: formatos anteriores a la marca de formato (compatibilidad) ---
+  const crudo = undoUrl(payload)
+  if (crudo.trimStart().startsWith('{')) return parse(crudo)
+  const s = b64urlDecodeStr(payload)
+  return s ? parse(s) : null
+}
+
+export default { encodeInvite, inviteUrl, parseInvite, FMT_JSON, FMT_B64, FMT_COMPACT, PAIR_URL, DEFAULT_PROXY }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.7.9",
+  "version": "0.9.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": {

package/src/ctl.js

@@ -26,6 +26,7 @@ import { execFileSync } from 'node:child_process'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir, readJson } from './paths.js'
 import { qrToString } from './qr.js'
+import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
 import { VERSION } from './version.js'
 
 const dir = dataDir()
@@ -53,8 +54,6 @@ const writeReq = (name, obj) => fs.writeFileSync(path.join(dir, name), JSON.stri
 const R = '\x1b[31m', B = '\x1b[1m', Z = '\x1b[0m' // rojo / negrita / reset
 // La versión se inyecta en build (esbuild --define); en dev cae a 'dev'.
 
-const PROFILE_URL = 'https://vault.dotrino.com/dispositivos#vault='
-
 /**
  * Cómo se arranca el vault EN ESTA MÁQUINA. El CLI corre en Linux (servicio systemd),
  * en Windows/macOS (por npm, en primer plano o al inicio de sesión) y dentro de un
@@ -176,9 +175,10 @@ async function cmdPair (args = []) {
   for (let i = 0; i < 50; i++) { await sleep(100); const p = readJson(pairFile, null); if (p?.expiresAt > Date.now()) { pair = p; break } }
   if (!pair) { console.error('No se recibió respuesta del daemon para el emparejamiento.'); process.exit(1) }
 
-  const payload = JSON.stringify(pair.qr)
-  const b64 = Buffer.from(payload, 'utf8').toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
-  const url = PROFILE_URL + b64
+  // Una sola forma para las dos cosas: la invitación compacta (base64url de ~100
+  // caracteres) va igual de bien dentro del QR que pegada a mano. Ver `lib/src/invite.js`.
+  const b64 = encodeInvite(pair.qr)
+  const url = inviteUrl(pair.qr)
   const mins = Math.round((pair.expiresAt - Date.now()) / 60000)
   // QUÉ CUENTA se comparte: el vault puede tener varias bóvedas y este QR sale de
   // UNA (la activa, o la de --profile). Decirlo evita enrolar el dispositivo en la
@@ -186,7 +186,7 @@ async function cmdPair (args = []) {
   const acct = pair.profileName || pair.profile
   if (acct) console.log('\nCuenta que se comparte: %s%s', acct, pair.profileName && pair.profile ? `  (${pair.profile})` : '')
   console.log('\nEscanea este QR con el dispositivo que quieres conectar (válido %d min):\n', mins)
-  console.log(qrToString(url, 2)) // QR con URL+JSON crudo (menos datos) y zona de silencio reducida
+  console.log(qrToString(url)) // el QR abre la consola de dispositivos y empareja solo
   console.log(`${R}${B}⚠ Este código deja LEER tus datos y FIRMAR con tu identidad.${Z}`)
   console.log(`${R}  NO lo compartas con nadie, ni con "soporte". Solo escanéalo en TU dispositivo.${Z}`)
   console.log('\nO abre esta dirección en el dispositivo:\n  ' + url)

package/src/tui/app.js

@@ -701,7 +701,7 @@ function pairingBody (st, t, cols, height) {
   // 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 = ''
-  try { qr = qrToString(info.url, 2) } catch (_) {}
+  try { qr = qrToString(info.url) } catch (_) {}
   const qrLines = qr ? qr.replace(/\n$/, '').split('\n') : []
   const qrWidth = qrLines.length ? Math.max(...qrLines.map((l) => l.replace(/\x1b\[[0-9;]*m/g, '').length)) : 0
   if (qrLines.length && qrWidth <= cols) {

package/src/tui/i18n.js

@@ -137,7 +137,7 @@ const es = {
   pairAccount: (name) => `Cuenta que se comparte: ${name}`,
   pairValid: (min) => `Válido ~${min} min. Escanéalo o abre la URL en el dispositivo.`,
   pairUrl: 'URL: ',
-  pairPaste: 'O pega este código en la pestaña #vault de profile.dotrino.com:',
+  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.',
   pairConnected: (id) => `⧗ Se conectó: ${id} — pulsa A y escribe el código que muestra.`,
   pairWaiting: 'Esperando a que el dispositivo se conecte…',
@@ -300,7 +300,7 @@ const en = {
   pairAccount: (name) => `Account being shared: ${name}`,
   pairValid: (min) => `Valid ~${min} min. Scan it or open the URL on the device.`,
   pairUrl: 'URL: ',
-  pairPaste: 'Or paste this code into the #vault tab of profile.dotrino.com:',
+  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.',
   pairConnected: (id) => `⧗ Connected: ${id} — press A and type the code it shows.`,
   pairWaiting: 'Waiting for the device to connect…',

package/src/vaultControl.js

@@ -20,6 +20,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir, readJson } from './paths.js'
+import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
 
 const dir = dataDir()
 
@@ -255,25 +256,26 @@ export async function deleteScope (ns, profile) {
 // Emparejamiento de dispositivos (pares)
 // ---------------------------------------------------------------------------
 
-const PROFILE_URL = 'https://vault.dotrino.com/dispositivos#vault='
-
 /**
- * Codifica el QR crudo como URL de la consola de vault.dotrino.com.
- * El QR codifica la URL con el JSON crudo en el fragmento (menos datos que base64);
- * el código que el usuario COPIA Y PEGA sigue siendo base64url.
+ * Codifica el QR crudo para enseñarlo (ver `lib/src/invite.js`).
+ *
+ * Las dos formas son **la misma invitación compacta**: binario en base64url, ~100
+ * caracteres. Sirve igual para el QR (donde cada carácter son módulos, y módulos
+ * son filas de terminal) que para copiar y pegar (una sola palabra, sin comillas
+ * ni llaves, que sobrevive a un doble clic y a un chat). Antes hacían falta dos
+ * codificaciones distintas porque la única forma de achicar el QR era mandar el
+ * JSON crudo, ilegible al pegarlo; comprimiendo de verdad, esa disyuntiva
+ * desaparece.
+ *
+ *   · `url`     → el enlace del QR, `…/d#v=<invitación>`.
+ *   · `code`    → la invitación suelta, para pegar en la consola.
+ *   · `payload` → el JSON crudo. Ya no se emite; se devuelve para diagnóstico.
  */
 export function pairUrl (qr) {
-  const payload = JSON.stringify(qr)
-  const b64 = Buffer.from(payload, 'utf8').toString('base64')
-    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
-  return { url: PROFILE_URL + payload, payload, b64 }
+  const code = encodeInvite(qr)
+  return { url: inviteUrl(qr), code, payload: JSON.stringify(qr), b64: code }
 }
 
-/**
- * Inicia un emparejamiento. `service` (opcional) enrola un SERVICIO con acceso
- * SOLO a `vault:secrets:<service>` (no firma por ti ni lee tus datos).
- * Devuelve { qr, expiresAt, url, payload }.
- */
 export async function startPairing ({ profile, service } = {}) {
   requireAlive()
   rm(F.pair); rm(F.pending)
@@ -283,11 +285,11 @@ export async function startPairing ({ profile, service } = {}) {
     await sleep(100)
     const pr = read(F.pair, null)
     if (pr?.expiresAt > Date.now()) {
-      const { url, payload, b64 } = pairUrl(pr.qr)
+      const { url, payload, code } = pairUrl(pr.qr)
       // `profile`/`profileName`: DE QUÉ CUENTA del vault sale este QR. El vault
       // puede tener varias y el emparejamiento mete al dispositivo en UNA; la TUI
       // y la CLI lo muestran para que no se enrole en la equivocada.
-      return { qr: pr.qr, expiresAt: pr.expiresAt, url, payload, b64, profile: pr.profile || null, profileName: pr.profileName || '' }
+      return { qr: pr.qr, expiresAt: pr.expiresAt, url, payload, code, b64: code, profile: pr.profile || null, profileName: pr.profileName || '' }
     }
   }
   throw coded('el daemon no inició el emparejamiento', 'PAIR_FAILED')