@dotrino/vault 0.73.0 → 0.75.0

package/bin/dotrino-env.js

@@ -26,6 +26,7 @@ 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'
+import { deviceInfo, formatDeviceInfo, shortId } from '../src/deviceInfo.js'
 
 const argv = process.argv.slice(2)
 
@@ -83,6 +84,9 @@ function help () {
         Antes, en el vault:  dotrino-vault pair --service <ns>
         Si no pasas --code (alias --qr), se pide por consola (también acepta stdin).
 
+  info [--ns <ns>] [--vault <bóveda>] [--json]
+                         qué aparato es cada servicio de esta máquina: su ID (el de
+                         «dotrino-vault members»), su bóveda, sus permisos. Sin red.
   status                 servicios enrolados en esta máquina
   check [--ns <ns>] [--public]
                          pide los secretos al vault y lista sus NOMBRES (nunca los valores)
@@ -227,7 +231,7 @@ async function cmdEnroll () {
   console.log('\nEn tu app:  import \'@dotrino/vault/config\'   (con DOTRINO_NS=%s)', ns)
 }
 
-function cmdStatus () {
+async function cmdStatus () {
   const found = listEnrolled()
   if (!found.length) {
     console.log('Ningún servicio enrolado en %s\n  Enrola uno:  dotrino-env enroll --ns <ns> --code "<invitación>"', serviceRoot())
@@ -251,11 +255,34 @@ function cmdStatus () {
     const papel = typeof c?.seq === 'number'
       ? `acta #${c.seq}`
       : (typeof c?.exp === 'number' ? `modelo viejo · vence ${new Date(c.exp).toISOString().slice(0, 10)}` : '?')
-    console.log('%s/%s\n  dir:   %s\n  vault: %s…\n  scope: %s\n  cert:  %s',
-      e.vault, e.ns, dir, String(id.iss).slice(0, 24), (c?.scope || []).join(', '), papel)
+    const aparato = id?.device?.publickey ? await shortId(id.device.publickey) : '?'
+    const boveda = id?.iss ? await shortId(id.iss) : '?'
+    console.log('%s/%s\n  id:    %s\n  dir:   %s\n  vault: %s\n  scope: %s\n  cert:  %s',
+      e.vault, e.ns, aparato, dir, boveda, (c?.scope || []).join(', '), papel)
   }
 }
 
+/**
+ * `info`: qué aparato es cada servicio de esta máquina, con la pieza común de todos los
+ * comandos (`deviceInfo`). Lo que se viene a mirar es el ID, para buscarlo en el acta.
+ */
+async function cmdInfo () {
+  const onlyNs = flag('ns')
+  const onlyVault = flag('vault')
+  const found = listEnrolled().filter((e) => !e.legacy && (!onlyNs || e.ns === onlyNs) && (!onlyVault || e.vault === onlyVault))
+  if (!found.length) {
+    console.error('Ningún servicio enrolado%s en %s', onlyNs ? ` con --ns ${onlyNs}` : '', serviceRoot())
+    process.exit(1)
+  }
+  const infos = []
+  for (const e of found) {
+    const dir = serviceDir(e.vault, e.ns)
+    infos.push(await deviceInfo(readServiceIdentity(dir), { ns: `${e.vault}/${e.ns}`, version: VERSION, dir }))
+  }
+  if (argv.includes('--json')) { console.log(JSON.stringify(infos.length === 1 ? infos[0] : infos, null, 2)); return }
+  console.log(infos.map(formatDeviceInfo).join('\n\n'))
+}
+
 async function cmdCheck () {
   const ns = resolveNs(flag('ns'))
   // `fetchSecrets` y no `loadEnv`: listar NO debe tener efectos secundarios. Con
@@ -349,6 +376,7 @@ const run = async () => {
   switch (argv[0]) {
     case 'enroll': return cmdEnroll()
     case 'status': return cmdStatus()
+    case 'info': return cmdInfo()
     case 'check': return cmdCheck()
     case 'run': return cmdRun()
     case 'ssh-agent': return cmdSshAgent()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.73.0",
+  "version": "0.75.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",
@@ -39,6 +39,9 @@
     },
     "./admin": {
       "import": "./src/admin.js"
+    },
+    "./device-info": {
+      "import": "./src/deviceInfo.js"
     }
   },
   "files": [

package/src/deviceInfo.js

@@ -0,0 +1,70 @@
+/**
+ * deviceInfo.js — QUÉ APARATO SOY, dicho igual en todos los comandos del ecosistema.
+ *
+ * Regla del dueño (2026-09-29): todo comando que se enrola en una bóveda tiene un `info`
+ * que enseña la información del aparato, **sobre todo su id**. El id (`AB12-CD34`) es lo que
+ * sale en `dotrino-vault members` y lo que pide `dotrino-vault caps <ID>`: sin verlo aquí no
+ * hay forma de saber qué fila del acta es esta máquina. `dotrino-env status` enseñaba la
+ * llave de la bóveda en crudo (`{"key_ops":["verify"],…`) y ningún id.
+ *
+ * Una sola pieza para todos: `dotrino-env`, los agentes de remote-agent (terminal, ia) y lo
+ * que venga. Local y sin red: lee el enlace que ya está en el disco, así que responde con
+ * la bóveda apagada, que es justo cuando más falta hace saber quién eres.
+ *
+ * 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'
+
+/** 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')
+}
+
+/**
+ * La información del aparato a partir de su enlace.
+ * @param {{ device?: { publickey?: string }, cert?: object, iss?: string, proxy?: string }} link
+ * @param {Record<string, any>} [extra]  lo propio de cada comando (nombre, versión, carpeta…).
+ */
+export async function deviceInfo (link, extra = {}) {
+  const pub = link?.device?.publickey
+  if (!pub) throw Object.assign(new Error('this link has no device key: enroll first'), { code: 'not-enrolled' })
+  const cert = link.cert || null
+  return {
+    id: await shortId(pub),
+    vault: link.iss ? await shortId(link.iss) : null,
+    scope: Array.isArray(cert?.scope) ? cert.scope : [],
+    // El papel se describe por el acta a la que se ató; uno del modelo viejo, por su fecha,
+    // porque eso sí importa: es lo único que todavía caduca.
+    record: typeof cert?.seq === 'number' ? cert.seq : null,
+    legacyExpires: typeof cert?.seq !== 'number' && typeof cert?.exp === 'number' ? cert.exp : null,
+    proxy: link.proxy || null,
+    publickey: pub,
+    ...extra
+  }
+}
+
+const LABELS = {
+  id: 'Aparato', vault: 'Bóveda', kind: 'Tipo', name: 'Nombre', ns: 'Cajón', version: 'Versión',
+  scope: 'Permisos', record: 'Papel', dir: 'Enlace', proxy: 'Proxio'
+}
+
+/**
+ * El texto que imprime `info`. El id va primero y con la pista de dónde buscarlo: es lo que
+ * se viene a mirar.
+ * @param {Awaited<ReturnType<typeof deviceInfo>>} info
+ */
+export function formatDeviceInfo (info) {
+  const rows = []
+  const put = (k, v) => { if (v != null && v !== '') rows.push([LABELS[k] || k, v]) }
+  put('id', `${info.id}   (así sale en \`dotrino-vault members\`)`)
+  put('vault', info.vault)
+  put('kind', info.kind); put('name', info.name); put('ns', info.ns); put('version', info.version)
+  put('scope', info.scope?.length ? info.scope.join(', ') : null)
+  put('record', info.record != null
+    ? `acta #${info.record}`
+    : (info.legacyExpires ? `modelo viejo, vence ${new Date(info.legacyExpires).toISOString().slice(0, 10)}` : null))
+  put('dir', info.dir); put('proxy', info.proxy)
+  const w = Math.max(...rows.map(([k]) => k.length))
+  return rows.map(([k, v]) => `${(k + ':').padEnd(w + 2)}${v}`).join('\n')
+}

package/src/enroll.js

@@ -30,7 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
-import { verifyContinuity, canSeal } from '@dotrino/identity/acta'
+import { verifyContinuity, canSeal, DEVICE_CAPS } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -159,8 +159,24 @@ export function createEnrollDesk ({
    *   · `account`       → cómo se llama la cuenta de la bóveda, para nombrarla en el
    *                       aviso. Es ORIENTATIVO (un nombre que puso su dueño); la
    *                       identidad de verdad de la cuenta es `iss`.
+   *   · `caps`          → LOS PERMISOS con los que entra al acta, elegidos por quien
+   *                       empareja (dueño, 2026-09-26: «al emparejar debería escoger los
+   *                       permisos, caso contrario estoy obligado a hacer dos actas»). Sin
+   *                       esto el aparato entraba con lo que da el scope y cualquier otro
+   *                       permiso —`admin`, `approve`…— costaba una segunda acta. Se quedan
+   *                       AQUÍ, en la sesión de la bóveda: NO viajan en el QR, así que la
+   *                       invitación que circula no concede nada; lo concede quien teclea
+   *                       el código, igual que hacía `caps` después.
    */
-  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
+  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '', caps = null } = {}) {
+    if (caps != null) {
+      if (!Array.isArray(caps)) throw Object.assign(new Error('caps must be a list'), { code: 'bad-caps' })
+      const cn = scopeToCn(scope)
+      const bad = caps.filter((c) => !(DEVICE_CAPS.includes(c) || (c === 'secrets' && cn)))
+      if (bad.length) throw Object.assign(new Error('unknown permission(s): ' + bad.join(', ')), { code: 'bad-caps' })
+      if (!caps.length) throw Object.assign(new Error('the pairing grants no permission'), { code: 'empty-scope' })
+      caps = [...new Set(caps)]
+    }
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
     const acct = String(account || '').slice(0, 40)
     // INVITACIÓN CORTA: si sabemos cómo alcanzarnos, el QR lleva solo eso y el
@@ -176,12 +192,12 @@ export function createEnrollDesk ({
     const conn = typeof connToken === 'function' ? await connToken() : connToken
     if (conn) {
       const sn = randToken(8)
-      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, caps, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
       return { token: sn, qr: { v: 2, conn, sn, m: mode, proxy }, expiresInMs: PAIRING_TTL_MS }
     }
     const token = randToken(PAIR_TOKEN_BYTES)
     const sn = randToken(PAIR_TOKEN_BYTES)
-    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, caps, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
     return { token, qr: { v: 2, iss, proxy, token, sn, m: mode, ...(acct ? { acct } : {}) }, expiresInMs: PAIRING_TTL_MS }
   }
 
@@ -364,8 +380,10 @@ export function createEnrollDesk ({
     // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
     // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
     // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
+    // Si quien emparejó ELIGIÓ los permisos (`startPairing({ caps })`), entran esos y en
+    // esta misma acta; si no, los que da el scope.
     const cn = scopeToCn(pend.scope)
-    const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
+    const caps = [...new Set([...(pend.caps || scopeToCaps(pend.scope)), ...(cn ? ['secrets'] : [])])]
     if (!caps.length) {
       throw Object.assign(new Error('the pairing scope grants no permission: no certificate was issued'), { code: 'empty-scope' })
     }