@torrent-tv/proxy 2.9.22 → 2.9.24

package/CHANGELOG.md

@@ -1,6 +1,8 @@
 ## 2.9.24
 
 - **New**: IPv6-first support (roadmap step 5a). (1) A second STUN server (`stun.cloudflare.com:3478`, alongside Google's) is added to the ICE config — both have IPv6 (AAAA) records, so when the proxy host has a global IPv6 address it gathers a `srflx` candidate over v6 too. IPv6 has no NAT, so if both the proxy and a (v6-native, e.g. cellular) viewer have global v6, the connection can go **direct** over v6 — sidestepping the whole NAT-traversal machinery. (2) Candidate logging now classifies each candidate by address scope — `v4-private` / `v4-public` / `v6-global` / `v6-ula` / `v6-linklocal` / `v6-loopback` (replaces the old private/public host label) — so the field log shows whether a global IPv6 path is actually being offered and chosen. Audited the candidate path: the proxy already forwards ALL candidates (incl. global v6) and the browser adds them all — nothing was dropping global v6, so no filter fix was needed. NOTE: not verifiable on the dev's proxy (its ISP exposes only ULA v6 `fd…`, no global v6); needs a proxy with global v6 to confirm in the field — the new `v6-global` log tag is there to spot it.
+- **Fix**: Cold-start playback no longer fails with "Data channel request timed out". `POST /api/playback-plan` (`playback-planner.getPlan`) used to block up to 60 s waiting for the file header to download for the codec probe — exactly the transport's 60 s request timeout, so a cold torrent (peers still connecting, 0 % header) raced and failed. The planner now takes a short per-request budget (`maxWaitMs`, 8 s from the route): it prioritises the file header and probes, and if the header still isn't down it returns the plan flagged `pending: true` (uncached) instead of blocking. The browser polls again — each call keeps the header prioritised — so no single request approaches the 60 s limit and the existing `/stats` poll keeps showing live peers/speed/% the whole time. Pairs with server 0.8.24 (browser-side poll loop, already live).
+- **New**: Disk hygiene (Level 1, `torrent-pool.js`). (1) A torrent with **zero active file readers** is now removed together with its on-disk store after a 300 s idle TTL (`torrent.destroy({ destroyStore: true })`), so downloaded data no longer accumulates while the proxy keeps running; re-requesting the torrent re-adds it. Re-acquiring a file cancels the pending removal, and the TTL is generous so brief gaps between ffmpeg range reads (or a short pause) never evict an in-use torrent. (2) **Startup orphan sweep**: leftover torrent data under `os.tmpdir()/webtorrent` from a previous hard kill (where graceful `destroyAll` never ran) is cleared at construction (safe — no torrents loaded yet). Still pending (Level 1): a global disk cap with LRU eviction.
 
 ## 2.9.23
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.9.22",
+  "version": "2.9.24",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/routes/api/playback-plan/post.js

@@ -35,7 +35,11 @@ export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner })
   }
 
   try {
-    const plan = await playbackPlanner.getPlan({ sourceKey, fileIndex, userAgent });
+    // Short per-request budget: if the file header is not downloaded yet the
+    // planner returns quickly with `pending: true` instead of blocking up to
+    // the transport's 60 s request timeout. The browser polls again (the header
+    // keeps downloading, prioritised on each call). Well under that 60 s limit.
+    const plan = await playbackPlanner.getPlan({ sourceKey, fileIndex, userAgent, maxWaitMs: 8_000 });
     return reply.send(plan);
   } catch (error) {
     if (error instanceof Error && error.code === "SOURCE_NOT_FOUND") {

package/services/playback-planner.js

@@ -167,13 +167,22 @@ export function createPlaybackPlanner({
      * Throws with `error.code === "SOURCE_NOT_FOUND"` or `"FILE_NOT_FOUND"`
      * when the source or file cannot be located.
      *
+     * When the file header has not downloaded yet (cold torrent, peers still
+     * connecting) the codec probe cannot succeed. Rather than block the HTTP
+     * response until it can, the planner prioritises the header, probes for at
+     * most `maxWaitMs`, and if still undetectable returns a plan flagged
+     * `pending: true` (NOT cached). The caller polls again — each call keeps the
+     * header prioritised and downloading — until a real plan comes back. This
+     * avoids a single long request racing the transport's request timeout.
+     *
      * @param {object} params
      * @param {string} params.sourceKey
      * @param {number} params.fileIndex
      * @param {string} [params.userAgent=""]
-     * @returns {Promise<PlaybackPlan>}
+     * @param {number} [params.maxWaitMs=60000] - Max time to wait for the header within ONE call.
+     * @returns {Promise<PlaybackPlan & { pending?: boolean }>}
      */
-    async getPlan({ sourceKey, fileIndex, userAgent = "" }) {
+    async getPlan({ sourceKey, fileIndex, userAgent = "", maxWaitMs = 60_000 }) {
       const cacheKey = `${sourceKey}:${fileIndex}`;
       const cached = cache.get(cacheKey);
       if (cached) {
@@ -218,7 +227,7 @@ export function createPlaybackPlanner({
       // file, and an unsupported codec like xvid gets copied → black video.
       await torrentPool.prefetchFileEdges(torrent, fileIndex);
       let probe = await probeStreamCodecs({ ffmpegBin, inputUrl: directUrl, userAgent });
-      const probeDeadline = Date.now() + 60_000;
+      const probeDeadline = Date.now() + Math.max(0, maxWaitMs);
       let attempt = 0;
       while (
         probe.audioCodec.length === 0 &&
@@ -248,11 +257,14 @@ export function createPlaybackPlanner({
       };
       // Only cache a plan whose codecs were actually detected. An empty probe is
       // a "header not downloaded yet" signal, not a valid result — caching it
-      // would permanently mis-plan the file.
+      // would permanently mis-plan the file. In that case flag the plan
+      // `pending` so the caller polls again (the header keeps downloading,
+      // prioritised by the prefetch above).
       if (codecsDetected) {
         cache.set(cacheKey, plan);
+        return plan;
       }
-      return plan;
+      return { ...plan, pending: true };
     }
   };
 }

package/services/torrent-pool.js

@@ -7,9 +7,23 @@
  */
 
 import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { rmSync } from "node:fs";
 import WebTorrent from "webtorrent";
 import { logger } from "../utils/logger.js";
 
+// WebTorrent's default download root (see webtorrent lib/torrent.js: TMP =
+// path.join(os.tmpdir(), 'webtorrent')). We use the default store, so all
+// torrent data lives under here.
+const WEBTORRENT_STORE_ROOT = path.join(os.tmpdir(), "webtorrent");
+
+// How long a torrent may sit with zero active file readers before it is
+// removed (with its on-disk store). Generous so brief gaps between ffmpeg
+// range reads — or a short pause — do not evict an in-use torrent; a longer
+// idle (viewer gone) frees the disk. Re-requesting re-adds (re-downloads) it.
+const TORRENT_IDLE_TTL_MS = 300_000;
+
 // Bytes ahead of a read position to mark CRITICAL (download-first) on each
 // range request. Big enough to unstick a seek into an undownloaded region,
 // small enough not to make "everything critical" (which defeats prioritization).
@@ -55,7 +69,26 @@ export class TorrentPool {
    */
   #pending = new Map();
 
+  /**
+   * Pending idle-removal timers, keyed by torrent object. A torrent with zero
+   * file refcount is scheduled for removal; re-acquiring it cancels the timer.
+   *
+   * @type {Map<import("webtorrent").Torrent, ReturnType<typeof setTimeout>>}
+   */
+  #idleTimers = new Map();
+
   constructor() {
+    // Sweep orphaned torrent data left by a previous hard kill (no graceful
+    // shutdown ran, so destroyAll never cleaned the store). Safe here: no
+    // torrents are loaded yet at construction. Best-effort, synchronous so it
+    // completes before the client starts writing.
+    try {
+      rmSync(WEBTORRENT_STORE_ROOT, { recursive: true, force: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.warn(`torrent-pool: could not sweep orphaned store at startup: ${message}`);
+    }
+
     /** @type {import("webtorrent").WebTorrent} */
     this.client = new WebTorrent();
 
@@ -170,6 +203,8 @@ export class TorrentPool {
       usage = new Map();
       this.fileUsageByTorrent.set(torrent, usage);
     }
+    // The torrent is in use again — cancel any pending idle removal.
+    this.#cancelIdleRemoval(torrent);
     usage.set(fileIndex, (usage.get(fileIndex) ?? 0) + 1);
     this.#syncSelections(torrent, usage);
 
@@ -187,11 +222,84 @@ export class TorrentPool {
       }
       if (usage.size === 0) {
         this.fileUsageByTorrent.delete(torrent);
+        // No active readers — schedule removal (with store) after an idle TTL.
+        this.#scheduleIdleRemoval(torrent);
       }
       this.#syncSelections(torrent, usage);
     };
   }
 
+  /**
+   * Schedule removal of a torrent (with its on-disk store) after
+   * {@link TORRENT_IDLE_TTL_MS} of zero file refcount. Idempotent — replaces
+   * any existing timer for the torrent.
+   *
+   * @param {import("webtorrent").Torrent} torrent
+   * @returns {void}
+   */
+  #scheduleIdleRemoval(torrent) {
+    if (!torrent) {
+      return;
+    }
+    this.#cancelIdleRemoval(torrent);
+    const timer = setTimeout(() => {
+      this.#idleTimers.delete(torrent);
+      // Re-check: a new acquire since scheduling would have cancelled this
+      // timer, but guard anyway against a race.
+      const usage = this.fileUsageByTorrent.get(torrent);
+      if (usage && usage.size > 0) {
+        return;
+      }
+      this.#removeTorrent(torrent);
+    }, TORRENT_IDLE_TTL_MS);
+    timer.unref?.();
+    this.#idleTimers.set(torrent, timer);
+  }
+
+  /**
+   * Cancel a pending idle-removal timer for a torrent, if any.
+   *
+   * @param {import("webtorrent").Torrent} torrent
+   * @returns {void}
+   */
+  #cancelIdleRemoval(torrent) {
+    const timer = this.#idleTimers.get(torrent);
+    if (timer) {
+      clearTimeout(timer);
+      this.#idleTimers.delete(torrent);
+    }
+  }
+
+  /**
+   * Remove a torrent from the pool together with its on-disk store, freeing
+   * disk while the proxy keeps running. Best-effort.
+   *
+   * @param {import("webtorrent").Torrent} torrent
+   * @returns {void}
+   */
+  #removeTorrent(torrent) {
+    if (!torrent) {
+      return;
+    }
+    // Drop it from the source→torrent map so a later request re-adds it.
+    for (const [key, value] of this.torrents) {
+      if (value === torrent) {
+        this.torrents.delete(key);
+        break;
+      }
+    }
+    this.fileUsageByTorrent.delete(torrent);
+    const name = typeof torrent.name === "string" ? torrent.name : "(unknown)";
+    try {
+      torrent.destroy({ destroyStore: true }, () => {
+        logger.info(`torrent-pool: removed idle torrent "${name}" and its store`);
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.warn(`torrent-pool: failed to remove idle torrent "${name}": ${message}`);
+    }
+  }
+
   /**
    * Return download statistics for a torrent and optionally a specific file.
    *
@@ -438,6 +546,12 @@ export class TorrentPool {
    * @returns {Promise<void>}
    */
   async destroyAll() {
+    // Cancel any pending idle-removal timers — destroyAll handles teardown.
+    for (const timer of this.#idleTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.#idleTimers.clear();
+
     if (!this.client || this.client.destroyed) {
       return;
     }