@dotrino/vaultd 0.7.4 → 0.7.6

package/README.md

@@ -100,8 +100,10 @@ raw mode).
 los dispositivos/variables que estás viendo:
 
 1. **Bóvedas** es la pantalla de entrada: lista tus perfiles (`↑↓` mover, `Enter`
-   **entrar** a uno — lo activa si no lo estaba). Ahí también creas una bóveda
-   nueva, renombras, borras y pones/quitas/usas la contraseña (candado).
+   **entrar** a uno — lo activa si no lo estaba). Ahí también **conectas un
+   dispositivo** con `p` (sin entrar: activa la bóveda elegida y abre la pregunta
+   de a qué cuenta entra), creas una bóveda nueva, renombras, borras y
+   pones/quitas/usas la contraseña (candado).
 2. Al entrar caes en sus **pestañas horizontales**, que cambias con `←→`:
    - **Dispositivos (pares):** verlos, **emparejar** uno nuevo, **aprobar** con el
      código que muestra el dispositivo, **rechazar** y **revocar**. Al emparejar, la
@@ -132,7 +134,8 @@ en español (solo se traduce la palabra que las explica en la barra de ayuda).
 | `n` | new — bóveda nueva / variable nueva | Bóvedas · Scopes |
 | `r` | rename (Bóvedas) · refresh (Dispositivos/Scopes) · restart (Emparejar) | — |
 | `d` | delete — borrar la bóveda | Bóvedas |
-| `p` | password (Bóvedas) · pair — emparejar (Dispositivos) | — |
+| `p` | **pair — conectar un dispositivo** (desde Bóvedas entra directo, sin `Enter`) | Bóvedas · Dispositivos |
+| `c` | change password — poner/cambiar la contraseña | Bóvedas |
 | `x` | quitar: contraseña · dispositivo pendiente · variable/scope | todas |
 | `u` / `k` | unlock / locK — candado de la bóveda | Bóvedas |
 | `a` | approve — aprobar el dispositivo | Dispositivos · Emparejar |

package/lib/src/enroll.js

@@ -108,13 +108,29 @@ export function createEnrollDesk ({
   const reply = (to, obj) => { try { send(to, obj) } catch (e) { log('[vault] no se pudo responder:', e.message) } }
   const isFresh = (d) => typeof d?.ts === 'number' && Math.abs(Date.now() - d.ts) <= FRESH_WINDOW_MS
 
-  /** Inicia un emparejamiento: token + nonce de sesión. NO firma nada todavía. */
-  function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '' } = {}) {
+  /**
+   * Inicia un emparejamiento: token + nonce de sesión. NO firma nada todavía.
+   *
+   * `mode` y `account` son LO QUE LA BÓVEDA DECLARA que va a pasar, y viajan en el QR
+   * para que el aparato pueda **decirlo antes de hacerlo** en vez de emparejar a
+   * ciegas (decisión V9 de `docs/vinculacion-de-cuentas.md`: pregunta el vault, el
+   * dispositivo muestra el proceso y sus consecuencias):
+   *
+   *   · `mode: 'join'`  → el dispositivo estrena una cuenta suya y entra a la de la
+   *                       bóveda. Es lo único que existe hoy.
+   *   · `mode: 'adopt'` → la bóveda se quedaría con la cuenta que trae el aparato
+   *                       (camino A). Reservado: todavía no hay protocolo.
+   *   · `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`.
+   */
+  function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
     const token = randToken()
     const sn = randToken()
-    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, state: 'AWAITING_ENROLL' })
-    return { token, qr: { v: 2, iss, proxy, token, sn }, expiresInMs: PAIRING_TTL_MS }
+    const acct = String(account || '').slice(0, 40)
+    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, 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 }
   }
 
   function stopPairing (token) { pending.delete(token) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "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": {

package/src/daemon.js

@@ -117,11 +117,13 @@ export async function runDaemon () {
       const isService = typeof pairReq?.service === 'string' && pairReq.service
       const scope = isService ? ['vault:secrets:' + pairReq.service] : ['vault:sign', 'vault:read', 'vault:store']
       const label = pairReq?.label || (isService ? 'servicio:' + pairReq.service : 'cli')
-      const { qr, expiresInMs } = vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS })
       // `profile`/`profileName`: la CUENTA del vault a la que entra el dispositivo.
       // Con varias bóvedas en el mismo daemon, el QR sale de UNA y quien empareja
-      // tiene que verlo (lo muestran la TUI y `dotrino-vault pair`).
+      // tiene que verlo (lo muestran la TUI y `dotrino-vault pair`). El nombre viaja
+      // TAMBIÉN dentro del QR (`acct`) para que el dispositivo pueda anunciar qué va
+      // a pasar antes de hacerlo (V9 de docs/vinculacion-de-cuentas.md).
       const profileName = mgr.profiles.get(profileId)?.name || ''
+      const { qr, expiresInMs } = vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode: 'join', account: profileName })
       writeJson(pairFile, { v: 2, qr, expiresAt: Date.now() + expiresInMs, profile: profileId, profileName })
       // El token es un secreto efímero: no debe quedar en disco más allá de su
       // vida. Se borra al VENCER (aquí) y al APROBARSE (abajo, consumido).
