@dotrino/vaultd 0.38.0 → 0.49.0

package/src/ctl.js

@@ -23,9 +23,11 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { execFileSync } from 'node:child_process'
+import tty from 'node:tty'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir, readJson } from './paths.js'
 import { assertVar } from './secretsStore.js'
+import { isValidSecretsNs } from './protocol.js'
 import { parseEnvText, PAIR_RE } from '../lib/src/envtext.js'
 import { qrToString } from './qr.js'
 import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
@@ -126,6 +128,7 @@ function cmdStatus () {
   }
   console.log('  fingerprint : %s', s.fingerprint)
   console.log('  proxy       : %s', s.proxy)
+  if (s.sshAgent) console.log('  ssh-agent   : %s   (dotrino-vault ssh)', s.sshAgent)
   console.log('  pid         : %s%s', s.pid, up ? '' : ' (no responde)')
   console.log('  datos       : %s', dir)
   const profiles = s.profiles || []
@@ -179,6 +182,31 @@ async function cmdPair (args = []) {
       console.error('uso: dotrino-vault pair --service <ns>   (ns en minúsculas, p.ej. proxy)'); process.exit(2)
     }
   }
+  // --scope <lista>: los PERMISOS del cert, y nada más. No hay tipos de aparato
+  // (2026-08-22, dueño): un aparato es un aparato y lo que puede hacer. Sin --scope,
+  // el juego de siempre (sign,read,store); `--service <ns>` es el atajo de
+  // `secrets:<ns>`, y los dos se combinan (`--service eco --scope sign` = un bot que
+  // firma como aparato del acta y lee solo su cajón). `admin` no se empareja: se
+  // concede desde el PC (`caps <ID> +administra`).
+  const scIdx = args.indexOf('--scope')
+  let scope = null
+  if (scIdx >= 0) {
+    const raw = args[scIdx + 1]
+    if (!raw || raw.startsWith('-')) { console.error('uso: dotrino-vault pair --scope sign,read,store,secrets:<ns>'); process.exit(2) }
+    const ALIAS = { firma: 'sign', lee: 'read', guarda: 'store' }
+    scope = []
+    for (const tok of raw.split(',').map((t) => t.trim()).filter(Boolean)) {
+      const t = ALIAS[tok] || tok
+      if (t === 'admin' || t === 'administra') { console.error('`admin` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +administra'); process.exit(2) }
+      if (t === 'approve' || t === 'aprueba') { console.error('`approve` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +aprueba'); process.exit(2) }
+      if (t === 'sign' || t === 'read' || t === 'store') { scope.push('vault:' + t); continue }
+      const m = /^secrets:([a-z0-9-]{1,32})$/.exec(t)
+      if (m) { scope.push('vault:secrets:' + m[1]); continue }
+      console.error('permiso desconocido: %s  (sign | read | store | secrets:<ns>)', tok); process.exit(2)
+    }
+    if (service) scope.push('vault:secrets:' + service)
+    scope = [...new Set(scope)]
+  }
   // `--new-account [nombre]`: la otra respuesta a «¿a qué cuenta entra?». En vez de
   // meter el dispositivo en una cuenta que ya vive aquí, se ESTRENA una (vacía) y
   // entra a ella; las demás no se tocan. En la TUI esto es una pregunta con sus
@@ -210,7 +238,7 @@ 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' } : {}) })
+  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(scope ? { scope } : {}), ...(adopt ? { mode: 'adopt' } : {}) })
   sendSignal(s.pid, 'SIGUSR1')
 
   let pair = null
@@ -354,7 +382,7 @@ async function cmdMembers () {
   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}` }
+  const CAP = { sign: 'firma', store: 'guarda', read: 'lee', secrets: 'lee sus claves', admin: `${B}administra el perfil${Z}`, approve: `${B}aprueba pedidos${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.
@@ -369,8 +397,12 @@ async function cmdMembers () {
     ].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, who, marks.length ? '  [' + marks.join(' · ') + ']' : '', caps)
+    // Un servicio SIN llave de cifrado no puede leer ninguna variable privada: van
+    // selladas a esa llave. Se dice aquí, junto a él, porque es el único sitio donde
+    // se mira quién es quién — y en la lista de variables ya seria tarde.
+    if (m.cn && !m.canSeal) console.log('      %ssin llave de cifrado: NO puede leer sus variables%s', R, Z)
   }
