@dotrino/vaultd 0.26.2 → 0.38.0

package/src/vault.js

@@ -13,7 +13,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { Identity } from '@dotrino/identity/node'
-import { verifyChain, pubkeyId } from '@dotrino/identity/capabilities'
+import { verifyChain, pubkeyId, verifyDeviceSig } from '@dotrino/identity/capabilities'
 import * as Acta from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS } from '../lib/src/enroll.js'
 import { createAdminDesk } from '../lib/src/admin.js'
@@ -21,7 +21,7 @@ import { shouldNotifyRevoked } from '../lib/src/revocation.js'
 import { createTransport, masterPubkeyOf } from './transport.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
-import { openSecretsStore } from './secretsStore.js'
+import { openSecretsStore, assertVar } from './secretsStore.js'
 import { seal } from '../lib/src/sealed.js'
 import { dataDir, ensureDir } from './paths.js'
 import { atRestFor, machineKey, migrateFile } from './atrest.js'
@@ -129,6 +129,16 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       catch (_) { return null }
     },
     onAdopted: (info) => { try { onAdopted?.(info) } catch (_) {} },
+    // Se va el aparato, se van SUS variables. Guardarlas sería configuración de una llave
+    // que ya no entra, y volvería a la vida sola el día que se enrole otro aparato con esa
+    // misma llave. Va aquí porque a quitar se entra por dos puertas (el PC y la consola
+    // remota) y las dos pasan por `desk.revokeDevice`.
+    onDeviceRemoved: (sub) => {
+      try {
+        const n = secrets.forgetDevice(sub)
+        if (n) log(`[vault] dropped ${n} variable(s) of the removed device`)
+      } catch (e) { log('[vault] could not drop the device variables:', e.message) }
+    },
     defaultScope: [SCOPE.READ],
     onChallenge ({ deviceId, scope }) {
       log(`\n[vault] Un dispositivo quiere conectarse:`)
@@ -273,6 +283,37 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
   }
 
+  /**
+   * «¿SIGO SIENDO DE ESTA CASA?» — la única pregunta que se atiende SIN certificado.
+   *
+   * Existe por el aparato que se quedó sin papel: no puede firmar, ni leer, ni renovar, y
+   * —esto es lo grave— tampoco tenía forma de enterarse de que lo echaron, porque todo lo
+   * demás exige el certificado que ya no tiene. Se quedaba enseñando para siempre una
+   * cuenta que ya no era suya. Va firmada con la llave del propio aparato, que es
+   * exactamente lo que el acta nombra, así que decir quién pregunta no necesita más.
+   *
+   * La respuesta es sí o no, y nada más: al que sigue dentro no se le manda el acta —no la
+   * pidió, y contarle el perfil entero a quien no trae papel es dar de más—. Al que ya no
+   * está se le manda el aviso FIRMADO de expulsión, que es lo único que le borra la cuenta.
+   * Que un desconocido pregunte no cuesta nada: lo que se le puede contestar es un aviso a
+   * nombre de SU propia llave, que no le sirve contra nadie más (`verifyRevoke` exige que
+   * el aviso nombre al aparato que lo recibe).
+   */
+  async function handleCheck (from, p) {
+    if (!isFresh(p?.data)) return staleReply(from)
+    const pub = p.data.publickey
+    if (typeof pub !== 'string') return reply(from, { type: MSG.ERROR, error: 'unauthorized: shape' })
+    if (!(await verifyDeviceSig({ publickey: pub, data: p.data, signature: p.signature }))) {
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: bad-signature' })
+    }
+    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+    const inside = (record?.members || []).some((m) => m?.pub === pub)
+    audit('check', { device: await deviceIdOf(pub).catch(() => null), in: inside })
+    if (inside) return reply(from, { type: MSG.CHECKED, in: true })
+    await notifyIfRevoked(pub, null, null, 'revoked')
+    reply(from, { type: MSG.CHECKED, in: false })
+  }
+
   async function handleDevices (from, p) {
     if (!isFresh(p.data)) return staleReply(from)
     const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, trustedIssuer: master, revoked: await revocationSet() })
