@torrent-tv/proxy 2.9.21 → 2.9.23

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.9.25
+
+- **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); ship together.
+
+## 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.
+
 ## 2.9.23
 
 - **New**: Symmetric-NAT port prediction for WebRTC (roadmap step 4; `webrtc-manager.js` + `nat-classifier.js` delta + `cli.js` wiring). When the startup NAT classification reports a **symmetric** NAT, for each real IPv4 `srflx` candidate the proxy also offers predicted-port candidates at `base + delta*k` (k = 1..16, `delta` = the per-destination external-port step measured at startup), each with a unique ICE foundation. The browser probes these too; if one matches the external port the NAT assigns for the proxy→browser path, ICE connects — the practical, signalling-only form of the birthday-paradox trick (no node-datachannel changes, no extra sockets). **Scope**: covers sequential/predictable symmetric NATs; a fully-random symmetric NAT (where the true 256-socket birthday would be needed) is not solved by this and is out of reach on the node-datachannel stack. No-op for cone NATs (the fixed-port mapping already suffices) and IPv6 (no NAT). Diagnostics: logs the injected predicted ports per session (`symmetric NAT (delta=D) — injecting N predicted srflx candidates: …`); combined with the existing `selected pair local=[…]` log this shows whether a predicted port won. NOTE: could not be exercised end-to-end — the dev's home NAT is cone; needs a symmetric-NAT vantage to verify in the field (the logging is there to diagnose it when it appears).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.9.21",
+  "version": "2.9.23",
   "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/webrtc-manager.js

@@ -13,7 +13,10 @@ import nodeDataChannel from "node-datachannel";
 
 /** @import { WebRtcSignal } from './tunnel-client.js' */
 
-const ICE_SERVERS = ["stun:stun.l.google.com:19302"];
+// Two STUN servers from different operators, both with IPv6 (AAAA) records, so
+// the proxy gathers a server-reflexive candidate over BOTH v4 and (when the
+// host has global v6) v6 — enabling a direct IPv6 path on v6-native networks.
+const ICE_SERVERS = ["stun:stun.l.google.com:19302", "stun:stun.cloudflare.com:3478"];
 
 // Symmetric-NAT port prediction window. For each real srflx candidate we offer
 // this many extra candidates at ports base + delta*k (k = 1..N), because the
@@ -82,46 +85,47 @@ function buildPredictedSrflxCandidates(candidate, delta, windowSize = PORT_PREDI
 }
 
 /**
- * Return true when the ICE candidate string describes a `typ host` candidate
- * with a private (RFC 1918 / ULA / loopback) IP address.
+ * Classify an ICE candidate by its address family and scope, for diagnostics.
  *
- * Browsers enforce Private Network Access (PNA) and show a permission dialog
- * when a page served from a public origin (e.g. webauth.courses) attempts a
- * WebRTC connection to a private-network address.  Filtering these candidates
- * out before forwarding them to the browser lets the connection proceed via the
- * server-reflexive (srflx) candidate — the proxy's public IP as seen by STUN —
- * which does not trigger PNA.
+ * Returns one of: `v4-private`, `v4-public`, `v6-global`, `v6-ula`,
+ * `v6-linklocal`, `v6-loopback`, or `unknown`. This is logged for every
+ * candidate so the field log shows whether a **global IPv6** path is being
+ * offered (IPv6 has no NAT — if both sides have a global v6 address the
+ * connection can go direct, which matters for v6-native mobile networks).
  *
- * Edge case: if no srflx candidate is available (STUN unreachable, symmetric
- * NAT that maps differently per destination, etc.) all host candidates are
- * suppressed and the connection will fail.  We accept this trade-off; STUN is
- * a hard dependency of the WebRTC path in any case.
+ * Note on PNA: a `v4-private` host candidate triggers the browser's Private
+ * Network Access permission prompt; the connection otherwise proceeds via the
+ * public srflx candidate. We forward all candidates regardless (the browser
+ * decides) — this only labels them.
  *
- * @param {string} candidate - Raw candidate attribute string from node-datachannel.
- * @returns {boolean}
+ * @param {string} candidate - Raw candidate attribute string (with or without `a=`).
+ * @returns {"v4-private"|"v4-public"|"v6-global"|"v6-ula"|"v6-linklocal"|"v6-loopback"|"unknown"}
  */
-function isPrivateHostCandidate(candidate) {
-  // Only care about "typ host" — srflx and relay are already public/relay.
-  if (!candidate.includes("typ host")) {
-    return false;
+function candidateAddrKind(candidate) {
+  const parts = candidate.replace(/^a=/, "").split(" ");
+  const ip = parts.length > 4 ? parts[4] : "";
+  if (!ip) {
+    return "unknown";
   }
-  // RFC 1918 IPv4 private ranges.
-  if (/\b(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.|169\.254\.)/.test(candidate)) {
-    return true;
+  if (!ip.includes(":")) {
+    // IPv4: RFC 1918 / loopback / link-local are private.
+    if (/^(10\.|127\.|169\.254\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.)/.test(ip)) {
+      return "v4-private";
+    }
+    return "v4-public";
   }
-  // Docker / typical private subnets not covered above (100.64–127 are special).
-  if (/\b127\./.test(candidate)) {
-    return true;
+  const low = ip.toLowerCase();
+  if (low === "::1") {
+    return "v6-loopback";
   }
-  // IPv6 loopback.
-  if (/\s::1\s/.test(candidate)) {
-    return true;
+  if (low.startsWith("fe80")) {
+    return "v6-linklocal";
   }
-  // IPv6 Unique Local Addresses (ULA): fc00::/7 — starts with fc or fd.
-  if (/\s(?:fc|fd)[0-9a-f]{2}:/i.test(candidate)) {
-    return true;
+  if (/^f[cd][0-9a-f]{2}:/.test(low)) {
+    // Unique Local Address (fc00::/7).
+    return "v6-ula";
   }
-  return false;
+  return "v6-global";
 }
 
 /**
@@ -245,11 +249,12 @@ export function createWebRtcManager({ sendSignal, onDataChannel, onLog, udpPort,
     // Network Access (PNA) permission dialog once; after the user allows it
     // the connection proceeds via the local LAN path.
     pc.onLocalCandidate((candidate, mid) => {
-      const isPrivate = isPrivateHostCandidate(candidate);
-      // Log the full candidate (addr:port typ …) so we can confirm WebRTC is
-      // pinned to the mapped UDP port and diagnose which paths are offered.
+      const kind = candidateAddrKind(candidate);
+      // Log the full candidate (addr:port typ …) with its address kind so we
+      // can confirm WebRTC is pinned to the mapped UDP port, see whether a
+      // global IPv6 path is offered, and diagnose which routes are available.
       log(
-        `[webrtc] Session ${sessionId.slice(0, 8)}: sending ${isPrivate ? "private" : "public"} candidate: ${candidate.replace(/^a=/, "")}`
+        `[webrtc] Session ${sessionId.slice(0, 8)}: sending ${kind} candidate: ${candidate.replace(/^a=/, "")}`
       );
       sendSignal(sessionId, { type: "candidate", candidate, mid });