@dotrino/vaultd 0.142.0 → 0.143.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.142.0",
+  "version": "0.143.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {

package/src/tui/app.js

@@ -160,6 +160,9 @@ function mergeMembersAndCerts (members, issued) {
   })
 }
 
+/** La entrada de bloqueo de un aparato (por su llave), o `null` si no está bloqueado. */
+const blockedOf = (st, pub) => (pub && (st.blocked || []).find((b) => b.pub === pub)) || null
+
 function activeProfile (st) {
   const list = st.profiles?.profiles || []
   return list.find((p) => p.current) || list[0] || null
@@ -388,11 +391,15 @@ function deviceRows (st, t) {
       (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
+    // BLOQUEADO: sigue en el acta pero la bóveda y los agentes no le atienden. Es un
+    // aviso (lo decidió un aprobador o el dueño), así que va en el color de aviso y
+    // delante de todo lo demás: es lo primero que hay que ver de esa fila.
+    const bloq = blockedOf(st, d.sub)
+    const status = (bloq ? t.warn(i.deviceBlocked) + '  ' : '') + (d.noAccess
       ? t.warn(i.deviceNoAccess)
       : d.isMaster
         ? t.muted(i.thisVault)
-        : t.muted('scope:' + shortScope(d.scope)) + '  ' + t.muted('exp:' + fmtExp(d.exp))
+        : t.muted('scope:' + shortScope(d.scope)) + '  ' + t.muted('exp:' + fmtExp(d.exp)))
     const marca = conCambios.has(d.sub) ? t.bold('*') : ' '
     rows.push({ text: `${marca}${t.bold(d.deviceId)}  ${label}${desde}  ${status}${extra}`, sel: true, meta: d })
   }
@@ -909,7 +916,7 @@ async function refreshAll (term, st, api = vc) {
   // Cerrada: no se pide su contenido, y tampoco se enseña un error por mirarla desde
   // fuera. Lo que hubiera cargado se suelta, para no dejar en pantalla lo de antes.
   if (activeLocked(st)) {
-    st.devices = null; st.secrets = null; st.members = []; st.me = undefined; st.capsDrafts = {}
+    st.devices = null; st.secrets = null; st.members = []; st.blocked = []; st.me = undefined; st.capsDrafts = {}
     return
   }
   const r = await guard(term, st, L(st).loading, () => api.snapshot(activeId(st)))
@@ -920,7 +927,7 @@ async function refreshAll (term, st, api = vc) {
   if (secrets) st.secrets = { ns: secrets.ns || {}, dev: Array.isArray(secrets.dev) ? secrets.dev : [] }
   // El ACTA entra en el volcado normal: es de donde sale la lista de dispositivos (ver
   // `mergeMembersAndCerts`). Antes solo se pedía al abrir la pantalla de permisos.
-  if (record) st.members = record.members || []
+  if (record) { st.members = record.members || []; st.blocked = Array.isArray(record.blocked) ? record.blocked : [] }
   if (devices) {
     const issued = (devices.issued || devices.active || devices.delegations || [])
     st.devices = { issued: await Promise.all(issued.map(async (d) => ({ ...d, deviceId: d.sub ? await api.deviceIdOf(d.sub) : '????-????' }))), revoked: devices.revoked || [] }
@@ -939,6 +946,7 @@ async function refreshAll (term, st, api = vc) {
 function applyDump (st, v) {
   st.devices = v
   if (Array.isArray(v?.members)) st.members = v.members
+  if (Array.isArray(v?.blocked)) st.blocked = v.blocked
 }
 
 async function refreshDevices (term, st) {
@@ -1257,6 +1265,20 @@ async function onKeyDevices (term, st, key) {
       },
       onNo: () => { st.confirm = null }
     })
+  } else if (ch === 'b' && cur?.isMaster) {
+    flash(st, i.cantBlockMaster, 'warn')
+  } else if (ch === 'b' && cur?.sub) {
+    // BLOQUEAR / DESBLOQUEAR (dueño, 2026-10-07). No toca el acta: el aparato sigue siendo
+    // miembro, pero la bóveda y los agentes no le atienden hasta que se le quite. Lo normal
+    // es que bloquee el aprobador desde el teléfono al recibir un incidente; desbloquear
+    // SOLO se hace aquí o desde la consola de administración. `b` = bloquear en Bóvedas
+    // también (k bloquea el perfil; esto es otro candado y otra tecla, para no confundir).
+    const on = !blockedOf(st, cur.sub)
+    const r = await guard(term, st, on ? i.blocking : i.unblocking, () => vc.setDeviceBlocked(cur.sub, on, activeId(st)))
+    if (r.ok) {
+      flash(st, on ? i.deviceBlockedMsg(cur.deviceId) : (r.v.was ? i.deviceUnblockedMsg(cur.deviceId) : i.deviceNotBlocked(cur.deviceId)))
+      await refreshDevices(term, st)
+    }
   } else if (ch === 'r' && cur) {
     // Renombrar: el nombre lo trae el aparato al emparejarse (y si no le diste uno, entra
     // con TU apodo de ese momento), así que a la semana ya no dice nada. `r` es renombrar
@@ -2298,8 +2320,11 @@ const helpSegs = (i, screen, st = {}) => {
   return segs({
     pending: !!st.pending,
     drafts: draftChanges(st).length > 0,
-    hasDevices: (st.devices?.issued || []).length > 0,
+    // Las filas salen del ACTA (miembros con o sin certificado), así que la ayuda mira
+    // la lista fundida: un miembro sin papel también se renombra, bloquea o quita.
+    hasDevices: devs.length > 0,
     isService: !!cur?.cn,
+    curBlocked: !!blockedOf(st, cur?.sub),
     hasSecrets: Object.keys(st.secrets?.ns || {}).length > 0,
     hasVars: devVarsOf(st, st.varsFor?.pub).length > 0,
     hasLogins: (st.logins || []).length > 0,
@@ -2528,6 +2553,7 @@ export async function runTui () {
     scroll: {},
     profiles: null,
     devices: null,
+    blocked: [],
     secrets: null,
     // Los inicios de sesión se piden al ENTRAR en su pestaña, no al arrancar.
     logins: null,

package/src/tui/i18n.js

@@ -280,6 +280,14 @@ const es = {
   revokeConfirm: (id) => `¿Quitar ${id} del perfil? Pierde el acceso ahora mismo. Lo que tenga guardado se le borra cuando se conecte: si está apagado, sigue ahí hasta entonces.`,
   revoking: 'Revocando…',
   deviceRevoked: (id) => `Revocado ${id}`,
+  // BLOQUEAR sin quitar: sigue en la cuenta, pero nadie le atiende hasta desbloquearlo.
+  deviceBlocked: 'BLOQUEADO',
+  blocking: 'Bloqueando…',
+  unblocking: 'Desbloqueando…',
+  deviceBlockedMsg: (id) => `Bloqueado ${id}: la bóveda y tus máquinas no le atienden hasta que lo desbloquees (b)`,
+  deviceUnblockedMsg: (id) => `Desbloqueado ${id}`,
+  deviceNotBlocked: (id) => `${id} no estaba bloqueado`,
+  cantBlockMaster: 'La bóveda no se bloquea a sí misma.',
   approveLabel: (id) => `Código que MUESTRA el dispositivo ${id}`,
   approveHint: 'el vault no lo conoce: compáralo en la otra pantalla',
   codeMissing: 'Falta el código',
@@ -411,13 +419,13 @@ const es = {
   // Anunciar teclas muertas confunde y además las quema para otros usos.
   // `e variables` solo en un SERVICIO: es el único que las lee, así que en un teléfono
   // era una tecla que solo sabía decir que no.
-  helpDevices: ({ pending, hasDevices, isService, drafts } = {}) => [
+  helpDevices: ({ pending, hasDevices, isService, drafts, curBlocked } = {}) => [
     '←→ pestaña', '↑↓', 'p emparejar',
     ...(drafts ? ['g guardar permisos'] : []),
     ...(pending ? ['a aprobar', 'x rechazar'] : []),
     ...(hasDevices ? ['r renombrar', 'c permisos'] : []),
     ...(isService ? ['e variables'] : []),
-    ...(hasDevices ? ['v revocar'] : []),
+    ...(hasDevices ? [curBlocked ? 'b desbloquear' : 'b bloquear', 'v revocar'] : []),
     'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'
   ],
   renameDeviceLabel: (id) => `¿Cómo quieres llamar a ${id}?`,
@@ -718,6 +726,13 @@ const en = {
   revokeConfirm: (id) => `Remove ${id} from the profile? It loses access right away. What it has stored is erased when it connects: if it is switched off, it stays there until then.`,
   revoking: 'Revoking…',
   deviceRevoked: (id) => `Revoked ${id}`,
+  deviceBlocked: 'BLOCKED',
+  blocking: 'Blocking…',
+  unblocking: 'Unblocking…',
+  deviceBlockedMsg: (id) => `Blocked ${id}: the vault and your machines ignore it until you unblock it (b)`,
+  deviceUnblockedMsg: (id) => `Unblocked ${id}`,
+  deviceNotBlocked: (id) => `${id} was not blocked`,
+  cantBlockMaster: 'The vault does not block itself.',
   approveLabel: (id) => `Code SHOWN by device ${id}`,
   approveHint: 'the vault does not know it: compare it on the other screen',
   codeMissing: 'The code is missing',
@@ -827,13 +842,13 @@ const en = {
   helpConfirm: 'y confirm · n/Esc cancel',
 
   helpProfiles: ['↑↓', 'Enter open', 'p pair', 'j join', 'n new', 'r rename', 'd delete', 'c password', 'x drop-password', 'y keys', 'u unlock', 'k lock', 'l Español', 'q quit'],
-  helpDevices: ({ pending, hasDevices, isService, drafts } = {}) => [
+  helpDevices: ({ pending, hasDevices, isService, drafts, curBlocked } = {}) => [
     '←→ tab', '↑↓', 'p pair',
     ...(drafts ? ['g save permissions'] : []),
     ...(pending ? ['a approve', 'x reject'] : []),
     ...(hasDevices ? ['r rename', 'c permissions'] : []),
     ...(isService ? ['e variables'] : []),
-    ...(hasDevices ? ['v revoke'] : []),
+    ...(hasDevices ? [curBlocked ? 'b unblock' : 'b block', 'v revoke'] : []),
     'F5 refresh', 'Esc vaults', 'l Español', 'q quit'
   ],
   renameDeviceLabel: (id) => `What do you want to call ${id}?`,

package/src/vaultControl.js

@@ -44,6 +44,9 @@ const F = {
   approveReq: 'approve-request.json',
   rejectReq: 'reject-request.json',
   revokeReq: 'revoke-request.json',
+  // BLOQUEAR / DESBLOQUEAR un aparato (sin tocar el acta). Mismo par que usa la CLI.
+  blockReq: 'block-request.json',
+  blockRes: 'block.json',
   labelReq: 'label-request.json',
   capsReq: 'caps-request.json',
   capsRes: 'caps.json',
@@ -394,6 +397,8 @@ export async function listDevices (profile) {
     issued: groupCertsByDevice(withIds, revoked),
     revoked,
     members: record?.members || [],
+    // LOS BLOQUEADOS viajan con el acta: quien pinte la lista los marca en su fila.
+    blocked: Array.isArray(record?.blocked) ? record.blocked : [],
     profile: devices.profile || null
   }
 }
@@ -502,6 +507,25 @@ export async function revokeDevice (target, profile) {
   return listDevices(profile)
 }
 
+/**
+ * BLOQUEA o DESBLOQUEA un aparato por su llave `pub`. No toca el acta: sigue siendo
+ * miembro, pero la bóveda y los agentes dejan de atenderle (dueño, 2026-10-07). Funciona
+ * con el perfil cerrado, igual que `dotrino-vault block|unblock`. Devuelve `{ on, was }`:
+ * `was` dice si al desbloquear había algo que quitar.
+ */
+export async function setDeviceBlocked (pub, on, profile) {
+  requireAlive()
+  if (typeof pub !== 'string' || !pub) throw coded('a device key is required', 'BAD_PUB')
+  rm(F.blockRes)
+  const since = Date.now()
+  const id = await writeReq(F.blockReq, { pub, on: !!on }, profile)
+  signalOrCleanup('SIGUSR2', [F.blockReq])
+  const r = await waitFor(F.blockRes, { req: id, since, tries: 40 })
+  if (!r) throw coded('the daemon did not reply', 'NO_REPLY')
+  if (r.ok === false) throw coded(r.error || `could not ${on ? 'block' : 'unblock'} the device`, r.code || 'BLOCK_FAILED')
+  return { on: !!on, was: !!r.was }
+}
+
 // ---------------------------------------------------------------------------
 // Perfil del usuario (lo que sincronizan los dispositivos)
 // ---------------------------------------------------------------------------