@dotrino/vault 0.60.4 → 0.62.0

package/bin/dotrino-env.js

@@ -218,7 +218,13 @@ async function cmdCheck () {
   // `--public` también aquí: ver QUÉ hay no debería costarle una aprobación al dueño. Sin
   // él se piden todas, que es lo que hace falta para comprobar de verdad un arranque.
   const publicOnly = argv.includes('--public')
-  const secrets = await fetchSecrets({ dir: serviceDir(etiquetaBoveda(), ns), ns, publicOnly })
+  // Y SE DICE QUE ESTÁ ESPERANDO. Sin este aviso `check` se queda mudo cinco minutos —el
+  // plazo de la aprobación— y desde fuera eso es un cuelgue: ni una línea que diga que la
+  // bóveda contestó, que lo que falta es un permiso, ni cuánto va a esperar. `run` sí lo
+  // decía; `check`, que es el comando de DIAGNÓSTICO, era el único que no. Le pasó al dueño
+  // el 2026-09-05 con un cajón cuyo servicio no tenía a nadie que pudiera aprobarle.
+  const onPending = () => console.error('[dotrino-env] la bóveda pide aprobación: apruébalo en un aparato con «aprueba» (hasta 5 min)')
+  const secrets = await fetchSecrets({ dir: serviceDir(etiquetaBoveda(), ns), ns, publicOnly, onPending })
   const keys = Object.keys(secrets)
   console.log('ns "%s": %d %s%s', ns, keys.length,
     publicOnly ? 'variable(s) pública(s)' : 'secreto(s)', keys.length ? ':' : '')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.60.4",
+  "version": "0.62.0",
   "description": "Usa ESTE dispositivo (navegador) como bóveda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegación a tus máquinas. Incluye el cliente de SERVICIO (Node): un proyecto se enrola una vez y jala sus credenciales del vault en vez del .env (`import '@dotrino/vault/config'`).",
   "type": "module",
   "main": "src/index.js",

package/src/admin.js

@@ -61,7 +61,11 @@ export const ADMIN_OPS = Object.freeze([
   // documentada en `buildSealedVar` y la consola la llamaba, pero no existía — así que
   // crear una variable desde la consola contestaba «admin: invalid operation». No expone
   // nada nuevo: son llaves PÚBLICAS, las mismas que ya viajan en el acta.
-  'vars', 'var.set', 'var.setMany', 'var.recipients'
+  'vars', 'var.set', 'var.setMany', 'var.recipients',
+  // ABRIR LA BÓVEDA A DISTANCIA (`docs/abrir-a-distancia.md`). Dos pasos: `unlock.begin`
+  // pide una llave efímera y los parámetros del molino; `unlock` trae la derivada dentro
+  // de un sobre que solo esta bóveda puede abrir. No hay una tercera.
+  'unlock.begin', 'unlock'
 ])
 
 /**
@@ -90,7 +94,13 @@ 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', 'var.set', 'var.setMany', 'var.recipients'])
+export const ADMIN_OPS_WHILE_LOCKED = Object.freeze([
+  'audit', 'vars', 'var.set', 'var.setMany', 'var.recipients',
+  // Las dos de abrir, obviamente: son las únicas que solo tienen sentido con el candado
+  // echado. Que estén aquí NO las deja pasar sin más — siguen exigiendo cert, acta, nonce
+  // y frescura como todas, y además la contraseña dentro del sobre.
+  'unlock.begin', 'unlock'
+])
 
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
 export const ADMIN_NONCE_TTL_MS = 10 * 60 * 1000
@@ -133,6 +143,10 @@ export function authorBody (owner, key, e, ts) {
 export function createAdminDesk ({
   desk, verify, readActivity = () => [], deviceIdOf, vars = null,
   notify = async () => {}, audit = () => {}, isLocked = () => false,
+  // ABRIR A DISTANCIA. Va inyectado —como `vars`— porque abrir necesita cripto y disco, y
+  // este módulo es puro a propósito. `null` en una bóveda que no lo soporte: entonces la
+  // operación existe y contesta que no, en vez de romper con un TypeError.
+  unlockDesk = null,
   now = () => Date.now()
 }) {
   const ops = new Set(ADMIN_OPS)
@@ -193,6 +207,17 @@ export function createAdminDesk ({
 
     try {
 
+      // ABRIR A DISTANCIA. La bóveda hace el trabajo; aquí solo se enruta, porque este
+      // módulo es puro —sin cripto, sin disco— y abrir necesita las dos cosas.
+      if (data.op === 'unlock.begin') {
+        if (!unlockDesk) return { ok: false, error: 'admin: this vault cannot be opened remotely (update it)' }
+        return { ok: true, result: await unlockDesk.begin({ by, device: chk.device }) }
+      }
+      if (data.op === 'unlock') {
+        if (!unlockDesk) return { ok: false, error: 'admin: this vault cannot be opened remotely (update it)' }
+        return await unlockDesk.open({ nonce: data.nonce, enc: data.enc, by, device: chk.device })
+      }
+
       if (data.op === 'audit') {
         const limit = Math.min(Math.max(Number(data.limit) || 100, 1), AUDIT_MAX)
         return { ok: true, result: { entries: readActivity(limit) } }

package/src/index.js

@@ -97,9 +97,8 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   const selfCert = await getSelfCert()
   const identify = async () => {
     if (!client.token) return
-    const data = { op: 'identify', publickey: iss, token: client.token, ts: Date.now() }
-    const { signature } = await identity.signData(data)
-    await client.identify({ data, signature, cert: selfCert })
+    // El sobre lo arma el pilar (`identifyAs`), que le pone el destinatario.
+    await client.identifyAs({ publickey: iss, sign: (d) => identity.signData(d), cert: selfCert })
   }
   await identify()
   client.on('token', () => identify().catch(() => {}))

package/src/localdesk.js

@@ -85,7 +85,15 @@ export async function connectLocal ({ masterId, timeoutMs = 3000 } = {}) {
     // El mostrador local no pide identificarse: la puerta la abre el certificado que va
     // dentro de cada mensaje, igual que por el proxio. Identificarse ahí sirve para ser
     // DIRECCIONABLE, y aquí no hay a quién direccionar.
+    //
+    // LAS DOS FORMAS, porque quien llama no sabe por dónde salió. `freshClient` devuelve
+    // esto o un `WebSocketProxyClient` según haya socket o no, y el de arriba llama al
+    // método sin más: si aquí falta el que el pilar usa ahora, el escalón 1 del transporte
+    // —el más rápido, y el que corre en la máquina del dueño— muere con «client.identifyAs
+    // is not a function» mientras por el proxio todo va bien. Que sea un no-op no lo hace
+    // opcional: es la forma del cliente, y tiene que estar entera.
     identify: async () => ({ ok: true }),
+    identifyAs: async () => ({ ok: true }),
     on: (ev, fn) => {
       if (ev !== 'message') return () => {}
       oyentes.add(fn)

package/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/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
@@ -178,9 +199,8 @@ async function freshClient (proxyUrl, connectTimeoutMs = 20000, master = null) {
 
 /** Identifica la conexión bajo la pubkey del servicio (para ser direccionable). */
 async function identifyAsService (client, device) {
-  const data = { op: 'identify', publickey: device.publickey, token: client.token, ts: Date.now() }
-  const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
-  await client.identify({ data, signature })
+  // El sobre lo arma el pilar (`identifyAs`), que le pone el destinatario.
+  await client.identifyAs({ publickey: device.publickey, sign: (d) => signWithDevice({ privateJwk: device.privateJwk, data: d }) })
 }
 
 /** Cuánto espera un agente a que alguien apruebe (el pedido vive 5 min en la bóveda). */
@@ -593,7 +613,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/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()