@torrent-tv/proxy 2.83.6 → 2.83.8

package/routes/api/client-logs/post.js

@@ -0,0 +1,86 @@
+/**
+ * @file Take the browser's own log and keep it beside the proxy's.
+ *
+ * The page has always forwarded its console somewhere; until now that was the
+ * SERVER's standard output on the droplet, which every release destroys. Both
+ * halves of a failure are needed to explain one — what the proxy did and what
+ * the page saw — and on 2026-09-13 an investigation ran on half of them for
+ * exactly that reason.
+ *
+ * Here the two land in one directory, on the host's durable disk, in files
+ * named so they join without guessing.
+ *
+ * The server's route stays and is not replaced: a page that has no proxy yet,
+ * or whose connection to one just failed, still has something to say, and those
+ * are the moments that matter most.
+ */
+
+const MAX_LINES = 50;
+const MAX_MSG_LEN = 2000;
+const MAX_TAG_LEN = 40;
+const MAX_SID_LEN = 16;
+const MAX_NAME_LEN = 200;
+
+/**
+ * @param {unknown} value
+ * @param {number} maxLen
+ * @returns {string}
+ */
+function safeString(value, maxLen) {
+  return (typeof value === "string" ? value : "").slice(0, maxLen);
+}
+
+/**
+ * Replace every control character with a space.
+ *
+ * These lines are written by a stranger's browser into a file a person will
+ * later read in a terminal: a newline would forge a log entry and an escape
+ * sequence would drive the terminal.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function sanitizeLine(value) {
+  let out = "";
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    out += code < 0x20 || code === 0x7f ? " " : character;
+  }
+  return out;
+}
+
+/**
+ * `POST /api/client-logs`
+ *
+ * Body: `{ sessionId, startedAt, torrentName, infoHash, tag, signalSessionId,
+ * lines: [{ level, ts, msg }] }`.
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ clientLogs: { write: (session: object, lines: string[]) => void } | null }} deps
+ * @returns {Promise<unknown>}
+ */
+export async function handleApiClientLogsPost(req, reply, { clientLogs }) {
+  const body = req.body && typeof req.body === "object" && !Array.isArray(req.body) ? req.body : {};
+  const session = {
+    sessionId: safeString(body.sessionId, MAX_SID_LEN) || "unknown",
+    startedAt: safeString(body.startedAt, 30),
+    torrentName: sanitizeLine(safeString(body.torrentName, MAX_NAME_LEN)),
+    infoHash: safeString(body.infoHash, 40)
+  };
+  const tag = sanitizeLine(safeString(body.tag, MAX_TAG_LEN)) || "Unknown/Unknown";
+  const rows = Array.isArray(body.lines) ? body.lines.slice(0, MAX_LINES) : [];
+
+  const lines = rows.map((row) => {
+    const entry = row && typeof row === "object" ? row : {};
+    const level = safeString(entry.level, 8) || "log";
+    const at = sanitizeLine(safeString(entry.ts, 16));
+    const message = sanitizeLine(safeString(entry.msg, MAX_MSG_LEN));
+    return `[${tag}] ${at} ${level}: ${message}`;
+  });
+
+  if (lines.length > 0) {
+    clientLogs?.write(session, lines);
+  }
+  return reply.code(204).send();
+}

package/routes/api/subtitles/get.js

@@ -24,6 +24,7 @@
  * @returns {Promise<void>}
  */
 
+import { deriveSourceKey } from "../../../services/torrent-source-key.js";
 import { spawn } from "node:child_process";
 import { TextSubtitleTrack } from "../../../services/tracks/TextSubtitleTrack.js";
 import { SubtitleController } from "../../../services/controllers/SubtitleController.js";
@@ -44,7 +45,7 @@ function setLanguageHeaders(reply, lang) {
   }
 }
 
