@dotrino/vaultd 0.150.1 → 0.152.0

package/lib/src/enroll.js

@@ -30,7 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
-import { verifyContinuity, canSeal, DEVICE_CAPS } from '@dotrino/identity/acta'
+import { verifyContinuity, canSeal, DEVICE_CAPS, VAULT_CN } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -169,12 +169,16 @@ export function createEnrollDesk ({
    *                       el código, igual que hacía `caps` después.
    */
   async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '', caps = null } = {}) {
+    // El nombre de la propia bóveda no es un servicio: su llave firma con el perfil cerrado
+    // y no puede abrir ningún cajón. Un servicio que entrara con ese nombre tampoco podría.
+    if (scopeToCn(scope) === VAULT_CN) throw Object.assign(new Error(`"${VAULT_CN}" is the vault's own name: a service cannot use it`), { code: 'reserved-cn' })
     if (caps != null) {
       if (!Array.isArray(caps)) throw Object.assign(new Error('caps must be a list'), { code: 'bad-caps' })
       const cn = scopeToCn(scope)
-      const bad = caps.filter((c) => !(DEVICE_CAPS.includes(c) || (c === 'secrets' && cn)))
+      const bad = caps.filter((c) => !DEVICE_CAPS.includes(c))
       if (bad.length) throw Object.assign(new Error('unknown permission(s): ' + bad.join(', ')), { code: 'bad-caps' })
-      if (!caps.length) throw Object.assign(new Error('the pairing grants no permission'), { code: 'empty-scope' })
+      // Un servicio puede entrar sin ningún permiso: su cajón lo abre el CN.
+      if (!caps.length && !cn) throw Object.assign(new Error('the pairing grants no permission'), { code: 'empty-scope' })
       caps = [...new Set(caps)]
     }
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
@@ -378,13 +382,14 @@ export function createEnrollDesk ({
       throw Object.assign(new Error('this vault cannot add devices to the account record: no certificate was issued'), { code: 'admit-unavailable' })
     }
     // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
-    // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
-    // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
+    // cajón (`secrets:<ns>`) fija el CN, que es lo que lo abre —no hay permiso aparte
+    // (dueño, 2026-10-13)—, y no borra lo demás: un bot con `sign,secrets:eco` firma como
+    // aparato del acta Y lee solo su cajón.
     // Si quien emparejó ELIGIÓ los permisos (`startPairing({ caps })`), entran esos y en
     // esta misma acta; si no, los que da el scope.
     const cn = scopeToCn(pend.scope)
-    const caps = [...new Set([...(pend.caps || scopeToCaps(pend.scope)), ...(cn ? ['secrets'] : [])])]
-    if (!caps.length) {
+    const caps = [...new Set(pend.caps || scopeToCaps(pend.scope))]
+    if (!caps.length && !cn) {
       throw Object.assign(new Error('the pairing scope grants no permission: no certificate was issued'), { code: 'empty-scope' })
     }
 

package/lib/src/service.js

@@ -522,8 +522,9 @@ export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device,
  * privadas al pasar.
  *
  * Lo que decide la bóveda, no este cliente:
- *   · si hay quien apruebe, se pide aprobación siempre, y al aprobarse puede EDITAR;
- *   · si nadie puede aprobar, solo AÑADE lo que falta (una que ya exista falla con `exists`);
+ *   · AÑADIR una variable nueva es directo: se guarda en el acto;
+ *   · EDITAR una que ya existe pide aprobación (la tanda entera queda en espera);
+ *   · si nadie puede aprobar, una que ya exista falla con `exists`;
  *   · BORRAR no existe por aquí.
  *
  * @param {object} o

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.150.1",
+  "version": "0.152.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": {
@@ -22,7 +22,7 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "^0.107.1",
+    "@dotrino/identity": "^0.111.0",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.17.0",
     "@dotrino/proxy-client": "0.30.1",

package/src/ctl.js

@@ -39,6 +39,7 @@ import { atRestFor, readConfig as readKekConfig, probe as probeKek, rekeyDir, en
 import { VERSION } from './version.js'
 import * as hw from './hwkeys.js'
 import { isNewer } from './update.js'
+import { COMM_CN } from './commKey.js'
 
 const dir = dataDir()
 const stateFile = path.join(dir, 'state.json')
@@ -614,7 +615,7 @@ async function cmdMembers () {
   // español. Se resaltan como `admin` y `approve`: los cuatro cambian lo que ese aparato
   // puede hacerle a la cuenta, y eso se lee de un vistazo o no se lee.
   const CAP = {
-    sign: 'firma', store: 'guarda', read: 'lee', secrets: 'lee sus claves',
+    sign: 'firma', store: 'guarda', read: 'lee',
     admin: `${B}administra el perfil${Z}`, approve: `${B}aprueba pedidos${Z}`,
     sealer: `${B}sella el acta${Z}`, passwords: `${B}pide contraseñas${Z}`,
     // Resaltado como los otros cuatro: dice si esa máquina se lleva tus claves privadas
@@ -644,7 +645,8 @@ async function cmdMembers () {
       m.isMe ? 'este dispositivo' : null,
       m.cn ? `servicio «${m.cn}»` : null
     ].filter(Boolean)
-    const caps = m.caps.length ? m.caps.map((c) => CAP[c] || c).join(', ') : '(sin permisos)'
+    // Un servicio sin permisos no está «sin nada»: su cajón lo abre el nombre, no un permiso.
+    const caps = m.caps.length ? m.caps.map((c) => CAP[c] || c).join(', ') : (m.cn && m.cn !== COMM_CN ? '(solo su cajón)' : '(sin permisos)')
     // CUÁNDO ENTRÓ. El nombre lo pone el propio aparato al emparejarse y muchas veces no
     // distingue nada —dos teléfonos con el mismo apodo, o «cli» a secas—, así que la fecha
     // es lo que deja reconocer cuál es cuál y ver si hay uno que no recuerdas haber
@@ -656,13 +658,13 @@ async function cmdMembers () {
     // selladas a esa llave. Se dice aquí, junto a él, porque es el único sitio donde
     // se mira quién es quién — y en la lista de variables ya seria tarde.
     //
-    // Solo si LEE variables (`secrets`). La llave de comunicación de la bóveda entra con
-    // `cn: 'vault'` y solo `firma`, y no tiene llave de cifrado a propósito: salía marcada
-    // en rojo «NO puede leer sus variables» cuando no tiene ninguna que leer.
+    // Menos la llave de comunicación de la bóveda: entra con `cn: 'vault'` y solo `firma`,
+    // y no tiene llave de cifrado a propósito: salía marcada en rojo «NO puede leer sus
+    // variables» cuando no tiene ninguna que leer.
     // SI LE LLEGAN LOS AVISOS, en quien aprueba. No cambia a quién se le pide —se le pide a
     // todos—: es para ver a cuál no le suena el pedido.
     if (m.caps.includes('approve') && 'notifiedAt' in m) console.log('      %s%s%s', D, avisosTxt(m.notifiedAt), Z)
-    if (m.cn && !m.canSeal && m.caps.includes('secrets')) console.log('      %ssin llave de cifrado: NO puede leer sus variables%s', R, Z)
+    if (m.cn && m.cn !== COMM_CN && !m.canSeal) console.log('      %ssin llave de cifrado: NO puede leer sus variables%s', R, Z)
     // QUÉ CORRE, y si cuadra con esta bóveda (CONVENCIONES §14). Sin esto una
     // incompatibilidad de versiones se ve como que ese aparato «no responde», que es el
     // fallo más caro que ha tenido el ecosistema. No bloquea nada: se enseña.

package/src/daemon.js

@@ -245,7 +245,7 @@ export async function runDaemon () {
       if (caps) {
         caps = [...new Set(caps)]
         const cn = scopeToCn(base)
-        const fromCaps = caps.map((c) => capScope(c, cn)).filter((x) => x && ALLOWED(x))
+        const fromCaps = caps.map((c) => capScope(c)).filter((x) => x && ALLOWED(x))
         // Sin `--scope` el papel sale de los permisos; con él, se suman.
         scope = [...new Set([...(asked?.length || isService ? base : []), ...fromCaps])]
         if (!scope.length) {

package/src/tui/app.js

@@ -562,17 +562,12 @@ const CAPS_ORDER = [...ORDEN.filter((c) => DEVICE_CAPS.includes(c)),
   ...DEVICE_CAPS.filter((c) => !ORDEN.includes(c))]
 
 /**
- * Los permisos que se le pueden dar A ESTE miembro, en orden.
- *
- * `secrets` solo existe para un SERVICIO (los que tienen `cn`), y por eso faltaba: la
- * lista era fija y no cabía algo que depende de quién sea. Pero para un servicio es EL
- * permiso —el que decide si abre su cajón— y no verlo aquí hacía creer que no existe,
- * igual que pasaba con `unattended`. Se enseña primero, que es su importancia real.
- *
- * A un aparato SIN `cn` no se le ofrece: no hay cajón que abrir, el acta lo filtra
- * (`allowedCaps`) y enseñar una casilla que no hace nada es peor que no enseñarla.
+ * EL CAJÓN NO ES UNA CASILLA (dueño, 2026-10-13: «no entiendo por qué es un permiso el
+ * acceso a un cajón, el cn ya garantiza eso»). Antes un servicio traía aquí «secretos
+ * «passmanager»» al lado de «contrasenas», y parecían dos permisos sobre lo mismo. Un
+ * servicio abre el cajón de su nombre por ser ese servicio: se DICE arriba de la lista
+ * (`capsDrawer`), y no se marca ni se desmarca.
  */
-const capsForMember = (member) => (member?.cn ? ['secrets', ...CAPS_ORDER] : CAPS_ORDER)
 
 /** Con lo que entra un aparato si no eliges otra cosa: lo mismo que `pair` sin `--scope`. */
 const PAIR_DEFAULT_CAPS = ['sign', 'read', 'store']
@@ -586,11 +581,10 @@ const PAIR_DEFAULT_CAPS = ['sign', 'read', 'store']
 function capChecklist (i, t, { cn = null, has, real = has }) {
   const rows = []
   let tocados = 0
-  for (const cap of capsForMember({ cn })) {
+  if (cn) rows.push({ text: t.muted(' ' + i.capsDrawer(cn)), sel: false }, { text: '', sel: false })
+  for (const cap of CAPS_ORDER) {
     const mark = has.has(cap) ? '[x]' : '[ ]'
-    // El nombre de `secrets` lleva el cajón dentro: «las claves de proxy» dice qué abre,
-    // «lee sus claves» te deja preguntándote cuáles.
-    const name = typeof i.capName[cap] === 'function' ? i.capName[cap](cn) : i.capName[cap]
+    const name = i.capName[cap]
     // LO QUE CAMBIA SE SEÑALA. Sin esto el borrador es indistinguible del acta y no sabes
     // qué vas a firmar — que es justo lo que hace peligroso acumular cambios.
     const cambia = has.has(cap) !== real.has(cap)
@@ -599,8 +593,7 @@ function capChecklist (i, t, { cn = null, has, real = has }) {
     // así que no hay que repetirlo al lado. Lo que hace va debajo.
     const line = ` ${mark}${cambia ? t.bold('*') : ' '} ${cap === 'admin' ? t.bold(name) : name}`
     rows.push({ text: line, sel: true, meta: { cap } })
-    const hint = typeof i.capHint[cap] === 'function' ? i.capHint[cap](cn) : i.capHint[cap]
-    rows.push({ text: t.muted('      ' + hint), sel: false })
+    rows.push({ text: t.muted('      ' + i.capHint[cap]), sel: false })
   }
   return { rows, tocados }
 }
@@ -1344,7 +1337,8 @@ async function onKeyDevices (term, st, key) {
       value: cur.label || '',
       onSubmit: async (raw) => {
         const name = String(raw || '').trim()
-        if (!name) return
+        st.input = null
+        if (!name) { flash(st, i.nameEmpty, 'danger'); return }
         const r = await guard(term, st, i.renaming, () => vc.setDeviceLabel(cur.sub, name, activeId(st)))
         if (r.ok) { applyDump(st, r.v); flash(st, i.deviceRenamed(name)) }
       }
@@ -1415,6 +1409,7 @@ async function onKeyLogins (term, st, key, api = vc) {
                   mask: true,
                   onSubmit: async (pw2) => {
                     if (pw1 !== pw2) { flash(st, i.loginPassMismatch, 'warn'); return }
+                    st.input = null
                     const r = await guard(term, st, i.loginCreating,
                       () => api.addLogin({ user, password: pw1, label }))
                     if (r.ok) {
@@ -1442,6 +1437,7 @@ async function onKeyLogins (term, st, key, api = vc) {
           mask: true,
           onSubmit: async (nueva) => {
             if (String(nueva || '').length < MIN_LOGIN_PASSWORD) { flash(st, i.loginPassShort, 'warn'); return }
+            st.input = null
             const r = await guard(term, st, i.loginChanging,
               () => api.passwdLogin({ user: cur.user, oldPassword: vieja, newPassword: nueva }))
             if (r.ok) { flash(st, i.loginChanged); await refreshLogins(term, st, api) }
@@ -1593,7 +1589,8 @@ async function onKeyPairCaps (term, st, key) {
     return true
   }
   if (ch === 'g') {
-    if (!pc.caps.length) { flash(st, i.pairCapsNone, 'warn'); return true }
+    // Un servicio puede entrar sin ningún permiso: su cajón lo abre el nombre.
+    if (!pc.caps.length && !pc.service) { flash(st, i.pairCapsNone, 'warn'); return true }
     const go = async () => {
       st.pairCaps = null
       const ok = await beginPairing(term, st, pc.profile, pc.service, pc.label, pc.caps)
@@ -1614,7 +1611,7 @@ async function onKeyPairCaps (term, st, key) {
 
 /** Abre la pantalla de permisos del emparejamiento; el QR sale al pulsar G. */
 function choosePairCaps (st, { profile, service = null, label = null, after = null }) {
-  st.pairCaps = { profile, service, label, after, caps: service ? ['secrets'] : [...PAIR_DEFAULT_CAPS] }
+  st.pairCaps = { profile, service, label, after, caps: service ? [] : [...PAIR_DEFAULT_CAPS] }
   st.sel.paircaps = 0
   st.scroll.paircaps = { value: 0 }
   st.screen = 'paircaps'

package/src/tui/i18n.js

@@ -79,6 +79,7 @@ const es = {
   // PERMISOS de un dispositivo (§9.1: se dice el beneficio, no el scope del cert).
   titleCaps: 'Permisos del dispositivo',
   capsFor: (id, name) => `Permisos de ${id}${name ? ' · ' + name : ''}`,
+  capsDrawer: (cn) => `Es el servicio «${cn}»: abre el cajón «${cn}» y ningún otro.`,
   capsNoMember: '  (este dispositivo ya no está en el perfil)',
   capsApplyHint: 'Enter marca o desmarca · G guarda · Esc vuelve a la lista sin perder lo marcado',
   capsPending: (n) => `${n} cambio(s) sin guardar en este aparato (*) · G guarda todo en una sola acta`,
@@ -104,7 +105,6 @@ const es = {
   // resultado fue una lista donde no se sabía qué permiso era cuál ni cómo nombrarlo para
   // el CLI. Lo que hace cada uno va DEBAJO, que es su sitio.
   capName: {
-    secrets: (cn) => `secretos «${cn}»`,
     sign: 'firma',
     store: 'guarda',
     read: 'lee',
@@ -120,7 +120,6 @@ const es = {
   // continuaba a «Conectar y quitar dispositivos»—; ahora el título es la palabra que se
   // teclea, así que la pista tiene que decir la frase entera.
   capHint: {
-    secrets: (cn) => `abrir el cajón de «${cn}» y ningún otro`,
     sign: 'usar tu identidad en las apps del ecosistema',
     store: 'escribir en tu bóveda: perfil, contenido, datos',
     read: 'ver lo que guardaste',
@@ -564,6 +563,7 @@ const en = {
   tabMe: 'Profile',
   titleCaps: 'Device permissions',
   capsFor: (id, name) => `Permissions for ${id}${name ? ' · ' + name : ''}`,
+  capsDrawer: (cn) => `It is the “${cn}” service: it opens the “${cn}” drawer and no other.`,
   capsNoMember: '  (this device is no longer in the record)',
   capsApplyHint: 'Enter ticks or unticks · G saves · Esc goes back to the list keeping your ticks',
   capsPending: (n) => `${n} unsaved change(s) on this device (*) · G saves everything in ONE record`,
@@ -583,7 +583,6 @@ const en = {
   // El título es el NOMBRE del permiso, el mismo que se teclea. Ver la nota en el bloque
   // español: describirlo dejaba una lista donde no se sabía qué permiso era cuál.
   capName: {
-    secrets: (cn) => `secrets «${cn}»`,
     sign: 'sign',
     store: 'store',
     read: 'read',
@@ -597,7 +596,6 @@ const en = {
   },
   // Cada pista se sostiene sola: el título es la palabra, no una frase que continuar.
   capHint: {
-    secrets: (cn) => `open the «${cn}» drawer and no other`,
     sign: 'use your identity across the ecosystem apps',
     store: 'write to your vault: profile, content, data',
     read: 'see what you saved',

package/src/vault.js

@@ -1477,9 +1477,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * firma del autor, las envolturas, la espera de aprobación. Aquí no hay otra puerta.
    *
    * Los límites (dueño, 2026-09-29):
-   *   · si hay alguien que aprueba, SIEMPRE se pide aprobación —`unattended` no exime— y con
-   *     el sí puede también EDITAR lo que ya existe;
-   *   · si nadie puede aprobar, no se pide y solo puede AÑADIR lo que falta;
+   *   · AÑADIR una variable nueva es directo, haya o no quien apruebe (dueño, 2026-10-12);
+   *   · EDITAR una que ya existe pide aprobación —`unattended` no exime—;
+   *   · si nadie puede aprobar, no se pide y lo que ya existe no se toca (`exists`);
    *   · BORRAR, nunca: eso es de la consola y del CLI de la bóveda.
    *
    * Dos operaciones: `store.recipients` (para quién se sella: solo públicas, nada que ocultar)
@@ -1696,7 +1696,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         log(`[vault] ${ns}: ${deviceId || '????-????'} wants to store ${items.length} variable(s) — waiting for approval (${result.pending})`)
       } else {
         audit('store', { device: deviceId, ns, keys: result?.keys || [] })
-        log(`[vault] ${ns}: ${deviceId || '????-????'} stored ${(result?.keys || []).length} variable(s) (nobody can approve: add only)`)
+        log(`[vault] ${ns}: ${deviceId || '????-????'} stored ${(result?.keys || []).length} new variable(s)`)
         await notifyMembers('vars', { by: deviceId, keys: result?.keys || [], ns })
       }
       return await answer({ op: 'store.result', ns, ts: Date.now(), keys: result?.keys || [], pending: result?.pending || null })
@@ -2811,13 +2811,18 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       const owner = ns ? `ns:${ns}` : `dev:${pub}`
       const keys = []
       // ¿SE PIDE APROBACIÓN? Desde la mesa del admin, lo de siempre (`needsApproval`: quien
-      // tiene `unattended` escribe solo). Desde el propio SERVICIO que guarda en su cajón, se
-      // pide SIEMPRE que haya quien apruebe, tenga o no `unattended` (dueño, 2026-09-29:
-      // «el unattended también pediría aprobación»): `unattended` es para llevarse claves al
-      // arrancar, no para reescribir su propia configuración. Sin nadie que apruebe no se
-      // pide —la regla de siempre— y entonces solo puede añadir.
+      // tiene `unattended` escribe solo). Desde el propio SERVICIO que guarda en su cajón, la
+      // aprobación es SOLO PARA EDITAR (dueño, 2026-10-12: «la aprobación solamente es para
+      // editar una env; para almacenarla es directo»): una variable nueva no le quita nada a
+      // nadie y se guarda en el acto; reemplazar una que ya existe pide el sí de quien
+      // aprueba, tenga o no `unattended` el servicio (dueño, 2026-09-29: «el unattended
+      // también pediría aprobación»). Una tanda con alguna que ya existe se pide ENTERA: va
+      // todo o nada. Sin nadie que apruebe no se pide —la regla de siempre— y lo que ya
+      // existe falla con `exists`.
       const record = await refreshActa()
-      const ask = fromService ? hasApprover(record) : needsApproval(caller, record)
+      const ask = fromService
+        ? hasApprover(record) && items.some((it) => it?.key && secrets.has(owner, it.key))
+        : needsApproval(caller, record)
       for (const it of items) {
         if (!it?.key || !it?.sealed) throw new Error('var.setMany: each variable needs its key and its sealed envelope')
         await checkAuthor(owner, it.key, it.sealed, caller, { allowOverwrite: ask })