@dotrino/vaultd 0.162.2 → 0.163.0

package/lib/src/core/libVersion.js

@@ -5,4 +5,4 @@
  * si no coincide con la del paquete: una versión anunciada que no es la que corre es peor
  * que no anunciar ninguna.
  */
-export const LIB_VERSION = '0.90.2'
+export const LIB_VERSION = '0.91.0'

package/lib/src/core/transport.js

@@ -36,7 +36,7 @@ export async function masterPubkeyOf (identity) {
  * @param {string} [opts.url] URL del proxy (default wss://proxy.dotrino.com).
  * @returns {Promise<{ client, token:string, identify():Promise<void> }>}
  */
-export async function createTransport ({ identity, url = DEFAULT_PROXY, commKey = null, log = () => {}, makeClient = null, announce = null, recheckMs = 60_000, patienceMs = 5 * 60_000, reannounceMs = 10 * 60_000 }) {
+export async function createTransport ({ identity, url = DEFAULT_PROXY, commKey = null, log = () => {}, makeClient = null, announce = null, wakeUrl = null, recheckMs = 60_000, patienceMs = 5 * 60_000, reannounceMs = 10 * 60_000 }) {
   // Import dinámico DESPUÉS de instalar los globals que el paquete usa.
   // `WebSocketProxyClient` (la clase) y NO el helper `getWebSocketProxyClient`:
   // ese es un SINGLETON de proceso, y con multi-perfil el vault necesita una
@@ -182,6 +182,25 @@ export async function createTransport ({ identity, url = DEFAULT_PROXY, commKey
     }
   }
 
+  /**
+   * DESPIÉRTAME AQUÍ (una bóveda que no vive conectada, `lambda/`). Si la plataforma da una
+   * URL, se registra en el proxio con la llave de comunicación y el acta, para que llame a esa
+   * URL cuando llegue algo para la cuenta y no haya nadie suyo conectado. Va pegado a
+   * `identify` por lo mismo que el anuncio: el acta puede haber cambiado. Si falla, se dice:
+   * lo que se pierde es que la despierten, y eso no se puede callar.
+   */
+  const registerWake = async () => {
+    if (!wakeUrl || !identificado) return
+    const comm = commKey?.pub?.() || null
+    if (!comm || !actaVista) { log('[vault] cannot register the wake URL: no communication key in the record yet'); return }
+    try {
+      await client.registerWake({ publicKey: comm, sign: (d) => commKey.sign(d), url: wakeUrl, acta: actaVista, channel: announce || undefined })
+      log('[vault] wake URL registered on the proxy')
+    } catch (e) {
+      log(`[vault] could not register the wake URL (${e.code || ''} ${e.message}) — the proxy will not wake this vault`)
+    }
+  }
+
   let reintento = null
   let fallos = 0
   const identifyWithRetry = async () => {
@@ -189,6 +208,7 @@ export async function createTransport ({ identity, url = DEFAULT_PROXY, commKey
     try {
       await identify()
       await announceAccount()
+      await registerWake()
       if (fallos) log(`[vault] identified on the proxy after ${fallos + 1} attempt(s)`)
       fallos = 0
     } catch (e) {

package/lib/src/core/vault.js

@@ -80,6 +80,8 @@ const MAX_REPLY_BYTES = 768 * 1024
  *   readProcContext(pid)  lo que el sistema dice de un proceso; `null` si no se puede mirar
  *   openLocalDesk({ name, onMessage, channels, maxBytes, log })  el atajo en la misma máquina
  *   makeClient        quién crea el cliente del proxio (opcional)
+ *   wakeUrl           la URL que despierta a esta bóveda si no vive conectada (opcional, `lambda/`)
+ *   onActivity()      llega un mensaje del proxio (opcional; la Lambda mide con esto su inactividad)
  *   noticeGroupMs     cuánto se agrupan los avisos de cambio
  *   opaque            el servidor de OPAQUE, si no vale el del paquete (opcional)
  *   servePasswords    `false`: el almacén de contraseñas lo atiende quien monta la bóveda,
@@ -492,7 +494,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
   // ninguna llave y solo sabe la dirección `nombre@AB12-CD34-EF56`— pueda encontrar a quien
   // la atiende. Lo construye la pieza compartida, porque quien lo busca es la extensión.
   const { client, identify: reidentificar, isIdentified } = await createTransport({
-    identity, url: proxyUrl, commKey, log, announce: vaultChannel(fp), makeClient: platform.makeClient || null
+    identity, url: proxyUrl, commKey, log, announce: vaultChannel(fp), makeClient: platform.makeClient || null, wakeUrl: platform.wakeUrl || null
   })
 
   // El registro público de cadenas de selladores: deposita, si hay a dónde, los eslabones
@@ -2189,7 +2191,12 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     reply(from, { type: MSG.INCIDENT_RESULT, id: pend.id, approvers, blocked: false })
   }
 
-  client.on('message', (from, payload) => onMessage(from, payload))
+  client.on('message', (from, payload) => {
+    // Quien monta la bóveda puede querer saber que hay trabajo (la Lambda se apaga cuando
+    // deja de haberlo). Es un aviso, no decide nada.
+    try { platform.onActivity?.() } catch (_) {}
+    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

package/lib/src/deviceInfo.js

@@ -14,12 +14,10 @@
  * Sirve cualquier enlace con la forma común `{ device: { publickey }, cert, iss, proxy }`
  * (el de remote-agent y el de un servicio de dotrino-env).
  */
-import { pubkeyId } from '@dotrino/identity/capabilities'
+import { keyLabel } from '@dotrino/identity/capabilities'
 
 /** El id corto de una llave, como lo enseña la bóveda: `AB12-CD34`. */
-export async function shortId (publickey) {
-  return (await pubkeyId(publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
-}
+export const shortId = keyLabel
 
 /**
  * La información del aparato a partir de su enlace.

package/lib/src/kek.js

@@ -85,7 +85,7 @@ export function writeConfig (dir, cfg) {
  * es a propósito el más tonto posible — cada CLI de KMS tiene sus manías con los binarios
  * y sus flags, y se resuelven en un envoltorio de tres líneas en vez de aquí dentro.
  */
-function runStep (step, input, what) {
+export function runStep (step, input, what) {
   if (!step || typeof step.cmd !== 'string' || !step.cmd) {
     throw new KekError('kek-config', `kek provider "command": missing ${what}.cmd`)
   }

package/lib/src/loginClient.js

@@ -44,6 +44,8 @@ const err = (code, message, extra = {}) => Object.assign(new Error(message), { c
 
 /** Cuánto se espera a que una bóveda conteste antes de probar con la siguiente. */
 export const REPLY_TIMEOUT_MS = 15_000
+/** Lo que se espera a una bóveda que se está despertando: arrancar en frío y conectarse. */
+export const WAKE_WAIT_MS = 30_000
 
 /**
  * Escucha UNA respuesta de un token concreto. El `off` se suelta siempre —también al
@@ -98,7 +100,14 @@ export async function loginWithPassword ({ transport, address, password, label =
   if (typeof password !== 'string' || !password) throw err('no-password', 'loginWithPassword: password required')
   const { user, code, address: dir } = parseLoginAddress(address)
 
-  const tokens = await transport.list(vaultChannel(code))
+  let tokens = await transport.list(vaultChannel(code))
+  // UNA BÓVEDA QUE DUERME (la de una Lambda): el proxio la está despertando y lo dice. Se
+  // espera a que se anuncie en vez de contestar que esa cuenta no existe.
+  const hasta = Date.now() + WAKE_WAIT_MS
+  while (!tokens.length && tokens.waking && Date.now() < hasta) {
+    await new Promise((resolve) => setTimeout(resolve, 2000))
+    tokens = await transport.list(vaultChannel(code))
+  }
   if (!tokens.length) {
     throw err('no-vault', 'no vault is answering for that address right now: turn yours on, or check the address')
   }

package/lib/src/passwordLogins.js

@@ -24,8 +24,8 @@
  * binario, `lib/src/index.js` en la pestaña—. Lo único que no es puro es `registerLogin`, al
  * final, porque hace falta la identidad que firma.
  */
-import { server as opaquePorDefecto, suiteId as suitePorDefecto } from '@dotrino/opaque'
-import { pubkeyId } from '@dotrino/identity/capabilities'
+import { server as opaquePorDefecto, client as opaqueClientePorDefecto, suiteId as suitePorDefecto } from '@dotrino/opaque'
+import { pubkeyId, makeDeviceKey, makeDeviceEncKey } from '@dotrino/identity/capabilities'
 import { DEVICE_CAPS, capScope } from '@dotrino/identity/acta'
 import { deviceIdOf } from './enroll.js'
 import { bytesToB64url, b64urlToBytes } from './b64.js'
@@ -448,6 +448,29 @@ export function createLoginDesk ({ load, save, now = () => Date.now(), opaque =
  *   `caps`     los PERMISOS del acta que lleva el aparato, cualquiera de `DEVICE_CAPS`;
  *              por defecto firmar, leer y guardar
  */
+/**
+ * DAR DE ALTA UN USUARIO, DEL LADO DE QUIEN TIENE LA CONTRASEÑA: el registro OPAQUE se
+ * termina aquí y las llaves del aparato nacen aquí y salen ya cerradas. La bóveda solo ve
+ * `begin`/`finish`, que es su mitad; quien llama decide por dónde llegan (el canal local de
+ * la CLI, o la propia bóveda en el arranque de una Lambda).
+ *
+ * @param {object} opts
+ *   `begin(req)`  → `{ response }`   (`register-begin` de la bóveda)
+ *   `finish(req)` → lo que devuelva  (`register-finish` de la bóveda)
+ */
+export async function createPasswordLogin ({ user, password, label, caps, begin, finish, opaque = opaqueClientePorDefecto } = {}) {
+  if (!isValidUser(user)) throw Object.assign(new Error('invalid user name'), { code: 'bad-user' })
+  if (typeof password !== 'string' || !password) throw Object.assign(new Error('a password is required'), { code: 'no-password' })
+  const start = opaque.registrationStart({ password })
+  const begun = await begin({ user, request: start.request })
+  // La bóveda contesta con su mitad; el registro se termina AQUÍ, con la contraseña.
+  const fin = opaque.registrationFinish({ state: start.state, response: begun.response, password })
+  const device = await makeDeviceKey({ label })
+  const enc = await makeDeviceEncKey()
+  const blob = await sealDeviceKeys(fin.exportKey, { sign: device.privateJwk, enc: enc.privateJwk })
+  return finish({ user, upload: fin.upload, pub: device.publickey, encPub: enc.publickey, label, blob, caps })
+}
+
 export async function registerLogin ({
   identity, logins, user, upload, pub, encPub = null, label = '', blob,
   caps = ['sign', 'read', 'store'], scope, replace = false

package/lib/src/service.js

@@ -23,7 +23,7 @@ import path from 'node:path'
 import { createHash } from 'node:crypto'
 import {
   makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice,
-  verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
+  verifyDeviceSig, makePairingCode, commitCode, pubkeyId, keyLabel } from '@dotrino/identity/capabilities'
 import { openWrap, wrapForMember, decryptWithCek } from '@dotrino/identity/content'
 import { verifyActa, sealKeyAt, memberCan, checkVaultReply } from '@dotrino/identity/acta'
 import { MSG, secretsScope, isValidSecretsNs, VAULT_PROTOCOL, VAULT_SPEAKS } from './protocol.js'
@@ -373,7 +373,7 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
     // aparato entra al acta pero no le llega ningún secreto, y no da error. Un replicador
     // entra así A PROPÓSITO (ver `withEncKey`): reparte sobres cerrados y no abre ninguno.
     const enc = withEncKey ? await makeDeviceEncKey() : null
-    const deviceId = (await pubkeyId(device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+    const deviceId = await keyLabel(device.publickey)
     // Código de emparejamiento ALEATORIO: se muestra y NO se envía. La bóveda lo
     // aprende solo cuando un humano lo tipea → aprobar exige TENER esta máquina.
     const code = makePairingCode()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.162.2",
+  "version": "0.163.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": {
@@ -22,10 +22,10 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "0.119.0",
+    "@dotrino/identity": "0.120.0",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.18.4",
-    "@dotrino/proxy-client": "0.36.1",
+    "@dotrino/proxy-client": "0.38.0",
     "@dotrino/roadmap": "0.4.30",
     "@dotrino/store": "0.12.3",
     "@dotrino/update": "0.9.0",
@@ -51,7 +51,7 @@
     "!lib/src/types.d.ts"
   ],
   "devDependencies": {
-    "@dotrino/remote-agent": "0.20.1",
+    "@dotrino/remote-agent": "0.21.0",
     "@types/node": "^22.0.0",
     "typescript": "5.9.3"
   },

package/src/client.js

@@ -11,7 +11,7 @@
  * estrictamente (firmado por la maestra que vio en el QR, y para SU clave) antes de
  * guardarlo. La maestra nunca sale del vault.
  */
-import { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
+import { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, keyLabel } from '@dotrino/identity/capabilities'
 import { myContentKey, encryptWithCek, decryptWithKeyring } from '@dotrino/identity/content'
 // Con qué se juzga lo que devuelve la bóveda (papel + acta): la regla del pilar, una sola.
 import { checkVaultReply } from '@dotrino/identity/acta'
@@ -65,7 +65,7 @@ export async function enroll ({ qr, label = '', dir, onChallenge, approveTimeout
     // La llave de CIFRADO del aparato: con su pública en el acta, la bóveda le envuelve la
     // clave de contenido al admitirlo. Sin ella no podría usar el almacén, que solo entra cifrado.
     const enc = await makeDeviceEncKey()
-    const myDeviceId = (await pubkeyId(device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+    const myDeviceId = await keyLabel(device.publickey)
     // ESTE dispositivo genera el código y lo MUESTRA; solo viaja su COMPROMISO. El vault
     // lo aprende cuando un humano lo tipea, y solo firma el cert si el compromiso coincide.
     const code = makePairingCode()

package/src/ctl.js

@@ -26,7 +26,7 @@ import path from 'node:path'
 import { execFileSync } from 'node:child_process'
 import tty from 'node:tty'
 import crypto from 'node:crypto'
-import { pubkeyId } from '@dotrino/identity/capabilities'
+import { pubkeyId, keyLabel } from '@dotrino/identity/capabilities'
 import { dataDir } from './paths.js'
 // EL CANAL LOCAL VA CIFRADO (ver `ipc.js`): por aquí salen la contraseña y los valores.
 import { ipcRead, ipcWrite } from './ipc.js'
@@ -133,10 +133,8 @@ function requireDaemon () {
   if (!alive(s.pid)) { console.error('El daemon no está corriendo. Arráncalo: %s', START_HINT); process.exit(1) }
   return s
 }
-function deviceIdOf (sub) {
-  // mismo formato que el daemon: 8 hex agrupados AB12-CD34
-  return pubkeyId(sub).then((id) => id.slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'))
-}
+// mismo formato que el daemon: AB12-CD34
+const deviceIdOf = keyLabel
 
 /** Lo que dijo un aprobador sobre sus avisos, para enseñarlo. No decide nada. */
 function avisosTxt (notifiedAt) {
@@ -1708,21 +1706,12 @@ async function cmdLogins (rest) {
         if (a[0] === '+') caps.add(cap); else caps.delete(cap)
       }
       const label = nombre.join(' ').trim() || 'equipo prestado'
-      const { client: opaqueClient } = await import('@dotrino/opaque')
-      const { makeDeviceKey, makeDeviceEncKey } = await import('@dotrino/identity/capabilities')
-      const { sealDeviceKeys } = await import('../lib/src/passwordLogins.js')
+      const { createPasswordLogin } = await import('../lib/src/passwordLogins.js')
       const password = await askNewPassword(user)
-
-      const start = opaqueClient.registrationStart({ password })
-      const begun = await loginsRequest('register-begin', { user, request: start.request })
-      // La bóveda contesta con su mitad; el registro se termina AQUÍ, con la contraseña.
-      const fin = opaqueClient.registrationFinish({ state: start.state, response: begun.response, password })
-      // Las llaves del aparato NACEN en esta terminal y salen de aquí ya cerradas.
-      const device = await makeDeviceKey({ label })
-      const enc = await makeDeviceEncKey()
-      const blob = await sealDeviceKeys(fin.exportKey, { sign: device.privateJwk, enc: enc.privateJwk })
-      const r = await loginsRequest('register-finish', {
-        user, upload: fin.upload, pub: device.publickey, encPub: enc.publickey, label, blob, caps: [...caps]
+      const r = await createPasswordLogin({
+        user, password, label, caps: [...caps],
+        begin: (req) => loginsRequest('register-begin', req),
+        finish: (req) => loginsRequest('register-finish', req)
       })
       const { loginAddress } = await import('../lib/src/passwordLogins.js')
       console.log('\nListo. Se entra con esta dirección y esa contraseña:')

package/src/replica.js

@@ -24,7 +24,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
 import { WebSocketProxyClient } from '@dotrino/proxy-client'
-import { signWithDevice, verifyDeviceSig, verifyChain, pubkeyId } from '@dotrino/identity/capabilities'
+import { signWithDevice, verifyDeviceSig, verifyChain, pubkeyId, keyLabel } from '@dotrino/identity/capabilities'
 import { verifyActa, memberCan, memberCanReadSecrets, sealKeyAt, sealersOf } from '@dotrino/identity/acta'
 import { MSG, secretsScope, isValidSecretsNs } from '../lib/src/protocol.js'
 import { FRESH_WINDOW_MS } from '../lib/src/enroll.js'
@@ -156,7 +156,7 @@ export async function runReplica ({ dir = replicaDir(), proxyUrl, log = console.
       { code: 'replica-not-enrolled' })
   }
   const url = proxyUrl || link.proxy || process.env.PROXY_URL || 'wss://proxy.dotrino.com'
-  const id = (await pubkeyId(link.device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+  const id = await keyLabel(link.device.publickey)
 
   const firmar = (data) => signWithDevice({ privateJwk: link.device.privateJwk, data })
   // CONTESTAR es por la CONEXIÓN (`send`) y no por la llave (`sendByPubkey`): `from` es el

package/src/vault.js

@@ -7,8 +7,12 @@ import { startVault as startVaultCore } from '../lib/src/core/vault.js'
 import { nodePlatform } from './platform.js'
 import { dataDir } from './paths.js'
 
-export async function startVault ({ dir = dataDir(), ...opts } = {}) {
-  return startVaultCore({ ...opts, platform: nodePlatform(dir) })
+/**
+ * `platform` suma o cambia piezas de la del binario: la Lambda (`lambda/session.mjs`) pone
+ * la URL que la despierta y un cliente del proxio que le dice cuándo hay trabajo.
+ */
+export async function startVault ({ dir = dataDir(), platform = null, ...opts } = {}) {
+  return startVaultCore({ ...opts, platform: { ...nodePlatform(dir), ...(platform || {}) } })
 }
 
 export default { startVault }