@dotrino/vaultd 0.97.0 → 0.105.1

package/src/vault.js

@@ -26,7 +26,7 @@ import { startSealersPublisher } from './sealers.js'
 import { assertKeyOwnsDir } from './keyowner.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
-import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP } from './secretsStore.js'
+import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER } from './secretsStore.js'
 // `PENDING_TTL_MS` se usa abajo, al esperar la firma del aprobador: sin importarlo, esa
 // espera reventaba con un ReferenceError y la aprobación del mostrador de contraseñas no
 // llegaba a existir. Solo se veía por ese camino —el único que lo usa—, y no había prueba
@@ -36,7 +36,9 @@ import { makeSealer } from './sealer.js'
 import { openSealKeys } from './sealKey.js'
 import { openCommKey, COMM_CN, COMM_CAPS } from './commKey.js'
 import { seal } from '../lib/src/sealed.js'
+import { localSocketPath, socketDir } from '../lib/src/localdesk.js'
 import { dataDir, ensureDir } from './paths.js'
+import net from 'node:net'
 import { atRestFor, kekFor, migrateFile, encryptText, decryptText } from './atrest.js'
 import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
 
@@ -321,15 +323,26 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * Así que una respuesta que no quepa no se manda: se sustituye por un error, que sí cabe.
    * Una bóveda que dice «no cabe» se arregla; una muda no se puede ni diagnosticar.
    */
+  /**
+   * QUIÉN CONTESTA A QUIÉN. Por defecto el proxio; un remitente LOCAL (el socket de esta
+   * máquina) se apunta aquí con su propia forma de contestar.
+   *
+   * Que haya dos transportes no cambia NADA de quién puede pedir qué: la autorización sale
+   * del certificado y del acta, igual por los dos caminos. Alcanzar el socket no autoriza
+   * nada — es la misma puerta, con el camino más corto.
+   */
+  const canales = new Map()
+
   const reply = (to, obj) => {
     try {
+      const enviar = canales.get(to) || ((o) => client.send(to, o))
       const bytes = Buffer.byteLength(JSON.stringify(obj))
       if (bytes > MAX_REPLY_BYTES) {
         log(`[vault] the reply to ${obj?.type} does not fit (${bytes} bytes > ${MAX_REPLY_BYTES}): sending an error instead of killing the connection`)
         audit('reply-too-big', { type: obj?.type || null, bytes })
-        return client.send(to, { type: MSG.ERROR, error: `reply too big (${bytes} bytes): ask for less at a time` })
+        return enviar({ type: MSG.ERROR, error: `reply too big (${bytes} bytes): ask for less at a time` })
       }
-      client.send(to, obj)
+      enviar(obj)
     } catch (e) { log('[vault] could not reply:', e.message) }
   }
 
@@ -610,6 +623,69 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   // Store de hilos+aperturas (Fase 3): escrituras requieren vault:store; lecturas
   // aceptan vault:store o vault:read. Cada op va firmada por D + cert (cadena D←maestra).
