@dotrino/vaultd 0.49.0 → 0.51.0

package/src/vault.js

@@ -23,7 +23,6 @@ import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
 import { openSecretsStore, assertVar } from './secretsStore.js'
 import { createApprovals } from './approvals.js'
-import { parsePublicKey, sshSignature } from './sshKeys.js'
 import { makeSealer } from './sealer.js'
 import { openSealKeys } from './sealKey.js'
 import { seal } from '../lib/src/sealed.js'
@@ -31,6 +30,13 @@ import { dataDir, ensureDir } from './paths.js'
 import { atRestFor, machineKey, migrateFile } from './atrest.js'
 import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
 
+/**
+ * Tope de una respuesta de la bóveda por el transporte. El proxio (`PROXY_MAX_FRAME_BYTES`)
+ * corta el frame a 1 MB, y el sobre del proxio (destinatarios, tipos) va por encima de esto:
+ * se deja margen en vez de apurar el límite.
+ */
+const MAX_REPLY_BYTES = 768 * 1024
+
 /**
  * Abre UN perfil del vault (una maestra, un dir, una conexión al proxy). El
  * daemon multi-perfil (`manager.js`) levanta uno de estos por perfil.
@@ -72,7 +78,96 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const store = openStore(dir)
   const threads = openThreadStore(dir)
   const approvals = createApprovals()
-  const approvalsSweeper = setInterval(() => { for (const g of approvals.sweep()) audit(g.kind === 'ssh' ? 'ssh.expired' : 'secrets.expired', { id: g.id, ns: g.ns, device: g.deviceId }) }, 30 * 1000); approvalsSweeper.unref?.()
+
+  /**
+   * Pedidos de aprobación que NO son de un cajón de secretos: quien espera es una
+   * promesa dentro del vault (la bóveda de contraseñas), no un aparato aguardando un
+   * sobre sellado. `id` del pedido → `resolve(boolean)`.
+   *
+   * Aparte a propósito: `approvals` es un módulo puro y no tiene por qué saber que hay
+   * dos clases de espera.
+   */
+  const waiters = new Map()
+  // APARATOS QUE PIDEN APROBACIÓN: una lista de llaves en `approval.json` (cifrado en reposo
+  // como todo el dir). Es decisión de esta bóveda, no del acta: es ella la que entrega.
+  const approvalFile = path.join(dir, 'approval.json')
+  const approvalAtRest = atRestFor(dir)
+  const readSupervised = () => { try { const d = JSON.parse(approvalAtRest.decrypt(fs.readFileSync(approvalFile, 'utf8'))); return Array.isArray(d?.members) ? d.members : [] } catch (_) { return [] } }
+  const needsApproval = (pub) => readSupervised().includes(pub)
+  async function setApproval (pub, on) {
+    const cur = new Set(readSupervised())
+    if (on) cur.add(pub); else cur.delete(pub)
+    fs.writeFileSync(approvalFile, approvalAtRest.encrypt(JSON.stringify({ v: 1, members: [...cur] })), { mode: 0o600 })
+    audit('approval', { device: await deviceIdOf(pub).catch(() => null), on: !!on })
+    return { approval: !!on }
+  }
+  // LA BÓVEDA DE CONTRASEÑAS: entradas y su llave, en el dir del perfil y cifradas en
+  // reposo como todo lo demás. Quién puede pedir es una LISTA DE ESTA BÓVEDA, no del
+  // acta — por lo mismo que `approval.json`: es ella la que entrega. El acta sigue
+  // mandando en que el aparato exista y no esté revocado, y eso se comprueba aparte.
+  const passwordsFile = path.join(dir, 'passwords.json')
+  const passwordsAtRest = atRestFor(dir)
+  const readPasswordsFile = () => {
+    try { return JSON.parse(passwordsAtRest.decrypt(fs.readFileSync(passwordsFile, 'utf8'))) } catch (_) { return null }
+  }
+  const writePasswordsFile = (d) => {
+    fs.writeFileSync(passwordsFile, passwordsAtRest.encrypt(JSON.stringify(d)), { mode: 0o600 })
+  }
+
+  /** El almacén que espera `@dotrino/passmanager`. Todo en un archivo, cifrado en reposo. */
+  const passwordsStore = {
+    async get (k) { return readPasswordsFile()?.data?.[k] },
+    async set (k, v) {
+      const d = readPasswordsFile() || { v: 1, data: {}, devices: [] }
+      d.data = { ...(d.data || {}), [k]: v }
+      writePasswordsFile(d)
+    },
+  }
+
+  const passwordDevices = () => readPasswordsFile()?.devices || []
+
+  /**
+   * El acta vigente, en caché.
+   *
+   * `isAllowed`/`encPubOf` del responder son SÍNCRONOS (se llaman por cada mensaje que
+   * entra, y leer el acta ahí sería un await por mensaje), así que se refresca aparte.
+   * Se relee cada pocos segundos: revocar un aparato tarda eso en cortarle el acceso,
+   * no un reinicio.
+   */
+  let actaCache = null
+  const refreshActa = async () => {
+    try { actaCache = (await identity.profileActa?.().catch(() => null))?.acta || null } catch (_) {}
+    return actaCache
+  }
+
+  /**
+   * La llave de la bóveda de contraseñas. Nace con el primer uso y vive cifrada en
+   * reposo, como la identidad: aquí no hace falta envolverla a cada aparato porque
+   * ningún aparato abre la bóveda — piden de a una y el vault responde.
+   */
+  async function passwordsKey () {
+    const d = readPasswordsFile()
+    if (d?.cek) {
+      const raw = Uint8Array.from(Buffer.from(d.cek, 'base64'))
+      return crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt'])
+    }
+    const key = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt'])
+    const raw = new Uint8Array(await crypto.subtle.exportKey('raw', key))
+    writePasswordsFile({ ...(d || { v: 1, data: {} }), cek: Buffer.from(raw).toString('base64'), devices: d?.devices || [] })
+    return key
+  }
+
+  /** Autorizar/retirar un aparato para pedir contraseñas (`dotrino-vault passwords`). */
+  async function setPasswordDevice (pub, { label = '', on = true } = {}) {
+    const d = readPasswordsFile() || { v: 1, data: {}, devices: [] }
+    const resto = (d.devices || []).filter((x) => x.pubkey !== pub)
+    if (on) resto.push({ pubkey: pub, label: String(label || '').slice(0, 60), ts: Date.now() })
+    writePasswordsFile({ ...d, devices: resto })
+    audit('passwords.device', { device: await deviceIdOf(pub).catch(() => null), on: !!on })
+    return { ok: true }
+  }
+
+  const approvalsSweeper = setInterval(() => { for (const g of approvals.sweep()) audit('secrets.expired', { id: g.id, ns: g.ns, device: g.deviceId }) }, 30 * 1000); approvalsSweeper.unref?.()
   const secrets = openSecretsStore(dir, {
     sealer: makeSealer(),
     // A QUIÉN se le envuelve la llave de cada cajón: los servicios de ese namespace (o el
@@ -405,7 +500,30 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const devices = await Promise.all(issued.map(async (x) => ({
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce
     })))
-    reply(from, { type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain })
+    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain }))
+  }
+
+  /**
+   * NADA DE FRAMES QUE NO CABEN. El proxio corta a 1 MB y cierra la conexión con un 1009:
+   * la respuesta no llega, la bóveda reconecta y no queda ni una línea de log de su lado.
+   * Así estuvo muda tres días para todo el ecosistema (2026-08-24) mientras el bot social
+   * repetía «no tienes ningún node de contenido enrolado».
+   *
+   * La cadena de actas es lo único que puede crecer sin techo aquí —cada acta es un
+   * snapshot completo de los miembros—, así que se recorta por el FINAL: el tramo que sale
+   * sigue siendo contiguo desde el `seq` del que pregunta, que es lo que necesita para
+   * encadenar, y en la siguiente pregunta seguirá desde donde llegó.
+   */
+  function fitChain (msg) {
+    const size = (m) => JSON.stringify(m).length
+    if (size(msg) <= MAX_REPLY_BYTES) return msg
+    const full = msg.chain?.length || 0
+    while (msg.chain?.length && size(msg) > MAX_REPLY_BYTES) msg.chain = msg.chain.slice(0, -1)
+    if (!msg.chain?.length) msg.chain = null
+    const left = msg.chain?.length || 0
+    log(`[vault] record chain trimmed to fit the transport: ${left}/${full} link(s), ${size(msg)} bytes`)
+    if (size(msg) > MAX_REPLY_BYTES) log(`[vault] ⚠ the reply STILL does not fit (${size(msg)} bytes): the proxy will drop it`)
+    return msg
   }
 
   // RENOVACIÓN automática: un dispositivo con cert VIGENTE y no revocado pide un
