@dotrino/vaultd 0.106.1 → 0.107.0

package/lib/src/protocol.js

@@ -128,3 +128,18 @@ export const isValidSecretsNs = (ns) => typeof ns === 'string' && /^[a-z0-9-]{1,
  * remota y el lector de `.env`, y tres copias de una regla son tres reglas.
  */
 export const isValidVarKey = (key) => typeof key === 'string' && /^[A-Z0-9_]{1,64}$/.test(key)
+
+/**
+ * LA VERSIÓN DEL CABLE (CONVENCIONES §14, `@dotrino/compat`).
+ *
+ * Sube **solo cuando cambia el protocolo**, no con cada release: es lo que decide *si dos
+ * piezas pueden hablar*. La `version` del paquete decide otra cosa —si esa build concreta
+ * está rota— y por eso hacen falta las dos.
+ *
+ * Empieza en 1 hoy, con todo lo anterior sin declarar nada: a quien calla se le atiende
+ * hasta que cierre la ventana de migración del pilar, y después no.
+ */
+export const VAULT_PROTOCOL = 1
+
+/** Los protocolos que esta build entiende. Al añadir el 2, aquí van `[1, 2]`. */
+export const VAULT_SPEAKS = [1]

package/lib/src/service.js

@@ -26,7 +26,8 @@ import {
   verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
 import { openWrap, wrapForMember, decryptWithCek } from '@dotrino/identity/content'
 import { verifyActa, sealKeyAt, sealersOf, memberCan } from '@dotrino/identity/acta'
-import { MSG, secretsScope, isValidSecretsNs } from './protocol.js'
+import { MSG, secretsScope, isValidSecretsNs, VAULT_PROTOCOL, VAULT_SPEAKS } from './protocol.js'
+import { PKG_VERSION } from './version.js'
 import { makeEphemeralKey, openSealed } from './sealed.js'
 import { parseInvite } from './invite.js'
 import { atRestFor } from './atrest.js'
@@ -35,6 +36,26 @@ import { connectLocal, hasLocalVault } from './localdesk.js'
 const IDENTITY_FILE = 'service-identity.json'
 const FRESH_WINDOW_MS = 5 * 60 * 1000
 
+/**
+ * QUÉ SOMOS, dentro de lo que ya va firmado (CONVENCIONES §14).
+ *
+ * Va DENTRO de `data` y no en el envoltorio a propósito: `data` lo firma la llave del
+ * aparato, así que lo que la bóveda apunta y enseña es lo que ese aparato dijo **con su
+ * llave**. Un inventario de versiones que cualquiera puede escribir no es un inventario.
+ *
+ * `PRODUCT` es el cliente de la bóveda —el que se instala con `@dotrino/env`—, que es
+ * justo la pieza que se quedaba atrás sin que nadie se enterara: pedía `^0.33.2` con la
+ * librería en 0.60 y enrolar contestaba `invalid cert: no-acta`, que es verdad y no es la
+ * causa.
+ */
+const PRODUCT = 'vault'
+export const MY_VERSION = {
+  product: PRODUCT,
+  version: PKG_VERSION,
+  protocol: VAULT_PROTOCOL,
+  speaks: VAULT_SPEAKS
+}
+
 let _globalsInstalled = false
 function installNodeGlobals () {
   if (_globalsInstalled) return
@@ -593,7 +614,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     const eph = await makeEphemeralKey()
     // `publicOnly` VIAJA FIRMADO (va dentro de `data`), así que nadie lo puede quitar ni
     // poner por el camino. Quien decide qué se manda es la bóveda; esto solo es la petición.
-    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), ...(publicOnly ? { publicOnly: true } : {}) }
+    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), v: MY_VERSION, ...(publicOnly ? { publicOnly: true } : {}) }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
     // A QUIÉN SE LE PREGUNTA: primero a la bóveda, y si no contesta, a los REPLICADORES
     // que el acta nombraba la última vez que la vimos (`docs/replicas.md` §8: «el servicio

