@dotrino/content 0.3.13 → 0.4.1

package/bin/cli.js

@@ -26,9 +26,14 @@ import { ContentNode } from '../src/node.js'
 import { createServer } from '../src/server.js'
 import { createPublicServer, DEFAULT_PUBLIC_PORT, DEFAULT_MAX_BYTES, DEFAULT_RATE_PER_MIN } from '../src/public.js'
 import { isLinked, linkDir, startContentAgent } from '../src/agent.js'
+import { createRequire } from 'node:module'
+
+const { version: VERSION } = createRequire(import.meta.url)('../package.json')
 
 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 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://…]
@@ -53,6 +58,7 @@ const { values, positionals } = parseArgs({
     'public-url': { type: 'string' },
     'app-url': { type: 'string' },
     'public-index': { type: 'boolean' },
+    json: { type: 'boolean' },
     help: { type: 'boolean', short: 'h' }
   }
 })
@@ -63,11 +69,24 @@ if (values.help) {
 }
 
 const cmd = positionals[0] || 'start'
-if (cmd !== 'start' && cmd !== 'enroll') {
+if (cmd !== 'start' && cmd !== 'enroll' && cmd !== 'info') {
   console.error(`comando desconocido: ${cmd}\n${USAGE}`)
   process.exit(1)
 }
 
+// `info`: la pieza común de todos los comandos (CONVENCIONES §15.1). Lo que se viene a
+// mirar es el ID, para buscarlo en el acta.
+if (cmd === 'info') {
+  const { loadLink } = await import('@dotrino/remote-agent/link')
+  const { deviceInfo, formatDeviceInfo } = await import('@dotrino/vault/device-info')
+  const dir = linkDir()
+  const link = loadLink(dir)
+  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))
+  process.exit(0)
+}
+
 /**
  * Enrolamiento: el flujo endurecido del ecosistema, tal cual lo hace la terminal.
  * Este node genera su llave, MUESTRA un código y espera a que lo apruebes tipeando
@@ -149,10 +168,17 @@ node.gc()
 // propia ACL, su límite por IP y su techo de salida: no se activa por descuido.
 server.listen(port, '127.0.0.1', () => {
   const s = node.stats()
-  console.log(`dotrino-content en http://127.0.0.1:${port}  ·  datos: ${dir}`)
+  console.log(`dotrino-content ${VERSION} en http://127.0.0.1:${port}  ·  datos: ${dir}`)
   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.
@@ -161,7 +187,7 @@ if (values['no-agent']) {
   console.log('plano de control: apagado (--no-agent)')
 } else if (isLinked()) {
   try {
-    agent = await startContentAgent({ node })
+    agent = await startContentAgent({ node, version: VERSION })
   } catch (e) {
     console.error(`plano de control: no arrancó (${e.message})`)
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/content",
-  "version": "0.3.13",
+  "version": "0.4.1",
   "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": {
@@ -23,9 +23,11 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@dotrino/identity": "0.78.0",
-    "@dotrino/remote-agent": "0.9.2",
-    "@dotrino/vault": "0.52.0"
+    "@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.75.0"
   },
   "keywords": [
     "dotrino",

package/src/announce.js

@@ -38,6 +38,21 @@ export { channelFor }
 /** Cada cuánto se re-publica (el proxio caduca las entradas de canal). */
 export const REPUBLISH_MS = 4 * 60 * 1000
 
+/**
+ * Cada cuánto se reintenta un anuncio que falló. No se espera al tic de 4 min: el fallo
+ * típico es un proxio recién reiniciado (cada despliegue lo hace) cuya malla con el otro
+ * aún no está lista, y eso se arregla en segundos. Mientras tanto quien esté conectado a
+ * ese proxio no encuentra el node.
+ */
+export const RETRY_MS = 30 * 1000
+
+/**
+ * Cuántos reintentos seguidos se aguantan en silencio antes de llamarlo error (~2 min).
+ * Un proxio que se está reiniciando no es un fallo y no debe salir en el log de errores;
+ * uno que lleva dos minutos sin dejar anunciarse, sí.
+ */
+export const FAILURES_BEFORE_ERROR = 4
+
 /**
  * Publica este node en el canal de su dueño, en todos los proxios conocidos, y lo
  * mantiene publicado. Best-effort a propósito: si el proxy está caído, el node
@@ -45,17 +60,19 @@ export const REPUBLISH_MS = 4 * 60 * 1000
  * siguiente tic lo vuelve a intentar. Un anuncio perdido no rompe nada; lo único
  * que pasa es que un tercero no lo encuentra hasta que vuelva.
  *
- * @param {{ client: any, owner: string, quiet?: boolean, intervalMs?: number }} opts
+ * @param {{ client: any, owner: string, quiet?: boolean, intervalMs?: number, retryMs?: number }} opts
  *   client: el `WebSocketProxyClient` YA conectado del agente (`ra.client`) — no se
  *   abre otro: dos conexiones del mismo aparato son dos identidades de transporte.
  * @returns {{ channels: () => string[], close: () => void }}
  */
-export function startAnnounce ({ client, owner, quiet = false, intervalMs = REPUBLISH_MS }) {
+export function startAnnounce ({ client, owner, quiet = false, intervalMs = REPUBLISH_MS, retryMs = RETRY_MS }) {
   if (!client) throw new Error('startAnnounce: client is required')
   if (!owner) throw new Error('startAnnounce: owner is required')
 
   let stopped = false
   let current = []
+  let retry = null
+  const failures = new Map()   // canal → fallos seguidos
 
   /** Los proxios donde hay que anunciarse: el que nos atiende y los que conoce. */
   const targets = () => {
@@ -72,10 +89,23 @@ export function startAnnounce ({ client, owner, quiet = false, intervalMs = REPU
       try {
         await client.publish(name, { app: 'content', owner })
         done.push(name)
+        const antes = failures.get(name) || 0
+        failures.delete(name)
+        if (antes >= FAILURES_BEFORE_ERROR && !quiet) console.log(`[content] announce on ${name} works again`)
       } catch (e) {
-        if (!quiet) console.error(`[content] could not announce on ${name}: ${e.message}`)
+        const n = (failures.get(name) || 0) + 1
+        failures.set(name, n)
+        if (quiet) continue
+        // Primer fallo: casi siempre un proxio que se acaba de reiniciar. Se dice sin alarma.
+        if (n === 1) console.log(`[content] announce on ${name} failed (${e.message}); retrying every ${retryMs / 1000} s`)
+        // Si sigue, ya no es un reinicio: error, una sola vez hasta que se recupere.
+        else if (n === FAILURES_BEFORE_ERROR) console.error(`[content] still cannot announce on ${name} after ${Math.round(n * retryMs / 60000)} min: ${e.message}`)
       }
     }
+    if (failures.size && !retry && !stopped) {
+      retry = setTimeout(() => { retry = null; publishAll() }, retryMs)
+      retry.unref?.()
+    }
     // Se avisa cuando CAMBIA en cuántos proxios está anunciado, no solo la primera vez.
     // Antes solo hablaba al pasar de 0 a algo, así que un arranque que solo alcanzó uno de
     // los dos decía «en 1 proxio(s)» y se callaba para siempre — aunque el tic siguiente ya
@@ -98,6 +128,7 @@ export function startAnnounce ({ client, owner, quiet = false, intervalMs = REPU
     close () {
       stopped = true
       clearInterval(timer)
+      if (retry) { clearTimeout(retry); retry = null }
       try { offToken?.() } catch (_) {}
       for (const name of current) { try { client.unpublish(name) } catch (_) {} }
       current = []