@dotrino/vault 0.48.0 → 0.49.1

package/bin/dotrino-env.js

@@ -31,13 +31,18 @@ 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)
         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).
 
   status                 servicios enrolados en esta máquina
-  check [--ns <ns>]      pide los secretos al vault y lista sus NOMBRES (nunca los valores)
-  run --vault <bóveda> [--ns <ns>] -- <cmd> [args…]
+  check [--ns <ns>] [--public]
+                         pide los secretos al vault y lista sus NOMBRES (nunca los valores)
+                         con --public no pide aprobación: solo mira las públicas
+  run [--vault <bóveda>] [--ns <ns>] [--public] -- <cmd> [args…]
+        --public  trae SOLO las variables públicas. No pide aprobación en el teléfono:
+                  la aprobación es para las claves privadas, y una pública está en claro.
   ssh-agent [--ns <ns>] [--socket <ruta>]
                          agente SSH con las llaves (SSH_KEY_* del cajón) solo en memoria;
                          pide el cajón al arrancar. Pon SSH_AUTH_SOCK en la ruta que imprime.
@@ -82,9 +87,15 @@ async function readInvite () {
  * `--vault` y no `--profile`: `dotrino-vault --profile` ya significa otra cosa y los dos
  * comandos se usan seguidos.
  */
-function etiquetaBoveda () {
+/**
+ * La etiqueta de bóveda, si la hay. AL ENROLAR es obligatoria (`exigida: true`): ahí se está
+ * creando el directorio y hay que decir de quién es. Para USARLO no: el `ns` se busca entre
+ * las bóvedas enroladas y solo hace falta elegir si está en más de una (dueño, 2026-09-01).
+ */
+function etiquetaBoveda ({ exigida = false } = {}) {
   const v = resolveVaultLabel(flag('vault'))
   if (!v) {
+    if (!exigida) return null
     console.error('falta --vault <nombre>  (o DOTRINO_ENV_VAULT)')
     console.error('')
     console.error('  Dice DE QUÉ BÓVEDA es este cajón. Es una etiqueta tuya, de esta máquina:')
@@ -99,8 +110,8 @@ function etiquetaBoveda () {
 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 perfil = etiquetaBoveda()
-  const dir = flag('dir') || serviceDir(bov, ns)
+  const boveda = etiquetaBoveda({ exigida: true })
+  const dir = flag('dir') || serviceDir(boveda, ns)
   const qr = parseInvite((flag('qr') || flag('code')) || await readInvite())
 
   console.log('\nEnrolando el servicio "%s" contra el vault…', ns)
@@ -170,9 +181,13 @@ async function cmdCheck () {
   // `fetchSecrets` y no `loadEnv`: listar NO debe tener efectos secundarios. Con
   // `loadEnv` esto inyectaría el bundle en el entorno del propio `check`, que es
   // justo lo que un comando de diagnóstico no tiene por qué hacer.
-  const secrets = await fetchSecrets({ dir: serviceDir(etiquetaBoveda(), ns), ns })
+  // `--public` también aquí: ver QUÉ hay no debería costarle una aprobación al dueño. Sin
+  // él se piden todas, que es lo que hace falta para comprobar de verdad un arranque.
+  const publicOnly = argv.includes('--public')
+  const secrets = await fetchSecrets({ dir: serviceDir(etiquetaBoveda(), ns), ns, publicOnly })
   const keys = Object.keys(secrets)
-  console.log('ns "%s": %d secreto(s)%s', ns, keys.length, keys.length ? ':' : '')
+  console.log('ns "%s": %d %s%s', ns, keys.length,
+    publicOnly ? 'variable(s) pública(s)' : 'secreto(s)', keys.length ? ':' : '')
   for (const k of keys) console.log('  ' + k)   // NUNCA los valores
   // Delata el `.env` rancio: qué claves de esta máquina el vault pisaría.
   const clashing = keys.filter((k) => k in process.env && process.env[k] !== String(secrets[k]))
@@ -184,7 +199,7 @@ async function cmdCheck () {
 async function cmdRun () {
   const sep = argv.indexOf('--')
   const cmd = sep >= 0 ? argv.slice(sep + 1) : []
-  if (!cmd.length) { console.error('uso: dotrino-env run --vault <bóveda> [--ns <ns>] -- <cmd> [args…]'); process.exit(2) }
+  if (!cmd.length) { console.error('uso: dotrino-env run [--vault <bóveda>] [--ns <ns>] [--public] -- <cmd> [args…]'); process.exit(2) }
   const onPending = () => console.error('[dotrino-env] waiting for approval on your phone…')
   // POR QUÉ SE REINTENTA, SIEMPRE. Sin esto la espera es muda: la bóveda contestaba, la
   // respuesta se caía por un motivo concreto —un aparato sin sobre en su cajón, por
@@ -192,7 +207,12 @@ async function cmdRun () {
   // dueño hubiera aprobado cada una. Un reintento que no dice su causa es un fallback: le
   // pone cara de espera a un error. (Ver CLAUDE.md, «nada de repliegues».)
   const onRetry = (e, ms) => console.error('[dotrino-env] failed: %s — retrying in %ds', e.message, Math.round(ms / 1000))
-  const { injected, overridden } = await loadEnv({ ns: flag('ns'), vault: etiquetaBoveda(), onPending, onRetry })
+  // `--public`: SOLO las variables públicas, y por eso no hace sonar el teléfono de nadie.
+  // La aprobación existe para soltar claves privadas; una pública está guardada en claro y
+  // ya la ve quien administra. Es lo que quiere un arranque que solo necesita configuración
+  // —una URL, un puerto— y no tiene por qué despertar al dueño.
+  const publicOnly = argv.includes('--public')
+  const { injected, overridden } = await loadEnv({ ns: flag('ns'), vault: etiquetaBoveda(), onPending, onRetry, publicOnly })
   console.error('[dotrino-env] %d valor(es) en el entorno de %s%s', injected.length, cmd[0],
     overridden.length ? ` (pisados: ${overridden.join(', ')})` : '')
   const child = spawn(cmd[0], cmd.slice(1), { stdio: 'inherit', env: process.env })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.48.0",
+  "version": "0.49.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",

package/src/env.js

@@ -53,11 +53,26 @@ export const isValidVaultLabel = (p) => typeof p === 'string' && /^[a-z0-9-]{1,3
 /** Directorio de la identidad del servicio `ns` bajo la etiqueta de bóveda `vault`. */
 export function serviceDir (vault, ns) {
   if (process.env.DOTRINO_ENV_DIR) return process.env.DOTRINO_ENV_DIR
-  if (!isValidVaultLabel(vault)) {
-    throw new Error('missing vault label: pass --vault <nombre> (use [a-z0-9-]{1,32}). It is a label of YOUR machine: it says which vault this drawer came from')
-  }
   if (!isValidSecretsNs(ns)) throw new Error('invalid ns (use [a-z0-9-]{1,32}, e.g. "myapp")')
-  return path.join(serviceRoot(), vault, ns)
+  if (isValidVaultLabel(vault)) return path.join(serviceRoot(), vault, ns)
+  // SIN `--vault`: SE BUSCA, Y SOLO SE EXIGE SI HAY EMPATE (dueño, 2026-09-01).
+  //
+  // La etiqueta se hizo obligatoria para que dos bóvedas pudieran tener un cajón que se
+  // llame igual sin pisarse. Eso lo arregla la RUTA, no la bandera: con un solo enrolamiento
+  // de ese `ns` no hay nada que desambiguar y pedirla es fricción sin nada a cambio.
+  //
+  // Con dos, en cambio, elegir por el usuario sería adivinar cuál de sus cuentas usar — así
+  // que se para y se dice cuáles hay. Eso es lo contrario de un repliegue: no se resuelve
+  // una ambigüedad a la brava, se señala.
+  const donde = listEnrolled().filter((e) => !e.legacy && e.ns === ns)
+  if (donde.length === 1) return path.join(serviceRoot(), donde[0].vault, ns)
+  if (donde.length > 1) {
+    throw new Error(`"${ns}" is enrolled in more than one vault (${donde.map((e) => e.vault).join(', ')}): pick one with --vault <label>`)
+  }
+  const otros = listEnrolled().filter((e) => !e.legacy)
+  throw new Error(otros.length
+    ? `"${ns}" is not enrolled on this machine (there is: ${otros.map((e) => `${e.vault}/${e.ns}`).join(', ')})`
+    : `"${ns}" is not enrolled on this machine: run \`dotrino-env enroll --vault <label> --ns ${ns}\` first`)
 }
 
 /** La etiqueta de bóveda: `--vault`, o `DOTRINO_ENV_VAULT`. */
@@ -139,18 +154,21 @@ let lastApplied = null
  * @param {boolean} [opts.wait]      `true` (default) = si el vault no está, ESPERA (reintenta) en vez de fallar.
  * @param {string[]} [opts.required] Claves que deben venir; si falta alguna, lanza.
  * @param {(e:Error, ms:number)=>void} [opts.onRetry]
+ * @param {boolean} [opts.publicOnly] Solo las variables PÚBLICAS. No hay claves privadas de
+ *   por medio, así que la bóveda no pide aprobación: sirve para un arranque que solo
+ *   necesita configuración (una URL, un puerto) y no debe despertar a nadie.
  * @returns {Promise<{ns, secrets, injected:string[], overridden:string[], skipped:string[]}>}
  *   `overridden` = las que YA tenían otro valor en el entorno y el vault pisó. Es
  *   el dato que delata un `.env` rancio, así que se reporta en vez de callarse.
  */
-export async function loadEnv ({ ns, vault, dir, override, wait = true, required = [], onRetry, onPending } = {}) {
+export async function loadEnv ({ ns, vault, dir, override, wait = true, required = [], onRetry, onPending, publicOnly = false } = {}) {
   if (override === undefined) override = overrideByDefault()
   ns = resolveNs(ns)
-  // La ETIQUETA DE BÓVEDA es obligatoria salvo que se diga el directorio a pelo: es lo que
-  // hace que dos bóvedas puedan tener un cajón con el mismo nombre sin pisarse.
+  // La etiqueta de bóveda es OPCIONAL: `serviceDir` busca el `ns` entre las que hay y solo
+  // la exige si está enrolado en más de una (ahí sí hay que elegir, y elige el dueño).
   dir = dir || serviceDir(resolveVaultLabel(vault), ns)
   const load = wait ? waitForSecrets : fetchSecrets
-  const secrets = await load({ dir, ns, onRetry, onPending })
+  const secrets = await load({ dir, ns, onRetry, onPending, publicOnly })
 
   const missing = required.filter((k) => !(k in secrets))
   if (missing.length) {

package/src/service.js

@@ -421,7 +421,7 @@ export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device,
  * Renueva el cert automáticamente si está por vencer (best-effort).
  * @returns {Promise<Record<string,string>>}  secretos KEY→valor
  */
-export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, timeoutMs = 30000, onPending, onCert, approvalTimeoutMs = APPROVAL_TIMEOUT_MS } = {}) {
+export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, timeoutMs = 30000, onPending, onCert, approvalTimeoutMs = APPROVAL_TIMEOUT_MS, publicOnly = false } = {}) {
   let saved = null
   if (dir) saved = readServiceIdentity(dir)
   // Sin `dir`: la identidad viene entera por parámetros — es el caso de un agente
@@ -499,7 +499,9 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     }
 
     const eph = await makeEphemeralKey()
-    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now() }
+    // `publicOnly` VIAJA FIRMADO (va dentro de `data`), así que nadie lo puede quitar ni
+    // poner por el camino. Quien decide qué se manda es la bóveda; esto solo es la petición.
+    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), ...(publicOnly ? { publicOnly: true } : {}) }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
     const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs)
     client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
@@ -1022,11 +1024,11 @@ export function isFinal (e) {
   return /not enrolled|invalid ns|unauthorized: (revoked|expired|scope|cn|untrusted-issuer|cert-device-mismatch|denied)/.test(e?.message || '')
 }
 
-export async function waitForSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, retryMs = 5000, maxRetryMs = 60000, onRetry, onPending, onCert } = {}) {
+export async function waitForSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, retryMs = 5000, maxRetryMs = 60000, onRetry, onPending, onCert, publicOnly = false } = {}) {
   let delay = retryMs
   for (;;) {
     try {
-      return await fetchSecrets({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, onPending, onCert })
+      return await fetchSecrets({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, onPending, onCert, publicOnly })
     } catch (e) {
       if (isFinal(e)) throw e
       try { onRetry?.(e, delay) } catch (_) {}