package/lib/src/version.js

@@ -0,0 +1,30 @@
+/**
+ * version.js — la versión de `@dotrino/vault` (el CLIENTE, no el daemon).
+ *
+ * Existe porque el cliente tiene que poder decir qué versión es (CONVENCIONES §14), y esta
+ * es justo la pieza que se quedaba atrás sin que nadie se enterara: `@dotrino/env` pedía
+ * `^0.33.2` con la librería en 0.60, y enrolar contestaba `invalid cert: no-acta` — verdad,
+ * y no la causa.
+ *
+ * Se lee del `package.json` que viaja con el paquete. Si no se puede leer se dice `0.0.0`,
+ * que es un número imposible y por tanto legible como «no lo sé» — no se inventa uno
+ * plausible, que sería peor que no decir nada.
+ */
+import fs from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+function leer () {
+  try {
+    const aqui = dirname(fileURLToPath(import.meta.url))
+    for (const p of [join(aqui, '..', 'package.json'), join(aqui, '..', '..', 'package.json')]) {
+      try {
+        const v = JSON.parse(fs.readFileSync(p, 'utf8'))
+        if (v?.name === '@dotrino/vault' && typeof v.version === 'string') return v.version
+      } catch (_) {}
+    }
+  } catch (_) {}
+  return '0.0.0'
+}
+
+export const PKG_VERSION = leer()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.106.1",
+  "version": "0.107.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": {
@@ -21,9 +21,11 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@dotrino/compat": "0.4.0",
     "@dotrino/identity": "0.79.0",
     "@dotrino/passmanager": "^0.10.1",
     "@dotrino/proxy-client": "0.15.0",
+    "@dotrino/roadmap": "0.1.0",
     "ws": "^8.18.0"
   },
   "license": "MIT",

package/src/ctl.js

@@ -595,6 +595,18 @@ async function cmdMembers () {
     // selladas a esa llave. Se dice aquí, junto a él, porque es el único sitio donde
     // 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)
+    // QUÉ CORRE, y si cuadra con esta bóveda (CONVENCIONES §14). Sin esto una
+    // incompatibilidad de versiones se ve como que ese aparato «no responde», que es el
+    // fallo más caro que ha tenido el ecosistema. No bloquea nada: se enseña.
+    if (m.running) {
+      const v = `${m.running.product} ${m.running.version}`
+      if (m.running.compatible) console.log('      %scorre %s%s', D, v, Z)
+      else console.log('      %s⚠ corre %s · %s%s', R, v, m.running.reason, Z)
+    }
+  }
+  if (record.vault) {
+    console.log('\n  %sEsta bóveda corre %s %s (protocolo %d)%s',
+      D, record.vault.product, record.vault.version, record.vault.protocol, Z)
   }
   console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +contrasenas | +sella | +desatendido | +replica')
   console.log('  «Permiso»: ese aparato solo recibe claves privadas cuando lo apruebas desde un aparato con «aprueba» (en cada arranque).')

package/src/vault.js

@@ -14,7 +14,7 @@ import fs from 'node:fs'
 import nodeCrypto from 'node:crypto'
 import path from 'node:path'
 import { Identity } from '@dotrino/identity/node'
-import { verifyChain, pubkeyId, verifyDeviceSig } from '@dotrino/identity/capabilities'
+import { verifyChain as verifyChainRaw, 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, authorBody } from '../lib/src/admin.js'
@@ -27,6 +27,9 @@ 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, PROFILE_OWNER } from './secretsStore.js'
+import { VERSION } from './version.js'
+import { declare as compatDeclare, check as compatCheck, annotate as compatAnnotate } from '@dotrino/compat'
+import { loadManifest, brokenOf } from '@dotrino/roadmap'
 // `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
