@dotrino/content 0.4.2 → 0.5.0

package/README.md

@@ -47,6 +47,28 @@ Requiere **Node ≥ 22.5**. El core usa solo `node:crypto` y `node:sqlite`; la
 identidad viene de los pilares del ecosistema (`@dotrino/remote-agent`,
 `@dotrino/identity`).
 
+## Actualizarse
+
+El node **se actualiza solo** (CONVENCIONES §15): mira una vez al día si hay versión nueva,
+comprueba lo que entrega npm contra el `npm-integrity.json` de la release de este repo y
+lo instala. Lo hace `@dotrino/update/npm`; aquí solo se cablea.
+
+```sh
+dotrino-content update                    # dice cómo está
+dotrino-content update --approval on      # antes de instalar, pide permiso a quien aprueba en tu bóveda
+dotrino-content update --notify off       # no avisa de que se actualizó
+```
+
+- Los dos ajustes son de **esta instancia** (viven junto a su enlace) y no tienen que ver
+  con el de la bóveda. Por defecto: se actualiza sin preguntar y avisa.
+- El permiso se pide **una vez por versión**; sin respuesta en un día cuenta como no, y
+  `dotrino-content info` lo dice.
+- **Solo se actualiza sola una instalación global de npm en un prefijo del usuario**
+  (`npm i -g @dotrino/content` con nvm o un prefijo propio). Si el prefijo es de root, avisa a
+  quien aprueba de que hay versión y necesita permisos de administrador. Con `npx`, dentro
+  de un proyecto o desde un checkout no se toca nada.
+- Solo se reinicia si hay quien lo levante (systemd, pm2).
+
 ## Plano de control (Fase 2, por el proxy, cifrado)
 
 Con el node enlazado, tus propias apps —cualquier aparato con un certificado de **la

package/bin/cli.js

@@ -3,6 +3,8 @@
  * CLI de dotrino-content.
  *
  *   dotrino-content enroll <código>     enlaza este node a tu vault (una vez)
+ *   dotrino-content update [--approval on|off] [--notify on|off]
+ *                                       cómo se actualiza este node (CONVENCIONES §15)
  *   dotrino-content start [--port 3777] [--dir <ruta>] [--max-gb <n>] [--gc-min <min>]
  *                         [--no-agent]  arranca sin el plano de control
  *                         [--public]    abre el puerto de VISTAS PREVIAS (§7.2)
@@ -34,11 +36,26 @@ const USAGE = `uso:
   dotrino-content enroll <código>
   dotrino-content info [--json]     qué aparato es este node: su ID (el de «dotrino-vault members»),
                                     su bóveda y sus permisos. Sin red.
+  dotrino-content update [--approval on|off] [--notify on|off]
+                                    este node se actualiza solo. --approval on: antes pide permiso a
+                                    quien aprueba en tu bóveda. --notify off: no avisa de que se
+                                    actualizó. Sin opciones, dice cómo está.
   dotrino-content start [--port 3777] [--dir <ruta>] [--max-gb <n>] [--max-blob-mb <n>] [--gc-min <min>] [--no-agent]
                         [--public] [--public-port 3778] [--public-host 0.0.0.0] [--public-max-kb 512]
                         [--public-rate 60] [--public-egress-gb <n>] [--public-url https://…] [--app-url https://…]
                         [--public-index]`
 
