@dotrino/vaultd 0.162.3 → 0.163.1

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.3'
+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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.162.3",
+  "version": "0.163.1",
   "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": {
@@ -25,7 +25,7 @@
     "@dotrino/identity": "0.120.0",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.18.4",
-    "@dotrino/proxy-client": "0.36.2",
+    "@dotrino/proxy-client": "0.38.0",
     "@dotrino/roadmap": "0.4.30",
     "@dotrino/store": "0.12.3",
     "@dotrino/update": "0.9.0",

package/src/ctl.js

@@ -1706,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/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 }