@torrent-tv/proxy 2.9.80 → 2.9.81

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.9.81
+
+- **New**: The stream route says why a read failed. A body that failed mid-flight was dropped silently — the connection closed with no status and no log line, which from the client looks like the proxy died and from the log like nothing happened; found while probing the route by hand, where every ranged read closed the socket without a word. It now reports the file, the range, how many bytes had been sent, and the error.
+
 ## 2.9.80
 
 - **Fix**: A seek backward could hang forever. `prioritizeByteRange` demotes the pieces behind the playhead with `deselect`, which removes them from the download set — and `critical`, which runs right after, only flags pieces that are already selected, so it never puts them back. A seek forward followed by a seek backward therefore left the target pieces wanted by nobody: the encoder waited on data the torrent had been told to stop fetching, while the swarm ran at full speed on pieces nobody needed. The read position is now re-selected whenever it moves back behind what an earlier seek deselected, tracked per file because WebTorrent does not report its own selection back.

package/package.json

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

package/routes/stream/get.js

@@ -7,6 +7,7 @@
  */
 
 import { parseRange } from "../../utils/parse-range.js";
+import { logger } from "../../utils/logger.js";
 
 /**
  * Resolve source parameters from the query string.
@@ -121,6 +122,7 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool
     // being fetched for nobody.
     reply.raw.once("close", () => fragments.cancel());
 
+    let sent = 0;
     try {
       for await (const fragment of fragments) {
         if (reply.raw.writableEnded || reply.raw.destroyed) {
@@ -130,15 +132,23 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool
         await new Promise((resolve, reject) => {
           reply.raw.write(fragment.bytes, (error) => (error ? reject(error) : resolve()));
         });
+        sent += fragment.bytes.length;
         // Only now are these bytes gone: the piece can be unpinned, and the
         // slot it occupies reused. Releasing before this point corrupts the
         // response silently.
         fragment.release();
       }
       reply.raw.end();
-    } catch {
+    } catch (error) {
       // The body is already committed by its headers, so there is nothing
       // useful to send instead — drop the connection and let the client retry.
+      // But say why: swallowing this made the route close connections with no
+      // status and no trace, which from the client looks like the proxy died
+      // and from the log looks like nothing happened at all.
+      logger.warn(
+        `stream: read of "${file.name}" bytes ${start}-${end} failed after ` +
+        `${sent} of ${contentLength} bytes: ${error instanceof Error ? error.message : String(error)}`
+      );
       reply.raw.destroy();
     } finally {
       releaseFile();