-export async function handleApiSubtitlesGet(req, reply, { sourceRegistry, torrentPool, ffmpegBin, localBaseUrl }) {
+export async function handleApiSubtitlesGet(req, reply, { sourceRegistry, torrentPool, ffmpegBin, localBaseUrl, viewers }) {
   const query = req.query ?? {};
   const sourceKey = typeof query.sourceKey === "string" ? query.sourceKey.trim() : "";
   const fileIndex = Number(query.fileIndex);
@@ -55,6 +56,30 @@ export async function handleApiSubtitlesGet(req, reply, { sourceRegistry, torren
     return reply.code(400).send({ error: "sourceKey and fileIndex are required." });
   }
 
+  // Turning subtitles on is a fact about the VIEWER, and this is the only place
+  // that knows both the person and the file, so this is where it is recorded.
+  //
+  // It used to be recorded in the transport, against the CHANNEL, which the
+  // transport could only do by sniffing this path out of the request and
+  // deriving the torrent key itself. Two costs followed: a reconnect lost the
+  // subscription for the rest of the session, and the layer that carries bytes
+  // held application routing and torrent identity.
+  //
+  // The browser sends its registry key; the push side speaks the pool key, so
+  // the two are reconciled here — the same reconciliation the transport did.
+  const consumerId = typeof query.consumerId === "string" ? query.consumerId.trim() : "";
+  if (consumerId && hasTrackIndex && viewers) {
+    const record = sourceRegistry?.get(sourceKey);
+    if (record) {
+      try {
+        viewers.wantsCues(consumerId, await deriveSourceKey(record.sourceType, record.source), fileIndex);
+      } catch {
+        // A subscription that cannot be resolved costs this viewer pushed cues;
+        // it must not cost them the subtitles they asked for in this request.
+      }
+    }
+  }
+
   // Interface layer delegates to SubtitleController (orchestrator + domain),
   // which owns external-file vs embedded-track branching and the cluster walk.
   const controller = new SubtitleController({ sourceRegistry, torrentPool });

package/server.js

@@ -22,6 +22,8 @@ import { handleApiSourceStatsGet } from "./routes/api/sources/stats/get.js";
 import { handleApiSourceFilesGet } from "./routes/api/sources/files/get.js";
 import { handleApiSourceWarmPost } from "./routes/api/sources/warm/post.js";
 import { handleApiPlaybackPlanPost } from "./routes/api/playback-plan/post.js";
+import { handleApiClientLogsPost } from "./routes/api/client-logs/post.js";
+import { createClientLogFiles } from "./utils/client-log-file.js";
 import { handleApiSubtitlesGet } from "./routes/api/subtitles/get.js";
 import { handleApiTranscodeSessionsPost } from "./routes/api/transcode-sessions/post.js";
 import { handleApiTranscodeSessionsProgressGet } from "./routes/api/transcode-sessions/progress/get.js";
@@ -84,7 +86,11 @@ function buildPortCandidates(startPort, maxAttempts = 51) {
  */
 export async function startProxyServer({
   host, port, transcodeAudio, ffmpegBin, maxDiskBytes, memoryBytes, segmentFormat, stateDir, onSubtitleCues,
-  deliverySink = false
+  deliverySink = false,
+  // Where the proxy writes its own log. Its DIRECTORY is what matters here:
+  // the browser's half of every session is written beside it, so the two are
+  // on one durable disk and join by name.
+  logFile = ""
 }) {
   const app = Fastify({
     // No practical body-size limit — the proxy server is localhost-only and
@@ -346,6 +352,12 @@ export async function startProxyServer({
   app.post("/api/sources/:sourceKey/warm", async (req, reply) =>
     handleApiSourceWarmPost(req, reply, { sourceRegistry, torrentPool })
   );
+  // The browser's own log, kept beside the proxy's. See the route's own file
+  // for why it is here and not only on the registry server.
+  const clientLogs = logFile ? createClientLogFiles(logFile) : null;
+  app.post("/api/client-logs", async (req, reply) =>
+    handleApiClientLogsPost(req, reply, { clientLogs })
+  );
   app.post("/api/playback-plan", async (req, reply) =>
     handleApiPlaybackPlanPost(req, reply, { playbackPlanner })
   );
@@ -354,7 +366,8 @@ export async function startProxyServer({
       sourceRegistry,
       torrentPool,
       ffmpegBin,
-      localBaseUrl: hlsSessionManager.localBaseUrl
+      localBaseUrl: hlsSessionManager.localBaseUrl,
+      viewers: hlsSessionManager.viewers
     })
   );
   app.get("/stream", async (req, reply) =>

package/services/data-channel-handler.js

@@ -45,7 +45,6 @@
 
 /** @import { DataChannel } from 'node-datachannel' */
 
-import { deriveSourceKey } from "./torrent-source-key.js";
 import { createDeliveryProbe, PROBE_INTERVAL_MS } from "./delivery-probe.js";
 
 /**
@@ -582,11 +581,79 @@ export function encodeFrame(idBytes, bytes, done) {
   return frame;
 }
 
+/**
+ * Reshapes a body into messages of `sizeBytes` each, handing every finished one
+ * to `sendOne`. A size of zero passes each body read through untouched, which
+ * is what the field does today — 10 657 210 bytes over 163 messages, so 65 382
+ * each, measured 2026-09-12.
+ *
+ * Only the SIZE changes: the same bytes reach the far end in the same order,
+ * over the same channel. That is what makes a comparison between two sizes a
+ * comparison of one thing, and it is why the wedge's dependence on the size can
+ * be measured at all — the wedge of 2026-09-12 arrived in the middle of one
+ * message, with 63 % of a segment on the wire and then nothing.
+ *
+ * @param {(bytes: Uint8Array) => void} sendOne - Given each finished message.
+ * @param {number}                      sizeBytes - 0 to leave reads as they are.
+ * @returns {{ push: (bytes: Uint8Array) => number, flush: () => number }}
+ *   Both answer how many messages they sent, so a caller counting messages
+ *   counts messages rather than body reads.
+ */
+export function bodySender(sendOne, sizeBytes) {
+  if (!(sizeBytes > 0)) {
+    return {
+      push(bytes) {
+        sendOne(bytes);
+        return 1;
+      },
+      flush() {
+        return 0;
+      }
+    };
+  }
+  /** @type {Uint8Array[]} */
+  let held = [];
+  let heldBytes = 0;
+  const release = () => {
+    const message = held.length === 1 ? held[0] : Buffer.concat(held);
+    held = [];
+    heldBytes = 0;
+    sendOne(message);
+  };
+  return {
+    push(bytes) {
+      let sent = 0;
+      let offset = 0;
+      while (offset < bytes.length) {
+        const take = Math.min(sizeBytes - heldBytes, bytes.length - offset);
+        held.push(bytes.subarray(offset, offset + take));
+        heldBytes += take;
+        offset += take;
+        if (heldBytes === sizeBytes) {
+          release();
+          sent += 1;
+        }
+      }
+      return sent;
+    },
+    flush() {
+      if (heldBytes === 0) return 0;
+      release();
+      return 1;
+    }
+  };
+}
+
 export function createDataChannelHandler({
   proxyPort,
   onLog,
   getTransportSnapshot,
-  sourceRegistry,
+  // Who wants pushed subtitle cues for a file, BY NAME. A plain function
+  // returning opaque ids: this layer never learns what a viewer is, and the
+  // subscription it used to hold against a channel — and had to sniff
+  // `/api/subtitles` to build — now belongs to the person and outlives the
+  // channel, a reconnect and a deliberate rotation alike.
+  viewersWantingCues = () => [],
   witness,
   // Reads usrsctp's own association state (services/usrsctp-state.js) the
   // moment a wedge is declared, from either detector below. Optional: a host
@@ -599,7 +666,14 @@ export function createDataChannelHandler({
   // released a viewer when their connection closed: the only exits were the
   // browser's own `release` and a silence long enough to be called an absence.
   onViewerPresent = () => {},
-  onViewerGone = () => {}
+  onViewerGone = () => {},
+  // The size of one data-channel message carrying body bytes. Zero keeps
+  // whatever the body read hands over, which in the field is 65 382 bytes —
+  // 10 657 210 over 163 chunks, measured 2026-09-12. It is settable because
+  // that day's wedge arrived in the MIDDLE of one message (63 % of a segment
+  // on the wire, then nothing), and whether the fault depends on the size is
+  // the one branch no capture has been able to close.
+  sendChunkBytes = 0
 }) {
   /**
    * Who is on each connection, by WebRTC session id.
@@ -639,40 +713,30 @@ export function createDataChannelHandler({
     }
   }
   /**
-   * Channels currently interested in one file's subtitle cues, keyed by
-   * `sourceKey:fileIndex`. Populated the moment a browser asks for an
-   * embedded track — there is no separate subscribe message on the wire, the
-   * existing `/api/subtitles` request already says which file a viewer opened
-   * subtitles for. Pruned on channel close and, defensively, on a failed send.
+   * The channel each viewer is reachable on right now, by the name the far end
+   * presented when it opened.
    *
-   * @type {Map<string, Set<DataChannel>>}
+   * The transport knows a NAME and nothing else about a viewer: what it means,
+   * who holds it and what they are watching are somebody else's facts. Keeping
+   * only "this name is reachable here" is what lets a subscription made once
+   * outlive the channel it was made on — a reconnect, and a rotation done on
+   * purpose, both just rewrite this entry.
+   *
+   * @type {Map<string, DataChannel>}
    */
-  const subtitleSubscribers = new Map();
+  const channelOfViewer = new Map();
 
   /**
-   * @param {string} sourceKey
-   * @param {number} fileIndex
+   * Forget every name that was reachable on this channel.
+   *
    * @param {DataChannel} channel
    * @returns {void}
    */
-  function subscribeSubtitles(sourceKey, fileIndex, channel) {
-    const key = `${sourceKey}:${fileIndex}`;
-    let set = subtitleSubscribers.get(key);
-    if (!set) {
-      set = new Set();
-      subtitleSubscribers.set(key, set);
-    }
-    const isNew = !set.has(channel);
-    set.add(channel);
-    if (isNew) {
-      log(`[dc] subtitle push: channel subscribed to ${key} (${set.size} channel(s) now)`);
-    }
-  }
-
-  /** @param {DataChannel} channel */
-  function unsubscribeSubtitlesAll(channel) {
-    for (const set of subtitleSubscribers.values()) {
-      set.delete(channel);
+  function forgetChannel(channel) {
+    for (const [consumerId, on] of channelOfViewer) {
+      if (on === channel) {
+        channelOfViewer.delete(consumerId);
+      }
     }
   }
 
@@ -688,30 +752,37 @@ export function createDataChannelHandler({
    * @returns {void}
    */
   function publishSubtitleCues({ sourceKey, fileIndex, trackIndex, cues, language, detectedLanguage, cursor }) {
-    const set = subtitleSubscribers.get(`${sourceKey}:${fileIndex}`);
-    if (!set || set.size === 0) {
+    const names = viewersWantingCues(sourceKey, fileIndex);
+    if (names.length === 0) {
       log(
         `[dc] subtitle push: ${cues.length} cue(s) for ${sourceKey.slice(0, 8)}:${fileIndex} track ${trackIndex} ` +
-        "found no subscribed channel"
+        "found nobody who wants them"
       );
       return;
     }
-    const message = { type: "subtitle-cues", fileIndex, trackIndex, cues, language, detectedLanguage, cursor };
-    const total = set.size;
+    const message = JSON.stringify({
+      type: "subtitle-cues", fileIndex, trackIndex, cues, language, detectedLanguage, cursor
+    });
     let sent = 0;
-    for (const channel of set) {
+    for (const consumerId of names) {
+      const channel = channelOfViewer.get(consumerId);
+      if (!channel) {
+        // Subscribed but not reachable this instant — between connections, or
+        // rotating. Nothing is dropped: they are still subscribed, and the walk
+        // keeps a per-viewer cursor, so what they missed comes on the next ask.
+        continue;
+      }
       try {
-        channel.sendMessage(JSON.stringify(message));
+        channel.sendMessage(message);
         sent += 1;
       } catch {
-        // Closed between the subscription and this send; onClosed will not
-        // fire for a channel that is already gone, so drop it here too.
-        set.delete(channel);
+        // Closed between the lookup and the send. The subscription belongs to
+        // the person and stays; only this delivery is lost.
       }
     }
     log(
       `[dc] subtitle push: sent ${cues.length} cue(s) for ${sourceKey.slice(0, 8)}:${fileIndex} track ${trackIndex} ` +
-      `to ${sent}/${total} channel(s)`
+      `to ${sent}/${names.length} viewer(s)`
     );
   }
 
@@ -914,6 +985,7 @@ export function createDataChannelHandler({
         const isNew = !known.has(message.consumerId);
         known.add(message.consumerId);
         viewersOnConnection.set(sessionId, known);
+        channelOfViewer.set(message.consumerId, channel);
         if (isNew) {
           log(`[dc] Session ${tag}: viewer ${message.consumerId} is on this connection`);
         }
@@ -952,7 +1024,7 @@ export function createDataChannelHandler({
         clearTimeout(entry.timer);
       }
       partials.clear();
-      unsubscribeSubtitlesAll(channel);
+      forgetChannel(channel);
       log(`[dc] Session ${tag}: channel closed`);
       // The ordinary way a viewer leaves, and the only one that is immediate.
       // Everything else — a silence long enough to be called an absence, the
@@ -988,45 +1060,6 @@ export function createDataChannelHandler({
       return;
     }
 
-    // Piggy-backs on the browser's own request for an EMBEDDED track — no
-    // separate subscribe message. `trackIndex` is what tells the two request
-    // shapes apart: an external subtitle FILE (no trackIndex) names a
-    // different file's own index in `fileIndex` — the subtitle file's, not the
-    // video's — and subscribing under that would just be a key nothing ever
-    // publishes to (an external file is one whole-file read, not something
-    // this walks incrementally). `fileIndex` alone would also scope this to
-    // the wrong grain for the real case — a torrent can carry several playable
-    // files — so the pair is what a push is ever addressed to.
-    //
-    // The browser's `sourceKey` is a REGISTRY key — a hash of the raw request
-    // bytes, one per (magnet-or-.torrent, this API session). The torrent pool
-    // publishes under its OWN key — the content's infohash, deliberately the
-    // SAME for a magnet and a `.torrent` naming the same film, so the two
-    // share one swarm (item 10). The two are different strings for the same
-    // torrent whenever a source was added by its `.torrent` file (a `.torrent`
-    // and a magnet are different request bytes, same infohash) — subscribing
-    // under the registry key found no publisher for that reason, not because
-    // nothing was ever read: field case 2026-08-22, cues were found and
-    // logged, every push answered "found no subscribed channel". Resolved to
-    // the pool's key here, the one place both are in hand.
-    if (path === "/api/subtitles" && typeof query === "string") {
-      const params = new URLSearchParams(query);
-      const registrySourceKey = params.get("sourceKey");
-      const fileIndex = Number(params.get("fileIndex"));
-      const hasTrackIndex = params.get("trackIndex") !== null && params.get("trackIndex") !== "";
-      if (registrySourceKey && Number.isInteger(fileIndex) && hasTrackIndex) {
-        const record = sourceRegistry?.get(registrySourceKey);
-        if (record) {
-          try {
-            const poolSourceKey = await deriveSourceKey(record.sourceType, record.source);
-            subscribeSubtitles(poolSourceKey, fileIndex, channel);
-          } catch (error) {
-            log(`[dc] subtitle push: could not resolve ${registrySourceKey.slice(0, 8)} to a pool key: ` +
-              `${error instanceof Error ? error.message : error}`);
-          }
-        }
-      }
-    }
 
     const queryInfo = query ? `?${query}` : "";
     const bodyInfo =
@@ -1092,12 +1125,14 @@ export function createDataChannelHandler({
       let readMs = 0;
       let sendMs2 = 0;
       let drainMs = 0;
+      const body = bodySender((bytes) => sendChunk(channel, requestId, bytes, false), sendChunkBytes);
       resetEventLoopDelay();
       while (true) {
         const readStartedAt = performance.now();
         const { done, value } = await reader.read();
         readMs += performance.now() - readStartedAt;
         if (done) {
+          chunks += body.flush();
           sendChunk(channel, requestId, null, true);
           const elapsedMs = Date.now() - sendStartedAt;
           let bufferedNow = 0;
@@ -1107,6 +1142,9 @@ export function createDataChannelHandler({
           log(
             `[net-debug] sent ${path}${queryInfo} bytes=${totalBytes} fetchMs=${fetchMs} ` +
               `ttfbMs=${firstByteMs} sendMs=${elapsedMs} chunks=${chunks} ` +
+              // The size of one message, so a reading can be attributed to the
+              // size it was taken at rather than to the run it came from.
+              `msgBytes=${sendChunkBytes > 0 ? sendChunkBytes : "asread"} ` +
               `maxBuffered=${maxBuffered} bufferedAtEnd=${bufferedNow} ` +
               // Where the time went: reading the body from the local route,
               // handing chunks to the channel, or waiting for its queue. Plus
@@ -1120,14 +1158,13 @@ export function createDataChannelHandler({
           break;
         }
         if (firstByteMs < 0) firstByteMs = Date.now() - sendStartedAt;
-        chunks += 1;
         totalBytes += value.length;
         try {
           const b = typeof channel.bufferedAmount === "function" ? channel.bufferedAmount() : 0;
           if (b > maxBuffered) maxBuffered = b;
         } catch { /* ignore */ }
         const sendStepAt = performance.now();
-        sendChunk(channel, requestId, value, false);
+        chunks += body.push(value);
         sendMs2 += performance.now() - sendStepAt;
         // Backpressure: do not keep queuing chunks once the channel's outgoing
         // buffer is large — wait for it to drain. Prevents the SCTP send buffer