@@ -489,8 +607,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // da acceso a nada por sí solo. Quien firma esta petición ya tiene la llave de firma
     // del servicio y su cert, o sea que ya lee ese namespace. No hay escalada.
     if (p.data?.op === 'enckey') return handleEncKey(from, p)
-    if (['approvals', 'approve', 'deny', 'ssh.keys', 'ssh.key.add', 'ssh.key.rm'].includes(p.data?.op)) return handleApproval(from, p)
-    if (p.data?.op === 'ssh.sign' || p.data?.op === 'ssh.keys.public') return handleSshRemote(from, p)
+    if (['approvals', 'approve', 'deny'].includes(p.data?.op)) return handleApproval(from, p)
     const ns = p.data?.ns
     if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'secrets: invalid namespace' })
     if (typeof p.data?.ek !== 'string') return reply(from, { type: MSG.ERROR, error: 'secrets: missing ek (requester ephemeral key)' })
@@ -507,10 +624,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       audit('rejected', { what: 'secrets', ns, reason: 'cn' })
       return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
     }
-    // APROBACIÓN POR USO: si el cajón la exige y este aparato no tiene la ventana abierta,
-    // el pedido se apunta, se avisa a quien aprueba y se contesta «pendiente». La respuesta
-    // de verdad sale cuando el teléfono firme (`handleApproval`), sellada a la misma `ek`.
-    if (secrets.policyOf(ns).approval && !approvals.has(ns, chk.device)) {
+    // APROBACIÓN: si este APARATO está marcado (`dotrino-vault approval <ID> on`), liberarle
+    // claves privadas exige el visto bueno de un aparato con `approve` — en CADA petición,
+    // que para un servicio bien hecho es una por arranque: pide al (re)iniciar, se queda las
+    // claves en memoria y no vuelve a pedir. El pedido se apunta, se avisa a quien aprueba y se
+    // contesta «pendiente»; la respuesta de verdad sale cuando el teléfono firme
+    // (`handleApproval`), sellada a la misma `ek`.
+    if (needsApproval(chk.device)) {
       const deviceId = await deviceIdOf(chk.device).catch(() => null)
       const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
       const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek })
