@dotrino/vaultd 0.130.0 → 0.131.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.130.0",
+  "version": "0.131.1",
   "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": {
@@ -28,7 +28,7 @@
     "@dotrino/proxy-client": "0.24.0",
     "@dotrino/roadmap": "0.3.7",
     "@dotrino/store": "0.11.0",
-    "@dotrino/update": "0.2.1",
+    "@dotrino/update": "0.2.2",
     "ws": "^8.18.0"
   },
   "license": "MIT",

package/src/ctl.js

@@ -520,7 +520,9 @@ async function cmdMe () {
   // El volcado es contenido del usuario: se lee y se BORRA, no se queda ahí suelto.
   try { fs.rmSync(meFile, { force: true }) } catch (_) {}
   if (!dump) { console.error('La bóveda no respondió. ¿Está corriendo?  dotrino-vault status'); process.exit(1) }
-  assertOpen(dump)
+  // Con el perfil CERRADO se enseña igual lo público (la bóveda ya se lo da a cualquiera);
+  // lo que no sale son ni los nombres de los datos privados. Se dice.
+  if (dump.locked && !dump.me) assertOpen(dump)
 
   const me = dump.me
   if (!me) {
@@ -530,6 +532,7 @@ async function cmdMe () {
   }
 
   const when = me.updatedAt ? new Date(me.updatedAt).toLocaleString() : '—'
+  if (dump.locked) console.log('\n(perfil bloqueado: solo lo público; ábrelo con  dotrino-vault unlock  para ver qué datos privados hay)')
   console.log('\n%sPerfil%s · actualizado %s\n', B, Z, when)
   console.log('  nombre      : %s', me.nickname || '(sin nombre)')
   console.log('  foto        : %s', me.avatar
@@ -546,6 +549,10 @@ async function cmdMe () {
       console.log('  %s: %s%s', label.padEnd(12), me[k], me[k + 'Visible'] === false ? '   (oculto)' : '')
     }
   }
+  // Lo PRIVADO viaja sellado y la bóveda no lo abre para enseñarlo: se dice qué hay.
+  if (Array.isArray(me.privateKeys) && me.privateKeys.length) {
+    console.log('\n  privados   : %s  (sellados: se ven en tus aparatos, no aquí)', me.privateKeys.join(', '))
+  }
   for (const [title, list] of [['Enlaces', me.links], ['Otros datos', me.fields]]) {
     if (!Array.isArray(list) || !list.length) continue
     console.log('\n  %s:', title)

package/src/daemon.js

@@ -342,6 +342,26 @@ export async function runDaemon () {
   const meReqFile = path.join(dir, 'me-request.json')
   const meFile = path.join(dir, 'me.json')
 
+  /**
+   * EL PERFIL PARA `dotrino-vault me` Y LA TUI, desde el cajón `@me` (donde escribe el aparato,
+   * dato a dato). Leía el `profileGet` del almacén viejo, al que ya no escribe nadie: un perfil
+   * nuevo salía SIEMPRE vacío aunque el aparato lo hubiera mandado (dueño, 2026-09-24).
+   *
+   * `conPrivados`: con el perfil CERRADO no se dicen ni los nombres de los datos privados —el
+   * candado esconde nombres igual que con las variables—. Lo público sí: la bóveda ya se lo
+   * da a cualquiera por el proxio (`profilePublic`), así que no revela nada.
+   */
+  function perfilParaMostrar (vault, { conPrivados }) {
+    const v = vault.profileView()
+    const lista = (s) => { if (typeof s !== 'string') return undefined; try { const a = JSON.parse(s); return Array.isArray(a) ? a : undefined } catch (_) { return undefined } }
+    const { avatar, links, fields, ...rest } = v.public
+    if (!Object.keys(v.public).length && !(conPrivados && v.private.length)) return null
+    return {
+      ...rest, avatar: avatarInfo(avatar), links: lista(links), fields: lista(fields),
+      ...(conPrivados ? { privateKeys: v.private } : {}), updatedAt: v.updatedAt
+    }
+  }
+
   /** Resumen de la foto de perfil: qué es y cuánto pesa, nunca los bytes. */
   function avatarInfo (avatar) {
     if (typeof avatar !== 'string' || !avatar) return null
@@ -366,7 +386,8 @@ export async function runDaemon () {
     const v = mgr.get(id)
     if (!v?.rekeySecrets) return
     const r = await v.rekeySecrets(vieja, nueva)
-    if (r?.rekeyed) console.log('[vault] secrets master re-sealed (%d drawer(s))', r.drawers)
+    // Se re-sella UNA copia (la de recuperación, que abre el llavero), no cajón por cajón.
+    if (r?.rekeyed) console.log('[vault] secrets recovery copy re-sealed under the new key')
   }
 
   /**
@@ -808,7 +829,11 @@ export async function runDaemon () {
           ipcWrite(path.join(dir, 'acta.json'), { ...closed, members: [] })
         }
         rm(meReqFile)
-        if (meReq) ipcWrite(meFile, { ...closed, req: meReq.id || null, me: null })
+        if (meReq) {
+          let me = null
+          try { me = perfilParaMostrar(t.vault, { conPrivados: false }) } catch (e) { console.error('[vault] could not dump the profile:', e.message) }
+          ipcWrite(meFile, { ...closed, req: meReq.id || null, me })
+        }
         return
       }
       if (dumpReq) {
@@ -852,9 +877,8 @@ export async function runDaemon () {
         rm(meReqFile)
         try {
           const tm = resolveTarget(meReq) || { id: mgr.currentId(), vault: mgr.current() }
-          const { me } = tm.vault.threads.methods.profileGet()
-          const { avatar, ...rest } = me || {}
-          ipcWrite(meFile, { v: 1, at: Date.now(), req: meReq.id || null, profile: tm.id, me: me ? { ...rest, avatar: avatarInfo(avatar) } : null })
+          const me = perfilParaMostrar(tm.vault, { conPrivados: true })
+          ipcWrite(meFile, { v: 1, at: Date.now(), req: meReq.id || null, profile: tm.id, me })
         } catch (e) { console.error('[vault] could not dump the profile:', e.message) }
       }
     } catch (e) {
@@ -1001,12 +1025,24 @@ export async function runDaemon () {
    * Lo que arregla es lo que de verdad dolió el 2026-09-19: el replicador llevaba quince
    * días atrás y las bóvedas dos versiones, y NADA lo decía en ninguna pantalla.
    *
-   * Si no se puede mirar, no se dice nada y ya está: no saber si hay versión nueva no es un
-   * problema del usuario, y llenarle el log de fallos de red tampoco ayuda.
+   * SI NO SE PUEDE MIRAR, SE DICE — una vez por motivo, no en cada intento. Antes se callaba
+   * («no saber si hay versión nueva no es un problema del usuario»), y eso choca con §15:
+   * «no se pudo mirar» NUNCA es «estás al día». El 2026-09-24 una bóveda se quedó en la
+   * 0.130.0 con la 0.131.0 publicada y el log no decía nada: no había forma de saber si
+   * estaba al día o si no había podido preguntar.
    */
+  let ultimoFallo = null
   const mirarRelease = async () => {
-    const r = await latestRelease()
-    if (!r.ok) return
+    let r
+    try { r = await latestRelease() } catch (e) { r = { ok: false, reason: e?.message || String(e) } }
+    if (!r.ok) {
+      if (r.reason !== ultimoFallo) console.log(`[vault] could not check for a new version: ${r.reason} · trying again in an hour`)
+      ultimoFallo = r.reason
+      // Un fallo al arrancar (la red todavía no está) no puede costar un día entero.
+      setTimeout(mirarRelease, 60 * 60_000).unref?.()
+      return
+    }
+    ultimoFallo = null
     ultimaPublicada = { version: r.version, checkedAt: Date.now() }
     writeState()
     if (!isNewer(r.version, daemonVersion)) return

package/src/secretsStore.js

@@ -909,6 +909,24 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
      * Va firmado igual que lo demás: un dato público sin firma es un dato que cualquiera
      * puede inventar en tu nombre, que es peor que no tenerlo.
      */
+    profileView () {
+      // EL PERFIL TAL COMO LO TIENE LA BÓVEDA, para enseñárselo al dueño (`dotrino-vault me`,
+      // la TUI). Sale del cajón `@me`, que es donde escribe el aparato dato a dato. Lo
+      // público va en claro; de lo privado solo el NOMBRE del dato: viaja sellado y la
+      // bóveda no lo abre para enseñarlo (§8.1), igual que una variable privada.
+      const vars = data.ns[PROFILE_NS]?.vars || {}
+      const pub = {}
+      const priv = []
+      let at = 0
+      for (const [key, e] of Object.entries(vars)) {
+        if (!e) continue
+        at = Math.max(at, e.at || 0)
+        if (e.cls === 'public' && typeof e.pubv === 'string') pub[key] = e.pubv
+        else priv.push(key)
+      }
+      return { public: pub, private: priv.sort(), updatedAt: at || null }
+    },
+
     profilePublic () {
       const bag = data.ns[PROFILE_NS]
       if (!bag?.vars) return {}

package/src/tui/app.js

@@ -620,6 +620,11 @@ function meRows (st, t) {
   if (filled.length) rows.push({ text: '', sel: false })
   for (const [k, label] of filled) field(label, me[k], me[k + 'Visible'] === false)
 
+  // Lo PRIVADO viaja sellado y la bóveda no lo abre: se dice qué hay, no qué dice.
+  if (Array.isArray(me.privateKeys) && me.privateKeys.length) {
+    rows.push({ text: '', sel: false })
+    field(i.privateData, me.privateKeys.join(', ') + t.muted(i.privateDataHint))
+  }
   for (const [title, list] of [[i.links, me.links], [i.otherData, me.fields]]) {
     if (!Array.isArray(list) || !list.length) continue
     rows.push({ text: '', sel: false })

package/src/tui/i18n.js

@@ -148,6 +148,8 @@ const es = {
   fieldAddress: 'dirección',
   links: 'Enlaces',
   otherData: 'Otros datos',
+  privateData: 'Privados',
+  privateDataHint: '  (sellados: se ven en tus aparatos, no aquí)',
   hidden: '   (oculto)',
   no: 'no',
   helpMe: ['←→ pestaña', 'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'],
@@ -537,6 +539,8 @@ const en = {
   fieldAddress: 'address',
   links: 'Links',
   otherData: 'Other data',
+  privateData: 'Private',
+  privateDataHint: '  (sealed: they show on your devices, not here)',
   hidden: '   (hidden)',
   noName: '(no name)',
   no: 'no',

package/src/vault.js

@@ -3718,6 +3718,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return { ok: true, pub: found.pub, deviceId: found.deviceId }
     },
     listApprovals: () => approvals.list(),
+    // El perfil desde el cajón `@me` (lo que empujan los aparatos): ver `profileView`.
+    profileView: () => secrets.profileView(),
     // LAS CONCESIONES VIVAS, para verlas y para cortarlas. Se enseñan en la máquina del
     // dueño (TUI/CLI), donde el contexto ya es suyo y no hay nada que sellar.
     listGrants: () => grants.list(),

package/src/vaultControl.js

@@ -500,7 +500,8 @@ export async function getMe (profile) {
   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)
+  // Con el perfil cerrado llega igual lo público (ver `perfilParaMostrar` en daemon.js).
+  if (d.locked && !d.me) assertOpen(d)
   return d.me || null
 }