dotrino-content 0.3.1 → 0.3.2

package/lib/public.js

@@ -0,0 +1,123 @@
+/**
+ * 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')
+  let last = null
+  for (const token of tokens) {
+    try {
+      return await fetchFrom({ client, token, cid, head, full, timeoutMs })
+    } catch (e) {
+      last = e
+      // Si el node CONTESTÓ que no (privado, no existe), otro node del mismo dueño
+      // dirá lo mismo: no tiene sentido insistir. Solo se reintenta lo que fue ruido.
+      if (e.code && e.code !== 'timeout' && e.code !== 'corrupt') throw e
+    }
+  }
+  throw last || 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.2",
   "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": {