@@ -280,7 +321,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const { issued, revoked } = await identity.listDelegations()
     // El acta viaja con la lista: así cada dispositivo se entera de los cambios de
     // política (quién manda, quién puede qué) sin un canal aparte.
-    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
     // Si el dispositivo estuvo apagado y viene con un `seq` viejo, se le manda la CADENA
     // que falta (ventana de retención, §1.3) para que compruebe el encadenamiento en vez
     // de tragarse un salto a ciegas. Si se salió de la ventana, llega vacía y toca
@@ -301,7 +342,7 @@ 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, chain })
+    reply(from, { type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain })
   }
 
   // RENOVACIÓN automática: un dispositivo con cert VIGENTE y no revocado pide un
@@ -322,10 +363,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // `administra` no llegaba nunca al cert (la consola remota no podía funcionar) y
     // QUITARLO tampoco surtía efecto hasta que el cert caducara, hasta un mes después.
     // Si el miembro ya no está en el acta, no se renueva nada: lo echaron.
-    const acta = (await identity.profileActa?.().catch(() => null))?.acta
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
     let scope = p.cert.scope
-    if (acta) {
-      scope = Acta.memberScopes(acta, p.cert.sub)
+    if (record) {
+      scope = Acta.memberScopes(record, p.cert.sub)
       if (!scope.length) {
         audit('rejected', { what: 'renew', device: await deviceIdOf(p.cert.sub), reason: 'not-a-member' })
         return reply(from, { type: MSG.ERROR, error: 'unauthorized: the record no longer lists this device' })
@@ -338,7 +379,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
 
   // SECRETOS de servicios: un servicio enrolado (cert `vault:secrets:<ns>`)
-  // pide el bundle de su namespace. La respuesta va SELLADA a la llave ECDH
+  // pide el bundle de su namespace — el del SCOPE (que comparten todos los
+  // aparatos que sirven ese ns) con el SUYO PROPIO encima (`secretsStore.js`).
+  // Lo suyo se indexa por la llave que firma esta misma petición, así que no hay
+  // manera de pedir lo de otro aparato. La respuesta va SELLADA a la llave ECDH
   // efímera `ek` que vino en el sobre firmado (el proxy transporta pero no
   // puede leer los valores) y el cuerpo va FIRMADO por la maestra (el
   // servicio verifica contra su iss pineada — un relay no puede inyectar
@@ -357,14 +401,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // FRONTERA DEL CN (acta): además del scope del cert, el acta tiene que decir que este
     // miembro es el servicio `ns`. Así el límite no depende solo de qué cert se emitió: la
     // llave del proxy no ve nada que no sea del proxy, y está escrito donde se puede comprobar.
-    const acta = (await identity.profileActa?.().catch(() => null))?.acta
-    if (acta && !Acta.memberCanReadSecrets(acta, chk.device, ns)) {
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    if (record && !Acta.memberCanReadSecrets(record, chk.device, ns)) {
       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` })
     }
     let enc
     try {
-      enc = await seal({ ek: p.data.ek, payload: { secrets: secrets.get(ns) } })
+      enc = await seal({ ek: p.data.ek, payload: { secrets: secrets.get(ns, chk.device) } })
     } catch (e) {
       return reply(from, { type: MSG.ERROR, error: 'secrets: invalid ek' })
     }
@@ -383,6 +427,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (payload.type === MSG.SIGN) return await handleSign(from, payload)
       if (payload.type === MSG.GET) return await handleGet(from, payload)
       if (payload.type === MSG.STORE) return await handleStore(from, payload)
+      if (payload.type === MSG.CHECK) return await handleCheck(from, payload)
       if (payload.type === MSG.DEVICES) return await handleDevices(from, payload)
       if (payload.type === MSG.RENEW) return await handleRenew(from, payload)
       if (payload.type === MSG.SECRETS) return await handleSecrets(from, payload)
@@ -408,14 +453,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // AGRUPADO a propósito: cargar cinco valores seguidos con `secret set` son cinco
   // escrituras, pero un solo cambio de configuración. Sin esta ventana serían cinco
   // reinicios en cadena, y el agente se pasaría la carga entera reiniciándose.
-  const AVISO_AGRUPA_MS = Number(process.env.DOTRINO_VAULT_AVISO_MS) || 3000
-  const avisosPendientes = new Map()   // ns → timer
+  // La variable de entorno va en inglés (CONVENCIONES §8.1); nadie la tenía puesta.
+  const NOTICE_GROUP_MS = Number(process.env.DOTRINO_VAULT_NOTICE_MS) || 3000
+  const pendingNotices = new Map()   // clave (ns | 'dev:'+pub) → timer
 
-  async function avisarCambio (ns) {
-    let destinos = []
+  async function notifyNsChange (ns) {
+    let targets = []
     try {
       const { issued } = await identity.listDelegations()
-      const revocados = await revocationSet()
+      const revokedNonces = await revocationSet()
       const scope = secretsScope(ns)
       // Los agentes de ESE ns y nadie más: el aviso dice qué namespace cambió, así
       // que mandárselo a otro sería filtrarle que existe.
@@ -423,33 +469,62 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // Y UNO POR LLAVE, no uno por delegación: renovar el cert emite una
       // delegación nueva para la MISMA sub-clave, así que un agente que lleve
       // tiempo enrolado aparece varias veces y recibiría el aviso repetido.
-      const vistas = new Set()
-      destinos = (issued || []).filter((x) => {
-        if (!x.sub || revocados.has(x.nonce) || !(x.scope || []).includes(scope)) return false
-        if (vistas.has(x.sub)) return false
-        vistas.add(x.sub)
+      const seen = new Set()
+      targets = (issued || []).filter((x) => {
+        if (!x.sub || revokedNonces.has(x.nonce) || !(x.scope || []).includes(scope)) return false
+        if (seen.has(x.sub)) return false
+        seen.add(x.sub)
         return true
       })
     } catch (e) { return log('[vault] could not list who to notify:', e.message) }
-    if (!destinos.length) return
+    if (!targets.length) return
 
     const body = { op: 'secrets.changed', ns, ts: Date.now() }
     const { signature } = await identity.signData(body)
-    for (const d of destinos) {
+    for (const d of targets) {
       try { client.sendByPubkey(d.sub, { type: MSG.SECRETS_CHANGED, body, signature }) } catch (_) {}
     }
-    audit('secrets.changed', { ns, avisados: destinos.length })
-    log(`[vault] config for "${ns}" changed: notified ${destinos.length} agent(s)`)
+    audit('secrets.changed', { ns, notified: targets.length })
+    log(`[vault] config for "${ns}" changed: notified ${targets.length} agent(s)`)
   }
 
-  function programarAviso (ns) {
-    clearTimeout(avisosPendientes.get(ns))
+  /**
+   * Cambió una variable de UN aparato: el aviso va solo a ese aparato. El mensaje dice
+   * qué NAMESPACE cambió (es lo que el agente sabe leer), así que hace falta su `cn`; un
+   * miembro sin `cn` no es un servicio y no lee variables, de modo que no hay a quién
+   * avisar y no se manda nada.
+   */
+  async function notifyDeviceChange (pub) {
+    let cn = null
+    try {
+      const record = (await identity.profileActa?.().catch(() => null))?.acta
+      cn = (record?.members || []).find((m) => m.pub === pub)?.cn || null
+    } catch (e) { return log('[vault] could not look up who to notify:', e.message) }
+    if (!cn) return
+    const body = { op: 'secrets.changed', ns: cn, ts: Date.now() }
+    const { signature } = await identity.signData(body)
+    try { client.sendByPubkey(pub, { type: MSG.SECRETS_CHANGED, body, signature }) } catch (_) {}
+    const device = await deviceIdOf(pub).catch(() => null)
+    audit('secrets.changed', { ns: cn, device, notified: 1 })
+    log(`[vault] config for device ${device} ("${cn}") changed: notified it`)
+  }
+
+  /**
+   * Un cambio de configuración, un aviso: escrituras seguidas se agrupan en la misma
+   * ventana. La CLAVE distingue los dos cajones (`<ns>` y `dev:<pub>`) para que tocar
+   * lo de un aparato no cancele el aviso pendiente de todo su namespace.
+   */
+  function scheduleNotice (ns) { schedule(ns, () => notifyNsChange(ns)) }
+  function scheduleDeviceNotice (pub) { schedule('dev:' + pub, () => notifyDeviceChange(pub)) }
+
+  function schedule (key, fn) {
+    clearTimeout(pendingNotices.get(key))
     const t = setTimeout(() => {
-      avisosPendientes.delete(ns)
-      avisarCambio(ns).catch((e) => log('[vault] change notice failed:', e.message))
-    }, AVISO_AGRUPA_MS)
+      pendingNotices.delete(key)
+      fn().catch((e) => log('[vault] change notice failed:', e.message))
+    }, NOTICE_GROUP_MS)
     t.unref?.()
-    avisosPendientes.set(ns, t)
+    pendingNotices.set(key, t)
   }
 
   // --- CONSOLA REMOTA (docs/consola-remota.md) ---------------------------------
@@ -480,16 +555,76 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // UNO POR LLAVE, no uno por delegación: renovar emite una delegación nueva para la
       // MISMA sub-clave, así que un aparato que lleve tiempo enrolado aparece varias veces
       // y recibía el mismo aviso repetido —una vez por renovación acumulada—. Mismo
-      // cuidado que en `avisarCambio`.
-      const vistas = new Set()
+      // cuidado que en `notifyNsChange`.
+      const seen = new Set()
       for (const d of issued || []) {
-        if (!d.sub || vistas.has(d.sub)) continue
-        vistas.add(d.sub)
+        if (!d.sub || seen.has(d.sub)) continue
+        seen.add(d.sub)
         try { client.sendByPubkey(d.sub, { type: MSG.ADMIN_EVENT, body, signature }) } catch (_) {}
       }
     } catch (e) { log('[vault] could not notify members of the change:', e.message) }
   }
 
+  /**
+   * MOSTRADOR DE VARIABLES para la consola remota (`lib/src/admin.js` enruta; la política
+   * y la cripto viven aquí, que es donde están la clave y el disco).
+   *
+   * Dos reglas, y son toda la frontera:
+   *
+   *   1. **El valor de una PRIVADA no sale de esta máquina.** Ni para un aparato tuyo con
+   *      `admin`. Lo que viaja de una privada es su nombre y que es privada — con eso se
+   *      le puede poner un valor nuevo a ciegas, que es lo que hace falta para rotarla.
+   *   2. **Lo que sale, sale CIFRADO** con la clave de contenido del perfil: el proxy
+   *      transporta el sobre y no ve nada. Igual que el contenido del usuario (`store`).
+   */
+  const varsDesk = {
+    async list () {
+      // `listSecrets`/`listDeviceSecrets` ya traen el valor de las públicas y solo de esas:
+      // la frontera se decide en un sitio, y lo mismo ve el dueño en su terminal que aquí.
+      // Se sella la lista ENTERA, no solo los valores: el proxy tampoco tiene por qué
+      // aprender cómo se llaman tus variables ni qué servicios corres.
+      return {
+        enc: await identity.sealContent(JSON.stringify({
+          ns: listSecrets(), dev: await listDeviceSecrets()
+        }))
+      }
+    },
+    async set ({ ns, pub, key, enc, public: isPublic }) {
+      const payload = JSON.parse(await identity.openContent(enc))
+      const value = payload?.value
+      if (typeof value !== 'string' || !value) throw new Error('var.set: the sealed envelope must carry a non-empty value')
+      if (ns) setSecret(ns, key, value, isPublic)
+      else await setDeviceSecret(pub, key, value, isPublic)
+      return { ok: true, key }
+    },
+    /**
+     * VARIAS DE UNA VEZ, y por eso existe: cada guardado suelto hace que la bóveda avise
+     * al servicio de que su configuración cambió, y el servicio SALE para releerla entera
+     * (`watchEnv`). Guardadas de una en una, quien administra a distancia reiniciaba el
+     * servicio una vez por variable, y las primeras veces arrancaba con la configuración a
+     * medio poner. Juntas: un guardado, un aviso, un reinicio.
+     *
+     * Los NOMBRES también viajan dentro del sobre —no solo los valores—: el proxy
+     * transporta y no tiene por qué aprender cómo se llama la configuración de un servicio.
+     */
+    async setMany ({ ns, pub, enc, public: isPublic }) {
+      const payload = JSON.parse(await identity.openContent(enc))
+      const items = payload?.items
+      if (!Array.isArray(items) || !items.length) throw new Error('var.setMany: the sealed envelope must carry the variables')
+      // Borrar no se delega (`docs/consola-remota.md` §2): un aparato robado no puede
+      // dejar sin configuración a un servicio. Así que aquí solo entran valores nuevos.
+      /** @type {Array<{op:'set', key:string, value:string, public?:boolean}>} */
+      const list = items.map((it) => ({
+        op: /** @type {'set'} */ ('set'),
+        key: it?.key,
+        value: it?.value,
+        ...(typeof it?.public === 'boolean' ? { public: it.public } : (isPublic === undefined ? {} : { public: isPublic }))
+      }))
+      const keys = ns ? applySecrets(ns, list) : await applyDeviceSecrets(pub, list)
+      return { ok: true, keys }
+    }
+  }
+
   const admin = createAdminDesk({
     desk,
     deviceIdOf,
@@ -497,6 +632,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     audit,
     notify: notifyMembers,
     readActivity,
+    vars: varsDesk,
     // CERT ∩ ACTA, igual que los secretos con su CN. El cert dice qué se emitió; el acta,
     // qué decidió el dueño AHORA. Sin el segundo, `caps <ID> -administra` no surtía efecto
     // hasta que el cert caducara: quitarle la administración a un aparato que ya no es de
@@ -513,8 +649,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         await notifyIfRevoked(data?.publickey, cert?.nonce || null, cert?.iss || null, chk.reason)
         return chk
       }
-      const acta = (await identity.profileActa?.().catch(() => null))?.acta
-      if (acta && !Acta.memberCan(acta, chk.device, 'admin')) return { ok: false, reason: 'acta' }
+      const record = (await identity.profileActa?.().catch(() => null))?.acta
+      if (record && !Acta.memberCan(record, chk.device, 'admin')) return { ok: false, reason: 'acta' }
       return chk
     }
   })
@@ -556,10 +692,176 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     reply(from, { type: MSG.ADMIN_RESULT, op: p.data.op, result: r.result })
   }
 
-  // API local de secretos (solo CLI/UI del dueño; audita cada cambio).
-  function setSecret (ns, key, value) { secrets.set(ns, key, value); audit('secret.set', { ns, key }); programarAviso(ns) }
-  function deleteSecret (ns, key) { const ok = secrets.delete(ns, key); if (ok) { audit('secret.rm', { ns, key }); programarAviso(ns) } return ok }
-  function listSecrets () { return secrets.list() }
+  // API local de secretos (CLI/UI del dueño; audita cada cambio). `isPublic` es opcional:
+  // sin decir nada, la variable conserva su visibilidad (y una nueva nace privada).
+  function setSecret (ns, key, value, isPublic) { secrets.set(ns, key, value, isPublic); audit('secret.set', { ns, key }); scheduleNotice(ns) }
+  function deleteSecret (ns, key) { const ok = secrets.delete(ns, key); if (ok) { audit('secret.rm', { ns, key }); scheduleNotice(ns) } return ok }
+
+  /**
+   * CARGAR CONFIGURACIÓN ES UNA TRANSACCIÓN: muchas variables, UN aviso.
+   *
+   * De una en una, cada `set` es un cambio de configuración para la bóveda, y el agente
+   * obedece el primero —sale, lo levanta el supervisor, lee lo que hubiera en ese
+   * instante— mientras el dueño sigue tecleando. El resultado es un servicio corriendo
+   * con media configuración, y encima con el arranque a medio hacer. La ventana de
+   * agrupado (`NOTICE_GROUP_MS`) tapa el caso de un script, no el de una persona
+   * escribiendo con quince segundos entre variable y variable.
+   *
+   * Así que la carga en grupo llega hasta aquí entera: se valida TODO primero, se
+   * escribe en un solo guardado y sale UN aviso al final. Las visibilidades no entran:
+   * no cambian lo que el servicio lee y por eso nunca avisaron.
+   *
+   * @param {string} ns
+   * @param {Array<{op:'set'|'rm', key:string, value?:string, public?:boolean}>} items
+   * @returns {string[]} las claves que efectivamente cambiaron (un `rm` de lo que no
+   *   estaba no cambia nada, y no tiene por qué reiniciar a nadie).
+   */
+  function applySecrets (ns, items) {
+    const list = assertItems(items)
+    const changed = []
+    secrets.batch(() => {
+      for (const it of list) {
+        if (it.op === 'rm') {
+          if (secrets.delete(ns, it.key)) { audit('secret.rm', { ns, key: it.key }); changed.push(it.key) }
+        } else {
+          secrets.set(ns, it.key, it.value, it.public)
+          audit('secret.set', { ns, key: it.key })
+          changed.push(it.key)
+        }
+      }
+    })
+    if (changed.length) scheduleNotice(ns)
+    return changed
+  }
+
+  /** Lo mismo para el cajón de UN aparato (el aviso va solo a él). */
+  async function applyDeviceSecrets (pub, items) {
+    const list = assertItems(items)
+    const m = await requireService(pub)
+    const changed = []
+    secrets.batch(() => {
+      for (const it of list) {
+        if (it.op === 'rm') {
+          if (secrets.deleteDevice(pub, it.key)) changed.push(it.key)
+        } else {
+          secrets.setDevice(pub, it.key, it.value, it.public)
+          changed.push(it.key)
+        }
+      }
+    })
+    if (changed.length) {
+      const device = await deviceIdOf(pub).catch(() => null)
+      for (const it of list) {
+        if (!changed.includes(it.key)) continue
+        audit(it.op === 'rm' ? 'secret.rm' : 'secret.set', { device, ns: m?.cn || null, key: it.key, scope: 'device' })
+      }
+      scheduleDeviceNotice(pub)
+    }
+    return changed
+  }
+
+  /**
+   * Todo o nada: si una variable del grupo no vale, no se escribe NINGUNA. Media
+   * configuración cargada es peor que ninguna — el servicio arranca con ella.
+   */
+  function assertItems (items) {
+    if (!Array.isArray(items) || !items.length) throw new Error('batch: no items')
+    for (const it of items) {
+      if (!it || (it.op !== 'set' && it.op !== 'rm')) throw new Error('batch: each item must be a set or an rm')
+      if (it.op === 'rm') { if (!it.key) throw new Error('batch: rm needs a key') } else assertVar(it.key, it.value)
+    }
+    return items
+  }
+  /**
+   * Los nombres, y el VALOR de las públicas. Pública quiere decir «este valor puede salir
+   * de esta máquina»: taparlo justo aquí —en la máquina donde vive, delante de su dueño—
+   * era lo único que la marca no significaba. La consola remota ya las enseña.
+   */
+  function listSecrets () {
+    const out = {}
+    for (const [ns, keys] of Object.entries(secrets.list())) {
+      const values = secrets.publicOf(ns)
+      out[ns] = keys.map((k) => (k.public ? { ...k, value: values[k.key] } : k))
+    }
+    return out
+  }
+  /** Cambiar SOLO quién puede ver el valor (no toca el valor ni avisa: el servicio lee lo mismo). */
+  function setSecretVisibility (ns, key, isPublic) {
+    const ok = secrets.setVisibility(ns, key, isPublic)
+    if (ok) audit('secret.visibility', { ns, key, public: !!isPublic })
+    return ok
+  }
+
+  /** El miembro del acta con esa llave, o `null` (también si la bóveda todavía no tiene acta). */
+  async function memberOf (pub) {
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    if (!record) return null
+    return (record.members || []).find((m) => m.pub === pub) || null
+  }
+
+  /**
+   * Variables de UN aparato. Se exige que sea un SERVICIO del acta (miembro con `cn`) porque
+   * es el único que las lee: guardárselas a un teléfono sería configuración muerta, escrita
+   * donde nadie la va a buscar el día que no funcione. Si la bóveda es anterior al acta no
+   * hay contra qué comprobarlo y se acepta.
+   */
+  async function requireService (pub) {
+    const m = await memberOf(pub)
+    if (!m) {
+      const record = (await identity.profileActa?.().catch(() => null))?.acta
+      if (record) throw new Error('device: it is not a member of this profile')
+      return null
+    }
+    if (!m.cn) throw new Error('device: it is not a service (only services read variables); pair it with `pair --service <ns>`')
+    return m
+  }
+
+  async function setDeviceSecret (pub, key, value, isPublic) {
+    const m = await requireService(pub)
+    secrets.setDevice(pub, key, value, isPublic)
+    audit('secret.set', { device: await deviceIdOf(pub).catch(() => null), ns: m?.cn || null, key, scope: 'device' })
+    scheduleDeviceNotice(pub)
+  }
+
+  async function deleteDeviceSecret (pub, key) {
+    const m = await memberOf(pub)
+    const ok = secrets.deleteDevice(pub, key)
+    if (ok) {
+      audit('secret.rm', { device: await deviceIdOf(pub).catch(() => null), ns: m?.cn || null, key, scope: 'device' })
+      scheduleDeviceNotice(pub)
+    }
+    return ok
+  }
+
+  async function setDeviceSecretVisibility (pub, key, isPublic) {
+    const ok = secrets.setDeviceVisibility(pub, key, isPublic)
+    if (ok) audit('secret.visibility', { device: await deviceIdOf(pub).catch(() => null), key, public: !!isPublic, scope: 'device' })
+    return ok
+  }
+
+  /**
+   * Las variables por aparato —nombres, y el valor de las PÚBLICAS, igual que `listSecrets`—
+   * con quién es cada aparato pegado: una llave suelta no se puede administrar. `orphan`
+   * marca las que quedaron de una llave que ya no está en el acta.
+   */
+  async function listDeviceSecrets () {
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    const members = record?.members || []
+    const out = []
+    for (const [pub, keys] of Object.entries(secrets.listDevices())) {
+      const m = members.find((x) => x.pub === pub) || null
+      const values = secrets.publicOfDevice(pub)
+      out.push({
+        pub,
+        id: m?.id || await deviceIdOf(pub).catch(() => null),
+        label: m?.label || '',
+        cn: m?.cn || null,
+        keys: keys.map((k) => (k.public ? { ...k, value: values[k.key] } : k)),
+        orphan: !!members.length && !m
+      })
+    }
+    return out
+  }
 
   return {
     identity, client, store, threads, secrets, master, fingerprint: fp,
@@ -574,7 +876,12 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return r
     },
     rejectDevice: (deviceId) => desk.reject(deviceId),
-    setSecret, deleteSecret, listSecrets,
+    // El mostrador que atiende a la consola remota. Se expone para poder probar la
+    // frontera de verdad (que el valor de una privada no salga ni dentro del sobre).
+    vars: varsDesk,
+    setSecret, deleteSecret, listSecrets, setSecretVisibility,
+    setDeviceSecret, deleteDeviceSecret, listDeviceSecrets, setDeviceSecretVisibility,
+    applySecrets, applyDeviceSecrets,
     listDevices: () => identity.listDelegations(),
     // Acta del perfil (quién es del perfil y qué puede cada uno): lo que muestran
     // `dotrino-vault members` y la consola de vault.dotrino.com.
@@ -613,8 +920,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return r
     },
     close () {
-      for (const t of avisosPendientes.values()) clearTimeout(t)
-      avisosPendientes.clear()
+      for (const t of pendingNotices.values()) clearTimeout(t)
+      pendingNotices.clear()
       try { client.close() } catch (_) {} identity.destroy()
     }
   }