@dotrino/vaultd 0.129.1 → 0.131.0

package/package.json

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

@@ -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)
@@ -1715,9 +1722,10 @@ async function cmdLogins (rest) {
 /**
  * `dotrino-vault update` — TRAER LA VERSIÓN NUEVA, cuando lo escribe una persona.
  *
- * La mitad automática es MIRAR, y la hace el daemon una vez al día (`src/update.js`
- * explica por qué la otra mitad no se automatiza: sería un canal para meter código en la
- * máquina que guarda la maestra sin que nadie diga que sí).
+ * Con la INSTALACIÓN DE USUARIO (`~/.local/share/dotrino/bin`) el daemon ya se actualiza
+ * solo: pide permiso al teléfono si hay aprobadores y, si no los hay, no hace falta
+ * (dueño, 2026-09-24). Esto es lo mismo a mano, sin esperar al aviso del día. Con el
+ * `.deb` del sistema el binario es de root y aquí solo se verifica y se dice el `sudo`.
  *
  * Lo que se baja SE VERIFICA contra la atestación de sigstore antes de tocar el disco, y
  * si no se puede verificar NO SE INSTALA. Que la URL sea la correcta no prueba nada.
@@ -1726,7 +1734,7 @@ async function cmdLogins (rest) {
  * va para que systemd lo levante con el nuevo (`src/selfupdate.js`).
  */
 async function cmdUpdate (args = []) {
-  const { latestRelease, assetFor, download, verifyArtifact, isNewer } = await import('./update.js')
+  const { latestRelease, assetFor, download, verifyArtifact, isNewer, isUserInstall, installUserRelease } = await import('./update.js')
   const soloMirar = args.includes('--check')
 
   process.stdout.write('Mirando qué hay publicado… ')
@@ -1745,6 +1753,21 @@ async function cmdUpdate (args = []) {
   console.log('%sHay %s y esta es la %s.%s', B, r.version, VERSION, Z)
   if (soloMirar) { console.log('Tráela con:  dotrino-vault update'); return }
 
+  // Instalación de usuario: se verifica y se instala aquí mismo, sin sudo.
+  if (isUserInstall()) {
+    process.stdout.write('Bajando y comprobando la firma… ')
+    const res = await installUserRelease(r)
+    if (!res.ok) {
+      console.log('')
+      console.error('%sNO se instala nada.%s %s', R, Z, res.reason)
+      if (res.file) console.error('El archivo quedó en %s, sin tocar nada.', res.file)
+      process.exit(1)
+    }
+    console.log('firmada por el release de %s ✓', 'imdotrino/dotrino-vault')
+    console.log('Instalada la %s. El servicio se reinicia solo; compruébalo con:  dotrino-vault status', res.version)
+    return
+  }
+
   const pick = assetFor(r.assets)
   if (!pick.ok) { console.error('%s', pick.reason); process.exit(1) }
 

package/src/daemon.js

@@ -23,7 +23,7 @@ import { dataDir } from './paths.js'
 import { ipcRead, ipcWrite, migrateIpcDir } from './ipc.js'
 import { parseInvite } from '../lib/src/invite.js'
 import { watchBinary } from './selfupdate.js'
-import { latestRelease, isNewer, CHECK_EVERY_MS } from './update.js'
+import { latestRelease, isNewer, CHECK_EVERY_MS, isUserInstall, installUserRelease } from './update.js'
 import { VERSION } from './version.js'
 import crypto from 'node:crypto'
 
@@ -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) {
@@ -1025,11 +1049,37 @@ export async function runDaemon () {
      */
     let quienAprueba = []
     try { quienAprueba = (await mgr.current()?.approvers?.()) || [] } catch (_) {}
-    const comoLoDice = quienAprueba.length
-      ? `waiting for one of ${quienAprueba.length} approver(s) to say yes`
-      : 'no approver in the record, so this vault may update itself'
-    console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · ${comoLoDice} · dotrino-vault update`)
+
+    // INSTALADA COMO PAQUETE DEL SISTEMA (.deb en /usr/bin): el binario es de root y este
+    // proceso no puede tocarlo. Se dice, con las dos salidas, y no se intenta nada.
+    if (!isUserInstall()) {
+      console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · installed as a system package, so it cannot update itself: \`dotrino-vault update\` (needs sudo), or move to a user install with the tarball's install.sh`)
+      return
+    }
+    if (actualizando) return
+    actualizando = true
+    try {
+      // PIDE PERMISO SOLO SI HAY A QUIÉN PEDÍRSELO (dueño, 2026-09-20); sin aprobadores
+      // no se necesita aprobación (dueño, 2026-09-24).
+      if (quienAprueba.length) {
+        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · asking one of ${quienAprueba.length} approver(s)`)
+        const si = await mgr.current().askUpdateApproval({ version: r.version })
+        if (!si) { console.log(`[vault] update to ${r.version}: not approved (denied or expired) · it will ask again`); return }
+      } else {
+        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · no approver in the record: updating on its own`)
+      }
+      const res = await installUserRelease(r, { log: (m) => console.log(m) })
+      if (!res.ok) {
+        // Lo que NO cuadra no se instala, y se dice por qué: el archivo queda a mano.
+        console.log(`[vault] update to ${r.version} NOT installed: ${res.reason}${res.file ? ` (file left at ${res.file})` : ''}`)
+        return
+      }
+      console.log(`[vault] update: ${r.version} installed · the service restarts on its own`)
+    } catch (e) {
+      console.log(`[vault] update to ${r.version} failed: ${e.message}`)
+    } finally { actualizando = false }
   }
