@dotrino/vault 0.69.0 → 0.71.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.71.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/passwordLogins.js

@@ -26,8 +26,8 @@
  */
 import { server as opaquePorDefecto, suiteId as suitePorDefecto } from '@dotrino/opaque'
 import { pubkeyId } from '@dotrino/identity/capabilities'
-import { deviceIdOf, scopeToCaps, scopeToCn } from './enroll.js'
-import { SCOPE } from './protocol.js'
+import { DEVICE_CAPS, capScope } from '@dotrino/identity/acta'
+import { deviceIdOf } from './enroll.js'
 import { bytesToB64url, b64urlToBytes } from './b64.js'
 
 /** Un usuario es la parte de antes de la `@` en `nombre@AB12-CD34-EF56`. */
@@ -445,24 +445,35 @@ export function createLoginDesk ({ load, save, now = () => Date.now(), opaque =
  * @param {object} opts
  *   `identity` la identidad que firma (`signDelegation`, `admitMember`)
  *   `logins`   el escritorio de `createLoginDesk`
- *   `scope`    permisos del aparato; por defecto firmar, leer y guardar
- *   `unattended` si además puede trabajar sin que nadie apruebe
+ *   `caps`     los PERMISOS del acta que lleva el aparato, cualquiera de `DEVICE_CAPS`;
+ *              por defecto firmar, leer y guardar
  */
 export async function registerLogin ({
   identity, logins, user, upload, pub, encPub = null, label = '', blob,
-  scope, unattended = false, replace = false
+  caps = ['sign', 'read', 'store'], scope, replace = false
 } = {}) {
   if (replace) {
     await logins.registerFinish({ user, upload, blob, replace: true })
     return { ok: true, user, replaced: true }
   }
-  // PERMISOS, no tipos: los del scope, más `unattended` si quien lo crea lo eligió
-  // (temporary-access.md §3.1). `passwords` no entra todavía — hasta que existan las
-  // contraseñas selladas, este aparato se llevaría TODAS (sealed-passwords.md).
-  const scopes = Array.isArray(scope) && scope.length ? scope : [SCOPE.SIGN, SCOPE.READ, SCOPE.STORE]
-  if (scopes.includes(SCOPE.PASSWORDS)) {
-    throw Object.assign(new Error('a password login cannot take `contrasenas` yet: the sealed passwords come first'), { code: 'passwords-not-yet' })
+  // CUALQUIER PERMISO, y todos por el mismo camino (dueño, 2026-09-21: «al crear debe
+  // poder asignársele cualquier permiso»; regla dura «simplificar los procesos»). Antes
+  // llegaban como scopes del certificado con `unattended` aparte, `passwords` se rechazaba
+  // con `passwords-not-yet` y `passkeys` —que no tiene scope— no se podía asignar.
+  //
+  // `scope` ya no se acepta, y se dice: ignorarlo daría al aparato los permisos por defecto
+  // en vez de los que se eligieron, y nadie lo notaría.
+  if (scope !== undefined) {
+    throw Object.assign(new Error('registerLogin takes `caps` (account record permissions), not `scope`'), { code: 'use-caps' })
   }
+  const pedidos = [...new Set(Array.isArray(caps) ? caps : [])]
+  const raros = pedidos.filter((c) => !DEVICE_CAPS.includes(c))
+  if (!pedidos.length || raros.length) {
+    throw Object.assign(new Error(`not device permissions: ${raros.join(', ') || '(none)'} — expected any of ${DEVICE_CAPS.join(', ')}`), { code: 'bad-caps' })
+  }
+  // El certificado lleva el scope de los permisos que lo tienen; los demás (`unattended`,
+  // `passkeys`) viven solo en el acta, que es quien decide.
+  const scopes = pedidos.map((c) => capScope(c)).filter(Boolean)
   if (typeof identity?.admitMember !== 'function') {
     throw Object.assign(new Error('this vault cannot add devices to the account record: no login was created'), { code: 'admit-unavailable' })
   }
@@ -470,11 +481,9 @@ export async function registerLogin ({
   await logins.registerFinish({ user, upload, pub, encPub, deviceId, label, blob })
   try {
     const { cert } = await identity.signDelegation(pub, scopes, { label: label || `login:${user}` })
-    const cn = scopeToCn(scopes)
-    const caps = [...new Set([...scopeToCaps(scopes), ...(unattended ? ['unattended'] : [])])]
-    await identity.admitMember({ pub, encPub, label: label || `login:${user}`, cn, caps, cert })
+    await identity.admitMember({ pub, encPub, label: label || `login:${user}`, cn: null, caps: pedidos, cert })
     logins.setCert({ user, cert, iss: identity.me?.publickey || null })
-    return { ok: true, user, deviceId, cert, caps }
+    return { ok: true, user, deviceId, cert, caps: pedidos }
   } catch (e) {
     // NADA DE MEDIAS ALTAS: si no entra en el acta, no queda un usuario que pueda entrar a
     // una cuenta que no lo reconoce. Se deshace y se dice.