@dotrino/vaultd 0.111.1 → 0.112.0

package/README.md

@@ -846,6 +846,7 @@ ed25519 en formato OpenSSH (sin frase: la bóveda es el candado) y RSA/P-256 en
   - [`acta-de-perfil.md`](./docs/acta-de-perfil.md) — el modelo vigente: un perfil es un conjunto de llaves con un acta firmada por un solo sellador.
   - [`pairing-protocol.md`](./docs/pairing-protocol.md) — el emparejamiento endurecido: por qué el token dejó de ser autoridad suficiente.
   - [`vinculacion-de-cuentas.md`](./docs/vinculacion-de-cuentas.md) — los dos caminos al conectar un aparato, y por qué no existe fusionar cuentas.
+  - [`inicio-de-sesion.md`](./docs/inicio-de-sesion.md) — **entrar sin enrolar**: las sesiones (papel con vencimiento, respaldado por un aparato tuyo) y el orden hacia el inicio de sesión federado.
   - [`store-identity-architecture.md`](./docs/store-identity-architecture.md) — por qué la bóveda del PC hace de store además de identidad.
 
 Sin anuncios, sin cuentas, sin rastreo. MIT · parte de Dotrino.

package/lib/src/index.js

@@ -97,9 +97,8 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   const selfCert = await getSelfCert()
   const identify = async () => {
     if (!client.token) return
-    const data = { op: 'identify', publickey: iss, token: client.token, ts: Date.now() }
-    const { signature } = await identity.signData(data)
-    await client.identify({ data, signature, cert: selfCert })
+    // El sobre lo arma el pilar (`identifyAs`), que le pone el destinatario.
+    await client.identifyAs({ publickey: iss, sign: (d) => identity.signData(d), cert: selfCert })
   }
   await identify()
   client.on('token', () => identify().catch(() => {}))

package/lib/src/localdesk.js

