@dotrino/vaultd 0.52.0 → 0.56.0

package/src/profiles.js

@@ -24,7 +24,9 @@ import fs from 'node:fs'
 import crypto2 from 'node:crypto'
 import path from 'node:path'
 import { dataDir, ensureDir, readJson, writeJson } from './paths.js'
-import { atRestFor, migrateFile, machineKey } from './atrest.js'
+import { atRestFor, migrateFile, kekFor } from './atrest.js'
+import { probe as probeKek, writeConfig as writeKekConfig, configFromEnv } from './atrest.js'
+import { keyDirName, keyOwnerOf } from './keyowner.js'
 
 const REGISTRY = 'profiles.json'
 const PWD_ITER = 300000 // PBKDF2 del verificador v1 (heredado); v2 usa scrypt
@@ -52,6 +54,25 @@ const PWD_MIN = 12
  */
 const TRIES_FORGET_MS = 15 * 60 * 1000
 
+/**
+ * BLOQUEO AUTOMÁTICO. Cuánto aguanta abierto el candado sin que nadie lo use.
+ *
+ * Abrir la bóveda dejaba la consola abierta hasta que alguien la cerraba a mano o
+ * reiniciaba el servicio — y el servicio de un PC de escritorio no se reinicia en semanas.
+ * O sea que teclear la contraseña una vez un lunes dejaba la máquina administrable para
+ * quien pasara por delante el jueves. Un candado que solo se cierra reiniciando no es un
+ * candado.
+ *
+ * El plazo se cuenta desde el ÚLTIMO USO (`touch`), no desde que se abrió: quien está
+ * trabajando no se queda fuera a media faena, y quien se levanta de la silla lo encuentra
+ * cerrado. Y vence solo, sin temporizador: se mira la hora al preguntar (`isOpen`), así
+ * que no hay nada que limpiar ni un `setTimeout` que mantenga vivo al proceso.
+ *
+ * Como todo el candado, esto es de la CONSOLA: al vencer, los aparatos ya emparejados
+ * siguen firmando, leyendo y guardando. Lo que se cierra es administrar y mirar.
+ */
+const AUTO_LOCK_MS = 5 * 60 * 1000
+
 /**
  * Archivos de un perfil que en la versión mono-perfil vivían sueltos en la raíz.
  *
@@ -88,10 +109,25 @@ async function derivePwd (password, saltB64, iter) {
   return b64(bits)
 }
 
-const newId = () => 'p' + crypto.randomUUID().slice(0, 8)
+/**
+ * El nombre de la carpeta DE PASO, la que existe solo mientras se acuña la llave.
+ *
+ * La llave se genera antes de escribirse (`crypto.subtle.generateKey` y luego el kv), pero
+ * la única API que tenemos —`Identity.connect({ dir })`— recibe la carpeta por delante y
+ * hace las dos cosas de un tirón: no hay costura donde meterse a preguntar la huella. Así
+ * que se acuña aquí y en cuanto se sabe de quién es, la carpeta se MUEVE a su nombre.
+ * El punto delante la deja fuera de la lista de perfiles si algo se corta a medias.
+ */
+const stagingName = () => '.new-' + crypto.randomUUID().slice(0, 8)
 const cleanName = (name) => String(name || '').slice(0, MAX_NAME)
 
