@dotrino/vaultd 0.38.0 → 0.46.2

package/src/store.js

@@ -64,6 +64,8 @@ export function openStore (dir) {
       return ok
     },
     getSetting (k) { return data.settings[k] },
-    setSetting (k, v) { data.settings[k] = v; save() }
+    setSetting (k, v) { if (v === undefined) delete data.settings[k]; else data.settings[k] = v; save() },
+    /** Todos los ajustes (copia). Para quien necesita buscar por prefijo. */
+    listSettings () { return { ...data.settings } }
   }
 }

package/src/tui/app.js

@@ -138,6 +138,13 @@ function activeProfile (st) {
   return list.find((p) => p.current) || list[0] || null
 }
 const activeId = (st) => activeProfile(st)?.id || undefined
+/**
+ * La contraseña del perfil ACTIVO, que la TUI ya guarda para toda la sesión al
+ * desbloquear (ver `reunlockSilently`). Las operaciones que SELLAN una variable la
+ * necesitan: sin ella el daemon cae a la llave de la máquina, que no abre la copia
+ * maestra de un perfil con contraseña, y la escritura falla con «wrong password».
+ */
+const activePwd = (st) => st.sessionPwd?.get(activeId(st)) || undefined
 
 function lockGlyph (p) {
   if (!p?.protected) return ''
@@ -251,8 +258,12 @@ function deviceRows (st, t) {
   for (const d of devices) {
     const label = d.label || t.muted(i.noLabel)
     const vars = devVarsOf(st, d.sub).length
+    const debt = debtOf(st, d.sub)
     const extra = (d.certCount > 1 ? t.muted(`  certs:${d.certCount}`) : '') +
-      (vars ? t.muted(`  vars:${vars}`) : '')
+      (vars ? t.muted(`  vars:${vars}`) : '') +
+      // EN DEUDA: en el acta y sin poder abrir lo suyo. Va en color de aviso al lado de
+      // sus variables, que es donde se mira cuando algo no arranca.
+      (debt ? t.warn(`  ${i.deviceDebt(debt)}`) : '')
     // SIN ACCESO: está en el acta y no puede entrar. Es un aviso, no un adorno, así que va
     // en el color de aviso y en el sitio donde estaría su vencimiento.
     const status = d.noAccess
@@ -341,7 +352,19 @@ function secretRows (st, t) {
   // El puntero a la otra pantalla va SIEMPRE, con scopes y sin ellos: es la mitad de la
   // función y quien la busca no tiene por qué adivinar que vive en Dispositivos.
   const footer = [{ text: '', sel: false }, { text: t.muted(' ' + i.devVarsElsewhere), sel: false }]
-  if (!names.length) return [{ text: t.muted(i.noScopes), sel: false }, ...footer]
+  // ARRIBA DEL TODO, antes que las variables: lo que está sin sellar significa que esos
+  // aparatos NO están leyendo su configuración ahora mismo, y que solo la contraseña lo
+  // arregla. Un aviso que hay que buscar no es un aviso.
+  const head = []
+  for (const [owner, info] of Object.entries(st.secrets?.pending || {})) {
+    const who = (info?.members || []).map((m) => deviceIdOf(st, m.pub) + ' (' + m.keys.join(', ') + ')').join(', ')
+    head.push({ text: t.warn(' ' + i.pendingSeal(owner, info?.kind, who)), sel: false })
+  }
+  const p = activeProfile(st)
+  if (p && !p.protected) head.push({ text: t.warn(' ' + i.noPasswordWarn), sel: false })
+  if (head.length) head.push({ text: '', sel: false })
+  if (!names.length) return [...head, { text: t.muted(i.noScopes), sel: false }, ...footer]
+  rows.push(...head)
   for (const n of names) {
     rows.push({ text: t.accent(` ▸ ${n}`) + t.muted(i.scopeOf(n)), sel: true, meta: { ns: n, key: null } })
     for (const k of sortByKey(ns[n])) {
@@ -354,6 +377,21 @@ function secretRows (st, t) {
 /** Las claves guardadas para UN aparato (`pub`), o `[]`. Cada una es `{key, public}`. */
 const devVarsOf = (st, pub) => (st.secrets?.dev || []).find((x) => x.pub === pub)?.keys || []
 
+/**
+ * Lo que ese aparato NO puede abrir (§8.11). Un servicio que entra después de escrita
+ * una variable no tiene envoltura de ella, y hasta que alguien se la reparta está en el
+ * acta sin poder arrancar del todo. Aquí se cuenta cuántas, que es lo que cabe en una
+ * fila; el detalle está en la consola.
+ */
+/** El ID corto de un aparato a partir de su llave, tal como lo enseña la lista de Aparatos. */
+const deviceIdOf = (st, pub) =>
+  (st.devices?.issued || []).find((d) => d.sub === pub)?.deviceId || (st.members || []).find((m) => m.pub === pub)?.id || pub.slice(0, 8)
+
+const debtOf = (st, pub) => {
+  const d = (st.secrets?.incomplete || []).find((x) => x.pub === pub)
+  return d ? [...new Set(Object.values(d.owners || {}).flat())].length : 0
+}
+
 const sortByKey = (list) => (list || []).slice().sort((a, b) => a.key.localeCompare(b.key))
 
 /**
@@ -696,7 +734,7 @@ async function onKeyProfiles (term, st, key) {
           onSubmit: async (again) => {
             st.input = null
             if (again !== pwd) { flash(st, i.passwordMismatch, 'danger'); return }
-            const r = await guard(term, st, i.savingPassword, () => vc.setProfilePassword(p.id, pwd))
+            const r = await guard(term, st, i.savingPassword, () => vc.setProfilePassword(p.id, pwd, st.sessionPwd?.get(p.id)))
             // La nueva es la que vale para el resto de la sesión: guardar la vieja dejaría
             // a la TUI reabriendo con una contraseña que ya no existe.
             if (r.ok) { st.sessionPwd?.set(p.id, pwd); flash(st, i.passwordSaved); await refreshProfiles(term, st) }
@@ -709,7 +747,7 @@ async function onKeyProfiles (term, st, key) {
   } else if (ch === 'x' && cur) { // quitar contraseña
     if (!cur.protected) { flash(st, i.noPasswordSet, 'warn'); return true }
     await ensureUnlocked(term, st, cur, async (p = cur) => {
-      const r = await guard(term, st, i.removingPassword, () => vc.removeProfilePassword(p.id))
+      const r = await guard(term, st, i.removingPassword, () => vc.removeProfilePassword(p.id, st.sessionPwd?.get(p.id)))
       if (r.ok) { st.sessionPwd?.delete(p.id); flash(st, i.passwordRemoved); await refreshProfiles(term, st) }
     })
   } else if (ch === 'u' && cur) {
@@ -800,6 +838,19 @@ async function onKeyDevices (term, st, key) {
   return true
 }
 
+/**
+ * Tira la cuenta que NACIÓ para un emparejamiento que no llegó a término y vuelve a la que
+ * estabas usando. Es una cuenta recién creada y vacía —el aparato nunca entró—, así que no
+ * hay nada dentro que perder; lo que sí molesta es que se queden acumulando.
+ */
+async function descartarCuenta (term, st, id, volverA) {
+  const i = L(st)
+  const r = await guard(term, st, i.discardingAccount, () => vc.removeProfile(id))
+  if (volverA) await guard(term, st, i.switchingVault, () => vc.useProfile(volverA))
+  await refreshAll(term, st)
+  if (r.ok) flash(st, i.accountDiscarded)
+}
+
 /**
  * Abre el emparejamiento contra `profile` y salta a la pantalla del QR. Con `service`,
  * el QR es el de un SERVICIO de ese namespace (cert limitado a sus variables).
@@ -895,6 +946,7 @@ async function onKeyPairMode (term, st, key) {
       st.input = null
       const name = raw.trim()
       if (!name) { flash(st, i.nameEmpty, 'danger'); return }
+      const previa = activeId(st)
       const r = await guard(term, st, i.creatingVault, () => vc.addProfile(name))
       if (!r.ok) return
       const created = r.v?.id || (r.v?.profiles || []).find((p) => p.name === name)?.id
@@ -903,7 +955,11 @@ async function onKeyPairMode (term, st, key) {
       if (!u.ok) return
       await refreshAll(term, st)
       flash(st, i.accountCreated(name))
-      await beginPairing(term, st, created)
+      // Si el emparejamiento no llega a abrirse, la cuenta que se creó PARA él se va con
+      // él: si no, cada intento fallido dejaba una cuenta vacía —y encima activa— que
+      // luego había que ir a borrar a mano adivinando cuál era.
+      if (!await beginPairing(term, st, created)) await descartarCuenta(term, st, created, previa)
+      else st.pairing.born = { id: created, from: previa }
     },
     onCancel: () => { st.input = null }
   })
@@ -922,6 +978,9 @@ function promptApprove (term, st) {
       if (r.ok) {
         flash(st, i.deviceApproved)
         st.pending = null
+        // El aparato entró: la cuenta que se creó para esto ya es de alguien, así que deja
+        // de estar en la lista de las que se descartan al salir.
+        st.pairing = null
         st.screen = 'devices'
         // Sin lista (el volcado se perdió): se pide otra vez. El aparato ya está dentro;
         // lo único que falta es la foto, y esa se vuelve a pedir sin drama.
@@ -963,11 +1022,26 @@ async function onKeyPairing (term, st, key) {
     return true
   }
   if (ch === 'r') { // restart: reiniciar el emparejamiento
+    const born = st.pairing?.born
     const r = await guard(term, st, i.restartingPairing, () => vc.startPairing({ profile: activeId(st) }))
-    if (r.ok) { st.pairing = r.v; st.pending = null; st.scroll.pairing = { value: 0 } }
+    if (r.ok) { st.pairing = { ...r.v, ...(born ? { born } : {}) }; st.pending = null; st.scroll.pairing = { value: 0 } }
     return true
   }
-  if (key.name === 'escape' || ch === 'b') { st.screen = 'devices'; st.pairing = null; await refreshDevices(term, st) }
+  if (key.name === 'escape' || ch === 'b') {
+    // Te vas sin que nadie haya entrado, y la cuenta se creó PARA esto: se pregunta antes
+    // de dejarla ahí. Es la otra mitad del mismo descuido — con «cuenta nueva» era fácil
+    // acabar con tres cuentas vacías y ninguna forma de saber cuál era cuál.
+    const born = st.pairing?.born
+    if (born) {
+      setConfirm(st, {
+        text: i.confirmDiscardAccount,
+        onYes: async () => { st.confirm = null; st.pairing = null; st.screen = 'devices'; await descartarCuenta(term, st, born.id, born.from) },
+        onNo: async () => { st.confirm = null; st.pairing = null; st.screen = 'devices'; await refreshDevices(term, st) }
+      })
+      return true
+    }
+    st.screen = 'devices'; st.pairing = null; await refreshDevices(term, st)
+  }
   return true
 }
 
@@ -1015,8 +1089,10 @@ async function onKeySecrets (term, st, key) {
         onNo: () => { st.confirm = null }
       })
     }
+  } else if (ch === 'v' && cur?.key) {
+    await revealValue(term, st, `ns:${cur.ns}`, cur.key, cur.public)
   } else if (ch === 't' && cur?.key) {
-    await toggleVisibility(term, st, cur.public, () => vc.setSecretVisibility(cur.ns, cur.key, !cur.public, activeId(st)))
+    await toggleVisibility(term, st, cur.public, () => vc.setSecretVisibility(cur.ns, cur.key, !cur.public, activeId(st), activePwd(st)))
   } else if (key.name === 'f5') {
     await refreshSecrets(term, st)
   }
@@ -1027,6 +1103,38 @@ async function onKeySecrets (term, st, key) {
  * Hacer pública una variable es dejar que su valor SALGA de esta máquina, así que se
  * pregunta; volverla privada no expone nada y se aplica directo.
  */
+/**
+ * VER el valor de una variable. Es lo único que la contraseña guarda desde v5, y en la
+ * máquina de la bóveda no hay otro camino: la llave de este aparato vive en este mismo
+ * disco, así que si abriera sin frase una copia del disco abriría todo.
+ *
+ * Si el perfil no tiene contraseña se abre con la llave de la máquina y no se pregunta
+ * nada — pero se dice, para que no parezca una protección que no está puesta.
+ */
+async function revealValue (term, st, owner, key, isPublic) {
+  const i = L(st)
+  const p = activeProfile(st)
+  const mostrar = async (pwd) => {
+    const r = await guard(term, st, i.revealing, () => vc.revealSecret(owner, key, activeId(st), pwd))
+    if (r.ok) flash(st, i.revealed(key, r.v), 'ok')
+  }
+  if (isPublic) return mostrar(undefined)             // una pública no está cerrada
+  if (!p?.protected) { flash(st, i.revealNoPwd, 'warn'); return mostrar(undefined) }
+  const guardada = activePwd(st)
+  if (guardada) return mostrar(guardada)
+  setInput(st, {
+    label: i.revealAsk,
+    hint: i.revealHint,
+    mask: true,
+    onSubmit: async (pwd) => {
+      st.input = null
+      if (!pwd) return
+      await mostrar(pwd)
+    },
+    onCancel: () => { st.input = null }
+  })
+}
+
 async function toggleVisibility (term, st, wasPublic, apply) {
   const i = L(st)
   const run = async () => {
@@ -1059,7 +1167,9 @@ async function onKeyDevVars (term, st, key) {
   if (ch === 'n') { promptNewDeviceVariable(term, st); return true }
   if (ch === 'i' && target) { promptLoadVars(term, st, { pub: target.pub, where: target.deviceId }); return true }
   if (ch === 't' && cur && target) {
-    await toggleVisibility(term, st, cur.public, () => vc.setDeviceSecretVisibility(target.pub, cur.key, !cur.public, activeId(st)))
+    await toggleVisibility(term, st, cur.public, () => vc.setDeviceSecretVisibility(target.pub, cur.key, !cur.public, activeId(st), activePwd(st)))
+  } else if (ch === 'v' && cur?.key) {
+    await revealValue(term, st, `dev:${target.pub}`, cur.key, cur.public)
     return true
   }
   if ((ch === 'x' || key.name === 'delete') && cur && target) {

package/src/tui/i18n.js

@@ -83,6 +83,8 @@ const es = {
 
   // bóvedas (perfiles)
   noPassword: 'sin clave',
+  noPasswordWarn: 'Este perfil no tiene contraseña: una copia de este disco abre las variables privadas.',
+  pendingSeal: (owner, kind, who) => kind === 'rotate' ? `${owner}: sin rotar (salió un aparato). Guarda una variable con la contraseña.` : `${owner}: sin llave todavía en ${who}. Se reparte sola con otro aparato del grupo encendido, o al abrir la bóveda.`,
   locked: '🔒 bloqueada',
   unlocked: '🔓 abierta',
   passwordOf: (name) => `Contraseña de "${name}"`,
@@ -109,7 +111,7 @@ const es = {
   deletingVault: 'Borrando bóveda…',
   vaultDeleted: 'Bóveda borrada',
   newPasswordLabel: (name) => `Contraseña nueva para "${name}" (mín. 4)`,
-  passwordTooShort: 'La contraseña debe tener al menos 4 caracteres',
+  passwordTooShort: 'La contraseña debe tener al menos 12 caracteres: usa varias palabras al azar',
   repeatPassword: 'Repite la contraseña',
   passwordMismatch: 'Las contraseñas no coinciden',
   savingPassword: 'Guardando contraseña…',
@@ -129,6 +131,7 @@ const es = {
   noLabel: '(sin etiqueta)',
   // Está en el acta y no puede entrar: o le retiraron el certificado, o se le venció.
   deviceNoAccess: 'SIN ACCESO — está en el acta pero no puede entrar',
+  deviceDebt: (n) => `no abre ${n}`,
   thisVault: 'esta bóveda (manda ella)',
   cantRemoveMaster: 'Esta bóveda es la que manda: no se quita a sí misma.',
   revokedCount: (n) => `  Revocados: ${n}`,
@@ -218,6 +221,9 @@ const es = {
   newAccountLabel: 'Nombre de la cuenta nueva',
   newAccountHint: 'nace vacía; el dispositivo será su primer invitado',
   accountCreated: (name) => `Cuenta creada: ${name}`,
+  discardingAccount: 'Descartando la cuenta…',
+  accountDiscarded: 'Cuenta descartada: nadie llegó a entrar en ella',
+  confirmDiscardAccount: 'La cuenta se creó para este emparejamiento y quedó vacía. ¿La descarto?',
   // Cuenta + vigencia en UNA línea: cada línea de cabecera es una fila menos de QR
   // visible antes de tener que hacer scroll.
   pairAccount: (name, min) => `Cuenta que se comparte: ${name}  ·  válido ~${min} min`,
@@ -257,14 +263,21 @@ const es = {
   deviceRenamed: (n) => `Ahora se llama «${n}»`,
   helpSecrets: ({ hasSecrets } = {}) => [
     '←→ pestaña', '↑↓', 'n nueva variable', 'i cargar varias',
-    ...(hasSecrets ? ['t pública/privada', 'x quitar (variable/scope)'] : []),
+    ...(hasSecrets ? ['v ver valor', 't pública/privada', 'x quitar (variable/scope)'] : []),
     'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'
   ],
   helpDevVars: ({ hasVars } = {}) => [
     '↑↓', 'n nueva variable', 'i cargar varias',
-    ...(hasVars ? ['t pública/privada', 'x quitar'] : []),
+    ...(hasVars ? ['v ver valor', 't pública/privada', 'x quitar'] : []),
     'F5 refrescar', 'Esc dispositivos', 'l English', 'q salir'
   ],
+  // Ver el valor de una privada: lo único que la contraseña guarda en esta máquina.
+  revealTitle: 'Ver el valor',
+  revealAsk: 'Contraseña del perfil (para ver el valor)',
+  revealHint: 'sin ella no se puede abrir: es lo único que la guarda (Esc cancela)',
+  revealing: 'abriendo…',
+  revealed: (k, v) => `${k} = ${v}`,
+  revealNoPwd: 'Este perfil no tiene contraseña: se abre con la llave de esta máquina.',
   helpPairing: ['a aprobar', 'x rechazar', 'r reiniciar', '↑↓ scroll', 'Esc atrás', 'l English'],
   helpPairMode: ['↑↓', 'Enter elegir', 'Esc atrás', 'l English', 'q salir'],
 
@@ -363,6 +376,8 @@ const en = {
   titlePairMode: 'Pairing: which account does it join?',
 
   noPassword: 'no password',
+  noPasswordWarn: 'This profile has no password: a copy of this disk opens the private variables.',
+  pendingSeal: (owner, kind, who) => kind === 'rotate' ? `${owner}: not rotated (a device left). Save a variable with the password.` : `${owner}: no key yet on ${who}. It is handed out by another device of the group that is on, or when the vault is opened.`,
   locked: '🔒 locked',
   unlocked: '🔓 unlocked',
   passwordOf: (name) => `Password for "${name}"`,
@@ -389,7 +404,7 @@ const en = {
   deletingVault: 'Deleting vault…',
   vaultDeleted: 'Vault deleted',
   newPasswordLabel: (name) => `New password for "${name}" (min. 4)`,
-  passwordTooShort: 'The password must be at least 4 characters',
+  passwordTooShort: 'The password must be at least 12 characters: use several random words',
   repeatPassword: 'Repeat the password',
   passwordMismatch: 'The passwords do not match',
   savingPassword: 'Saving password…',
@@ -407,6 +422,7 @@ const en = {
   noDevices: '  (no devices enrolled — press P to pair one)',
   noLabel: '(no label)',
   deviceNoAccess: 'NO ACCESS — it is on the record but cannot get in',
+  deviceDebt: (n) => `cannot open ${n}`,
   thisVault: 'this vault (it is the Master)',
   cantRemoveMaster: 'This vault is the Master: it does not remove itself.',
   revokedCount: (n) => `  Revoked: ${n}`,
@@ -491,6 +507,9 @@ const en = {
   newAccountLabel: 'Name of the new account',
   newAccountHint: 'born empty; the device will be its first guest',
   accountCreated: (name) => `Account created: ${name}`,
+  discardingAccount: 'Discarding the account…',
+  accountDiscarded: 'Account discarded: nobody got to join it',
+  confirmDiscardAccount: 'The account was created for this pairing and is empty. Discard it?',
   pairAccount: (name, min) => `Account being shared: ${name}  ·  valid ~${min} min`,
   pairScan: 'Scan it, or open this address on the device:',
   pairUrl: 'URL: ',
@@ -518,14 +537,20 @@ const en = {
   deviceRenamed: (n) => `Now called "${n}"`,
   helpSecrets: ({ hasSecrets } = {}) => [
     '←→ tab', '↑↓', 'n new variable', 'i load several',
-    ...(hasSecrets ? ['t public/private', 'x remove (variable/scope)'] : []),
+    ...(hasSecrets ? ['v show value', 't public/private', 'x remove (variable/scope)'] : []),
     'F5 refresh', 'Esc vaults', 'l Español', 'q quit'
   ],
   helpDevVars: ({ hasVars } = {}) => [
     '↑↓', 'n new variable', 'i load several',
-    ...(hasVars ? ['t public/private', 'x remove'] : []),
+    ...(hasVars ? ['v show value', 't public/private', 'x remove'] : []),
     'F5 refresh', 'Esc devices', 'l Español', 'q quit'
   ],
+  revealTitle: 'Show the value',
+  revealAsk: 'Profile password (to show the value)',
+  revealHint: 'without it there is no way to open it: it is the only thing guarding it (Esc cancels)',
+  revealing: 'opening…',
+  revealed: (k, v) => `${k} = ${v}`,
+  revealNoPwd: 'This profile has no password: it opens with this machine key.',
   helpPairing: ['a approve', 'x reject', 'r restart', '↑↓ scroll', 'Esc back', 'l Español'],
   helpPairMode: ['↑↓', 'Enter choose', 'Esc back', 'l Español', 'q quit'],