@dotrino/vault 0.68.0 → 0.70.0

package/bin/dotrino-env.js

@@ -24,8 +24,38 @@ import { loadEnv, serviceDir, serviceRoot, listEnrolled, resolveNs, resolveVault
 // proxy) lo hizo con su propio `enroll-vault.js` en vez de con esta CLI.
 import { parseInvite as sharedParseInvite } from '../src/invite.js'
 import { selfContext, commandLine } from '../src/proc.js'
+import { updateNotice } from '@dotrino/update/notice'
+import { PKG_VERSION as VERSION } from '../src/version.js'
 
 const argv = process.argv.slice(2)
+
+/**
+ * ¿HAY UN dotrino-env MÁS NUEVO? (CONVENCIONES §15)
+ *
+ * La regla que manda en un comando: **avisar no puede hacer lenta la orden**. Por eso la
+ * consulta ARRANCA aquí, antes de hacer nada, y se recoge al terminar: mientras corre lo que
+ * el usuario pidió —un `run` dura lo que dure su programa— la pregunta ya está contestada, y
+ * lo normal es que no cueste ni un milisegundo. Una vez al día; el resto sale de caché.
+ *
+ * Se compara contra `@dotrino/env`, que es lo que la gente instala, con la versión del
+ * código que corre: son la misma por construcción (`packaging/release-env.mjs` las fija
+ * iguales al publicar).
+ *
+ * La línea va por STDERR: `dotrino-env run` le cede stdout a otro programa, y colarle ahí
+ * una cortesía es romperle la tubería a quien lo esté canalizando.
+ */
+const avisoVersion = updateNotice({
+  current: VERSION, source: 'npm', pkg: '@dotrino/env', product: 'dotrino-env'
+}).catch(() => null)
+
+/** Lo dice, si hay algo que decir, con un tope: nunca retiene la salida más de 1,5 s. */
+let avisoDicho = false
+async function decirAvisoVersion () {
+  if (avisoDicho) return
+  avisoDicho = true
+  const linea = await Promise.race([avisoVersion, new Promise((resolve) => setTimeout(() => resolve(null), 1500).unref())])
+  if (linea) process.stderr.write(`\n[dotrino-env] ${linea} · actualiza con: npm i -g @dotrino/env\n`)
+}
 const flag = (name) => { const i = argv.indexOf('--' + name); return i >= 0 ? argv[i + 1] : undefined }
 
 /**
@@ -275,7 +305,8 @@ async function cmdRun () {
   console.error('[dotrino-env] %d valor(es) en el entorno de %s%s', injected.length, cmd[0],
     overridden.length ? ` (pisados: ${overridden.join(', ')})` : '')
   const child = spawn(cmd[0], cmd.slice(1), { stdio: 'inherit', env: process.env })
-  child.on('exit', (code, signal) => process.exit(signal ? 1 : (code ?? 0)))
+  // Al terminar el programa, no antes: mientras corría, la consulta ya se contestó.
+  child.on('exit', async (code, signal) => { await decirAvisoVersion(); process.exit(signal ? 1 : (code ?? 0)) })
 }
 
 /**
@@ -329,4 +360,10 @@ const run = async () => {
   }
 }
 
-run().catch((e) => { console.error('\n[dotrino-env] ' + e.message); process.exit(1) })
+run()
+  // `run` y `ssh-agent` NO avisan aquí, y hay que hacerlo cumplir, no solo decirlo: `cmdRun`
+  // termina en cuanto LANZA el programa, así que este `.then` lo diría mientras el programa
+  // aún corre, mezclado con su salida. `run` avisa cuando su hijo sale; `ssh-agent` no
+  // termina nunca. Aquí llegan las órdenes cortas.
+  .then(() => (['run', 'ssh-agent'].includes(argv[0]) ? null : decirAvisoVersion()))
+  .catch((e) => { console.error('\n[dotrino-env] ' + e.message); process.exit(1) })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.68.0",
+  "version": "0.70.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",
@@ -73,6 +73,7 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@dotrino/opaque": "0.1.0"
+    "@dotrino/opaque": "0.1.0",
+    "@dotrino/update": "0.1.1"
   }
 }

package/src/loginClient.js

@@ -34,7 +34,7 @@
  * Si algo de eso falla, se PARA con un `code` propio. No hay repliegue: entrar «a medias»
  * en una cuenta es peor que no entrar.
  */
-import { client as opaque } from '@dotrino/opaque'
+import { client as opaquePorDefecto } from '@dotrino/opaque'
 import { pubkeyId, verifyDeviceSig, signWithDevice } from '@dotrino/identity/capabilities'
 import { checkVaultReply } from '@dotrino/identity/acta'
 import { MSG } from './protocol.js'
@@ -82,11 +82,16 @@ const parseJson = (s) => { try { return JSON.parse(s) } catch (_) { return null
  * @param {string} opts.password
  * @param {string} [opts.label]    de dónde se entra («el cyber de la esquina»): es lo que
  *   el dueño va a leer en su consola para decidir si cerrarlo.
+ * @param {object} [opts.opaque]   el OPAQUE a usar. Por defecto el de casa, que va en este
+ *   mismo hilo. Se inyecta porque en una EXTENSIÓN el WASM vive en una página sandbox, al
+ *   otro lado de un `postMessage`, y entonces sus métodos devuelven promesas — igual que en
+ *   `createLoginDesk`, y por el mismo motivo. Aquí se espera siempre: esperar a algo que no
+ *   es una promesa no cuesta nada, y dos firmas serían dos clientes.
  * @returns {Promise<{user:string,address:string,code:string,sid:string,cert:object,
  *   iss:string,acta:object,vaultToken:string,publickey:string,encPublickey:(string|null),
  *   keys:{sign:object,enc:(object|null)}}>}
  */
-export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS, opaque = opaquePorDefecto } = {}) {
   if (!transport || typeof transport.on !== 'function' || typeof transport.send !== 'function') {
     throw err('no-transport', 'loginWithPassword: a connected transport is required')
   }
@@ -104,7 +109,7 @@ export async function loginWithPassword ({ transport, address, password, label =
   let ultimo = null
   for (const token of tokens) {
     try {
-      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs })
+      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs, opaque })
     } catch (e) {
       // Se para: son cosas del que entra, y probar con otra bóveda no las arregla.
       if (e?.code === 'login-failed' || e?.code === 'too-many-tries' || e?.code === 'wrong-account' ||
@@ -115,15 +120,15 @@ export async function loginWithPassword ({ transport, address, password, label =
   throw ultimo || err('no-vault', 'none of the vaults on that address could let you in')
 }
 
-async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs }) {
-  const start = opaque.loginStart({ password })
+async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs, opaque }) {
+  const start = await opaque.loginStart({ password })
   transport.send(token, { type: MSG.LOGIN_START, user, request: start.request })
   const r1 = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_RESPONSE || p.type === MSG.ERROR, timeoutMs)
   if (r1.type === MSG.ERROR) throw deVuelta(r1)
 
   let fin
   try {
-    fin = opaque.loginFinish({ state: start.state, response: r1.response, password })
+    fin = await opaque.loginFinish({ state: start.state, response: r1.response, password })
   } catch (_) {
     // OPAQUE comprueba a las dos partes: aquí se sabe que el otro lado NO conoce el
     // registro de este usuario. Contraseña equivocada, usuario que no existe o una bóveda
@@ -198,11 +203,26 @@ function deVuelta (p) {
  * quedarse bloqueado esperándola. La sesión sigue abierta allí hasta que se cierre desde la
  * consola, y eso ya está dicho en el diseño (§3.2).
  */
-export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, sign, timeoutMs = REPLY_TIMEOUT_MS } = {}) {
   if (!transport || typeof transport.send !== 'function') throw err('no-transport', 'closeLogin: transport required')
   if (!token || !user || !sid || !publickey) throw err('bad-input', 'closeLogin: token, user, sid and publickey are required')
   const data = { op: 'login.close', publickey, user, sid, ts: Date.now() }
-  const { signature } = await signWithDevice({ privateJwk, privateKey, publickey, data })
+  // CON LA LLAVE O CON QUIEN LA TIENE. `sign(data)` es lo normal en el ecosistema —el
+  // transporte se identifica con `identity.signData` y no con una llave suelta— y aquí hace
+  // falta de verdad: en una extensión la llave vive en el service worker y quien tiene el
+  // socket es la página, así que o se firma a distancia o la llave privada tendría que
+  // cruzar para nada. Sin ninguna de las dos no se firma, y salir no se puede fingir.
+  //
+  // Se comprueba ANTES de firmar: sin nada con qué hacerlo, WebCrypto revienta con un error
+  // suyo que no dice qué falta («code: 0»), y el de arriba es el que se puede buscar.
+  if (typeof sign !== 'function' && !privateJwk && !privateKey) {
+    throw err('no-signature', 'closeLogin: give it the device key (privateJwk/privateKey) or a sign(data)')
+  }
+  const firmado = typeof sign === 'function'
+    ? await sign(data)
+    : await signWithDevice({ privateJwk, privateKey, publickey, data })
+  const signature = typeof firmado === 'string' ? firmado : firmado?.signature
+  if (typeof signature !== 'string') throw err('no-signature', 'closeLogin: sign(data) returned no signature')
   transport.send(token, { type: MSG.LOGIN_CLOSE, data, signature })
   try {
     const r = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_CLOSED || p.type === MSG.ERROR, timeoutMs)