@dotrino/vaultd 0.26.2 → 0.38.0

package/src/ctl.js

@@ -25,6 +25,8 @@ import path from 'node:path'
 import { execFileSync } from 'node:child_process'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir, readJson } from './paths.js'
+import { assertVar } from './secretsStore.js'
+import { parseEnvText, PAIR_RE } from '../lib/src/envtext.js'
 import { qrToString } from './qr.js'
 import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
 import { VERSION } from './version.js'
@@ -49,7 +51,18 @@ function takeProfileFlag (args) {
 }
 /** Campo `profile` de las peticiones al daemon (omitido = perfil activo). */
 const withProfile = (obj) => (PROFILE ? { ...obj, profile: PROFILE } : obj)
-const writeReq = (name, obj) => fs.writeFileSync(path.join(dir, name), JSON.stringify(withProfile({ ...obj, at: Date.now() })), { mode: 0o600 })
+/**
+ * Deja una petición para el daemon. ATÓMICA (escribir aparte y renombrar): el daemon
+ * vigila la carpeta con `fs.watch`, que avisa al CREAR el archivo y no al terminar de
+ * escribirlo, así que escrito en el sitio se puede leer a medias — y una petición que no
+ * parsea se pierde con todos sus datos.
+ */
+const writeReq = (name, obj) => {
+  const dest = path.join(dir, name)
+  const tmp = dest + '.tmp'
+  fs.writeFileSync(tmp, JSON.stringify(withProfile({ ...obj, at: Date.now() })), { mode: 0o600 })
+  fs.renameSync(tmp, dest)
+}
 
 const R = '\x1b[31m', B = '\x1b[1m', Z = '\x1b[0m' // rojo / negrita / reset
 // La versión se inyecta en build (esbuild --define); en dev cae a 'dev'.
@@ -60,13 +73,13 @@ const R = '\x1b[31m', B = '\x1b[1m', Z = '\x1b[0m' // rojo / negrita / reset
  * contenedor, así que decir siempre «systemctl» manda a la mitad de la gente a un
  * comando que no existe.
  */
-const EN_DOCKER = !!process.env.DOTRINO_IN_DOCKER
-const START_HINT = EN_DOCKER
+const IN_DOCKER = !!process.env.DOTRINO_IN_DOCKER
+const START_HINT = IN_DOCKER
   ? 'docker start dotrino-vault'
   : process.platform === 'linux'
     ? 'systemctl --user start dotrino-vault'
     : 'dotrino-vaultd   (o: npx -y @dotrino/vaultd)'
-const RESTART_HINT = EN_DOCKER
+const RESTART_HINT = IN_DOCKER
   ? 'docker restart dotrino-vault'
   : process.platform === 'linux'
     ? 'systemctl --user restart dotrino-vault'
