@dotrino/vaultd 0.9.0 → 0.10.0

package/lib/src/enroll.js

@@ -42,6 +42,10 @@ export const DEVICE_TTL_MS = 30 * 24 * 60 * 60 * 1000
 export const MSG_ENROLL = 'vault.enroll'
 export const MSG_ENROLL_CHALLENGE = 'vault.enroll.challenge'
 export const MSG_ENROLLED = 'vault.enrolled'
+// --- camino A: la cuenta del aparato pasa a vivir en la bóveda ---
+export const MSG_ENROLL_ADOPT = 'vault.enroll.adopt'
+export const MSG_ACTA_SEALED = 'vault.acta.sealed'
+export const MSG_ACTA_ADOPTED = 'vault.acta.adopted'
 export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
@@ -104,8 +108,11 @@ export async function deviceIdOf (pub) {
 export function createEnrollDesk ({
   identity, iss, proxy, send, sendByPubkey,
   audit = () => {}, log = () => {},
-  onChallenge = () => {}, onPendingChange = () => {},
-  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS
+  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {},
+  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS,
+  // Camino A: lo que ESTA bóveda le manda al aparato para que la meta en su acta. `encPub`
+  // es su llave de CIFRADO — sin ella entra mandando pero sin poder leer el contenido.
+  encPub = null, vaultLabel = ''
 } = {}) {
   if (!identity) throw new Error('createEnrollDesk: falta identity')
   if (!iss) throw new Error('createEnrollDesk: falta iss (pubkey de la maestra)')
@@ -172,6 +179,17 @@ export function createEnrollDesk ({
       return reply(from, { type: MSG_ERROR, error: 'token de emparejamiento inválido o expirado' })
     }
     if (d.sn !== pend.sn) return reply(from, { type: MSG_ERROR, error: 'sesión inválida' })
+    // V7 · la INTENCIÓN viaja firmada y tiene que coincidir con el modo con el que ESTA
+    // bóveda abrió el emparejamiento. Es lo que garantiza que lo que pasa es lo que el
+    // humano vio anunciado en las dos pantallas, y no algo que se decidió a mitad de camino.
+    const intent = d.intent || 'join'
+    if (intent !== 'join' && intent !== 'adopt') {
+      return reply(from, { type: MSG_ERROR, error: 'intención desconocida: ' + intent })
+    }
+    if (intent !== (pend.mode || 'join')) {
+      audit('rejected', { what: 'enroll', reason: 'intent-mismatch' })
+      return reply(from, { type: MSG_ERROR, error: `este emparejamiento se abrió para «${pend.mode || 'join'}» y el dispositivo pidió «${intent}»` })
+    }
     if (!isFresh(d)) {
       audit('rejected', { what: 'enroll', reason: 'stale' })
       return reply(from, { type: MSG_ERROR, error: 'petición vencida: ts fuera de la ventana ±5 min (posible replay, o el reloj del dispositivo está desfasado)' })
@@ -208,9 +226,12 @@ export function createEnrollDesk ({
     }
     pend.from = from // la bóveda NO conoce el código: lo aprende cuando lo tipeas
     if (d.label) pend.label = String(d.label).slice(0, 60)
+    // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
+    // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
+    if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
 
     reply(from, { type: MSG_ENROLL_CHALLENGE, deviceId })
-    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '' })
+    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', mode: pend.mode || 'join' })
     fire(onPendingChange)
     return { deviceId }
   }
@@ -246,6 +267,20 @@ export function createEnrollDesk ({
       throw new Error('el código no coincide con el que muestra el dispositivo: no se emitió ningún certificado. Vuelve a mirarlo y prueba otra vez.')
     }
 
+    // CAMINO A · aquí la bóveda no entrega un cert: entrega SU IDENTIDAD para que el
+    // aparato la meta en el acta de la cuenta que le está pasando. El código de vuelta es
+    // la misma defensa de siempre, en el otro sentido: el aparato solo hace caso a una
+    // bóveda que demuestre que un humano la aprobó.
+    if ((pend.mode || 'join') === 'adopt') {
+      audit('adopt-approve', { device: pend.deviceId, profile: pend.profileId || null })
+      pend.state = 'AWAITING_ACTA'
+      pend.approvedAt = Date.now()
+      reply(pend.from, { type: MSG_ENROLL_ADOPT, code, pub: iss, encPub: encPub || null, label: vaultLabel || '' })
+      log('[vault] adopción aprobada para %s: esperando el acta sellada', pend.deviceId)
+      fire(onPendingChange)
+      return { ok: true, deviceId: pend.deviceId, adopting: true }
+    }
+
     const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
 
     // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
@@ -273,6 +308,60 @@ export function createEnrollDesk ({
     return { ok: true, deviceId: pend.deviceId, cert }
   }
 
+  /**
+   * CAMINO A · paso 6: llega el acta que el aparato acaba de sellar, con la bóveda dentro
+   * como miembro, la clave de contenido envuelta para ella y el mando ya traspasado.
+   *
+   * Lo que se comprueba antes de guardar nada (y por qué):
+   *   · que el sellador sea ESTA bóveda — si no, no es un traspaso, es un acta ajena;
+   *   · que la selle el aparato que estaba en este emparejamiento — cierra que un tercero
+   *     que vea pasar el mensaje cuele la suya;
+   *   · que sea la cuenta que ese aparato declaró al enrolarse (`profileId`) — cierra el
+   *     cambiazo de cuenta entre el anuncio que leyó el humano y lo que llega después.
+   *
+   * Adoptar la cuenta de otro solo procede sobre un perfil que **nació para eso** (la marca
+   * de `prepareForAdoption`). Es la misma regla del navegador: sin la marca, adoptar sería
+   * pisar una cuenta con datos, y eso no puede pasar por accidente.
+   */
+  async function handleActaSealed (from, p) {
+    const acta = p?.acta
+    const pend = [...pending.values()].find((x) => x.state === 'AWAITING_ACTA' && (x.from === from || x.dpub))
+    if (!pend) return reply(from, { type: MSG_ERROR, error: 'no hay ninguna adopción esperando un acta' })
+    if (!acta || typeof acta !== 'object') return reply(from, { type: MSG_ERROR, error: 'acta ausente o ilegible' })
+    if (acta.sealer !== iss) {
+      audit('rejected', { what: 'adopt', reason: 'not-sealer' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta no nombra a esta bóveda como quien manda' })
+    }
+    if (acta.sealedBy !== pend.dpub) {
+      audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta no la selló el dispositivo de este emparejamiento' })
+    }
+    if (pend.profileId && acta.profileId !== pend.profileId) {
+      audit('rejected', { what: 'adopt', reason: 'other-profile' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta es de otra cuenta distinta a la que anunció el dispositivo' })
+    }
+
+    try {
+      const r = await identity.joinProfile(acta)
+      if (!r?.joined) throw new Error(r?.reason || 'no se pudo adoptar')
+      audit('adopt', { device: pend.deviceId, profile: acta.profileId, seq: acta.seq })
+      // El acta que vuelve es la que la bóveda tiene guardada: el aparato la adopta y los
+      // dos quedan en la misma versión.
+      const mia = (await identity.profileActa?.())?.acta || acta
+      reply(pend.from, { type: MSG_ACTA_ADOPTED, code: p.code, acta: mia })
+      pend.state = 'DONE'
+      pending.delete(pend.token)
+      fire(onPendingChange)
+      fire(onAdopted, { deviceId: pend.deviceId, profileId: acta.profileId, seq: mia.seq })
+      log('[vault] cuenta adoptada del dispositivo %s (perfil %s)', pend.deviceId, acta.profileId?.slice(0, 12))
+      return { ok: true, adopted: true, profileId: acta.profileId, seq: mia.seq }
+    } catch (e) {
+      log('[vault] no se pudo adoptar la cuenta: %s', e.message)
+      reply(pend.from, { type: MSG_ERROR, error: 'la bóveda no pudo adoptar la cuenta: ' + e.message })
+      return { ok: false, error: e.message }
+    }
+  }
+
   /** Rechaza un enrolamiento pendiente. */
   function reject (deviceId) {
     const pend = deviceId
@@ -310,7 +399,7 @@ export function createEnrollDesk ({
   }
 
   return {
-    startPairing, stopPairing, handleEnroll, approve, reject,
+    startPairing, stopPairing, handleEnroll, handleActaSealed, approve, reject,
     listPending, findPending, emitRevoke, revoke,
     get pendingCount () { return pending.size }
   }

package/lib/src/protocol.js

@@ -20,6 +20,13 @@ export const MSG = Object.freeze({
   ENROLL: 'vault.enroll',                     // dispositivo → vault: { data, signature }
   ENROLL_CHALLENGE: 'vault.enroll.challenge', // vault → dispositivo: { deviceId, sas }
   ENROLLED: 'vault.enrolled',                 // vault → dispositivo (tras aprobar): { cert, iss, sas }
+  // Camino A (la cuenta del aparato pasa a vivir en la bóveda): en vez de un cert, la
+  // bóveda manda QUIÉN es para que el aparato la admita, le envuelva la clave de
+  // contenido y le traspase el mando; el aparato devuelve el acta sellada y la bóveda
+  // responde con la definitiva. Ver docs/vinculacion-de-cuentas.md §2.
+  ENROLL_ADOPT: 'vault.enroll.adopt',         // vault → dispositivo: { code, pub, encPub, label }
+  ACTA_SEALED: 'vault.acta.sealed',           // dispositivo → vault: { acta, code }
+  ACTA_ADOPTED: 'vault.acta.adopted',         // vault → dispositivo: { acta }
   REVOKED: 'vault.revoked',                   // vault → dispositivo: { body:{op,sub,nonce,iat,exp}, signature }
   SIGN: 'vault.sign',                         // dispositivo → vault: { data, signature, cert }
   SIGNED: 'vault.signed',                     // vault → dispositivo: { signature, publickey, device }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.9.0",
+  "version": "0.10.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": {
@@ -19,7 +19,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.34.0",
+    "@dotrino/identity": "^0.35.0",
     "@dotrino/proxy-client": "0.8.0",
     "ws": "^8.18.0"
   },

package/src/ctl.js

@@ -166,9 +166,24 @@ async function cmdPair (args = []) {
     PROFILE = d.id // el emparejamiento y los comandos siguientes apuntan a ELLA
     console.log('Cuenta nueva: %s  (%s)', name, d.id)
   }
+  // `--adopt [nombre]`: la TERCERA respuesta a «¿de qué cuenta hablamos?» — el camino A.
+  // Aquí la cuenta NO sale de esta bóveda: la trae el aparato y esta bóveda pasa a
+  // guardarla y a mandarla. Por eso se crea un perfil VACÍO, que nace a la espera de
+  // adoptarla; sin ese sitio no habría dónde meterla.
+  const adIdx = args.findIndex((a) => a === '--adopt')
+  const adopt = adIdx >= 0
+  if (adopt) {
+    const next = args[adIdx + 1]
+    const name = (next && !next.startsWith('-')) ? next : `cuenta del dispositivo`
+    const d = await profileRequest('add', { name, adopt: true })
+    if (d.error) { console.error('%s', d.error); process.exit(1) }
+    if (!d.id) { console.error('El daemon no dijo qué cuenta creó.'); process.exit(1) }
+    PROFILE = d.id
+    console.log('Cuenta a la espera de adoptar la del dispositivo: %s  (%s)', name, d.id)
+  }
   // La petición se escribe SIEMPRE (aunque no haya --service): lleva a qué perfil
   // se empareja el dispositivo.
-  writeReq('pair-request.json', service ? { service } : {})
+  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(adopt ? { mode: 'adopt' } : {}) })
   avisar(s.pid, 'SIGUSR1')
 
   let pair = null

package/src/daemon.js

@@ -123,7 +123,14 @@ export async function runDaemon () {
       // TAMBIÉN dentro del QR (`acct`) para que el dispositivo pueda anunciar qué va
       // a pasar antes de hacerlo (V9 de docs/vinculacion-de-cuentas.md).
       const profileName = mgr.profiles.get(profileId)?.name || ''
-      const { qr, expiresInMs } = vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode: 'join', account: profileName })
+      // MODO (V9): lo decide la bóveda y viaja en el QR para que el aparato pueda decir
+      // qué va a pasar antes de hacerlo.
+      //   · `join`  → el dispositivo entra a esta cuenta de la bóveda.
+      //   · `adopt` → la bóveda se queda con la cuenta que trae el aparato (camino A). El
+      //               perfil de esta bóveda tiene que haber nacido para eso (`--adopt`
+      //               crea uno vacío), o no habría dónde meterla.
+      const mode = pairReq?.mode === 'adopt' ? 'adopt' : 'join'
+      const { qr, expiresInMs } = vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode, account: profileName })
       writeJson(pairFile, { v: 2, 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).
@@ -160,7 +167,7 @@ export async function runDaemon () {
       case 'list': return {} // el volcado de perfiles ya se hace abajo
       // `id`: quien la crea necesita saber CUÁL quedó, no adivinar por nombre (dos
       // cuentas pueden llamarse igual). Lo usa «emparejar en una cuenta nueva».
-      case 'add': { const p = await mgr.add(req.name); return { done: `perfil creado: ${p.name || p.id}`, id: p.id } }
+      case 'add': { const p = await mgr.add(req.name, { adopt: !!req.adopt }); return { done: `perfil creado: ${p.name || p.id}`, id: p.id, adopt: !!req.adopt } }
       case 'rm': { const r = await mgr.remove(req.profile); return { done: `perfil borrado: ${r.name || r.id}` } }
       case 'rename': { const p = mgr.profiles.rename(ref(), req.name); return { done: `perfil renombrado: ${p.name}` } }
       case 'use': { const p = mgr.profiles.setCurrent(ref()); return { done: `perfil activo: ${p.name || p.id}` } }

package/src/manager.js

@@ -56,6 +56,10 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
       proxyUrl,
       log: (...a) => log(`[${tag}]`, ...a),
       isLocked: () => profiles.isLocked(id),
+      // Camino A: nació para adoptar la cuenta de un aparato (ver profiles.add).
+      forAdoption: !!p?.adopt,
+      // Ya adoptó: la marca se consume (no vuelve a estar «a la espera»).
+      onAdopted: () => { try { profiles.clearAdopt(id) } catch (_) {} },
       onEnrollChallenge: (info) => onEnrollChallenge?.({ ...info, profile: id, profileName: p?.name || '' })
     })
     running.set(id, v)
@@ -88,10 +92,15 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
     currentId: () => profiles.current(),
     resolve: (ref) => profiles.resolve(ref),
 
-    async add (name) {
-      const p = profiles.add(name)
+    /**
+     * Crea un perfil. Con `adopt: true` nace **vacío, esperando la cuenta de un aparato**
+     * (camino A): la bóveda pone el sitio y la llave que entrará como miembro, pero la
+     * cuenta la trae el dispositivo y se adopta al emparejar.
+     */
+    async add (name, { adopt = false } = {}) {
+      const p = profiles.add(name, { adopt })
       await open(p.id)
-      log('[vault] perfil creado: %s (%s)', p.name || '(sin nombre)', p.id)
+      log('[vault] perfil creado%s: %s (%s)', adopt ? ' (a la espera de adoptar una cuenta)' : '', p.name || '(sin nombre)', p.id)
       return profiles.get(p.id)
     },
 

package/src/profiles.js

@@ -63,7 +63,9 @@ export function openProfiles (root = dataDir()) {
     createdAt: p.createdAt || null,
     protected: !!p.pwd,
     locked: !!p.pwd && !unlocked.has(p.id),
-    current: p.id === data.current
+    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 } : {})
   })
 
   function assertExists (id) {
@@ -123,15 +125,30 @@ export function openProfiles (root = dataDir()) {
       return { id, migrated: legacy }
     },
 
-    add (name) {
+    /**
+     * Crea un perfil. Con `adopt: true` nace **para adoptar la cuenta de un aparato**
+     * (camino A): la bóveda le hace sitio, pero la cuenta —el `profileId`, la reputación,
+     * lo ya firmado— la trae el dispositivo. La marca la consume `startVault`, que se la
+     * pasa a la identidad (`prepareForAdoption`); sin ella, adoptar una cuenta ajena se
+     * 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))
-      data.profiles.push({ id, name: cleanName(name), createdAt: Date.now() })
+      data.profiles.push({ id, name: cleanName(name), createdAt: Date.now(), ...(adopt ? { adopt: true } : {}) })
       if (!data.current) data.current = id
       save()
       return entry(find(id))
     },
 
+    /** Quita la marca de «nació para adoptar» (ya adoptó, o se canceló). */
+    clearAdopt (id) {
+      const p = find(id)
+      if (p?.adopt) { delete p.adopt; save() }
+      return !!p
+    },
+
     rename (id, name) {
       const p = assertExists(id)
       api.assertUnlocked(id)

package/src/tui/app.js

@@ -694,10 +694,8 @@ function pairingBody (st, t, cols, height) {
   // en la cuenta equivocada sin enterarse.
   const ap = activeProfile(st)
   const acct = info.profileName || ap?.name || info.profile || ap?.id || '—'
-  lines.push(t.bold(i.pairAccount(acct)))
   const left = Math.max(0, Math.round((info.expiresAt - Date.now()) / 60000))
-  lines.push(t.muted(i.pairValid(left)))
-  lines.push('')
+  lines.push(t.bold(i.pairAccount(acct, left)))
   // QR: se dibuja siempre que quepa de ancho; si es más alto que la pantalla se
   // puede hacer scroll hacia arriba/abajo para verlo completo.
   let qr = ''
@@ -711,6 +709,7 @@ function pairingBody (st, t, cols, height) {
     lines.push(t.warn(i.pairQrTooNarrow(cols, qrWidth)))
     lines.push('')
   }
+  lines.push(t.muted(i.pairScan))
   lines.push(t.bold(i.pairUrl) + info.url)
   lines.push('')
   lines.push(t.muted(i.pairPaste))

package/src/tui/i18n.js

@@ -134,8 +134,10 @@ const es = {
   newAccountLabel: 'Nombre de la cuenta nueva',
   newAccountHint: 'nace vacía; el dispositivo será su primer invitado',
   accountCreated: (name) => `Cuenta creada: ${name}`,
-  pairAccount: (name) => `Cuenta que se comparte: ${name}`,
-  pairValid: (min) => `Válido ~${min} min. Escanéalo o abre la URL en el dispositivo.`,
+  // Cuenta + vigencia en UNA línea: cada línea de cabecera es una fila menos de QR
+  // visible antes de tener que hacer scroll.
+  pairAccount: (name, min) => `Cuenta que se comparte: ${name}  ·  válido ~${min} min`,
+  pairScan: 'Escanéalo, o abre esta dirección en el dispositivo:',
   pairUrl: 'URL: ',
   pairPaste: 'O pega este código en vault.dotrino.com/dispositivos:',
   pairWarning: '⚠ Este código deja LEER tus datos y FIRMAR con tu identidad. No lo compartas.',
@@ -297,8 +299,8 @@ const en = {
   newAccountLabel: 'Name of the new account',
   newAccountHint: 'born empty; the device will be its first guest',
   accountCreated: (name) => `Account created: ${name}`,
-  pairAccount: (name) => `Account being shared: ${name}`,
-  pairValid: (min) => `Valid ~${min} min. Scan it or open the URL on the device.`,
+  pairAccount: (name, min) => `Account being shared: ${name}  ·  valid ~${min} min`,
+  pairScan: 'Scan it, or open this address on the device:',
   pairUrl: 'URL: ',
   pairPaste: 'Or paste this code into vault.dotrino.com/dispositivos:',
   pairWarning: '⚠ This code lets someone READ your data and SIGN as you. Do not share it.',

package/src/vault.js

@@ -35,7 +35,7 @@ import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
  *   Solo bloquea EDITAR el perfil (`profileSet`): firmar/leer y el resto del store
  *   siguen sirviendo a los dispositivos enrolados aunque esté bloqueado.
  */
-export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false } = {}) {
+export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false, forAdoption = false, onAdopted } = {}) {
   ensureDir(dir)
   // CIFRADO EN REPOSO ligado a esta máquina: `identity.json` deja de estar en claro, así
   // que copiarlo a otro equipo no sirve de nada. No protege contra quien ya tiene ESTA
@@ -47,6 +47,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   } catch (e) { log('[vault] no se pudo cifrar la identidad en reposo:', e.message) }
   const identity = await Identity.connect({ dir, atRest: atRestFor(dir) })
   if (!identity.me?.publickey) await identity.setMyNickname('')
+  // CAMINO A: este perfil nació para adoptar la cuenta de un aparato. La identidad se crea
+  // igual (su llave es la que entrará como miembro), pero se marca para que `joinProfile`
+  // acepte cambiar su acta recién nacida por la que traiga el dispositivo. Sin la marca,
+  // adoptar sería pisar una cuenta con datos y se rechaza — que es lo correcto por defecto.
+  if (forAdoption) {
+    try { await identity.prepareForAdoption() } catch (e) { log('[vault] no se pudo preparar el perfil para adoptar:', e.message) }
+  }
 
   const store = openStore(dir)
   const threads = openThreadStore(dir)
@@ -101,6 +108,12 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     sendByPubkey: (pub, obj) => client.sendByPubkey(pub, obj),
     audit,
     log,
+    // Camino A: lo que esta bóveda le manda al aparato para entrar en SU acta. La llave de
+    // cifrado es lo que le permite leer el contenido de la cuenta que va a custodiar; sin
+    // ella entraría mandando una cuenta que no puede abrir.
+    encPub: identity.me?.encryptionPubkey || null,
+    vaultLabel: 'bóveda',
+    onAdopted: (info) => { try { onAdopted?.(info) } catch (_) {} },
     defaultScope: [SCOPE.READ],
     onChallenge ({ deviceId, scope }) {
       log(`\n[vault] Un dispositivo quiere conectarse:`)
@@ -263,6 +276,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!payload || typeof payload !== 'object') return
     try {
       if (payload.type === MSG.ENROLL) return await desk.handleEnroll(from, payload)
+      if (payload.type === MSG.ACTA_SEALED) return await desk.handleActaSealed(from, payload)
       if (payload.type === MSG.SIGN) return await handleSign(from, payload)
       if (payload.type === MSG.GET) return await handleGet(from, payload)
       if (payload.type === MSG.STORE) return await handleStore(from, payload)