@dotrino/vaultd 0.148.1 → 0.150.0

package/README.md

@@ -141,13 +141,32 @@ clic, o en la terminal:
 sudo apt install ./dotrino-vault_*.deb
 ```
 
-Deja los binarios en `/usr/bin` e instala la unidad `systemd --user` en
-`/usr/lib/systemd/user`, habilitada para **todos** los usuarios de la máquina (cada
-uno con su propia bóveda en su `$HOME`): te arranca sola en tu **próximo inicio de
-sesión**. Para levantarla ya, `systemctl --user start dotrino-vault`; si estabas
+Instala la unidad `systemd --user` en `/usr/lib/systemd/user`, habilitada para
+**todos** los usuarios de la máquina (cada uno con su propia bóveda en su `$HOME`): te
+arranca sola en tu **próximo inicio de sesión**.
+
+**El paquete no deja la bóveda en `/usr/bin`: deja un lanzador** (desde la 0.150.0,
+`packaging/pkg-launcher.sh`). El binario viene en `/usr/lib/dotrino-vault` y el lanzador lo
+copia a `~/.local/share/dotrino/bin` de cada usuario la primera vez, y lo corre desde ahí.
+Es la misma instalación de usuario del tarball, así que **se actualiza sola, sin `sudo`**
+(CONVENCIONES §15). Un paquete más nuevo repone esa copia; uno más viejo que la copia no la
+toca. Quitar el paquete no borra ni esa copia ni tus datos. Para levantarla ya, `systemctl --user start dotrino-vault`; si estabas
 **actualizando**, el servicio viejo sigue corriendo y hay que reiniciarlo con
 `systemctl --user restart dotrino-vault`.
 
+**Fedora / RHEL / openSUSE — `.rpm`:** el mismo instalador, para las distribuciones que
+usan `rpm`. Deja exactamente lo mismo que el `.deb` (el lanzador, la copia en tu carpeta
+que se actualiza sola, y la unidad `systemd --user` para todos los usuarios):
+
+```sh
+sudo dnf install ./dotrino-vault-*.x86_64.rpm      # Fedora, RHEL y derivadas
+sudo zypper install --allow-unsigned-rpm ./dotrino-vault-*.x86_64.rpm   # openSUSE
+```
+
+El `.rpm` no lleva firma GPG (por eso `zypper` pide `--allow-unsigned-rpm`); lo que
+prueba de dónde salió es la atestación de sigstore del release:
+`gh attestation verify dotrino-vault-*.x86_64.rpm --repo imdotrino/dotrino-vault`.
+
 **Otro Linux x64 con systemd — tarball:**
 
 ```sh
@@ -160,13 +179,13 @@ Hace lo equivalente en tu `$HOME` (`~/.local/bin` + `~/.config/systemd/user`) y
 paso más allá: lo **arranca en el acto** y activa `linger`, así el vault corre desde
 el arranque de la máquina aunque no inicies sesión.
 
-El binario del tarball y el `.deb` son **x64/amd64** y el instalador **necesita
+El binario del tarball, el `.deb` y el `.rpm` son **x64/amd64** y el instalador **necesita
 systemd** (si no lo encuentra, se detiene y te dice cómo arrancar el daemon a mano).
 Para ARM —una Raspberry— o para un Linux sin systemd, usa Docker o `npx`.
 
 Ambos traen **Node embebido**: no necesitas instalar Node ni dependencias de npm. Lo
 único que esperan del sistema es `libatomic1`, que casi todas las distribuciones
-traen puesta; el `.deb` la declara y la instala sola si falta. Con el tarball, en un
+traen puesta; el `.deb` y el `.rpm` la declaran y se instala sola si falta. Con el tarball, en un
 sistema muy pelado (un contenedor mínimo), instálala tú: `sudo apt install
 libatomic1`.
 
