@dotrino/vaultd 0.49.1 → 0.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.49.1",
+  "version": "0.52.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -20,8 +20,9 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.58.0",
-    "@dotrino/proxy-client": "^0.10.1",
+    "@dotrino/identity": "^0.61.0",
+    "@dotrino/passmanager": "^0.1.0",
+    "@dotrino/proxy-client": "^0.13.1",
     "ws": "^8.18.0"
   },
   "license": "MIT",

package/src/approvals.js

@@ -1,38 +1,30 @@
 /**
- * PEDIDOS DE APROBACIÓN y VENTANAS de un cajón con `approval` (puro: sin red ni disco).
+ * PEDIDOS DE APROBACIÓN (puro: sin red ni disco).
  *
- * Cuando un cajón exige aprobación por uso, leerlo ya no depende solo de tener el cert:
- * el vault apunta el pedido, avisa a los aparatos con `approve` (el teléfono), y solo su
- * firma libera los secretos. Aprobado, se abre una VENTANA para ese aparato y ese cajón
- * (15 min): una sesión de trabajo no pide veinte veces. Lo que nadie aprueba vence solo.
+ * Un aparato marcado con `approval on` no recibe claves privadas solo por tener el cert: el
+ * vault apunta el pedido, avisa a los aparatos con `approve` (el teléfono), y solo su firma
+ * libera los secretos. No hay ventana: cada petición es un pedido, y para un servicio bien
+ * hecho eso es UNA por arranque (pide al iniciar, se queda las claves en memoria). Lo que
+ * nadie aprueba vence solo a los 5 min.
  *
- * Lo que se guarda de cada pedido es lo justo para contestar después: el cajón, quién
- * pide y su llave efímera `ek` (a la que se sella la respuesta). Nunca un valor.
+ * Lo que se guarda de cada pedido es lo justo para contestar después: el cajón, quién pide
+ * y su llave efímera `ek` (a la que se sella la respuesta). Nunca un valor.
  */
 const rnd = () => [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.toString(16).padStart(2, '0')).join('')
 
 export const PENDING_TTL_MS = 5 * 60 * 1000
-export const GRANT_TTL_MS = 15 * 60 * 1000
 
-export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS, grantTtlMs = GRANT_TTL_MS } = {}) {
+export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS } = {}) {
   /** id → { id, ns, device, deviceId, label, ek, ts, exp } */
   const pending = new Map()
-  /** `${ns}|${device}` → exp */
-  const grants = new Map()
-  const gkey = (ns, device) => ns + '|' + device
-
-  const publicOf = (p) => ({ id: p.id, kind: p.kind, ns: p.ns, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp, ...(p.ssh ? { ssh: p.ssh } : {}) })
+  const publicOf = (p) => ({ id: p.id, ns: p.ns, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp })
 
   return {
-    /**
-     * Apunta un pedido. `kind`: `secrets` (leer un cajón; uno por cajón y aparato: pedir
-     * otra vez reemplaza al anterior) o `ssh` (firmar un reto SSH con la llave del
-     * teléfono; cada firma es un pedido, con `ssh: { key, data }` y sus callbacks).
-     */
-    request ({ kind = 'secrets', ns, device = null, deviceId, label = '', ek = null, ssh = null, resolve = null, reject = null }) {
-      if (kind === 'secrets') for (const [id, p] of pending) if (p.kind === 'secrets' && p.ns === ns && p.device === device) pending.delete(id)
+    /** Apunta un pedido. Uno por cajón y aparato: pedir otra vez reemplaza al anterior. */
+    request ({ ns, device, deviceId, label = '', ek }) {
+      for (const [id, p] of pending) if (p.ns === ns && p.device === device) pending.delete(id)
       const ts = now()
-      const p = { id: rnd(), kind, ns, device, deviceId, label, ek, ssh, resolve, reject, ts, exp: ts + pendingTtlMs }
+      const p = { id: rnd(), ns, device, deviceId, label, ek, ts, exp: ts + pendingTtlMs }
       pending.set(p.id, p)
       return publicOf(p)
     },
@@ -45,25 +37,13 @@ export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS
       if (p) pending.delete(id)
       return p || null
     },
-    /** Abre la ventana de ese aparato sobre ese cajón. */
-    grant (ns, device) { const exp = now() + grantTtlMs; grants.set(gkey(ns, device), exp); return exp },
-    /** ¿Sigue abierta la ventana? */
-    has (ns, device) {
-      const exp = grants.get(gkey(ns, device))
-      if (exp == null) return false
-      if (exp <= now()) { grants.delete(gkey(ns, device)); return false }
-      return true
-    },
-    /** Cierra las ventanas de un aparato (al revocarlo, por ejemplo). */
-    forget (device) { for (const k of [...grants.keys()]) if (k.endsWith('|' + device)) grants.delete(k) },
     /** Tira lo vencido; devuelve los pedidos que vencieron, para anotarlos. */
     sweep () {
       const t = now(); const gone = []
-      for (const [id, p] of pending) if (p.exp <= t) { pending.delete(id); gone.push(publicOf(p)); try { p.reject?.(new Error('approval: nobody approved the request in time')) } catch (_) {} }
-      for (const [k, exp] of grants) if (exp <= t) grants.delete(k)
+      for (const [id, p] of pending) if (p.exp <= t) { pending.delete(id); gone.push(publicOf(p)) }
       return gone
     }
   }
 }
 
