@dotrino/vault 0.54.0 → 0.60.1

package/bin/dotrino-env.js

@@ -30,8 +30,9 @@ const flag = (name) => { const i = argv.indexOf('--' + name); return i >= 0 ? ar
 function help () {
   console.log(`dotrino-env — credenciales del vault en vez del .env
 
-  enroll --vault <bóveda> --ns <ns> [--code <invitación>] [--dir <dir>]
-        (--vault SOLO hace falta aquí, y para usarlo si el mismo <ns> está en dos bóvedas)
+  enroll --ns <ns> [--vault <bóveda>] [--code <invitación>] [--dir <dir>]
+        (sin --vault se usa el NOMBRE DE LA CUENTA, que la bóveda dice al enrolar; solo
+         hace falta darla si quieres otra etiqueta, o si el mismo <ns> está en dos bóvedas)
         Registra ESTE servicio contra el vault (una sola vez).
         Antes, en el vault:  dotrino-vault pair --service <ns>
         Si no pasas --code (alias --qr), se pide por consola (también acepta stdin).
@@ -103,16 +104,45 @@ function etiquetaBoveda ({ exigida = false } = {}) {
     console.error('  Sirve para que dos bóvedas puedan tener un cajón llamado igual.')
     process.exit(2)
   }
-  if (!isValidVaultLabel(v)) { console.error('etiqueta inválida: usa [a-z0-9-]{1,32}'); process.exit(2) }
-  return v
+  // EN MINÚSCULAS, SIN PROTESTAR. La etiqueta es el nombre de una carpeta de esta máquina
+  // y nada más, así que las mayúsculas no significan nada aquí — pero el perfil sí se llama
+  // «Cepi», con mayúscula, y es lo que uno teclea. Rechazarlo era fricción sin nada a
+  // cambio, y el mensaje solo repetía la regla en vez de decir qué escribir.
+  const norm = v.toLowerCase()
+  if (!isValidVaultLabel(norm)) {
+    console.error('etiqueta inválida: «%s»', v)
+    console.error('  es el nombre de una carpeta de esta máquina: letras, números y guiones (máx. 32).')
+    console.error('  ej.:  --vault cepi')
+    process.exit(2)
+  }
+  return norm
 }
 
 async function cmdEnroll () {
   const ns = flag('ns')
   if (!ns) { console.error('falta --ns <ns>  (el mismo del `dotrino-vault pair --service <ns>`)'); process.exit(2) }
-  const boveda = etiquetaBoveda({ exigida: true })
-  const dir = flag('dir') || serviceDir(boveda, ns)
   const qr = parseInvite((flag('qr') || flag('code')) || await readInvite())
+  // SIN `--vault`, SE LO PREGUNTA A LA BÓVEDA (dueño, 2026-09-03: «en el enroll si no se
+  // pone vault debería usar el nombre del perfil»). Al enrolar ya sabes contra qué bóveda
+  // vas —la invitación lo dice, o ella lo contesta—, así que pedir la etiqueta era hacer
+  // teclear un dato que el programa tiene delante.
+  //
+  // La etiqueta es solo el nombre de una carpeta de esta máquina, así que el nombre de la
+  // cuenta se lleva a minúsculas y se le quitan los caracteres que no valen. Si de ahí no
+  // sale nada utilizable, se pide — no se inventa un nombre.
+  let boveda = etiquetaBoveda()
+  if (!boveda) {
+    const { vaultAccountName } = await import('../src/service.js')
+    const nombre = await vaultAccountName(qr).catch(() => '')
+    boveda = String(nombre || '').toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 32)
+    if (!boveda) {
+      console.error('esa bóveda no dice cómo se llama su cuenta: dime tú la etiqueta')
+      console.error('  ej.:  dotrino-env enroll --ns %s --vault mi-boveda --code …', ns)
+      process.exit(2)
+    }
+    console.log('  bóveda: «%s» (el nombre de la cuenta; se guarda en ~/.dotrino/service/%s/%s)', boveda, boveda, ns)
+  }
+  const dir = flag('dir') || serviceDir(boveda, ns)
 
   console.log('\nEnrolando el servicio "%s" contra el vault…', ns)
   const { cert } = await enrollService({
@@ -150,7 +180,7 @@ async function cmdEnroll () {
 function cmdStatus () {
   const found = listEnrolled()
   if (!found.length) {
-    console.log('Ningún servicio enrolado en %s\n  Enrola uno:  dotrino-env enroll --vault <bóveda> --ns <ns>', serviceRoot())
+    console.log('Ningún servicio enrolado en %s\n  Enrola uno:  dotrino-env enroll --ns <ns> --code "<invitación>"', serviceRoot())
     return
   }
   for (const e of found) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.54.0",
+  "version": "0.60.1",
   "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",
@@ -51,7 +51,7 @@
   ],
   "peerDependencies": {
     "@dotrino/identity": ">=0.73.1",
-    "@dotrino/proxy-client": ">=0.13.0"
+    "@dotrino/proxy-client": ">=0.17.0"
   },
   "license": "MIT",
   "repository": {

package/src/admin.js

@@ -56,7 +56,12 @@ export const ADMIN_OPS = Object.freeze([
   // aparato que administra no tiene sobres de lo privado (solo el servicio dueño y la
   // recuperación). Eso lo hace la bóveda en su máquina (`secret show/history/revert`).
   // No lo cablees.
-  'vars', 'var.set', 'var.setMany'
+  // `var.recipients` es solo LEER, y hace falta para poder escribir: la consola sella el
+  // valor ella misma (§8.1) y para eso necesita saber a quién envolverle la llave. Estaba
+  // documentada en `buildSealedVar` y la consola la llamaba, pero no existía — así que
+  // crear una variable desde la consola contestaba «admin: invalid operation». No expone
+  // nada nuevo: son llaves PÚBLICAS, las mismas que ya viajan en el acta.
+  'vars', 'var.set', 'var.setMany', 'var.recipients'
 ])
 
 /**
@@ -85,7 +90,7 @@ export const ADMIN_OPS = Object.freeze([
  * Se dejan las de LEER a propósito: si se cortaran todas, la consola no podría ni
  * enterarse de por qué no funciona y parecería rota. Así puede decir «está cerrada».
  */
-export const ADMIN_OPS_WHILE_LOCKED = Object.freeze(['audit', 'vars', 'var.set', 'var.setMany'])
+export const ADMIN_OPS_WHILE_LOCKED = Object.freeze(['audit', 'vars', 'var.set', 'var.setMany', 'var.recipients'])
 
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
 export const ADMIN_NONCE_TTL_MS = 10 * 60 * 1000
@@ -195,7 +200,7 @@ export function createAdminDesk ({
 
       // VARIABLES DE ENTORNO. El módulo solo enruta y audita: qué valor puede salir y con
       // qué se cifra lo decide la bóveda (`vars`), que es la que tiene la clave y el disco.
-      if (data.op === 'vars' || data.op === 'var.set' || data.op === 'var.setMany') {
+      if (data.op === 'vars' || data.op === 'var.set' || data.op === 'var.setMany' || data.op === 'var.recipients') {
         if (!vars) return { ok: false, error: 'admin: this vault does not serve environment variables' }
         // Un destino y solo uno: o un scope, o un aparato. Sin esto, mandar los dos dejaría
         // que quien llama adivine dónde acabó su variable.
@@ -212,6 +217,27 @@ export function createAdminDesk ({
         }
         if (toScope === toDevice) return { ok: false, error: 'admin: var.set needs exactly one target (ns or pub)' }
 
+        // A QUIÉN HAY QUE ENVOLVERLE. Se pide ANTES de sellar, porque sellar lo hace la
+        // consola: envolver solo necesita públicas, así que puede hacerlo un navegador sin
+        // que ninguna privada ande suelta (§8.1). La lista sale del ACTA y la sabe la
+        // bóveda, no la consola — así conceder un permiso a un aparato nuevo basta, sin que
+        // nadie tenga que acordarse de actualizar una lista en otro sitio.
+        //
+        // Depende de la VISIBILIDAD: una pública se envuelve además para quien administra,
+        // así que quien pregunta dice cuál va a escribir.
+        if (data.op === 'var.recipients') {
+          if (typeof vars.recipients !== 'function') {
+            return { ok: false, error: 'admin: this vault cannot say who to seal for (update it)' }
+          }
+          const result = await vars.recipients({
+            ns: toScope ? data.ns : null,
+            pub: toDevice ? data.pub : null,
+            public: data.public === true
+          })
+          audit('admin.var.recipients', { by, ns: toScope ? data.ns : null })
+          return { ok: true, result }
+        }
+
         // VARIAS DE UNA VEZ. Mismo permiso y misma frontera que una sola: lo que cambia es
         // que la bóveda las guarda juntas y manda UN aviso de cambio en vez de uno por
         // variable — o sea, el servicio se reinicia una vez, con la configuración entera,

package/src/index.js

@@ -84,7 +84,10 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   const client = injectedClient || await (async () => {
     const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
     const c = new WebSocketProxyClient({
-      url: proxy, enableWebRTC: false, autoReconnect: true,
+  // WEBRTC SOLO DONDE EXISTE (ver `lib/src/service.js`): en Node no hay
+  // `RTCPeerConnection` y encenderlo reventaría al negociar; en un navegador es nativo y es
+  // el camino directo que hay que preferir. Se mira, en vez de apagarlo para siempre.
+      url: proxy, enableWebRTC: typeof globalThis.RTCPeerConnection === 'function', autoReconnect: true,
       maxReconnectAttempts: 100000, reconnectDelay: 4000
     })
     await c.connect()

package/src/localdesk.js

@@ -0,0 +1,96 @@
+/**
+ * localdesk.js — HABLARLE A LA BÓVEDA SIN SALIR DE LA MÁQUINA.
+ *
+ * Un servicio en el mismo equipo que la bóveda daba la vuelta por `proxy.dotrino.com`:
+ * salía a internet, volvía, y si el proxio tenía un mal momento el arranque se retrasaba
+ * cinco segundos por nada. Absurdo cuando los dos procesos comparten disco (dueño,
+ * 2026-09-03: «estando en la misma máquina debería ser inmediato»).
+ *
+ * Es EL MISMO PROTOCOLO. Lo que viaja es idéntico —`{type, data, signature, cert}`— y la
+ * bóveda lo comprueba igual, contra el certificado y contra el acta. **Alcanzar el socket
+ * no autoriza nada**: es la misma puerta por un camino más corto, no una puerta de atrás.
+ *
+ * Se hace pasar por un cliente del proxio (`send`, `sendByPubkey`, `on('message')`,
+ * `close`) para que quien lo use no tenga que saber por dónde va. `sendByPubkey` ignora a
+ * quién se dirige, y es correcto: al otro lado del socket solo hay una bóveda, la de esta
+ * máquina — si hubiera que elegir destinatario, este no sería el camino.
+ */
+import fs from 'node:fs'
+import net from 'node:net'
+import path from 'node:path'
+import os from 'node:os'
+
+/**
+ * DÓNDE ESTÁ EL SOCKET, y por qué se nombra por la LLAVE de la bóveda.
+ *
+ * Una máquina puede tener varias bóvedas (varios perfiles), y un servicio no sabe nada de
+ * perfiles: lo único que conoce de la suya es su llave maestra, que lleva pineada desde
+ * que se enroló. Así que el nombre sale de ahí y los dos lados lo calculan igual, sin
+ * mirar ningún índice ni depender de cómo estén repartidos los datos en el disco.
+ *
+ * Y va en el directorio de EJECUCIÓN del usuario, no entre los datos: un socket es algo
+ * vivo, no algo guardado. Se lo lleva el reinicio, que es lo correcto.
+ */
+export function socketDir () {
+  const base = process.env.XDG_RUNTIME_DIR || os.tmpdir()
+  return path.join(base, 'dotrino-vault')
+}
+
+export function localSocketPath (masterId) {
+  if (process.env.DOTRINO_VAULT_SOCKET) return process.env.DOTRINO_VAULT_SOCKET
+  return path.join(socketDir(), String(masterId) + '.sock')
+}
+
+/** ¿Hay una bóveda escuchando aquí mismo? Mirar el archivo es barato y no conecta nada. */
+export const hasLocalVault = (masterId) => {
+  try { return fs.statSync(localSocketPath(masterId)).isSocket() } catch (_) { return false }
+}
+
+/**
+ * Se conecta al mostrador local y devuelve algo con la forma de un cliente del proxio.
+ * Si no hay socket, o no acepta, LANZA — no se queda callado: quien llama decide si sale
+ * por el proxio, y esa decisión tiene que ser explícita y no un silencio.
+ */
+export async function connectLocal ({ masterId, timeoutMs = 3000 } = {}) {
+  const socketPath = localSocketPath(masterId)
+  const sock = await new Promise((resolve, reject) => {
+    const s = net.createConnection(socketPath)
+    const t = setTimeout(() => { s.destroy(); reject(new Error('the local vault desk did not answer')) }, timeoutMs)
+    s.once('connect', () => { clearTimeout(t); resolve(s) })
+    s.once('error', (e) => { clearTimeout(t); reject(new Error('no local vault desk at ' + socketPath + ': ' + e.message)) })
+  })
+
+  const oyentes = new Set()
+  let buf = ''
+  sock.setEncoding('utf8')
+  sock.on('data', (chunk) => {
+    buf += chunk
+    let i
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const linea = buf.slice(0, i); buf = buf.slice(i + 1)
+      if (!linea.trim()) continue
+      let p = null
+      try { p = JSON.parse(linea) } catch (_) { continue }
+      // `from` es el mismo para todo: al otro lado solo hay una bóveda.
+      for (const fn of oyentes) { try { fn('local', p) } catch (_) {} }
+    }
+  })
+
+  const enviar = (obj) => { sock.write(JSON.stringify(obj) + '\n') }
+  return {
+    local: true,
+    token: 'local',
+    send: (_to, obj) => enviar(obj),
+    sendByPubkey: (_pub, obj) => enviar(obj),
+    // El mostrador local no pide identificarse: la puerta la abre el certificado que va
+    // dentro de cada mensaje, igual que por el proxio. Identificarse ahí sirve para ser
+    // DIRECCIONABLE, y aquí no hay a quién direccionar.
+    identify: async () => ({ ok: true }),
+    on: (ev, fn) => {
+      if (ev !== 'message') return () => {}
+      oyentes.add(fn)
+      return () => oyentes.delete(fn)
+    },
+    close: () => { try { sock.destroy() } catch (_) {} }
+  }
+}

package/src/service.js

@@ -30,6 +30,7 @@ import { MSG, secretsScope, isValidSecretsNs } from './protocol.js'
 import { makeEphemeralKey, openSealed } from './sealed.js'
 import { parseInvite } from './invite.js'
 import { atRestFor } from './atrest.js'
+import { connectLocal, hasLocalVault } from './localdesk.js'
 
 const IDENTITY_FILE = 'service-identity.json'
 const FRESH_WINDOW_MS = 5 * 60 * 1000
@@ -126,10 +127,33 @@ async function resolveAppointment (client, code) {
   return r.instance
 }
 
-async function freshClient (proxyUrl, connectTimeoutMs = 20000) {
+/**
+ * EL MÁS CORTO PRIMERO: si la bóveda está en ESTA máquina, se le habla por su socket y no
+ * se sale a internet (dueño, 2026-09-03: «estando en la misma máquina debería ser
+ * inmediato»). Es el mismo protocolo y las mismas comprobaciones; lo único que cambia es
+ * por dónde van los bytes.
+ *
+ * No es un repliegue que tape nada: el socket o está o no está, y no estar es el caso
+ * normal —la bóveda suele vivir en otra máquina—. Lo que sí sería un repliegue es callar
+ * un fallo del socket y salir por el proxio como si nada, así que se dice.
+ */
+async function freshClient (proxyUrl, connectTimeoutMs = 20000, master = null) {
   installNodeGlobals()
+  // El id sale de la LLAVE de la bóveda, que es lo único que quien llama sabe seguro de
+  // ella. Sin llave no se busca socket: no habría forma de saber cuál es el suyo.
+  const masterId = master ? (await pubkeyId(master)).slice(0, 16) : null
+  if (masterId && hasLocalVault(masterId)) {
+    try { return await connectLocal({ masterId }) } catch (e) {
+      console.error('[vault] the local desk is there but did not answer (%s): going out through the proxy', e.message)
+    }
+  }
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({ url: proxyUrl, enableWebRTC: false, autoReconnect: false })
+  // WEBRTC SOLO DONDE EXISTE. En Node no hay `RTCPeerConnection`, así que encenderlo
+  // reventaría al negociar; en un navegador es nativo y es el camino directo que hay que
+  // preferir. Se mira si está, en vez de apagarlo a mano para siempre: el día que este
+  // código corra en un navegador —o que Node lo traiga— se enciende solo.
+  const hayWebRTC = typeof globalThis.RTCPeerConnection === 'function'
+  const client = new WebSocketProxyClient({ url: proxyUrl, enableWebRTC: hayWebRTC, autoReconnect: false })
   // connect() del cliente solo se resuelve con 'connected' y solo rechaza en el
   // evento 'error' de transporte: si el socket cierra LIMPIO antes de 'connected'
   // (p.ej. el proxy banea la IP y envía close 1008), la promesa quedaría colgada
@@ -251,6 +275,43 @@ function writeServiceIdentity (dir, obj) {
  *   puede convertirse en leer ni por descuido ni por un cambio futuro. Es el mismo cerrojo
  *   que tiene la llave de comunicación.
  */
+/**
+ * QR CORTO: se le pregunta a la bóveda QUIÉN ES, punto a punto, presentando el `sn`.
+ *
+ * Sale de dentro de `enrollWithVault` para poder preguntarlo ANTES de enrolar: quien
+ * enrola necesita el nombre de la cuenta para saber dónde guardar (la etiqueta de bóveda
+ * es una carpeta con ese nombre), y pedírselo al usuario cuando la bóveda ya lo sabe es
+ * fricción sin nada a cambio.
+ *
+ * Devuelve el mismo `qr` con `iss`, `proxy` y `acct` puestos. Con un QR largo no pregunta
+ * nada: ya los trae.
+ */
+export async function sayHello (client, qr) {
+  if (qr.iss) return qr
+  const target = await resolveAppointment(client, qr.conn)
+  const hello = await new Promise((resolve, reject) => {
+    const off = client.on('message', (_f, p) => {
+      if (p?.type === MSG.HELLO_OK) { finish(); verifyHello(p, qr.sn).then(resolve, reject) }
+      else if (p?.type === MSG.ERROR) { finish(); reject(new Error(p.error)) }
+    })
+    const t = setTimeout(() => { finish(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
+    const finish = () => { off(); clearTimeout(t) }
+    try { client.send(target, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { finish(); reject(e) }
+  })
+  return { ...qr, iss: hello.iss, proxy: hello.proxy || qr.proxy, ...(hello.acct ? { acct: hello.acct } : {}) }
+}
+
+/**
+ * Cómo se llama la cuenta de esa invitación, sin enrolar nada. Una conexión y una pregunta.
+ */
+export async function vaultAccountName (qr) {
+  if (typeof qr === 'string') qr = parseInvite(qr)
+  if (!qr?.sn) throw new Error('that does not look like a vault invitation')
+  if (qr.acct) return qr.acct
+  const client = await freshClient(qr.proxy || 'wss://proxy.dotrino.com')
+  try { return (await sayHello(client, qr)).acct || '' } finally { try { client.close() } catch (_) {} }
+}
+
 export async function enrollWithVault ({ qr, label = 'agent', expectedScope = null, onCode, approveTimeoutMs = 180000, withEncKey = true } = {}) {
   // `parseInvite` y NO `JSON.parse`: el vault no imprime JSON desde hace rato.
   // `dotrino-vault pair` emite la URL del QR y el código compacto (`c…`/`t…`, ver
@@ -264,20 +325,7 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
   rejectAdoption(qr.m)
 
   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 target = await resolveAppointment(client, qr.conn)
-    const hello = await new Promise((resolve, reject) => {
-      const off = client.on('message', (_f, p) => {
-        if (p?.type === MSG.HELLO_OK) { finish(); verifyHello(p, qr.sn).then(resolve, reject) }
-        else if (p?.type === MSG.ERROR) { finish(); reject(new Error(p.error)) }
-      })
-      const t = setTimeout(() => { finish(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
-      const finish = () => { off(); clearTimeout(t) }
-      try { client.send(target, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { finish(); reject(e) }
-    })
-    qr = { ...qr, iss: hello.iss, proxy: hello.proxy || qr.proxy }
-  }
+  qr = await sayHello(client, qr)
   try {
     const device = await makeDeviceKey({ label })
     // La llave de CIFRADO: es a la que la bóveda sella cada variable. Sin ella el
@@ -413,7 +461,7 @@ export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device,
   cert = cert || saved?.cert
   if (!proxyUrl || !masterPubkey || !device || !cert) throw new Error('service not enrolled')
 
-  const client = await freshClient(proxyUrl)
+  const client = await freshClient(proxyUrl, 20000, masterPubkey)
   try {
     await identifyAsService(client, device)
     const data = { op: 'enckey', ns, encPub, publickey: device.publickey, ts: Date.now() }
@@ -449,7 +497,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     throw new Error('service not enrolled: run enrollService() first (service-identity.json missing)')
   }
 
-  const client = await freshClient(proxyUrl)
+  const client = await freshClient(proxyUrl, 20000, masterPubkey)
   try {
     await identifyAsService(client, device)
 
@@ -1062,6 +1110,15 @@ export async function watchSecretsChanges ({
   const connect = async () => {
     if (stopped) return
     try {
+      // POR EL PROXIO, A PROPÓSITO, aunque la bóveda esté en esta misma máquina.
+      //
+      // El mostrador local es pregunta y respuesta. Los avisos que la bóveda manda POR SU
+      // CUENTA —«tu configuración cambió», una revocación— salen por el proxio, así que un
+      // oyente conectado solo en local no se enteraría de nada y se quedaría corriendo con
+      // la configuración vieja para siempre. Lo cazaron los E2E de avisos.
+      //
+      // El atajo local es para el ARRANQUE, que es donde se nota la latencia: pedir las
+      // claves una vez. Escuchar es otra cosa y necesita que la bóveda pueda alcanzarte.
       client = await freshClient(saved.proxy)
       await identifyAsService(client, saved.device)
       client.on('message', (_from, p) => { handleMessage(p).catch(() => {}) })