@dotrino/vaultd 0.38.0 → 0.46.2

package/src/ctl.js

@@ -23,6 +23,7 @@
 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'
@@ -179,6 +180,30 @@ 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 === '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 +235,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
@@ -369,6 +394,10 @@ 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('  «Administra» deja conectar y quitar dispositivos desde ese aparato, sin venir aquí.')
@@ -601,6 +630,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 +675,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 +707,7 @@ 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)',
     '',
     '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 +732,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 +772,126 @@ 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()
+
+  // --- 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 +914,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 +949,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 +989,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 +1016,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 +1124,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 +1203,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 +1220,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

package/src/daemon.js

@@ -143,7 +143,19 @@ export async function runDaemon () {
       if (!vault) return
       const profileId = pairReq?.profile ? mgr.resolve(pairReq.profile) : mgr.currentId()
       const isService = typeof pairReq?.service === 'string' && pairReq.service
-      const scope = isService ? ['vault:secrets:' + pairReq.service] : ['vault:sign', 'vault:read', 'vault:store']
+      // PERMISOS, no tipos (2026-08-22): el cert lleva lo que pidió `pair --scope`, y si
+      // no pidió nada, el juego de siempre. `--service <ns>` sigue siendo el atajo de
+      // `vault:secrets:<ns>`. Se valida aquí porque es la maestra la que firma: nada
+      // que no esté en esta lista entra en un cert, y `vault:admin` nunca por este camino.
+      const ALLOWED = (x) => x === 'vault:sign' || x === 'vault:read' || x === 'vault:store' || /^vault:secrets:[a-z0-9-]{1,32}$/.test(x)
+      const asked = Array.isArray(pairReq?.scope) ? pairReq.scope.filter((x) => typeof x === 'string') : null
+      if (asked && asked.some((x) => !ALLOWED(x))) {
+        writeJson(pairFile, { v: 2, at: Date.now(), error: 'scope not allowed: ' + asked.filter((x) => !ALLOWED(x)).join(',') })
+        return console.error('[vault] pairing refused: scope not allowed (%s)', asked.join(','))
+      }
+      const scope = asked?.length
+        ? [...new Set(asked)]
+        : isService ? ['vault:secrets:' + pairReq.service] : ['vault:sign', 'vault:read', 'vault:store']
       const label = pairReq?.label || (isService ? 'service:' + pairReq.service : 'cli')
       // `profile`/`profileName`: la CUENTA del vault a la que entra el dispositivo.
       // Con varias bóvedas en el mismo daemon, el QR sale de UNA y quien empareja
@@ -181,6 +193,21 @@ export async function runDaemon () {
   const revokeReqFile = path.join(dir, 'revoke-request.json')
   const secretReqFile = path.join(dir, 'secret-request.json')
   const secretsListFile = path.join(dir, 'secrets-list.json')
+  /**
+   * Por qué falló la última orden de variables. La consola pide el cambio y el volcado
+   * por señales distintas, así que el motivo no cabe en la respuesta: se guarda aquí y
+   * viaja en el volcado siguiente. Sin esto, una contraseña equivocada se leía como
+   * «El daemon no aplicó el cambio», que no dice qué hacer.
+   */
+  let lastSecretError = null
+  /**
+   * El VALOR que se acaba de destapar, esperando al volcado siguiente (mismo camino que
+   * `lastSecretError`: la orden y el volcado son señales distintas). Vive en memoria un
+   * instante y se va con el volcado — quien lo lee borra el archivo enseguida.
+   */
+  let lastSecretValue = null
+  /** Y las versiones anteriores que se acaban de pedir. Mismo camino, mismo volcado. */
+  let lastSecretHistory = null
   const profileReqFile = path.join(dir, 'profile-request.json')
   const dumpReqFile = path.join(dir, 'dump-request.json')
   const meReqFile = path.join(dir, 'me-request.json')
@@ -200,6 +227,19 @@ export async function runDaemon () {
    * 0700 del vault y se BORRA al consumirla — mismo camino que ya usan los
    * secretos, y así nunca pasa por `ps` ni por el historial de la shell.
    */
+  /**
+   * Vuelve a cerrar la copia maestra de los secretos con otra llave. Se llama al poner
+   * o quitar la contraseña del perfil: los sobres de las variables NO se tocan (siguen
+   * sellados a la llave de cada aparato), solo cambia con qué se abre el llavero de
+   * administración. Sin esto, cambiar la contraseña dejaría los secretos ilegibles.
+   */
+  async function rekey (id, vieja, nueva) {
+    const v = mgr.get(id)
+    if (!v?.rekeySecrets) return
+    const r = await v.rekeySecrets(vieja, nueva)
+    if (r?.rekeyed) console.log('[vault] secrets master re-sealed (%d drawer(s))', r.drawers)
+  }
+
   async function handleProfileRequest (req) {
     const ref = () => mgr.resolve(req.profile || mgr.currentId())
     switch (req.op) {
@@ -210,10 +250,54 @@ export async function runDaemon () {
       case 'rm': { const r = await mgr.remove(req.profile); return { done: `perfil borrado: ${r.name || r.id}` } }
       case 'rename': { const p = mgr.profiles.rename(ref(), req.name); return { done: `perfil renombrado: ${p.name}` } }
       case 'use': { const p = mgr.profiles.setCurrent(ref()); return { done: `perfil activo: ${p.name || p.id}` } }
-      case 'unlock': { await mgr.profiles.unlock(ref(), req.password); return { done: 'perfil desbloqueado' } }
+      // ABRIR LA BÓVEDA SALDA LO QUE SE DEBE. Un aparato que entró después de escrita
+      // una variable no puede abrirla —envolverle su llave exige abrir la CEK, y eso
+      // pide la frase—, así que se queda en deuda y se ve en la consola y en la TUI.
+      // Este es el único momento en que la frase está delante, así que es aquí donde se
+      // paga; el dueño no tiene que acordarse de un comando aparte.
+      case 'unlock': {
+        const id = ref()
+        await mgr.profiles.unlock(id, req.password)
+        let note = ''
+        try {
+          const ak = await mgr.profiles.adminKey(id, req.password)
+          // REHACER el llavero, no solo saldar: con la frase delante se puede dejar cada
+          // cajón envuelto para exactamente quien dice el acta — creando lo que falta,
+          // reemplazando lo que alguien metiera mal y quitando lo que sobre.
+          const r = await mgr.get(id)?.resealAll?.(ak)
+          if (r?.wrapped) console.log('[vault] keyring rebuilt on unlock: %d wrap(s) in %d drawer(s)%s',
+            r.wrapped, r.drawers, r.dropped ? `, ${r.dropped} stale one(s) dropped` : '')
+          if (r?.dropped) note = ` · llavero al día (${r.dropped} envoltura(s) de más retirada(s))`
+          else if (r?.wrapped) note = ' · llavero al día'
+        } catch (e) { console.error('[vault] could not rebuild the keyring on unlock:', e.message) }
+        return { done: 'perfil desbloqueado' + note }
+      }
       case 'lock': { mgr.profiles.lock(ref()); return { done: 'perfil bloqueado' } }
-      case 'password-set': { await mgr.profiles.setPassword(ref(), req.password); return { done: 'contraseña guardada' } }
-      case 'password-rm': { mgr.profiles.removePassword(ref()); return { done: 'contraseña quitada' } }
+      // PONER contraseña: los secretos pasan de abrirse con la llave de la máquina a
+      // abrirse con la frase. Hay que volver a cerrar la copia maestra con la nueva, o
+      // quedarían ilegibles. Si el perfil YA tenía contraseña, hace falta la vieja para
+      // poder abrirla: por eso el camino normal para cambiarla es quitarla y ponerla.
+      case 'password-set': {
+        const id = ref()
+        const tenia = !!mgr.profiles.get(id)?.protected
+        if (tenia && !req.current) throw new Error('this profile already has a password: remove it first (`profile password --rm`) and then set the new one')
+        const vieja = tenia ? await mgr.profiles.adminKey(id, req.current) : null
+        await mgr.profiles.setPassword(id, req.password)
+        const nueva = await mgr.profiles.adminKey(id, req.password)
+        await rekey(id, vieja, nueva)
+        return { done: 'contraseña guardada' }
+      }
+      // QUITARLA: al revés. Se abre la copia maestra con la frase y se vuelve a cerrar
+      // con la llave de la máquina, que es la protección de siempre — el disco sigue
+      // cifrado, pero su material vive en ese mismo disco.
+      case 'password-rm': {
+        const id = ref()
+        if (!req.password) throw new Error('removing the password needs the current one: the secrets must be re-sealed before it goes')
+        const vieja = await mgr.profiles.adminKey(id, req.password)
+        await rekey(id, vieja, null)
+        mgr.profiles.removePassword(id)
+        return { done: 'contraseña quitada · los secretos ahora se abren con la llave de esta máquina' }
+      }
       default: throw new Error('unknown profile operation: ' + req.op)
     }
   }
@@ -278,25 +362,75 @@ export async function runDaemon () {
       // 0700 del vault y se borra al consumir.
       const sec = readJsonSafe(secretReqFile)
       if (sec?.op) {
-        rm(secretReqFile)
+        rm(secretReqFile) // puede llevar la contraseña: fuera del disco cuanto antes
+        lastSecretError = null
         try {
           const vault = targetOf(sec)
           // Carga en GRUPO (`secret set ns K=v K2=v2`, `secret import`): todas las
           // variables entran de una vez y sale UN solo aviso de cambio, para que el
           // servicio no se reinicie a media carga y arranque con la mitad puesta.
-          if (sec.op === 'batch') {
+          // La CONTRASEÑA, si vino, se convierte en la llave que abre la copia de
+          // RECUPERACIÓN, y no se guarda en ningún sitio: se usa y se suelta. Desde v5
+          // solo la piden las operaciones que LEEN —ver un valor, cambiar su visibilidad,
+          // convertir el archivo, rotar re-cifrando—: escribir no (§8.1). Sin ella se cae
+          // a la llave de la máquina, que es la protección de antes de esto (y el vault lo
+          // avisa al arrancar).
+          const ak = sec.password ? await mgr.profiles.adminKey(sec.profile ? mgr.resolve(sec.profile) : mgr.currentId(), sec.password) : undefined
+          if (sec.op === 'migrate') {
+            // Sin lista a mano: la pone el vault, y es la MISMA que usa cualquier
+            // escritura (servicios del cajón + aparatos que administran). Con una lista
+            // propia aquí, lo convertido quedaba sellado solo a los servicios y el dueño
+            // no podía ver desde su consola nada de lo que ya tenía.
+            const r = await vault.migrateSecrets(null, ak)
+            if (!r.migrated) console.log('[vault] nothing to migrate: %s', r.reason)
+            else {
+              console.log('[vault] secrets SEALED (v%d -> v5). Backup left at secrets.json.v%d.bak', r.from, r.from)
+              for (const [owner, sin] of Object.entries(r.sinLlave || {})) {
+                console.log('[vault] WARNING %s: %d member(s) without an encryption key will NOT read their variables', owner, sin.length)
+              }
+            }
+          } else if (sec.op === 'batch') {
             const changed = sec.pub
-              ? await vault.applyDeviceSecrets(sec.pub, sec.items)
-              : vault.applySecrets(sec.ns, sec.items)
+              ? await vault.applyDeviceSecrets(sec.pub, sec.items, { by: null })
+              : await vault.applySecrets(sec.ns, sec.items, { by: null })
             console.log('[vault] %d secret(s) applied in one go: %s', changed.length, sec.pub ? 'device' : sec.ns)
-          } else if (sec.op === 'set') { vault.setSecret(sec.ns, sec.key, sec.value, sec.public); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
-          else if (sec.op === 'rm') { vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
+          } else if (sec.op === 'set') { await vault.setSecret(sec.ns, sec.key, sec.value, sec.public); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
+          else if (sec.op === 'rm') { await vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
           else if (sec.op === 'dev-set') { await vault.setDeviceSecret(sec.pub, sec.key, sec.value, sec.public); console.log('[vault] device secret saved: %s', sec.key) }
           else if (sec.op === 'dev-rm') { await vault.deleteDeviceSecret(sec.pub, sec.key); console.log('[vault] device secret deleted: %s', sec.key) }
+          // Saldar lo que quedó a deber: heredarle a un aparato nuevo lo ya guardado y
+          // rotar de verdad el cajón del que salió alguien. Las dos cosas abren, así que
+          // van con la frase — y por eso se hacen aquí y no al escribir.
+          else if (sec.op === 'settle') {
+            const r = await vault.settleSecretDebts(ak)
+            const n = Object.keys(r).length
+            console.log(n ? `[vault] ${n} pending drawer(s) settled` : '[vault] nothing pending')
+          }
+          // Ver el valor de una privada: lo único que la frase guarda (§8.3).
+          else if (sec.op === 'reveal') {
+            const value = await vault.revealSecret(sec.owner, sec.key, ak)
+            lastSecretValue = { owner: sec.owner, key: sec.key, value }
+          }
+          // Qué versiones anteriores hay (sin valores: son sobres).
+          else if (sec.op === 'history') {
+            lastSecretHistory = { owner: sec.owner || null, key: sec.key || null, items: vault.secretHistory(sec.owner || null, sec.key || null) }
+          }
+          // REVERTIR: abrir la versión vieja (frase) y volver a guardarla (nada).
+          else if (sec.op === 'revert') {
+            const ok = await vault.revertSecret(sec.owner, sec.key, sec.ts, { adminKey: ak })
+            if (!ok) throw new Error('that version is not in the history any more')
+            console.log('[vault] secret reverted: %s/%s', sec.owner, sec.key)
+          }
           // Visibilidad: si el valor puede salir hacia la consola remota. No toca el valor.
-          else if (sec.op === 'vis') { vault.setSecretVisibility(sec.ns, sec.key, sec.public); console.log('[vault] secret visibility: %s/%s → %s', sec.ns, sec.key, sec.public ? 'public' : 'private') }
-          else if (sec.op === 'dev-vis') { await vault.setDeviceSecretVisibility(sec.pub, sec.key, sec.public); console.log('[vault] device secret visibility: %s → %s', sec.key, sec.public ? 'public' : 'private') }
-        } catch (e) { console.error('[vault] secret failed:', e.message) }
+          else if (sec.op === 'vis') { await vault.setSecretVisibility(sec.ns, sec.key, sec.public, ak); console.log('[vault] secret visibility: %s/%s → %s', sec.ns, sec.key, sec.public ? 'public' : 'private') }
+          else if (sec.op === 'dev-vis') { await vault.setDeviceSecretVisibility(sec.pub, sec.key, sec.public, ak); console.log('[vault] device secret visibility: %s → %s', sec.key, sec.public ? 'public' : 'private') }
+        } catch (e) {
+          lastSecretError = {
+            error: e.message,
+            code: e.code || (/wrong password/i.test(e.message) ? 'WRONG_PASSWORD' : 'SECRET_FAILED')
+          }
+          console.error('[vault] secret failed:', e.message)
+        }
       }
       // Perfiles / candado.
       const preq = readJsonSafe(profileReqFile)
@@ -376,8 +510,21 @@ export async function runDaemon () {
         writeJson(secretsListFile, {
           v: 2, at: Date.now(), req: reqId, profile: t.id,
           ns: t.vault.listSecrets(),
-          dev: await t.vault.listDeviceSecrets()
+          dev: await t.vault.listDeviceSecrets(),
+          // Lo que quedó a deber un sellado. Va en el volcado porque si no se ve, no se
+          // salda: son cajones cuyos miembros NO están leyendo sus variables.
+          pending: await t.vault.secretDebts(),
+          // Y quién NO puede abrir lo suyo. Es lo mismo visto desde el aparato, que es
+          // como lo mira quien administra: «este servicio está en el acta y aun así no
+          // arranca». Sin esto solo se veía en el log del propio servicio.
+          incomplete: await t.vault.incompleteMembers(),
+          ...(lastSecretError ? { secretError: lastSecretError } : {}),
+          ...(lastSecretValue ? { revealed: lastSecretValue } : {}),
+          ...(lastSecretHistory ? { history: lastSecretHistory } : {})
         })
+        lastSecretError = null
+        lastSecretValue = null
+        lastSecretHistory = null
         writeJson(devFile, { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.listDevices()) })
         // Acta del perfil: quién es del perfil y qué puede hacer cada uno (`members`/`caps`).
         try { writeJson(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.profileMembers()) }) } catch (_) {}