@dotrino/vaultd 0.13.0 → 0.15.0

package/package.json

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

@@ -231,6 +231,47 @@ function secretRows (st, t) {
   return rows
 }
 
+/**
+ * PERFIL del usuario: nombre, foto y datos, tal como los tiene la bóveda. Es lo que se
+ * edita en un dispositivo emparejado y se sincroniza aquí; esta pantalla sirve para
+ * comprobar que llegó.
+ *
+ * Solo lectura A PROPÓSITO: el perfil se edita donde lo usas (el aparato), no en el
+ * servidor donde vive la bóveda. Aquí se mira.
+ */
+function meRows (st, t) {
+  const i = L(st)
+  const me = st.me
+  if (me === undefined) return [{ text: t.muted(i.loading), sel: false }]
+  if (!me) return [{ text: t.muted(i.noProfile), sel: false }, { text: '', sel: false }, { text: t.muted(i.noProfileHint), sel: false }]
+
+  const rows = []
+  const campo = (etiqueta, valor, oculto) => rows.push({
+    text: `  ${t.muted(String(etiqueta).padEnd(12))} ${valor}${oculto ? t.muted(i.hidden) : ''}`, sel: false
+  })
+  rows.push({ text: t.muted(i.profileUpdated(me.updatedAt ? new Date(me.updatedAt).toLocaleString() : '—')), sel: false })
+  rows.push({ text: '', sel: false })
+  campo(i.fieldName, me.nickname ? t.bold(me.nickname) : t.muted(i.noName))
+  campo(i.fieldPhoto, me.avatar
+    ? `${me.avatar.type || '?'} · ${(me.avatar.bytes / 1024).toFixed(1)} KB`
+    : t.muted(i.no))
+
+  const STD = [['nombres', i.fieldFirstName], ['apellidos', i.fieldLastName], ['email', i.fieldEmail],
+    ['telefono', i.fieldPhone], ['direccion', i.fieldAddress]]
+  const puestos = STD.filter(([k]) => me[k])
+  if (puestos.length) rows.push({ text: '', sel: false })
+  for (const [k, etiqueta] of puestos) campo(etiqueta, me[k], me[k + 'Visible'] === false)
+
+  for (const [titulo, lista] of [[i.links, me.links], [i.otherData, me.fields]]) {
+    if (!Array.isArray(lista) || !lista.length) continue
+    rows.push({ text: '', sel: false })
+    rows.push({ text: t.accent(' ▸ ' + titulo), sel: false })
+    for (const x of lista) campo(x.type || x.label || '', x.value, x.visible === false)
+  }
+  if (me.avatar) { rows.push({ text: '', sel: false }); rows.push({ text: t.muted(i.savePhotoHint), sel: false }) }
+  return rows
+}
+
 // --------------------------------- entrada ---------------------------------
 
 function setInput (st, opts) {
@@ -266,6 +307,10 @@ async function refreshSecrets (term, st) {
   const r = await guard(term, st, L(st).loadingSecrets, () => vc.listSecrets(activeId(st)))
   if (r.ok) st.secrets = r.v
 }
+async function refreshMe (term, st) {
+  const r = await guard(term, st, L(st).loadingProfile, () => vc.getMe(activeId(st)))
+  st.me = r.ok ? r.v : null
+}
 async function refreshProfiles (term, st) {
   const r = await guard(term, st, L(st).loadingVaults, () => vc.listProfiles())
   if (r.ok) st.profiles = r.v
@@ -557,6 +602,31 @@ async function onKeyPairing (term, st, key) {
   return true
 }
 
+/**
+ * Teclas del PERFIL: refrescar y guardar la foto. Nada de editar — el perfil se edita en
+ * el dispositivo que usas, no en la máquina donde vive la bóveda.
+ */
+async function onKeyMe (term, st, key) {
+  const i = L(st)
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+  if (ch === 'r') {
+    await refreshMe(term, st)
+  } else if (ch === 'f' && st.me?.avatar) {
+    setInput(st, {
+      label: i.savePhotoLabel,
+      hint: i.savePhotoHintInput,
+      value: 'perfil.png',
+      onSubmit: async (valor) => {
+        const destino = String(valor || '').trim()
+        if (!destino) return
+        const r = await guard(term, st, i.savingPhoto, () => vc.saveAvatar(destino, activeId(st)))
+        if (r.ok && r.v) flash(st, i.photoSaved(r.v))
+      }
+    })
+  }
+  return true
+}
+
 async function onKeySecrets (term, st, key) {
   const i = L(st)
   const rows = secretRows(st, term.t)
@@ -659,15 +729,16 @@ async function onConfirmKey (st, key) {
 
 // Pestañas INTERNAS de una bóveda ya elegida: se cambian con ←→. La lista de
 // bóvedas (profiles) es el nivel de arriba (se entra con Enter, no es una pestaña).
-const INNER_TABS = ['devices', 'secrets']
-const tabLabel = (i, k) => (k === 'devices' ? i.tabDevices : i.tabSecrets)
+const INNER_TABS = ['devices', 'secrets', 'me']
+const tabLabel = (i, k) => ({ devices: i.tabDevices, secrets: i.tabSecrets, me: i.tabMe })[k]
 
 const helpSegs = (i, screen) => ({
   profiles: i.helpProfiles,
   devices: i.helpDevices,
   secrets: i.helpSecrets,
   pairing: i.helpPairing,
-  pairmode: i.helpPairMode
+  pairmode: i.helpPairMode,
+  me: i.helpMe
 })[screen] || []
 
 const title = (i, screen) => ({
@@ -758,6 +829,7 @@ function render (term, st) {
   if (st.screen === 'profiles') body = renderList(profileRows(st, t), st.sel.profiles, contentH, cols, t, scrollRef)
   else if (st.screen === 'devices') body = renderList(deviceRows(st, t), st.sel.devices, contentH, cols, t, scrollRef)
   else if (st.screen === 'secrets') body = renderList(secretRows(st, t), st.sel.secrets, contentH, cols, t, scrollRef)
+  else if (st.screen === 'me') body = renderList(meRows(st, t), -1, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairmode') body = renderList(pairModeRows(st, t), st.sel.pairmode, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairing') {
     const pb = pairingBody(st, t, cols, contentH)
@@ -896,6 +968,9 @@ export async function runTui () {
       if ((key.name === 'left' || key.name === 'right') && INNER_TABS.includes(st.screen)) {
         const n = INNER_TABS.indexOf(st.screen)
         st.screen = INNER_TABS[(n + (key.name === 'right' ? 1 : -1) + INNER_TABS.length) % INNER_TABS.length]
+        // El perfil se pide al ENTRAR en su pestaña, no al arrancar: es contenido del
+        // usuario y no hay por qué sacarlo del cifrado si nadie lo está mirando.
+        if (st.screen === 'me' && st.me === undefined) await refreshMe(term, st)
         continue
       }
       // Esc/'b' desde una pestaña vuelve a la lista de bóvedas (salir de la bóveda
@@ -907,6 +982,7 @@ export async function runTui () {
       if (st.screen === 'profiles') running = await onKeyProfiles(term, st, key)
       else if (st.screen === 'devices') running = await onKeyDevices(term, st, key)
       else if (st.screen === 'secrets') running = await onKeySecrets(term, st, key)
+      else if (st.screen === 'me') running = await onKeyMe(term, st, key)
       else if (st.screen === 'pairmode') running = await onKeyPairMode(term, st, key)
       else if (st.screen === 'pairing') running = await onKeyPairing(term, st, key)
     }
@@ -916,4 +992,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, profileRows, deviceRows, secretRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang }
+export const __test = { render, profileRows, deviceRows, secretRows, meRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang }

package/src/tui/i18n.js

@@ -34,6 +34,31 @@ const es = {
   // pestañas y títulos
   tabDevices: 'Dispositivos',
   tabSecrets: 'Scopes y variables',
+  tabMe: 'Perfil',
+  // Perfil del usuario (lo que sincronizan los dispositivos). Solo lectura: se edita en
+  // el aparato, no en la máquina donde vive la bóveda.
+  loadingProfile: 'Cargando el perfil…',
+  noProfile: '  (esta bóveda todavía no tiene perfil)',
+  noProfileHint: '  Edita tu nombre o tu foto en un dispositivo emparejado y pulsa R.',
+  profileUpdated: (cuando) => `  actualizado ${cuando}`,
+  fieldName: 'nombre',
+  fieldPhoto: 'foto',
+  fieldFirstName: 'nombres',
+  fieldLastName: 'apellidos',
+  fieldEmail: 'correo',
+  fieldPhone: 'teléfono',
+  fieldAddress: 'dirección',
+  links: 'Enlaces',
+  otherData: 'Otros datos',
+  hidden: '   (oculto)',
+  noName: '(sin nombre)',
+  no: 'no',
+  savePhotoHint: '  Pulsa F para guardar la foto y poder verla.',
+  savePhotoLabel: '¿Dónde guardo la foto?',
+  savePhotoHintInput: 'ruta del archivo (Esc cancela)',
+  savingPhoto: 'Guardando la foto…',
+  photoSaved: (ruta) => `Foto guardada en ${ruta}`,
+  helpMe: ['←→ pestaña', 'r refrescar', 'f guardar foto', 'Esc bóvedas', 'l English', 'q salir'],
   tabsHint: '   (←→ cambiar)',
   titleProfiles: 'Bóvedas',
   titlePairing: 'Emparejar un dispositivo',
@@ -203,6 +228,29 @@ const en = {
 
   tabDevices: 'Devices',
   tabSecrets: 'Scopes & variables',
+  tabMe: 'Profile',
+  loadingProfile: 'Loading profile…',
+  noProfile: '  (this vault has no profile yet)',
+  noProfileHint: '  Edit your name or photo on a paired device and press R.',
+  profileUpdated: (cuando) => `  updated ${cuando}`,
+  fieldName: 'name',
+  fieldPhoto: 'photo',
+  fieldFirstName: 'first name',
+  fieldLastName: 'last name',
+  fieldEmail: 'email',
+  fieldPhone: 'phone',
+  fieldAddress: 'address',
+  links: 'Links',
+  otherData: 'Other data',
+  hidden: '   (hidden)',
+  noName: '(no name)',
+  no: 'no',
+  savePhotoHint: '  Press F to save the photo so you can look at it.',
+  savePhotoLabel: 'Where should I save the photo?',
+  savePhotoHintInput: 'file path (Esc cancels)',
+  savingPhoto: 'Saving the photo…',
+  photoSaved: (ruta) => `Photo saved to ${ruta}`,
+  helpMe: ['←→ tab', 'r refresh', 'f save photo', 'Esc vaults', 'l Español', 'q quit'],
   tabsHint: '   (←→ switch)',
   titleProfiles: 'Vaults',
   titlePairing: 'Pair a device',

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 } })

package/src/vaultControl.js

@@ -32,6 +32,7 @@ const F = {
   devices: 'devices.json',
   profilesList: 'profiles-list.json',
   secretsList: 'secrets-list.json',
+  me: 'me.json',
   // peticiones (las escribe el control; el daemon las consume y borra)
   pairReq: 'pair-request.json',
   approveReq: 'approve-request.json',
@@ -39,6 +40,7 @@ const F = {
   revokeReq: 'revoke-request.json',
   secretReq: 'secret-request.json',
   profileReq: 'profile-request.json',
+  meReq: 'me-request.json',
   dumpReq: 'dump-request.json'
 }
 
@@ -206,6 +208,44 @@ export async function revokeDevice (nonce, profile) {
   return listDevices(profile)
 }
 
+// ---------------------------------------------------------------------------
+// Perfil del usuario (lo que sincronizan los dispositivos)
+// ---------------------------------------------------------------------------
+
+/**
+ * El PERFIL del usuario tal como lo tiene la bóveda: nombre, foto y datos. Es lo que se
+ * edita en cualquier dispositivo emparejado y se sincroniza aquí, así que sirve para
+ * comprobar que lo que cambiaste en el aparato llegó.
+ *
+ * No es lo mismo que `listProfiles` (las cuentas de ESTE PC) ni que el acta (quién es del
+ * perfil): esto es el CONTENIDO. La foto llega resumida (tipo y tamaño), no en bytes:
+ * nadie va a mirar un data-URI de 90 KB en una terminal.
+ *
+ * El volcado es contenido del usuario, así que se lee y se BORRA en el acto.
+ */
+export async function getMe (profile) {
+  requireAlive()
+  rm(F.me)
+  writeReq(F.meReq, {}, profile)
+  signalOrCleanup('SIGUSR2', [F.meReq])
+  const d = await waitFor(F.me)
+  rm(F.me)
+  if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
+  return d.me || null
+}
+
+/** Escribe la foto de perfil en `destino` (para poder mirarla) y devuelve la ruta. */
+export async function saveAvatar (destino, profile) {
+  requireAlive()
+  rm(F.me)
+  writeReq(F.meReq, { avatarPath: destino }, profile)
+  signalOrCleanup('SIGUSR2', [F.meReq])
+  const d = await waitFor(F.me)
+  rm(F.me)
+  if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
+  return d.avatarGuardada || null
+}
+
 // ---------------------------------------------------------------------------
 // Secretos: scopes (namespaces) y variables (claves)
 // ---------------------------------------------------------------------------