-  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra')
+  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba')
   console.log('  «Administra» deja conectar y quitar dispositivos desde ese aparato, sin venir aquí.')
   console.log('  No deja cambiar permisos ni traspasar el mando: eso solo se hace en esta máquina.')
   console.log('  Los servicios solo pueden abrir las claves de su propio nombre; eso no se cambia aquí.\n')
@@ -411,16 +443,42 @@ async function findMember (id) {
   return m
 }
 
+/**
+ * `dotrino-vault ssh` — cómo usar la llave SSH del teléfono desde este PC. La llave
+ * privada no está aquí: el daemon expone un agente SSH y cada firma la aprueba el
+ * teléfono (`caps <ID> +aprueba`). Imprime lo que hay que poner en el shell.
+ */
+async function cmdSsh (args = []) {
+  const s = requireDaemon()
+  if (!s.sshAgent) { console.error('El daemon no tiene el agente SSH activo (DOTRINO_VAULT_SSH_AGENT=0, o Windows).'); process.exit(1) }
+  if (args[0] === 'keys' || args[0] === '-L') {
+    try { execFileSync('ssh-add', ['-L'], { env: { ...process.env, SSH_AUTH_SOCK: s.sshAgent }, stdio: 'inherit' }) } catch (_) { process.exit(1) }
+    return
+  }
+  console.log('# La llave SSH vive en tu teléfono; este PC solo le pide la firma. Pon en tu shell:')
+  console.log('export SSH_AUTH_SOCK=%s', s.sshAgent)
+  console.log('')
+  console.log('# Registra la llave desde el teléfono (vault.dotrino.com → Llave SSH) y pega su línea')
+  console.log('# pública en ~/.ssh/authorized_keys de cada servidor. Para no aprobar cada comando,')
+  console.log('# reusa la conexión 15 min en ~/.ssh/config:')
+  console.log('#   Host *')
+  console.log('#     ControlMaster auto')
+  console.log('#     ControlPath ~/.ssh/cm-%r@%h:%p')
+  console.log('#     ControlPersist 15m')
+  console.log('')
+  console.log('# Ver las llaves registradas:  dotrino-vault ssh keys')
+}
+
 /** `dotrino-vault caps <ID> ±permiso` — cambia lo que puede hacer un dispositivo. */
 async function cmdCaps (args = []) {
   const [id, ...changes] = args
   if (!id || !changes.length) {
-    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra')
+    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra|+aprueba|-aprueba')
     process.exit(2)
   }
   const CAP_BY_WORD = {
-    firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin',
-    sign: 'sign', store: 'store', read: 'read', admin: 'admin'
+    firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin', aprueba: 'approve',
+    sign: 'sign', store: 'store', read: 'read', admin: 'admin', approve: 'approve'
   }
   const s = requireDaemon()
   const m = await findMember(id)
@@ -601,6 +659,37 @@ async function cmdSecret (rest) {
   })
   const [sub, ...args] = rest2
   const s = requireDaemon()
+
+  /**
+   * La contraseña del perfil, y SOLO si el perfil la tiene.
+   *
+   * Desde v5 la piden únicamente las operaciones que **LEEN** un valor: verlo, cambiarle
+   * la visibilidad (para enseñarlo hay que sacarlo), convertir el archivo y saldar lo que
+   * quedó a deber. **Guardar no la pide**: sellar solo necesita las públicas de quien va
+   * a leer (`docs/secretos-sellados.md` §8.1). Borrar tampoco, porque tirar un sobre no
+   * obliga a abrirlo.
+   */
+  let cachedPwd
+  const adminPassword = async () => {
+    if (cachedPwd !== undefined) return cachedPwd
+    const d = await profileRequest('list')
+    const list = Array.isArray(d.profiles) ? d.profiles : []
+    const p = PROFILE
+      ? list.find((x) => x.id === PROFILE || x.name === PROFILE)
+      : (list.find((x) => x.current) || list[0])
+    if (!p?.protected) { cachedPwd = null; return null }
+    // Nunca por argumento: quedaría en `ps` y en el historial de la shell. Si no hay
+    // terminal se dice qué falta, en vez de fallar con «el daemon no aplicó el cambio».
+    let pwd
+    try { pwd = await askPassword('Contraseña del perfil: ') } catch (_) {
+      console.error('Este perfil tiene contraseña y hace falta para guardar una variable.')
+      console.error('Ejecútalo desde un terminal (por ssh, con -t).')
+      process.exit(1)
+    }
+    if (!pwd) { console.error('Cancelado.'); process.exit(1) }
+    cachedPwd = pwd
+    return pwd
+  }
   const secretsListFile = path.join(dir, 'secrets-list.json')
   const signalAndWaitList = async () => {
     try { fs.rmSync(secretsListFile, { force: true }) } catch (_) {}
@@ -615,6 +704,26 @@ async function cmdSecret (rest) {
     }
     console.error('El daemon no respondió.'); process.exit(1)
   }
