@dotrino/vaultd 0.26.2 → 0.46.2

package/lib/src/env.js

@@ -32,7 +32,7 @@ export function serviceRoot () {
 /** Directorio de la identidad del servicio `ns` (`DOTRINO_ENV_DIR` lo pisa). */
 export function serviceDir (ns) {
   if (process.env.DOTRINO_ENV_DIR) return process.env.DOTRINO_ENV_DIR
-  if (!isValidSecretsNs(ns)) throw new Error('ns inválido (usa [a-z0-9-]{1,32}, p. ej. "miapp")')
+  if (!isValidSecretsNs(ns)) throw new Error('invalid ns (use [a-z0-9-]{1,32}, e.g. "myapp")')
   return path.join(serviceRoot(), ns)
 }
 
@@ -50,15 +50,15 @@ export function listEnrolled () {
 export function resolveNs (ns) {
   ns = ns || process.env.DOTRINO_NS
   if (ns) {
-    if (!isValidSecretsNs(ns)) throw new Error('ns inválido: ' + ns)
+    if (!isValidSecretsNs(ns)) throw new Error('invalid ns: ' + ns)
     return ns
   }
   const found = listEnrolled()
   if (found.length === 1) return found[0]
   if (found.length === 0) {
-    throw new Error('no hay ningún servicio enrolado en esta máquina: corre `npx dotrino-env enroll --ns <tu-app>`')
+    throw new Error('no service enrolled on this machine: run `npx dotrino-env enroll --ns <your-app>`')
   }
-  throw new Error(`hay varios servicios enrolados (${found.join(', ')}): elige uno con DOTRINO_NS=<ns> o loadEnv({ ns })`)
+  throw new Error(`several services are enrolled (${found.join(', ')}): pick one with DOTRINO_NS=<ns> or loadEnv({ ns })`)
 }
 
 /**
@@ -81,6 +81,9 @@ function overrideByDefault () {
   return process.env.DOTRINO_ENV_OVERRIDE !== '0'
 }
 
+/** El último bundle que `applyEnv` puso a correr en este proceso (ver `watchEnv`). */
+let lastApplied = null
+
 /**
  * Trae los secretos del ns desde el vault y los pone en `process.env`.
  *
@@ -104,7 +107,7 @@ export async function loadEnv ({ ns, dir, override, wait = true, required = [],
 
   const missing = required.filter((k) => !(k in secrets))
   if (missing.length) {
-    throw new Error(`faltan secretos en el ns "${ns}": ${missing.join(', ')} (agrégalos con \`dotrino-vault secret set ${ns} <CLAVE> <valor>\`)`)
+    throw new Error(`missing secrets in ns "${ns}": ${missing.join(', ')} (add them with \`dotrino-vault secret set ${ns} <KEY> <value>\`)`)
   }
 
   return { ns, secrets, ...applyEnv(secrets, override) }
@@ -130,17 +133,21 @@ export async function loadEnv ({ ns, dir, override, wait = true, required = [],
  * @returns {{injected:string[], overridden:string[], skipped:string[]}}
  */
 export function applyEnv (secrets, override = overrideByDefault()) {
+  // Lo último que este proceso puso a correr. `watchEnv` lo toma como referencia para
+  // comparar, así que cualquier agente que use `loadEnv`/`applyEnv` —o sea, todos—
+  // queda protegido del aviso perdido sin cablear nada.
+  lastApplied = { ...(secrets || {}) }
   const injected = []
   const overridden = []
   const skipped = []
   for (const [k, v] of Object.entries(secrets || {})) {
-    const previo = process.env[k]
-    const tenia = k in process.env
-    if (!override && tenia) { skipped.push(k); continue }
-    const valor = String(v)
-    process.env[k] = valor
+    const previous = process.env[k]
+    const had = k in process.env
+    if (!override && had) { skipped.push(k); continue }
+    const value = String(v)
+    process.env[k] = value
     injected.push(k)
-    if (tenia && previo !== valor) overridden.push(k)
+    if (had && previous !== value) overridden.push(k)
   }
   return { injected, overridden, skipped }
 }
@@ -169,10 +176,22 @@ export function applyEnv (secrets, override = overrideByDefault()) {
  * el supervisor ya trae backoff y tope de intentos, que es justo lo que evita que
  * una configuración rota se convierta en un ciclo.
  *
+ * No depende solo del aviso: al conectar COMPARA su configuración con la de la bóveda
+ * (`watchSecretsChanges`), porque un agente incomunicado se pierde el aviso y antes se
+ * quedaba con lo viejo para siempre.
+ *
+ * OJO con lo que se compara: el bundle de la bóveda contra el bundle de la bóveda,
+ * nunca contra el `.env`. Recibir la configuración por primera vez —tarde, que es como
+ * la recibe el proxio— **no** es un cambio, y por eso esto no puede convertirse en un
+ * ciclo de reinicios.
+ *
  * @param {Object} [opts]
  * @param {string} [opts.ns]
  * @param {string} [opts.dir]
- * @param {(info:{ns:string, ts:number, reason:'changed'|'revoked'})=>void} [opts.onUpdate]
+ * @param {Record<string,string>} [opts.applied]  Lo que este proceso tiene EN USO. Por
+ *   defecto, lo último que pasó por `applyEnv` en este proceso — o sea, lo que puso a
+ *   correr `loadEnv`.
+ * @param {(info:{ns:string, ts:number, reason:'changed'|'revoked', via?:'notice'|'reconcile'})=>void} [opts.onUpdate]
  *   Reemplaza la salida por defecto. Úsalo cuando terminar el proceso no sea una
  *   opción — el caso del proxio, cuyo reinicio corta el transporte de todos.
  * @param {number} [opts.exitCode=0]  Salida LIMPIA: systemd con `Restart=on-failure`
@@ -180,27 +199,28 @@ export function applyEnv (secrets, override = overrideByDefault()) {
  *   también. Se elige 0 porque salir a propósito no es un fallo.
  * @returns {Promise<{stop:()=>void}>}
  */
-export async function watchEnv ({ ns, dir, onUpdate, exitCode = 0, quiet = false, ...resto } = {}) {
+export async function watchEnv ({ ns, dir, applied = lastApplied ?? undefined, onUpdate, exitCode = 0, quiet = false, ...rest } = {}) {
   ns = resolveNs(ns)
   dir = dir || serviceDir(ns)
   const say = (m) => { if (!quiet) console.error(m) }
 
   const exitNow = (reason) => {
     say(`[dotrino-env] ${reason === 'revoked'
-      ? 'la bóveda REVOCÓ este agente: terminando (no volverá a arrancar)'
-      : 'configuración nueva en la bóveda: terminando para que el supervisor lo levante limpio'}`)
+      ? 'the vault REVOKED this agent: exiting (it will not start again)'
+      : 'new config in the vault: exiting so the supervisor brings it back clean'}`)
     process.exit(reason === 'revoked' ? 1 : exitCode)
   }
 
   return watchSecretsChanges({
     dir,
     ns,
+    applied,
     log: say,
-    onChange: ({ ts }) => (onUpdate ? onUpdate({ ns, ts, reason: 'changed' }) : exitNow('changed')),
+    onChange: ({ ts, via }) => (onUpdate ? onUpdate({ ns, ts, reason: 'changed', via }) : exitNow('changed')),
     // Un cert revocado sale con código de FALLO a propósito: si el supervisor lo
     // levanta, va a morir otra vez al no poder leer sus secretos, y el contador de
     // reinicios fallidos es lo que hace que se note en vez de girar en silencio.
     onRevoked: () => (onUpdate ? onUpdate({ ns, ts: Date.now(), reason: 'revoked' }) : exitNow('revoked')),
-    ...resto
+    ...rest
   })
 }

package/lib/src/envtext.js

@@ -0,0 +1,94 @@
+/**
+ * Lector de `.env` — el formato en el que la gente YA tiene la configuración de un
+ * servicio, y por lo tanto la forma natural de cargarla entera de una vez.
+ *
+ * Existe aquí, en la lib pura, porque lo usan los tres sitios desde los que se cargan
+ * variables: el CLI (`secret import`), la TUI y la consola remota (pegar el bloque en
+ * la web). Tres lectores distintos serían tres formatos distintos.
+ *
+ * POR QUÉ ESTO IMPORTA MÁS DE LO QUE PARECE: cada variable guardada suelta es, para la
+ * bóveda, un cambio de configuración, y el servicio obedece el primero —sale y lo
+ * levanta su supervisor— mientras el dueño sigue tecleando las demás. Cargarlas juntas
+ * es lo que hace que el servicio se reinicie UNA vez, con todo puesto.
+ *
+ * Los errores salen como CÓDIGOS, no como frases: quien llama los traduce (el CLI en
+ * español, la consola en los dos idiomas).
+ */
+import { isValidVarKey } from './protocol.js'
+
+/**
+ * `CLAVE=valor` — la clave no lleva espacios ni `=`; el valor puede llevar de todo. Se
+ * toleran los espacios alrededor del `=` porque un `.env` escrito a mano los trae, y
+ * rechazar un archivo entero por eso sería quisquilloso sin ganar nada.
+ */
+export const PAIR_RE = /^([^=\s]+)\s*=\s*([\s\S]*)$/
+
+/**
+ * @param {string} text
+ * @returns {{items: Array<{op:'set', key:string, value:string}>,
+ *            errors: Array<{code:'shape'|'dup'|'key'|'novalue'|'empty', line?:number, key?:string, first?:number}>}}
+ */
+export function parseEnvText (text) {
+  /** @type {Array<{op:'set', key:string, value:string}>} */
+  const items = []
+  /** @type {Array<{code:'shape'|'dup'|'key'|'novalue'|'empty', line?:number, key?:string, first?:number}>} */
+  const errors = []
+  const seen = new Map()
+  const lines = String(text || '').split(/\r?\n/)
+
+  lines.forEach((raw, idx) => {
+    const line = idx + 1
+    const trimmed = raw.trim()
+    // Línea vacía o comentario entero. Un `#` a MITAD de línea NO se corta: una
+    // contraseña puede llevarlo, y recortar el valor ahí lo estropea en silencio —que
+    // en un secreto significa un servicio que no levanta y nadie sabe por qué.
+    if (!trimmed || trimmed.startsWith('#')) return
+    const m = PAIR_RE.exec(trimmed.replace(/^export\s+/, ''))
+    if (!m) return errors.push({ code: 'shape', line })
+
+    const key = m[1]
+    const value = unquote(m[2].trim())
+    if (!isValidVarKey(key)) return errors.push({ code: 'key', line, key })
+    if (!value) return errors.push({ code: 'novalue', line, key })
+    // Repetida = casi siempre un pegado a medias. Adivinar cuál de las dos quería el
+    // dueño no es asunto de un lector de configuración.
+    if (seen.has(key)) return errors.push({ code: 'dup', line, key, first: seen.get(key) })
+    seen.set(key, line)
+    items.push({ op: 'set', key, value })
+  })
+
+  if (!items.length && !errors.length) errors.push({ code: 'empty' })
+  return { items, errors }
+}
+
+/**
+ * Lo mismo, pero aceptando que todo venga en UNA línea (`K=v K2=v2`), que es lo que se
+ * puede escribir en un campo de una sola línea como el de la TUI. Un valor con espacios
+ * va entre comillas, igual que en la shell.
+ */
+export function parseEnvInput (text) {
+  const s = String(text || '')
+  return parseEnvText(/\r?\n/.test(s) ? s : tokenize(s).join('\n'))
+}
+
+/** Parte por espacios, pero no dentro de comillas. */
+function tokenize (line) {
+  const out = []
+  let cur = ''
+  let quote = null
+  for (const ch of line) {
+    if (quote) { cur += ch; if (ch === quote) quote = null; continue }
+    if (ch === '"' || ch === "'") { quote = ch; cur += ch; continue }
+    if (/\s/.test(ch)) { if (cur) { out.push(cur); cur = '' } ; continue }
+    cur += ch
+  }
+  if (cur) out.push(cur)
+  return out
+}
+
+/** Quita las comillas de FUERA: un `.env` las usa cuando el valor lleva espacios. */
+function unquote (v) {
+  const q = v[0]
+  if (v.length > 1 && (q === '"' || q === "'") && v.endsWith(q)) return v.slice(1, -1)
+  return v
+}

package/lib/src/index.js

@@ -52,7 +52,7 @@ export { deviceIdOf }
  */
 export async function startDeviceVault (identity, { proxyUrl, client: injectedClient } = {}) {
   const iss = identity.me?.publickey
-  if (!iss) throw new Error('sin identidad: crea/desbloquea tu identidad antes de usar el dispositivo como bóveda')
+  if (!iss) throw new Error('no identity: create/unlock your identity before using this device as a vault')
   const proxy = proxyUrl || 'wss://proxy.dotrino.com'
 
   // ----- self-cert P ← P (para que este dispositivo pueda además actuar de cliente
@@ -133,7 +133,7 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
    */
   async function handleRenew (from, p) {
     const d = p?.data
-    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'petición inválida' })
+    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'invalid request' })
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
       return send(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
     }
@@ -151,10 +151,10 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   // QUIEN consulta es una máquina ya revocada (reapareció), le re-emite el REVOKED firmado.
   async function handleDevices (from, p) {
     const d = p?.data
-    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'petición inválida' })
+    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'invalid request' })
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) return
     const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss })
