@torrent-tv/proxy 1.0.0

package/services/registry-api.js

@@ -0,0 +1,43 @@
+function buildRegistryUrl(serverUrl, pathname) {
+  return new URL(pathname, ensureBaseUrl(serverUrl));
+}
+
+function ensureBaseUrl(serverUrl) {
+  return serverUrl.endsWith("/") ? serverUrl : `${serverUrl}/`;
+}
+
+export async function registerClient({ serverUrl, id, name, baseUrl, token }) {
+  const response = await fetch(buildRegistryUrl(serverUrl, "api/proxy-clients/register"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      id,
+      name,
+      baseUrl,
+      token
+    })
+  });
+
+  if (!response.ok) {
+    const bodyText = await response.text();
+    throw new Error(`Registration failed (${response.status}): ${bodyText}`);
+  }
+
+  return response.json();
+}
+
+export async function sendHeartbeat({ serverUrl, id, token }) {
+  try {
+    const response = await fetch(buildRegistryUrl(serverUrl, "api/proxy-clients/heartbeat"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        id,
+        token
+      })
+    });
+    return response.status;
+  } catch (_error) {
+    return null;
+  }
+}

package/services/torrent-pool.js

@@ -0,0 +1,123 @@
+import crypto from "node:crypto";
+import chalk from "chalk";
+import WebTorrent from "webtorrent";
+
+function decodeTorrentSource(sourceType, source) {
+  if (sourceType === "magnet") {
+    return source;
+  }
+  if (sourceType === "torrent") {
+    return Buffer.from(source, "base64");
+  }
+  throw new Error("Unsupported sourceType. Expected magnet or torrent.");
+}
+
+export class TorrentPool {
+  constructor() {
+    this.client = new WebTorrent();
+    this.torrents = new Map();
+    this.fileUsageByTorrent = new WeakMap();
+
+    this.client.on("error", (error) => {
+      console.error(chalk.red(`[proxy-client] WebTorrent client error: ${error.message}`));
+    });
+  }
+
+  async getTorrent(sourceType, source) {
+    const key = `${sourceType}:${crypto.createHash("sha1").update(source).digest("hex")}`;
+    const existing = this.torrents.get(key);
+    if (existing) {
+      return existing;
+    }
+
+    const torrentId = decodeTorrentSource(sourceType, source);
+    const torrent = await new Promise((resolve, reject) => {
+      const onError = (error) => {
+        this.client.off("error", onError);
+        reject(error);
+      };
+      this.client.once("error", onError);
+      this.client.add(torrentId, (readyTorrent) => {
+        this.client.off("error", onError);
+        resolve(readyTorrent);
+      });
+    });
+
+    this.torrents.set(key, torrent);
+    return torrent;
+  }
+
+  setActiveFile(torrent, fileIndex) {
+    if (!torrent || !Array.isArray(torrent.files)) {
+      return;
+    }
+    for (let index = 0; index < torrent.files.length; index += 1) {
+      const file = torrent.files[index];
+      if (!file) {
+        continue;
+      }
+      if (index === fileIndex) {
+        if (typeof file.select === "function") {
+          file.select();
+        }
+        continue;
+      }
+      if (typeof file.deselect === "function") {
+        file.deselect();
+      }
+    }
+  }
+
+  acquireFile(torrent, fileIndex) {
+    if (!torrent || !Array.isArray(torrent.files) || !Number.isInteger(fileIndex) || fileIndex < 0) {
+      return () => undefined;
+    }
+    let usage = this.fileUsageByTorrent.get(torrent);
+    if (!usage) {
+      usage = new Map();
+      this.fileUsageByTorrent.set(torrent, usage);
+    }
+    usage.set(fileIndex, (usage.get(fileIndex) ?? 0) + 1);
+    this.#syncSelections(torrent, usage);
+
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      const nextCount = (usage.get(fileIndex) ?? 0) - 1;
+      if (nextCount > 0) {
+        usage.set(fileIndex, nextCount);
+      } else {
+        usage.delete(fileIndex);
+      }
+      if (usage.size === 0) {
+        this.fileUsageByTorrent.delete(torrent);
+      }
+      this.#syncSelections(torrent, usage);
+    };
+  }
+
+  #syncSelections(torrent, usage) {
+    if (!torrent || !Array.isArray(torrent.files)) {
+      return;
+    }
+    for (let index = 0; index < torrent.files.length; index += 1) {
+      const file = torrent.files[index];
+      if (!file) {
+        continue;
+      }
+      const shouldSelect = (usage.get(index) ?? 0) > 0;
+      if (shouldSelect) {
+        if (typeof file.select === "function") {
+          file.select();
+        }
+        continue;
+      }
+      if (typeof file.deselect === "function") {
+        file.deselect();
+      }
+    }
+  }
+}

package/store/source-registry.js

@@ -0,0 +1,32 @@
+import crypto from "node:crypto";
+
+export function createSourceRegistry(maxSources = 200) {
+  const sources = new Map();
+
+  return {
+    upsert(sourceType, source) {
+      const sourceKey = crypto
+        .createHash("sha1")
+        .update(`${sourceType}:${source}`)
+        .digest("hex");
+
+      sources.set(sourceKey, {
+        sourceType,
+        source,
+        updatedAt: Date.now()
+      });
+
+      if (sources.size > maxSources) {
+        const oldest = Array.from(sources.entries()).sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+        for (const [key] of oldest.slice(0, sources.size - maxSources)) {
+          sources.delete(key);
+        }
+      }
+
+      return sourceKey;
+    },
+    get(sourceKey) {
+      return sources.get(sourceKey) ?? null;
+    }
+  };
+}

package/utils/parse-range.js

@@ -0,0 +1,12 @@
+export function parseRange(rangeHeader, fileLength) {
+  if (!rangeHeader || !rangeHeader.startsWith("bytes=")) {
+    return null;
+  }
+  const [startRaw, endRaw] = rangeHeader.slice("bytes=".length).split("-");
+  const start = startRaw.length > 0 ? Number(startRaw) : 0;
+  const end = endRaw && endRaw.length > 0 ? Number(endRaw) : fileLength - 1;
+  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start) {
+    return null;
+  }
+  return { start, end: Math.min(end, fileLength - 1) };
+}