+// `update`: los dos ajustes de actualización de ESTA instancia (CONVENCIONES §15). Va antes
+// de `parseArgs` porque `--approval` y `--notify` se pueden dar sin valor (para preguntar
+// cómo están), y `parseArgs` no admite una opción que a veces lleva valor y a veces no.
+if (process.argv[2] === 'update') {
+  const { updatePrefsCommand } = await import('@dotrino/update/npm')
+  const r = updatePrefsCommand(process.argv.slice(3), { dir: linkDir(), lang: 'es' })
+  if (!r.handled) { console.error(`uso: dotrino-content update [--approval on|off] [--notify on|off]`); process.exit(2) }
+  ;(r.ok ? console.log : console.error)(r.text)
+  process.exit(r.ok ? 0 : 2)
+}
+
 const { values, positionals } = parseArgs({
   allowPositionals: true,
   options: {
@@ -84,6 +101,13 @@ if (cmd === 'info') {
   if (!link) { console.error(`este node no está enlazado (${dir}): dotrino-content enroll <código>`); process.exit(1) }
   const info = await deviceInfo(link, { kind: 'content', ns: 'content', version: VERSION, dir })
   console.log(values.json ? JSON.stringify(info, null, 2) : formatDeviceInfo(info))
+  // Y si hay una actualización que no se instaló (no se aprobó, o necesita root), se dice
+  // aquí: es donde se mira qué es este aparato. Fuera del JSON, que lo lee una máquina.
+  if (!values.json) {
+    const { updateStatusText } = await import('@dotrino/update/npm')
+    const estado = updateStatusText({ dir, current: VERSION, lang: 'es' })
+    if (estado) console.log('\n' + estado)
+  }
   process.exit(0)
 }
 
@@ -172,13 +196,6 @@ server.listen(port, '127.0.0.1', () => {
   console.log(`blobs: ${s.blobs}  ·  bytes: ${s.bytes}${maxBytes ? ` / ${maxBytes}` : ''}`)
 })
 
-// §15: una vez al día mira si hay versión nueva y lo dice en el log. Solo avisa.
-const { watchForUpdate } = await import('@dotrino/update')
-watchForUpdate({
-  current: VERSION, source: 'npm', pkg: '@dotrino/content',
-  onNewer: (r) => console.log(`[content] version ${r.version} is available (running ${r.current}): npm i -g @dotrino/content@${r.version}`)
-})
-
 // Plano de control: solo si este node ya está enlazado a un vault. Sin enlace sigue
 // siendo lo de antes (un node local), y se dice en voz alta para que nadie crea que
 // tiene administración remota cuando no la tiene.
@@ -226,11 +243,29 @@ if (values.public) {
   })
 }
 
+/** @type {null | (() => void)} */
+let stopSelfUpdate = null
 const shutdown = () => {
   clearInterval(gcTimer)
+  try { stopSelfUpdate?.() } catch (_) {}
   try { agent?.close() } catch (_) {}
   try { publicServer?.close() } catch (_) {}
   server.close(() => { node.close(); process.exit(0) })
 }
 process.on('SIGINT', shutdown)
 process.on('SIGTERM', shutdown)
+
+// §15: SE ACTUALIZA SOLO. Mira al arrancar y una vez al día; lo que baja se comprueba
+// contra la release de GitHub antes de tocar el disco, y solo se reinicia si hay quien lo
+// levante. Los dos ajustes (`dotrino-content update`) son de esta instancia. Va al final
+// porque reiniciar es `shutdown`. Desde un checkout (el node de Dotrino, que se despliega
+// con git) no se toca nada: lo dice una vez y sigue.
+const { startSelfUpdate } = await import('../src/selfUpdate.js')
+const { serviceDir } = await import('../src/vaultEnv.js')
+stopSelfUpdate = startSelfUpdate({
+  version: VERSION,
+  dir: linkDir(),
+  conn: isEnrolled() ? () => ({ dir: serviceDir() }) : null,
+  restart: shutdown,
+  log
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/content",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Nodo de contenido del ecosistema Dotrino: guarda los bytes del usuario direccionados por su hash (cid), en su propia maquina y, si el dueno quiere, respaldados en su propio bucket (R2, Backblaze, Hetzner, Storj o S3). Lo publico sale por URL directa; lo privado, cifrado y solo por la red Dotrino.",
   "type": "module",
   "bin": {
@@ -25,9 +25,9 @@
   "dependencies": {
     "@dotrino/identity": "0.105.0",
     "@dotrino/proxy-client": "0.25.0",
-    "@dotrino/remote-agent": "0.12.0",
-    "@dotrino/update": "0.2.2",
-    "@dotrino/vault": "0.79.0"
+    "@dotrino/remote-agent": "0.13.0",
+    "@dotrino/update": "0.5.0",
+    "@dotrino/vault": "0.82.0"
   },
   "keywords": [
     "dotrino",

package/src/selfUpdate.js

@@ -0,0 +1,81 @@
+/**
+ * selfUpdate.js — este node SE ACTUALIZA SOLO (CONVENCIONES §15, dueño 2026-10-08).
+ *
+ * No implementa nada de eso: mirar, comprobar lo que entrega npm contra la release de
+ * GitHub, instalar y recordar lo ya preguntado es de `@dotrino/update/npm`; preguntarle a
+ * la bóveda y avisarle es de `@dotrino/vault/service`. Aquí solo está el pegamento, y es
+ * lo único que conoce las dos piezas a la vez.
+ *
+ * Los dos ajustes son de ESTA instancia (`update-prefs.json` en su carpeta) y no tienen
+ * que ver con el de la bóveda:
+ *   · `approval` (apagado): encendido, antes de instalar se le pregunta a la bóveda.
+ *   · `notify` (encendido): se avisa a quien aprueba de que el node se actualizó, o de
+ *     que hay versión nueva y esta instalación necesita root.
+ *
+ * SIN BÓVEDA NO HAY A QUIÉN PREGUNTAR NI A QUIÉN AVISAR, y se dice tal cual: no se pasan
+ * los ganchos, así que con `approval` encendida y sin enrolar el resultado es
+ * `no-approver` y no se instala. Suponer un sí sería saltarse lo que el dueño pidió.
+ */
+import { watchSelfUpdateNpm } from '@dotrino/update/npm'
+import { askUpdateApproval, reportUpdated, reportUpdateNeedsRoot } from '@dotrino/vault/service'
+
+export const PKG = '@dotrino/content'
+export const REPO = 'imdotrino/dotrino-content'
+
+/**
+ * Los tres ganchos que hablan con la bóveda. `conn()` da, EN EL MOMENTO de llamar, con
+ * qué identidad se le habla (`{ dir }` o `{ proxyUrl, masterPubkey, device, cert }`): el
+ * papel se renueva con el proceso en marcha y uno leído al arrancar ya no valdría.
+ *
+ * @param {{ product: string, conn: () => object, vault?: any }} o
+ */
+export function vaultUpdateHooks ({ product, conn, vault = { askUpdateApproval, reportUpdated, reportUpdateNeedsRoot } }) {
+  return {
+    // true = sí · false = no, o pasó el día sin respuesta · lanza = no se pudo preguntar
+    // (eso no es una negativa: `@dotrino/update` lo reintenta en la próxima pasada).
+    mayUpdate: async ({ version, from }) => {
+      try {
+        return (await vault.askUpdateApproval({ product, version, from, ...conn() })).ok === true
+      } catch (e) {
+        // El pedido quedó pendiente y venció sin que nadie contestara: vencido es no.
+        if (e?.code === 'unanswered') return false
+        throw e
+      }
+    },
+    onUpdated: ({ version, from }) => vault.reportUpdated({ product, version, from, ...conn() }),
+    onNeedsRoot: ({ version, from }) => vault.reportUpdateNeedsRoot({ product, version, from, ...conn() })
+  }
+}
+
+/**
+ * Arranca el vigilante. Devuelve cómo pararlo.
+ *
+ * @param {{
+ *   version: string, dir: string, conn?: (() => object) | null,
+ *   restart: (version: string) => void, log?: (m: string) => void,
+ *   watch?: typeof watchSelfUpdateNpm, vault?: any
+ * }} o
+ *   dir: la carpeta del enlace de esta instancia (ahí viven sus ajustes de actualización).
+ *   conn: cómo hablarle a la bóveda, o `null` si este node no está enrolado.
+ *   restart: salir limpio para que systemd/pm2 levante la versión nueva.
+ */
+export function startSelfUpdate ({ version, dir, conn = null, restart, log = console.log, watch = watchSelfUpdateNpm, vault }) {
+  return watch({
+    pkg: PKG,
+    current: version,
+    repo: REPO,
+    dir,
+    ...(conn ? vaultUpdateHooks({ product: PKG, conn, ...(vault ? { vault } : {}) }) : {}),
+    onInstalled: ({ version: to, restart: canRestart }) => {
+      if (canRestart) {
+        log(`[update] ${PKG} ${to} installed · restarting to run it`)
+        restart(to)
+      } else {
+        log(`[update] ${PKG} ${to} installed · nothing restarts this process, so it keeps running ${version} until the next start`)
+      }
+    },
+    log
+  })
+}
+
+export default { PKG, REPO, vaultUpdateHooks, startSelfUpdate }