@dotrino/vaultd 0.17.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "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/tui/app.js

@@ -213,6 +213,37 @@ function pairModeRows (st, t) {
   return rows
 }
 
+/**
+ * PERMISOS de un dispositivo. Los cuatro que existen, con lo que significan en cristiano y
+ * una marca de si los tiene. El de administrar va aparte y avisado: es el único que deja
+ * a ese aparato meter y sacar dispositivos sin venir aquí.
+ */
+const CAPS_ORDEN = ['sign', 'store', 'read', 'admin']
+
+function capsRows (st, t) {
+  const i = L(st)
+  const objetivo = st.capsFor
+  if (!objetivo) return [{ text: t.muted(i.loading), sel: false }]
+  const miembro = (st.members || []).find((m) => m.pub === objetivo.pub)
+  if (!miembro) return [{ text: t.muted(i.capsNoMember), sel: false }]
+
+  const tiene = new Set(miembro.caps || [])
+  const rows = [
+    { text: ' ' + t.bold(i.capsFor(objetivo.deviceId, miembro.label || '')), sel: false },
+    { text: '', sel: false }
+  ]
+  for (const cap of CAPS_ORDEN) {
+    const marca = tiene.has(cap) ? '[x]' : '[ ]'
+    const nombre = i.capName[cap]
+    const linea = ` ${marca}  ${cap === 'admin' ? t.bold(nombre) : nombre}`
+    rows.push({ text: linea, sel: true, meta: { cap } })
+    rows.push({ text: t.muted('      ' + i.capHint[cap]), sel: false })
+  }
+  rows.push({ text: '', sel: false })
+  rows.push({ text: t.muted(' ' + i.capsApplyHint), sel: false })
+  return rows
+}
+
 function secretRows (st, t) {
   const i = L(st)
   const ns = st.secrets || {}
@@ -306,6 +337,10 @@ async function refreshSecrets (term, st) {
   const r = await guard(term, st, L(st).loadingSecrets, () => vc.listSecrets(activeId(st)))
   if (r.ok) st.secrets = r.v
 }
+async function refreshMembers (term, st) {
+  const r = await guard(term, st, L(st).loadingMembers, () => vc.listMembers(activeId(st)))
+  if (r.ok) st.members = r.v
+}
 async function refreshMe (term, st) {
   const r = await guard(term, st, L(st).loadingProfile, () => vc.getMe(activeId(st)))
   st.me = r.ok ? r.v : null
@@ -498,9 +533,10 @@ async function onKeyDevices (term, st, key) {
       },
       onNo: () => { st.confirm = null }
     })
-  } else if (ch === 'n' && cur) {
+  } else if (ch === 'r' && cur) {
     // Renombrar: el nombre lo trae el aparato al emparejarse (y si no le diste uno, entra
-    // con TU apodo de ese momento), así que a la semana ya no dice nada.
+    // con TU apodo de ese momento), así que a la semana ya no dice nada. `r` es renombrar
+    // también en Bóvedas: una tecla, un significado.
     setInput(st, {
       label: i.renameDeviceLabel(cur.deviceId),
       hint: i.renameDeviceHint,
@@ -512,7 +548,12 @@ async function onKeyDevices (term, st, key) {
         if (r.ok) { st.devices = r.v; flash(st, i.deviceRenamed(nombre)) }
       }
     })
-  } else if (ch === 'r') {
+  } else if (ch === 'c' && cur?.sub) {
+    st.capsFor = { pub: cur.sub, deviceId: cur.deviceId }
+    st.sel.caps = 0
+    await refreshMembers(term, st)
+    st.screen = 'caps'
+  } else if (key.name === 'f5') {
     await refreshDevices(term, st)
   }
   return true
@@ -525,6 +566,47 @@ async function beginPairing (term, st, profile) {
   return r.ok
 }
 
