@dotrino/vaultd 0.76.0 → 0.78.0

package/lib/src/admin.js

@@ -60,7 +60,20 @@ export const ADMIN_OPS = Object.freeze([
 ])
 
 /**
- * LO ÚNICO QUE SE ATIENDE CON EL CANDADO ECHADO: mirar. Ni una operación que cambie algo.
+ * QUÉ SE ATIENDE CON EL CANDADO ECHADO.
+ *
+ * No es «solo mirar», y confundirlo fue un error: **guardar una variable NO necesita la
+ * maestra**. Sellar un valor usa las llaves PÚBLICAS de quien va a leerlo, así que la
+ * bóveda puede hacerlo sin ningún secreto suyo (`docs/secretos-sellados.md` §8.1) — es
+ * justo lo que hace barata la rotación. Meterlo en el mismo saco que revocar dejaba la
+ * consola sin poder configurar nada con el perfil cerrado, que es su trabajo diario.
+ *
+ * Lo que SÍ se queda fuera es `revoke`: reescribe el acta, y sellar el acta es de la
+ * maestra. Cerrada no hay con qué.
+ *
+ * (Si el cajón tiene su llave sellada con la frase, repartirla a los miembros puede quedar
+ * a deber hasta que alguien abra: eso ya lo dice la bóveda y se salda solo. Guardar el
+ * valor, que es lo que se pidió, se hace igual.)
  *
  * El candado ES de la consola —los aparatos ya emparejados siguen leyendo, guardando y
  * firmando con SU llave— así que cerrar el perfil tiene que cerrar exactamente esto. No
@@ -72,7 +85,7 @@ export const ADMIN_OPS = Object.freeze([
  * Se dejan las de LEER a propósito: si se cortaran todas, la consola no podría ni
  * enterarse de por qué no funciona y parecería rota. Así puede decir «está cerrada».
  */
-export const ADMIN_OPS_WHILE_LOCKED = Object.freeze(['audit', 'vars'])
+export const ADMIN_OPS_WHILE_LOCKED = Object.freeze(['audit', 'vars', 'var.set', 'var.setMany'])
 
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
 export const ADMIN_NONCE_TTL_MS = 10 * 60 * 1000