-export function openProfiles (root = dataDir()) {
+/**
+ * @param {string} root  dir de datos
+ * @param {{ autoLockMs?: number, onAutoLock?: (id: string) => void }} [opts]
+ *   `autoLockMs`: 0 desactiva el bloqueo automático (las pruebas lo acortan).
+ *   `onAutoLock`: se avisa cuando un perfil se cierra solo, para poder decirlo en el log.
+ */
+export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onAutoLock = null } = {}) {
   const file = path.join(root, REGISTRY)
   // CIFRADO EN REPOSO, como todo lo demás. Era el único archivo del vault sin códec, y
   // lleva dentro el verificador del candado. No protege de quien tenga el disco entero
@@ -100,15 +136,46 @@ export function openProfiles (root = dataDir()) {
   // respaldo o en una carpeta compartida por descuido, que es lo que el códec cubre
   // para el resto. La migración verifica antes de reemplazar y es de una sola vez.
   ensureDir(root)
-  try { migrateFile(file, machineKey(root)) } catch (_) {}
+  // LA RAÍZ TAMBIÉN NECESITA EL PROVEEDOR DEL ENTORNO, y esto lo destapó un contenedor:
+  // los perfiles nacían con la clave en el KMS, pero el REGISTRO de perfiles seguía con
+  // la de la máquina — así que al recrear el contenedor la bóveda no arrancaba igual,
+  // solo que fallando un paso antes. No guarda el contenido de ningún perfil (la lista y
+  // el verificador del candado), pero sin él no hay bóveda.
+  //
+  // Solo si está por estrenar: si el registro ya existe cifrado con la clave de antes,
+  // cambiarle el proveedor lo dejaría ilegible. Ahí se migra con `atrest rekey`.
+  if (!fs.existsSync(path.join(root, 'atrest.json'))) {
+    const kek = configFromEnv()
+    if (kek && !fs.existsSync(file)) {
+      probeKek(root, kek)
+      writeKekConfig(root, kek)
+    }
+  }
+  try { migrateFile(file, kekFor(root)) } catch (_) {}
   const atRest = atRestFor(root)
   let data = readJson(file, null, atRest)
   if (!data || !Array.isArray(data.profiles)) data = { v: 1, current: null, profiles: [] }
   const save = () => writeJson(file, data, atRest)
 
   // Perfiles DESBLOQUEADOS en esta ejecución del daemon (en memoria: un reinicio
-  // vuelve a bloquear, igual que cerrar la pestaña en el navegador).
-  const unlocked = new Set()
+  // vuelve a bloquear, igual que cerrar la pestaña en el navegador), cada uno con la
+  // hora a la que se cierra solo si nadie lo usa (ver AUTO_LOCK_MS).
+  const unlocked = new Map() // id -> vence (ms epoch)
+
+  /** ¿Sigue abierto? Vence al MIRARLO, así que no hace falta ningún temporizador. */
+  const isOpen = (id) => {
+    const until = unlocked.get(id)
+    if (until == null) return false
+    if (autoLockMs > 0 && Date.now() >= until) {
+      unlocked.delete(id)
+      // El aviso va después de borrarlo: quien lo escuche verá el perfil ya cerrado.
+      try { onAutoLock?.(id) } catch (_) {}
+      return false
+    }
+    return true
+  }
+  /** Abre (o estira) el plazo. Todo lo que abre el candado pasa por aquí. */
+  const open = (id) => { unlocked.set(id, Date.now() + (autoLockMs > 0 ? autoLockMs : Number.MAX_SAFE_INTEGER)) }
 
   const find = (id) => data.profiles.find((p) => p.id === id) || null
   const dirOf = (id) => path.join(root, 'p', id)
@@ -118,7 +185,10 @@ export function openProfiles (root = dataDir()) {
     name: p.name || '',
     createdAt: p.createdAt || null,
     protected: !!p.pwd,
-    locked: !!p.pwd && !unlocked.has(p.id),
+    locked: !!p.pwd && !isOpen(p.id),
+    // Hasta cuándo sigue abierto si nadie lo toca. Es DATO: la consola lo enseña para
+    // que el cierre no llegue por sorpresa.
+    ...(p.pwd && isOpen(p.id) && autoLockMs > 0 ? { until: unlocked.get(p.id) } : {}),
     current: p.id === data.current,
     // Nació para adoptar la cuenta de un aparato (camino A) y todavía no lo ha hecho.
     ...(p.adopt ? { adopt: true } : {})
@@ -148,6 +218,13 @@ export function openProfiles (root = dataDir()) {
       const hits = data.profiles.filter((p) => (p.name || '').toLowerCase() === needle)
       if (hits.length === 1) return hits[0].id
       if (hits.length > 1) throw new Error(`there are ${hits.length} profiles named "${ref}"; use its id (dotrino-vault profile ls)`)
+      // POR PREFIJO. Desde que el id del perfil es el nombre de su carpeta —y ese sale de
+      // la llave— es largo, y nadie va a teclear 24 caracteres para decir `--profile`. El
+      // trozo que sí se lee y se reconoce es la huella de delante (`0571-465F`), que es la
+      // misma que sale en `members`. Ambiguo se rechaza, no se adivina.
+      const porPrefijo = data.profiles.filter((p) => p.id.toLowerCase().startsWith(needle))
+      if (porPrefijo.length === 1) return porPrefijo[0].id
+      if (porPrefijo.length > 1) throw new Error(`"${ref}" matches ${porPrefijo.length} profiles; give more of the id (dotrino-vault profile ls)`)
       throw new Error('profile does not exist: ' + ref)
     },
 
@@ -157,12 +234,18 @@ export function openProfiles (root = dataDir()) {
      * navegador, que adopta la identidad vieja como «Perfil 1»). `transport.json`
      * se queda en la raíz: es del proceso, no de la identidad.
      */
-    migrate () {
+    async migrate (mintKey) {
       if (data.profiles.length) return null
       const legacy = fs.existsSync(path.join(root, 'identity.json'))
-      const id = newId()
-      const dir = dirOf(id)
-      ensureDir(dir)
+      // EL PROVEEDOR DEL ENTORNO, y SOLO en una instalación nueva. Es lo que hace que un
+      // contenedor levantado con `DOTRINO_KMS_KEY_ID` tenga su primer perfil ya con la
+      // clave en el KMS, sin entrar a configurar nada.
+      //
+      // En una MIGRACIÓN no se toca, y el matiz importa: esos archivos ya están cifrados
+      // con la clave de la máquina, así que ponerles ahora un proveedor distinto los
+      // dejaría ilegibles —el guardia lo pararía, pero el usuario se quedaría con una
+      // bóveda que no arranca tras actualizar—. Ahí se migra con `atrest rekey`, a la vista.
+      const dir = api.stage({ fromEnv: !legacy })
       if (legacy) {
         for (const f of LEGACY_FILES) {
           const from = path.join(root, f)
@@ -173,12 +256,23 @@ export function openProfiles (root = dataDir()) {
           if (/^peers\..+\.json$/.test(f)) { try { fs.renameSync(path.join(root, f), path.join(dir, f)) } catch (_) {} }
         }
       }
-      // «Perfil 1» tanto al migrar como en una instalación nueva: es un nombre que
-      // el dueño puede cambiar, y evita que la CLI salude con «(sin nombre)».
-      data.profiles.push({ id, name: 'Perfil 1', createdAt: Date.now() })
-      data.current = id
-      save()
-      return { id, migrated: legacy }
+      try {
+        // Al migrar, la llave ya existe y esto solo la lee; en una instalación nueva, la crea.
+        const pub = await mintKey(dir)
+        // «Perfil 1» tanto al migrar como en una instalación nueva: es un nombre que
+        // el dueño puede cambiar, y evita que la CLI salude con «(sin nombre)».
+        const p = await api.commit(dir, 'Perfil 1', { pub })
+        data.current = p.id
+        save()
+        return { id: p.id, migrated: legacy }
+      } catch (e) {
+        // En una instalación NUEVA no hay nada que perder y la carpeta de paso se va. En
+        // una MIGRACIÓN sí lo hay —los archivos del dueño ya están dentro—, así que se
+        // queda donde está y se dice en voz alta: borrarla sería borrar su bóveda.
+        if (!legacy) { try { fs.rmSync(dir, { recursive: true, force: true }) } catch (_) {} }
+        else e.message += ` (your data is safe in ${dir}; it could not be given its final name)`
+        throw e
+      }
     },
 
     /**
@@ -189,15 +283,110 @@ export function openProfiles (root = dataDir()) {
      * leería como pisar una cuenta con datos y se rechazaría, que es lo que tiene que
      * pasar cuando nadie lo pidió.
      */
-    add (name, { adopt = false } = {}) {
-      const id = newId()
-      ensureDir(dirOf(id))
+    /**
+     * `kek`: el proveedor de la clave del disco, si el perfil tiene que NACER con él.
+     *
+     * Se escribe aquí y no después porque ese es justo el momento que importa: el
+     * directorio existe y todavía no hay un solo byte dentro. La maestra que genere
+     * `open()` un instante más tarde ya nace bajo esa clave y NUNCA existe bajo otra.
+     *
+     * Migrar un perfil que ya tiene identidad NO da esto, y por eso no se ofrece como
+     * si lo diera: su maestra ya se escribió bajo la clave vieja, y una copia del disco
+     * anterior a la migración la sigue abriendo para siempre. Un perfil con raíz en el
+     * KMS **nace** así (dueño, 2026-08-30).
+     */
+    stage ({ kek = null, fromEnv = true } = {}) {
+      const dir = path.join(root, 'p', stagingName())
+      ensureDir(dir)
+      // Sin `--kms` explícito, manda el entorno: es lo que permite levantar un contenedor
+      // con KMS pasando variables, sin entrar a escribir un JSON dentro. Solo al CREAR:
+      // un perfil que ya existe manda con su `atrest.json`.
+      kek = kek || (fromEnv ? configFromEnv() : null)
+      if (kek) {
+        // Comprobar ANTES de dejar rastro: un KMS que no responde no puede dejar a
+        // medio crear un perfil cuya maestra no se va a poder volver a abrir.
+        try {
+          probeKek(dir, kek)
+          writeKekConfig(dir, kek)
+        } catch (e) {
+          try { fs.rmSync(dir, { recursive: true, force: true }) } catch (_) {}
+          throw e
+        }
+      }
+      return dir
+    },
+
+    /**
+     * La carpeta de paso ya tiene su llave: se le pone SU nombre y entra en el registro.
+     * El `id` del perfil ES el nombre de su carpeta, y sale de la llave (`keyDirName`).
+     */
+    async commit (staging, name, { adopt = false, pub } = {}) {
+      if (!pub) throw new Error('cannot name the folder: the key is missing')
+      const id = await keyDirName(pub)
+      const dest = dirOf(id)
+      // Esa llave ya tiene carpeta. No es un choque de nombres: es la MISMA llave dos
+      // veces, que es justo lo que este esquema existe para que no pase.
+      if (fs.existsSync(dest)) {
+        try { fs.rmSync(staging, { recursive: true, force: true }) } catch (_) {}
+        throw Object.assign(new Error('that key already has a folder here: ' + id), { code: 'key-exists' })
+      }
+      fs.renameSync(staging, dest)
       data.profiles.push({ id, name: cleanName(name), createdAt: Date.now(), ...(adopt ? { adopt: true } : {}) })
       if (!data.current) data.current = id
       save()
       return entry(find(id))
     },
 
+    /**
+     * Crea un perfil entero: hace el sitio, deja que `mintKey` acuñe la llave dentro y
+     * mueve la carpeta a su nombre. `mintKey(dir)` devuelve la pública, y es cosa de quien
+     * llama porque generar una identidad no es asunto del registro.
+     */
+    async add (name, { adopt = false, kek = null, mintKey } = {}) {
+      if (typeof mintKey !== 'function') throw new Error('add() needs mintKey to know whose folder it is')
+      const staging = api.stage({ kek })
+      try {
+        const pub = await mintKey(staging)
+        return await api.commit(staging, name, { adopt, pub })
+      } catch (e) {
+        // Nada a medias: la carpeta de paso se va con el intento fallido.
+        try { fs.rmSync(staging, { recursive: true, force: true }) } catch (_) {}
+        throw e
+      }
+    },
+
+    /**
+     * PONERLE A UNA CARPETA VIEJA EL NOMBRE DE SU LLAVE.
+     *
+     * Es toda la migración: mover la data a la carpeta que le toca. Se hace con la
+     * identidad CERRADA —antes de abrirla—, porque la identidad se queda con la ruta como
+     * texto y renombrar por debajo la deja escribiendo en una carpeta que ya no existe.
+     *
+     * De quién es la carpeta se sabe por la marca (`key.json`); si no la tiene —una
+     * instalación anterior a que existiera— se abre un momento solo para preguntárselo.
+     */
+    async ensureNamedByKey (id, mintKey) {
+      const dir = dirOf(id)
+      if (!fs.existsSync(dir)) return id
+      let pub = keyOwnerOf(dir)
+      if (!pub && typeof mintKey === 'function') {
+        try { pub = await mintKey(dir) } catch (_) { return id }
+      }
+      if (!pub) return id
+      const quiere = await keyDirName(pub)
+      if (quiere === id) return id
+      if (fs.existsSync(dirOf(quiere))) {
+        throw Object.assign(new Error(`cannot rename ${id}: ${quiere} already exists`), { code: 'key-exists' })
+      }
+      fs.renameSync(dir, dirOf(quiere))
+      const p = find(id)
+      if (p) p.id = quiere
+      if (data.current === id) data.current = quiere
+      if (unlocked.has(id)) { unlocked.set(quiere, unlocked.get(id)); unlocked.delete(id) }
+      save()
+      return quiere
+    },
+
     /** Quita la marca de «nació para adoptar» (ya adoptó, o se canceló). */
     clearAdopt (id) {
       const p = find(id)
@@ -231,7 +420,20 @@ export function openProfiles (root = dataDir()) {
     // ----- candado -----
 
     isProtected: (id) => !!find(id)?.pwd,
-    isLocked: (id) => { const p = find(id); return !!p?.pwd && !unlocked.has(id) },
+    isLocked: (id) => { const p = find(id); return !!p?.pwd && !isOpen(id) },
+    /** Cuánto dura abierto el candado sin usarse (ms). 0 = no se cierra solo. */
+    get autoLockMs () { return autoLockMs },
+    /**
+     * «Se acaba de usar»: estira el plazo del bloqueo automático. Lo llama la consola
+     * al atender CADA petición suya, y solo eso cuenta como uso: que un aparato pida su
+     * configuración no abre nada ni alarga nada, porque el candado no es suyo.
+     * Devuelve si el perfil estaba abierto (a uno cerrado no hay nada que estirarle).
+     */
+    touch (id) {
+      if (!isOpen(id)) return false
+      open(id)
+      return true
+    },
     assertUnlocked (id) {
       if (api.isLocked(id)) throw new Error('profile locked: unlock it with your password (dotrino-vault unlock)')
     },
@@ -258,7 +460,7 @@ export function openProfiles (root = dataDir()) {
 
     async unlock (id, password) {
       const p = assertExists(id)
-      if (!p.pwd) { unlocked.add(id); return { ok: true, locked: false } }
+      if (!p.pwd) { open(id); return { ok: true, locked: false } }
       // Freno de fuerza bruta (una contraseña corta se adivina probando): tras 5
       // fallos, espera exponencial (2^n s, tope 5 min) persistida en el registro.
       // Los fallos VIEJOS se olvidan (ver TRIES_FORGET_MS): si desde el último ha pasado
@@ -296,7 +498,7 @@ export function openProfiles (root = dataDir()) {
       }
       delete p.tries
       save()
-      unlocked.add(id)
+      open(id)
       return { ok: true, locked: false }
     },
 
@@ -314,7 +516,7 @@ export function openProfiles (root = dataDir()) {
       p.pwd = { v: 2, salt, verifier: deriveScryptPwd(password, salt) }
       delete p.tries
       save()
-      unlocked.add(id)
+      open(id)
       return entry(p)
     },
 
@@ -324,7 +526,7 @@ export function openProfiles (root = dataDir()) {
       delete p.pwd
       delete p.tries
       save()
-      unlocked.add(id)
+      open(id)
       return entry(p)
     }
   }

package/src/tui/app.js

@@ -492,6 +492,72 @@ async function guard (term, st, msg, fn) {
  */
 const activeLocked = (st) => { const p = activeProfile(st); return !!(p?.protected && p.locked) }
 
+/** Los minutos que el daemon aguanta abierto (viene en `state.json`; 5 por defecto). */
+const autoLockMin = (st) => Math.max(1, Math.round((st.state?.autoLockMs || 5 * 60 * 1000) / 60000))
+
+/**
+ * ¿Alguna de las bóvedas que abrió ESTA sesión se cerró sola?
+ *
+ * El plazo lo lleva el daemon (`profiles.js`), no la TUI: aquí solo se MIRA su foto
+ * (`state.json`, que se reescribe cada dos segundos). Así hay un único reloj y no dos
+ * que se desincronizan — y lo que decida el daemon es lo que manda, porque es quien
+ * atiende.
+ */
+const autoLockedIds = (st) => (st.state?.profiles || [])
+  .filter((p) => p.protected && p.locked && (st.sessionPwd?.has(p.id) || st.unlockedHere?.has(p.id)))
+  .map((p) => p.id)
+
+/**
+ * Cuándo hay que despertar para enterarse. Sin esto la TUI se queda dormida en
+ * `readKey()` hasta la siguiente tecla y seguiría enseñando los aparatos y los nombres
+ * de las variables de una bóveda que el daemon ya cerró. Se suman ~2 s porque la foto
+ * se reescribe cada dos: despertar en el instante justo leería la anterior.
+ */
+function autoLockWakeIn (st, now = Date.now()) {
+  let at = 0
+  for (const p of st.state?.profiles || []) {
+    if (!p.until || !(st.sessionPwd?.has(p.id) || st.unlockedHere?.has(p.id))) continue
+    at = at ? Math.min(at, p.until) : p.until
+  }
+  if (!at) return 0
+  const left = at - now + 2200
+  // El plazo ya pasó y la foto sigue diciendo que está abierta: el daemon no la está
+  // reescribiendo (caído o colgado). Se insiste un rato y luego se deja de despertar, o
+  // la TUI se quedaría dando vueltas contra una foto que no va a cambiar.
+  if (left <= 0) return now - at > 15000 ? 0 : 1000
+  return Math.max(250, left)
+}
+
+/**
+ * BLOQUEO AUTOMÁTICO. Se cerró sola: se OLVIDA su contraseña y se sale de lo que se
+ * estaba mirando (dentro se ven los aparatos, las variables y tus datos, que es justo
+ * lo que el candado tapa).
+ *
+ * Olvidarla es la mitad que importa: sin esto la TUI la seguiría teniendo y la
+ * reabriría sola en cuanto alguien pulsara Enter (ver `reunlockSilently`), así que el
+ * candado del daemon no habría cerrado nada.
+ */
+async function forgetAutoLocked (term, st, api = vc) {
+  const ids = autoLockedIds(st)
+  if (!ids.length) return false
+  for (const id of ids) { st.sessionPwd?.delete(id); st.unlockedHere?.delete(id) }
+  const cur = (st.state?.profiles || []).find((p) => p.current)
+  if (ids.includes(cur?.id) && st.screen !== 'profiles') {
+    // Un modal abierto (una pregunta a medias) también se cierra: quien lo dejó abierto
+    // ya no está delante.
+    st.input = null
+    st.confirm = null
+    st.screen = 'profiles'
+  }
+  // Suelta lo cargado y repinta la lista con el candado ya echado (`refreshAll` no pide
+  // el contenido de una bóveda cerrada).
+  await refreshAll(term, st, api)
+  // El aviso va DESPUÉS del refresco: si no, un tropiezo al refrescar lo pisaría con su
+  // error rojo y el candado se cerraría en silencio.
+  flash(st, L(st).autoLocked(autoLockMin(st)), 'warn')
+  return true
+}
+
 // `api` es `vaultControl` — se recibe para poder probar ESTA función (la que se rompió)
 // sin un daemon detrás, que es donde vive la regla de qué se pide y en qué orden.
 async function refreshAll (term, st, api = vc) {
@@ -1608,14 +1674,23 @@ export async function runTui () {
     while (running) {
       st.state = vc.readState()
       st.daemonUp = vc.daemonAlive()
+      // ¿Se cerró sola mientras nadie miraba? Olvida su contraseña y sal de su contenido.
+      await forgetAutoLocked(term, st)
       // caducar el flash a los ~4 s
       if (st.flash && Date.now() - st.flash.at > 4000) st.flash = null
       render(term, st)
 
-      const tick = (st.screen === 'pairing' || (st.screen === 'devices' && !st.input && !st.confirm)) ? 800 : 0
+      const base = (st.screen === 'pairing' || (st.screen === 'devices' && !st.input && !st.confirm)) ? 800 : 0
+      // Despertar a tiempo del bloqueo automático, además del sondeo de la pantalla.
+      const wake = autoLockWakeIn(st)
+      const tick = base && wake ? Math.min(base, wake) : (base || wake)
       const key = await term.readKey(tick)
 
       if (key.name === 'resize') continue
+      // Un despertar del bloqueo automático no es una tecla: ya se atendió arriba, y las
+      // pantallas que NO esperan `tick` (todas menos aparatos y emparejamiento) no tienen
+      // por qué verlo.
+      if (key.name === 'tick' && st.screen !== 'pairing' && st.screen !== 'devices') continue
       // input/confirm se AWAITan: serializa las ops contra el daemon (ver onInputKey).
       // Ctrl-C dentro de un modal lo CANCELA (no sale); fuera de un modal, sale.
       if (st.input) { await onInputKey(st, key); continue }
@@ -1664,4 +1739,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, activeLocked, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts }
+export const __test = { render, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts }

package/src/tui/i18n.js

@@ -126,6 +126,7 @@ const es = {
   vaultUnlocked: 'Bóveda desbloqueada',
   lockingVault: 'Bloqueando…',
   vaultLocked: 'Bóveda bloqueada',
+  autoLocked: (min) => `Se bloqueó sola tras ${min} min sin usarse · la contraseña se olvidó`,
 
   // dispositivos
   pendingDevice: (id) => ` ⧗ PENDIENTE: ${id}`,
@@ -422,6 +423,7 @@ const en = {
   vaultUnlocked: 'Vault unlocked',
   lockingVault: 'Locking…',
   vaultLocked: 'Vault locked',
+  autoLocked: (min) => `Locked itself after ${min} min idle · the password was forgotten`,
 
   pendingDevice: (id) => ` ⧗ PENDING: ${id}`,
   pendingHint: '  — press A to approve, X to reject',