+  /**
+   * LOS DATOS DEL PERFIL (`docs/datos-del-perfil.md`). Tres métodos y ninguno más:
+   *
+   *   · `profilePut`      — guarda un dato. Privado = sobre ya sellado; público = en claro.
+   *   · `profileBundle`   — los sobres de ESTE aparato, para que arme su perfil.
+   *   · `profilePublic`   — lo público en claro, que puede pedir cualquiera.
+   *
+   * Lo que NO se comprueba aquí: el candado. Un sobre sellado no lo puede leer ni fabricar
+   * la bóveda, así que guardarlo no es una decisión suya y no necesita su maestra. Ese era
+   * el motivo real por el que editar el perfil exigía abrirla, y es el síntoma que abrió
+   * todo esto: se cerraba sola a los cinco minutos y editar dejaba de funcionar.
+   */
+  const PROFILE_METHODS = new Set(['profilePut', 'profileBundle', 'profilePublic', 'profileRecipients'])
+
+  async function handleProfile (from, p, d) {
+    // LO PÚBLICO NO PIDE NADA. Es lo que ve quien pregunta desde fuera y no tiene ninguna
+    // llave tuya: pedir un papel para leerlo sería contradecir lo que significa «público».
+    // Va firmado, así que quien lo recibe comprueba que es tuyo sin fiarse de nadie.
+    if (d.method === 'profilePublic') {
+      return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: secrets.profilePublic() })
+    }
+    // A QUIÉN HAY QUE ENVOLVERLE. Lo pide el aparato ANTES de sellar, porque sellar lo hace
+    // él: envolver solo necesita públicas, así que puede hacerlo un navegador sin que
+    // ninguna privada ande suelta. Sale de aquí y no de una lista suya para que conceder
+    // `firma` a un aparato nuevo baste — sin que nadie tenga que acordarse de nada.
+    if (d.method === 'profileRecipients') {
+      const members = await recipientsOf(PROFILE_OWNER)
+      return reply(from, {
+        type: MSG.STORE_RESULT,
+        method: d.method,
+        result: { recoveryPub: secrets.recoveryPub(), members: members.map((m) => ({ pub: m.pub, encPub: m.encPub })) }
+      })
+    }
+
+    const revoked = await revocationSet()
+    // `vault:sign` — hablar por ti. No `vault:store`, que es guardar cosas.
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.SIGN, ...(await contextoActa()), revoked })
+    if (!chk.ok) return denyChain(from, chk, p, 'profile')
+    if (!await actaAllows(from, chk, SCOPE.SIGN, 'profile')) return
+
+    try {
+      if (d.method === 'profileBundle') {
+        const b = secrets.profileBundleFor(chk.device)
+        return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: b })
+      }
+      // profilePut
+      const { key, cls, sobre, value } = d.args || {}
+      const quien = await deviceIdOf(chk.device).catch(() => null)
+      let r
+      if (cls === 'public') {
+        r = await secrets.profilePutPublic(key, value, { by: quien })
+      } else {
+        r = await secrets.putSealed(PROFILE_OWNER, key, sobre, { by: quien })
+      }
+      audit('profile.put', { key, cls: cls || 'private', by: quien, gen: r?.gen ?? null })
+      // Y a los demás aparatos, que si no se enteran al arrancar y vuelve la divergencia.
+      await notifyMembers('profile', { key, by: quien })
+      return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: r })
+    } catch (e) {
+      return reply(from, { type: MSG.ERROR, error: 'profile: ' + e.message })
+    }
+  }
+
   async function handleStore (from, p) {
     const d = p.data
     // `Object.hasOwn` y no `threads.methods[d.method]`: con la comprobación laxa,
@@ -619,9 +695,19 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return reply(from, { type: MSG.ERROR, error: 'store: invalid method' })
     }
     if (!isFresh(d)) return staleReply(from)
-    // CANDADO del perfil (contraseña opcional): solo frena EDITAR el perfil. Un
-    // dispositivo enrolado puede seguir firmando, leyendo y guardando contenido;
-    // lo que no puede es reescribir quién sos mientras el perfil está bloqueado.
+    // EL PERFIL VA POR OTRO CAMINO, y por eso se atiende antes que nada
+    // (`docs/datos-del-perfil.md`). Dos diferencias, y las dos son el arreglo:
+    //
+    //   · **No hace falta abrir la bóveda.** Lo que llega es un sobre ya sellado y
+    //     firmado, que ella no puede leer ni falsificar: aceptarlo no es una decisión
+    //     suya. El candado estaba ahí porque guardaba el perfil en claro; ya no.
+    //   · **Lo gatea `firma`, no `guarda`.** Escribir tu identidad es hablar por ti, no
+    //     guardar un archivo en tu bóveda (dueño, 2026-09-03). El proxio tiene `guarda`
+    //     para lo suyo y no debe poder cambiar quién eres.
+    if (PROFILE_METHODS.has(d.method)) return await handleProfile(from, p, d)
+    // CANDADO del perfil (contraseña opcional): solo frena EDITAR el perfil heredado
+    // (`profileSet`, el `me` plano). Un dispositivo enrolado puede seguir firmando,
+    // leyendo y guardando contenido.
     if (PROFILE_EDIT_METHODS.has(d.method) && isLocked()) {
       audit('rejected', { what: 'store', method: d.method, reason: 'locked' })
       return reply(from, { type: MSG.ERROR, error: 'profile locked: unlock it on the vault machine (dotrino-vault unlock) to edit it' })
@@ -981,7 +1067,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!publicOnly && needsApproval(chk.device, record)) {
       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 })
