@dotrino/vaultd 0.122.0 → 0.123.1

package/src/replica.js

@@ -66,9 +66,44 @@ export function mergeBundle (viejo, nuevo) {
     if (gb > ga) entries[k] = e
     else if (gb === ga && String(e.e?.ct ?? e.pubv ?? '') < String(a.e?.ct ?? a.pubv ?? '')) entries[k] = e
   }
-  const porGen = new Map()
-  for (const w of [...(viejo.wraps || []), ...(nuevo.wraps || [])]) porGen.set(w.gen, w)
-  return { ...viejo, ...nuevo, entries, wraps: [...porGen.values()].sort((x, y) => x.gen - y.gen) }
+  const wraps = mergeWraps(viejo.wraps, nuevo.wraps)
+  // `ns`/`dev` son la envoltura VIGENTE de cada lado, y salen de la lista ya mezclada: con
+  // `{...viejo, ...nuevo}` se quedaba la del empujón aunque su generación fuera menor, o
+  // sea justo lo contrario de lo que decide la lista.
+  return {
+    ...viejo,
+    ...nuevo,
+    entries,
+    wraps,
+    ns: wraps.ns[wraps.ns.length - 1] || null,
+    dev: wraps.dev[wraps.dev.length - 1] || null
+  }
+}
+
+/**
+ * `wraps` es `{ ns: [...], dev: [...] }`, NO una lista.
+ *
+ * Aquí se esparcía como si fuera una lista, así que cada empujón sobre un sobre que ya
+ * existía moría con «(viejo.wraps || []) is not iterable» — y solo en producción: el
+ * primer guardado sale por `if (!viejo) return nuevo` y nunca llega aquí. El replicador de
+ * Cepi lleva así desde que se desplegó, guardando el primer sobre de cada cajón y
+ * rechazando en silencio todas las actualizaciones.
+ *
+ * La forma la fija quien lo produce (`secretsStore.js`, `sealedBundleFor`) y quien lo lee
+ * (`lib/src/service.js`, que recorre `wraps.ns` y `wraps.dev`). Los dos estaban de acuerdo;
+ * el único equivocado era esto. Y de haber funcionado habría sido peor: escribía `wraps`
+ * como lista y el servicio se habría quedado sin envolturas, que es no poder abrir nada.
+ *
+ * Las de cada lado se SUMAN por generación: son de aparatos distintos y ninguna estorba.
+ */
+function mergeWraps (a, b) {
+  const out = {}
+  for (const side of ['ns', 'dev']) {
+    const byGen = new Map()
+    for (const w of [...(a?.[side] || []), ...(b?.[side] || [])]) byGen.set(w.gen, w)
+    out[side] = [...byGen.values()].sort((x, y) => x.gen - y.gen)
+  }
+  return out
 }
 
 /** La clave de un sobre: es POR (cajón, aparato), porque va tallado a quien lo pide. */

package/src/secretsStore.js

@@ -1145,6 +1145,20 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
      * decidir si hay que migrarla. Preguntarlo intentando reenvolver un cajón mezcla dos
      * cosas y deja el fallo diciendo «wrong password» sobre el cajón, que no es donde está.
      */