@@ -40,7 +43,7 @@ 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'
+import { MSG, SCOPE, secretsScope, isValidSecretsNs, VAULT_PROTOCOL, VAULT_SPEAKS } from './protocol.js'
 
 /**
  * Tope de una respuesta de la bóveda por el transporte. El proxio (`PROXY_MAX_FRAME_BYTES`)
@@ -333,9 +336,67 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    */
   const canales = new Map()
 
+  /**
+   * QUÉ SOMOS, Y QUÉ CORRE CADA APARATO (CONVENCIONES §14, `@dotrino/compat`).
+   *
+   * El agujero que esto tapa: una incompatibilidad de versiones se manifestaba como
+   * SILENCIO. El que llamaba no sabía si estábamos apagados, ocupados o hablando otro
+   * idioma, así que reintentaba para siempre — y aquí no se sabía que nos hablaban.
+   *
+   * **Informa, no bloquea** (dueño, 2026-09-04): el dictamen se enseña y se le pega a los
+   * errores, y no hay ni un `if` que deje de atender por él. Si algún día se decide
+   * bloquear, se decide arriba y se escribe aquí a propósito.
+   *
+   * La lista de rotas sale del registro común (`@dotrino/roadmap`), que viaja DENTRO de
+   * esta versión: la compatibilidad es política del código, no de la cuenta.
+   */
+  const MI_VERSION = compatDeclare({
+    product: 'vaultd', version: VERSION, protocol: VAULT_PROTOCOL, speaks: VAULT_SPEAKS
+  })
+  let ROTAS = []
+  try { ROTAS = brokenOf(loadManifest()) } catch (e) { log('[vault] no compatibility registry: ' + e.message) }
+
+  /**
+   * Lo que dice correr cada aparato, por llave. Se apunta de lo que viene FIRMADO
+   * (`p.data.v`, dentro del sobre) y no del envoltorio: una versión que cualquiera puede
+   * escribir no vale para enseñarla como si fuera un dato.
+   */
+  const versiones = new Map()
+  const apuntarVersion = (pub, v) => {
+    if (!pub || !v) return
+    const dictamen = compatCheck({ mine: MI_VERSION, theirs: v, broken: ROTAS })
+    versiones.set(pub, { ...v, at: Date.now(), compatible: dictamen.compatible, reason: dictamen.reason })
+    if (!dictamen.compatible) log(`[vault] ${v.product} ${v.version}: ${dictamen.reason}`)
+    return dictamen
+  }
+  /** El dictamen de un aparato, para enseñarlo o para pegárselo a un error. */
+  const versionDe = (pub) => versiones.get(pub) || null
+
+  /**
+   * LA VERSIÓN SE APUNTA DONDE YA SE COMPRUEBA LA FIRMA, y por eso esto envuelve a
+   * `verifyChain` en vez de mirar el envoltorio del mensaje: `data` va firmado, así que
+   * lo que se apunta es lo que ese aparato dijo **con su llave**, no lo que cualquiera
+   * pueda escribir por fuera. Un inventario de versiones que se puede falsificar no es un
+   * inventario, es una pantalla bonita.
+   *
+   * Va envuelto y no repetido en los ocho mostradores porque una comprobación copiada
+   * ocho veces son siete sitios donde olvidarla.
+   */
+  const verifyChain = async (args) => {
+    const chk = await verifyChainRaw(args)
+    if (chk.ok && args?.data?.v) apuntarVersion(chk.device, args.data.v)
+    return chk
+  }
+
+
   const reply = (to, obj) => {
     try {
       const enviar = canales.get(to) || ((o) => client.send(to, o))
+      // ANUNCIAMOS EN CADA RESPUESTA: el otro lado decide con esto, y decide él porque es
+      // el que puede tener la lista al día (§14). Va en el envoltorio y no dentro de un
+      // cuerpo firmado a propósito — es un dato para enseñar y para explicar un fallo, no
+      // una credencial: nada se autoriza con él.
+      obj = { ...obj, v: MI_VERSION }
       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`)
@@ -889,10 +950,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // `sub` (pubkey completa) va incluida: es la DIRECCIÓN de cada dispositivo en el
     // proxy → permite a las apps AUTODESCUBRIR tus máquinas (p. ej. la terminal
     // lista tus agentes sin pegar nada). Solo la ve quien presenta un cert tuyo válido.
+    // QUÉ CORRE CADA UNO, y si cuadra con lo que corremos aquí (CONVENCIONES §14). Va con
+    // la lista porque es donde se mira: el dueño lo pidió en el administrador Y en la
+    // lista de dispositivos de la bóveda. `null` significa «todavía no ha hablado desde
+    // que arrancamos», que es distinto de «no declara» — y se dice distinto.
     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
+      deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce,
+      running: x.sub ? versionDe(x.sub) : null
     })))
-    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain }))
+    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain, vault: MI_VERSION }))
   }
 
   /**
@@ -1923,6 +1989,29 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       audit('rejected', { what: 'renounce', reason: 'signature' })
       return reply(from, { type: MSG.ERROR, error: 'renounce: the signature is not the member own' })
     }
+    // UNA RENUNCIA QUE NO QUITA NADA NO SE HONRA, y esto es lo que corta el replay barato.
+    //
+    // El registro va firmado y lleva `ts`, pero nadie lo miraba: cualquiera que lo viera
+    // pasar por el proxio podía volver a mandarlo cuando quisiera. Como `absorbRenounce`
+    // SELLA UN ACTA NUEVA cada vez, repetirlo hacía subir el `seq` y empujar a todos los
+    // aparatos sin que hubiera cambiado nada — y dejaba en la bitácora una renuncia con el
+    // nombre del aparato, que es lo peor: la bitácora es la prueba, y ahí decía algo que
+    // ese aparato no hizo.
+    //
+    // Mirando lo que el acta dice HOY, un registro repetido no quita nada y se para aquí.
+    // Lo que esto NO cierra, y queda anotado: si el dueño vuelve a conceder ese permiso, el
+    // mismo registro viejo lo quita otra vez. Cerrarlo del todo pide que el acta recuerde
+    // la fecha de la última renuncia por miembro y rechace las que no sean posteriores.
+    const actual = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!actual) {
+      audit('rejected', { what: 'renounce', reason: 'sin-acta' })
+      return reply(from, { type: MSG.ERROR, error: 'renounce: this vault has no record to apply it to' })
+    }
+    const tiene = new Set(Acta.effectiveCaps(actual, record.member) || [])
+    if (!(record.caps || []).some((c) => tiene.has(c))) {
+      audit('rejected', { what: 'renounce', reason: 'nada-que-quitar' })
+      return reply(from, { type: MSG.ERROR, error: 'renounce: that member no longer holds any of those capabilities' })
+    }
     try {
       const r = await identity.absorbRenounce(record)
       const device = await deviceIdOf(record.member).catch(() => null)
@@ -3015,7 +3104,22 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     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.
-    profileMembers: () => identity.profileMembers(),
+    /**
+     * Los miembros del acta, y QUÉ CORRE CADA UNO (CONVENCIONES §14). La versión no está en
+     * el acta —el acta dice quién puede qué, no qué build es— así que se le pega aquí, que
+     * es por donde salen `members` y la consola. El dueño lo pidió en los dos sitios.
+     *
+     * `running: null` es «todavía no ha hablado desde que arrancamos», que no es lo mismo
+     * que «no declara»: lo segundo trae un dictamen con `code: 'undeclared'`.
+     */
+    profileMembers: async () => {
+      const r = await identity.profileMembers()
+      return {
+        ...r,
+        vault: MI_VERSION,
+        members: (r?.members || []).map((m) => ({ ...m, running: versionDe(m.pub) }))
+      }
+    },
     // Los namespaces que quedaron a deber una rotación (se fue un miembro y no se pudo
     // rotar su llave). Lo enseñan `secret list` y la consola: si no se ve, no se salda.
     rotationsDue,