+  let actualizando = false
   mirarRelease()
   const relojRelease = setInterval(mirarRelease, CHECK_EVERY_MS)
   relojRelease.unref?.()

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/update.js

@@ -10,8 +10,11 @@
  * mismo son dos sitios donde arreglar el mismo fallo, y el segundo siempre se olvida.
  */
 import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { execFileSync } from 'node:child_process'
 import { latestVersion, isNewer, CHECK_EVERY_MS } from '@dotrino/update'
-import { pickAsset, download, verifyArtifact as verify } from '@dotrino/update/fetch'
+import { pickAsset, download, verifyArtifact as verify, fetchVerified } from '@dotrino/update/fetch'
 import { VERSION } from './version.js'
 
 export const REPO = 'imdotrino/dotrino-vault'
@@ -37,3 +40,56 @@ export function assetFor (assets, { platform = process.platform, arch = process.
 
 /** Verifica contra la atestación del release del vault. Sin `gh`, no se instala. */
 export const verifyArtifact = (file, opts = {}) => verify(file, { repo: REPO, ...opts })
+
+
+/**
+ * INSTALACIÓN DE USUARIO: los binarios viven en `~/.local/share/dotrino/bin`, que es del
+ * usuario, y la bóveda se actualiza sin `sudo` (dueño, 2026-09-24).
+ *
+ * Es esa carpeta y no `~/.local/bin` por una razón concreta: la unidad de systemd lleva
+ * `ProtectHome=read-only` y solo deja escribir en `~/.local/share/dotrino`. Desde ahí el
+ * daemon puede reemplazar su propio binario; en `~/.local/bin` no podría.
+ *
+ * El precio, dicho: un proceso de ese mismo usuario también podría reemplazarlo, cosa que
+ * con el `.deb` en `/usr/bin` (de root) no. En el modelo de la bóveda la frontera ya es el
+ * usuario (memoria `dotrino-aprobacion-comando`), y el binario nuevo solo entra verificado.
+ */
+export function userBinDir (home = os.homedir()) {
+  return path.join(home, '.local', 'share', 'dotrino', 'bin')
+}
+
+/** ¿Corre este proceso desde la instalación de usuario? Solo entonces puede actualizarse solo. */
+export function isUserInstall (execPath = process.execPath, home = os.homedir()) {
+  return path.dirname(execPath) === userBinDir(home)
+}
+
+/**
+ * Baja el tarball del release, lo VERIFICA contra su atestación y cambia los dos binarios
+ * de forma atómica (se escribe al lado y se renombra encima: nunca queda uno a medias).
+ * `selfupdate.js` ve el binario nuevo y el servicio se reinicia solo.
+ *
+ * Si la verificación falla no se toca nada, y se devuelve por qué.
+ *
+ * @returns {Promise<{ok:true, version:string} | {ok:false, code?:string, reason:string, file?:string}>}
+ */
+export async function installUserRelease (release, { binDir = userBinDir(), log = () => {}, fetchVerifiedImpl = fetchVerified } = {}) {
+  const pick = pickAsset(release.assets, [{ kind: 'tar', re: /-linux-x64\.tar\.gz$/ }])
+  if (!pick.ok) return pick
+  const got = await fetchVerifiedImpl(pick.asset, { repo: REPO, product: 'dotrino-vault', version: VERSION })
+  if (!got.ok) return got
+  log(`[vault] update: ${pick.asset.name} verified against its attestation`)
+  const work = path.dirname(got.file)
+  execFileSync('tar', ['xzf', got.file, '-C', work])
+  const src = fs.readdirSync(work).map((d) => path.join(work, d)).find((d) => fs.existsSync(path.join(d, 'dotrino-vaultd')))
+  if (!src) return { ok: false, code: 'BAD_TARBALL', reason: 'the tarball has no dotrino-vaultd inside' }
+  fs.mkdirSync(binDir, { recursive: true })
+  // El CLI primero y el daemon al final: cambiar el daemon es lo que dispara el reinicio.
+  for (const name of ['dotrino-vault', 'dotrino-vaultd']) {
+    const tmp = path.join(binDir, `.${name}.new`)
+    fs.copyFileSync(path.join(src, name), tmp)
+    fs.chmodSync(tmp, 0o755)
+    fs.renameSync(tmp, path.join(binDir, name))
+  }
+  try { fs.rmSync(work, { recursive: true, force: true }) } catch (_) {}
+  return { ok: true, version: release.version }
+}

package/src/vault.js

@@ -37,7 +37,7 @@ import { loadManifest, brokenOf } from '@dotrino/roadmap'
 // espera reventaba con un ReferenceError y la aprobación del mostrador de contraseñas no
 // llegaba a existir. Solo se veía por ese camino —el único que lo usa—, y no había prueba
 // que lo recorriera hasta que la hubo (dotrino-test, smoke:demonio, 2026-08-30).
-import { createApprovals, createGrants, lastApproverGone, PENDING_TTL_MS, GRANT_TTL_MS } from './approvals.js'
+import { createApprovals, createGrants, lastApproverGone, PENDING_TTL_MS, GRANT_TTL_MS, UPDATE_TTL_MS } from './approvals.js'
 import { readProcContext, sanitizeContext, commandFingerprint, commandLine } from '../lib/src/proc.js'
 import { makeContentKey, encryptWithCek, wrapForMember } from '@dotrino/identity/content'
 import { makeSealer } from './sealer.js'
@@ -167,11 +167,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * variables (la escritura se aplica al aprobar). Si nadie contesta, vence solo con un no:
    * nada se queda colgado para siempre.
    */
-  async function awaitApproval ({ device, ns, kind, what, op = null, ctx = null, onAnswer }) {
+  async function awaitApproval ({ device, ns, kind, what, op = null, ctx = null, onAnswer, ttlMs = PENDING_TTL_MS }) {
     const deviceId = await deviceIdOf(device).catch(() => null)
     const record = await refreshActa()
     const label = (record?.members || []).find((m) => m.pub === device)?.label || ''
-    const pend = approvals.request({ ns, device, deviceId, label, ek: '', ctx, kind })
+    const pend = approvals.request({ ns, device, deviceId, label, ek: '', ctx, kind, ttlMs })
     audit(`${what}.pending`, { device: deviceId, ns, id: pend.id, op })
     log(`[vault] ${what}: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
     waiters.set(pend.id, onAnswer)
@@ -180,7 +180,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         audit(`${what}.expired`, { device: deviceId, ns, id: pend.id })
         onAnswer(false)
       }
-    }, PENDING_TTL_MS)
+    }, ttlMs)
     t.unref?.()
     await notifyApprovers(pend, record)
     return pend
@@ -1621,7 +1621,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       const resolver = waiters.get(id)
       waiters.delete(id)
       const ok = op === 'approve'
-      const what = pend.kind === 'write' ? 'vars' : 'passwords'
+      const what = pend.kind === 'write' ? 'vars' : pend.kind === 'update' ? 'update' : 'passwords'
       audit(ok ? `${what}.approved` : `${what}.denied`, { device: pend.deviceId, ns: pend.ns, id, by })
       log(`[vault] ${what}: request ${pend.id} of ${pend.deviceId} ${ok ? 'approved' : 'DENIED'} by ${by}`)
       // Lo aprobado SE HACE AQUÍ (una escritura se aplica ahora), y si falla quien aprobó
@@ -3655,6 +3655,21 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
      * aprobadores que se quedaría sin poder actualizarse nunca, esperando un sí que nadie
      * puede dar. Mismo sitio del que ya sale el «rang N approver(s)» de los secretos.
      */
+    /**
+     * PEDIR PERMISO PARA ACTUALIZARSE a `version` (la instala el daemon si se aprueba). Es
+     * un pedido como los demás —sale en Pedidos del teléfono, `kind: 'update'`—, pero dura
+     * un día (`UPDATE_TTL_MS`): no hay nadie esperando delante de una terminal.
+     * @returns {Promise<boolean>} sí o no; vencido es no.
+     */
+    askUpdateApproval: async ({ version }) => {
+      const yo = identity.me?.publickey || null
+      return new Promise((resolve) => {
+        awaitApproval({
+          device: yo, ns: 'vault', kind: 'update', what: 'update',
+          ctx: { version, from: VERSION }, ttlMs: UPDATE_TTL_MS, onAnswer: resolve
+        }).catch((e) => { log(`[vault] update: could not ask for approval: ${e.message}`); resolve(false) })
+      })
+    },
     approvers: async () => {
       const record = await refreshActa()
       if (!record) return []
@@ -3703,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
 }