@@ -190,8 +209,8 @@ curl -fsSL https://install.dotrino.com/install.sh | sh -s -- @dotrino/vaultd
 & ([scriptblock]::Create((irm https://install.dotrino.com/install.ps1))) @dotrino/vaultd
 ```
 
-**Docker (cualquier sistema, y la única vía *empaquetada* para ARM — el `.deb` y el
-tarball son solo x64; `npx` también sirve en una Raspberry):**
+**Docker (cualquier sistema, y la única vía *empaquetada* para ARM — el `.deb`, el `.rpm` y
+el tarball son solo x64; `npx` también sirve en una Raspberry):**
 
 ```sh
 docker volume create dotrino-vault
@@ -615,6 +634,7 @@ npm test                             # 118 pruebas (node --test, sin dependencia
 
 bash packaging/build.sh              # binario único SEA + tarball de Linux (dist/)
 bash packaging/build-deb.sh          # el .deb (requiere dpkg-deb; construye el binario si falta)
+bash packaging/build-rpm.sh          # el .rpm (requiere rpmbuild: `apt install rpm`; mismo binario)
 bash packaging/build-win.sh          # .exe + .zip de Windows, cruzado desde Linux (sin probar)
 docker build -t dotrino-vault .      # la imagen (la misma que CI publica en GHCR)
 ```
@@ -628,8 +648,8 @@ hermano en `../dotrino-proxy` (`secrets.e2e`, `multiprofile.e2e`,
 `pairing-cita.e2e`): no se saltan solos, así que sin ese repo al lado `npm test`
 falla.
 
-Etiquetar `vaultd-v<ver>` publica la imagen de Docker en GHCR; el `.deb` y el tarball
-se suben a la release a mano.
+Etiquetar `vaultd-v<ver>` publica la imagen de Docker en GHCR. Etiquetar `v<ver>` lanza
+`release.yml`, que construye, atestigua y sube a la release el `.deb`, el `.rpm` y el tarball.
 
 ### Enrolar y usar desde un dispositivo (Node, para testing)
 

package/bin/dotrino-vaultd.js

@@ -76,10 +76,10 @@ if (process.argv.includes('--pair')) {
   // que pedírsela) en vez de la dirección de la conexión.
   const { qr, expiresInMs } = await mgr.current().startPairing({ label: 'cli' })
   const { url, b64 } = pairUrl(qr)
-  console.log(`\nEmparejá un dispositivo (válido ${expiresInMs / 60000} min):\n`)
+  console.log(`\nEmpareja un dispositivo (válido ${expiresInMs / 60000} min):\n`)
   console.log(qrToString(url))
   console.log(url)
-  console.log('\nO pegá este código:\n  ' + b64)
+  console.log('\nO pega este código:\n  ' + b64)
 }
 
 // --tui: la bóveda Y su interfaz en la MISMA ventana. Donde no queda como servicio

package/package.json

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

@@ -1792,7 +1792,7 @@ async function cmdLogins (rest) {
  * solo: pide permiso a un aparato con `aprueba` (el teléfono, un navegador…) si lo hay y,
  * si no hay ninguno, 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`.
+ * paquete del sistema (`.deb` o `.rpm`) 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.
@@ -1904,14 +1904,15 @@ async function cmdUpdate (args = []) {
   }
   console.log('firmada por el release de %s ✓', 'imdotrino/dotrino-vault')
 
-  if (pick.kind === 'deb') {
+  if (pick.kind === 'deb' || pick.kind === 'rpm') {
+    const cmd = pick.kind === 'deb' ? ['dpkg', '-i'] : ['rpm', '-U']
     if (typeof process.getuid === 'function' && process.getuid() === 0) {
-      execFileSync('dpkg', ['-i', file], { stdio: 'inherit' })
+      execFileSync(cmd[0], [cmd[1], file], { stdio: 'inherit' })
     } else {
       // No se pide sudo por dentro: que la contraseña la escriba quien la escribe, en su
       // terminal y viendo qué comando la pide.
       console.log('\nYa verificada. Instálala con:')
-      console.log('  %ssudo dpkg -i %s%s', B, file, Z)
+      console.log('  %ssudo %s %s%s', B, cmd.join(' '), file, Z)
       console.log('\nEl servicio se reinicia solo al cambiar el binario.')
       return
     }

package/src/daemon.js

@@ -1157,7 +1157,7 @@ export async function runDaemon () {
     }
     const conAvisos = quienAprueba.filter((a) => a.notifiedAt).length
 
-    // INSTALADA COMO PAQUETE DEL SISTEMA (.deb en /usr/bin): el binario es de root y este
+    // INSTALADA COMO PAQUETE DEL SISTEMA (.deb o .rpm 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`)

package/src/update.js

@@ -25,15 +25,28 @@ export const latestRelease = (opts = {}) =>
   latestVersion({ source: 'github', repo: REPO, product: 'dotrino-vault', version: VERSION, ...opts })
 
 /**
- * Qué archivo le toca a esta máquina. El `.deb` donde hay `dpkg`; en cualquier otro Linux,
- * el tarball. Fuera de Linux no se emite binario, y se dice en vez de bajar algo inútil.
+ * Con qué instala paquetes esta máquina: `'deb'`, `'rpm'` o `null` (ninguno de los dos).
+ * `dpkg` va primero: en Debian y Ubuntu es normal tener además la herramienta `rpm`
+ * instalada (para empaquetar), y ahí lo que instala sigue siendo `dpkg`.
  */
-export function assetFor (assets, { platform = process.platform, arch = process.arch, hasDpkg = null } = {}) {
+export function systemPackager (exists = fs.existsSync) {
+  if (exists('/usr/bin/dpkg')) return 'deb'
+  if (exists('/usr/bin/rpm')) return 'rpm'
+  return null
+}
+
+/**
+ * Qué archivo le toca a esta máquina. El `.deb` donde se instala con `dpkg`, el `.rpm`
+ * donde se instala con `rpm` (Fedora, RHEL, openSUSE); en cualquier otro Linux, el tarball.
+ * Fuera de Linux no se emite binario, y se dice en vez de bajar algo inútil.
+ */
+export function assetFor (assets, { platform = process.platform, arch = process.arch, packager = undefined } = {}) {
   if (platform !== 'linux') return { ok: false, reason: `there is no binary for ${platform}: update with npm (npx @dotrino/vaultd)` }
   if (arch !== 'x64') return { ok: false, reason: `there is no binary for ${arch}` }
-  const deb = hasDpkg === null ? fs.existsSync('/usr/bin/dpkg') : hasDpkg
+  const pk = packager === undefined ? systemPackager() : packager
   return pickAsset(assets, [
-    { kind: 'deb', re: /_amd64\.deb$/, when: () => deb },
+    { kind: 'deb', re: /_amd64\.deb$/, when: () => pk === 'deb' },
+    { kind: 'rpm', re: /\.x86_64\.rpm$/, when: () => pk === 'rpm' },
     { kind: 'tar', re: /-linux-x64\.tar\.gz$/ }
   ])
 }