@dotrino/vaultd 0.129.0 → 0.130.0

package/package.json

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

package/src/ctl.js

@@ -1715,9 +1715,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 +1727,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 +1746,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) }
 
@@ -1754,7 +1770,7 @@ async function cmdUpdate (args = []) {
   console.log('listo')
 
   process.stdout.write('Comprobando la firma… ')
-  const v = verifyArtifact(file)
+  const v = await verifyArtifact(file)
   if (!v.ok) {
     console.log('')
     console.error('%sNO se instala nada.%s %s', R, Z, v.reason)

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'
 
@@ -1025,11 +1025,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/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 []