@dotrino/vaultd 0.14.0 → 0.16.0

package/package.json

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

@@ -257,18 +257,14 @@ function cmdReject (deviceId) {
  * 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.
+ * De la foto solo se dice que la hay, de qué tipo y cuánto pesa: es un data-URI de hasta
+ * ~90 KB y una terminal no es sitio para volcarlo.
  */
-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) }
-
+async function cmdMe () {
   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) } : {}) })
+  writeReq('me-request.json', {})
   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 } }
@@ -306,8 +302,6 @@ async function cmdMe (args = []) {
     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('')
 }
 
@@ -691,7 +685,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 'me': return cmdMe()
     case 'members': return cmdMembers()
     case 'caps': return cmdCaps(rest)
     case 'revoke': return cmdRevoke(rest[0])

package/src/daemon.js

@@ -257,7 +257,7 @@ export async function runDaemon () {
       // 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.
+      // una terminal): solo se dice que la hay, de qué tipo y cuánto pesa.
       const meReq = readJsonSafe(meReqFile)
       if (meReq) {
         rm(meReqFile)
@@ -265,15 +265,7 @@ export async function runDaemon () {
           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 })
+          writeJson(meFile, { v: 1, at: Date.now(), profile: tm.id, me: me ? { ...resto, avatar: avatarInfo(avatar) } : null })
         } catch (e) { console.error('[vault] could not dump the profile:', e.message) }
       }
     } catch (e) {

package/src/tui/app.js

@@ -231,6 +231,46 @@ 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)
+  }
+  return rows
+}
+
 // --------------------------------- entrada ---------------------------------
 
 function setInput (st, opts) {
@@ -266,6 +306,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 +601,15 @@ async function onKeyPairing (term, st, key) {
   return true
 }
 
+/**
+ * Teclas del PERFIL: solo refrescar. 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) {
+  if (key.name === 'char' && key.ch.toLowerCase() === 'r') await refreshMe(term, st)
+  return true
+}
+
 async function onKeySecrets (term, st, key) {
   const i = L(st)
   const rows = secretRows(st, term.t)
@@ -659,15 +712,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 +812,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 +951,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 +965,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 +975,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,26 @@ 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',
+  helpMe: ['←→ pestaña', 'r refrescar', 'Esc bóvedas', 'l English', 'q salir'],
   tabsHint: '   (←→ cambiar)',
   titleProfiles: 'Bóvedas',
   titlePairing: 'Emparejar un dispositivo',
@@ -203,6 +223,24 @@ 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',
+  helpMe: ['←→ tab', 'r refresh', 'Esc vaults', 'l Español', 'q quit'],
   tabsHint: '   (←→ switch)',
   titleProfiles: 'Vaults',
   titlePairing: 'Pair a device',

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,33 @@ 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
+}
+
+
 // ---------------------------------------------------------------------------
 // Secretos: scopes (namespaces) y variables (claves)
 // ---------------------------------------------------------------------------