@dotrino/vaultd 0.13.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.13.0",
+  "version": "0.14.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": {

package/src/ctl.js

@@ -249,6 +249,68 @@ function cmdReject (deviceId) {
   console.log('Rechazado %s.', deviceId)
 }
 
+/**
+ * `dotrino-vault me` — el PERFIL del usuario tal como lo tiene la bóveda: apodo, foto y
+ * datos. Es lo que editas en cualquier dispositivo emparejado y se sincroniza aquí, así
+ * que sirve para comprobar que lo que cambiaste en el aparato llegó de verdad.
+ *
+ * Distinto de `members` (quién es del perfil) y de `profile` (los perfiles del PC): esto
+ * es el CONTENIDO, no la identidad.
+ *
+ * La foto no se imprime —es un data-URI de hasta ~90 KB— sino que se resume;
+ * `me --foto <archivo>` la escribe en disco para poder mirarla.
+ */
+async function cmdMe (args = []) {
+  const i = args.findIndex((a) => a === '--foto' || a === '--photo')
+  const avatarPath = i >= 0 ? args[i + 1] : null
+  if (i >= 0 && !avatarPath) { console.error('uso: dotrino-vault me --foto <archivo>'); process.exit(2) }
+
+  const s = requireDaemon()
+  const meFile = path.join(dir, 'me.json')
+  try { fs.rmSync(meFile, { force: true }) } catch (_) {}
+  writeReq('me-request.json', { ...(avatarPath ? { avatarPath: path.resolve(avatarPath) } : {}) })
+  avisar(s.pid, 'SIGUSR2')
+  let dump = null
+  for (let n = 0; n < 50; n++) { await sleep(100); const d = readJson(meFile, null); if (d?.at) { dump = d; break } }
+  // 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) }
+
+  const me = dump.me
+  if (!me) {
+    console.log('\nTodavía no hay perfil en esta bóveda.')
+    console.log('Edita tu nombre o tu foto en un dispositivo emparejado y vuelve a mirar.\n')
+    return
+  }
+
+  const cuando = me.updatedAt ? new Date(me.updatedAt).toLocaleString() : '—'
+  console.log('\n%sPerfil%s · actualizado %s\n', B, Z, cuando)
+  console.log('  nombre      : %s', me.nickname || '(sin nombre)')
+  console.log('  foto        : %s', me.avatar
+    ? `sí · ${me.avatar.type || 'desconocido'} · ${(me.avatar.bytes / 1024).toFixed(1)} KB`
+    : 'no')
+
+  // Los campos estándar. `visible` es del usuario: teléfono y dirección nacen ocultos.
+  const STD = [['nombres', 'nombres'], ['apellidos', 'apellidos'], ['email', 'correo'],
+    ['telefono', 'teléfono'], ['direccion', 'dirección']]
+  const puestos = STD.filter(([k]) => me[k])
+  if (puestos.length) {
+    console.log('')
+    for (const [k, etiqueta] of puestos) {
+      console.log('  %s: %s%s', etiqueta.padEnd(12), me[k], me[k + 'Visible'] === false ? '   (oculto)' : '')
+    }
+  }
+  for (const [titulo, lista] of [['Enlaces', me.links], ['Otros datos', me.fields]]) {
+    if (!Array.isArray(lista) || !lista.length) continue
+    console.log('\n  %s:', titulo)
+    for (const x of lista) console.log('    %s %s%s', (x.type || x.label || '').padEnd(12), x.value, x.visible === false ? '   (oculto)' : '')
+  }
+
+  if (dump.avatarGuardada) console.log('\n  Foto escrita en: %s', dump.avatarGuardada)
+  else if (me.avatar) console.log('\n  Para verla:  dotrino-vault me --foto ~/perfil.png')
+  console.log('')
+}
+
 /**
  * `dotrino-vault members` — el ACTA del perfil: qué llaves son tuyas y qué puede hacer cada
  * una. Es la misma información que muestra la consola de vault.dotrino.com.
@@ -584,6 +646,7 @@ function help () {
   approve <código>    aprueba el dispositivo tipeando el código que MUESTRA (el vault no lo sabe)
   reject <deviceId>   rechaza un dispositivo pendiente
   devices             lista dispositivos enrolados / revocados
+  me                  tu perfil (nombre, foto, datos) tal como lo tiene la bóveda
   members             el acta del perfil: quién es tuyo y qué puede hacer
   caps <ID> ±permiso  cambia permisos (+firma -guarda +administra …)
   revoke <nonce>      revoca un dispositivo (le ordena autoborrarse)
@@ -628,6 +691,7 @@ export async function runCtl (argv) {
     case 'approve': return cmdApprove(rest[0])
     case 'reject': return cmdReject(rest[0])
     case 'devices': return cmdDevices()
+    case 'me': return cmdMe(rest)
     case 'members': return cmdMembers()
     case 'caps': return cmdCaps(rest)
     case 'revoke': return cmdRevoke(rest[0])

package/src/daemon.js

@@ -154,6 +154,16 @@ export async function runDaemon () {
   const secretsListFile = path.join(dir, 'secrets-list.json')
   const profileReqFile = path.join(dir, 'profile-request.json')
   const dumpReqFile = path.join(dir, 'dump-request.json')
+  const meReqFile = path.join(dir, 'me-request.json')
+  const meFile = path.join(dir, 'me.json')
+
+  /** 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
+    const m = /^data:([^;,]+)?(?:;base64)?,(.*)$/s.exec(avatar)
+    if (!m) return { type: null, bytes: avatar.length }
+    return { type: m[1] || 'desconocido', bytes: Math.floor(m[2].length * 3 / 4) }
+  }
 
   /**
    * Órdenes de perfil (crear/renombrar/borrar/activar) y del candado
@@ -242,6 +252,30 @@ export async function runDaemon () {
       writeJson(devFile, { v: 1, at: Date.now(), profile: t.id, ...(await t.vault.listDevices()) })
       // Acta del perfil: quién es del perfil y qué puede hacer cada uno (`members`/`caps`).
       try { writeJson(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), profile: t.id, ...(await t.vault.profileMembers()) }) } catch (_) {}
+
+      // PERFIL del usuario (apodo, foto, datos) tal como lo tiene la bóveda: `dotrino-vault me`.
+      // Solo se vuelca cuando se PIDE, no en cada señal: es contenido del usuario y no tiene
+      // por qué quedar escrito en un archivo suelto cada vez que alguien mira los miembros.
+      // La FOTO no entra en el volcado (son hasta ~90 KB de data-URI que nadie va a leer en
+      // una terminal): se resume, y si la quieres, `--foto <archivo>` la escribe donde digas.
+      const meReq = readJsonSafe(meReqFile)
+      if (meReq) {
+        rm(meReqFile)
+        try {
+          const tm = resolveTarget(meReq) || { id: mgr.currentId(), vault: mgr.current() }
+          const { me } = tm.vault.threads.methods.profileGet()
+          const { avatar, ...resto } = me || {}
+          let guardada = null
+          if (meReq.avatarPath && typeof avatar === 'string') {
+            const m = /^data:([^;,]+)?(?:;base64)?,(.*)$/s.exec(avatar)
+            if (m) {
+              fs.writeFileSync(meReq.avatarPath, Buffer.from(m[2], 'base64'), { mode: 0o600 })
+              guardada = meReq.avatarPath
+            }
+          }
+          writeJson(meFile, { v: 1, at: Date.now(), profile: tm.id, me: me ? { ...resto, avatar: avatarInfo(avatar) } : null, avatarGuardada: guardada })
+        } catch (e) { console.error('[vault] could not dump the profile:', e.message) }
+      }
     } catch (e) {
       console.error('[vault] error handling a control signal:', e.message)
     }

package/src/vault.js

@@ -200,6 +200,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         args = JSON.parse(await identity.openContent(d.enc))
       }
       const result = await threads.methods[d.method](args)
+      // Que un aparato ESCRIBA en tu bóveda queda anotado. Antes solo se auditaba el
+      // rechazo, así que la bitácora contaba quién entró pero no qué hizo después.
+      // Solo la operación y el aparato: nunca el contenido (`activity` es un registro
+      // de seguridad, no una copia de lo que guardas).
+      if (!STORE_READ_METHODS.has(d.method)) {
+        audit('store', { device: await deviceIdOf(chk.device), method: d.method })
+      }
       if (cek) {
         const enc = await identity.sealContent(JSON.stringify(result ?? null))
         return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: { __enc: enc } })