+    /**
+     * ABRE UNA ENVOLTURA DE RECUPERACIÓN y devuelve lo que lleva dentro.
+     *
+     * Es para OTROS almacenes de este mismo perfil —hoy la bóveda de contraseñas—, que
+     * comparten ESTA copia de recuperación en vez de estrenar una segunda. Una segunda
+     * sería otra llave que custodiar, otra que rotar y otra que se queda atrás.
+     *
+     * Sigue siendo la única puerta a un valor en claro, y sigue pidiendo la frase.
+     */
+    async openRecoveryWrap (wrap, adminKey = null) {
+      const priv = await openRecovery(adminKey)
+      return sealer.openWrapWith(priv, wrap)
+    },
+
     async recoveryOpensWith (key) {
       needSealer('check the recovery key')
       if (!data.recovery?.priv) throw new NeedsPassword('this store has no recovery key yet')

package/src/tui/app.js

@@ -42,6 +42,12 @@ import { DEVICE_CAPS } from '@dotrino/identity/acta'
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
 // Regex de validación (mismas que el store de secretos, protocol.js).
+// El mínimo de la contraseña de un inicio de sesión. No es manía: quien tenga una COPIA
+// DEL DISCO de la bóveda puede probar contraseñas contra el registro de OPAQUE sin límite y
+// sin que nadie se entere (`temporary-access.md` §4). Contra eso lo único que aguanta es la
+// contraseña. Mismo número que la CLI, que es la misma regla.
+const MIN_LOGIN_PASSWORD = 12
+
 const NS_RE = /^[a-z0-9-]{1,32}$/
 const KEY_RE = /^[A-Z0-9_]{1,64}$/
 
@@ -343,6 +349,42 @@ function deviceRows (st, t) {
   return rows
 }
 
+/**
+ * ENTRAR CON USUARIO Y CONTRASEÑA (`docs/temporary-access.md`).
+ *
+ * Esto estaba SOLO en la línea de comandos, y es lo que la regla de las tres versiones no
+ * admite: lo que hace el binario tiene que poder hacerse en su pantalla. El canal es el
+ * MISMO que usa `dotrino-vault logins` —una pieza, no dos—, así que no se pueden
+ * desincronizar.
+ *
+ * Lo que se ve de cada uno es lo que hace falta para decidir: su DIRECCIÓN (que es lo que
+ * se teclea en el equipo prestado), cuántas sesiones tiene abiertas, y si está esperando
+ * por intentos fallidos.
+ */
+function loginRows (st, t) {
+  const i = L(st)
+  const rows = []
+  const list = st.logins || []
+  if (!list.length) {
+    rows.push({ text: t.muted(i.noLogins), sel: false })
+    rows.push({ text: '', sel: false })
+    rows.push({ text: t.muted(i.loginsHint), sel: false })
+    return rows
+  }
+  for (const l of list) {
+    const espera = l.blockedUntil > Date.now() ? Math.ceil((l.blockedUntil - Date.now()) / 1000) : 0
+    const abiertas = (l.sessions || []).length
+    const extra = [
+      abiertas ? t.warn('  ' + i.loginOpen(abiertas)) : t.muted('  ' + i.loginOpen(0)),
+      l.label ? t.muted('  «' + l.label + '»') : '',
+      espera ? t.danger('  ' + i.loginWait(espera)) : '',
+      l.createdAt ? t.muted('  ' + i.loginCreated(fmtExp(l.createdAt))) : ''
+    ].join('')
+    rows.push({ text: ` ${t.bold(l.address || l.user)}  ${t.muted(l.deviceId || '????-????')}${extra}`, sel: true, meta: l })
+  }
+  return rows
+}
+
 /**
  * LA PREGUNTA DEL EMPAREJAMIENTO. La decisión es del vault (es quien lo inicia) y
  * este daemon puede tener varias cuentas: antes de mostrar el QR hay que decir a
@@ -403,7 +445,7 @@ function pairModeRows (st, t) {
  * esté nombrado se añade al final: un permiso puede salir en mal sitio, nunca desaparecer.
  * `test/tui-permisos.test.mjs` exige además que todos tengan nombre en los dos idiomas.
  */
-const ORDEN = ['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica']
+const ORDEN = ['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'passkeys', 'sealer', 'unattended', 'replica']
 const CAPS_ORDER = [...ORDEN.filter((c) => DEVICE_CAPS.includes(c)),
   ...DEVICE_CAPS.filter((c) => !ORDEN.includes(c))]
 
@@ -753,6 +795,17 @@ 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
 }
+/**
+ * Los inicios de sesión de la bóveda activa. Es una petición aparte del volcado normal a
+ * propósito: no hace falta para nada más, y pedirla siempre sería sacar del cifrado algo
+ * que nadie está mirando.
+ */
+async function refreshLogins (term, st, api = vc) {
+  const r = await guard(term, st, L(st).refreshing, () => api.listLogins(activeId(st)))
+  if (r.ok) st.logins = r.v
+  else st.logins = []
+}
+
 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
@@ -1047,6 +1100,105 @@ async function onKeyDevices (term, st, key) {
   return true
 }
 
+/**
+ * ENTRAR CON USUARIO Y CONTRASEÑA: las mismas acciones que el CLI, con las mismas teclas
+ * que el resto de la TUI (`n` nuevo, `c` contraseña, `v` quitar, `x` cerrar, `u` desbloquear).
+ *
+ * `x` es CERRAR SESIONES y no «quitar», porque aquí «quitar» ya es `v` —revocar, como en
+ * Dispositivos— y una tecla significa lo mismo en todas las pantallas.
+ */
+async function onKeyLogins (term, st, key, api = vc) {
+  const i = L(st)
+  const list = st.logins || []
+  moveSel(st, key, 'logins', list.length)
+  const cur = list[Math.min(st.sel.logins || 0, Math.max(0, list.length - 1))]
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+
+  if (ch === 'n') {
+    // Tres preguntas encadenadas: usuario → de dónde entra → contraseña (dos veces). Van
+    // en cadena y no en un formulario porque la TUI pregunta de a una, como en el resto.
+    setInput(st, {
+      label: i.loginUserLabel,
+      hint: i.loginUserHint,
+      onSubmit: async (raw) => {
+        const user = String(raw || '').trim().toLowerCase()
+        if (!user) return
+        setInput(st, {
+          label: i.loginLabelLabel(user),
+          hint: i.loginLabelHint,
+          value: 'equipo prestado',
+          onSubmit: async (rawLabel) => {
+            const label = String(rawLabel || '').trim() || 'equipo prestado'
+            setInput(st, {
+              label: i.loginPassLabel(user),
+              hint: i.loginPassHint,
+              mask: true,
+              onSubmit: async (pw1) => {
+                if (String(pw1 || '').length < MIN_LOGIN_PASSWORD) { flash(st, i.loginPassShort, 'warn'); return }
+                setInput(st, {
+                  label: i.loginPassAgain,
+                  hint: i.loginPassHint,
+                  mask: true,
+                  onSubmit: async (pw2) => {
+                    if (pw1 !== pw2) { flash(st, i.loginPassMismatch, 'warn'); return }
+                    const r = await guard(term, st, i.loginCreating,
+                      () => api.addLogin({ user, password: pw1, label }))
+                    if (r.ok) {
+                      await refreshLogins(term, st, api)
+                      const nuevo = (st.logins || []).find((l) => l.user === user)
+                      flash(st, i.loginCreatedOk(nuevo?.address || user))
+                    }
+                  }
+                })
+              }
+            })
+          }
+        })
+      }
+    })
+  } else if (ch === 'c' && cur) {
+    setInput(st, {
+      label: i.loginOldPass(cur.user),
+      hint: i.loginPassHint,
+      mask: true,
+      onSubmit: async (vieja) => {
+        setInput(st, {
+          label: i.loginNewPass,
+          hint: i.loginPassHint,
+          mask: true,
+          onSubmit: async (nueva) => {
+            if (String(nueva || '').length < MIN_LOGIN_PASSWORD) { flash(st, i.loginPassShort, 'warn'); return }
+            const r = await guard(term, st, i.loginChanging,
+              () => api.passwdLogin({ user: cur.user, oldPassword: vieja, newPassword: nueva }))
+            if (r.ok) { flash(st, i.loginChanged); await refreshLogins(term, st, api) }
+          }
+        })
+      }
+    })
+  } else if (ch === 'x' && cur) {
+    if (!(cur.sessions || []).length) { flash(st, i.loginNoSessions, 'warn'); return true }
+    const r = await guard(term, st, i.loginClosing, () => api.closeLoginSession(cur.user))
+    if (r.ok) { flash(st, i.loginClosed(r.v?.closed ?? (cur.sessions || []).length)); await refreshLogins(term, st, api) }
+  } else if (ch === 'u' && cur) {
+    if (!(cur.blockedUntil > Date.now())) { flash(st, i.loginNotBlocked, 'warn'); return true }
+    const r = await guard(term, st, i.loginUnblocking, () => api.unblockLogin(cur.user))
+    if (r.ok) { flash(st, i.loginUnblocked); await refreshLogins(term, st, api) }
+  } else if ((ch === 'v' || key.name === 'delete') && cur) {
+    setConfirm(st, {
+      text: i.loginRemoveConfirm(cur.user),
+      onYes: async () => {
+        st.confirm = null
+        const r = await guard(term, st, i.loginRemoving, () => api.removeLogin(cur.user))
+        if (r.ok) { flash(st, i.loginRemoved(cur.user)); st.sel.logins = 0; await refreshLogins(term, st, api) }
+      },
+      onNo: () => { st.confirm = null }
+    })
+  } else if (key.name === 'f5') {
+    await refreshLogins(term, st, api)
+  }
+  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
@@ -1794,8 +1946,8 @@ async function onConfirmKey (st, key) {
 
 // Pestañas INTERNAS de una bóveda ya elegida: se cambian con ←→. La lista de
 // bóvedas (profiles) es el nivel de arriba (se entra con Enter, no es una pestaña).
-const INNER_TABS = ['devices', 'secrets', 'me']
-const tabLabel = (i, k) => ({ devices: i.tabDevices, secrets: i.tabSecrets, me: i.tabMe })[k]
+const INNER_TABS = ['devices', 'secrets', 'logins', 'me']
+const tabLabel = (i, k) => ({ devices: i.tabDevices, secrets: i.tabSecrets, logins: i.tabLogins, me: i.tabMe })[k]
 
 /**
  * Las teclas que se pueden usar AHORA, no el catálogo entero. Aprobar/rechazar sin nadie
@@ -1807,6 +1959,7 @@ const helpSegs = (i, screen, st = {}) => {
     profiles: i.helpProfiles,
     devices: i.helpDevices,
     secrets: i.helpSecrets,
+    logins: i.helpLogins,
     pairing: i.helpPairing,
     pairmode: i.helpPairMode,
     join: i.helpJoin,
@@ -1819,12 +1972,18 @@ const helpSegs = (i, screen, st = {}) => {
   // el único que las lee), y las filas seleccionables de la lista son justo los aparatos.
   const devs = mergeMembersAndCerts(st.members, st.devices?.issued || [])
   const cur = devs[Math.min(st.sel?.devices || 0, devs.length - 1)]
+  // El inicio de sesión señalado: `x cerrar` solo tiene sentido si tiene alguna abierta, y
+  // `u quitar espera` solo si está esperando.
+  const lg = (st.logins || [])[Math.min(st.sel?.logins || 0, Math.max(0, (st.logins || []).length - 1))]
   return segs({
     pending: !!st.pending,
     hasDevices: (st.devices?.issued || []).length > 0,
     isService: !!cur?.cn,
     hasSecrets: Object.keys(st.secrets?.ns || {}).length > 0,
-    hasVars: devVarsOf(st, st.varsFor?.pub).length > 0
+    hasVars: devVarsOf(st, st.varsFor?.pub).length > 0,
+    hasLogins: (st.logins || []).length > 0,
+    hasSessions: ((lg?.sessions) || []).length > 0,
+    blocked: (lg?.blockedUntil || 0) > Date.now()
   })
 }
 
@@ -1843,7 +2002,9 @@ function renderTabs (st, t) {
   return INNER_TABS.map((k) => {
     const active = st.screen === k
     return active ? t.bold(t.accent('▐ ' + tabLabel(i, k) + ' ▌')) : t.muted('  ' + tabLabel(i, k) + '  ')
-  }).join('   ') + t.muted(i.tabsHint)
+    // UN espacio entre pestañas, no tres: con cuatro ya no cabía el «(←→ cambiar)» en 80
+    // columnas, y lo que se perdía era justamente la pista de que se puede cambiar.
+  }).join(' ') + t.muted(i.tabsHint)
 }
 
 function pairingBody (st, t, cols, height) {
@@ -1943,6 +2104,7 @@ function render (term, st) {
   if (st.screen === 'profiles') body = renderList(profileRows(st, t), st.sel.profiles, contentH, cols, t, scrollRef)
   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 === 'logins') body = renderList(loginRows(st, t), st.sel.logins || 0, 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 === 'devvars') body = renderList(devVarRows(st, t), st.sel.devvars || 0, contentH, cols, t, scrollRef)
@@ -2029,7 +2191,7 @@ export async function runTui () {
   const st = {
     screen: 'profiles', // se arranca en la lista de bóvedas: hay que ENTRAR a una
     lang: loadLang(), // es/en — se conmuta con `l` y se recuerda en prefs.json
-    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, devvars: 0 },
+    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, devvars: 0, logins: 0 },
     // Las bóvedas que ha abierto ESTA sesión, para volver a cerrarlas al salir.
     unlockedHere: new Set(),
     // Su contraseña, SOLO en memoria y SOLO mientras la TUI esté abierta: sirve para
@@ -2040,6 +2202,8 @@ export async function runTui () {
     profiles: null,
     devices: null,
     secrets: null,
+    // Los inicios de sesión se piden al ENTRAR en su pestaña, no al arrancar.
+    logins: null,
     pending: null,
     pairing: null,
     state: null,
@@ -2107,6 +2271,7 @@ export async function runTui () {
         // El perfil se pide al ENTRAR en su pestaña, no al arrancar: es contenido del
         // usuario y no hay por qué sacarlo del cifrado si nadie lo está mirando.
         if (st.screen === 'me' && st.me === undefined) await refreshMe(term, st)
+        if (st.screen === 'logins' && st.logins === null) await refreshLogins(term, st)
         continue
       }
       // Esc/'b' desde una pestaña vuelve a la lista de bóvedas (salir de la bóveda
@@ -2118,6 +2283,7 @@ export async function runTui () {
       if (st.screen === 'profiles') running = await onKeyProfiles(term, st, key)
       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 === 'logins') running = await onKeyLogins(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 === 'devvars') running = await onKeyDevVars(term, st, key)
@@ -2138,4 +2304,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, onKeySecrets, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }
+export const __test = { render, onKeySecrets, loginRows, onKeyLogins, refreshLogins, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }

package/src/tui/i18n.js

@@ -33,6 +33,44 @@ const es = {
   tooSmallHint: (cols, rows) => `Agranda a ≥ 24×9 (hay ${cols}×${rows}).`,
 
   // pestañas y títulos
+  // ----- ENTRAR CON USUARIO Y CONTRASEÑA (`docs/temporary-access.md`) -----
+  tabLogins: 'Entrar',
+  noLogins: 'Todavía no hay ninguno. Con «n» creas uno.',
+  loginsHint: 'Un aparato de esta cuenta que se abre escribiendo una dirección y una contraseña, sin conectar nada. Sirve para entrar desde un equipo prestado.',
+  loginOpen: (n) => `${n} abierto${n === 1 ? '' : 's'}`,
+  loginWait: (s) => `espera ${s} s`,
+  loginCreated: (d) => `creado ${d}`,
+  helpLogins: ({ hasLogins, hasSessions, blocked } = {}) => [
+    '←→ pestaña', '↑↓', 'n nuevo',
+    ...(hasSessions ? ['x cerrar sesiones'] : []),
+    ...(blocked ? ['u quitar espera'] : []),
+    ...(hasLogins ? ['c contraseña', 'v quitar'] : []),
+    'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'
+  ],
+  loginUserLabel: '¿Qué nombre de usuario?',
+  loginUserHint: 'letras y números, en minúscula (Esc cancela)',
+  loginLabelLabel: (u) => `¿De dónde va a entrar «${u}»?`,
+  loginLabelHint: 'lo que vas a leer aquí para decidir si cerrarlo (Esc cancela)',
+  loginPassLabel: (u) => `Contraseña para «${u}»`,
+  loginPassAgain: 'Escríbela otra vez',
+  loginPassHint: 'mínimo 12 caracteres; no se puede recuperar (Esc cancela)',
+  loginPassShort: 'La contraseña tiene que tener al menos 12 caracteres.',
+  loginPassMismatch: 'No coinciden. Inténtalo otra vez.',
+  loginOldPass: (u) => `Contraseña actual de «${u}»`,
+  loginNewPass: 'Contraseña nueva',
+  loginCreating: 'Creando el inicio de sesión…',
+  loginCreatedOk: (a) => `Listo. La dirección es ${a}`,
+  loginChanging: 'Cambiando la contraseña…',
+  loginChanged: 'Contraseña cambiada.',
+  loginClosing: 'Cerrando las sesiones…',
+  loginClosed: (n) => `${n} sesión(es) cerrada(s).`,
+  loginUnblocking: 'Quitando la espera…',
+  loginUnblocked: 'Ya puede volver a intentarlo.',
+  loginRemoving: 'Quitándolo…',
+  loginRemoved: (u) => `«${u}» se fue, y su llave salió del acta.`,
+  loginRemoveConfirm: (u) => `¿Quitar «${u}»? Su llave sale del acta y ese equipo deja de entrar.`,
+  loginNoSessions: 'Ese no tiene ninguna sesión abierta.',
+  loginNotBlocked: 'Ese no está esperando.',
   tabDevices: 'Dispositivos',
   tabSecrets: 'Scopes y variables',
   tabMe: 'Perfil',
@@ -60,6 +98,7 @@ const es = {
     read: 'lee',
     admin: 'administra',
     passwords: 'contrasenas',
+    passkeys: 'passkeys',
     approve: 'aprueba',
     sealer: 'sella',
     unattended: 'desatendido',
@@ -75,6 +114,9 @@ const es = {
     read: 'ver lo que guardaste',
     admin: 'conectar y quitar aparatos desde ahí, sin venir aquí. No puede cambiar permisos',
     passwords: 'pedir una contraseña por sitio, nunca la lista entera',
+    // Una passkey copiada sirve hasta que la borres en cada sitio: de una contraseña, al
+    // menos, se puede cambiar. Por eso es una decisión aparte.
+    passkeys: 'abrir además las passkeys guardadas, que son llaves y no se pueden cambiar. Sin «contrasenas» no hace nada',
     approve: 'dar el visto bueno cuando otro aparato pide claves privadas',
     // Sellar solo significa algo en un aparato que HAGA de bóveda (otra máquina con el
     // daemon, o un navegador que se puso de bóveda). En un teléfono normal se concede y no
@@ -399,6 +441,43 @@ const en = {
   tooSmall: 'Terminal too small',
   tooSmallHint: (cols, rows) => `Resize to ≥ 24×9 (now ${cols}×${rows}).`,
 
+  tabLogins: 'Sign in',
+  noLogins: 'None yet. Press “n” to create one.',
+  loginsHint: 'A device of this account that opens by typing an address and a password, with nothing to plug in. It is how you sign in from a borrowed computer.',
+  loginOpen: (n) => `${n} open`,
+  loginWait: (s) => `wait ${s} s`,
+  loginCreated: (d) => `created ${d}`,
+  helpLogins: ({ hasLogins, hasSessions, blocked } = {}) => [
+    '←→ tab', '↑↓', 'n new',
+    ...(hasSessions ? ['x close sessions'] : []),
+    ...(blocked ? ['u clear wait'] : []),
+    ...(hasLogins ? ['c password', 'v remove'] : []),
+    'F5 refresh', 'Esc vaults', 'l español', 'q quit'
+  ],
+  loginUserLabel: 'Which username?',
+  loginUserHint: 'lowercase letters and numbers (Esc cancels)',
+  loginLabelLabel: (u) => `Where will “${u}” sign in from?`,
+  loginLabelHint: 'what you will read here to decide whether to close it (Esc cancels)',
+  loginPassLabel: (u) => `Password for “${u}”`,
+  loginPassAgain: 'Type it again',
+  loginPassHint: 'at least 12 characters; it cannot be recovered (Esc cancels)',
+  loginPassShort: 'The password must be at least 12 characters.',
+  loginPassMismatch: 'They do not match. Try again.',
+  loginOldPass: (u) => `Current password for “${u}”`,
+  loginNewPass: 'New password',
+  loginCreating: 'Creating the sign-in…',
+  loginCreatedOk: (a) => `Done. The address is ${a}`,
+  loginChanging: 'Changing the password…',
+  loginChanged: 'Password changed.',
+  loginClosing: 'Closing the sessions…',
+  loginClosed: (n) => `${n} session(s) closed.`,
+  loginUnblocking: 'Clearing the wait…',
+  loginUnblocked: 'It can try again now.',
+  loginRemoving: 'Removing it…',
+  loginRemoved: (u) => `“${u}” is gone, and its key left the account record.`,
+  loginRemoveConfirm: (u) => `Remove “${u}”? Its key leaves the account record and that computer stops getting in.`,
+  loginNoSessions: 'That one has no open sessions.',
+  loginNotBlocked: 'That one is not waiting.',
   tabDevices: 'Devices',
   tabSecrets: 'Scopes & variables',
   tabMe: 'Profile',
@@ -419,6 +498,7 @@ const en = {
     read: 'read',
     admin: 'admin',
     passwords: 'passwords',
+    passkeys: 'passkeys',
     approve: 'approve',
     sealer: 'sealer',
     unattended: 'unattended',
@@ -432,6 +512,7 @@ const en = {
     read: 'see what you saved',
     admin: 'connect and remove devices from there, without coming here. It cannot change permissions',
     passwords: 'ask for one password per site, never the whole list',
+    passkeys: 'also open saved passkeys, which are keys and cannot be changed. Without «passwords» it does nothing',
     approve: 'give the go-ahead when another device asks for private keys',
     sealer: 'admit devices and change permissions on its own when this vault is away. Only useful on another VAULT',
     unattended: 'take private keys without asking you. Off, it must be approved from a device with «approve» every time it starts',

package/src/vault.js

@@ -234,6 +234,25 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   /** Los aparatos que el acta autoriza a pedir credenciales (`caps <ID> +contraseñas`). */
   const passwordDevices = () => (actaCache?.members || []).filter((m) => Acta.memberCan(actaCache, m.pub, 'passwords'))
 
+  /**
+   * A QUIÉN SE LE ENVUELVE LA LLAVE DE UNA CONTRASEÑA — Y LA BÓVEDA NUNCA ESTÁ EN LA LISTA.
+   *
+   * Es la comprobación que sostiene todo el modelo sellado: si la maestra o la llave de
+   * comunicación de esta máquina recibieran envoltura, el demonio volvería a poder leer las
+   * contraseñas y no habríamos arreglado nada —solo lo habríamos escrito más bonito—. Por
+   * eso se filtran explícitamente aquí, que es donde se construye la lista, y no en quien la
+   * consume (`sealed-passwords.md` §2.1).
+   *
+   * `main` son los aparatos con `contraseñas`; `passkeys`, los que además pueden abrir la
+   * privada de una passkey (§2.8). Un miembro sin llave de cifrado no puede recibir nada: se
+   * queda fuera y se ve en `incompleteMembers`.
+   */
+  const noEsLaBoveda = (pub) => pub !== master && pub !== commKey.pub()
+  const passwordRecipients = (kind = 'main') => (actaCache?.members || [])
+    .filter((m) => m.encPub && noEsLaBoveda(m.pub) && Acta.memberCan(actaCache, m.pub, 'passwords'))
+    .filter((m) => kind !== 'passkeys' || Acta.memberCan(actaCache, m.pub, 'passkeys'))
+    .map((m) => ({ pub: m.pub, encPub: m.encPub }))
+
   /**
    * El acta vigente, en caché.
    *
@@ -249,20 +268,27 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
 
   /**
-   * La llave de la bóveda de contraseñas. Nace con el primer uso y vive cifrada en
-   * reposo, como la identidad: aquí no hace falta envolverla a cada aparato porque
-   * ningún aparato abre la bóveda — piden de a una y el vault responde.
+   * LA LLAVE VIEJA DE LA BÓVEDA DE CONTRASEÑAS, la que había que quitar.
+   *
+   * Vivía DENTRO del mismo archivo que las entradas, cifrada con la llave de la máquina y
+   * no con la contraseña del perfil. O sea: el demonio con el perfil cerrado seguía
+   * descifrando, y una copia del disco las abría todas. Esto ya no la crea — solo la LEE,
+   * y solo para convertir lo que quedó escrito con ella; en cuanto la conversión termina,
+   * `soltarLlaveVieja` la borra del archivo.
    */
-  async function passwordsKey () {
+  async function llaveViejaDeContrasenas () {
     const d = readPasswordsFile()
-    if (d?.cek) {
-      const raw = Uint8Array.from(Buffer.from(d.cek, 'base64'))
-      return crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt'])
-    }
-    const key = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt'])
-    const raw = new Uint8Array(await crypto.subtle.exportKey('raw', key))
-    writePasswordsFile({ ...(d || { v: 1, data: {} }), cek: Buffer.from(raw).toString('base64') })
-    return key
+    if (!d?.cek) return null
+    const raw = Uint8Array.from(Buffer.from(d.cek, 'base64'))
+    return crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt'])
+  }
+  const soltarLlaveVieja = () => {
+    const d = readPasswordsFile()
+    if (!d?.cek) return
+    delete d.cek
+    writePasswordsFile(d)
+    log('[vault] passwords: the old vault key is gone from the disk')
+    audit('passwords.converted', {})
   }
 
   const approvalsSweeper = setInterval(() => {
@@ -1121,7 +1147,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   async function handleLoginStart (from, p) {
     try {
-      const { lid, response } = logins.loginBegin({ user: p?.user, request: p?.request })
+      const { lid, response } = await logins.loginBegin({ user: p?.user, request: p?.request })
       audit('login.start', { user: String(p?.user || '').slice(0, 32) })
       reply(from, { type: MSG.LOGIN_RESPONSE, lid, response })
     } catch (e) { loginError(from, e) }
@@ -1129,7 +1155,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   async function handleLoginFinish (from, p) {
     try {
-      const r = logins.loginEnd({ lid: p?.lid, finalization: p?.finalization, label: p?.label })
+      const r = await logins.loginEnd({ lid: p?.lid, finalization: p?.finalization, label: p?.label })
       const record = (await identity.profileActa?.().catch(() => null))?.acta || null
       audit('login.ok', { user: r.user, sid: r.sid.slice(0, 8) })
       log('[vault] login: %s entered (session %s)', r.user, r.sid.slice(0, 8))
@@ -1871,7 +1897,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     passwords = createPasswordDesk({
       client,
       store: passwordsStore,
-      cek: await passwordsKey(),
+      // LA BÓVEDA NO TIENE LLAVE. Lo que pone aquí es a quién envolverle las que hacen los
+      // aparatos, y la pública de la copia de recuperación —la que abre la frase del perfil
+      // y es la única forma de volver a repartir una entrada si un día no queda ningún
+      // aparato—. Ninguna de las dos abre nada por sí sola.
+      members: (kind) => passwordRecipients(kind),
+      recoveryPub: () => secrets.recoveryPub(),
+      canWrite: (pub) => !!actaCache && !!pub && Acta.memberCan(actaCache, pub, 'passwords'),
       // UNA sola condición, y es del ACTA: el aparato tiene la capacidad `passwords`.
       // Quitársela —o quitar el aparato— le corta esto en la siguiente pasada, sin
       // que haya una segunda lista que acordarse de tocar.
@@ -3092,6 +3124,64 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     }
   }
 
+  /**
+   * LAS CONTRASEÑAS, AL FORMATO SELLADO (§2.7) Y CON SUS ENVOLTURAS AL DÍA (§2.5).
+   *
+   * Las dos cosas se hacen aquí, al ABRIR el perfil, porque las dos necesitan lo mismo: la
+   * frase. Convertir hay que hacerlo una vez; repasar las envolturas, cada vez que cambie
+   * quién puede leer — y este es el único momento en que hay con qué.
+   *
+   * La bóveda ve los valores SOLO mientras convierte, que es cuando tiene que reescribirlos.
+   * Después no puede: lo último que hace la conversión es borrar la llave vieja.
+   */
+  async function sealPasswords (adminKey = null) {
+    if (!passwords) return null
+    const recipients = {
+      recoveryPub: secrets.recoveryPub(),
+      main: passwordRecipients('main'),
+      passkeys: passwordRecipients('passkeys')
+    }
+    if (!recipients.recoveryPub) {
+      log('[vault] passwords: no recovery key yet — nothing can be sealed until there is one')
+      return null
+    }
+    const out = {}
+    try {
+      const { convertPasswords } = await import('./passwords.js')
+      const r = await convertPasswords({
+        store: passwordsStore,
+        sealed: passwords.sealed,
+        cek: await llaveViejaDeContrasenas(),
+        recipients,
+        // LA MAESTRA FIRMA LO QUE ESCRIBE, como cualquier aparato que guarda una entrada.
+        // Firmar no es leer: lo que se le envuelve a esta bóveda sigue siendo nada.
+        author: { publickey: master, sign: (body) => identity.signData(body) },
+        dropOldKey: soltarLlaveVieja,
+        log
+      })
+      out.converted = r?.entries || 0
+      if (r?.already) out.converted = 0
+    } catch (e) {
+      log(`[vault] passwords: could not convert to the sealed format (${e.message})`)
+      out.convertError = e.message
+    }
+    try {
+      const r = await passwords.sealed.rewrapAll({
+        openRecovery: (wrap) => secrets.openRecoveryWrap(wrap, adminKey)
+      })
+      out.wrapped = r.wrapped
+      out.dropped = r.dropped
+      if (r.wrapped || r.dropped) {
+        log(`[vault] passwords: keyring rebuilt (${r.wrapped} wrap(s), ${r.dropped} stale one(s) dropped)`)
+      }
+      if (r.failed?.length) log(`[vault] passwords: ${r.failed.length} generation(s) could NOT be rewrapped`)
+    } catch (e) {
+      log(`[vault] passwords: could not rebuild the keyring (${e.message})`)
+      out.rewrapError = e.message
+    }
+    return out
+  }
+
   async function resealAll (adminKey = null) {
     // ANTES de reenvolver nada: si la copia de recuperación se quedó bajo la llave de la
     // máquina, se pasa a la frase. Sin esto, todo lo de abajo falla con «wrong password».
@@ -3558,6 +3648,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
      * diseño dice que sí (§8.2). Lo de siempre: dos sitios decidiendo lo mismo.
      */
     resealAll,
+    /** Convierte las contraseñas al formato sellado y repasa sus envolturas (§2.5, §2.7). */
+    sealPasswords,
     delegateRewrap,
     incompleteMembers,
     migrateSecrets: (membersOf, adminKey) => secrets.migrate(