@dotrino/vaultd 0.26.2 → 0.38.0

package/src/daemon.js

@@ -36,7 +36,7 @@ const rm = (f) => { try { fs.rmSync(f, { force: true }) } catch (_) {} }
  * pid muerto (se cortó la luz) no estorba. Con `DOTRINO_VAULT_DIR` distintos conviven
  * cuantas quieras: lo que colisiona es el directorio, no el programa.
  */
-function comprobarInstanciaUnica (dir) {
+function assertSingleInstance (dir) {
   let s = null
   try { s = JSON.parse(fs.readFileSync(path.join(dir, 'state.json'), 'utf8')) } catch (_) { return }
   const pid = Number(s?.pid)
@@ -52,7 +52,7 @@ function comprobarInstanciaUnica (dir) {
 export async function runDaemon () {
   const dir = dataDir()
   const proxyUrl = process.env.PROXY_URL || 'wss://proxy.dotrino.com'
-  comprobarInstanciaUnica(dir)
+  assertSingleInstance(dir)
 
   const pendingEnrollFile = path.join(dir, 'pending-enroll.json')
   // Cuando un dispositivo pide enrolarse, exponemos su deviceId (y a QUÉ perfil
@@ -79,26 +79,47 @@ export async function runDaemon () {
   }
   writeState()
   const profilesFile = path.join(dir, 'profiles-list.json')
-  const dumpProfiles = (extra = {}) => { writeState(); writeJson(profilesFile, { v: 1, at: Date.now(), current: mgr.currentId(), profiles: mgr.summary(), ...extra }) }
+  // `req: null` VA SIEMPRE, aunque nadie haya pedido nada: el daemon vuelca esta lista
+  // también por su cuenta (cada repaso, y al atender cualquier otra cosa), y quien espera
+  // respuesta tiene que poder distinguir «este volcado no contesta a nadie» de «este
+  // contesta a lo mío». Sin esa marca, un repaso que caía en medio pasaba por respuesta:
+  // el `unlock` se daba por hecho con la foto de cuando aún estaba cerrada, y un
+  // «contraseña incorrecta» se perdía por el camino sin que nadie lo llegara a ver.
+  const dumpProfiles = (extra = {}) => { writeState(); writeJson(profilesFile, { v: 1, at: Date.now(), req: null, current: mgr.currentId(), profiles: mgr.summary(), ...extra }) }
 
   console.log(`dotrino-vault · datos en ${dir} · proxy ${proxyUrl}`)
   for (const p of mgr.summary()) {
     console.log(`perfil ${p.current ? '*' : ' '} ${p.name || '(sin nombre)'} · ${p.id} · ${p.fingerprint}${p.protected ? (p.locked ? ' · 🔒 bloqueado' : ' · 🔓 desbloqueado') : ''}`)
   }
 
-  /** Perfil destino de una petición de la CLI (o el activo si no lo dice). */
+  /**
+   * Perfil destino de una petición de la CLI (o el activo si no lo dice), con su CANDADO.
+   *
+   * EL CANDADO ES DE ESTA CONSOLA. Un perfil con contraseña y bloqueado no se puede ver ni
+   * tocar desde la máquina de la bóveda —ni la lista de aparatos, ni las variables, ni tus
+   * datos, ni emparejar o quitar nada— hasta que alguien teclee la contraseña
+   * (`dotrino-vault unlock`). Lo que NO cambia es el servicio: los aparatos ya emparejados
+   * siguen firmando, leyendo y guardando, porque la bóveda es de ellos tanto como de esta
+   * pantalla. Lo que se protege es la consola, que es donde se administra y donde se mira.
+   */
   const resolveTarget = (req) => {
     try {
       const id = req?.profile ? mgr.resolve(req.profile) : mgr.currentId()
-      return { id, vault: mgr.get(id) }
+      return { id, vault: mgr.get(id), locked: mgr.profiles.isLocked(id) }
     } catch (e) { console.error('[vault] invalid profile in the request:', e.message); return null }
   }
-  const targetOf = (req) => resolveTarget(req)?.vault || null
+  /** La bóveda destino, o `null` si el perfil está bloqueado (la petición no se atiende). */
+  const targetOf = (req) => {
+    const t = resolveTarget(req)
+    if (!t) return null
+    if (t.locked) { console.error('[vault] profile %s is locked: request refused (unlock it to use this console)', t.id); return null }
+    return t.vault
+  }
 
   // --- SIGUSR1: iniciar emparejamiento ---
   const pairFile = path.join(dir, 'pair.json')
   const pairReqFile = path.join(dir, 'pair-request.json')
-  async function atenderEmparejamiento () {
+  async function handlePairingRequest () {
     try {
       rm(pendingEnrollFile)
       // Pairing manual por CLI = gesto explícito del dueño → cert de identidad completo.
@@ -111,12 +132,19 @@ export async function runDaemon () {
       // vault:secrets:<ns> — para enrolar un SERVICIO (proxy, geo…) que lee sus
       // secretos, sin poder firmar como el usuario ni leer sus datos.
       const pairReq = readJsonSafe(pairReqFile); rm(pairReqFile)
+      const locked = resolveTarget(pairReq)
+      if (locked?.locked) {
+        // Se responde por el MISMO archivo que espera quien pidió el QR: si no, se queda
+        // mirando una pantalla vacía hasta que se agote el tiempo, sin saber por qué.
+        writeJson(pairFile, { v: 2, at: Date.now(), profile: locked.id, locked: true })
+        return console.error('[vault] profile %s is locked: pairing refused', locked.id)
+      }
       const vault = targetOf(pairReq)
       if (!vault) return
       const profileId = pairReq?.profile ? mgr.resolve(pairReq.profile) : mgr.currentId()
       const isService = typeof pairReq?.service === 'string' && pairReq.service
       const scope = isService ? ['vault:secrets:' + pairReq.service] : ['vault:sign', 'vault:read', 'vault:store']
-      const label = pairReq?.label || (isService ? 'servicio:' + pairReq.service : 'cli')
+      const label = pairReq?.label || (isService ? 'service:' + pairReq.service : 'cli')
       // `profile`/`profileName`: la CUENTA del vault a la que entra el dispositivo.
       // Con varias bóvedas en el mismo daemon, el QR sale de UNA y quien empareja
       // tiene que verlo (lo muestran la TUI y `dotrino-vault pair`). El nombre viaja
@@ -131,7 +159,7 @@ export async function runDaemon () {
       //               crea uno vacío), o no habría dónde meterla.
       const mode = pairReq?.mode === 'adopt' ? 'adopt' : 'join'
       const { qr, expiresInMs } = await vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode, account: profileName })
-      writeJson(pairFile, { v: 2, qr, expiresAt: Date.now() + expiresInMs, profile: profileId, profileName })
+      writeJson(pairFile, { v: 2, at: Date.now(), qr, expiresAt: Date.now() + expiresInMs, profile: profileId, profileName })
       // El token es un secreto efímero: no debe quedar en disco más allá de su
       // vida. Se borra al VENCER (aquí) y al APROBARSE (abajo, consumido).
       const tok = qr.token
@@ -148,6 +176,7 @@ export async function runDaemon () {
   // --- SIGUSR2: approve / reject / revoke / secretos / perfiles + volcados ---
   const devFile = path.join(dir, 'devices.json')
   const approveReqFile = path.join(dir, 'approve-request.json')
+  const approveFile = path.join(dir, 'approve.json')
   const rejectReqFile = path.join(dir, 'reject-request.json')
   const revokeReqFile = path.join(dir, 'revoke-request.json')
   const secretReqFile = path.join(dir, 'secret-request.json')
@@ -189,15 +218,27 @@ export async function runDaemon () {
     }
   }
 
-  async function atenderPeticiones () {
+  async function handleRequests () {
     try {
       const appr = readJsonSafe(approveReqFile)
       if (appr?.code) {
+        rm(approveReqFile)
+        // EL RESULTADO SE CONTESTA, no solo se anota en el log del servicio. Un código
+        // equivocado NO emite certificado (lo corta `enroll.js`), pero eso se quedaba en
+        // esta consola: quien aprobaba desde la TUI leía «Dispositivo aprobado», el
+        // pendiente desaparecía de la pantalla y el aparato seguía esperando al otro lado
+        // sin que nadie pudiera reintentar.
+        const answer = (extra) => writeJson(approveFile, { v: 1, at: Date.now(), req: appr.id || null, ...extra })
         try {
           const vault = targetOf(appr)
-          const r = await vault.approveDevice(appr.code); rm(pendingEnrollFile); rm(pairFile); console.log('[vault] aprobado %s', r.deviceId)
-        } catch (e) { console.error('[vault] approval failed:', e.message) }
-        rm(approveReqFile)
+          if (!vault) throw Object.assign(new Error('profile locked'), { code: 'PROFILE_LOCKED' })
+          const r = await vault.approveDevice(appr.code); rm(pendingEnrollFile); rm(pairFile)
+          console.log('[vault] aprobado %s', r.deviceId)
+          answer({ ok: true, deviceId: r.deviceId || null })
+        } catch (e) {
+          console.error('[vault] approval failed:', e.message)
+          answer({ ok: false, error: e.message, code: e.code || 'APPROVE_FAILED' })
+        }
       }
       const rej = readJsonSafe(rejectReqFile)
       if (rej?.deviceId) {
@@ -232,53 +273,128 @@ export async function runDaemon () {
         } catch (e) { console.error('[vault] revocation failed:', e.message) }
         rm(revokeReqFile)
       }
-      // Secretos de servicios: `secret set/rm` del CLI. El archivo con el valor
-      // vive un instante en el mismo dir 0700 del vault y se borra al consumir.
+      // Secretos: `secret set/rm` (por SCOPE) y `secret device set/rm` (por APARATO),
+      // del CLI o de la TUI. El archivo con el valor vive un instante en el mismo dir
+      // 0700 del vault y se borra al consumir.
       const sec = readJsonSafe(secretReqFile)
       if (sec?.op) {
         rm(secretReqFile)
         try {
           const vault = targetOf(sec)
-          if (sec.op === 'set') { vault.setSecret(sec.ns, sec.key, sec.value); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
+          // Carga en GRUPO (`secret set ns K=v K2=v2`, `secret import`): todas las
+          // variables entran de una vez y sale UN solo aviso de cambio, para que el
+          // servicio no se reinicie a media carga y arranque con la mitad puesta.
+          if (sec.op === 'batch') {
+            const changed = sec.pub
+              ? await vault.applyDeviceSecrets(sec.pub, sec.items)
+              : vault.applySecrets(sec.ns, sec.items)
+            console.log('[vault] %d secret(s) applied in one go: %s', changed.length, sec.pub ? 'device' : sec.ns)
+          } else if (sec.op === 'set') { vault.setSecret(sec.ns, sec.key, sec.value, sec.public); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
           else if (sec.op === 'rm') { vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
+          else if (sec.op === 'dev-set') { await vault.setDeviceSecret(sec.pub, sec.key, sec.value, sec.public); console.log('[vault] device secret saved: %s', sec.key) }
+          else if (sec.op === 'dev-rm') { await vault.deleteDeviceSecret(sec.pub, sec.key); console.log('[vault] device secret deleted: %s', sec.key) }
+          // Visibilidad: si el valor puede salir hacia la consola remota. No toca el valor.
+          else if (sec.op === 'vis') { vault.setSecretVisibility(sec.ns, sec.key, sec.public); console.log('[vault] secret visibility: %s/%s → %s', sec.ns, sec.key, sec.public ? 'public' : 'private') }
+          else if (sec.op === 'dev-vis') { await vault.setDeviceSecretVisibility(sec.pub, sec.key, sec.public); console.log('[vault] device secret visibility: %s → %s', sec.key, sec.public ? 'public' : 'private') }
         } catch (e) { console.error('[vault] secret failed:', e.message) }
       }
       // Perfiles / candado.
       const preq = readJsonSafe(profileReqFile)
       if (preq?.op) {
         rm(profileReqFile) // lleva la contraseña: fuera del disco cuanto antes
-        let extra = {}
-        try { extra = await handleProfileRequest(preq) }
+        // `req`: el id de la petición viaja de vuelta en el volcado. Sin él, quien
+        // espera podía quedarse con un volcado anterior —el daemon los escribe también
+        // por su cuenta— y dar por contestado lo que aún no se había hecho.
+        let extra = { req: preq.id || null }
+        try { extra = { ...extra, ...(await handleProfileRequest(preq)) } }
         // `code`: la TUI es bilingüe y traduce por código (un freno como el D12 tiene
         // que leerse en el idioma de quien lo lee, no en el del daemon).
-        catch (e) { extra = { error: e.message, ...(e.code ? { code: e.code } : {}) }; console.error('[vault] profile: %s', e.message) }
+        catch (e) {
+          // `waitSec`/`tries` viajan con el error: quien lo enseña necesita el dato, no
+          // solo el motivo («espera 32 s» y «van 9 intentos» son lo que cambia la conducta).
+          extra = { req: preq.id || null, error: e.message, ...(e.code ? { code: e.code } : {}), ...(e.waitSec ? { waitSec: e.waitSec } : {}), ...(e.tries ? { tries: e.tries } : {}) }
+          console.error('[vault] profile: %s', e.message)
+        }
         dumpProfiles(extra)
       } else {
-        dumpProfiles()
+        // NADIE PREGUNTÓ: se refresca el estado, pero NO se pisa `profiles-list.json`.
+        // Ese archivo es la RESPUESTA a una petición, y el daemon repasa su carpeta cada
+        // dos segundos: al volcarlo también sin que nadie lo pidiera, un repaso que caía
+        // entre la respuesta y quien la esperaba se la llevaba por delante. Eso es lo que
+        // hacía que un `unlock` correcto contestara «sigue cerrada» y que un «contraseña
+        // incorrecta» se perdiera sin llegar a verse. Quien lee esta lista —la TUI y el
+        // CLI— siempre pide antes, así que no se queda sin ella.
+        writeState()
+      }
+      // Volcados que lee la CLI (`devices`, `members`, `secret list`) y la TUI. A QUÉ
+      // perfil miran lo dice dump-request.json; sin él, al activo.
+      //
+      // SOLO SI ALGUIEN LOS PIDIÓ. Estos archivos son la RESPUESTA a una petición, igual
+      // que `profiles-list.json` (ver arriba), y el daemon pasa por aquí cada dos segundos
+      // —y otra vez, en el acto, si algo llegó mientras atendía—. Volcarlos también sin que
+      // nadie preguntara se llevaba por delante la respuesta recién escrita: quien esperaba
+      // veía un volcado con `req: null` en vez del suyo, seguía esperando y a los seis
+      // segundos se rendía. Eso era la TUI colgada en «Cargando dispositivos…» y luego «el
+      // daemon no responde» — con el daemon sano y contestando en milisegundos.
+      // NO SE BORRA LO QUE NO SE PUDO LEER. `readJsonSafe` devuelve null tanto si el
+      // archivo no está como si llegó a medias (`fs.watch` avisa al crearlo, no al
+      // terminar de escribirlo), y borrarlo en ese segundo caso destruía la petición: el
+      // que la había pedido esperaba seis segundos y leía «el daemon no respondió», con el
+      // daemon sano y contestando lo demás. Si no parsea se deja donde está y lo recoge el
+      // repaso de 2 s, que es la misma regla que ya tenía la petición de emparejamiento.
+      const dumpReq = readJsonSafe(dumpReqFile)
+      if (dumpReq || !fs.existsSync(dumpReqFile)) rm(dumpReqFile)
+      const meReq = readJsonSafe(meReqFile)
+      if (!dumpReq && !meReq) return
+      const t = resolveTarget(dumpReq || meReq || appr || rej || req || sec || {}) || { id: mgr.currentId(), vault: mgr.current(), locked: false }
+      // El id de la petición vuelve en cada volcado, para que quien espera sepa que le
+      // contestan a ÉL y no lea el volcado de la vuelta anterior (ver `waitFor`).
+      const reqId = dumpReq?.id || null
+      if (t.locked) {
+        // BLOQUEADO: se contesta que lo está, y nada más. Los volcados se escriben igual
+        // (quien pregunta espera una respuesta, no un plantón) pero VACÍOS: ni aparatos, ni
+        // nombres de variables, ni acta. Antes el candado no tapaba ninguna de las tres.
+        const closed = { v: 1, at: Date.now(), req: reqId, profile: t.id, locked: true }
+        if (dumpReq) {
+          writeJson(secretsListFile, { ...closed, ns: {}, dev: [] })
+          writeJson(devFile, { ...closed, issued: [], revoked: [] })
+          writeJson(path.join(dir, 'acta.json'), { ...closed, members: [] })
+        }
+        rm(meReqFile)
+        if (meReq) writeJson(meFile, { ...closed, req: meReq.id || null, me: null })
+        return
+      }
+      if (dumpReq) {
+        // Los DOS cajones: `ns` (por scope, que comparten todos los aparatos del perfil) y
+        // `dev` (las propias de cada aparato). Con el VALOR de las públicas —que es lo que
+        // pública significa— y sin el de las privadas, que no salen del proceso.
+        //
+        // Ese valor queda escrito en claro en este archivo (0600, y quien lo lee lo borra
+        // en cuanto lo tiene). Es material que su dueño marcó como mostrable, y aquí ya
+        // viaja a un navegador; lo que NO puede pasar es que se quede en el disco esperando
+        // a que alguien copie la carpeta, porque eso sí burlaría el cifrado en reposo.
+        writeJson(secretsListFile, {
+          v: 2, at: Date.now(), req: reqId, profile: t.id,
+          ns: t.vault.listSecrets(),
+          dev: await t.vault.listDeviceSecrets()
+        })
+        writeJson(devFile, { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.listDevices()) })
+        // Acta del perfil: quién es del perfil y qué puede hacer cada uno (`members`/`caps`).
+        try { writeJson(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.profileMembers()) }) } catch (_) {}
       }
-      // Volcados que lee la CLI (`devices`, `secret list`). A QUÉ perfil miran lo
-      // dice dump-request.json; sin él, al activo.
-      const dumpReq = readJsonSafe(dumpReqFile); rm(dumpReqFile)
-      const t = resolveTarget(dumpReq || appr || rej || req || sec || {}) || { id: mgr.currentId(), vault: mgr.current() }
-      // Nombres de secretos, nunca valores.
-      writeJson(secretsListFile, { v: 1, at: Date.now(), profile: t.id, ns: t.vault.listSecrets() })
-      writeJson(devFile, { v: 1, at: Date.now(), profile: t.id, ...(await t.vault.listDevices()) })
-      // Acta del perfil: quién es del perfil y qué puede hacer cada uno (`members`/`caps`).
-      try { writeJson(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), profile: t.id, ...(await t.vault.profileMembers()) }) } catch (_) {}
 
       // PERFIL del usuario (apodo, foto, datos) tal como lo tiene la bóveda: `dotrino-vault me`.
       // Solo se vuelca cuando se PIDE, no en cada señal: es contenido del usuario y no tiene
       // por qué quedar escrito en un archivo suelto cada vez que alguien mira los miembros.
       // La FOTO no entra en el volcado (son hasta ~90 KB de data-URI que nadie va a leer en
       // una terminal): solo se dice que la hay, de qué tipo y cuánto pesa.
-      const meReq = readJsonSafe(meReqFile)
       if (meReq) {
         rm(meReqFile)
         try {
           const tm = resolveTarget(meReq) || { id: mgr.currentId(), vault: mgr.current() }
           const { me } = tm.vault.threads.methods.profileGet()
-          const { avatar, ...resto } = me || {}
-          writeJson(meFile, { v: 1, at: Date.now(), profile: tm.id, me: me ? { ...resto, avatar: avatarInfo(avatar) } : null })
+          const { avatar, ...rest } = me || {}
+          writeJson(meFile, { v: 1, at: Date.now(), req: meReq.id || null, profile: tm.id, me: me ? { ...rest, avatar: avatarInfo(avatar) } : null })
         } catch (e) { console.error('[vault] could not dump the profile:', e.message) }
       }
     } catch (e) {
@@ -298,38 +414,44 @@ export async function runDaemon () {
   // sistemas, más un repaso periódico por si el watcher se pierde un evento (pasa en
   // carpetas de red y en algunos montajes). Las señales se mantienen donde existen: no
   // estorban y hacen que la respuesta sea inmediata.
-  const REPASO_MS = 2000
-  let atendiendo = false
-  async function atender () {
-    if (atendiendo) return          // una a la vez: las peticiones se consumen y se borran
-    atendiendo = true
+  const SWEEP_MS = 2000
+  let serving = false
+  let anotherRound = false
+  async function serve () {
+    // Una a la vez (las peticiones se consumen y se borran), pero lo que llegue mientras
+    // tanto NO se pierde: se anota y se da otra vuelta al terminar. Antes se descartaba,
+    // y la petición se quedaba esperando al repaso de 2 s — tiempo de sobra para que
+    // quien pidió escribiera la siguiente encima.
+    if (serving) { anotherRound = true; return }
+    serving = true
     try {
       // OJO: `fs.watch` avisa al CREAR el archivo, antes de que el CLI termine de
       // escribirlo. Si se lee a medias, el JSON no parsea y la petición se pierde con
       // sus datos — y el emparejamiento salía como si fuera de un dispositivo normal,
       // sin el `--service`, emitiendo un cert con el scope equivocado. Así que solo se
       // atiende cuando el archivo YA parsea; si no, lo recoge el repaso de 2 s.
-      if (readJsonSafe(pairReqFile)) await atenderEmparejamiento()
-      await atenderPeticiones()
+      if (readJsonSafe(pairReqFile)) await handlePairingRequest()
+      await handleRequests()
     } catch (e) { console.error('[vault] error serving a request:', e.message) }
-    finally { atendiendo = false }
+    finally { serving = false }
+    if (anotherRound) { anotherRound = false; await serve() }
   }
 
   try {
-    fs.watch(dir, (_ev, file) => { if (!file || /-request\.json$/.test(file)) atender() })
+    fs.watch(dir, (_ev, file) => { if (!file || /-request\.json$/.test(file)) serve() })
   } catch (e) {
     console.error('[vault] could not watch %s (%s); will be served by polling only', dir, e.message)
   }
-  const repaso = setInterval(atender, REPASO_MS)
-  repaso.unref?.()
+  const sweep = setInterval(serve, SWEEP_MS)
+  sweep.unref?.()
 
   // POSIX: la señal sigue valiendo como atajo inmediato. En Windows no existe y no pasa nada.
   // Van por `atender()` y NO llaman directo: si no, la señal y el vigilante corren a la
   // vez, la primera consume la petición y la segunda la lee vacía — y un `pair --service`
   // acababa emitiendo un cert de dispositivo normal, con el scope equivocado.
   if (process.platform !== 'win32') {
-    process.on('SIGUSR1', () => { atender() })
-    process.on('SIGUSR2', () => { atender() })
+    process.on('SIGUSR1', () => { serve() })
+    process.on('SIGUSR2', () => { serve() })
   }
 
   // --- apagado limpio ---

package/src/manager.js

@@ -24,11 +24,11 @@ import { dataDir, ensureDir } from './paths.js'
  */
 export function assertCanRemove ({ isMaster, memberCount, name = '' }) {
   if (!isMaster || memberCount <= 1) return true
-  const otros = memberCount - 1
+  const others = memberCount - 1
   const e = new Error(
-    `la cuenta "${name}" la manda esta bóveda y tiene ${otros} dispositivo(s) más: ` +
-    'pásale primero el mando a uno que esté conectado. Si la borras así, se quedan ' +
-    'con su llave y sin nadie que pueda volver a firmar el acta.'
+    `this vault is the master of account "${name}" and it has ${others} more device(s): ` +
+    'hand the master over to one that is connected first. Deleting it like this leaves them ' +
+    'with their key and nobody able to sign the record again.'
   )
   e.code = 'MASTER_WITH_MEMBERS'
   e.members = memberCount
@@ -114,11 +114,11 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
       // se lleva su llave y su copia, y la cuenta sigue viva donde vive el master.)
       const v = running.get(id)
       if (v) {
-        const [soyMaster, acta] = await Promise.all([
+        const [isMaster, record] = await Promise.all([
           v.isMaster().catch(() => false),
           v.profileMembers().catch(() => ({ members: [] }))
         ])
-        assertCanRemove({ isMaster: soyMaster, memberCount: (acta?.members || []).length, name: profiles.get(id)?.name || id })
+        assertCanRemove({ isMaster, memberCount: (record?.members || []).length, name: profiles.get(id)?.name || id })
       } else {
         log('[vault] profile %s is not open: deleting without being able to check its record', id)
       }

package/src/profiles.js

@@ -28,6 +28,15 @@ const REGISTRY = 'profiles.json'
 const PWD_ITER = 300000 // mismo coste que el candado del navegador
 const MAX_NAME = 40
 
+/**
+ * Cuánto tarda el freno en OLVIDAR los fallos. Sin esto la cuenta solo subía —solo la
+ * borraba un acierto—, así que teclear mal la contraseña cinco veces un martes te dejaba
+ * el vault con esperas de minutos el miércoles, y cada intento nuevo (aunque fuera el
+ * bueno) la alargaba sin llegar a comprobarse: la bóveda quedaba cerrada para su dueño.
+ * El freno tiene que estorbar a una RÁFAGA, no a quien vuelve al día siguiente.
+ */
+const TRIES_FORGET_MS = 15 * 60 * 1000
+
 /**
  * Archivos de un perfil que en la versión mono-perfil vivían sueltos en la raíz.
  *
@@ -97,7 +106,7 @@ export function openProfiles (root = dataDir()) {
       const needle = String(ref).trim().toLowerCase()
       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(`hay ${hits.length} perfiles llamados "${ref}"; usa su id (dotrino-vault profile ls)`)
+      if (hits.length > 1) throw new Error(`there are ${hits.length} profiles named "${ref}"; use its id (dotrino-vault profile ls)`)
       throw new Error('profile does not exist: ' + ref)
     },
 
@@ -191,15 +200,29 @@ export function openProfiles (root = dataDir()) {
       if (!p.pwd) { unlocked.add(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.
-      const tries = p.tries || { n: 0, at: 0 }
+      // Los fallos VIEJOS se olvidan (ver TRIES_FORGET_MS): si desde el último ha pasado
+      // el rato, se empieza de cero. Así el freno sigue frenando una ráfaga —los intentos
+      // seguidos se cuentan igual— pero no convierte un despiste de ayer en un vault que
+      // ya no se abre.
+      let tries = p.tries || { n: 0, at: 0 }
+      if (tries.at && Date.now() - tries.at > TRIES_FORGET_MS) {
+        tries = { n: 0, at: 0 }
+        if (p.tries) { delete p.tries; save() }
+      }
       const waitMs = tries.n >= 5 ? Math.min(2 ** (tries.n - 4) * 1000, 5 * 60 * 1000) : 0
       const left = tries.at + waitMs - Date.now()
-      if (left > 0) throw new Error(`demasiados intentos: espera ${Math.ceil(left / 1000)} s`)
+      // Con CÓDIGO: la TUI es bilingüe y lo traduce, y la CLI puede decirlo con sus
+      // palabras. Sin código, el rechazo llegaba como un texto suelto del daemon y era
+      // indistinguible de «se volvió a pedir la contraseña porque sí».
+      if (left > 0) {
+        throw Object.assign(new Error(`too many tries: wait ${Math.ceil(left / 1000)} s`),
+          { code: 'TOO_MANY_TRIES', waitSec: Math.ceil(left / 1000) })
+      }
       const proof = await derivePwd(password, p.pwd.salt, p.pwd.iter)
       if (proof !== p.pwd.verifier) {
         p.tries = { n: tries.n + 1, at: Date.now() }
         save()
-        throw new Error('wrong password')
+        throw Object.assign(new Error('wrong password'), { code: 'WRONG_PASSWORD', tries: p.tries.n })
       }
       delete p.tries
       save()