+/**
+ * Enter marca o desmarca un permiso y lo aplica en el acto. Sin botón de «guardar»: cada
+ * cambio se sella en el acta y se avisa a los demás aparatos, así que acumularlos en
+ * pantalla solo serviría para que el acta y lo que ves dijeran cosas distintas.
+ */
+async function onKeyCaps (term, st, key) {
+  const i = L(st)
+  const rows = capsRows(st, term.t)
+  const sels = rows.filter((r) => r.sel).map((r) => r.meta)
+  moveSel(st, key, 'caps', sels.length)
+  const cur = sels[Math.min(st.sel.caps || 0, sels.length - 1)]
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+
+  if (key.name === 'escape' || ch === 'b') { st.screen = 'devices'; st.capsFor = null; return true }
+  if (key.name === 'f5') { await refreshMembers(term, st); return true }
+  if ((key.name !== 'enter' && ch !== ' ') || !cur) return true
+
+  const miembro = (st.members || []).find((m) => m.pub === st.capsFor?.pub)
+  if (!miembro) return true
+  const caps = new Set(miembro.caps || [])
+  const dando = !caps.has(cur.cap)
+  if (dando) caps.add(cur.cap); else caps.delete(cur.cap)
+
+  const aplicar = async () => {
+    const r = await guard(term, st, i.applyingCaps, () => vc.setDeviceCaps(miembro.pub, [...caps], activeId(st)))
+    if (!r.ok) return
+    st.devices = r.v
+    await refreshMembers(term, st)
+    flash(st, dando ? i.capGiven(i.capName[cur.cap]) : i.capTaken(i.capName[cur.cap]))
+  }
+
+  // Administrar se PREGUNTA: es el permiso que deja a ese aparato admitir y expulsar
+  // dispositivos sin pasar por aquí. Los otros tres se marcan y ya.
+  if (cur.cap === 'admin' && dando) {
+    setConfirm(st, { text: i.confirmAdmin(st.capsFor.deviceId), onYes: aplicar })
+    return true
+  }
+  await aplicar()
+  return true
+}
+
 async function onKeyPairMode (term, st, key) {
   const i = L(st)
   const rows = pairModeRows(st, term.t)
@@ -620,7 +702,7 @@ async function onKeyPairing (term, st, key) {
  * que usas, no en la máquina donde vive la bóveda.
  */
 async function onKeyMe (term, st, key) {
-  if (key.name === 'char' && key.ch.toLowerCase() === 'r') await refreshMe(term, st)
+  if (key.name === 'f5') await refreshMe(term, st)
   return true
 }
 
@@ -657,7 +739,7 @@ async function onKeySecrets (term, st, key) {
         onNo: () => { st.confirm = null }
       })
     }
-  } else if (ch === 'r') {
+  } else if (key.name === 'f5') {
     await refreshSecrets(term, st)
   }
   return true
