@dotrino/vault 0.21.0 → 0.23.0

package/README.md

@@ -50,7 +50,7 @@ si la máquina se compromete, revocas el cert y no había nada que robar.
 ```bash
 # en el VAULT (tu PC): abres el emparejamiento del servicio y cargas sus secretos
 dotrino-vault pair --service miapp          # invitación con scope SOLO vault:secrets:miapp
-dotrino-vault secret set miapp API_KEY  sk-…
+dotrino-vault secret set miapp API_KEY  sk-…   # la comparten TODAS las máquinas del ns
 
 # en el PROYECTO/servidor: enrola esta máquina (pega la invitación)
 npx dotrino-env enroll --ns miapp
@@ -60,6 +60,17 @@ npx dotrino-env enroll --ns miapp
 dotrino-vault approve 7K3F-92Q1
 ```
 
+Si la misma app corre en **varias máquinas**, lo que cambia de una a otra (el puerto,
+la URL pública) va en el cajón **por aparato**, sin partir el `ns`:
+
+```bash
+dotrino-vault devices                                   # el ID del aparato: AB12-CD34
+dotrino-vault secret device set AB12-CD34 PORT 8443     # solo la lee ESA máquina
+```
+
+Llegan **mezcladas en el mismo bundle** —y por lo tanto en el mismo `process.env`—:
+las del scope, con las del aparato **encima** si se llaman igual.
+
 El código lo **genera el servicio** y **no viaja** por la red: el vault solo puede
 echarlo de vuelta si un humano lo tipeó. Así, un vault falso no puede enrolarte y
 aprobar a ciegas no enrola a nadie. Queda `~/.dotrino/service/<ns>/service-identity.json`

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.21.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'`).",
+  "version": "0.23.0",
+  "description": "Usa ESTE dispositivo (navegador) como b\u00f3veda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegaci\u00f3n a tus m\u00e1quinas. 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",
   "module": "src/index.js",
@@ -50,5 +50,12 @@
     "type": "git",
     "url": "git+https://github.com/imdotrino/dotrino-vault.git",
     "directory": "lib"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "@types/node": "^22.0.0"
+  },
+  "scripts": {
+    "type-check": "tsc --noEmit"
   }
 }

package/src/admin.js

@@ -9,8 +9,16 @@
  *
  *   sí  · ver el acta y la bitácora · iniciar un emparejamiento (mostrar el QR)
  *       · APROBAR o rechazar a quien entra · REVOCAR a un miembro
+ *       · VARIABLES DE ENTORNO: crearlas y darles valor (de un scope o de un aparato),
+ *         y ver el valor de las marcadas PÚBLICAS
  *   no  · cambiar permisos · traspasar el mando · conceder `admin`
- *       · nada de los secretos de servicios
+ *       · ver el valor de una variable PRIVADA · borrar variables
+ *
+ * SOBRE LAS VARIABLES, que es la rendija más nueva: lo que cruza la frontera no es «los
+ * secretos» sino los que su dueño MARCÓ como mostrables. Una privada se puede reescribir
+ * a ciegas desde la consola, pero su valor no sale de la máquina de la bóveda ni para un
+ * aparato tuyo con `admin`. Y los valores que sí salen viajan CIFRADOS con la clave de
+ * contenido del perfil (quien llama sella y abre): el proxy transporta y no ve nada.
  *
  * La frontera no es un capricho: un admin puede **admitir y expulsar**, pero no
  * reescribir quién manda. Así un aparato con `admin` robado hace daño **acotado y
@@ -26,7 +34,13 @@
  */
 
 /** Las únicas operaciones que existen a distancia. Lista cerrada, como las capacidades. */
-export const ADMIN_OPS = Object.freeze(['pending', 'pair', 'approve', 'reject', 'revoke', 'audit'])
+export const ADMIN_OPS = Object.freeze([
+  'pending', 'pair', 'approve', 'reject', 'revoke', 'audit',
+  // Variables de entorno: verlas (nombres siempre; valor solo de las públicas) y
+  // ponerles valor (de las dos). Borrar NO está, y es a propósito: un aparato robado
+  // no debe poder dejar sin configuración a los servicios.
+  'vars', 'var.set'
+])
 
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
 export const ADMIN_NONCE_TTL_MS = 10 * 60 * 1000
@@ -40,13 +54,18 @@ export const AUDIT_MAX = 500
  * @param {(scope:string[])=>Promise<any>} o.verify  verifica cadena+cert; devuelve `{ok, device, reason}`.
  * @param {(limit:number)=>any[]} o.readActivity     últimas entradas de la bitácora.
  * @param {(pub:string)=>Promise<string>} o.deviceIdOf