-    if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason })
+    if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
     const { issued, revoked, revokedCerts } = await identity.listDelegations()
     const devices = await Promise.all((issued || []).map(async (x) => ({
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null,

package/lib/src/invite.js

@@ -392,16 +392,16 @@ export function parseInvite (text) {
   // el original.
   const undoUrl = (s) => { try { return decodeURIComponent(s) } catch { return s } }
 
-  const marca = payload[0]
-  const resto = payload.slice(1)
-  if (marca === FMT_SHORT) { const o = shortDecode(resto); if (o) return o }
-  if (marca === FMT_COMPACT) { const o = compactDecode(resto); if (o) return o }
-  if (marca === FMT_JSON) { const o = parse(undoUrl(resto)) || parse(resto); if (o) return o }
-  if (marca === FMT_B64) { const s = b64urlDecodeStr(resto); const o = s && parse(s); if (o) return o }
+  const tag = payload[0]
+  const rest = payload.slice(1)
+  if (tag === FMT_SHORT) { const o = shortDecode(rest); if (o) return o }
+  if (tag === FMT_COMPACT) { const o = compactDecode(rest); if (o) return o }
+  if (tag === FMT_JSON) { const o = parse(undoUrl(rest)) || parse(rest); if (o) return o }
+  if (tag === FMT_B64) { const s = b64urlDecodeStr(rest); const o = s && parse(s); if (o) return o }
 
   // --- sin marca: formatos anteriores a la marca de formato (compatibilidad) ---
-  const crudo = undoUrl(payload)
-  if (crudo.trimStart().startsWith('{')) return parse(crudo)
+  const raw = undoUrl(payload)
+  if (raw.trimStart().startsWith('{')) return parse(raw)
   const s = b64urlDecodeStr(payload)
   return s ? parse(s) : null
 }

package/lib/src/protocol.js

@@ -33,6 +33,11 @@ export const MSG = Object.freeze({
   ACTA_SEALED: 'vault.acta.sealed',           // dispositivo → vault: { acta, code }
   ACTA_ADOPTED: 'vault.acta.adopted',         // vault → dispositivo: { acta }
   REVOKED: 'vault.revoked',                   // vault → dispositivo: { body:{op,sub,nonce,iat,exp}, signature }
+  // «¿sigo siendo de esta casa?» — la ÚNICA pregunta que se puede hacer SIN certificado:
+  // va firmada con la llave del propio aparato, que es lo que el acta nombra. Existe para
+  // el aparato que perdió su papel: sin ella no tiene forma de enterarse de que lo echaron.
+  CHECK: 'vault.check',                       // dispositivo → vault: { data:{op:'check',publickey,ts}, signature }
+  CHECKED: 'vault.checked',                   // vault → dispositivo: { in:boolean } — y si no, el REVOKED firmado
   SIGN: 'vault.sign',                         // dispositivo → vault: { data, signature, cert }
   SIGNED: 'vault.signed',                     // vault → dispositivo: { signature, publickey, device }
   GET: 'vault.get',                           // dispositivo → vault: { data, signature, cert }
@@ -61,6 +66,16 @@ export const MSG = Object.freeze({
   // Va FIRMADO por la maestra y el agente lo verifica contra su `iss` pineada: un
   // aviso de reinicio sin autenticar ES un ataque de denegación.
   SECRETS_CHANGED: 'vault.secrets.changed',   // vault → servicio: { body:{op,ns,ts}, signature }
+  // REPARTIR LA LLAVE DE UN CAJÓN A UN MIEMBRO NUEVO. Lo hace el SERVICIO y no la
+  // bóveda, porque la bóveda no puede abrir la llave sin la frase y el servicio ya la
+  // tiene: re-envolverla no le añade ningún poder. Ver `docs/secretos-sellados.md` §8.11.
+  //
+  // El servicio NO se fía de lo que le manden: comprueba la firma de la maestra, comprueba
+  // el ACTA que viene dentro (también firmada) y saca de ahí la llave pública del
+  // destinatario. Así, ni siquiera una bóveda comprometida puede hacerle envolver la
+  // llave para alguien que la maestra no haya metido en su propio cajón.
+  REWRAP: 'vault.rewrap',                     // vault → servicio: { body:{op,owner,gen,wrap,target,acta,ts}, signature }
+  REWRAP_OK: 'vault.rewrap.ok',               // servicio → vault: { data:{op,owner,gen,target,wrap,ts}, signature, cert }
   // --- CONSOLA REMOTA (docs/consola-remota.md) — requiere cert `vault:admin` ---
   // Un solo mensaje con `data.op`: pending · pair · approve · reject · revoke · audit.
   // Admitir y expulsar, nada más: cambiar permisos, traspasar el mando y los secretos
@@ -93,3 +108,10 @@ export const SCOPE = Object.freeze({
 export const SECRETS_SCOPE_PREFIX = 'vault:secrets:'
 export const secretsScope = (ns) => SECRETS_SCOPE_PREFIX + ns
 export const isValidSecretsNs = (ns) => typeof ns === 'string' && /^[a-z0-9-]{1,32}$/.test(ns)
+
+/**
+ * Nombre de una variable de entorno: `MAYUSCULAS_CON_GUION_BAJO`, hasta 64. Vive aquí
+ * —y no en el cajón que la guarda— porque la comprueban también la TUI, la consola
+ * remota y el lector de `.env`, y tres copias de una regla son tres reglas.
+ */
+export const isValidVarKey = (key) => typeof key === 'string' && /^[A-Z0-9_]{1,64}$/.test(key)