@dotrino/vault 0.8.0 → 0.9.0

package/bin/dotrino-env.js

@@ -44,18 +44,14 @@ Entorno: DOTRINO_NS · DOTRINO_ENV_DIR · DOTRINO_ENV_HOME · DOTRINO_ENV_QUIET`
 }
 
 /**
- * La invitación que imprime `dotrino-vault pair` viene en tres formas: el JSON
- * crudo, el base64url del payload, o la URL de profile con `#vault=<b64>`.
- * Aceptamos las tres para que el operador pegue lo que tenga a mano.
+ * La invitación que imprime `dotrino-vault pair`, en cualquiera de sus formas
+ * (URL del QR, código pegable, formatos viejos). El parser es el compartido:
+ * `lib/src/invite.js`, que lee la marca de formato en vez de adivinar.
  */
 function parseInvite (raw) {
-  const s = String(raw || '').trim()
-  if (!s) throw new Error('invitación vacía')
-  if (s.startsWith('{')) return JSON.parse(s)
-  const b64 = s.includes('#vault=') ? s.split('#vault=')[1] : (s.includes('#') ? s.split('#').pop() : s)
-  const json = Buffer.from(b64.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8')
-  if (!json.trim().startsWith('{')) throw new Error('no parece una invitación del vault')
-  return JSON.parse(json)
+  const o = sharedParseInvite(raw)
+  if (!o) throw new Error('no parece una invitación del vault')
+  return o
 }
 
 async function readInvite () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Usa ESTE dispositivo (navegador) como bóveda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegación a tus máquinas. Incluye el cliente de SERVICIO (Node): un proyecto se enrola una vez y jala sus credenciales del vault en vez del .env (`import '@dotrino/vault/config'`).",
   "type": "module",
   "main": "src/index.js",

package/src/enroll.js

@@ -108,13 +108,29 @@ export function createEnrollDesk ({
   const reply = (to, obj) => { try { send(to, obj) } catch (e) { log('[vault] no se pudo responder:', e.message) } }
   const isFresh = (d) => typeof d?.ts === 'number' && Math.abs(Date.now() - d.ts) <= FRESH_WINDOW_MS
 
-  /** Inicia un emparejamiento: token + nonce de sesión. NO firma nada todavía. */
-  function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '' } = {}) {
+  /**
+   * Inicia un emparejamiento: token + nonce de sesión. NO firma nada todavía.
+   *
+   * `mode` y `account` son LO QUE LA BÓVEDA DECLARA que va a pasar, y viajan en el QR
+   * para que el aparato pueda **decirlo antes de hacerlo** en vez de emparejar a
+   * ciegas (decisión V9 de `docs/vinculacion-de-cuentas.md`: pregunta el vault, el
+   * dispositivo muestra el proceso y sus consecuencias):
+   *
+   *   · `mode: 'join'`  → el dispositivo estrena una cuenta suya y entra a la de la
+   *                       bóveda. Es lo único que existe hoy.
+   *   · `mode: 'adopt'` → la bóveda se quedaría con la cuenta que trae el aparato
+   *                       (camino A). Reservado: todavía no hay protocolo.
+   *   · `account`       → cómo se llama la cuenta de la bóveda, para nombrarla en el
+   *                       aviso. Es ORIENTATIVO (un nombre que puso su dueño); la
+   *                       identidad de verdad de la cuenta es `iss`.
+   */
+  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()
-    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, state: 'AWAITING_ENROLL' })
-    return { token, qr: { v: 2, iss, proxy, token, sn }, expiresInMs: PAIRING_TTL_MS }
+    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 }
   }
 
   function stopPairing (token) { pending.delete(token) }

package/src/invite.js

@@ -0,0 +1,87 @@
+/**
+ * invite.js — la invitación de emparejamiento: cómo se escribe y cómo se lee.
+ *
+ * Un emparejamiento viaja de dos maneras, y cada una quiere una codificación
+ * distinta:
+ *
+ *   · **El QR / el enlace** → JSON CRUDO (`j`). Nadie lo lee con los ojos y cada
+ *     carácter cuenta: el base64 infla el payload un 33 % y eso son módulos de más
+ *     en el QR (~8 columnas y 4 filas de terminal). Va crudo.
+ *   · **El código que se copia y se pega** → base64url (`b`). Ahí sí lo manipula
+ *     una persona: una sola palabra sin comillas, llaves ni espacios, que sobrevive
+ *     a un doble clic, a un chat y a un campo de texto.
+ *
+ * Para que el lector no tenga que ADIVINAR cuál de las dos le llegó, el payload
+ * empieza por una **marca de formato** de un carácter (`j` o `b`). Sin marca se
+ * asume el formato viejo (base64url, y si no, JSON), solo por compatibilidad con
+ * los enlaces que ya salieron.
+ *
+ * GOTCHA que justifica la mitad de este archivo: 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 el JSON
+ * que se emitió. Medido en un navegador real (2026-07-28). Por eso se
+ * `decodeURIComponent` antes de parsear: sin eso, el QR daba «ese código no vale».
+ */
+
+export const FMT_JSON = 'j'
+export const FMT_B64 = 'b'
+
+const b64urlEncode = (s) => {
+  const bytes = new TextEncoder().encode(s)
+  let bin = ''
+  for (const b of bytes) bin += String.fromCharCode(b)
+  const raw = typeof btoa === 'function' ? btoa(bin) : Buffer.from(s, 'utf8').toString('base64')
+  return raw.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+const b64urlDecode = (s) => {
+  const b = s.replace(/-/g, '+').replace(/_/g, '/')
+  const pad = b + '='.repeat((4 - b.length % 4) % 4)
+  if (typeof atob === 'function') {
+    const bin = atob(pad)
+    const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0))
+    return new TextDecoder().decode(bytes)
+  }
+  return Buffer.from(pad, 'base64').toString('utf8')
+}
+
+/** El payload marcado, listo para meter en el `#fragment` o para copiar y pegar. */
+export function encodeInvite (qr, fmt = FMT_B64) {
+  const json = JSON.stringify(qr)
+  return fmt === FMT_JSON ? FMT_JSON + json : FMT_B64 + b64urlEncode(json)
+}
+
+/** Una URL sin percent-encodear rompe el `#`: el fragmento se corta ahí. */
+const cutFragment = (text) => {
+  const i = text.indexOf('#vault=')
+  return i >= 0 ? text.slice(i + 7) : text
+}
+
+/**
+ * Lee una invitación venga como venga: URL con `#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_JSON) return parse(undoUrl(resto)) || parse(resto)
+  if (marca === FMT_B64) { try { return parse(b64urlDecode(resto)) } catch { return null } }
+
+  // --- sin marca: formatos anteriores a la marca de formato (compatibilidad) ---
+  const crudo = undoUrl(payload)
+  if (crudo.trimStart().startsWith('{')) return parse(crudo)
+  try { return parse(b64urlDecode(payload)) } catch { return null }
+}
+
+export default { encodeInvite, parseInvite, FMT_JSON, FMT_B64 }