@@ -551,68 +671,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return { body, signature }
   }
 
-  // ---------- LLAVES SSH DEL TELÉFONO (`sshKeys.js`) ----------
-  // Aquí solo viven las PÚBLICAS: la privada está en el aparato que aprueba. `ssh` en este
-  // PC habla con el agente del daemon (`sshAgent.js`), y cada firma es un pedido más.
-  const sshKeysFile = path.join(dir, 'ssh-keys.json')
-  const atRest = atRestFor(dir)
-  const readSshKeys = () => { const d = readJsonAt(sshKeysFile); return Array.isArray(d?.keys) ? d.keys : [] }
-  function readJsonAt (file) { try { return JSON.parse(atRest.decrypt(fs.readFileSync(file, 'utf8'))) } catch (_) { return null } }
-  const writeSshKeys = (keys) => fs.writeFileSync(sshKeysFile, atRest.encrypt(JSON.stringify({ v: 1, keys })), { mode: 0o600 })
-  const sshKeys = () => readSshKeys().map((k) => ({ id: k.id, type: k.type, blob: k.blob, comment: k.comment, deviceId: k.deviceId, addedAt: k.addedAt }))
-
-  /**
-   * FIRMAR UN RETO SSH: lo pide el agente local (el `ssh` del usuario) y lo resuelve el
-   * teléfono. No hay ventana: cada conexión es un «sí» — para no repetirlo veinte veces
-   * está `ControlMaster` en el `ssh_config`, que reusa la conexión 15 min.
-   */
-  function requestSshSign ({ keyId, data, askedBy = null, onPending = null }) {
-    const key = readSshKeys().find((k) => k.id === keyId)
-    if (!key) return Promise.reject(new Error('ssh: unknown key'))
-    return new Promise((resolve, reject) => {
-      const pend = approvals.request({
-        kind: 'ssh', ns: 'ssh', deviceId: askedBy || (fp.slice(0, 4).toUpperCase() + '-' + fp.slice(4, 8).toUpperCase()), label: 'ssh',
-        ssh: { key: key.id, comment: key.comment, data: Buffer.from(data).toString('base64') },
-        resolve, reject
-      })
-      try { onPending?.(pend) } catch (_) {}
-      audit('ssh.pending', { key: key.id, id: pend.id, device: askedBy || null })
-      log(`[vault] ssh: ${key.comment || key.id} is waiting for the phone to sign (${pend.id})`)
-      identity.profileActa?.().catch(() => null).then((r) => notifyApprovers(pend, r?.acta))
-    })
-  }
-
   /**
-   * AGENTE SSH DELGADO en otra máquina (`dotrino-env ssh-agent`): un aparato con `vault:sign`
-   * pide que un reto se firme con una llave del teléfono. No hay nada que proteger en el
-   * que pide: solo convierte el reto en un pedido; quien firma es el teléfono.
-   */
-  async function handleSshRemote (from, p) {
-    const chk = await verifyChain({
-      data: p.data, signature: p.signature, cert: p.cert,
-      expectedScope: SCOPE.SIGN, trustedIssuer: master, revoked: await revocationSet()
-    })
-    if (!chk.ok) return denyChain(from, chk, p, 'ssh')
-    const answer = async (body) => {
-      body = { ...body, ts: Date.now() }
-      const { signature } = await identity.signData(body)
-      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
-    }
-    if (p.data.op === 'ssh.keys.public') return answer({ op: 'ssh.keys.public', items: sshKeys().map((k) => ({ id: k.id, blob: k.blob, comment: k.comment })) })
-    const key = readSshKeys().find((k) => k.id === p.data.key)
-    if (!key || typeof p.data.data !== 'string') return reply(from, { type: MSG.ERROR, error: 'ssh: unknown key' })
-    const asker = await deviceIdOf(chk.device).catch(() => null)
-    let pendId = null
-    const done = requestSshSign({ keyId: key.id, data: Buffer.from(p.data.data, 'base64'), askedBy: asker, onPending: (pend) => { pendId = pend.id } })
-    await answer({ op: 'ssh.pending', id: pendId, exp: Date.now() + 5 * 60 * 1000 })
-    try {
-      const sig = await done
-      await answer({ op: 'ssh.sign.result', sig: Buffer.from(sig).toString('base64') })
-    } catch (e) { reply(from, { type: MSG.ERROR, error: e.message }) }
-  }
-
-  /**
-   * PEDIDOS DE APROBACIÓN (cajones con `approval`). Entran por `vault.secrets` con
+   * PEDIDOS DE APROBACIÓN (aparatos marcados con `approval on`). Entran por `vault.secrets` con
    * `op: approvals | approve | deny`, firmados por un aparato con `vault:approve` — que,
    * como `admin`, no se empareja: se concede a mano (`caps <ID> +aprueba`). El acta tiene
    * que decirlo también, para que quitar el permiso surta efecto en el acto.
@@ -636,44 +696,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       reply(from, { type: MSG.SECRETS_RESULT, body, signature })
     }
     if (op === 'approvals') return answer({ op: 'approvals', items: approvals.list() })
-    if (op === 'ssh.keys') return answer({ op: 'ssh.keys', items: sshKeys() })
-    if (op === 'ssh.key.add') {
-      let k
-      try { k = parsePublicKey(p.data?.pub) } catch (e) { return reply(from, { type: MSG.ERROR, error: e.message }) }
-      const keys = readSshKeys().filter((x) => x.id !== k.id)
-      keys.push({ ...k, deviceId: by, addedAt: Date.now() })
-      writeSshKeys(keys)
-      audit('ssh.key.add', { key: k.id, by })
-      log(`[vault] ssh: key ${k.id} (${k.comment || 'no comment'}) registered by ${by}`)
-      return answer({ op: 'ssh.key.add', id: k.id, ok: true })
-    }
-    if (op === 'ssh.key.rm') {
-      const keys = readSshKeys(); const n = keys.length
-      writeSshKeys(keys.filter((x) => x.id !== p.data?.id))
-      if (keys.length !== n) audit('ssh.key.rm', { key: p.data?.id, by })
-      return answer({ op: 'ssh.key.rm', ok: true })
-    }
     const id = typeof p.data?.id === 'string' ? p.data.id : ''
     const pend = approvals.take(id)
     if (!pend) return reply(from, { type: MSG.ERROR, error: 'approval: unknown or expired request' })
-    if (pend.kind === 'ssh') {
-      if (op === 'deny') {
-        audit('ssh.denied', { key: pend.ssh.key, id, by })
-        try { pend.reject?.(new Error('ssh: denied from ' + by)) } catch (_) {}
-        return answer({ op: 'deny.result', id, ok: true })
-      }
-      if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
-      const key = readSshKeys().find((k) => k.id === pend.ssh.key)
-      let blob
-      try { blob = sshSignature({ jwk: key.jwk, data: Buffer.from(pend.ssh.data, 'base64'), rawSig: p.data?.sig }) } catch (e) {
-        try { pend.reject?.(e) } catch (_) {}
-        audit('rejected', { what: 'ssh.sign', reason: e.message })
-        return reply(from, { type: MSG.ERROR, error: e.message })
-      }
-      audit('ssh.signed', { key: key.id, id, by })
-      log(`[vault] ssh: ${key.comment || key.id} signed by ${by}`)
-      try { pend.resolve?.(blob) } catch (_) {}
-      return answer({ op: 'approve.result', id, ok: true })
+    // PEDIDOS QUE NO SON DE UN CAJÓN (hoy: la bóveda de contraseñas). Se resuelve ANTES
+    // de tocar `resultFor`, que asume un cajón y una `ek`: aquí no hay nada que sellar,
+    // solo una promesa esperando un sí o un no.
+    if (waiters.has(id)) {
+      const resolver = waiters.get(id)
+      waiters.delete(id)
+      const ok = op === 'approve'
+      audit(ok ? 'passwords.approved' : 'passwords.denied', { device: pend.deviceId, id, by })
+      log(`[vault] passwords: request of ${pend.deviceId} ${ok ? 'approved' : 'DENIED'} by ${by}`)
+      resolver(ok)
+      return answer({ op: `${op}.result`, id, ok: true })
     }
     if (op === 'deny') {
       audit('secrets.denied', { device: pend.deviceId, ns: pend.ns, id, by })
@@ -682,16 +718,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return answer({ op: 'deny.result', id, ok: true })
     }
     if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
-    const exp = approvals.grant(pend.ns, pend.device)
     let res
     try { res = await resultFor(pend.ns, pend.device, pend.ek, record) } catch (e) {
       return reply(from, { type: MSG.ERROR, error: 'approval: could not seal the reply: ' + e.message })
     }
-    audit('secrets.approved', { device: pend.deviceId, ns: pend.ns, id, by, until: exp })
-    log(`[vault] ${pend.ns}: request of ${pend.deviceId} approved by ${by} (window until ${new Date(exp).toISOString()})`)
+    audit('secrets.approved', { device: pend.deviceId, ns: pend.ns, id, by })
+    log(`[vault] ${pend.ns}: request of ${pend.deviceId} approved by ${by}`)
     // Va por `sendByPubkey`: si el que pedía ya no está conectado, lo recoge al volver.
     try { client.sendByPubkey(pend.device, { type: MSG.SECRETS_RESULT, ...res }) } catch (_) {}
-    return answer({ op: 'approve.result', id, ok: true, exp })
+    return answer({ op: 'approve.result', id, ok: true })
   }
 
   /** Aviso a los aparatos que aprueban (cola del proxio → push nativo si están apagados). */