+ * @param {{list:(a:object)=>Promise<any>, set:(a:object)=>Promise<any>}} [o.vars]
+ *   mostrador de VARIABLES DE ENTORNO. Va inyectado porque aquí no hay cripto ni disco:
+ *   quien lo implementa (la bóveda) es quien sella con la clave de contenido del perfil y
+ *   quien decide qué valor puede salir. Sin él, las ops de variables responden que esta
+ *   bóveda no las atiende, en vez de fingir que se aplicaron.
  * @param {(ev:string, info?:object)=>Promise<void>} [o.notify]  aviso a todos los miembros.
  * @param {(op:string, info?:object)=>void} [o.audit]
  * @param {string[]} [o.defaultScope]    lo que recibe un dispositivo emparejado a distancia.
  * @param {number} [o.ttlMs]             vida del cert que se emita.
  */
 export function createAdminDesk ({
-  desk, verify, readActivity = () => [], deviceIdOf,
+  desk, verify, readActivity = () => [], deviceIdOf, vars = null,
   notify = async () => {}, audit = () => {},
   defaultScope = ['vault:sign', 'vault:read', 'vault:store'],
   ttlMs, now = () => Date.now()
@@ -127,6 +146,43 @@ export function createAdminDesk ({
         return { ok: true, result: { ok: true } }
       }
 
+      // VARIABLES DE ENTORNO. El módulo solo enruta y audita: qué valor puede salir y con
+      // qué se cifra lo decide la bóveda (`vars`), que es la que tiene la clave y el disco.
+      if (data.op === 'vars' || data.op === 'var.set') {
+        if (!vars) return { ok: false, error: 'admin: this vault does not serve environment variables' }
+        // Un destino y solo uno: o un scope, o un aparato. Sin esto, mandar los dos dejaría
+        // que quien llama adivine dónde acabó su variable.
+        // Booleanos a propósito: comparar los VALORES («proxy» vs una pubkey) nunca da
+        // igual, así que mandar los dos destinos se colaba por el hueco.
+        const toScope = typeof data.ns === 'string' && !!data.ns
+        const toDevice = typeof data.pub === 'string' && !!data.pub
+        if (data.op === 'vars') {
+          const result = await vars.list({ by })
+          audit('admin.vars', { by })
+          return { ok: true, result }
+        }
+        if (toScope === toDevice) return { ok: false, error: 'admin: var.set needs exactly one target (ns or pub)' }
+        if (typeof data.key !== 'string' || !data.key) return { ok: false, error: 'admin: var.set needs a key' }
+        if (!data.enc || typeof data.enc !== 'object') {
+          // El valor NUNCA viaja en claro: si llega sin sobre, es un error de quien llama,
+          // no algo que se pueda «arreglar» aceptándolo.
+          return { ok: false, error: 'admin: var.set needs the value sealed with the profile content key' }
+        }
+        const result = await vars.set({
+          ns: toScope ? data.ns : null,
+          pub: toDevice ? data.pub : null,
+          key: data.key,
+          enc: data.enc,
+          public: typeof data.public === 'boolean' ? data.public : undefined,
+          by
+        })
+        audit('admin.var.set', { by, ns: toScope ? data.ns : null, device: toDevice ? await deviceIdOf(data.pub).catch(() => null) : null, key: data.key })
+        // Cambiar la configuración de un servicio a distancia no puede ser invisible: es
+        // la contrapartida de delegar (F3 de docs/consola-remota.md).
+        await notify('vars', { by, key: data.key, ns: toScope ? data.ns : null })
+        return { ok: true, result: result || { ok: true } }
+      }
+
       // QUITAR UN DISPOSITIVO se hace por `sub` (su llave): sale del acta Y se le retiran
       // todos los certificados. Las dos cosas o ninguna.
       //

package/src/enroll.js

@@ -104,13 +104,16 @@ export async function deviceIdOf (pub) {
  * @param {(...a:any[])=>void} [opts.log]
  * @param {(c:{deviceId:string, scope:any, label:string})=>void} [opts.onChallenge]  un dispositivo espera aprobación.
  * @param {()=>void} [opts.onPendingChange]
+ * @param {(sub:string)=>void} [opts.onDeviceRemoved]  se quitó un aparato (fuera del acta y sin papeles):
+ *   para que quien guarde algo indexado por esa llave lo suelte. Se avisa desde AQUÍ y no desde
+ *   quien llama porque a `revokeDevice` se entra por dos puertas (el PC y la consola remota).
  * @param {string[]} [opts.defaultScope]
  * @param {number} [opts.defaultTtlMs]
  */
 export function createEnrollDesk ({
   identity, iss, proxy, send, sendByPubkey,
   audit = () => {}, log = () => {},
-  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {},
+  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {}, onDeviceRemoved = () => {},
   defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS,
   // Camino A: lo que ESTA bóveda le manda al aparato para que la meta en su acta. `encPub`
   // es su llave de CIFRADO — sin ella entra mandando pero sin poder leer el contenido.
@@ -461,6 +464,7 @@ export function createEnrollDesk ({
           return done
         })() }
     await emitRevoke(sub, mine[0]?.nonce || null)
+    fire(onDeviceRemoved, sub)
     return res
   }
 

package/src/types.d.ts

@@ -0,0 +1,7 @@
+declare global {
+  interface Element { [key: string]: any; }
+  interface EventTarget { [key: string]: any; }
+  interface HTMLElement { [key: string]: any; }
+  interface Event { [key: string]: any; }
+  interface Window { [key: string]: any; }
+}