@dotrino/vaultd 0.83.0 → 0.84.0

package/lib/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/lib/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 (_) {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.83.0",
+  "version": "0.84.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/secretsStore.js

@@ -329,10 +329,25 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
      * Van TODAS sus generaciones, no solo la última, porque desde v5 cada variable puede
      * venir de una escritura distinta. En v3 devuelve los valores en claro, como siempre.
      */
-    bundleFor (ns, devicePub = null) {
+    /**
+     * @param {string} ns
+     * @param {string|null} devicePub
+     * @param {{publicOnly?: boolean}} [opts] `publicOnly`: SOLO las públicas, y sin
+     *   envolturas. Una pública está guardada en claro, así que no hay llave que repartir
+     *   ni sobre que abrir — y por eso pedirlas no pasa por la aprobación (ver `handleSecrets`).
+     */
+    bundleFor (ns, devicePub = null, { publicOnly = false } = {}) {
       assertNs(ns)
-      const entries = { ...entriesOf(data.ns, ns), ...(devicePub ? entriesOf(data.dev, devicePub) : {}) }
+      const todo = { ...entriesOf(data.ns, ns), ...(devicePub ? entriesOf(data.dev, devicePub) : {}) }
+      // EL FILTRO LO HACE LA BÓVEDA, no quien pide. Si mandara todo y el cliente eligiera,
+      // pedir «solo públicas» sería la forma de saltarse la aprobación y llevarse las
+      // privadas igual — o sea justo lo contrario de lo que se quiere.
+      const entries = publicOnly
+        ? Object.fromEntries(Object.entries(todo).filter(([, e]) => e.pub))
+        : todo
       if (isLegacy()) return { legacy: true, entries }
+      // Sin privadas no hay nada que envolver: el paquete va sin llavero.
+      if (publicOnly) return { entries, ns: null, dev: null, wraps: { ns: [], dev: [] } }
       const misWraps = (bag, k) => (bag[k]?.keyring || [])
         .filter((g) => g.wraps?.[devicePub])
         .map((g) => ({ gen: g.gen, wrap: g.wraps[devicePub] }))

package/src/vault.js

@@ -852,7 +852,18 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // claves en memoria y no vuelve a pedir. El pedido se apunta, se avisa a quien aprueba y se
     // contesta «pendiente»; la respuesta de verdad sale cuando el teléfono firme
     // (`handleApproval`), sellada a la misma `ek`.
-    if (needsApproval(chk.device, record)) {
+    // SOLO PÚBLICAS: NO SE PIDE APROBACIÓN (dueño, 2026-09-01).
+    //
+    // La aprobación existe para soltar CLAVES PRIVADAS. Una variable pública está guardada
+    // en claro —eso es lo que significa marcarla— y ya la ve cualquiera que administre, así
+    // que hacer sonar el teléfono del dueño para entregarla es molestarlo por nada.
+    //
+    // Lo que NO se relaja: quien pide sigue teniendo que ser un miembro identificado, con su
+    // papel y con el `cn` de este cajón (las dos comprobaciones de arriba). Y el filtro lo
+    // hace la BÓVEDA (`bundleFor({ publicOnly })`), no el que pide: si mandáramos todo y el
+    // cliente eligiera, pedir «solo públicas» sería la manera de saltarse la aprobación.
+    const publicOnly = p.data?.publicOnly === true
+    if (!publicOnly && needsApproval(chk.device, record)) {
       const deviceId = await deviceIdOf(chk.device).catch(() => null)
       const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
       const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek })
@@ -866,20 +877,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return
     }
     let res
-    try { res = await resultFor(ns, chk.device, p.data.ek, record) } catch (e) {
+    try { res = await resultFor(ns, chk.device, p.data.ek, record, { publicOnly }) } catch (e) {
       return reply(from, { type: MSG.ERROR, error: 'secrets: invalid ek' })
     }
-    audit('secrets', { device: await deviceIdOf(chk.device), ns })
+    audit('secrets', { device: await deviceIdOf(chk.device), ns, ...(publicOnly ? { publicOnly: true } : {}) })
     reply(from, { type: MSG.SECRETS_RESULT, ...res })
   }
 
-  /** El bundle de `ns` para `devicePub`, sellado a su `ek` y firmado por la maestra. */
-  async function resultFor (ns, devicePub, ek, record) {
+  /** El bundle de `ns` para `devicePub`, sellado a su `ek` y firmado por la llave de sellado. */
+  async function resultFor (ns, devicePub, ek, record, { publicOnly = false } = {}) {
     // Mientras el archivo siga en v3 el cable NO cambia: se mandan los valores como
     // siempre. Solo tras la migración viajan sobres, y entonces quien los abre es el
     // agente con su llave. Así el despliegue del daemon se deshace con un reinicio,
     // porque hasta el primer desbloqueo no ha cambiado nada de lo que ve nadie.
-    const b = secrets.bundleFor(ns, devicePub)
+    const b = secrets.bundleFor(ns, devicePub, { publicOnly })
     // EL ACTA VIAJA CON EL BUNDLE (§8.8): es lo que le permite al agente comprobar que
     // los sobres los selló esta bóveda, y con qué llave —la que el acta nombra para el
     // `seq` con el que se firmaron—. No es un dato secreto: el acta es pública dentro
@@ -897,7 +908,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // como si se hubiera servido. Desde fuera parecía que el pedido funcionaba y volvía a
     // aparecer una y otra vez. Falta la envoltura, y eso solo se arregla ABRIENDO la
     // bóveda; decirlo aquí es lo que convierte un bucle mudo en algo que se puede arreglar.
-    if (!b.legacy) {
+    if (!b.legacy && !publicOnly) {
       const faltan = [...secrets.missingFor(`ns:${ns}`, devicePub), ...secrets.missingFor(`dev:${devicePub}`, devicePub)]
       if (faltan.length) {
         const quien = await deviceIdOf(devicePub).catch(() => '????-????')