dotrino-content 0.2.3 → 0.3.1

package/README.md

@@ -152,9 +152,10 @@ const back = await cc.get(ref) // comprueba el hash antes de devolver nada
   `putImageWithThumbnail()`, que sube el original **cifrado y privado** y la miniatura
   **en claro y pública** — que es el reparto que hace que haya tarjeta sin publicar el
   archivo.
-- **Todavía NO lee el contenido de otro usuario**: hoy solo se abre sesión con un
-  aparato de tu misma acta. Un tercero con tu enlace ve la vista previa (si la
-  encendiste) y podrá pedir los bytes cuando exista el transporte P2P.
+- **Lo PÚBLICO de otro usuario ya se lee por la red** (`fetchPublic` en la lib,
+  DISENO §16): un tercero con tu enlace encuentra tu node por el proxio y le pide el
+  `cid`; el node contesta solo lo marcado público y en claro, y los bytes se
+  verifican contra el `cid`. Lo privado sigue siendo de tus aparatos.
 
 ## Tests
 

package/bin/cli.js

@@ -132,9 +132,9 @@ if (!isEnrolled()) console.log('sin vault: configuración local (enrola con: dot
 await vaultConfig.ready
 
 const { openStore } = await import('../src/storage.js')
-const { store } = await openStore({ dir, log })
+const { store, cfg } = await openStore({ dir, log })
 
-const node = await new ContentNode({ dir, maxBytes, maxBlobBytes, store, log }).init()
+const node = await new ContentNode({ dir, maxBytes, maxBlobBytes, store, log, publicBase: cfg?.pub ? cfg.baseUrl : null }).init()
 // Lo que quedó sin subir en un arranque anterior. Se lanza y no se espera.
 node.backupPending().then(({ pending }) => { if (pending) log(`[almacén] ${pending} pendiente(s) de subir al bucket`) })
 const server = createServer(node)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotrino-content",
-  "version": "0.2.3",
+  "version": "0.3.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": {

package/src/agent.js

@@ -23,6 +23,7 @@ import { pubkeyId } from '@dotrino/identity/capabilities'
 import { startRemoteAgent } from '@dotrino/remote-agent/agent'
 import { dataDir, loadLink } from '@dotrino/remote-agent/link'
 import { startAnnounce } from './announce.js'
+import { startPublicFetch } from './fetch.js'
 import { createOps } from './ops.js'
 
 /** Carpeta de datos del enlace (NO es la de los blobs: el enlace es del aparato). */

package/src/announce.js

@@ -30,8 +30,10 @@
  * el sitio de siempre.
  */
 
-/** Nombre del canal de un dueño dentro de un proxio concreto. */
-export const channelFor = (nodeId, ownerId) => `${nodeId}/content_${ownerId}`
+import { channelFor } from '../lib/public.js'
+
+/** Nombre del canal de un dueño dentro de un proxio concreto (vive en la lib: el cliente del tercero lo necesita igual). */
+export { channelFor }
 
 /** Cada cuánto se re-publica (el proxio caduca las entradas de canal). */
 export const REPUBLISH_MS = 4 * 60 * 1000

package/src/fetch.js

@@ -0,0 +1,88 @@
+/**
+ * fetch.js — el node ATIENDE a terceros (DISENO.md §16).
+ *
+ * Un aparato del acta entra por sesión cifrada (`ops.js`). Cualquier otro —quien
+ * recibió un enlace— no tiene sesión ni la tendrá: manda un mensaje suelto por el
+ * proxio, `content.fetch { cid }`, y recibe el blob si y solo si está marcado
+ * `public` y en claro. Es la misma regla que el modo HTTP (§7.2): sin `public`
+ * explícito, no sale nada, y un 'not-found' nunca distingue «no existe» de «no es
+ * público» para no confirmar qué guarda el node.
+ *
+ * Lo que va en la respuesta:
+ *  - `url`: el atajo del bucket (§15.13) si el node lo tiene y el bucket ya confirmó
+ *    esos bytes. La app la usa para un `<img>`; si falla, vuelve a pedir por aquí.
+ *  - `data`: los bytes en base64, salvo `head` o si no caben en un mensaje. Lo que no
+ *    cabe se sirve solo por URL; sin bucket, 'too-large' — lo grande es P2P (§13).
+ *
+ * Límite por remitente (token) para que un enlace viral no convierta el node en un
+ * CDN por el proxio: el proxio ya tiene el suyo, y este es el del node.
+ */
+
+import { isValidCid } from '../lib/ref.js'
+import { MSG, FETCH_MAX_BYTES } from '../lib/public.js'
+
+export { MSG, FETCH_MAX_BYTES }
+
+/**
+ * @param {{ client: any, node: import('./node.js').ContentNode, ratePerMin?: number, quiet?: boolean }} opts
+ *   client: el `WebSocketProxyClient` YA conectado del agente (no se abre otro).
+ * @returns {{ close: () => void, served: () => number }}
+ */
+export function startPublicFetch ({ client, node, ratePerMin = 60, quiet = false }) {
+  if (!client || !node) throw new Error('startPublicFetch: client and node are required')
+  /** token → { n, windowStart } */
+  const buckets = new Map()
+  let served = 0
+
+  const allowed = (from) => {
+    const now = Date.now()
+    const b = buckets.get(from) || { n: 0, windowStart: now }
+    if (now - b.windowStart >= 60_000) { b.n = 0; b.windowStart = now }
+    b.n++
+    buckets.set(from, b)
+    if (buckets.size > 5000) buckets.clear()   // que la tabla no crezca sin techo
+    return b.n <= ratePerMin
+  }
+
+  const send = (to, obj) => { try { client.send(to, obj) } catch (e) { if (!quiet) console.error('[content] fetch reply:', e.message) } }
+  const fail = (to, rid, code, error) => send(to, { type: MSG.FETCH_ERR, rid, code, error })
+
+  const handle = async (from, p) => {
+    const rid = typeof p.rid === 'string' ? p.rid : null
+    if (!rid) return
+    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)
+    // Mismo 'not-found' para «no existe» y «no es público»: el mismo motivo que §7.2.
+    if (!meta || meta.acl !== 'public' || meta.enc) return fail(from, rid, 'not-found', 'no such public cid')
+    const url = node.publicUrl(p.cid)
+    const out = { type: MSG.FETCH_OK, rid, cid: p.cid, mime: meta.mime, size: meta.size, url }
+    // Con atajo, los bytes NO viajan por el proxio salvo que el que pide insista
+    // (`full`): cargar por URL es gratis para el node y para la red, y la app ya
+    // sabe volver aquí si la URL le falla. Sin atajo, van en el mensaje si caben.
+    if (!p.head && (!url || p.full)) {
+      if (meta.size > FETCH_MAX_BYTES) {
+        if (!url) return fail(from, rid, 'too-large', `${meta.size} bytes do not fit in a message and this node has no public bucket`)
+        // Cabe solo por URL: se contesta sin bytes y la app carga por ahí.
+      } else {
+        const chunks = []
+        for await (const c of node.read(p.cid)) chunks.push(c)
+        out.data = Buffer.concat(chunks).toString('base64')
+      }
+    }
+    served++
+    send(from, out)
+  }
+
+  const off = client.on('message', (from, p) => {
+    if (!p || p.type !== MSG.FETCH) return
+    handle(from, p).catch((e) => fail(from, p.rid, 'failed', e.message))
+  })
+
+  return {
+    served: () => served,
+    close () { try { off?.() } catch (_) {} }
+  }
+}
+
+export default { startPublicFetch, MSG, FETCH_MAX_BYTES }

package/src/node.js

@@ -30,6 +30,9 @@ export class ContentNode {
     // El almacén se puede INYECTAR (`storage.js` monta el de bucket cuando toca). Por
     // defecto, disco: sin configuración, un node funciona con lo que hay en la máquina.
     this.store = opts.store || new BlobStore(opts.dir)
+    // Base de la URL pública del bucket (§15.13). Sin bucket público es null y lo
+    // público viaja por la red, que es el camino que SIEMPRE existe.
+    this.publicBase = opts.publicBase || null
     this.index = null
     /** Subidas al bucket en curso, por cid: para no lanzar dos veces la misma. */
     this._uploading = new Map()
@@ -73,6 +76,18 @@ export class ContentNode {
     return isValidCid(cid) ? this.index.get(cid) : null
   }
 
+  /**
+   * La URL pública de un blob, o null. Es un ATAJO (§15.13), nunca el enlace: solo
+   * existe si hay bucket público, el blob está marcado público y en claro, y el
+   * bucket YA confirmó esos bytes (`remote`) — una URL que todavía da 404 no ayuda.
+   */
+  publicUrl (cid) {
+    if (!this.publicBase || !this.store.backed || typeof this.store.urlFor !== 'function') return null
+    const m = this.stat(cid)
+    if (!m || m.acl !== 'public' || m.enc || !m.remote) return null
+    return this.store.urlFor(cid, this.publicBase)
+  }
+
   /**
    * Marca un blob como público o privado (`acl`). Es lo único que autoriza a que
    * los bytes salgan del node cuando esté encendido el modo público (DISENO.md
@@ -98,8 +113,12 @@ export class ContentNode {
    * subió sigue siendo la cola pendiente del índice, y se reintenta al arrancar.
    */
   backup (cid, meta) {
-    if (!this.store.backed || this._uploading.has(cid)) return null
-    const p = this.store.upload(cid, meta)
+    if (!this.store.backed) return null
+    // Si ya hay una subida en curso (la privada, típicamente), esta va DETRÁS, no se
+    // descarta: publicar a mitad de la subida tiene que terminar en el bucket público.
+    const prev = this._uploading.get(cid)
+    const p = (prev ? prev.catch(() => {}) : Promise.resolve())
+      .then(() => this.store.upload(cid, meta))
       .then(() => { this.index.setRemote(cid, true) })
       .catch((e) => { this.log(`[almacén] no se pudo subir ${cid.slice(0, 14)}…: ${e.message}`) })
       .finally(() => this._uploading.delete(cid))