@@ -85,7 +85,15 @@ export async function connectLocal ({ masterId, timeoutMs = 3000 } = {}) {
     // El mostrador local no pide identificarse: la puerta la abre el certificado que va
     // dentro de cada mensaje, igual que por el proxio. Identificarse ahí sirve para ser
     // DIRECCIONABLE, y aquí no hay a quién direccionar.
+    //
+    // LAS DOS FORMAS, porque quien llama no sabe por dónde salió. `freshClient` devuelve
+    // esto o un `WebSocketProxyClient` según haya socket o no, y el de arriba llama al
+    // método sin más: si aquí falta el que el pilar usa ahora, el escalón 1 del transporte
+    // —el más rápido, y el que corre en la máquina del dueño— muere con «client.identifyAs
+    // is not a function» mientras por el proxio todo va bien. Que sea un no-op no lo hace
+    // opcional: es la forma del cliente, y tiene que estar entera.
     identify: async () => ({ ok: true }),
+    identifyAs: async () => ({ ok: true }),
     on: (ev, fn) => {
       if (ev !== 'message') return () => {}
       oyentes.add(fn)

package/lib/src/service.js

@@ -199,9 +199,8 @@ async function freshClient (proxyUrl, connectTimeoutMs = 20000, master = null) {
 
 /** Identifica la conexión bajo la pubkey del servicio (para ser direccionable). */
 async function identifyAsService (client, device) {
-  const data = { op: 'identify', publickey: device.publickey, token: client.token, ts: Date.now() }
-  const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
-  await client.identify({ data, signature })
+  // El sobre lo arma el pilar (`identifyAs`), que le pone el destinatario.
+  await client.identifyAs({ publickey: device.publickey, sign: (d) => signWithDevice({ privateJwk: device.privateJwk, data: d }) })
 }
 
 /** Cuánto espera un agente a que alguien apruebe (el pedido vive 5 min en la bóveda). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.111.1",
+  "version": "0.112.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": {
@@ -24,7 +24,7 @@
     "@dotrino/compat": "0.4.0",
     "@dotrino/identity": "0.81.0",
     "@dotrino/passmanager": "^0.10.1",
-    "@dotrino/proxy-client": "0.15.0",
+    "@dotrino/proxy-client": "0.18.2",
     "@dotrino/roadmap": "0.2.0",
     "ws": "^8.18.0"
   },

package/src/client.js

@@ -40,9 +40,8 @@ async function freshClient ({ proxyUrl, dir = '.dotrino-vault-device' }) {
 /** Identifica la conexión bajo la pubkey de dispositivo D (para ser direccionable). */
 async function identifyAsDevice (client, device) {
   if (!client.token) return
-  const data = { op: 'identify', publickey: device.publickey, token: client.token, ts: Date.now() }
-  const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
-  await client.identify({ data, signature })
+  // El sobre lo arma el pilar (`identifyAs`), que le pone el destinatario.
+  await client.identifyAs({ publickey: device.publickey, sign: (d) => signWithDevice({ privateJwk: device.privateJwk, data: d }) })
 }
 
 function waitFor (client, predicate, timeoutMs = 30000) {

package/src/replica.js

@@ -132,8 +132,8 @@ export async function runReplica ({ dir = replicaDir(), proxyUrl, log = console.
 
   const client = new WebSocketProxyClient({ url })
   await client.connect()
-  const data = { op: 'identify', publickey: link.device.publickey, token: client.token, ts: Date.now() }
-  await client.identify({ data, signature: (await firmar(data)).signature })
+  // El sobre lo arma el pilar (`identifyAs`), que le pone el destinatario.
+  await client.identifyAs({ publickey: link.device.publickey, sign: (d) => firmar(d) })
   log(`[replica] ${id} · connected to ${url}`)
   log(`[replica] record #${store.seq}${store.acta ? '' : ' · no record yet: waiting for the vault'}`)
 

package/src/transport.js

@@ -87,10 +87,9 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
     const esMiembro = comm && (record?.members || []).some((m) => m?.pub === comm)
 
     if (comm && esMiembro) {
-      const data = { op: 'identify', publickey: comm, token: client.token, ts: Date.now() }
-      const signature = await commKey.sign(data)
-      if (signature) {
-        await client.identify({ data, signature, acta: record })
+      // El sobre lo arma el pilar (`identifyAs`), que le pone el destinatario.
+      try {
+        await client.identifyAs({ publickey: comm, sign: (d) => commKey.sign(d), acta: record })
         // SE DICE QUE SE IDENTIFICÓ, y con qué llave. Este camino era MUDO: al pasar de la
         // maestra a la llave de comunicación, el único rastro de «estoy alcanzable» que
         // quedaba en el log era el del repliegue. Así que cuando la consola decía «no
@@ -98,6 +97,11 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
         // o no. Una línea por reconexión es barata; no tenerla cuesta una hora de sondeos.
         log(`[vault] identified on the proxy with the communication key · record #${record?.seq ?? '?'}`)
         return
+      } catch (e) {
+        // SOLO «esta llave no firma» cae al camino de abajo, y se distingue por el `code`.
+        // Un fallo de red no es eso: tragárselo aquí mandaría a la maestra a firmar por un
+        // problema pasajero, que es justo lo que la llave de comunicación vino a evitar.
+        if (e?.code !== 'no-signature') throw e
       }
     }
 
@@ -118,10 +122,8 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
     try {
       const publickey = await masterPubkeyOf(identity)
       if (!publickey) return
-      const data = { op: 'identify', publickey, token: client.token, ts: Date.now() }
-      const { signature } = await identity.signData(data)
       log('[vault] identifying with the master key: this vault is not in its own record yet (open the profile once to fix it)')
-      await client.identify({ data, signature, acta: record })
+      await client.identifyAs({ publickey, sign: (d) => identity.signData(d), acta: record })
     } catch (e) {
       log(`[vault] cannot identify on the proxy yet: ${e.message} — the profile still opens; unlock it once and it gets its own communication key`)
     }

package/src/tui/app.js

@@ -1333,7 +1333,9 @@ async function onKeySecrets (term, st, key) {
   } else if (ch === 't' && cur?.key) {
     await toggleVisibility(term, st, cur.public, () => vc.setSecretVisibility(cur.ns, cur.key, !cur.public, activeId(st), activePwd(st)))
   } else if (ch === 'r' && cur?.key) {
-    await promptRenameVariable(term, st, cur)
+    // SIN `await`: el prompt solo ABRE el cuadro de entrada y vuelve. Esperarlo aquí
+    // congelaba la TUI entera — ver `promptRenameVariable`.
+    promptRenameVariable(term, st, cur)
   } else if (key.name === 'f5') {
     await refreshSecrets(term, st)
   }
@@ -1349,24 +1351,33 @@ async function onKeySecrets (term, st, key) {
  * cambio de configuración, así que se va a reiniciar. Si su código busca el nombre viejo,
  * dejará de encontrarlo — y eso no lo puede saber la bóveda.
  */
+/**
+ * ABRE EL CUADRO Y VUELVE. No devuelve una promesa que espere a que el usuario escriba, y
+ * eso no es estilo: era un INTERBLOQUEO que congelaba la TUI entera.
+ *
+ * Quien escribe es `onInputKey`, y a `onInputKey` solo se llega desde el bucle de teclas.
+ * Devolver aquí una promesa que solo resuelve en `onSubmit` dejaba al bucle esperándola —
+ * o sea, esperando a una tecla que no iba a leer nunca, porque el que lee es él. A partir
+ * de ahí no respondía a nada: ni Enter, ni Esc, ni Ctrl-C, que también se atienden ahí. La
+ * única salida era cerrar la terminal, y es lo que le tocó hacer al dueño el 2026-09-05.
+ *
+ * Los otros veinte prompts de esta TUI ya eran así; este era el único que no.
+ */
 function promptRenameVariable (term, st, cur) {
   const i = L(st)
-  return new Promise((listo) => {
-    setInput(st, {
-      label: i.renameLabel(cur.key),
-      hint: i.renameHint,
-      value: cur.key,
-      onSubmit: async (nuevo) => {
-        const nv = nuevo.trim()
-        st.input = null
-        if (!nv || nv === cur.key) { listo(); return }
-        if (!KEY_RE.test(nv)) { flash(st, i.keyInvalid, 'danger'); listo(); return }
-        const r = await guard(term, st, i.renaming, () => vc.renameSecret(cur.ns, cur.key, nv, activeId(st)))
-        if (r.ok) { flash(st, i.renamed(cur.key, nv)); st.secrets = r.v }
-        listo()
-      },
-      onCancel: () => { st.input = null; listo() }
-    })
+  setInput(st, {
+    label: i.renameLabel(cur.key),
+    hint: i.renameHint,
+    value: cur.key,
+    onSubmit: async (nuevo) => {
+      const nv = nuevo.trim()
+      st.input = null
+      if (!nv || nv === cur.key) return
+      if (!KEY_RE.test(nv)) { flash(st, i.keyInvalid, 'danger'); return }
+      const r = await guard(term, st, i.renaming, () => vc.renameSecret(cur.ns, cur.key, nv, activeId(st)))
+      if (r.ok) { flash(st, i.renamed(cur.key, nv)); st.secrets = r.v }
+    },
+    onCancel: () => { st.input = null }
   })
 }
 
@@ -1971,4 +1982,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }
+export const __test = { render, onKeySecrets, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }

package/src/vault.js

@@ -306,7 +306,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
   await ensureCommKeyInActa()
 
-  const { client } = await createTransport({ identity, dir, url: proxyUrl, commKey, log })
+  const { client, identify: reidentificar } = await createTransport({ identity, dir, url: proxyUrl, commKey, log })
 
   // El registro público de cadenas de selladores: deposita, si hay a dónde, los eslabones
   // que le dicen a un tercero si esta cuenta sigue sellada por quien él cree. Ver
@@ -1263,6 +1263,27 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!publicOnly && needsApproval(chk.device, record)) {
       const deviceId = await deviceIdOf(chk.device).catch(() => null)
       const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
+      // NADIE PUEDE APROBAR = SE DICE AHORA, no se deja esperando cinco minutos.
+      //
+      // La bóveda ya lo sabía —lo escribía en su propio log, «rang 0 approver(s)»— y aun
+      // así contestaba «pendiente» y dejaba al otro aguardando a algo que no podía pasar.
+      // Eso es un fallo ruidoso convertido en uno mudo, que es exactamente lo que la norma
+      // prohíbe (CLAUDE.md, «nada de repliegues»), y encima el que sabe es el ÚNICO que
+      // puede enterar al otro (CONVENCIONES §14): el que pide no tiene el acta, así que no
+      // hay forma de que lo averigüe por su cuenta.
+      //
+      // Lo pidió el dueño el 2026-09-05, después de mirar un `dotrino-env check` que parecía
+      // colgado y era esto.
+      const quienAprueba = (record?.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve'))
+      if (!quienAprueba.length) {
+        audit('rejected', { what: 'secrets', ns, reason: 'sin-aprobador' })
+        log(`[vault] ${ns}: refused ${deviceId || '????-????'} — nobody in the record can approve`)
+        return reply(from, {
+          type: MSG.ERROR,
+          code: 'no-approver',
+          error: `approval: nobody in the record can approve — grant it with \`dotrino-vault caps <ID> +aprueba\`, or let this service run unattended with \`dotrino-vault caps ${deviceId || '<ID>'} +desatendido\``
+        })
+      }
       // `from` SE GUARDA: la respuesta llega más tarde —cuando alguien apruebe— y tiene que
       // volver POR DONDE VINO. Si la pregunta entró por el mostrador local, mandarla por el
       // proxio la deja en el vacío: quien preguntó está escuchando en el socket, no ahí.
@@ -3181,7 +3202,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // ABRIR ES EL ÚNICO MOMENTO en que un perfil con contraseña está abierto, así que es
       // aquí donde puede estrenar su llave de comunicación (ver `ensureCommKeyInActa`).
       // Si falla, no se arrastra: abrir el perfil no puede depender de esto.
-      if (r?.locked === false) { try { await ensureCommKeyInActa() } catch (_) {} }
+      //
+      // Y SE VUELVE A IDENTIFICAR EN EL ACTO: `identify` solo corre al conectar y al cambiar
+      // el token, así que estrenar la llave no servía de nada hasta el siguiente arranque —
+      // la bóveda seguía muda en el proxio con su llave ya admitida en el acta. Al dueño le
+      // pasó el 2026-09-05: hizo lo que el log pedía y la consola siguió sin contestar.
+      if (r?.locked === false) {
+        try { if (await ensureCommKeyInActa()) await reidentificar?.() } catch (_) {}
+      }
       // Y ABSORBER LO PENDIENTE. La subacta ya lo estaba honrando con el perfil cerrado —de
       // eso vive—, pero mientras siga ahí solo lo sabe esta máquina: al sellarlo, entra en
       // el acta y lo respeta toda la cuenta. Si falla no se arrastra: abrir el perfil no