@@ -217,7 +219,9 @@ export async function runDaemon () {
         rm(profileReqFile) // lleva la contraseña: fuera del disco cuanto antes
         let extra = {}
         try { extra = await handleProfileRequest(preq) }
-        catch (e) { extra = { error: e.message }; console.error('[vault] perfil: %s', e.message) }
+        // `code`: la TUI es bilingüe y traduce por código (un freno como el D12 tiene
+        // que leerse en el idioma de quien lo lee, no en el del daemon).
+        catch (e) { extra = { error: e.message, ...(e.code ? { code: e.code } : {}) }; console.error('[vault] perfil: %s', e.message) }
         dumpProfiles(extra)
       } else {
         dumpProfiles()

package/src/manager.js

@@ -13,6 +13,28 @@ import { openProfiles } from './profiles.js'
 import { installNodeGlobals } from './node-globals.js'
 import { dataDir, ensureDir } from './paths.js'
 
+/**
+ * D12 (`docs/acta-de-perfil.md`): la bóveda **no** borra una cuenta que ella manda si
+ * quedan otros miembros — antes tiene que pasarle el acta a un dispositivo conectado.
+ * Es D6 ("perder el master es perder la cuenta") leído al derecho: con más miembros,
+ * el que borra no la pierde solo para él.
+ *
+ * Pura a propósito (recibe el veredicto ya calculado) para poder probar la regla sin
+ * levantar un vault entero.
+ */
+export function assertCanRemove ({ isMaster, memberCount, name = '' }) {
+  if (!isMaster || memberCount <= 1) return true
+  const otros = memberCount - 1
+  const e = new Error(
+    `la cuenta "${name}" la manda esta bóveda y tiene ${otros} dispositivo(s) más: ` +
+    'pásale primero el mando a uno que esté conectado. Si la borras así, se quedan ' +
+    'con su llave y sin nadie que pueda volver a firmar el acta.'
+  )
+  e.code = 'MASTER_WITH_MEMBERS'
+  e.members = memberCount
+  throw e
+}
+
 export async function startVaultManager ({ root = dataDir(), proxyUrl, log = console.log, onEnrollChallenge } = {}) {
   ensureDir(root)
   // El keypair de transporte del proxy-client es del PROCESO, no de la identidad:
@@ -76,6 +98,21 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
     /** Borra el perfil: cierra su conexión y elimina su maestra y sus datos. */
     async remove (ref) {
       const id = profiles.resolve(ref)
+      // FRENO D12 (acta-de-perfil.md): si esta bóveda MANDA la cuenta y quedan otros
+      // miembros, borrarla los deja con su llave y sin nadie que pueda volver a sellar
+      // el acta: la cuenta muere para todos, en silencio. Primero se le pasa el mando
+      // a un dispositivo conectado. (En el dispositivo no hay tal freno: allí borrar
+      // se lleva su llave y su copia, y la cuenta sigue viva donde vive el master.)
+      const v = running.get(id)
+      if (v) {
+        const [soyMaster, acta] = await Promise.all([
+          v.isMaster().catch(() => false),
+          v.profileMembers().catch(() => ({ members: [] }))
+        ])
+        assertCanRemove({ isMaster: soyMaster, memberCount: (acta?.members || []).length, name: profiles.get(id)?.name || id })
+      } else {
+        log('[vault] perfil %s no está abierto: se borra sin poder comprobar su acta', id)
+      }
       const res = profiles.remove(id) // valida: no es el único, no está bloqueado
       try { running.get(id)?.close() } catch (_) {}
       running.delete(id)

package/src/tui/app.js

@@ -18,8 +18,9 @@
  * LAS TECLAS NO CAMBIAN CON EL IDIOMA: son mnemónicos en INGLÉS y son las mismas
  * en español (lo que se traduce es la palabra que las explica en la barra de
  * ayuda). new · rename · delete · password · unlock · locK · pair · approve ·
- * reject · reVoke · refresh · back · language · quit. Por eso el candado dejó de
- * ser `l` (hoy idioma) y es `k`, la contraseña es `p` y emparejar es `p`.
+ * reject · reVoke · refresh · back · language · quit. Una tecla significa LO MISMO
+ * en todas las pantallas: `p` es SIEMPRE emparejar (también en Bóvedas, sin tener
+ * que entrar antes), el candado es `k` (la `l` es el idioma) y la contraseña `c`.
  */
 import { execFile } from 'node:child_process'
 import { createTerm, widthOf } from './term.js'
@@ -50,7 +51,8 @@ function humanErr (e, st) {
     NO_REPLY: t.errNoReply,
     NOT_APPLIED: t.errNotApplied,
     NOT_DELETED: t.errNotDeleted,
-    PAIR_FAILED: t.errPairFailed
+    PAIR_FAILED: t.errPairFailed,
+    MASTER_WITH_MEMBERS: t.errMasterWithMembers
   }
   return byCode[e?.code] || e?.message || String(e)
 }
@@ -317,6 +319,19 @@ async function onKeyProfiles (term, st, key) {
     }
     st.screen = 'devices'
     await refreshDevices(term, st)
+  } else if (ch === 'p' && cur) {
+    // Emparejar SIN tener que entrar antes: `p` significa lo mismo aquí que en la
+    // pestaña Dispositivos. Se activa la bóveda elegida (el QR sale de UNA, y las
+    // acciones siguientes —aprobar, revocar— miran a la activa) y se abre la
+    // pregunta de a qué cuenta entra el dispositivo.
+    if (!cur.current) {
+      const r = await guard(term, st, i.switchingVault, () => vc.useProfile(cur.id))
+      if (!r.ok) return true
+      await refreshAll(term, st)
+    }
+    st.sel.pairmode = 0
+    st.scroll.pairmode = { value: 0 }
+    st.screen = 'pairmode'
   } else if (ch === 'n') {
     setInput(st, {
       label: i.newVaultLabel,
@@ -354,7 +369,7 @@ async function onKeyProfiles (term, st, key) {
       },
       onCancel: () => { st.input = null }
     }))
-  } else if (ch === 'p' && cur) { // password
+  } else if (ch === 'c' && cur) { // change password (la `p` es emparejar, igual que en Dispositivos)
     await ensureUnlocked(term, st, cur, (p = cur) => setInput(st, {
       label: i.newPasswordLabel(p.name || p.id),
       mask: true,

package/src/tui/i18n.js

@@ -151,7 +151,7 @@ const es = {
   // INGLÉS: new/rename/delete/password/unlock/locK/pair/approve/revoke/refresh/
   // language/quit); lo único que se traduce es la palabra que las explica.
   // Segmentos, no una línea: el render recorta del medio si no caben.
-  helpProfiles: ['↑↓', 'Enter entrar', 'n nueva', 'r renombrar', 'd borrar', 'p clave', 'x quitar-clave', 'u desbloq', 'k bloquear', 'l English', 'q salir'],
+  helpProfiles: ['↑↓', 'Enter entrar', 'p emparejar', 'n nueva', 'r renombrar', 'd borrar', 'c clave', 'x quitar-clave', 'u desbloq', 'k bloquear', 'l English', 'q salir'],
   helpDevices: ['←→ pestaña', '↑↓', 'p emparejar', 'a aprobar', 'x rechazar', 'v revocar', 'r refrescar', 'Esc bóvedas', 'l English', 'q salir'],
   helpSecrets: ['←→ pestaña', '↑↓', 'n nueva variable', 'x quitar (variable/scope)', 'r refrescar', 'Esc bóvedas', 'l English', 'q salir'],
   helpPairing: ['a aprobar', 'x rechazar', 'r reiniciar', 'Esc atrás', 'l English'],
@@ -179,7 +179,8 @@ const es = {
   errNoReply: 'El daemon no respondió.',
   errNotApplied: 'El daemon no aplicó el cambio (revisa los logs del servicio).',
   errNotDeleted: 'El daemon no borró la variable (revisa los logs del servicio).',
-  errPairFailed: 'El daemon no inició el emparejamiento.'
+  errPairFailed: 'El daemon no inició el emparejamiento.',
+  errMasterWithMembers: 'Esta cuenta la manda esta bóveda y tiene otros dispositivos: pásale primero el mando a uno que esté conectado. Si la borras así, se quedan con su llave y sin nadie que pueda volver a firmar el acta.'
 }
 
 // ---------------------------------- inglés ----------------------------------
@@ -307,7 +308,7 @@ const en = {
   helpInput: 'Enter confirm · Esc cancel · Ctrl-U clear',
   helpConfirm: 'y confirm · n/Esc cancel',
 
-  helpProfiles: ['↑↓', 'Enter open', 'n new', 'r rename', 'd delete', 'p password', 'x drop-password', 'u unlock', 'k lock', 'l Español', 'q quit'],
+  helpProfiles: ['↑↓', 'Enter open', 'p pair', 'n new', 'r rename', 'd delete', 'c password', 'x drop-password', 'u unlock', 'k lock', 'l Español', 'q quit'],
   helpDevices: ['←→ tab', '↑↓', 'p pair', 'a approve', 'x reject', 'v revoke', 'r refresh', 'Esc vaults', 'l Español', 'q quit'],
   helpSecrets: ['←→ tab', '↑↓', 'n new variable', 'x remove (variable/scope)', 'r refresh', 'Esc vaults', 'l Español', 'q quit'],
   helpPairing: ['a approve', 'x reject', 'r restart', 'Esc back', 'l Español'],
@@ -333,7 +334,8 @@ const en = {
   errNoReply: 'The daemon did not answer.',
   errNotApplied: 'The daemon did not apply the change (check the service logs).',
   errNotDeleted: 'The daemon did not delete the variable (check the service logs).',
-  errPairFailed: 'The daemon did not start the pairing.'
+  errPairFailed: 'The daemon did not start the pairing.',
+  errMasterWithMembers: 'This vault is in charge of this account and it has other devices: hand the lead over to one that is online first. If you delete it like this, they keep their key with nobody able to sign the record again.'
 }
 
 // --------------------------- selección y persistencia -----------------------

package/src/vault.js

@@ -296,6 +296,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // Acta del perfil (quién es del perfil y qué puede cada uno): lo que muestran
     // `dotrino-vault members` y la consola de vault.dotrino.com.
     profileMembers: () => identity.profileMembers(),
+    // ¿Es ESTA bóveda la que sella el acta? Lo usa el freno de borrado (D12).
+    isMaster: () => identity.isMaster(),
     setCaps: (pub, caps) => identity.setCaps(pub, caps),
     revokeDevice: (nonce) => desk.revoke(nonce),
     close () { try { client.close() } catch (_) {} identity.destroy() }

package/src/vaultControl.js

@@ -149,7 +149,7 @@ async function profileOp (op, { profile, name, password } = {}) {
   signalOrCleanup('SIGUSR2', [F.profileReq])
   const d = await waitFor(F.profilesList)
   if (!d) throw coded('el daemon no respondió', 'NO_REPLY')
-  if (d.error) throw new Error(d.error)
+  if (d.error) throw coded(d.error, d.code) // p.ej. MASTER_WITH_MEMBERS (freno D12)
   return d // { profiles:[{id,name,protected,locked,current,fingerprint,iss,createdAt}], current, done? }
 }