+  /**
+   * SELLA el almacén: pasa un `secrets.json` v3 (valores que esta bóveda puede leer) a
+   * v4 (cada privada cifrada a la llave de su destinatario). Corre UNA vez.
+   *
+   * Es una operación con nombre propio y no un efecto de desbloquear, porque es el
+   * punto de no retorno: a partir de aquí la contraseña es lo ÚNICO que puede
+   * re-sellar, y perderla impide rotar una variable o sumar un aparato al namespace.
+   * Deja `secrets.json.v3.bak` al lado para poder volver.
+   */
+  async function secretMigrate () {
+    console.log('Esto SELLA las variables privadas a la llave de cada aparato.')
+    console.log('A partir de aquí, esta contraseña es lo único que puede volver a sellarlas:')
+    console.log('si la pierdes no podrás rotar una variable ni sumar un aparato al namespace.')
+    console.log('Se deja una copia en secrets.json.v3.bak por si hay que volver.\n')
+    const pwd = await askPassword('Contraseña del perfil: ')
+    if (!pwd) { console.error('Cancelado.'); process.exit(1) }
+    writeReq('secret-request.json', { op: 'migrate', password: pwd })
+    console.log('\nPedido enviado. Mira el resultado con:  journalctl --user -u dotrino-vault -n 20')
+  }
+
   const USAGE = [
     'uso: dotrino-vault secret set <ns> <CLAVE> <valor> [--public|--private]',
     '                                                  (la comparten todos los aparatos del ns)',
@@ -627,6 +736,8 @@ async function cmdSecret (rest) {
     '     dotrino-vault secret device import <ID> [archivo.env]',
     '     dotrino-vault secret device rm  <ID> <CLAVE>',
     '     dotrino-vault secret list',
+    '     dotrino-vault secret migrate                                 SELLA los secretos (una vez)',
+    '     dotrino-vault secret policy <ns> approval on|off              cada lectura espera tu aprobación (teléfono)',
     '',
     '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',
@@ -651,13 +762,16 @@ async function cmdSecret (rest) {
       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 })
+    // Guardar NO pide la contraseña (§8.1).
+    const base = pub ? { op: 'batch', pub, items: withVisibility } : { op: 'batch', ns, items: withVisibility }
+    writeReq('secret-request.json', base)
     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) {
+      if (d?.secretError) return noSeAplico(d)
       console.error('El daemon no guardó: %s (revisa: dotrino-vault logs)', missing.join(', '))
       process.exit(1)
     }
