dotrino-content 0.3.1 → 0.3.3

package/lib/public.js

@@ -0,0 +1,127 @@
+/**
+ * public.js — leer contenido PÚBLICO de otro dueño por la red de Dotrino.
+ *
+ * Es el camino del tercero (DISENO.md §16): quien recibe una referencia
+ * `ownerId + cid` no tiene sesión con ese node ni la va a tener —las sesiones son de
+ * los aparatos del acta—. Lo que sí puede hacer es lo mismo que con un teléfono:
+ * buscar al dueño en la guía (el canal `content_<owner>` del proxio, §3.1) y
+ * pedirle el `cid` en un mensaje suelto. El node contesta SOLO lo marcado público y
+ * en claro, y el que pide comprueba que los bytes cuadren con el `cid`: el node no
+ * es autoridad de nada, el hash sí.
+ *
+ * Si el node tiene bucket, contesta además la URL pública (§15.13): es un ATAJO
+ * para cargar la imagen con un `<img>` sin mover los bytes por el proxio. Nunca es
+ * el enlace —el enlace sigue siendo `app/#owner/cid`— y si la URL falla, se vuelve
+ * a pedir por la red.
+ *
+ * Isomórfico: el `client` es un `WebSocketProxyClient` ya conectado (el que la app
+ * ya tiene; no se abre otro). Sin dependencias.
+ */
+
+import { isValidCid } from './ref.js'
+
+/** Nombre del canal de un dueño dentro de un proxio (espejo de src/announce.js). */
+export const channelFor = (nodeId, ownerId) => `${nodeId}/content_${ownerId}`
+
+export const MSG = Object.freeze({
+  FETCH: 'content.fetch',
+  FETCH_OK: 'content.fetch.ok',
+  FETCH_ERR: 'content.fetch.err'
+})
+
+/** Lo que cabe en un mensaje del proxio: el mismo tope que el plano de control. */
+export const FETCH_MAX_BYTES = 256 * 1024
+
+const b64ToBytes = (s) => /** @type {Uint8Array<ArrayBuffer>} */ (Uint8Array.from(atob(s), (c) => c.charCodeAt(0)))
+
+async function cidOf (bytes) {
+  const digest = await crypto.subtle.digest('SHA-256', bytes)
+  return 'sha256-' + [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+const err = (code, msg) => Object.assign(new Error(msg), { code })
+
+/**
+ * Los nodes de un dueño que están en línea ahora mismo, como tokens del proxio.
+ * Se mira en todos los proxios de la malla: un canal sin prefijo es local a cada
+ * uno, y el node se anuncia en todos. Quitarse a uno mismo evita que una app con
+ * node propio se pregunte a sí misma.
+ * @param {{ client: any, owner: string }} opts
+ * @returns {Promise<string[]>}
+ */
+export async function findNodes ({ client, owner }) {
+  if (!client || !owner) throw new Error('findNodes: client and owner are required')
+  const known = Array.isArray(client.knownNodes) && client.knownNodes.length
+    ? client.knownNodes
+    : (client.node ? [client.node] : [])
+  const out = new Set()
+  for (const nodeId of known) {
+    try {
+      for (const token of await client.list(channelFor(nodeId, owner))) out.add(token)
+    } catch (_) { /* un proxio que no contesta no invalida al otro */ }
+  }
+  if (client.token) out.delete(client.token)
+  return [...out]
+}
+
+let rid = 0
+
+/**
+ * Pide un `cid` público a un node concreto (por su token) y espera la respuesta.
+ * @returns {Promise<{ cid: string, mime: string, size: number, url: string|null, bytes: Uint8Array<ArrayBuffer>|null }>}
+ */
+export async function fetchFrom ({ client, token, cid, head = false, full = false, timeoutMs = 8000 }) {
+  const id = `f${++rid}`
+  const reply = new Promise((resolve, reject) => {
+    const done = (fn, v) => { off(); clearTimeout(t); fn(v) }
+    const off = client.on('message', (_from, p) => {
+      if (!p || p.rid !== id) return
+      if (p.type === MSG.FETCH_OK) done(resolve, p)
+      else if (p.type === MSG.FETCH_ERR) done(reject, err(p.code || 'failed', p.error || 'fetch failed'))
+    })
+    const t = setTimeout(() => done(reject, err('timeout', 'the node did not answer')), timeoutMs)
+  })
+  client.send(token, { type: MSG.FETCH, rid: id, cid, head: !!head, full: !!full })
+  const p = await reply
+  let bytes = null
+  if (typeof p.data === 'string') {
+    bytes = b64ToBytes(p.data)
+    // El node no es autoridad: lo que diga que es el cid tiene que SERLO.
+    if (await cidOf(bytes) !== cid) throw err('corrupt', 'the bytes do not match the cid')
+  }
+  return { cid, mime: p.mime || 'application/octet-stream', size: Number(p.size) || (bytes?.length ?? 0), url: p.url || null, bytes }
+}
+
+/**
+ * Resuelve una referencia pública `ownerId + cid` por la red: encuentra un node
+ * vivo del dueño y le pide el blob. Prueba los que haya hasta que uno conteste.
+ *
+ * @param {{ client: any, owner: string, cid: string, head?: boolean, full?: boolean, timeoutMs?: number }} opts
+ *   head: solo metadatos y URL, sin bytes.
+ *   full: los bytes aunque haya URL (por defecto, con URL el node no los manda:
+ *   cargas por la URL y solo vuelves aquí con `full` si te falló).
+ * @throws {Error & {code:'no-node'|'not-found'|'private'|'too-large'|'corrupt'|'timeout'}}
+ */
+export async function fetchPublic ({ client, owner, cid, head = false, full = false, timeoutMs = 8000 }) {
+  if (!isValidCid(cid)) throw err('bad-input', 'invalid cid')
+  const tokens = await findNodes({ client, owner })
+  if (!tokens.length) throw err('no-node', 'no node of that owner is online')
+  // A TODOS a la vez, y se queda con el primero que conteste bien. En serie, cada
+  // token de un node ya apagado —el proxio los conserva un rato— costaba un timeout
+  // entero antes de llegar al que sí está vivo. Un `not-found` es una respuesta de
+  // verdad (otro node del mismo dueño diría lo mismo) y gana sobre los silencios.
+  return new Promise((resolve, reject) => {
+    let pending = tokens.length
+    let answered = null   // el primer error "de verdad" (el node contestó que no)
+    let noise = null      // timeout / corrupt: no dicen nada del contenido
+    for (const token of tokens) {
+      fetchFrom({ client, token, cid, head, full, timeoutMs }).then(resolve, (e) => {
+        if (e.code && e.code !== 'timeout' && e.code !== 'corrupt') answered = answered || e
+        else noise = noise || e
+        if (--pending === 0) reject(answered || noise || err('no-node', 'no node answered'))
+      })
+    }
+  })
+}
+
+export default { channelFor, findNodes, fetchFrom, fetchPublic, MSG, FETCH_MAX_BYTES }

package/lib/ref.js

@@ -0,0 +1,69 @@
+/**
+ * ref.js — la REFERENCIA compartible (DISENO.md §3 y §7). Isomórfico y sin
+ * dependencias: lo usan las apps, el node y las pruebas.
+ *
+ * Una referencia es `ownerId + cid` y, si el contenido va cifrado, la LLAVE:
+ *
+ *     https://eco.dotrino.com/#<ownerId>/<cid>/<llave>
+ *                             └──────── el #fragment ────────┘
+ *
+ * Las dos mitades hacen falta y ninguna sobra:
+ *  - el **`cid`** es el hash del contenido: lo vuelve inmutable, deduplicable y
+ *    **verificable** (quien lo recibe comprueba que los bytes son los pedidos);
+ *  - el **`ownerId`** es la huella de la maestra del dueño, y es lo que permite
+ *    **rutear** (`ownerId` → sus nodes) y comprobar que quien sirvió los bytes es
+ *    un aparato suyo. Un `cid` suelto es ambiguo: cualquiera podría reclamarlo.
+ *
+ * **La llave va en el fragmento y por eso NUNCA llega a un servidor**: el
+ * navegador no manda el `#` en la petición. Es lo mismo que hace el resto del
+ * ecosistema, y es lo que permite compartir un enlace de contenido cifrado sin
+ * que quien lo hospeda pueda leerlo.
+ */
+
+const CID_RE = /^sha256-[0-9a-f]{64}$/
+
+/** ¿Tiene forma de cid? (no dice si existe, solo si es un cid) */
+export const isValidCid = (cid) => typeof cid === 'string' && CID_RE.test(cid)
+
+/**
+ * Arma la parte de fragmento de una referencia (sin el `#`).
+ * @param {{ owner: string, cid: string, key?: string|null }} ref
+ * @returns {string} `<owner>/<cid>` o `<owner>/<cid>/<llave>`
+ */
+export function buildRef ({ owner, cid, key = null }) {
+  if (!owner) throw new Error('buildRef: falta owner')
+  if (!isValidCid(cid)) throw new Error(`buildRef: cid inválido: ${cid}`)
+  return key ? `${owner}/${cid}/${key}` : `${owner}/${cid}`
+}
+
+/**
+ * Arma el enlace completo hacia una app del ecosistema.
+ * @param {{ owner: string, cid: string, key?: string|null }} ref
+ * @param {string} [appUrl]
+ */
+export function buildUrl (ref, appUrl = 'https://eco.dotrino.com/') {
+  return `${appUrl.replace(/\/+$/, '')}/#${buildRef(ref)}`
+}
+
+/**
+ * Lee una referencia de un fragmento, una URL o la barra de direcciones.
+ * Devuelve `null` si eso no es una referencia — que es lo normal: las apps del
+ * ecosistema usan el fragmento para muchas cosas (`#room=`, `#vault`…), así que
+ * esto tiene que poder decir "no es mío" sin ruido.
+ * @param {string} input
+ * @returns {{ owner: string, cid: string, key: string|null }|null}
+ */
+export function parseRef (input) {
+  if (typeof input !== 'string' || !input) return null
+  let frag = input
+  const hash = frag.indexOf('#')
+  if (hash >= 0) frag = frag.slice(hash + 1)
+  frag = frag.replace(/^\/+/, '')
+  const parts = frag.split('/')
+  if (parts.length < 2 || parts.length > 3) return null
+  const [owner, cid, key = null] = parts
+  if (!owner || !isValidCid(cid)) return null
+  return { owner, cid, key: key || null }
+}
+
+export default { buildRef, buildUrl, parseRef, isValidCid }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotrino-content",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "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": {
@@ -49,6 +49,8 @@
   "files": [
     "bin",
     "src",
+    "lib/public.js",
+    "lib/ref.js",
     "README.md"
   ],
   "publishConfig": {

package/src/agent.js

@@ -90,12 +90,18 @@ export async function startContentAgent ({
   const beacon = announce && agent.client
     ? startAnnounce({ client: agent.client, owner, quiet })
     : null
+  // LECTURA PÚBLICA por la red (§16): un tercero con el enlace pide el `cid` en un
+  // mensaje suelto y recibe solo lo marcado público. Sin esto, anunciarse no sirve
+  // de nada: el enlace nombraría a un node que no contesta a nadie.
+  const fetcher = agent.client ? startPublicFetch({ client: agent.client, node, quiet }) : null
 
   return {
     ...agent,
     owner,
     channels: () => beacon?.channels() || [],
+    served: () => fetcher?.served() || 0,
     close () {
+      try { fetcher?.close() } catch (_) {}
       try { beacon?.close() } catch (_) {}
       agent.close()
     }

package/src/announce.js

@@ -78,7 +78,7 @@ export function startAnnounce ({ client, owner, quiet = false, intervalMs = REPU
     }
     const first = !current.length && done.length
     current = done
-    if (first && !quiet) console.log(`[content] anunciado como node de ${owner.slice(0, 16)} en ${done.length} proxio(s)`)
+    if (first && !quiet) console.log(`[content] anunciado como node de ${owner.slice(0, 16)} en ${done.length} proxio(s) · token ${client.token}`)
   }
 
   publishAll()

package/src/fetch.js

@@ -50,6 +50,7 @@ export function startPublicFetch ({ client, node, ratePerMin = 60, quiet = false
   const handle = async (from, p) => {
     const rid = typeof p.rid === 'string' ? p.rid : null
     if (!rid) return
+    if (!quiet) console.log(`[content] fetch ${String(p.cid).slice(0, 20)}… from ${String(from).slice(0, 16)}${p.head ? ' (head)' : ''}`)
     if (!allowed(from)) return fail(from, rid, 'rate-limited', 'too many requests')
     if (!isValidCid(p.cid)) return fail(from, rid, 'bad-input', 'invalid cid')
     const meta = node.stat(p.cid)