-export default { createApprovals, PENDING_TTL_MS, GRANT_TTL_MS }
+export default { createApprovals, PENDING_TTL_MS }

package/src/ctl.js

@@ -128,7 +128,6 @@ 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 || []
@@ -188,21 +187,27 @@ async function cmdPair (args = []) {
   // `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`).
+  // --approval: el aparato que entre pedirá tu aprobación (teléfono) en cada petición de
+  // claves privadas. Por defecto NO pide; se cambia después con `caps <ID> +permiso`.
+  const approval = args.includes('--approval')
   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' }
+    const ALIAS = { firma: 'sign', lee: 'read', guarda: 'store', contrasenas: 'passwords', 'contraseñas': 'passwords' }
     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 }
+      // El gestor de contraseñas SÍ se empareja con su permiso puesto: es lo único que
+      // va a hacer ese aparato, y pedirlo en dos pasos era el paso que nadie daba.
+      if (t === 'passwords') { scope.push('vault:passwords'); 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)
+      console.error('permiso desconocido: %s  (sign | read | store | contrasenas | secrets:<ns>)', tok); process.exit(2)
     }
     if (service) scope.push('vault:secrets:' + service)
     scope = [...new Set(scope)]
@@ -238,7 +243,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 } : {}), ...(scope ? { scope } : {}), ...(adopt ? { mode: 'adopt' } : {}) })
+  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(scope ? { scope } : {}), ...(adopt ? { mode: 'adopt' } : {}), ...(approval ? { approval: true } : {}) })
   sendSignal(s.pid, 'SIGUSR1')
 
   let pair = null
