@dotrino/vaultd 0.7.8 → 0.8.0

package/bin/dotrino-vaultd.js

@@ -14,7 +14,7 @@
  */
 import { runDaemon } from '../src/daemon.js'
 import { qrToString } from '../src/qr.js'
-import { daemonAlive } from '../src/vaultControl.js'
+import { daemonAlive, pairUrl } from '../src/vaultControl.js'
 
 // `--tui` con una bóveda YA CORRIENDO en otra ventana: se engancha a ella y abre solo la
 // interfaz. Antes intentaba levantar una segunda bóveda sobre los mismos datos, chocaba
@@ -37,9 +37,11 @@ const mgr = await runDaemon()
 // Empareja contra el perfil ACTIVO.
 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(JSON.stringify(qr), 2))
-  console.log(JSON.stringify(qr))
+  console.log(qrToString(url))
+  console.log(url)
+  console.log('\nO pegá este código:\n  ' + b64)
 }
 
 // --tui: la bóveda Y su interfaz en la MISMA ventana. Donde no queda como servicio

package/lib/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 }

package/package.json

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

@@ -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(payload, 2)) // QR con el JSON crudo (menos datos) y zona de silencio reducida
+  console.log(qrToString(url)) // el QR abre vault.dotrino.com/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.payload, 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/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, FMT_JSON, FMT_B64 } from '../lib/src/invite.js'
 
 const dir = dataDir()
 
@@ -257,19 +258,24 @@ export async function deleteScope (ns, profile) {
 
 const PROFILE_URL = 'https://vault.dotrino.com/dispositivos#vault='
 
-/** Codifica el QR crudo como URL de la consola de vault.dotrino.com (base64url del payload). */
+/**
+ * Codifica el QR crudo en sus dos formas (ver `lib/src/invite.js`):
+ *
+ *   · `url`  → para el QR y el enlace: JSON CRUDO con marca `j`. Es lo más corto
+ *              que hay, y en un QR cada carácter son módulos: con base64 el QR
+ *              pide ~8 columnas y 4 filas más de terminal.
+ *   · `code` → para copiar y pegar: base64url con marca `b`. Una sola palabra,
+ *              sin comillas ni llaves, que sobrevive a un doble clic y a un chat.
+ *
+ * La MARCA de formato (el primer carácter) existe para que el lector no tenga que
+ * probar los dos formatos a ver cuál cuela: la lee y sabe.
+ */
 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 + b64, payload, b64 }
+  const code = encodeInvite(qr, FMT_B64)
+  return { url: PROFILE_URL + encodeInvite(qr, FMT_JSON), code, payload, 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)
@@ -279,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')