+      // `from` SE GUARDA: la respuesta llega más tarde —cuando alguien apruebe— y tiene que
+      // volver POR DONDE VINO. Si la pregunta entró por el mostrador local, mandarla por el
+      // proxio la deja en el vacío: quien preguntó está escuchando en el socket, no ahí.
+      // Lo cazó el E2E de aprobación, que se quedó esperando cinco minutos.
+      const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek, from })
       audit('secrets.pending', { device: deviceId, ns, id: pend.id })
       log(`[vault] ${ns}: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
       const body = { op: 'secrets.pending', ns, id: pend.id, exp: pend.exp, ts: Date.now() }
@@ -1093,8 +1183,12 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (op === 'deny') {
       audit('secrets.denied', { device: pend.deviceId, ns: pend.ns, id, by })
       log(`[vault] ${pend.ns}: request of ${pend.deviceId} DENIED by ${by}`)
-      try { client.sendByPubkey(pend.device, { type: MSG.ERROR, error: `unauthorized: denied — the "${pend.ns}" request was denied from ${by}` }) }
-      catch (e) { log(`[vault] ${pend.ns}: could not tell ${pend.deviceId} it was denied: ${e.message}`) }
+      try {
+        const err = { type: MSG.ERROR, error: `unauthorized: denied — the "${pend.ns}" request was denied from ${by}` }
+        const porLocal = pend.from && canales.get(pend.from)
+        if (porLocal) porLocal(err)
+        else client.sendByPubkey(pend.device, err)
+      } catch (e) { log(`[vault] ${pend.ns}: could not tell ${pend.deviceId} it was denied: ${e.message}`) }
       return answer({ op: 'deny.result', id, ok: true })
     }
     if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
@@ -1108,8 +1202,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // EL FALLO NO SE TRAGA. Tragarlo era lo peor de este mostrador: la bóveda apuntaba
     // «aprobado», el que pedía no recibía nada, y no quedaba una sola línea que mirar —
     // así que el dueño aprobaba una y otra vez creyendo que el teléfono no llegaba.
-    try { client.sendByPubkey(pend.device, { type: MSG.SECRETS_RESULT, ...res }) }
-    catch (e) { log(`[vault] ${pend.ns}: approved, but the reply did not reach ${pend.deviceId}: ${e.message}`) }
+    // Por el canal por el que preguntó. Si fue el proxio, `sendByPubkey`: así lo recoge al
+    // volver aunque ahora esté apagado. Si fue el socket local, por el socket.
+    try {
+      const porLocal = pend.from && canales.get(pend.from)
+      if (porLocal) porLocal({ type: MSG.SECRETS_RESULT, ...res })
+      else client.sendByPubkey(pend.device, { type: MSG.SECRETS_RESULT, ...res })
+    } catch (e) { log(`[vault] ${pend.ns}: approved, but the reply did not reach ${pend.deviceId}: ${e.message}`) }
     return answer({ op: 'approve.result', id, ok: true })
   }
 
@@ -1144,7 +1243,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     } catch (e) { log('[vault] could not notify approvers:', e.message) }
   }
 
-  client.on('message', async (from, payload) => {
+  client.on('message', (from, payload) => onMessage(from, payload))
+
+  // EL MOSTRADOR LOCAL, siempre que se pueda. Si no se puede abrir (un sistema sin sockets
+  // de archivo, un directorio de solo lectura) se dice y se sigue: los servicios usan el
+  // proxio como hasta ahora. Lo que NO se hace es callarlo — un atajo que no está y nadie
+  // lo dice es media hora buscando por qué algo va lento.
+  // El socket se nombra por la LLAVE de esta bóveda: una máquina puede tener varias, y un
+  // servicio solo conoce la maestra que lleva pineada. Así los dos lados calculan la misma
+  // ruta sin mirar ningún índice.
+  if (identity.me?.publickey) {
+    abrirMostradorLocal(localSocketPath((await pubkeyId(identity.me.publickey)).slice(0, 16)))
+  }
+
+  async function onMessage (from, payload) {
     if (!payload || typeof payload !== 'object') return
     try {
       if (payload.type === MSG.HELLO) return desk.handleHello(from, payload)
@@ -1161,10 +1273,64 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (payload.type === MSG.ADMIN) return await handleAdmin(from, payload)
       if (payload.type === MSG.RENOUNCE) return await handleRenounce(from, payload)
       if (payload.type === MSG.ADMIN_EVENT) return await handleAdminEvent(payload)
+      if (payload.type === MSG.REPLICA_ACK) return await handleReplicaAck(from, payload)
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: e.message })
     }
-  })
+  }
+
+  /**
+   * EL MOSTRADOR LOCAL: el mismo protocolo, sin salir de la máquina.
+   *
+   * Un servicio en ESTA máquina hablaba con la bóveda dando la vuelta por
+   * `proxy.dotrino.com`: sale a internet, vuelve, y si el proxio tiene un mal momento el
+   * arranque se retrasa cinco segundos por nada. Absurdo cuando los dos procesos comparten
+   * disco (dueño, 2026-09-03: «estando en la misma máquina debería ser inmediato»).
+   *
+   * Es EL MISMO PROTOCOLO y el mismo enrutador: llega `{type, data, signature, cert}` y se
+   * comprueba igual, contra el certificado y contra el acta. **Alcanzar el socket no
+   * autoriza nada** — es la misma puerta por un camino más corto, no una puerta de atrás.
+   * Por eso no hay un solo `if` de «viene de local» en ningún handler, y no debe haberlo.
+   *
+   * Y no es un puerto: es un socket de archivo, en modo 0600 y bajo el directorio del
+   * usuario. No se alcanza desde otra máquina ni desde otro usuario, así que la promesa
+   * del `docker-compose` —«la bóveda no escucha nada»— sigue siendo cierta donde importa.
+   */
+  function abrirMostradorLocal (socketPath) {
+    let n = 0
+    const server = net.createServer((sock) => {
+      const id = 'local:' + (++n)
+      let buf = ''
+      const enviar = (obj) => { try { sock.write(JSON.stringify(obj) + '\n') } catch (_) {} }
+      canales.set(id, enviar)
+      sock.on('data', (chunk) => {
+        buf += chunk
+        // UN TOPE, y por lo mismo que en las respuestas: sin él, quien se conecte puede
+        // hacer crecer este buffer hasta tumbar la bóveda mandando y sin saltos de línea.
+        if (buf.length > MAX_REPLY_BYTES) { buf = ''; enviar({ type: MSG.ERROR, error: 'request too big' }); return }
+        let i
+        while ((i = buf.indexOf('\n')) >= 0) {
+          const linea = buf.slice(0, i); buf = buf.slice(i + 1)
+          if (!linea.trim()) continue
+          let p = null
+          try { p = JSON.parse(linea) } catch (_) { enviar({ type: MSG.ERROR, error: 'malformed request' }); continue }
+          onMessage(id, p).catch((e) => enviar({ type: MSG.ERROR, error: e.message }))
+        }
+      })
+      const cerrar = () => canales.delete(id)
+      sock.on('close', cerrar)
+      sock.on('error', cerrar)
+    })
+    server.on('error', (e) => log('[vault] the local desk could not open (' + e.message + '): services will use the proxy'))
+    try { fs.mkdirSync(socketDir(), { recursive: true, mode: 0o700 }) } catch (_) {}
+    try { fs.rmSync(socketPath, { force: true }) } catch (_) {}
+    server.listen(socketPath, () => {
+      try { fs.chmodSync(socketPath, 0o600) } catch (_) {}
+      log('[vault] local desk at ' + socketPath + ' (same machine, no round trip)')
+    })
+    server.unref?.()
+    return server
+  }
 
   /**
    * AVISO DE OTRA BÓVEDA de la misma cuenta (multivault). Trae el acta nueva y aquí se
@@ -1355,7 +1521,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * 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 scheduleNotice (ns) {
+    schedule(ns, async () => {
+      await notifyNsChange(ns)
+      // Y a los replicadores el sobre nuevo. Sin esto repartirían el valor de ayer: el
+      // aviso de cambio le dice al servicio que se reinicie, y al reiniciar volvería a
+      // pedir — y si la bóveda está apagada, el replicador le daría lo viejo.
+      await pushToReplicas(`secret:${ns}`)
+    })
+  }
   function scheduleDeviceNotice (pub) { schedule('dev:' + pub, () => notifyDeviceChange(pub)) }
 
   function schedule (key, fn) {
@@ -1432,6 +1606,80 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       for (const d of issued || []) avisar(d.sub)
       log(`[vault] notified ${seen.size} member(s) of "${ev}" (record #${acta?.seq ?? '?'})`)
     } catch (e) { log('[vault] could not notify members of the change:', e.message) }
+    // Y a los replicadores, que no quieren un aviso sino el CONTENIDO: sin esto se
+    // quedarían con el acta de ayer y repartiendo sobres de un aparato ya revocado.
+    await pushToReplicas(ev)
+  }
+
+  /**
+   * EL ARRASTRE AL ARRANCAR (`docs/replicas.md` §6). Un replicador dice por dónde va en
+   * cuanto se conecta, y si va por detrás se le empuja.
+   *
+   * Sin esto, la bóveda solo empujaba al cambiar algo: un replicador que se enciende
+   * después se quedaba vacío hasta el siguiente cambio, que puede no llegar en semanas.
+   * Y el empujón de un enrolamiento se manda a un aparato que todavía no está conectado.
+   * Lo destapó el smoke y era un hueco del diseño, no del código.
+   *
+   * El acuse va FIRMADO por el replicador y se comprueba contra el acta: sin eso, cualquiera
+   * podría pedirle a la bóveda que reparta el acta y los sobres mandando un acuse inventado.
+   */
+  async function handleReplicaAck (from, p) {
+    const body = p?.body
+    if (!body || body.op !== 'replica.ack') return
+    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!record) return
+    // LA LLAVE VA DENTRO DEL MENSAJE FIRMADO, no se saca de `from`: `from` es el
+    // identificador de la conexión en el proxio, no la llave del miembro. Compararlo con
+    // el acta rechazaba a todo el mundo, y en el caso contrario habría sido peor.
+    const quien = body.publickey
+    if (typeof quien !== 'string' || !Acta.memberCan(record, quien, 'replica')) {
+      return log('[vault] a replica ack arrived from someone the record does not allow to serve: ignored')
+    }
+    if (!(await verifyDeviceSig({ publickey: quien, data: body, signature: p.signature }))) {
+      return log('[vault] a replica ack does not check out against its own key: ignored')
+    }
+    if (typeof body.seq === 'number' && body.seq >= record.seq) return
+    log(`[vault] a replica is at #${body.seq} and we are at #${record.seq}: catching it up`)
+    await pushToReplicas('catch-up')
+  }
+
+  /**
+   * EMPUJAR A LOS REPLICADORES lo que tienen que poder repartir: el acta y los sobres.
+   *
+   * Se manda TODO firmado de antes —el acta la selló la maestra, cada sobre lo firmó la
+   * llave de sellado— así que un replicador no puede falsificar nada de lo que le damos.
+   * Y va cerrado a su destinatario, no a él: reparte sobres que no puede abrir. Es lo que
+   * permite ponerlo en una máquina en la que no confías (`docs/replicas.md` §8.bis).
+   *
+   * Se empuja después de cada cambio, y no se espera acuse: si un replicador está apagado
+   * se queda atrás y lo alcanza el siguiente empujón. Un replicador atrasado no es un
+   * peligro —el cliente rechaza un acta con `seq` menor del que ya vio— sino menos
+   * disponibilidad, que es exactamente lo que un replicador arriesga.
+   */
+  async function pushToReplicas (motivo = 'change') {
+    try {
+      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+      if (!record) return
+      const replicas = (record.members || []).filter((m) => Acta.memberCan(record, m.pub, 'replica'))
+      if (!replicas.length) return
+
+      // UN SOBRE POR (CAJÓN, APARATO), porque `bundleFor` lo talla a quien lo pide: lleva
+      // solo las envolturas de ESE aparato. Mandar uno genérico no serviría de nada.
+      const bundles = {}
+      for (const m of record.members || []) {
+        if (!m.cn) continue
+        try { bundles[`${m.cn} ${m.pub}`] = secrets.bundleFor(m.cn, m.pub) } catch (_) {}
+      }
+      const body = { op: 'replica.push', seq: record.seq, acta: record, bundles, ts: Date.now() }
+      const seal = await signSeal(body)
+      if (!seal) return log('[vault] cannot push to the replicas: the record names no sealing key of ours')
+      let n = 0
+      for (const r of replicas) {
+        try { client.sendByPubkey(r.pub, { type: MSG.REPLICA_PUSH, body, seal }); n++ }
+        catch (e) { log(`[vault] could not push to a replica: ${e.message}`) }
+      }
+      log(`[vault] pushed record #${record.seq} and ${Object.keys(bundles).length} bundle(s) to ${n} replica(s) on ${motivo}`)
+    } catch (e) { log('[vault] could not push to the replicas: ' + e.message) }
   }
 
   /**
@@ -1814,6 +2062,19 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // abrirse desde un navegador. Lo que cambia es que «pública» ya sí quiere decir algo
     // para quien administra — puede leerla— además de que se despacha sin aprobación.
     const admins = isPublic ? await adminDevices() : []
+    // EL PERFIL SE LE ENVUELVE A QUIEN PUEDE HABLAR POR TI (`docs/datos-del-perfil.md`).
+    //
+    // Va explícito y antes que nada porque si no cae en la rama de «cajón sin dueño» y
+    // acabaría envuelto solo para quien ADMINISTRA — que no es lo que se decidió: leer y
+    // escribir tu identidad es `firma`, y no todos los que firman administran. Un teléfono
+    // normal firma y no administra, y tiene que ver tu perfil.
+    if (owner === PROFILE_OWNER) {
+      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+      const firman = (record?.members || [])
+        .filter((m) => m.encPub && Acta.memberCan(record, m.pub, 'sign'))
+        .map((m) => ({ pub: m.pub, encPub: m.encPub }))
+      return conCoselladores(dedup(firman), co)
+    }
     if (owner.startsWith('ns:')) {
       const owned = await nsMembers(owner.slice(3))
       // Sin dueño (un cajón personal, o uno cuyo servicio ya no está) entra quien administra
@@ -2369,6 +2630,25 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
   async function deleteSecret (ns, key) { const ok = await secrets.delete(ns, key); if (ok) { audit('secret.rm', { ns, key }); scheduleNotice(ns) } return ok }
 
+  /**
+   * RENOMBRAR una variable. Para el servicio que la lee es un cambio de configuración como
+   * cualquier otro —la de antes desaparece y aparece otra—, así que se avisa igual: si no,
+   * seguiría arrancando con el nombre viejo hasta el siguiente reinicio.
+   */
+  async function renameSecret (ns, from, to) {
+    const r = await secrets.rename(`ns:${ns}`, from, to)
+    if (r?.renamed) { audit('secret.rename', { ns, from, to }); scheduleNotice(ns) }
+    return r
+  }
+  async function renameDeviceSecret (pub, from, to) {
+    const r = await secrets.rename(`dev:${pub}`, from, to)
+    if (r?.renamed) {
+      audit('secret.rename', { device: await deviceIdOf(pub).catch(() => null), from, to, scope: 'device' })
+      scheduleDeviceNotice(pub)
+    }
+    return r
+  }
+
   /**
    * CARGAR CONFIGURACIÓN ES UNA TRANSACCIÓN: muchas variables, UN aviso.
    *
@@ -2604,6 +2884,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (r?.locked === false) { try { await ensureCommKeyInActa() } catch (_) {} }
       return { locked: r?.locked !== false }
     },
+    // Forzar un empujón: lo usa `replica push` de la CLI y el smoke, para no depender
+    // de que justo acabe de cambiar algo.
+    pushToReplicas,
     startPairing: desk.startPairing,
     stopPairing: desk.stopPairing,
     listPending: desk.listPending,
@@ -2652,7 +2935,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // 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, openSecrets,
+    setSecret, deleteSecret, renameSecret, renameDeviceSecret, listSecrets, setSecretVisibility, openSecrets,
     // Sella un `secrets.json` v3 entero. Es el punto de no retorno del despliegue y
     // por eso es una operación con nombre propio, no algo que ocurra de refilón al
     // desbloquear: deja `secrets.json.v3.bak` para poder volver.

package/src/vaultControl.js

@@ -513,6 +513,30 @@ export function deleteSecret (ns, key, profile) {
   })
 }
 
+/**
+ * Renombra una variable: el mismo sobre con otro nombre. No pide la frase — lo único que
+ * hay que rehacer es la firma, y de eso se encarga la llave de sellado.
+ *
+ * Se comprueban LAS DOS cosas: que la nueva esté y que la vieja ya no. Mirar solo una
+ * dejaría pasar una copia a medias, que es peor que un fallo.
+ */
+export function renameSecret (ns, key, to, profile) {
+  return secretOp({ op: 'rename', ns, key, to }, profile, (out) => {
+    if (!has(out.ns[ns], to) || has(out.ns[ns], key)) {
+      throw coded('the daemon did not rename the variable (check the service logs)', 'NOT_RENAMED')
+    }
+  })
+}
+
+/** Lo mismo para una variable de UN aparato. */
+export function renameDeviceSecret (pub, key, to, profile) {
+  return secretOp({ op: 'dev-rename', pub, key, to }, profile, (out) => {
+    if (!has(keysOf(out, pub), to) || has(keysOf(out, pub), key)) {
+      throw coded('the daemon did not rename the variable (check the service logs)', 'NOT_RENAMED')
+    }
+  })
+}
+
 /**
  * Cambia SOLO quién puede ver el valor: `public` deja que la consola remota lo vea,
  * `private` lo encierra en esta máquina. No toca el valor (ni hace falta conocerlo).