@dotrino/vault 0.75.0 → 0.76.0

package/bin/dotrino-env.js

@@ -16,7 +16,8 @@ import fs from 'node:fs'
 import path from 'node:path'
 import readline from 'node:readline/promises'
 import { spawn } from 'node:child_process'
-import { enrollService, readServiceIdentity, fetchSecrets } from '../src/service.js'
+import { enrollService, readServiceIdentity, fetchSecrets, storeVars } from '../src/service.js'
+import { parseEnvText, parseEnvInput } from '../src/envtext.js'
 import { loadEnv, serviceDir, serviceRoot, listEnrolled, resolveNs, resolveVaultLabel, isValidVaultLabel } from '../src/env.js'
 // Se usaba sin importarlo: `enroll` —el comando principal— moría con
 // «sharedParseInvite is not defined» en cuanto tocaba una invitación. Nunca
@@ -88,6 +89,16 @@ function help () {
                          qué aparato es cada servicio de esta máquina: su ID (el de
                          «dotrino-vault members»), su bóveda, sus permisos. Sin red.
   status                 servicios enrolados en esta máquina
+  import [<archivo>] [--ns <ns>] [--vault <bóveda>] [--public K1,K2 | --all-public]
+        [--link <dir>]
+                         sube un .env (por defecto ./.env) al cajón de ESTE servicio. Se
+                         sella aquí; la bóveda no ve los valores. Si hay quien apruebe, se
+                         pide aprobación y al aprobar también puede cambiar las que ya
+                         existen; si nadie puede aprobar, solo añade las que faltan.
+                         Borrar, nunca: eso se hace en la bóveda. --link usa el enlace de
+                         un agente (link.json) en vez de la identidad de dotrino-env.
+  set K=v [K2=v2 …] [--ns <ns>] [--public K1,K2 | --all-public] [--link <dir>]
+                         lo mismo, con los valores en la orden
   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
@@ -283,6 +294,80 @@ async function cmdInfo () {
   console.log(infos.map(formatDeviceInfo).join('\n\n'))
 }
 
+/**
+ * `import` y `set`: SUBIR VARIABLES AL CAJÓN DE ESTE SERVICIO (dueño, 2026-09-29: «para
+ * facilitar la migración de ENVs a Dotrino»). El `.env` de la máquina sube tal cual; qué
+ * se guarda y cuándo lo decide la bóveda (`storeVars`): con aprobación puede editar, sin
+ * ella solo añade, y borrar no existe por aquí.
+ */
+async function cmdStore (fromFile) {
+  let parsed
+  if (fromFile) {
+    const file = argv[1] && !argv[1].startsWith('--') ? argv[1] : '.env'
+    let text
+    try { text = fs.readFileSync(file, 'utf8') } catch (e) { console.error('no puedo leer %s: %s', file, e.message); process.exit(1) }
+    parsed = parseEnvText(text)
+  } else {
+    const pares = []
+    for (let i = 1; i < argv.length; i++) {
+      if (argv[i].startsWith('--')) { if (!['--all-public'].includes(argv[i])) i++; continue }
+      pares.push(argv[i])
+    }
+    parsed = parseEnvInput(pares.join(' '))
+  }
+  // UN ERROR PARA TODO: una línea mal escrita no se sube a medias, se dice y se para.
+  if (parsed.errors.length) {
+    for (const e of parsed.errors) {
+      console.error(e.code === 'dup' ? `  línea ${e.line}: ${e.key} repetida (ya estaba en la línea ${e.first})`
+        : e.code === 'novalue' ? `  línea ${e.line}: ${e.key} sin valor`
+          : e.code === 'key' ? `  línea ${e.line}: «${e.key}» no es un nombre de variable válido`
+            : e.code === 'empty' ? '  no hay ninguna variable'
+              : `  línea ${e.line}: no tiene la forma CLAVE=valor`)
+    }
+    console.error('No se subió nada. Corrige lo de arriba y vuelve a intentarlo.')
+    process.exit(1)
+  }
+  const allPublic = argv.includes('--all-public')
+  const publicas = new Set(String(flag('public') || '').split(',').map((k) => k.trim()).filter(Boolean))
+  const desconocidas = [...publicas].filter((k) => !parsed.items.some((it) => it.key === k))
+  if (desconocidas.length) { console.error('--public nombra variables que no se van a subir: %s', desconocidas.join(', ')); process.exit(2) }
+  const vars = parsed.items.map((it) => ({ key: it.key, value: it.value, public: allPublic || publicas.has(it.key) }))
+
+  // DE QUIÉN: la identidad de dotrino-env o, con --link, el enlace de un agente (terminal,
+  // ia, content…), que es un aparato con cajón igual que cualquier servicio.
+  let who
+  const linkDir = flag('link')
+  if (linkDir) {
+    let link
+    try { link = JSON.parse(fs.readFileSync(path.join(linkDir, 'link.json'), 'utf8')) } catch (e) { console.error('no puedo leer %s/link.json: %s', linkDir, e.message); process.exit(1) }
+    const ns = flag('ns') || link.ns
+    if (!ns) { console.error('ese enlace no dice su cajón: pásalo con --ns <ns>'); process.exit(2) }
+    who = { ns, proxyUrl: link.proxy, masterPubkey: link.iss, device: link.device, cert: link.cert, dondeDice: `${linkDir} (cajón ${ns})` }
+  } else {
+    const ns = resolveNs(flag('ns'))
+    const dir = serviceDir(etiquetaBoveda(), ns)
+    who = { dir, ns, dondeDice: `${path.basename(path.dirname(dir))}/${ns}` }
+  }
+
+  const pub = vars.filter((v) => v.public).map((v) => v.key)
+  console.log('Subiendo %d variable(s) a %s: %s', vars.length, who.dondeDice, vars.map((v) => v.key).join(', '))
+  if (pub.length) console.log('  públicas: %s', pub.join(', '))
+  const { dondeDice, ...ident } = who
+  const r = await storeVars({ ...ident, vars }).catch((e) => {
+    if (e.code === 'exists') {
+      console.error('\n%s\nSin nadie que pueda aprobar, desde aquí solo se añaden variables nuevas. Para cambiar una que ya existe, hazlo en la bóveda (dotrino-vault secret set) o dale a alguien el permiso de aprobar.', e.message)
+    } else console.error('\nno se pudo subir: %s', e.message)
+    process.exit(1)
+  })
+  if (r.pending) {
+    console.log('\nPedido de aprobación enviado (%s). Apruébalo en un aparato con «aprueba»:', r.pending)
+    console.log('se guardarán al aprobar. Con la aprobación también se pueden cambiar las que ya existían.')
+  } else {
+    console.log('\nGuardadas: %s', r.keys.join(', '))
+    console.log('(nadie en tu cuenta puede aprobar, así que solo se añaden las que faltaban)')
+  }
+}
+
 async function cmdCheck () {
   const ns = resolveNs(flag('ns'))
   // `fetchSecrets` y no `loadEnv`: listar NO debe tener efectos secundarios. Con
@@ -377,6 +462,8 @@ const run = async () => {
     case 'enroll': return cmdEnroll()
     case 'status': return cmdStatus()
     case 'info': return cmdInfo()
+    case 'import': return cmdStore(true)
+    case 'set': return cmdStore(false)
     case 'check': return cmdCheck()
     case 'run': return cmdRun()
     case 'ssh-agent': return cmdSshAgent()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.75.0",
+  "version": "0.76.0",
   "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/service.js

@@ -512,6 +512,75 @@ export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device,
   } finally { client.close() }
 }
 
+/**
+ * GUARDA VARIABLES EN EL CAJÓN DE ESTE SERVICIO (dueño, 2026-09-29: «para facilitar la
+ * migración de ENVs a Dotrino»). Es lo que hay detrás de `dotrino-env import`.
+ *
+ * Los valores se sellan AQUÍ, en la máquina del servicio, para quien diga el acta; la
+ * bóveda recibe sobres que no abre. La lista de destinatarios la firma la bóveda y se
+ * comprueba (`verifyResponder`): si el proxio pudiera cambiarla por sus llaves, abriría las
+ * privadas al pasar.
+ *
+ * Lo que decide la bóveda, no este cliente:
+ *   · si hay quien apruebe, se pide aprobación siempre, y al aprobarse puede EDITAR;
+ *   · si nadie puede aprobar, solo AÑADE lo que falta (una que ya exista falla con `exists`);
+ *   · BORRAR no existe por aquí.
+ *
+ * @param {object} o
+ * @param {Array<{ key:string, value:string, public?:boolean }>} o.vars
+ * @param {string} [o.dir]  identidad de `dotrino-env` (`service-identity.json`); o, en su
+ *   lugar, la identidad por parámetros (`ns`, `proxyUrl`, `masterPubkey`, `device`, `cert`),
+ *   que es como la trae un agente de remote-agent.
+ * @returns {Promise<{ keys: string[], pending: string|null, approval: boolean }>}
+ *   `pending`: el id del pedido de aprobación (se guarda al aprobar); `keys`: lo guardado ya.
+ */
+export async function storeVars ({ dir, ns, proxyUrl, masterPubkey, device, cert, vars, timeoutMs = 30000 } = {}) {
+  const saved = dir ? readServiceIdentity(dir) : null
+  ns = ns || saved?.ns
+  proxyUrl = proxyUrl || saved?.proxy
+  masterPubkey = masterPubkey || saved?.iss
+  device = device || saved?.device
+  cert = cert || saved?.cert
+  if (!isValidSecretsNs(ns)) throw new Error('invalid ns')
+  if (!proxyUrl || !masterPubkey || !device || !cert) throw new Error('service not enrolled')
+  if (!Array.isArray(vars) || !vars.length) throw new Error('storeVars: no variables to store')
+  for (const v of vars) {
+    if (typeof v?.key !== 'string' || !v.key) throw new Error('storeVars: every variable needs a key')
+    if (typeof v.value !== 'string' || !v.value) throw Object.assign(new Error(`storeVars: "${v.key}" has no value`), { code: 'novalue' })
+  }
+
+  const client = await freshClient(proxyUrl, 20000, masterPubkey)
+  try {
+    await identifyAsService(client, device)
+    const ask = async (data) => {
+      const signed = { ...data, ns, publickey: device.publickey, ts: Date.now() }
+      const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data: signed })
+      const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs)
+      client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data: signed, signature, cert })
+      const res = await pending
+      if (res.type === MSG.ERROR) throw vaultError(res)
+      await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey, knownSeq: saved?.actaSeq ?? null })
+      if (res.body?.op !== data.op.replace(/^store$/, 'store.result') || res.body?.ns !== ns) throw new Error('the vault answered something else')
+      return res.body
+    }
+
+    const { recipients, approval } = await ask({ op: 'store.recipients' })
+    const { buildSealedVar, authorFromDeviceKey } = await import('./admin.js')
+    const author = authorFromDeviceKey(device)
+    const items = []
+    for (const v of vars) {
+      const sealed = await buildSealedVar({
+        recipients: v.public ? recipients.public : recipients.private,
+        owner: `ns:${ns}`, key: v.key, value: v.value, author
+      })
+      items.push({ key: v.key, sealed, public: !!v.public })
+    }
+    const nonce = [...crypto.getRandomValues(new Uint8Array(16))].map((x) => x.toString(16).padStart(2, '0')).join('')
+    const r = await ask({ op: 'store', items, nonce })
+    return { keys: r.keys || [], pending: r.pending || null, approval: !!approval }
+  } finally { client.close() }
+}
+
 /**
  * Pide los secretos del ns al vault (una petición puntual; lanza si falla).
  * Usa la identidad persistida por `enrollService` salvo que se pase explícita.