@@ -688,7 +802,140 @@ async function cmdSecret (rest) {
    * 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)` : '••••••')
+  /**
+   * Por qué no se aplicó. El daemon deja el motivo en el volcado siguiente; sin él lo
+   * único que se podía decir era «revisa los logs», que no ayuda a quien acaba de
+   * escribir mal la contraseña.
+   */
+  const noSeAplico = (d) => {
+    if (d?.secretError?.code === 'WRONG_PASSWORD') console.error('Contraseña incorrecta.')
+    else if (d?.secretError?.error) console.error('No se aplicó: %s', d.secretError.error)
+    else console.error('El daemon no aplicó el cambio (revisa: dotrino-vault logs)')
+    process.exit(1)
+  }
   const has = (list, key) => (list || []).some((x) => x.key === key)
+  /**
+   * Los cajones que quedaron a deber un sellado. Sale ARRIBA del todo en rojo porque no
+   * es un detalle: mientras esté ahí, los aparatos de ese cajón NO están leyendo sus
+   * variables, y la bóveda no puede arreglarlo sola — necesita la contraseña.
+   */
+  /**
+   * Un perfil SIN contraseña abre sus variables privadas con la llave de esta máquina,
+   * cuyo material vive en este mismo disco: una copia del disco las abre. Es un default
+   * deliberado —tiene que seguir funcionando— pero NO es lo mismo, y callarlo es
+   * exactamente el error del comentario mentiroso de `atrest.js`.
+   */
+  const printNoPassword = async () => {
+    const d = await profileRequest('list')
+    const list = Array.isArray(d.profiles) ? d.profiles : []
+    const p = PROFILE ? list.find((x) => x.id === PROFILE || x.name === PROFILE) : (list.find((x) => x.current) || list[0])
+    if (!p || p.protected) return
+    console.log('%sEste perfil no tiene contraseña%s: las privadas se abren con la llave de ESTA', B, Z)
+    console.log('máquina, cuyo material vive en este mismo disco — o sea que una copia del disco')
+    console.log('las abre. Ponle una con:  dotrino-vault profile password\n')
+  }
+  const printPending = (d) => {
+    const pend = Object.entries(d?.pending || {})
+    if (!pend.length) return
+    console.error('%sHay %d cajón(es) sin sellar%s:', R, pend.length, Z)
+    for (const [owner, info] of pend) {
+      console.error('  · %s — %s', owner, info?.kind === 'rotate'
+        ? 'se fue un miembro y no se pudo rotar su llave'
+        : 'entró un aparato y no se le pudo entregar la llave')
+    }
+    console.error('Sus aparatos NO leen sus variables. Se arregla guardando una variable')
+    console.error('de ese cajón con la contraseña:  dotrino-vault secret set <ns> <CLAVE> <valor>\n')
+  }
+
+  if (sub === 'migrate') return secretMigrate()
+  // `secret policy <ns> approval on|off`: el cajón pasa a pedir el visto bueno de un
+  // aparato con `aprueba` (el teléfono) en cada lectura, con ventana de 15 min.
+  if (sub === 'policy') {
+    const [ns, what, val] = args
+    if (!isValidSecretsNs(ns || '') || what !== 'approval' || !['on', 'off'].includes(val)) {
+      console.error('uso: dotrino-vault secret policy <ns> approval on|off'); process.exit(2)
+    }
+    writeReq('secret-request.json', { op: 'policy', ns, approval: val === 'on' })
+    sendSignal(s.pid, 'SIGUSR2')
+    console.log(val === 'on'
+      ? `Listo: cada lectura de «${ns}» esperará la aprobación de un aparato con  caps <ID> +aprueba  (ventana de 15 min).`
+      : `Listo: «${ns}» vuelve a entregarse sin aprobación.`)
+    return
+  }
+
+  // --- VER un valor, su histórico y volver atrás ---------------------------------
+  // Las tres van juntas porque son la misma idea: ver es lo único que la contraseña
+  // guarda, y revertir es ver + volver a guardar (§8.3/§8.4).
+  const ownerDe = async (kind, ref) => {
+    if (kind === 'ns') return `ns:${ref}`
+    const m = await findMember(ref)
+    return `dev:${m.pub}`
+  }
+
+  if (sub === 'show' || sub === 'history' || sub === 'revert') {
+    // `secret show device <ID> <CLAVE>` mira el cajón de un aparato.
+    const esDev = args[0] === 'device'
+    const [ref, key, extra] = esDev ? args.slice(1) : args
+    if (!ref || (sub !== 'history' && !key)) {
+      console.error('uso: dotrino-vault secret %s [device] <ns|ID> <CLAVE>%s', sub, sub === 'revert' ? ' <marca>' : '')
+      process.exit(2)
+    }
+    const owner = await ownerDe(esDev ? 'dev' : 'ns', ref)
+
+    if (sub === 'history') {
+      writeReq('secret-request.json', { op: 'history', owner, key: key || null })
+      const d = await signalAndWaitList()
+      const items = d.history?.items || []
+      if (!items.length) { console.log('No hay versiones anteriores de %s%s.', owner, key ? `/${key}` : ''); return }
+      console.log('\n%sVersiones anteriores%s  (la de arriba es la más reciente)\n', B, Z)
+      for (const h of items) {
+        // Sin `by` no es que falte un dato: es que se escribió AQUÍ, desde esta máquina.
+        // Lo que llega por la consola remota sí trae de qué aparato vino.
+        console.log('  %s  %s%s%s  %s%s', new Date(h.ts).toISOString(), B, h.key, Z,
+          h.by ? `desde ${h.by.slice(0, 12)}…` : 'desde esta máquina', h.signed ? '' : '   (sobre sin firma)')
+      }
+      console.log('\nPara volver a una:  dotrino-vault secret revert %s%s <CLAVE> <marca>\n',
+        esDev ? 'device ' : '', ref)
+      return
+    }
+
+    if (sub === 'revert') {
+      if (!extra) { console.error('uso: dotrino-vault secret revert [device] <ns|ID> <CLAVE> <marca>'); process.exit(2) }
+      const ts = Number.isFinite(Number(extra)) ? Number(extra) : Date.parse(extra)
+      if (!Number.isFinite(ts)) { console.error('La marca es la que enseña `secret history` (fecha ISO).'); process.exit(2) }
+      const password = await adminPassword()
+      writeReq('secret-request.json', { op: 'revert', owner, key, ts, ...(password ? { password } : {}) })
+      const d = await signalAndWaitList()
+      if (d?.secretError) return noSeAplico(d)
+      console.log('Restaurada: %s/%s', owner, key)
+      return
+    }
+
+    // `show`: el valor. Es lo único que la contraseña guarda en esta máquina.
+    const password = await adminPassword()
+    writeReq('secret-request.json', { op: 'reveal', owner, key, ...(password ? { password } : {}) })
+    const d = await signalAndWaitList()
+    if (d?.secretError) return noSeAplico(d)
+    if (d.revealed?.owner !== owner || d.revealed?.key !== key) {
+      console.error('El daemon no devolvió el valor (revisa: dotrino-vault logs)')
+      process.exit(1)
+    }
+    if (d.revealed.value == null) { console.error('No existe esa variable.'); process.exit(1) }
+    console.log(d.revealed.value)
+    return
+  }
+
+  // Saldar lo que quedó a deber: heredarle a un aparato lo ya guardado, rotar de verdad.
+  if (sub === 'settle') {
+    const password = await adminPassword()
+    writeReq('secret-request.json', { op: 'settle', ...(password ? { password } : {}) })
+    const d = await signalAndWaitList()
+    if (d?.secretError) return noSeAplico(d)
+    const pend = Object.keys(d.pending || {})
+    if (!pend.length) console.log('Nada pendiente.')
+    else console.log('Siguen pendientes: %s', pend.join(', '))
+    return
+  }
 
   if (sub === 'list') {
     const d = await signalAndWaitList()
@@ -711,6 +958,8 @@ async function cmdSecret (rest) {
       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')
+    printPending(d)
+    await printNoPassword()
     return
   }
 
@@ -744,11 +993,13 @@ async function cmdSecret (rest) {
       : 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)
+    // Solo la visibilidad pide la frase: enseñar un valor obliga a sacarlo.
+    const password = op === 'vis' ? await adminPassword() : null
+    writeReq('secret-request.json', password ? { ...req, password } : req)
     const d = await signalAndWaitList()
     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 (!ok) return noSeAplico(d)
     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
@@ -782,11 +1033,13 @@ async function cmdSecret (rest) {
       : sub === 'rm'
         ? { op: 'rm', ns, key }
         : { op: 'vis', ns, key, public: wantsPublic(value, USAGE) }
-    writeReq('secret-request.json', req)
+    // Solo la visibilidad pide la frase: enseñar un valor obliga a sacarlo.
+    const password = sub === 'visibility' ? await adminPassword() : null
+    writeReq('secret-request.json', password ? { ...req, password } : 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 (!ok) return noSeAplico(d)
     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
@@ -807,13 +1060,24 @@ function wantsPublic (word, usage) {
  */
 function askPassword (prompt) {
   return new Promise((resolve, reject) => {
-    const stdin = process.stdin
-    if (!stdin.isTTY) return reject(new Error('a terminal is required to type the password'))
+    // Se lee del TERMINAL, no de la entrada estándar. `secret import` ya usa stdin para
+    // el `.env` (`cat .env | dotrino-vault secret import proxy`) y aun así hay que poder
+    // escribir la contraseña; lo mismo vale para cualquier tubería.
+    let stdin = process.stdin
+    let own = null
+    if (!stdin.isTTY) {
+      try {
+        own = fs.openSync('/dev/tty', 'r')
+        stdin = new tty.ReadStream(own)
+      } catch (_) { 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 = ''
     const done = (err, val) => {
-      stdin.setRawMode(false); stdin.pause(); stdin.removeListener('data', onData)
+      try { stdin.setRawMode(false) } catch (_) {}
+      stdin.removeListener('data', onData)
+      if (own !== null) { try { stdin.destroy() } catch (_) {} } else stdin.pause()
       process.stdout.write('\n')
       err ? reject(err) : resolve(val)
     }
@@ -904,14 +1168,37 @@ async function cmdProfile (rest) {
     }
     case 'password': {
       const action = args[0]
-      if (action === 'rm') { reportProfiles(await profileRequest('password-rm')); return }
+      // QUITARLA pide la actual, y no por trámite: con ella se abre la copia maestra de
+      // los secretos para volver a cerrarla con la llave de esta máquina. Sin ese paso,
+      // quitar la contraseña dejaría las variables privadas ilegibles para siempre.
+      if (action === 'rm') {
+        console.log('Al quitarla, las variables privadas pasan a abrirse con la llave de ESTA')
+        console.log('máquina: siguen cifradas en el disco, pero su material vive en ese mismo')
+        console.log('disco, así que una copia del disco las abre. Los aparatos no se enteran.')
+        const cur = await askPassword('\nContraseña actual: ')
+        if (!cur) { console.error('Cancelado.'); process.exit(1) }
+        reportProfiles(await profileRequest('password-rm', { password: cur }))
+        return
+      }
       if (action && action !== 'set') { console.error('uso: dotrino-vault profile password [set|rm]'); process.exit(2) }
-      console.log('La contraseña solo se pide para EDITAR el perfil. Tus dispositivos siguen')
-      console.log('funcionando (firmando y leyendo) aunque el perfil esté bloqueado.')
-      const pwd = await askPassword('\nContraseña nueva (mínimo 4): ')
+      console.log('La contraseña se pide para EDITAR el perfil y para escribir variables')
+      console.log('privadas. Tus dispositivos siguen funcionando (firmando, leyendo y')
+      console.log('recibiendo su configuración) aunque el perfil esté bloqueado.')
+      // Si ya hay una, hace falta para poder abrir la copia maestra y re-sellarla. El
+      // camino recomendado para CAMBIARLA es quitarla y ponerla: así cada paso pide
+      // solo lo que necesita.
+      const actual = await askPassword('\nContraseña actual (vacío si no tiene): ')
+      // Se pide una FRASE, y se dice cómo sacarla, porque lo que da fuerza es la
+      // longitud y que no la elija un humano: un modismo tiene la entropía de un
+      // modismo, no la de su longitud. Desde el sellado, esta frase es lo único que
+      // separa una copia del disco de las variables privadas.
+      console.log('\nUsa VARIAS PALABRAS AL AZAR (mínimo 12 caracteres). Para que las elija')
+      console.log('la máquina y no tú:')
+      console.log("  grep -x '[a-z]\\{4,8\\}' /usr/share/dict/words | shuf -n5 | paste -sd-")
+      const pwd = await askPassword('\nContraseña nueva: ')
       const again = await askPassword('Repítela: ')
       if (pwd !== again) { console.error('Las contraseñas no coinciden.'); process.exit(1) }
-      reportProfiles(await profileRequest('password-set', { password: pwd }))
+      reportProfiles(await profileRequest('password-set', { password: pwd, current: actual || undefined }))
       return
     }
     default:
@@ -960,6 +1247,8 @@ 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
+  pair --scope <lista>  los PERMISOS del cert: sign,read,store,secrets:<ns> (sin esto: sign,read,store;
+                      se combina con --service: --service eco --scope sign = bot que firma y lee su cajón)
   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 …
@@ -975,10 +1264,21 @@ function help () {
   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
+  secret show [device] <ns|ID> <CLAVE>
+                                    VE el valor de una privada. Es lo único que pide la
+                                    contraseña del perfil: en esta máquina es lo único
+                                    que la separa de una copia del disco
+  secret history [device] <ns|ID> [CLAVE]
+                                    las versiones anteriores (quién y cuándo)
+  secret revert [device] <ns|ID> <CLAVE> <marca>
+                                    vuelve a una versión anterior
+  secret settle                     salda lo pendiente: hereda lo ya guardado a un
+                                    aparato nuevo y rota de verdad el cajón del que se fue
   --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
+                                    máquina hacia la consola remota. Se nace privada,
+                                    y una privada NO se vuelve pública (bórrala y créala).
+  secret visibility <ns> <CLAVE> private               tapa una pública sin tocar el valor
+  secret device visibility <ID> <CLAVE> 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
@@ -1035,6 +1335,7 @@ export async function runCtl (argv) {
     case 'caps': return cmdCaps(rest)
     case 'revoke': return cmdRevoke(rest[0])
     case 'secret': return cmdSecret(rest)
+    case 'ssh': return cmdSsh(rest)
     case 'activity': return cmdActivity(Number(rest[0]) || 30)
     case 'logs': return cmdLogs()
     case 'version':