@@ -136,7 +149,7 @@ export function createAdminDesk ({
     }
     const by = await deviceIdOf(chk.device).catch(() => null)
 
-    // CERRADA NO SE ADMINISTRA. Va después de autorizar (el candado es estado del perfil,
+    // CERRADA NO SE SELLA EL ACTA. Va después de autorizar (el candado es estado del perfil,
     // y a un desconocido no se le cuenta) y ANTES de quemar el nonce: quien reintente
     // tras abrir la bóveda no tiene por qué generar otro.
     //

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.76.0",
+  "version": "0.78.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": {

package/src/ctl.js

@@ -419,7 +419,14 @@ async function cmdJoin (rest) {
     process.exit(2)
   }
   const qr = parseInvite(texto)
-  if (!qr?.sn || !qr?.iss || !qr?.proxy) {
+  // QUÉ HACE FALTA DE VERDAD: el nonce de la sesión (`sn`) y una forma de alcanzar a la
+  // otra bóveda — la CITA del proxio (`conn`) en la invitación corta, o su llave (`iss`)
+  // en la larga. Quien la consume es `enrollDevice`, que sabe canjear la cita.
+  //
+  // Esto exigía `iss` SIEMPRE, y la invitación corta no lo lleva (la llave dejó de viajar
+  // cuando el QR se acortó, `lib/src/invite.js`). O sea que `join` rechazaba todas las
+  // invitaciones que emite `pair` hoy: el multivault entero no se podía montar.
+  if (!qr?.sn || !(qr?.conn || qr?.iss)) {
     console.error('Esa invitación no se entiende. Pega la línea completa que imprime «dotrino-vault pair».')
     process.exit(2)
   }

package/src/daemon.js

@@ -791,7 +791,10 @@ export async function runDaemon () {
 
     let qr = null
     try { qr = parseInvite(texto) } catch (_) {}
-    if (!qr?.sn || !qr?.iss || !qr?.proxy) {
+    // Lo mismo que `dotrino-vault join` (ver `ctl.js`): basta `sn` + la cita del proxio o
+    // la llave. Exigir `iss` dejaba fuera a la invitación corta, que es la única que emite
+    // `pair` hoy — así que este camino de despliegue no había forma de que funcionara.
+    if (!qr?.sn || !(qr?.conn || qr?.iss)) {
       console.error('[vault] the invitation in DOTRINO_JOIN is not valid; ignoring it')
       return
     }
@@ -799,7 +802,7 @@ export async function runDaemon () {
     const hecho = readJsonSafe(marca)
     if (hecho?.sn === qr.sn) return // ya se usó: un reinicio no vuelve a pedir entrar
 
-    writeJson(marca, { at: Date.now(), sn: qr.sn, iss: qr.iss })
+    writeJson(marca, { at: Date.now(), sn: qr.sn, ...(qr.iss ? { iss: qr.iss } : {}) })
     writeJson(path.join(dir, 'join-request.json'), {
       qr,
       label: 'bóveda',

package/src/transport.js

@@ -66,7 +66,16 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
     if (comm && esMiembro) {
       const data = { op: 'identify', publickey: comm, token: client.token, ts: Date.now() }
       const signature = await commKey.sign(data)
-      if (signature) return client.identify({ data, signature, acta: record })
+      if (signature) {
+        await client.identify({ data, signature, acta: record })
+        // SE DICE QUE SE IDENTIFICÓ, y con qué llave. Este camino era MUDO: al pasar de la
+        // maestra a la llave de comunicación, el único rastro de «estoy alcanzable» que
+        // quedaba en el log era el del repliegue. Así que cuando la consola decía «no
+        // contesta», no había forma de saber desde aquí si la bóveda estaba atada al proxio
+        // o no. Una línea por reconexión es barata; no tenerla cuesta una hora de sondeos.
+        log('[vault] identified on the proxy with the communication key · record #%s', record?.seq ?? '?')
+        return
+      }
     }
 
     // REPLIEGUE, y solo para migrar: una bóveda que todavía no ha metido su llave de

package/src/vault.js

@@ -285,8 +285,26 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return new Set(revoked.map((r) => r.nonce))
   }
 
+  /**
+   * CONTESTAR SIN MATAR LA CONEXIÓN.
+   *
+   * El proxio corta los frames a 1 MB (`maxPayload`), y `ws` no «descarta» el que se pasa:
+   * CIERRA EL SOCKET con un 1009. La bóveda se queda muda, sin un solo error en su log, y
+   * desde fuera se ve igual que si estuviera apagada. Eso ya pasó y duró tres días.
+   *
+   * 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.
+   */
   const reply = (to, obj) => {
-    try { client.send(to, obj) } catch (e) { log('[vault] could not reply:', e.message) }
+    try {
+      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` })
+      }
+      client.send(to, obj)
+    } catch (e) { log('[vault] could not reply:', e.message) }
   }
 
   // FRESCURA anti-replay: toda petición firmada debe traer `data.ts` dentro de una
@@ -680,7 +698,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     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`)
+    // Si tras podar la cadena SIGUE sin caber, no se avisa y se manda igual —eso mataba la
+    // conexión—: se devuelve tal cual y `reply` lo sustituye por un error. El aviso de aquí
+    // sobra porque el de `reply` dice lo mismo y además dice qué hizo.
     return msg
   }
 
@@ -2031,6 +2051,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   return {
     identity, client, store, threads, secrets, master, fingerprint: fp, dir,
+    // Se expone para poder PROBAR que una respuesta que no cabe no mata la conexión: es el
+    // único punto por el que sale todo, y el fallo que cierra vive justo ahí.
+    reply,
     /**
      * SOLTAR LA MAESTRA. Cerrar el perfil tiene que sacarla de la memoria, no solo dejar de
      * cargarla en el siguiente arranque: si no, el candado seguiría siendo una bandera al