@@ -265,14 +270,14 @@ async function cmdPair (args = []) {
   console.log(`${R}${B}⚠ Este código deja LEER tus datos y FIRMAR con tu identidad.${Z}`)
   console.log(`${R}  NO lo compartas con nadie, ni con "soporte". Solo escanéalo en TU dispositivo.${Z}`)
   console.log('\nO abre esta dirección en el dispositivo:\n  ' + url)
-  console.log('\nO pega este código en vault.dotrino.com/dispositivos :\n  ' + b64)
+  console.log('\nO pega este código en vault.dotrino.com/vault :\n  ' + b64)
 
   // --save [archivo]: escribe la invitación (.dpair) para transferirla y abrirla en profile.
   const saveIdx = args.indexOf('--save')
   if (saveIdx >= 0) {
     const next = args[saveIdx + 1]
     const file = (next && !next.startsWith('-')) ? next : 'dotrino-invite.dpair'
-    try { fs.writeFileSync(file, url + '\n', { mode: 0o600 }); console.log('\nInvitación guardada en: %s\n  (ábrela en vault.dotrino.com/dispositivos → «Abrir imagen o archivo». Es efímera y de un solo uso; no la compartas.)', file) }
+    try { fs.writeFileSync(file, url + '\n', { mode: 0o600 }); console.log('\nInvitación guardada en: %s\n  (ábrela en vault.dotrino.com/vault → «Abrir imagen o archivo». Es efímera y de un solo uso; no la compartas.)', file) }
     catch (e) { console.error('No se pudo guardar la invitación:', e.message) }
   }
 
@@ -402,7 +407,8 @@ async function cmdMembers () {
     // 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 | +aprueba')
+  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +contrasenas | +permiso')
+  console.log('  «Permiso»: ese aparato solo recibe claves privadas cuando lo apruebas desde un aparato con «aprueba» (en cada arranque).')
   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')
@@ -444,47 +450,55 @@ async function findMember (id) {
 }
 
 /**
- * `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.
+ * `dotrino-vault approval <ID> on|off` — ese aparato solo recibe claves privadas con el
+ * visto bueno de un aparato con `aprueba` (el teléfono). Es propiedad del APARATO, no del
+ * cajón: el VPS desatendido no pide; la PC del dueño sí. Pide en cada petición, que para un
+ * servicio bien hecho es una por arranque.
  */
-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')
+async function cmdApproval (args = []) {
+  const [id, val] = args
+  if (!id || !['on', 'off'].includes(val)) { console.error('uso: dotrino-vault approval <ID> on|off'); process.exit(2) }
+  const m = await findMember(id)
+  writeReq('secret-request.json', { op: 'approval', pub: m.pub, id: m.id, approval: val === 'on' })
+  sendSignal(requireDaemon().pid, 'SIGUSR2')
+  console.log(val === 'on'
+    ? `Listo: ${m.id} solo recibirá claves privadas cuando un aparato con  caps <ID> +aprueba  lo apruebe (en cada arranque).`
+    : `Listo: ${m.id} vuelve a recibir sus claves sin aprobación.`)
 }
 
 /** `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|+aprueba|-aprueba')
+    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra|+aprueba|-aprueba|+contrasenas|-contrasenas|+permiso|-permiso')
     process.exit(2)
   }
   const CAP_BY_WORD = {
     firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin', aprueba: 'approve',
-    sign: 'sign', store: 'store', read: 'read', admin: 'admin', approve: 'approve'
+    // `contraseñas`: el gestor (la extensión, la app del teléfono) puede PEDIR
+    // credenciales de a una. Se acepta con y sin tilde: nadie escribe la ñ en una CLI.
+    contrasenas: 'passwords', 'contraseñas': 'passwords',
+    sign: 'sign', store: 'store', read: 'read', admin: 'admin', approve: 'approve',
+    passwords: 'passwords'
   }
   const s = requireDaemon()
   const m = await findMember(id)
 
-  const caps = new Set(m.caps)
+  // `+permiso` / `-permiso` no es una capacidad del acta: es la marca de la bóveda «este
+  // aparato pide aprobación al recibir claves». Se cambia aquí, como cualquier permiso.
+  const rest = []
   for (const c of changes) {
+    const w = c.slice(1).toLowerCase()
+    if ((c[0] === '+' || c[0] === '-') && (w === 'permiso' || w === 'approval')) {
+      writeReq('secret-request.json', { op: 'approval', pub: m.pub, id: m.id, approval: c[0] === '+' })
+      sendSignal(s.pid, 'SIGUSR2')
+      console.log(c[0] === '+' ? `Listo: ${m.id} pedirá tu aprobación en cada petición de claves.` : `Listo: ${m.id} ya no pide aprobación.`)
+      await sleep(300)
+    } else rest.push(c)
+  }
+  if (!rest.length) return
+  const caps = new Set(m.caps)
+  for (const c of rest) {
     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) }
@@ -737,7 +751,6 @@ async function cmdSecret (rest) {
     '     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',
@@ -848,95 +861,6 @@ async function cmdSecret (rest) {
   }
 
   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()
     const names = d.ns || {}
@@ -1247,7 +1171,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;
+  pair --approval       el aparato que entre pedirá tu aprobación (teléfono) al recibir claves
+  pair --scope <lista>  los PERMISOS del cert: sign,read,store,contrasenas,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
@@ -1286,7 +1211,7 @@ function help () {
   me                  tu perfil (nombre, foto, datos) tal como lo tiene la bóveda
   members             el acta del perfil: quién es tuyo y qué puede hacer
   label <ID> <nombre> renombra un dispositivo (el nombre con el que lo reconoces)
-  caps <ID> ±permiso  cambia permisos (+firma -guarda +administra …)
+  caps <ID> ±permiso  cambia permisos (+firma -guarda +administra +contrasenas …)
   revoke <ID|nonce>   quita un dispositivo (con el ID, todos sus certificados)
   activity [n]        bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
   logs                últimos logs del servicio
@@ -1335,7 +1260,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 'approval': return cmdApproval(rest)
     case 'activity': return cmdActivity(Number(rest[0]) || 30)
     case 'logs': return cmdLogs()
     case 'version':

package/src/daemon.js

@@ -17,7 +17,6 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { startVaultManager } from './manager.js'
-import { startSshAgent, defaultSocketPath } from './sshAgent.js'
 import { dataDir, writeJson, readJson } from './paths.js'
 import { VERSION } from './version.js'
 
@@ -64,14 +63,6 @@ export async function runDaemon () {
 
   const mgr = await startVaultManager({ root: dir, proxyUrl, onEnrollChallenge })
 
-  // --- agente SSH (la llave vive en el teléfono; ver sshAgent.js). `DOTRINO_VAULT_SSH_AGENT=0`
-  // lo apaga; cualquier otro valor es la ruta del socket.
-  let sshAgent = null
-  if (process.env.DOTRINO_VAULT_SSH_AGENT !== '0' && process.platform !== 'win32') {
-    const socketPath = process.env.DOTRINO_VAULT_SSH_AGENT || defaultSocketPath(dir)
-    try { sshAgent = startSshAgent({ socketPath, vault: () => mgr.current(), log: console.log }) } catch (e) { console.error('[vault] ssh-agent could not start: %s', e.message) }
-  }
-
   // --- state.json ---
   const stateFile = path.join(dir, 'state.json')
   const daemonVersion = VERSION
@@ -82,7 +73,7 @@ export async function runDaemon () {
     const cur = mgr.summary().find((p) => p.current) || {}
     writeJson(stateFile, {
       v: 2, version: daemonVersion, fingerprint: cur.fingerprint || null, iss: cur.iss || null,
-      proxy: proxyUrl, pid: process.pid, startedAt: new Date().toISOString(), sshAgent: sshAgent?.socketPath || null,
+      proxy: proxyUrl, pid: process.pid, startedAt: new Date().toISOString(),
       current: mgr.currentId(), profiles: mgr.summary()
     })
   }
@@ -127,6 +118,7 @@ export async function runDaemon () {
 
   // --- SIGUSR1: iniciar emparejamiento ---
   const pairFile = path.join(dir, 'pair.json')
+  let pendingApproval = false // lo pidió `pair --approval`; se aplica al aprobar
   const pairReqFile = path.join(dir, 'pair-request.json')
   async function handlePairingRequest () {
     try {
@@ -166,7 +158,12 @@ export async function runDaemon () {
       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')
+      // La etiqueta por defecto de un servicio es su ns a secas: la lista ya marca [servicio «ns»],
+      // y el prefijo «service:» confundía (el cajón se llama claude, no service:claude).
+      const label = pairReq?.label || (isService ? pairReq.service : 'cli')
+      // `pair --approval`: el aparato que entre por esta invitación pedirá el visto bueno del
+      // teléfono cada vez que reciba claves privadas (se aplica al aprobarlo, abajo).
+      pendingApproval = !!pairReq?.approval
       // `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
       // tiene que verlo (lo muestran la TUI y `dotrino-vault pair`). El nombre viaja
@@ -327,6 +324,8 @@ export async function runDaemon () {
           const vault = targetOf(appr)
           if (!vault) throw Object.assign(new Error('profile locked'), { code: 'PROFILE_LOCKED' })
           const r = await vault.approveDevice(appr.code); rm(pendingEnrollFile); rm(pairFile)
+          if (pendingApproval && r?.cert?.sub) { try { await vault.setApproval(r.cert.sub, true); console.log('[vault] the new device will need approval on every key request') } catch (e) { console.error('[vault] could not flag approval: %s', e.message) } }
+          pendingApproval = false
           console.log('[vault] aprobado %s', r.deviceId)
           answer({ ok: true, deviceId: r.deviceId || null })
         } catch (e) {
@@ -406,7 +405,7 @@ export async function runDaemon () {
             console.log('[vault] %d secret(s) applied in one go: %s', changed.length, sec.pub ? 'device' : sec.ns)
           } 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 === 'policy') { const r = await vault.setSecretPolicy(sec.ns, { approval: !!sec.approval }); console.log('[vault] %s: approval %s', sec.ns, r.approval ? 'REQUIRED (15 min window)' : 'off') }
+          else if (sec.op === 'approval') { const r = await vault.setApproval(sec.pub, !!sec.approval); console.log('[vault] device %s: approval %s', sec.id || '?', r.approval ? 'REQUIRED on every key request' : 'off') }
           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
@@ -616,7 +615,6 @@ export async function runDaemon () {
   const shutdown = (sig) => {
     console.log(`\n[vault] ${sig} → deteniendo…`)
     rm(pairFile); rm(pendingEnrollFile)
-    try { sshAgent?.close() } catch (_) {}
     try { mgr.close() } catch (_) {}
     process.exit(0)
   }

package/src/passwords.js

@@ -0,0 +1,81 @@
+/**
+ * LA BÓVEDA DE CONTRASEÑAS del dueño, atendida por el vault.
+ *
+ * `dotrino-passmanager serve` es la versión mínima: bóveda propia, aprobación por
+ * consola, bitácora propia. Esto es lo mismo pero dentro del vault, que ya tiene lo
+ * que allí había que improvisar:
+ *
+ *   · el ACTA dice qué aparatos existen y qué puede cada uno
+ *   · la APROBACIÓN ya sabe avisar al teléfono y esperar su firma (`caps +aprueba`)
+ *   · la BITÁCORA ya existe y es la misma que audita firmas y enrolamientos
+ *
+ * Lo que NO cambia es el protocolo: un aparato pide una credencial por dominio y
+ * recibe esa sola. `list` sigue sin existir en remoto.
+ *
+ * Módulo aislado a propósito: recibe todo lo que necesita y no toca el núcleo. Un
+ * fallo aquí no puede tumbar la CA.
+ */
+
+import { LocalVault, VaultResponder } from '@dotrino/passmanager'
+
+export const PASSWORDS_CAP = 'passwords'
+
+/**
+ * @param {object} opts
+ *   `client`      cliente del proxio del vault, ya identificado
+ *   `store`       `{ get(k), set(k,v) }` donde viven las entradas cifradas
+ *   `cek`         la llave de la bóveda de contraseñas (CryptoKey AES-GCM)
+ *   `isAllowed(pubkey)`   qué aparatos pueden pedir — lo decide el acta, no esto
+ *   `encPubOf(pubkey)`    su llave de cifrado, para sellarle la respuesta
+ *   `needsApproval(pubkey)`  si ese aparato está marcado para aprobar
+ *   `approve({ pubkey, op })`  pide el visto bueno (el teléfono) y espera
+ *   `devices()` / `unlink(pubkey)`   administración, opcional
+ *   `audit(op, info)`  la bitácora del vault
+ */
+export function createPasswordDesk (opts = {}) {
+  const {
+    client, store, cek,
+    isAllowed = () => false,
+    encPubOf = () => null,
+    needsApproval = () => true,
+    approve = async () => false,
+    devices = null,
+    unlink = null,
+    audit = () => {},
+    log = () => {},
+  } = opts
+
+  const vault = new LocalVault(store)
+  if (cek) vault.unlock(cek)
+
+  const responder = new VaultResponder({
+    client,
+    vault,
+    isAllowed,
+    encPubOf,
+    // La aprobación es del APARATO y dura mientras el vault siga encendido, igual que
+    // los cajones de secretos: una por arranque, sin ventana que vigilar.
+    needsApproval: (op, _payload, pubkey) => op === 'get' && needsApproval(pubkey),
+    approve,
+    admin: devices && unlink ? { devices, unlink } : null,
+    onRequest: (r) => {
+      // La bitácora NO lleva qué credencial se pidió: eso es contenido del usuario y
+      // el criterio del vault es apuntar la operación, no el payload.
+      audit('passwords', { op: r.op, outcome: r.outcome, device: (r.from || '').slice(0, 24) })
+      if (r.outcome !== 'served') {
+        log('[vault] passwords: %s %s', r.op, r.outcome)
+      }
+    },
+  })
+
+  return {
+    start () { responder.start(); return this },
+    stop () { responder.stop() },
+    /** Al bloquear el perfil, la bóveda de contraseñas se cierra con él. */
+    lock () { vault.lock() },
+    unlock (nuevaCek) { vault.unlock(nuevaCek) },
+    /** Para la consola local: aquí SÍ se puede listar, porque aquí está la llave. */
+    vault,
+    responder,
+  }
+}

package/src/secretsStore.js

@@ -159,11 +159,9 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
   if (!data) data = { schemaVersion: SCHEMA_VERSION, ns: {}, dev: {}, recovery: null, history: [] }
   if (!data.dev) data.dev = {}
   if (!data.history) data.history = []
-  // 0.47.0/0.48.0 guardaron la política DENTRO del cajón; se saca a `policies` al abrir.
-  for (const [ns, bag] of Object.entries(data.ns || {})) {
-    const stray = bag?.policy && typeof bag.policy === 'object' && !('v' in bag.policy) ? bag.policy : null
-    if (stray) { delete bag.policy; if (stray.approval) { if (!data.policies) data.policies = {}; data.policies[ns] = { approval: true } } }
-  }
+  // 0.47.0/0.48.0 guardaron una «política» DENTRO del cajón (salía como variable): fuera.
+  for (const bag of Object.values(data.ns || {})) if (bag?.policy && typeof bag.policy === 'object' && !('v' in bag.policy)) delete bag.policy
+  delete data.policies
 
   // v3 → v5 y v4 → v5 NO se hacen al abrir, y es deliberado: el daemon tiene que poder
   // arrancar y SERVIR sin nada (un perfil bloqueado sigue atendiendo a sus agentes). Un
@@ -593,30 +591,6 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       for (const ns of Object.keys(data.ns)) out[ns] = names(data.ns, ns)
       return out
     },
-    /**
-     * POLÍTICA de un cajón. Hoy una sola: `approval` — cada lectura espera el visto bueno
-     * de un aparato con `approve` (ver `approvals.js`). Los cajones de los servicios que
-     * corren solos (proxio, geo) van sin ella: no pueden esperar a un teléfono.
-     *
-     * Vive APARTE de las variables (`data.policies`), no dentro del cajón: en el formato
-     * v3 el cajón ES el mapa de variables y cualquier cosa que se meta ahí se reparte como
-     * si fuera una (pasó: `policy` salió en la lista y en el bundle).
-     */
-    policyOf (ns) { assertNs(ns); return { approval: !!data.policies?.[ns]?.approval } },
-    setPolicy (ns, patch) {
-      assertNs(ns)
-      if (!data.policies) data.policies = {}
-      data.policies[ns] = { ...(data.policies[ns] || {}), ...patch }
-      if (!data.policies[ns].approval) delete data.policies[ns]
-      save()
-      return this.policyOf(ns)
-    },
-    /** Solo los cajones con alguna política puesta (ns → política). */
-    policies () {
-      const out = {}
-      for (const [ns, p] of Object.entries(data.policies || {})) if (p?.approval) out[ns] = { approval: true }
-      return out
-    },
     /** Nombres y visibilidad (pub → [{key, public}]), sin valores. */
     listDevices () {
       const out = {}

package/src/tui/app.js

@@ -318,7 +318,7 @@ function pairModeRows (st, t) {
  * una marca de si los tiene. El de administrar va aparte y avisado: es el único que deja
  * a ese aparato meter y sacar dispositivos sin venir aquí.
  */
-const CAPS_ORDER = ['sign', 'store', 'read', 'admin']
+const CAPS_ORDER = ['sign', 'store', 'read', 'admin', 'passwords']
 
 function capsRows (st, t) {
   const i = L(st)