@@ -88,7 +101,7 @@ function alive (pid) { try { return !!pid && (process.kill(pid, 0) || true) } ca
  * vigila la carpeta igualmente, así que la petición se atiende en cuanto se escribe el
  * archivo; la señal solo se ahorra la latencia del watcher.
  */
-function avisar (pid, sig) { try { process.kill(pid, sig) } catch (_) { /* Windows, o el daemon ya se enteró */ } }
+function sendSignal (pid, sig) { try { process.kill(pid, sig) } catch (_) { /* Windows, o el daemon ya se enteró */ } }
 function sleep (ms) { return new Promise((r) => setTimeout(r, ms)) }
 function requireDaemon () {
   const s = readState()
@@ -138,6 +151,20 @@ function showChallenge (pe) {
   console.log('  Si no reconoces este dispositivo:  dotrino-vault reject %s\n', pe.deviceId)
 }
 
+/**
+ * EL CANDADO. Un perfil con contraseña y bloqueado no se ve ni se toca desde esta consola:
+ * el daemon contesta `locked` y sin contenido, y aquí se corta con un mensaje que dice qué
+ * hacer. Los aparatos ya emparejados siguen atendidos — lo que está cerrado es esta
+ * pantalla, no la bóveda.
+ */
+function assertOpen (d) {
+  if (d?.locked) {
+    console.error('Perfil bloqueado. Ábrelo con:  dotrino-vault unlock')
+    process.exit(1)
+  }
+  return d
+}
+
 async function cmdPair (args = []) {
   const s = requireDaemon()
   try { fs.rmSync(pairFile, { force: true }) } catch (_) {}
@@ -184,10 +211,15 @@ async function cmdPair (args = []) {
   // La petición se escribe SIEMPRE (aunque no haya --service): lleva a qué perfil
   // se empareja el dispositivo.
   writeReq('pair-request.json', { ...(service ? { service } : {}), ...(adopt ? { mode: 'adopt' } : {}) })
-  avisar(s.pid, 'SIGUSR1')
+  sendSignal(s.pid, 'SIGUSR1')
 
   let pair = null
-  for (let i = 0; i < 50; i++) { await sleep(100); const p = readJson(pairFile, null); if (p?.expiresAt > Date.now()) { pair = p; break } }
+  for (let i = 0; i < 50; i++) {
+    await sleep(100)
+    const p = readJson(pairFile, null)
+    assertOpen(p) // el candado se contesta por el mismo archivo, para no dejar esperando
+    if (p?.expiresAt > Date.now()) { pair = p; break }
+  }
   if (!pair) { console.error('No se recibió respuesta del daemon para el emparejamiento.'); process.exit(1) }
 
   // Una sola forma para las dos cosas: la invitación compacta (base64url de ~100
@@ -237,7 +269,7 @@ function cmdApprove (code) {
   if (!code) { console.error('uso: dotrino-vault approve <código>   (los dígitos que muestra el dispositivo)'); process.exit(2) }
   const s = requireDaemon()
   writeReq('approve-request.json', { code: String(code) })
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   console.log('Aprobando con el código %s… verifica con: dotrino-vault devices', code)
 }
 
@@ -245,7 +277,7 @@ function cmdReject (deviceId) {
   if (!deviceId) { console.error('uso: dotrino-vault reject <deviceId>'); process.exit(2) }
   const s = requireDaemon()
   writeReq('reject-request.json', { deviceId })
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   console.log('Rechazado %s.', deviceId)
 }
 
@@ -265,12 +297,13 @@ async function cmdMe () {
   const meFile = path.join(dir, 'me.json')
   try { fs.rmSync(meFile, { force: true }) } catch (_) {}
   writeReq('me-request.json', {})
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   let dump = null
   for (let n = 0; n < 50; n++) { await sleep(100); const d = readJson(meFile, null); if (d?.at) { dump = d; break } }
   // El volcado es contenido del usuario: se lee y se BORRA, no se queda ahí suelto.
   try { fs.rmSync(meFile, { force: true }) } catch (_) {}
   if (!dump) { console.error('La bóveda no respondió. ¿Está corriendo?  dotrino-vault status'); process.exit(1) }
+  assertOpen(dump)
 
   const me = dump.me
   if (!me) {
@@ -279,8 +312,8 @@ async function cmdMe () {
     return
   }
 
-  const cuando = me.updatedAt ? new Date(me.updatedAt).toLocaleString() : '—'
-  console.log('\n%sPerfil%s · actualizado %s\n', B, Z, cuando)
+  const when = me.updatedAt ? new Date(me.updatedAt).toLocaleString() : '—'
+  console.log('\n%sPerfil%s · actualizado %s\n', B, Z, when)
   console.log('  nombre      : %s', me.nickname || '(sin nombre)')
   console.log('  foto        : %s', me.avatar
     ? `sí · ${me.avatar.type || 'desconocido'} · ${(me.avatar.bytes / 1024).toFixed(1)} KB`
@@ -289,17 +322,17 @@ async function cmdMe () {
   // Los campos estándar. `visible` es del usuario: teléfono y dirección nacen ocultos.
   const STD = [['nombres', 'nombres'], ['apellidos', 'apellidos'], ['email', 'correo'],
     ['telefono', 'teléfono'], ['direccion', 'dirección']]
-  const puestos = STD.filter(([k]) => me[k])
-  if (puestos.length) {
+  const filled = STD.filter(([k]) => me[k])
+  if (filled.length) {
     console.log('')
-    for (const [k, etiqueta] of puestos) {
-      console.log('  %s: %s%s', etiqueta.padEnd(12), me[k], me[k + 'Visible'] === false ? '   (oculto)' : '')
+    for (const [k, label] of filled) {
+      console.log('  %s: %s%s', label.padEnd(12), me[k], me[k + 'Visible'] === false ? '   (oculto)' : '')
     }
   }
-  for (const [titulo, lista] of [['Enlaces', me.links], ['Otros datos', me.fields]]) {
-    if (!Array.isArray(lista) || !lista.length) continue
-    console.log('\n  %s:', titulo)
-    for (const x of lista) console.log('    %s %s%s', (x.type || x.label || '').padEnd(12), x.value, x.visible === false ? '   (oculto)' : '')
+  for (const [title, list] of [['Enlaces', me.links], ['Otros datos', me.fields]]) {
+    if (!Array.isArray(list) || !list.length) continue
+    console.log('\n  %s:', title)
+    for (const x of list) console.log('    %s %s%s', (x.type || x.label || '').padEnd(12), x.value, x.visible === false ? '   (oculto)' : '')
   }
 
   console.log('')
@@ -311,30 +344,31 @@ async function cmdMe () {
  */
 async function cmdMembers () {
   const s = requireDaemon()
-  const actaFile = path.join(dataDir(), 'acta.json')
-  try { fs.rmSync(actaFile, { force: true }) } catch (_) {}
+  const recordFile = path.join(dataDir(), 'acta.json')
+  try { fs.rmSync(recordFile, { force: true }) } catch (_) {}
   writeReq('dump-request.json', {})
-  avisar(s.pid, 'SIGUSR2')
-  let acta = null
-  for (let i = 0; i < 50; i++) { await sleep(100); const a = readJson(actaFile, null); if (a?.at) { acta = a; break } }
-  if (!acta) { console.error('El daemon no respondió.'); process.exit(1) }
-  if (!acta.members?.length) { console.log('Este perfil todavía no tiene acta.'); return }
+  sendSignal(s.pid, 'SIGUSR2')
+  let record = null
+  for (let i = 0; i < 50; i++) { await sleep(100); const a = readJson(recordFile, null); if (a?.at) { record = a; break } }
+  if (!record) { console.error('El daemon no respondió.'); process.exit(1) }
+  assertOpen(record)
+  if (!record.members?.length) { console.log('Este perfil todavía no tiene acta.'); return }
 
   const CAP = { sign: 'firma', store: 'guarda', read: 'lee', secrets: 'lee sus claves', admin: `${B}administra el perfil${Z}` }
   // El nombre del perfil es una pubkey JWK. Recortarla no la hace legible: la deja
   // pareciendo un error (`{"key_ops":["verify"],"e…`). Se muestra su huella corta, la
   // misma que se enseña al emparejar y en la lista de miembros.
-  const perfilId = await deviceIdOf(acta.profileId).catch(() => '????-????')
-  console.log('\n%sPerfil%s %s · acta #%d\n', B, Z, perfilId, acta.seq)
-  for (const m of acta.members) {
-    const quien = m.label || m.id
-    const marcas = [
+  const profileId = await deviceIdOf(record.profileId).catch(() => '????-????')
+  console.log('\n%sPerfil%s %s · acta #%d\n', B, Z, profileId, record.seq)
+  for (const m of record.members) {
+    const who = m.label || m.id
+    const marks = [
       m.isMaster ? `${B}Master${Z}` : null,
       m.isMe ? 'este dispositivo' : null,
       m.cn ? `servicio «${m.cn}»` : null
     ].filter(Boolean)
     const caps = m.caps.length ? m.caps.map((c) => CAP[c] || c).join(', ') : '(sin permisos)'
-    console.log('  %s  %s%s\n      %s', m.id, quien, marcas.length ? '  [' + marcas.join(' · ') + ']' : '', caps)
+    console.log('  %s  %s%s\n      %s', m.id, who, marks.length ? '  [' + marks.join(' · ') + ']' : '', caps)
   }
   console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra')
   console.log('  «Administra» deja conectar y quitar dispositivos desde ese aparato, sin venir aquí.')
@@ -350,55 +384,56 @@ async function cmdMembers () {
  * tener que revocar y volver a emparejar.
  */
 async function cmdLabel (args = []) {
-  const [id, ...resto] = args
-  const nombre = resto.join(' ').trim()
-  if (!id || !nombre) {
+  const [id, ...rest] = args
+  const name = rest.join(' ').trim()
+  if (!id || !name) {
     console.error('uso: dotrino-vault label <ID> <nombre>   (p.ej. label AB12-CD34 "Teléfono de casa")')
     process.exit(2)
   }
-  const m = await buscarMiembro(id)
-  writeReq('label-request.json', { pub: m.pub, label: nombre })
-  avisar(requireDaemon().pid, 'SIGUSR2')
-  console.log('Listo: %s ahora se llama «%s». Compruébalo con: dotrino-vault members', m.id, nombre.slice(0, 60))
+  const m = await findMember(id)
+  writeReq('label-request.json', { pub: m.pub, label: name })
+  sendSignal(requireDaemon().pid, 'SIGUSR2')
+  console.log('Listo: %s ahora se llama «%s». Compruébalo con: dotrino-vault members', m.id, name.slice(0, 60))
 }
 
 /** Busca un miembro del acta por su identificador (AB12-CD34) o se rinde con un mensaje claro. */
-async function buscarMiembro (id) {
+async function findMember (id) {
   const s = requireDaemon()
-  const actaFile = path.join(dataDir(), 'acta.json')
-  try { fs.rmSync(actaFile, { force: true }) } catch (_) {}
+  const recordFile = path.join(dataDir(), 'acta.json')
+  try { fs.rmSync(recordFile, { force: true }) } catch (_) {}
   writeReq('dump-request.json', {})
-  avisar(s.pid, 'SIGUSR2')
-  let acta = null
-  for (let i = 0; i < 50; i++) { await sleep(100); const a = readJson(actaFile, null); if (a?.at) { acta = a; break } }
-  const m = acta?.members?.find((x) => x.id === String(id).toUpperCase())
+  sendSignal(s.pid, 'SIGUSR2')
+  let record = null
+  for (let i = 0; i < 50; i++) { await sleep(100); const a = readJson(recordFile, null); if (a?.at) { record = a; break } }
+  assertOpen(record)
+  const m = record?.members?.find((x) => x.id === String(id).toUpperCase())
   if (!m) { console.error('No hay ningún dispositivo con ese identificador. Míralos con: dotrino-vault members'); process.exit(1) }
   return m
 }
 
 /** `dotrino-vault caps <ID> ±permiso` — cambia lo que puede hacer un dispositivo. */
 async function cmdCaps (args = []) {
-  const [id, ...cambios] = args
-  if (!id || !cambios.length) {
+  const [id, ...changes] = args
+  if (!id || !changes.length) {
     console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra')
     process.exit(2)
   }
-  const NOMBRE = {
+  const CAP_BY_WORD = {
     firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin',
     sign: 'sign', store: 'store', read: 'read', admin: 'admin'
   }
   const s = requireDaemon()
-  const m = await buscarMiembro(id)
+  const m = await findMember(id)
 
   const caps = new Set(m.caps)
-  for (const c of cambios) {
-    const signo = c[0]
-    const cap = NOMBRE[c.slice(1).toLowerCase()]
-    if (!cap || (signo !== '+' && signo !== '-')) { console.error('permiso no reconocido: %s', c); process.exit(2) }
-    if (signo === '+') caps.add(cap); else caps.delete(cap)
+  for (const c of changes) {
+    const sign = c[0]
+    const cap = CAP_BY_WORD[c.slice(1).toLowerCase()]
+    if (!cap || (sign !== '+' && sign !== '-')) { console.error('permiso no reconocido: %s', c); process.exit(2) }
+    if (sign === '+') caps.add(cap); else caps.delete(cap)
   }
   writeReq('caps-request.json', { pub: m.pub, caps: [...caps] })
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   console.log('Listo. Compruébalo con: dotrino-vault members')
 }
 
@@ -406,25 +441,26 @@ async function cmdDevices () {
   const s = requireDaemon()
   try { fs.rmSync(devFile, { force: true }) } catch (_) {}
   writeReq('dump-request.json', {}) // de qué perfil queremos los dispositivos
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   let snap = null
   for (let i = 0; i < 50; i++) { await sleep(100); const d = readJson(devFile, null); if (d?.at) { snap = d; break } }
   if (!snap) { console.error('El daemon no respondió.'); process.exit(1) }
+  assertOpen(snap)
   const revoked = snap.revoked || []
-  const fuera = new Set(revoked.map((r) => r?.nonce || r))
+  const revokedSet = new Set(revoked.map((r) => r?.nonce || r))
   // UN APARATO, UNA LÍNEA. El daemon lleva la cuenta por CERTIFICADO —correcto para él,
   // porque revocar es revocar un papel—, pero renovar emite uno nuevo cada 30 días: un
   // aparato de un año salía doce veces, y los ya retirados seguían contando como
   // enrolados. Se agrupa por llave y se dice cuántos certificados tiene.
-  const porLlave = new Map()
+  const byKey = new Map()
   for (const d of (snap.issued || snap.active || snap.delegations || [])) {
-    if (d.revokedAt || fuera.has(d.nonce)) continue
-    const clave = d.sub || d.nonce
-    const y = porLlave.get(clave)
-    if (!y) porLlave.set(clave, { ...d, certs: 1 })
+    if (d.revokedAt || revokedSet.has(d.nonce)) continue
+    const key = d.sub || d.nonce
+    const y = byKey.get(key)
+    if (!y) byKey.set(key, { ...d, certs: 1 })
     else { y.certs++; if ((d.exp || 0) > (y.exp || 0)) Object.assign(y, { ...d, certs: y.certs }) }
   }
-  const active = [...porLlave.values()]
+  const active = [...byKey.values()]
   console.log('Dispositivos enrolados: %d', active.length)
   for (const d of active) {
     const did = d.sub ? await deviceIdOf(d.sub) : '????-????'
@@ -454,14 +490,14 @@ async function cmdRevoke (arg) {
   const esId = /^[0-9a-f]{4}-?[0-9a-f]{4}$/i.test(arg)
   const s = requireDaemon()
   if (esId) {
-    const m = await buscarMiembro(arg.toUpperCase().includes('-') ? arg.toUpperCase() : arg.toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'))
+    const m = await findMember(arg.toUpperCase().includes('-') ? arg.toUpperCase() : arg.toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'))
     writeReq('revoke-request.json', { sub: m.pub })
-    avisar(s.pid, 'SIGUSR2')
+    sendSignal(s.pid, 'SIGUSR2')
     console.log('Quitado %s (todos sus certificados). Se autoborrará al reconectar. Verifica: dotrino-vault devices', m.id)
     return
   }
   writeReq('revoke-request.json', { nonce: arg })
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   console.log('Revocación enviada para nonce=%s. El dispositivo se autoborrará al reconectar. Verifica: dotrino-vault devices', arg)
 }
 
@@ -478,6 +514,10 @@ function profileDir () {
     ? list.find((x) => x.id === PROFILE || (x.name || '').toLowerCase() === ref)
     : (list.find((x) => x.current) || list[0])
   if (!p) { console.error('el perfil no existe: %s', PROFILE); process.exit(1) }
+  // El candado también aquí: esto es la única puerta que lee el directorio del perfil sin
+  // pasar por el daemon (la bitácora), y sin esta línea `activity` seguía contando quién
+  // firmó y cuándo con la bóveda cerrada.
+  assertOpen(p)
   return path.join(dir, 'p', p.id)
 }
 
@@ -500,43 +540,265 @@ function cmdActivity (n = 30) {
   }
 }
 
-// Secretos de servicios: se cargan aquí (el dueño, en el PC del vault) y los
-// leen los SERVICIOS enrolados con `pair --service <ns>`. Nunca se listan valores.
+// Variables de entorno de los servicios: se cargan aquí (el dueño, en el PC del vault) y
+// las leen los SERVICIOS enrolados con `pair --service <ns>`. Nunca se listan valores.
+//
+// DOS CAJONES: las del SCOPE (`secret set <ns> …`) las comparten todos los aparatos que
+// sirven ese namespace; las del APARATO (`secret device set <ID> …`) las lee solo ese
+// aparato y PISAN a las del scope con el mismo nombre. Ahí va lo que cambia de máquina a
+// máquina (el puerto, la URL pública) sin tener que partir el ns en uno por servidor.
+/**
+ * `KEY=valor KEY2=valor2` — la forma de CARGAR VARIAS de una vez. Devuelve `null` si no
+ * son todos pares, para que la forma clásica de tres argumentos (`set ns CLAVE valor`,
+ * donde el valor puede llevar espacios y hasta un `=`) siga funcionando igual.
+ */
+function asPairs (args) {
+  if (!args.length) return null
+  const out = []
+  for (const a of args) {
+    const m = PAIR_RE.exec(a)
+    if (!m) return null
+    out.push({ op: 'set', key: m[1], value: m[2] })
+  }
+  return out
+}
+
+/** Un `.env` con un problema no se carga A MEDIAS: se dice qué línea y no se escribe nada. */
+function abortEnv (errors) {
+  console.error('%sNo se cargó nada%s:', R, Z)
+  for (const e of errors) console.error('  · %s', envErrorText(e))
+  process.exit(2)
+}
+
+/** Los códigos del lector de `.env`, en la lengua del CLI. */
+function envErrorText (e) {
+  if (e.code === 'shape') return `línea ${e.line}: no tiene la forma CLAVE=valor`
+  if (e.code === 'key') return `línea ${e.line}: «${e.key}» va en MAYÚSCULAS_CON_GUION_BAJO`
+  if (e.code === 'novalue') return `línea ${e.line}: ${e.key} no tiene valor (para quitarla: secret rm)`
+  if (e.code === 'dup') return `línea ${e.line}: ${e.key} ya venía en la línea ${e.first}`
+  return 'no hay ninguna variable que cargar'
+}
+
+/** El problema de una variable, en español, o `null`. Las reglas son las del cajón. */
+function problemWith (key, value) {
+  try { assertVar(key, value); return null } catch (e) {
+    if (/invalid key/.test(e.message)) return 'el nombre va en MAYÚSCULAS_CON_GUION_BAJO (p. ej. TURN_KEY_ID)'
+    if (/non-empty/.test(e.message)) return 'no tiene valor (para quitarla: secret rm)'
+    if (/too long/.test(e.message)) return 'el valor es demasiado largo'
+    return e.message
+  }
+}
+
 async function cmdSecret (rest) {
-  const [sub, ns, key, ...valueParts] = rest
+  // --public / --private: si el VALOR puede salir de esta máquina hacia la consola remota.
+  // Se sacan de la línea antes de partirla, para que puedan ir en cualquier posición y no
+  // se cuelen dentro del valor (que es lo último y puede llevar espacios).
+  let isPublic
+  const rest2 = rest.filter((a) => {
+    if (a === '--public') { isPublic = true; return false }
+    if (a === '--private') { isPublic = false; return false }
+    return true
+  })
+  const [sub, ...args] = rest2
   const s = requireDaemon()
   const secretsListFile = path.join(dir, 'secrets-list.json')
   const signalAndWaitList = async () => {
     try { fs.rmSync(secretsListFile, { force: true }) } catch (_) {}
     writeReq('dump-request.json', {}) // de qué perfil son los secretos
-    avisar(s.pid, 'SIGUSR2')
-    for (let i = 0; i < 50; i++) { await sleep(100); const d = readJson(secretsListFile, null); if (d?.at) return d }
+    sendSignal(s.pid, 'SIGUSR2')
+    for (let i = 0; i < 50; i++) {
+      await sleep(100)
+      const d = readJson(secretsListFile, null)
+      // El volcado lleva el valor de las públicas: se borra en cuanto se tiene, para que no
+      // se quede esperando en el disco a que copien la carpeta (ver `daemon.js`).
+      if (d?.at) { try { fs.rmSync(secretsListFile, { force: true }) } catch (_) {} ; return assertOpen(d) }
+    }
     console.error('El daemon no respondió.'); process.exit(1)
   }
+  const USAGE = [
+    'uso: dotrino-vault secret set <ns> <CLAVE> <valor> [--public|--private]',
+    '                                                  (la comparten todos los aparatos del ns)',
+    '     dotrino-vault secret set <ns> CLAVE=valor [CLAVE2=valor2 …]   varias DE UNA VEZ',
+    '     dotrino-vault secret import <ns> [archivo.env]               desde un .env (o stdin)',
+    '     dotrino-vault secret rm  <ns> <CLAVE>',
+    '     dotrino-vault secret device set <ID> <CLAVE> <valor> [--public|--private]',
+    '                                                  (solo la lee ese aparato, y pisa a la del ns)',
+    '     dotrino-vault secret device set <ID> CLAVE=valor [CLAVE2=valor2 …]',
+    '     dotrino-vault secret device import <ID> [archivo.env]',
+    '     dotrino-vault secret device rm  <ID> <CLAVE>',
+    '     dotrino-vault secret list',
+    '',
+    'CARGA LA CONFIGURACIÓN DE UN SERVICIO DE UNA VEZ (`set` con varios pares, o `import`):',
+    'la bóveda la aplica entera y avisa UNA sola vez. De una en una, cada variable es un',
+    'cambio de configuración y el servicio se reinicia a media carga.',
+    '',
+    'Pública o privada dice UNA cosa: si el VALOR puede salir de esta máquina hacia la',
+    'consola remota (vault.dotrino.com). Se nace privada. El servicio recibe las dos igual.'
+  ].join('\n')
+
+  /**
+   * Manda un grupo entero al daemon y comprueba que llegó completo.
+   *
+   * Se valida TODO aquí antes de escribir nada: si una variable del archivo está mal, no
+   * se carga ninguna. Media configuración aplicada es peor que ninguna, porque el
+   * servicio arranca con ella y parece que funcionó.
+   */
+  const sendBatch = async ({ ns = null, pub = null, items, where }) => {
+    const bad = items.map((it) => [it.key, problemWith(it.key, it.value)]).filter(([, p]) => p)
+    if (bad.length) {
+      console.error('%sNo se cargó nada%s. Revisa:', R, Z)
+      for (const [key, p] of bad) console.error('  · %s: %s', key, p)
+      process.exit(2)
+    }
+    const withVisibility = items.map((it) => (isPublic === undefined ? it : { ...it, public: isPublic }))
+    writeReq('secret-request.json', pub ? { op: 'batch', pub, items: withVisibility } : { op: 'batch', ns, items: withVisibility })
+    const d = await signalAndWaitList()
+    const list = pub
+      ? ((Array.isArray(d.dev) ? d.dev : []).find((x) => x.pub === pub)?.keys || [])
+      : (d.ns?.[ns] || [])
+    const missing = items.filter((it) => !has(list, it.key)).map((it) => it.key)
+    if (missing.length) {
+      console.error('El daemon no guardó: %s (revisa: dotrino-vault logs)', missing.join(', '))
+      process.exit(1)
+    }
+    console.log('%d variables guardadas en %s%s%s%s', items.length, B, where, Z,
+      isPublic === undefined ? '' : isPublic ? '   (públicas)' : '   (privadas)')
+    console.log('Un solo aviso de cambio: el servicio se reinicia una vez, con todo puesto.')
+  }
+
+  /** El texto del `.env`: de un archivo, o de la entrada estándar si no se da ninguno. */
+  const readEnvText = (file) => {
+    if (file) {
+      try { return fs.readFileSync(file, 'utf8') } catch (e) {
+        console.error('No se pudo leer %s: %s', file, e.message); process.exit(1)
+      }
+    }
+    if (process.stdin.isTTY) {
+      console.error('%s\n\nimport necesita un archivo, o el .env por la entrada estándar:', USAGE)
+      console.error('  dotrino-vault secret import proxy .env')
+      console.error('  cat .env | dotrino-vault secret import proxy')
+      process.exit(2)
+    }
+    return fs.readFileSync(0, 'utf8')
+  }
+
+  /**
+   * Una variable en la lista: su nombre y su valor. La PÚBLICA enseña el suyo (pública
+   * quiere decir que ese valor puede salir de esta máquina: taparlo aquí, delante de su
+   * dueño, era lo único que la marca no significaba). La privada no se muestra.
+   */
+  const printVar = (k) => console.log('  · %s   %s', k.key, k.public ? `${k.value ?? ''}   (pública)` : '••••••')
+  const has = (list, key) => (list || []).some((x) => x.key === key)
+
   if (sub === 'list') {
     const d = await signalAndWaitList()
     const names = d.ns || {}
     const nss = Object.keys(names)
-    if (!nss.length) { console.log('No hay secretos guardados. Agrega uno:  dotrino-vault secret set <ns> <CLAVE> <valor>'); return }
+    const dev = Array.isArray(d.dev) ? d.dev : []
+    if (!nss.length && !dev.length) {
+      console.log('No hay variables guardadas. Agrega una:  dotrino-vault secret set <ns> <CLAVE> <valor>')
+      return
+    }
+    if (nss.length) console.log('\n%sPor scope%s (las comparten todos los aparatos del perfil)\n', B, Z)
     for (const n of nss) {
       console.log('%s%s%s  (scope vault:secrets:%s)', B, n, Z, n)
-      for (const k of names[n]) console.log('  · %s', k)
+      for (const k of names[n]) printVar(k)
+    }
+    if (dev.length) console.log('\n%sPor aparato%s (solo las lee ese aparato; pisan a las del scope)\n', B, Z)
+    for (const x of dev) {
+      const who = [x.label, x.cn ? `servicio «${x.cn}»` : null, x.orphan ? 'YA NO ESTÁ EN EL ACTA' : null].filter(Boolean).join(' · ')
+      console.log('%s%s%s%s', B, x.id, Z, who ? '  ' + who : '')
+      for (const k of x.keys) printVar(k)
     }
+    console.log('\n(pública) = su valor se puede ver desde la consola remota. Las demás no salen de aquí.\n')
     return
   }
-  if (sub === 'set' || sub === 'rm') {
+
+  // Por APARATO: `secret device set|rm|visibility <ID> <CLAVE> [valor|public|private]`.
+  if (sub === 'device') {
+    const [op, id, key, ...valueParts] = args
     const value = valueParts.join(' ')
-    if (!ns || !key || (sub === 'set' && !value)) {
-      console.error('uso: dotrino-vault secret set <ns> <CLAVE> <valor>\n     dotrino-vault secret rm <ns> <CLAVE>'); process.exit(2)
+    const ops = ['set', 'rm', 'visibility', 'import']
+    const asGroup = op === 'import' || (op === 'set' && !!asPairs(args.slice(2)))
+    if (!ops.includes(op) || !id || (!asGroup && (!key || (op === 'set' && !value)))) { console.error(USAGE); process.exit(2) }
+    const m = await findMember(id)
+    // Se avisa aquí, con nombre y apellido, en vez de dejar que el daemon lo rechace y la
+    // CLI diga «no aplicó el cambio»: quien escribe esto quiere saber POR QUÉ no vale.
+    if (!m.cn) {
+      console.error('%s no es un servicio, y solo los servicios leen variables.', m.id)
+      console.error('Empareja el servicio con:  dotrino-vault pair --service <ns>')
+      process.exit(1)
     }
-    writeReq('secret-request.json', sub === 'set' ? { op: 'set', ns, key, value } : { op: 'rm', ns, key })
+    if (op === 'import') {
+      const { items, errors } = parseEnvText(readEnvText(args[2]))
+      if (errors.length) return abortEnv(errors)
+      return sendBatch({ pub: m.pub, items, where: m.id })
+    }
+    if (asGroup) return sendBatch({ pub: m.pub, items: asPairs(args.slice(2)), where: m.id })
+    if (key && PAIR_RE.test(key) && args.length > 3) {
+      console.error('%s\n\nO todos los argumentos son CLAVE=valor, o es una sola variable.', USAGE)
+      process.exit(2)
+    }
+    const req = op === 'set'
+      ? { op: 'dev-set', pub: m.pub, key, value, ...(isPublic === undefined ? {} : { public: isPublic }) }
+      : op === 'rm'
+        ? { op: 'dev-rm', pub: m.pub, key }
+        : { op: 'dev-vis', pub: m.pub, key, public: wantsPublic(value, USAGE) }
+    writeReq('secret-request.json', req)
     const d = await signalAndWaitList()
-    const ok = sub === 'set' ? (d.ns?.[ns] || []).includes(key) : !(d.ns?.[ns] || []).includes(key)
-    if (ok) console.log(sub === 'set' ? 'Secreto guardado: %s/%s' : 'Secreto borrado: %s/%s', ns, key)
-    else { console.error('El daemon no aplicó el cambio (revisa: dotrino-vault logs)'); process.exit(1) }
+    const keys = (Array.isArray(d.dev) ? d.dev : []).find((x) => x.pub === m.pub)?.keys || []
+    const ok = op === 'rm' ? !has(keys, key) : has(keys, key)
+    if (!ok) { console.error('El daemon no aplicó el cambio (revisa: dotrino-vault logs)'); process.exit(1) }
+    if (op === 'rm') console.log('Variable borrada: %s/%s', m.id, key)
+    else console.log('Variable guardada: %s/%s%s', m.id, key, (keys.find((x) => x.key === key)?.public) ? '   (pública)' : '')
     return
   }
-  console.error('uso: dotrino-vault secret {set|rm|list}'); process.exit(2)
+
+  // Desde un `.env`: el caso real de estrenar un servicio, y el que de una en una
+  // reiniciaba al agente una vez por variable.
+  if (sub === 'import') {
+    const [ns, file] = args
+    if (!ns) { console.error(USAGE); process.exit(2) }
+    const { items, errors } = parseEnvText(readEnvText(file))
+    if (errors.length) return abortEnv(errors)
+    return sendBatch({ ns, items, where: ns })
+  }
+
+  if (sub === 'set' || sub === 'rm' || sub === 'visibility') {
+    const [ns, key, ...valueParts] = args
+    const value = valueParts.join(' ')
+    // `set <ns> CLAVE=valor CLAVE2=valor2` — varias de una vez, un solo aviso.
+    const pairs = sub === 'set' ? asPairs(args.slice(1)) : null
+    if (ns && pairs) return sendBatch({ ns, items: pairs, where: ns })
+    // Mezclar las dos formas (`K1=v1 CLAVE valor`) no es ninguna de las dos: mejor
+    // decirlo que guardar una variable llamada «K1=v1».
+    if (sub === 'set' && key && PAIR_RE.test(key) && args.length > 2) {
+      console.error('%s\n\nO todos los argumentos son CLAVE=valor, o es una sola variable: set <ns> <CLAVE> <valor>.', USAGE)
+      process.exit(2)
+    }
+    if (!ns || !key || (sub === 'set' && !value)) { console.error(USAGE); process.exit(2) }
+    const req = sub === 'set'
+      ? { op: 'set', ns, key, value, ...(isPublic === undefined ? {} : { public: isPublic }) }
+      : sub === 'rm'
+        ? { op: 'rm', ns, key }
+        : { op: 'vis', ns, key, public: wantsPublic(value, USAGE) }
+    writeReq('secret-request.json', req)
+    const d = await signalAndWaitList()
+    const list = d.ns?.[ns] || []
+    const ok = sub === 'rm' ? !has(list, key) : has(list, key)
+    if (!ok) { console.error('El daemon no aplicó el cambio (revisa: dotrino-vault logs)'); process.exit(1) }
+    if (sub === 'rm') console.log('Secreto borrado: %s/%s', ns, key)
+    else console.log('Secreto guardado: %s/%s%s', ns, key, (list.find((x) => x.key === key)?.public) ? '   (pública)' : '')
+    return
+  }
+  console.error(USAGE); process.exit(2)
+}
+
+/** `visibility … public|private` — el único argumento que acepta, y sin adivinar. */
+function wantsPublic (word, usage) {
+  if (word === 'public') return true
+  if (word === 'private') return false
+  console.error('%s\n\nvisibility acepta «public» o «private».', usage); process.exit(2)
 }
 
 /**
@@ -546,7 +808,7 @@ async function cmdSecret (rest) {
 function askPassword (prompt) {
   return new Promise((resolve, reject) => {
     const stdin = process.stdin
-    if (!stdin.isTTY) return reject(new Error('hace falta un terminal para escribir la contraseña'))
+    if (!stdin.isTTY) return reject(new Error('a terminal is required to type the password'))
     process.stdout.write(prompt)
     stdin.setRawMode(true); stdin.resume(); stdin.setEncoding('utf8')
     let buf = ''
@@ -558,7 +820,7 @@ function askPassword (prompt) {
     const onData = (ch) => {
       for (const c of ch) {
         if (c === '\n' || c === '\r' || c === '\u0004') return done(null, buf) // Enter / Ctrl-D
-        if (c === '\u0003') return done(new Error('cancelado')) // Ctrl-C
+        if (c === '\u0003') return done(new Error('cancelled')) // Ctrl-C
         if (c === '\u007f' || c === '\b') { buf = buf.slice(0, -1); continue } // borrar
         buf += c
       }
@@ -576,7 +838,7 @@ async function profileRequest (op, extra = {}) {
   const s = requireDaemon()
   try { fs.rmSync(profilesFile, { force: true }) } catch (_) {}
   writeReq('profile-request.json', { op, ...extra })
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   for (let i = 0; i < 100; i++) {
     await sleep(100)
     const d = readJson(profilesFile, null)
@@ -586,7 +848,14 @@ async function profileRequest (op, extra = {}) {
 }
 
 function reportProfiles (d) {
-  if (d.error) { console.error('%s', d.error); process.exit(1) }
+  if (d.error) {
+    // Los dos rechazos del candado se dicen con palabras y con el dato que hace falta; el
+    // resto se reenvía tal cual (son diagnósticos del servicio).
+    if (d.code === 'WRONG_PASSWORD') console.error('Contraseña incorrecta%s.', d.tries ? ` — van ${d.tries} intentos fallidos` : '')
+    else if (d.code === 'TOO_MANY_TRIES') console.error('Demasiados intentos: espera %s s antes de volver a probar.', d.waitSec || '?')
+    else console.error('%s', d.error)
+    process.exit(1)
+  }
   if (d.done) console.log('%s', d.done)
   return d
 }
@@ -691,9 +960,25 @@ function help () {
                       estrena una cuenta VACÍA en este vault y mete ahí al dispositivo
                       (sin la bandera entra a la cuenta activa, o a la de --profile)
   pair --service <ns> empareja un SERVICIO (proxy, geo…) con acceso SOLO a sus secretos
-  secret set <ns> <CLAVE> <valor>   guarda un secreto para el servicio <ns>
-  secret rm <ns> <CLAVE>            borra un secreto
-  secret list                       lista nombres de secretos (nunca valores)
+  secret set <ns> <CLAVE> <valor>   variable del scope <ns>: la comparten TODOS los
+                                    aparatos del perfil que sirven ese namespace
+  secret set <ns> CLAVE=valor CLAVE2=valor2 …
+                                    carga VARIAS de una vez: se aplican juntas y el
+                                    servicio recibe UN solo aviso (se reinicia una vez)
+  secret import <ns> [archivo.env]  lo mismo desde un .env (o por la entrada estándar)
+  secret rm <ns> <CLAVE>            borra una variable del scope
+  secret device set <ID> <CLAVE> <valor>
+                                    variable de UN aparato: solo la lee él, y pisa a la
+                                    del scope que se llame igual (puerto, URL pública…)
+  secret device set <ID> CLAVE=valor …
+  secret device import <ID> [archivo.env]
+  secret device rm <ID> <CLAVE>     borra una variable de ese aparato
+  secret list                       lista los dos cajones: el valor de las públicas,
+                                    tapadas las privadas
+  --public | --private              (al hacer un set) si el VALOR puede salir de esta
+                                    máquina hacia la consola remota. Se nace privada.
+  secret visibility <ns> <CLAVE> public|private        cambia eso sin tocar el valor
+  secret device visibility <ID> <CLAVE> public|private
   pending             muestra el dispositivo pendiente + su código a comparar
   approve <código>    aprueba el dispositivo tipeando el código que MUESTRA (el vault no lo sabe)
   reject <deviceId>   rechaza un dispositivo pendiente