@dotrino/vaultd 0.62.1 → 0.64.0

package/lib/src/enroll.js

@@ -30,7 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
-import { verifyContinuity } from '@dotrino/identity/acta'
+import { verifyContinuity, canSeal } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -388,9 +388,12 @@ export function createEnrollDesk ({
     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 adoption awaiting a record' })
     if (!record || typeof record !== 'object') return reply(from, { type: MSG_ERROR, error: 'record missing or unreadable' })
-    if (record.sealer !== iss) {
+    // Ya no hay campo `sealer`: se le pregunta al PERMISO. Es la misma comprobación —«¿me
+    // nombra a mí la que me mandan?»— dicha en el idioma nuevo, y con varios selladores la
+    // respuesta puede ser que sí para más de uno, que es lo correcto.
+    if (!canSeal(record, iss)) {
       audit('rejected', { what: 'adopt', reason: 'not-sealer' })
-      return reply(from, { type: MSG_ERROR, error: 'that record does not name this vault as the sealer' })
+      return reply(from, { type: MSG_ERROR, error: 'that record does not let this vault seal it' })
     }
     if (record.sealedBy !== pend.dpub) {
       audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })

package/lib/src/index.js

@@ -26,7 +26,7 @@
  * No reimplementa nada del ecosistema.
  */
 import { verifyChain, verifyDeviceSig } from '@dotrino/identity/capabilities'
-import { memberCanSign } from '@dotrino/identity/acta'
+import { memberCanScope } from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './enroll.js'
 // Las constantes del protocolo salen del MISMO módulo que usa el daemon: si la lista
 // local se queda corta, el dispositivo deja de handle mensajes sin que nadie lo note.
@@ -195,6 +195,17 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
       send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
       return null
     }
+    // EL ACTA MANDA, EL PAPEL SOLO ACOMPAÑA. Aquí y no en cada mostrador: el certificado
+    // dice a qué se comprometió esta bóveda al conectar el aparato, y el acta lo que puede
+    // HOY. Quitarle un permiso sella el acta pero no le retira el papel, que vive hasta 30
+    // días, así que sin esto seguiría entrando hasta que lo renovara.
+    if (expectedScope) {
+      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+      if (record && !memberCanScope(record, chk.device, expectedScope)) {
+        send(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member no longer has that permission' })
+        return null
+      }
+    }
     return chk
   }
 
@@ -206,14 +217,6 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   async function handleSign (from, p) {
     const chk = await authorise(from, p, SCOPE.SIGN)
     if (!chk) return
-    // MANDA EL ACTA, NO EL PAPEL. `authorise` mira el certificado, y quitarle `firma` a un
-    // aparato NO reemite ni revoca su cert: seguiría diciendo `vault:sign` hasta 30 días.
-    // Sin esto, retirarle el permiso lo cambiaba de firmar él a que firmara la bóveda por
-    // él — o sea, no se lo retiraba. Mismo arreglo que en el daemon (`src/vault.js`).
-    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
-    if (record && !memberCanSign(record, chk.device)) {
-      return send(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member does not sign' })
-    }
     const toSign = p.data?.payload
     if (toSign == null) return send(from, { type: MSG.ERROR, error: 'data.payload required' })
     const { signature, publickey } = await identity.signData(toSign)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.62.1",
+  "version": "0.64.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": {
@@ -20,7 +20,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.65.1",
+    "@dotrino/identity": "^0.67.0",
     "@dotrino/passmanager": "^0.9.0",
     "@dotrino/proxy-client": "^0.13.1",
     "ws": "^8.18.0"

package/src/ctl.js

@@ -548,7 +548,10 @@ async function cmdMembers () {
   for (const m of record.members) {
     const who = m.label || m.id
     const marks = [
-      m.isMaster ? `${B}Master${Z}` : null,
+      // Ya no hay UN master: la marca dice quién puede sellar, y pueden ser varios. El
+      // permiso también sale abajo en la lista, pero aquí se ve de un vistazo — que es
+      // justo lo que se busca al mirar quién es quién.
+      m.isMaster ? `${B}Sella${Z}` : null,
       m.isMe ? 'este dispositivo' : null,
       m.cn ? `servicio «${m.cn}»` : null
     ].filter(Boolean)

package/src/manager.js

@@ -24,13 +24,16 @@ import { atRestFor } from './atrest.js'
  * Pura a propósito (recibe el veredicto ya calculado) para poder probar la regla sin
  * levantar un vault entero.
  */
-export function assertCanRemove ({ isMaster, memberCount, name = '' }) {
-  if (!isMaster || memberCount <= 1) return true
+export function assertCanRemove ({ isMaster, memberCount, sealerCount = 1, name = '' }) {
+  // `isMaster` ahora es «¿puedo sellar?». Y con varios selladores, borrar esta bóveda ya
+  // NO deja la cuenta muerta si queda otro que pueda sellar: eso es exactamente para lo
+  // que existe el multivault, y el freno tiene que dejar de estorbar en ese caso.
+  if (!isMaster || memberCount <= 1 || sealerCount > 1) return true
   const others = memberCount - 1
   const e = new Error(
-    `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.'
+    `this vault is the only one that can seal account "${name}", and it has ${others} more device(s): ` +
+    'give another one the sealing permission first (`caps <ID> +sella`). Deleting it like this ' +
+    'leaves them with their key and nobody able to seal the record again.'
   )
   e.code = 'MASTER_WITH_MEMBERS'
   e.members = memberCount
@@ -159,7 +162,12 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
           v.isMaster().catch(() => false),
           v.profileMembers().catch(() => ({ members: [] }))
         ])
-        assertCanRemove({ isMaster, memberCount: (record?.members || []).length, name: profiles.get(id)?.name || id })
+        assertCanRemove({
+          isMaster,
+          memberCount: (record?.members || []).length,
+          sealerCount: (record?.sealers || []).length || 1,
+          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/vault.js

@@ -307,6 +307,28 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     }
   })
 
+  /**
+   * EL ACTA MANDA, EL PAPEL SOLO ACOMPAÑA. Se pregunta DESPUÉS de verificar la cadena y
+   * ANTES de hacer nada, en todos los mostradores.
+   *
+   * El certificado dice a qué se comprometió esta bóveda cuando conectó el aparato; el
+   * acta dice lo que puede HOY. Y no coinciden: `caps <ID> -lee` sella el acta pero no
+   * reemite ni revoca el papel, que vive hasta 30 días. Sin esto, quitarle un permiso a un
+   * aparato no se lo quitaba — seguía leyendo, guardando o firmando un mes más.
+   *
+   * Va por `memberCanScope` (el pilar) y no a mano en cada sitio: la regla es la misma en
+   * las dos bóvedas y se comprobaba mal en las dos.
+   *
+   * @returns {boolean} `true` si puede seguir; si no, ya contestó el «no».
+   */
+  async function actaAllows (from, chk, scope, what) {
+    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!record || Acta.memberCanScope(record, chk.device, scope)) return true
+    audit('rejected', { what, reason: 'acta' })
+    reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member no longer has that permission' })
+    return false
+  }
+
   // --- handleSign / handleGet: idénticos (verifyChain de la cadena D←maestra) ---
   async function handleSign (from, p) {
     if (!isFresh(p.data)) { audit('rejected', { what: 'sign', reason: 'stale' }); return staleReply(from) }
@@ -323,11 +345,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // `signData` local veía que ya no puede y se lo PEDÍA a la bóveda… que decía que sí.
     // O sea que quitarle el permiso de firmar no se lo quitaba: lo cambiaba de firmar él
     // a que firmaras tú por él.
-    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
-    if (record && !Acta.memberCanSign(record, chk.device)) {
-      audit('rejected', { what: 'sign', reason: 'acta' })
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member does not sign' })
-    }
+    if (!await actaAllows(from, chk, SCOPE.SIGN, 'sign')) return
 
     // Y CERRADA NO FIRMA NADA (dueño, 2026-08-31). La regla de antes —«el daemon sigue
     // firmando con el perfil bloqueado, para que un reinicio no deje las apps muertas»— es
@@ -355,6 +373,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       expectedScope: SCOPE.READ, trustedIssuer: master, revoked: await revocationSet()
     })
     if (!chk.ok) return denyChain(from, chk, p, 'get')
+    if (!await actaAllows(from, chk, SCOPE.READ, 'get')) return
     const id = p.data?.id || 'root'
     reply(from, { type: MSG.DATA, id, node: store.getNode(id) })
   }
@@ -383,6 +402,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.READ, trustedIssuer: master, revoked })
     }
     if (!chk.ok) return denyChain(from, chk, p, 'store')
+    // El scope que valió es el que hay que preguntarle al acta: un método de lectura pudo
+    // pasar con `read` en vez de `store`, y exigirle `store` al acta lo rechazaría a pesar
+    // de tener permiso para lo que pidió.
+    if (!await actaAllows(from, chk, chk.scope === SCOPE.READ ? SCOPE.READ : SCOPE.STORE, 'store')) return
     try {
       // CIFRADO de punta a punta con la clave de contenido del perfil: el proxy transporta
       // pero no ve nada de lo que el usuario guarda. Si el dispositivo mandó `enc`, se abre