@dotrino/vaultd 0.26.2 → 0.38.0

package/src/vaultControl.js

@@ -34,6 +34,7 @@ const F = {
   secretsList: 'secrets-list.json',
   me: 'me.json',
   acta: 'acta.json',
+  approve: 'approve.json',
   // peticiones (las escribe el control; el daemon las consume y borra)
   pairReq: 'pair-request.json',
   approveReq: 'approve-request.json',
@@ -91,14 +92,41 @@ function requireAlive () {
   if (!s || !pidAlive(s.pid)) throw new DaemonDownError()
 }
 
-function writeReq (name, obj, profile) {
-  const body = { ...obj, at: Date.now() }
-  if (profile) body.profile = profile
+/** Contador de peticiones de ESTE proceso: junto al pid, identifica cada una. */
+let reqSeq = 0
+
+/**
+ * Escribe una petición y devuelve su `id`.
+ *
+ * ESPERA A QUE EL DAEMON SE HAYA LLEVADO LA ANTERIOR. Cada tipo de petición es UN
+ * archivo con nombre fijo, así que escribir la siguiente antes de que se consuma la
+ * primera la BORRABA sin que nadie se enterara. Es exactamente lo que le pasaba al
+ * candado: la TUI manda `unlock` y, pegado, el `list` para repintar; si el daemon
+ * estaba ocupado, el `list` se comía el `unlock` —contraseña incluida— y la bóveda
+ * seguía cerrada sin un solo error por ninguna parte. Se vuelve a preguntar la
+ * contraseña, y otra vez lo mismo.
+ */
+async function writeReq (name, obj, profile) {
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
-  fs.writeFileSync(p(name), JSON.stringify(body), { mode: 0o600 })
+  // Hasta 3 s por la anterior; pasado eso, se pisa (el daemon no la va a atender ya, y
+  // dejar a quien pide esperando para siempre es peor).
+  for (let i = 0; i < 30 && fs.existsSync(p(name)); i++) await sleep(100)
+  const id = `${process.pid}-${++reqSeq}`
+  const body = { ...obj, id, at: Date.now() }
+  if (profile) body.profile = profile
+  // ATÓMICO (escribir aparte y renombrar), y no por manía: el daemon vigila esta carpeta
+  // con `fs.watch`, que avisa al CREAR el archivo — no al terminar de escribirlo. Escrito
+  // en el sitio, el daemon podía leerlo a medias, y como una petición sin `id` no es de
+  // nadie, se perdía: quien la había pedido esperaba seis segundos y leía «el daemon no
+  // respondió», con el daemon sano. `rename` es atómico dentro del mismo sistema de
+  // archivos, así que el vigilante o no ve nada, o ve la petición ENTERA.
+  const tmp = p(name) + '.tmp'
+  fs.writeFileSync(tmp, JSON.stringify(body), { mode: 0o600 })
+  fs.renameSync(tmp, p(name))
   // `mode` de writeFileSync solo aplica al CREAR: re-chmod por si el archivo ya
   // existía con permisos más laxos (defensa en profundidad; el dir ya es 0700).
   try { fs.chmodSync(p(name), 0o600) } catch (_) {}
+  return id
 }
 
 /**
@@ -126,12 +154,39 @@ function signalOrCleanup (sig, reqFiles) {
   try { signal(sig) } catch (e) { for (const f of reqFiles) rm(f); throw e }
 }
 
-/** Espera a que reaparezca un archivo de respuesta (con `.at`) tras borrarlo. */
-async function waitFor (name, { tries = 60, interval = 100 } = {}) {
+/**
+ * EL CANDADO, del lado de quien pregunta. El daemon contesta los volcados de un perfil
+ * bloqueado con `locked: true` y sin contenido; aquí eso se convierte en un error con
+ * código para que la CLI y la TUI digan lo mismo: hay que desbloquearlo, y no es que la
+ * bóveda esté vacía o rota.
+ */
+function assertOpen (d) {
+  if (d?.locked) throw coded('profile locked: unlock it with your password (dotrino-vault unlock)', 'PROFILE_LOCKED')
+  return d
+}
+
+/**
+ * Espera a que reaparezca un archivo de respuesta (con `.at`) tras borrarlo.
+ *
+ * Con `req`, solo vale LA RESPUESTA A ESA PETICIÓN (el daemon devuelve el `id` en
+ * `req`). El daemon vuelca la lista de perfiles también por su cuenta —cada repaso, y
+ * al atender cualquier otra cosa—, así que sin esto se podía tomar por respuesta un
+ * volcado de hace un instante, escrito ANTES de que la petición se atendiera: el
+ * `unlock` contestaba con la foto de cuando aún estaba cerrada.
+ *
+ * Un daemon viejo no devuelve `req`: entonces vale cualquier volcado posterior a la
+ * petición (que es lo que se hacía siempre, y sigue siendo mejor que nada).
+ */
+async function waitFor (name, { tries = 60, interval = 100, req = null, since = 0 } = {}) {
   for (let i = 0; i < tries; i++) {
     await sleep(interval)
     const d = read(name, null)
-    if (d && d.at) return d
+    if (!d || !d.at || d.at < since) continue
+    if (!req || d.req === req) return d
+    // Un daemon viejo NO trae el campo. Que venga con `null` significa lo contrario: el
+    // daemon sabe marcarlas y este volcado no contesta a nadie (es uno de los suyos), así
+    // que se sigue esperando el que sí lleva nuestro id.
+    if (!('req' in d)) return d
   }
   return null
 }
@@ -151,11 +206,14 @@ async function profileOp (op, { profile, name, password } = {}) {
   const extra = {}
   if (name != null) extra.name = name
   if (password != null) extra.password = password
-  writeReq(F.profileReq, { op, ...extra }, profile)
+  const since = Date.now()
+  const id = await writeReq(F.profileReq, { op, ...extra }, profile)
   signalOrCleanup('SIGUSR2', [F.profileReq])
-  const d = await waitFor(F.profilesList)
+  const d = await waitFor(F.profilesList, { req: id, since })
   if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
-  if (d.error) throw coded(d.error, d.code) // p.ej. MASTER_WITH_MEMBERS (freno D12)
+  // p.ej. MASTER_WITH_MEMBERS (freno D12) o WRONG_PASSWORD. Los datos del error viajan
+  // pegados (cuánto hay que esperar, cuántos intentos van): quien lo pinta los necesita.
+  if (d.error) throw Object.assign(coded(d.error, d.code), { waitSec: d.waitSec, tries: d.tries })
   return d // { profiles:[{id,name,protected,locked,current,fingerprint,iss,createdAt}], current, done? }
 }
 
@@ -179,17 +237,30 @@ export const removeProfilePassword = (profile) => profileOp('password-rm', { pro
  */
 export async function snapshot (profile) {
   requireAlive()
-  rm(F.devices); rm(F.secretsList); rm(F.profilesList); rm(F.acta)
-  writeReq(F.dumpReq, {}, profile)
+  rm(F.devices); rm(F.secretsList); rm(F.acta)
+  const since = Date.now()
+  const id = await writeReq(F.dumpReq, {}, profile)
   signalOrCleanup('SIGUSR2', [F.dumpReq])
   // El ACTA entra en el volcado normal: es la lista de dispositivos de verdad, y las
   // delegaciones son su reflejo. Sin ella, un miembro sin certificados (revocado a medias,
   // o con el papel caducado) no salía en ninguna pantalla del PC — invisible y, por lo
   // tanto, imposible de quitar desde aquí.
-  const [devices, secrets, profiles, acta] = await Promise.all([
-    waitFor(F.devices), waitFor(F.secretsList), waitFor(F.profilesList), waitFor(F.acta)
+  const [devices, secrets, record] = await Promise.all([
+    waitFor(F.devices, { req: id, since }), waitFor(F.secretsList, { req: id, since }),
+    waitFor(F.acta, { req: id, since })
   ])
-  return { devices, secrets, profiles, acta }
+  // El volcado de variables lleva el valor de las PÚBLICAS, así que se borra en cuanto se
+  // tiene: en la memoria de quien lo pidió, no esperando en el disco a que copien la
+  // carpeta (ahí es donde el cifrado en reposo dejaría de servir de nada).
+  rm(F.secretsList)
+  assertOpen(devices); assertOpen(secrets); assertOpen(record)
+  // LA LISTA DE BÓVEDAS NO SE ESPERA AQUÍ. `profiles-list.json` es la respuesta a una
+  // petición de PERFIL (`dumpProfiles`), y el daemon dejó de volcarlo por su cuenta —
+  // volcarlo sin que nadie preguntara se llevaba por delante las respuestas de verdad.
+  // Seguir esperándolo aquí era esperar seis segundos, los de rendirse, a un archivo que
+  // ya no iba a llegar: CADA refresco de la TUI costaba eso, con el daemon contestando lo
+  // suyo en 100 ms. Quien necesita la lista llama a `listProfiles()`, que sí la pide.
+  return { devices, secrets, record, profiles: read(F.profilesList, null) }
 }
 
 /**
@@ -197,7 +268,7 @@ export async function snapshot (profile) {
  * `issued` viene de identity.listDelegations(); el deviceId se deriva del `sub`.
  */
 export async function listDevices (profile) {
-  const { devices, acta } = await snapshot(profile)
+  const { devices, record } = await snapshot(profile)
   if (!devices) throw coded('the daemon did not reply', 'NO_REPLY')
   const issued = devices.issued || devices.active || devices.delegations || []
   const revoked = devices.revoked || []
@@ -208,9 +279,9 @@ export async function listDevices (profile) {
   // certificados son su reflejo. Quien pinte la lista los necesita a la vez, o acaba
   // enseñando solo a los que tienen papel — y el que hay que quitar es justo el que no.
   return {
-    issued: agruparPorAparato(withIds, revoked),
+    issued: groupCertsByDevice(withIds, revoked),
     revoked,
-    members: acta?.members || [],
+    members: record?.members || [],
     profile: devices.profile || null
   }
 }
@@ -224,20 +295,20 @@ export async function listDevices (profile) {
  * como «enrolados». Se agrupa por llave, se queda el más nuevo y se guardan TODOS sus
  * nonces, que es lo que hace falta para retirarlo entero.
  */
-export function agruparPorAparato (lista, revoked = []) {
-  const fuera = new Set(revoked.map((r) => r?.nonce || r))
-  const porLlave = new Map()
-  for (const d of lista) {
-    if (d.revokedAt || fuera.has(d.nonce)) continue
-    const clave = d.sub || d.nonce
-    const y = porLlave.get(clave)
-    if (!y) porLlave.set(clave, { ...d, nonces: [d.nonce] })
+export function groupCertsByDevice (list, revoked = []) {
+  const out = new Set(revoked.map((r) => r?.nonce || r))
+  const byKey = new Map()
+  for (const d of list) {
+    if (d.revokedAt || out.has(d.nonce)) continue
+    const key = d.sub || d.nonce
+    const y = byKey.get(key)
+    if (!y) byKey.set(key, { ...d, nonces: [d.nonce] })
     else {
       y.nonces.push(d.nonce)
       if ((d.exp || 0) > (y.exp || 0)) Object.assign(y, { ...d, nonces: y.nonces })
     }
   }
-  return [...porLlave.values()]
+  return [...byKey.values()]
 }
 
 /**
@@ -246,7 +317,7 @@ export function agruparPorAparato (lista, revoked = []) {
  */
 export async function setDeviceLabel (pub, label, profile) {
   requireAlive()
-  writeReq(F.labelReq, { pub, label }, profile)
+  await writeReq(F.labelReq, { pub, label }, profile)
   signalOrCleanup('SIGUSR2', [F.labelReq])
   await sleep(400)
   return listDevices(profile)
@@ -260,10 +331,12 @@ export async function setDeviceLabel (pub, label, profile) {
 export async function listMembers (profile) {
   requireAlive()
   rm(F.acta)
-  writeReq(F.dumpReq, {}, profile)
+  const since = Date.now()
+  const id = await writeReq(F.dumpReq, {}, profile)
   signalOrCleanup('SIGUSR2', [F.dumpReq])
-  const d = await waitFor(F.acta)
+  const d = await waitFor(F.acta, { req: id, since })
   if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
+  assertOpen(d)
   return d.members || []
 }
 
@@ -277,7 +350,7 @@ export async function listMembers (profile) {
  */
 export async function setDeviceCaps (pub, caps, profile) {
   requireAlive()
-  writeReq(F.capsReq, { pub, caps }, profile)
+  await writeReq(F.capsReq, { pub, caps }, profile)
   signalOrCleanup('SIGUSR2', [F.capsReq])
   await sleep(600)
   return listDevices(profile)
@@ -291,7 +364,7 @@ export async function setDeviceCaps (pub, caps, profile) {
 export async function revokeDevice (target, profile) {
   requireAlive()
   const req = typeof target === 'string' ? { nonce: target } : { sub: target?.sub, nonce: target?.nonce }
-  writeReq(F.revokeReq, req, profile)
+  await writeReq(F.revokeReq, req, profile)
   signalOrCleanup('SIGUSR2', [F.revokeReq])
   await sleep(300)
   return listDevices(profile)
@@ -315,59 +388,160 @@ export async function revokeDevice (target, profile) {
 export async function getMe (profile) {
   requireAlive()
   rm(F.me)
-  writeReq(F.meReq, {}, profile)
+  const since = Date.now()
+  const id = await writeReq(F.meReq, {}, profile)
   signalOrCleanup('SIGUSR2', [F.meReq])
-  const d = await waitFor(F.me)
+  const d = await waitFor(F.me, { req: id, since })
   rm(F.me)
   if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
+  assertOpen(d)
   return d.me || null
 }
 
 
 // ---------------------------------------------------------------------------
-// Secretos: scopes (namespaces) y variables (claves)
+// Variables de entorno: DOS CAJONES
+//
+//   · por SCOPE   (`ns`)  — las comparten todos los aparatos del perfil que sirven
+//                           ese namespace.
+//   · por APARATO (`dev`) — solo las lee ese aparato, y PISAN a las del scope.
+//
+// Las dos listas viajan juntas en el mismo volcado (`secrets-list.json`), así que
+// todas estas funciones devuelven lo mismo: `{ ns, dev }`. Nunca hay valores en
+// ninguna de las dos: el daemon no los expone.
 // ---------------------------------------------------------------------------
 
-/** Scopes→[claves] del perfil (NUNCA los valores; el daemon no los expone). */
+/**
+ * Da forma al volcado: `{ ns: {<scope>: [{key, public}]}, dev: [{pub,id,label,cn,keys,orphan}] }`.
+ * `public` dice si el VALOR puede salir de la máquina de la bóveda hacia la consola remota;
+ * el valor en sí no está aquí ni en ningún volcado.
+ */
+const shapeSecrets = (d) => ({ ns: d?.ns || {}, dev: Array.isArray(d?.dev) ? d.dev : [] })
+
+/** Los dos cajones del perfil (NUNCA los valores). */
 export async function listSecrets (profile) {
   const { secrets } = await snapshot(profile)
   if (!secrets) throw coded('the daemon did not reply', 'NO_REPLY')
-  return secrets.ns || {}
+  return shapeSecrets(secrets)
 }
 
-/** Guarda/actualiza una variable. ns: [a-z0-9-]{1,32}. clave: [A-Z0-9_]{1,64}. */
-export async function setSecret (ns, key, value, profile) {
+/**
+ * Manda una orden de secreto y espera el volcado, comprobando que se aplicó de verdad:
+ * el daemon puede rechazarla (clave inválida, aparato que no es un servicio) y quedarse
+ * callado, y un «guardado» que no guardó nada es la peor forma de fallar en esto.
+ */
+async function secretOp (req, profile, check) {
   requireAlive() // el VALOR es secreto: no escribirlo si el daemon está caído
   rm(F.secretsList)
-  writeReq(F.secretReq, { op: 'set', ns, key, value }, profile)
-  writeReq(F.dumpReq, {}, profile)
+  await writeReq(F.secretReq, req, profile)
+  await writeReq(F.dumpReq, {}, profile)
   signalOrCleanup('SIGUSR2', [F.secretReq, F.dumpReq])
   const d = await waitFor(F.secretsList)
+  rm(F.secretsList) // lleva el valor de las públicas: no se queda en el disco (ver `snapshot`)
   if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
-  if (!(d.ns?.[ns] || []).includes(key)) throw coded('the daemon did not apply the change (check the service logs)', 'NOT_APPLIED')
-  return d.ns
+  assertOpen(d)
+  const out = shapeSecrets(d)
+  check(out)
+  return out
 }
 
-/** Borra una variable. Si era la última del scope, el scope desaparece. */
-export async function deleteSecret (ns, key, profile) {
-  requireAlive()
-  rm(F.secretsList)
-  writeReq(F.secretReq, { op: 'rm', ns, key }, profile)
-  writeReq(F.dumpReq, {}, profile)
-  signalOrCleanup('SIGUSR2', [F.secretReq, F.dumpReq])
-  const d = await waitFor(F.secretsList)
-  if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
-  if ((d.ns?.[ns] || []).includes(key)) throw coded('the daemon did not delete the variable (check the service logs)', 'NOT_DELETED')
-  return d.ns
+const keysOf = (out, pub) => (out.dev.find((x) => x.pub === pub)?.keys) || []
+/** ¿Está esa clave en la lista? Las listas traen `{key, public}`, nunca el valor. */
+const has = (list, key) => (list || []).some((x) => x.key === key)
+const visibilityOf = (list, key) => !!(list || []).find((x) => x.key === key)?.public
+
+/**
+ * Guarda/actualiza una variable de SCOPE. ns: [a-z0-9-]{1,32}. clave: [A-Z0-9_]{1,64}.
+ * `isPublic` opcional: sin decir nada conserva la visibilidad que ya tenía (y una nueva
+ * nace privada, o sea que su valor no sale de la máquina de la bóveda).
+ */
+export function setSecret (ns, key, value, profile, isPublic) {
+  return secretOp({ op: 'set', ns, key, value, ...(isPublic === undefined ? {} : { public: !!isPublic }) }, profile, (out) => {
+    if (!has(out.ns[ns], key)) throw coded('the daemon did not apply the change (check the service logs)', 'NOT_APPLIED')
+  })
+}
+
+/** Borra una variable de SCOPE. Si era la última, el scope desaparece. */
+export function deleteSecret (ns, key, profile) {
+  return secretOp({ op: 'rm', ns, key }, profile, (out) => {
+    if (has(out.ns[ns], key)) throw coded('the daemon did not delete the variable (check the service logs)', 'NOT_DELETED')
+  })
+}
+
+/**
+ * Cambia SOLO quién puede ver el valor: `public` deja que la consola remota lo vea,
+ * `private` lo encierra en esta máquina. No toca el valor (ni hace falta conocerlo).
+ */
+export function setSecretVisibility (ns, key, isPublic, profile) {
+  return secretOp({ op: 'vis', ns, key, public: !!isPublic }, profile, (out) => {
+    if (visibilityOf(out.ns[ns], key) !== !!isPublic) throw coded('the daemon did not apply the change (check the service logs)', 'NOT_APPLIED')
+  })
+}
+
+export function setDeviceSecretVisibility (pub, key, isPublic, profile) {
+  return secretOp({ op: 'dev-vis', pub, key, public: !!isPublic }, profile, (out) => {
+    if (visibilityOf(keysOf(out, pub), key) !== !!isPublic) throw coded('the daemon did not apply the change (check the service logs)', 'NOT_APPLIED')
+  })
+}
+
+/**
+ * CARGA VARIAS DE UNA VEZ: un solo viaje al daemon, un solo guardado y —lo que de
+ * verdad importa— UN solo aviso a los servicios de ese scope.
+ *
+ * De una en una, cada variable es un cambio de configuración: el servicio obedece el
+ * primero, sale, lo levanta su supervisor y arranca con lo que hubiera puesto en ese
+ * momento, mientras quien administra sigue escribiendo el resto. Por eso cargar
+ * configuración tiene que llegar entera hasta abajo, y no romperse en N órdenes.
+ *
+ * @param {Array<{op:'set'|'rm', key:string, value?:string, public?:boolean}>} items
+ */
+export function applySecrets (ns, items, profile) {
+  return secretOp({ op: 'batch', ns, items }, profile, (out) => {
+    const missing = items.find((it) => (it.op === 'rm' ? has(out.ns[ns], it.key) : !has(out.ns[ns], it.key)))
+    if (missing) throw coded('the daemon did not apply the change (check the service logs)', 'NOT_APPLIED')
+  })
+}
+
+/** Lo mismo para el cajón de UN aparato. */
+export function applyDeviceSecrets (pub, items, profile) {
+  return secretOp({ op: 'batch', pub, items }, profile, (out) => {
+    const missing = items.find((it) => (it.op === 'rm' ? has(keysOf(out, pub), it.key) : !has(keysOf(out, pub), it.key)))
+    if (missing) throw coded('the daemon did not apply the change (check the service logs)', 'NOT_APPLIED')
+  })
 }
 
-/** Borra un scope entero (todas sus variables, una por una). */
+/** Borra un scope entero: todas sus variables juntas, para no avisar una vez por variable. */
 export async function deleteScope (ns, profile) {
-  const all = await listSecrets(profile)
-  const keys = all[ns] || []
-  let ns2 = all
-  for (const k of keys) ns2 = await deleteSecret(ns, k, profile)
-  return ns2
+  const out = await listSecrets(profile)
+  const keys = (out.ns[ns] || []).map(({ key }) => ({ op: 'rm', key }))
+  if (!keys.length) return out
+  return applySecrets(ns, keys, profile)
+}
+
+/**
+ * Guarda/actualiza una variable de UN APARATO, identificado por su llave (`pub`, la
+ * misma que trae el acta). Solo la lee ese aparato, y le gana a la del scope con el
+ * mismo nombre.
+ */
+export function setDeviceSecret (pub, key, value, profile, isPublic) {
+  return secretOp({ op: 'dev-set', pub, key, value, ...(isPublic === undefined ? {} : { public: !!isPublic }) }, profile, (out) => {
+    if (!has(keysOf(out, pub), key)) throw coded('the daemon did not apply the change (check the service logs)', 'NOT_APPLIED')
+  })
+}
+
+/** Borra una variable de un aparato. */
+export function deleteDeviceSecret (pub, key, profile) {
+  return secretOp({ op: 'dev-rm', pub, key }, profile, (out) => {
+    if (has(keysOf(out, pub), key)) throw coded('the daemon did not delete the variable (check the service logs)', 'NOT_DELETED')
+  })
+}
+
+/** Borra TODAS las variables de un aparato, juntas (mismo motivo que `deleteScope`). */
+export async function deleteDeviceVars (pub, profile) {
+  const out = await listSecrets(profile)
+  const keys = keysOf(out, pub).map(({ key }) => ({ op: 'rm', key }))
+  if (!keys.length) return out
+  return applyDeviceSecrets(pub, keys, profile)
 }
 
 // ---------------------------------------------------------------------------
@@ -397,11 +571,12 @@ export function pairUrl (qr) {
 export async function startPairing ({ profile, service } = {}) {
   requireAlive()
   rm(F.pair); rm(F.pending)
-  writeReq(F.pairReq, service ? { service } : {}, profile)
+  await writeReq(F.pairReq, service ? { service } : {}, profile)
   signalOrCleanup('SIGUSR1', [F.pairReq])
   for (let i = 0; i < 50; i++) {
     await sleep(100)
     const pr = read(F.pair, null)
+    assertOpen(pr)
     if (pr?.expiresAt > Date.now()) {
       const { url, payload, code } = pairUrl(pr.qr)
       // `profile`/`profileName`: DE QUÉ CUENTA del vault sale este QR. El vault
@@ -426,16 +601,30 @@ export function pendingEnroll () {
  */
 export async function approvePending (code, profile) {
   requireAlive()
-  writeReq(F.approveReq, { code: String(code) }, profile)
+  rm(F.approve)
+  const since = Date.now()
+  const id = await writeReq(F.approveReq, { code: String(code) }, profile)
   signalOrCleanup('SIGUSR2', [F.approveReq])
+  // SE ESPERA LA RESPUESTA. Antes se daba por hecho: con el código equivocado —que la
+  // bóveda rechaza sin firmar nada— la pantalla decía «Dispositivo aprobado» igual, se
+  // olvidaba del pendiente y no había forma de reintentar desde aquí.
+  const r = await waitFor(F.approve, { req: id, since, tries: 40 })
+  // Sin respuesta: un daemon anterior a esto. Se sigue como antes en vez de inventar un
+  // error (el emparejamiento pudo salir bien).
+  if (r && r.ok === false) throw coded(r.error || 'the code does not match', r.code || 'APPROVE_FAILED')
   await sleep(400)
-  return listDevices(profile)
+  // LA LISTA ES UN EXTRA, NO PARTE DE APROBAR. Si el volcado no llega, el aparato ya
+  // entró igual: el certificado se firmó y el acta se selló antes de esto. Dejar que ese
+  // fallo suba convertía un emparejamiento correcto en «el daemon no respondió», que es
+  // lo contrario de lo que pasó — y el dueño se queda sin saber si repetirlo o no.
+  // Se devuelve null y quien llama refresca por su cuenta.
+  try { return await listDevices(profile) } catch (_) { return null }
 }
 
 /** Rechaza el dispositivo pendiente. */
 export async function rejectPending (deviceId, profile) {
   requireAlive()
-  writeReq(F.rejectReq, { deviceId }, profile)
+  await writeReq(F.rejectReq, { deviceId }, profile)
   signalOrCleanup('SIGUSR2', [F.rejectReq])
   await sleep(200)
 }