@dotrino/vault 0.69.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.69.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"
   }
 }