@@ -726,6 +761,76 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     }
   })
 
+  // ----- LA BÓVEDA DE CONTRASEÑAS -----
+  //
+  // Se monta al final y envuelto: es una pieza opcional y un fallo suyo no puede tumbar
+  // la CA. Solo se levanta si hay algún aparato autorizado — sin eso no hay a quién
+  // responder, y crear la llave por si acaso sería crear un secreto que nadie pidió.
+  let passwords = null
+  try {
+    if (passwordDevices().length) {
+      const { createPasswordDesk } = await import('./passwords.js')
+      await refreshActa()
+      const actaSweeper = setInterval(refreshActa, 5000)
+      actaSweeper.unref?.()
+      passwords = createPasswordDesk({
+        client,
+        store: passwordsStore,
+        cek: await passwordsKey(),
+        // DOS condiciones, y hacen falta las dos: que esta bóveda lo haya autorizado
+        // (su lista) y que el ACTA siga reconociéndolo. Revocar un aparato en el acta
+        // le corta esto también, sin tener que acordarse de dos sitios.
+        isAllowed: (pub) => {
+          if (!passwordDevices().some((d) => d.pubkey === pub)) return false
+          return (actaCache?.members || []).some((m) => m.pub === pub)
+        },
+        encPubOf: (pub) => (actaCache?.members || []).find((m) => m.pub === pub)?.encPub || null,
+        needsApproval: (pub) => needsApproval(pub),
+        // El teléfono: se apunta el pedido, se le avisa y esta promesa espera su firma.
+        // Es el mismo camino que ya recorren los cajones de secretos.
+        approve: async ({ pubkey, op }) => {
+          const deviceId = await deviceIdOf(pubkey).catch(() => null)
+          const label = (actaCache?.members || []).find((m) => m.pub === pubkey)?.label || ''
+          const pend = approvals.request({ ns: 'passwords', device: pubkey, deviceId, label, ek: '' })
+          audit('passwords.pending', { device: deviceId, id: pend.id, op })
+          log(`[vault] passwords: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
+          const espera = new Promise((resolve) => {
+            waiters.set(pend.id, resolve)
+            // Si nadie contesta, vence solo: la promesa no se queda colgada para siempre
+            // y el aparato recibe un no en vez de esperar sin fin.
+            const t = setTimeout(() => {
+              if (waiters.delete(pend.id)) {
+                audit('passwords.expired', { device: deviceId, id: pend.id })
+                resolve(false)
+              }
+            }, PENDING_TTL_MS)
+            t.unref?.()
+          })
+          await notifyApprovers(pend, actaCache)
+          return espera
+        },
+        audit,
+        log,
+      }).start()
+      log('[vault] passwords: atendiendo peticiones de %d aparato(s)', passwordDevices().length)
+      // El código que se pega en la extensión o en la consola web. Lleva las DOS
+      // públicas: por la de firma enruta el proxio, a la de cifrado se le sella el
+      // contenido. Es público: no hay nada aquí que no pueda verse.
+      try {
+        const codigo = Buffer.from(JSON.stringify({
+          v: 1,
+          sign: await client.getPublicKey(),
+          enc: await identity.getEncryptionPubkey(),
+        })).toString('base64url')
+        log('[vault] passwords: enlaza un aparato con este código:\n%s', codigo)
+      } catch (e) {
+        log('[vault] passwords: no se pudo componer el código de enlace: %s', e.message)
+      }
+    }
+  } catch (e) {
+    log('[vault] passwords: no se pudo levantar (%s); el resto sigue igual', e.message)
+  }
+
   log(`[vault] listo · id ${fp} · ${store.getTree().children.length} nodos`)
 
   // ----- API local (CLI/UI de control) -----
@@ -1618,12 +1723,16 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     stopPairing: desk.stopPairing,
     listPending: desk.listPending,
     // Cajones con aprobación por uso (`approvals.js`).
-    secretPolicy: (ns) => secrets.policyOf(ns),
-    setSecretPolicy: async (ns, patch) => { const r = secrets.setPolicy(ns, patch); audit('secret.policy', { ns, ...r }); return r },
-    secretPolicies: () => secrets.policies(),
+    // Aparatos que piden aprobación al recibir claves (`approvals.js`).
+    needsApproval,
+    setApproval,
+    supervised: () => readSupervised(),
+    // La bóveda de contraseñas (`passwords.js`). Aquí SÍ se lista: es donde está la
+    // llave. Lo que no puede es listarla un aparato.
+    passwordDevices,
+    setPasswordDevice,
+    passwordsVault: () => passwords?.vault || null,
     listApprovals: () => approvals.list(),
-    sshKeys,
-    requestSshSign,
     // Aprobar desde el PC avisa igual que aprobar a distancia: el resto de tus
     // dispositivos se entera de que entró alguien, venga de donde venga.
     approveDevice: async (code, adminKey) => {