@@ -729,19 +811,34 @@ async function onConfirmKey (st, key) {
 const INNER_TABS = ['devices', 'secrets', 'me']
 const tabLabel = (i, k) => ({ devices: i.tabDevices, secrets: i.tabSecrets, me: i.tabMe })[k]
 
-const helpSegs = (i, screen) => ({
-  profiles: i.helpProfiles,
-  devices: i.helpDevices,
-  secrets: i.helpSecrets,
-  pairing: i.helpPairing,
-  pairmode: i.helpPairMode,
-  me: i.helpMe
-})[screen] || []
+/**
+ * Las teclas que se pueden usar AHORA, no el catálogo entero. Aprobar/rechazar sin nadie
+ * esperando, o revocar sin un aparato seleccionado, no hacen nada: anunciarlas confunde
+ * («¿por qué no pasa nada?») y además quema esas letras para otros usos en la pantalla.
+ */
+const helpSegs = (i, screen, st = {}) => {
+  const segs = {
+    profiles: i.helpProfiles,
+    devices: i.helpDevices,
+    secrets: i.helpSecrets,
+    pairing: i.helpPairing,
+    pairmode: i.helpPairMode,
+    me: i.helpMe,
+    caps: i.helpCaps
+  }[screen] || []
+  if (typeof segs !== 'function') return segs
+  return segs({
+    pendiente: !!st.pending,
+    hayAparatos: (st.devices?.issued || []).length > 0,
+    haySecretos: Object.keys(st.secrets || {}).length > 0
+  })
+}
 
 const title = (i, screen) => ({
   profiles: i.titleProfiles,
   pairing: i.titlePairing,
-  pairmode: i.titlePairMode
+  pairmode: i.titlePairMode,
+  caps: i.titleCaps
 })[screen] || ''
 
 /** Barra de pestañas horizontal (Dispositivos | Scopes y variables) de la bóveda entrada. */
@@ -827,6 +924,7 @@ function render (term, st) {
   else if (st.screen === 'devices') body = renderList(deviceRows(st, t), st.sel.devices, contentH, cols, t, scrollRef)
   else if (st.screen === 'secrets') body = renderList(secretRows(st, t), st.sel.secrets, contentH, cols, t, scrollRef)
   else if (st.screen === 'me') body = renderList(meRows(st, t), -1, contentH, cols, t, scrollRef)
+  else if (st.screen === 'caps') body = renderList(capsRows(st, t), st.sel.caps || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairmode') body = renderList(pairModeRows(st, t), st.sel.pairmode, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairing') {
     const pb = pairingBody(st, t, cols, contentH)
@@ -851,7 +949,7 @@ function render (term, st) {
   } else lines[statusRow] = ''
 
   // barra de ayuda
-  let help = fitHelp(helpSegs(i, st.screen), cols)
+  let help = fitHelp(helpSegs(i, st.screen, st), cols)
   if (st.input) help = i.helpInput
   else if (st.confirm) help = i.helpConfirm
   lines[rows - 1] = t.bar(help, cols)
@@ -980,6 +1078,7 @@ export async function runTui () {
       else if (st.screen === 'devices') running = await onKeyDevices(term, st, key)
       else if (st.screen === 'secrets') running = await onKeySecrets(term, st, key)
       else if (st.screen === 'me') running = await onKeyMe(term, st, key)
+      else if (st.screen === 'caps') running = await onKeyCaps(term, st, key)
       else if (st.screen === 'pairmode') running = await onKeyPairMode(term, st, key)
       else if (st.screen === 'pairing') running = await onKeyPairing(term, st, key)
     }
@@ -989,4 +1088,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, profileRows, deviceRows, secretRows, meRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang }
+export const __test = { render, profileRows, deviceRows, secretRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang }

package/src/tui/i18n.js

@@ -35,11 +35,34 @@ const es = {
   tabDevices: 'Dispositivos',
   tabSecrets: 'Scopes y variables',
   tabMe: 'Perfil',
+  // PERMISOS de un dispositivo (§9.1: se dice el beneficio, no el scope del cert).
+  titleCaps: 'Permisos del dispositivo',
+  capsFor: (id, nombre) => `Permisos de ${id}${nombre ? ' · ' + nombre : ''}`,
+  capsNoMember: '  (este dispositivo ya no está en el acta)',
+  capsApplyHint: 'Enter marca o desmarca. Cada cambio se aplica y se avisa a tus otros aparatos.',
+  capName: {
+    sign: 'Firmar como tú',
+    store: 'Guardar tus datos',
+    read: 'Leer tus datos',
+    admin: 'Administrar el perfil'
+  },
+  capHint: {
+    sign: 'usar tu identidad en las apps del ecosistema',
+    store: 'escribir en tu bóveda (perfil, contenido, datos sensibles)',
+    read: 'ver lo que guardaste',
+    admin: 'conectar y quitar dispositivos desde ese aparato, sin venir aquí'
+  },
+  confirmAdmin: (id) => `¿Dejar que ${id} conecte y quite dispositivos sin venir aquí?`,
+  capGiven: (n) => `Concedido: ${n}`,
+  capTaken: (n) => `Quitado: ${n}`,
+  applyingCaps: 'Aplicando…',
+  loadingMembers: 'Cargando el acta…',
+  helpCaps: ['↑↓', 'Enter marcar', 'F5 refrescar', 'Esc dispositivos', 'l English', 'q salir'],
   // Perfil del usuario (lo que sincronizan los dispositivos). Solo lectura: se edita en
   // el aparato, no en la máquina donde vive la bóveda.
   loadingProfile: 'Cargando el perfil…',
   noProfile: '  (esta bóveda todavía no tiene perfil)',
-  noProfileHint: '  Edita tu nombre o tu foto en un dispositivo emparejado y pulsa R.',
+  noProfileHint: '  Edita tu nombre o tu foto en un dispositivo emparejado y pulsa F5.',
   profileUpdated: (cuando) => `  actualizado ${cuando}`,
   fieldName: 'nombre',
   fieldPhoto: 'foto',
@@ -53,7 +76,7 @@ const es = {
   hidden: '   (oculto)',
   noName: '(sin nombre)',
   no: 'no',
-  helpMe: ['←→ pestaña', 'r refrescar', 'Esc bóvedas', 'l English', 'q salir'],
+  helpMe: ['←→ pestaña', 'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'],
   tabsHint: '   (←→ cambiar)',
   titleProfiles: 'Bóvedas',
   titlePairing: 'Emparejar un dispositivo',
@@ -175,12 +198,24 @@ const es = {
   // 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', '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', 'n renombrar', 'v revocar', 'r refrescar', 'Esc bóvedas', 'l English', 'q salir'],
+  // La barra dice lo que se PUEDE hacer AHORA, no todo lo que existe: aprobar/rechazar solo
+  // valen si hay alguien esperando, y renombrar/revocar solo si hay un aparato seleccionado.
+  // Anunciar teclas muertas confunde y además las quema para otros usos.
+  helpDevices: ({ pendiente, hayAparatos } = {}) => [
+    '←→ pestaña', '↑↓', 'p emparejar',
+    ...(pendiente ? ['a aprobar', 'x rechazar'] : []),
+    ...(hayAparatos ? ['r renombrar', 'c permisos', 'v revocar'] : []),
+    'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'
+  ],
   renameDeviceLabel: (id) => `¿Cómo quieres llamar a ${id}?`,
   renameDeviceHint: 'el nombre con el que lo reconoces (Esc cancela)',
   renaming: 'Renombrando…',
   deviceRenamed: (n) => `Ahora se llama «${n}»`,
-  helpSecrets: ['←→ pestaña', '↑↓', 'n nueva variable', 'x quitar (variable/scope)', 'r refrescar', 'Esc bóvedas', 'l English', 'q salir'],
+  helpSecrets: ({ haySecretos } = {}) => [
+    '←→ pestaña', '↑↓', 'n nueva variable',
+    ...(haySecretos ? ['x quitar (variable/scope)'] : []),
+    'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'
+  ],
   helpPairing: ['a aprobar', 'x rechazar', 'r reiniciar', '↑↓ scroll', 'Esc atrás', 'l English'],
   helpPairMode: ['↑↓', 'Enter elegir', 'Esc atrás', 'l English', 'q salir'],
 
@@ -228,9 +263,31 @@ const en = {
   tabDevices: 'Devices',
   tabSecrets: 'Scopes & variables',
   tabMe: 'Profile',
+  titleCaps: 'Device permissions',
+  capsFor: (id, nombre) => `Permissions for ${id}${nombre ? ' · ' + nombre : ''}`,
+  capsNoMember: '  (this device is no longer in the record)',
+  capsApplyHint: 'Enter ticks or unticks. Each change applies and your other devices are told.',
+  capName: {
+    sign: 'Sign as you',
+    store: 'Save your data',
+    read: 'Read your data',
+    admin: 'Manage the profile'
+  },
+  capHint: {
+    sign: 'use your identity across the ecosystem apps',
+    store: 'write to your vault (profile, content, sensitive data)',
+    read: 'see what you saved',
+    admin: 'connect and remove devices from that device, without coming here'
+  },
+  confirmAdmin: (id) => `Let ${id} connect and remove devices without coming here?`,
+  capGiven: (n) => `Granted: ${n}`,
+  capTaken: (n) => `Removed: ${n}`,
+  applyingCaps: 'Applying…',
+  loadingMembers: 'Loading the record…',
+  helpCaps: ['↑↓', 'Enter tick', 'F5 refresh', 'Esc devices', 'l Español', 'q quit'],
   loadingProfile: 'Loading profile…',
   noProfile: '  (this vault has no profile yet)',
-  noProfileHint: '  Edit your name or photo on a paired device and press R.',
+  noProfileHint: '  Edit your name or photo on a paired device and press F5.',
   profileUpdated: (cuando) => `  updated ${cuando}`,
   fieldName: 'name',
   fieldPhoto: 'photo',
@@ -244,7 +301,7 @@ const en = {
   hidden: '   (hidden)',
   noName: '(no name)',
   no: 'no',
-  helpMe: ['←→ tab', 'r refresh', 'Esc vaults', 'l Español', 'q quit'],
+  helpMe: ['←→ tab', 'F5 refresh', 'Esc vaults', 'l Español', 'q quit'],
   tabsHint: '   (←→ switch)',
   titleProfiles: 'Vaults',
   titlePairing: 'Pair a device',
@@ -355,12 +412,21 @@ const en = {
   helpConfirm: 'y confirm · n/Esc cancel',
 
   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', 'n rename', 'v revoke', 'r refresh', 'Esc vaults', 'l Español', 'q quit'],
+  helpDevices: ({ pendiente, hayAparatos } = {}) => [
+    '←→ tab', '↑↓', 'p pair',
+    ...(pendiente ? ['a approve', 'x reject'] : []),
+    ...(hayAparatos ? ['r rename', 'c permissions', 'v revoke'] : []),
+    'F5 refresh', 'Esc vaults', 'l Español', 'q quit'
+  ],
   renameDeviceLabel: (id) => `What do you want to call ${id}?`,
   renameDeviceHint: 'the name you recognise it by (Esc cancels)',
   renaming: 'Renaming…',
   deviceRenamed: (n) => `Now called "${n}"`,
-  helpSecrets: ['←→ tab', '↑↓', 'n new variable', 'x remove (variable/scope)', 'r refresh', 'Esc vaults', 'l Español', 'q quit'],
+  helpSecrets: ({ haySecretos } = {}) => [
+    '←→ tab', '↑↓', 'n new variable',
+    ...(haySecretos ? ['x remove (variable/scope)'] : []),
+    'F5 refresh', 'Esc vaults', 'l Español', 'q quit'
+  ],
   helpPairing: ['a approve', 'x reject', 'r restart', '↑↓ scroll', 'Esc back', 'l Español'],
   helpPairMode: ['↑↓', 'Enter choose', 'Esc back', 'l Español', 'q quit'],
 

package/src/tui/term.js

@@ -124,7 +124,13 @@ export function makeTheme () {
 
 // --------------------------------- teclado ----------------------------------
 
-function parseChunk (s, push) {
+/**
+ * Decodifica un trozo de stdin en teclas. Exportado SOLO para poder probarlo: vivía
+ * encerrado en `createTerm`, así que las secuencias de escape (flechas, F5, supr) no las
+ * comprobaba nadie — y una tabla mal escrita ahí no falla, simplemente la tecla no hace
+ * nada, que es la avería más difícil de ver.
+ */
+export function parseChunk (s, push) {
   let i = 0
   const arrow = { A: 'up', B: 'down', C: 'right', D: 'left', H: 'home', F: 'end' }
   while (i < s.length) {
@@ -138,7 +144,9 @@ function parseChunk (s, push) {
           let j = i + 2; let num = ''
           while (j < s.length && /[0-9;]/.test(s[j])) { num += s[j]; j++ }
           const fin = s[j]
-          const seq = { 3: 'delete', 5: 'pageup', 6: 'pagedown', 1: 'home', 4: 'end' }
+          // F5 = refrescar. Es tecla de función y no consume un mnemónico: así `r` queda
+          // libre para renombrar, que es lo que significa en el resto de la TUI.
+          const seq = { 3: 'delete', 5: 'pageup', 6: 'pagedown', 1: 'home', 4: 'end', 15: 'f5' }
           if (fin === '~' && seq[num]) { push({ name: seq[num] }); i = j + 1; continue }
           i = (fin ? j + 1 : s.length); continue
         }

package/src/vaultControl.js

@@ -33,12 +33,14 @@ const F = {
   profilesList: 'profiles-list.json',
   secretsList: 'secrets-list.json',
   me: 'me.json',
+  acta: 'acta.json',
   // peticiones (las escribe el control; el daemon las consume y borra)
   pairReq: 'pair-request.json',
   approveReq: 'approve-request.json',
   rejectReq: 'reject-request.json',
   revokeReq: 'revoke-request.json',
   labelReq: 'label-request.json',
+  capsReq: 'caps-request.json',
   secretReq: 'secret-request.json',
   profileReq: 'profile-request.json',
   meReq: 'me-request.json',
@@ -212,6 +214,37 @@ export async function setDeviceLabel (pub, label, profile) {
   return listDevices(profile)
 }
 
+/**
+ * El ACTA del perfil: quién es miembro y qué puede hacer cada uno. Es lo que manda para los
+ * permisos — la lista de dispositivos enseña el SCOPE DEL CERT, que es su reflejo y puede
+ * ir por detrás hasta que el aparato renueve.
+ */
+export async function listMembers (profile) {
+  requireAlive()
+  rm(F.acta)
+  writeReq(F.dumpReq, {}, profile)
+  signalOrCleanup('SIGUSR2', [F.dumpReq])
+  const d = await waitFor(F.acta)
+  if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
+  return d.members || []
+}
+
+/**
+ * Cambia lo que PUEDE hacer un dispositivo. La lista es completa (no un delta): lo que no
+ * venga, se le quita.
+ *
+ * `admin` (administrar el perfil a distancia) se concede AQUÍ, en la máquina de la bóveda,
+ * y nunca al emparejar: así el QR que circula no puede otorgarla nunca, y darla es un
+ * gesto deliberado del dueño que queda escrito en el acta.
+ */
+export async function setDeviceCaps (pub, caps, profile) {
+  requireAlive()
+  writeReq(F.capsReq, { pub, caps }, profile)
+  signalOrCleanup('SIGUSR2', [F.capsReq])
+  await sleep(600)
+  return listDevices(profile)
+}
+
 /** Revoca un dispositivo por su `nonce` (le ordena autoborrarse) y revuelca. */
 export async function revokeDevice (nonce, profile) {
   requireAlive()