@torrent-tv/proxy 2.46.0 → 2.47.0

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.47.0
+
+- **Fix**: The tunnel is replaced before anything upstream ends it, so a viewer no longer arrives to find no proxy. Something between the proxy and the server closes the socket after exactly **100 min 15 s** — measured across a day of logs 2026-08-20, three intervals of 100:15 wherever a restart did not reset the clock, `code=1006` each time, and with the 30 s keepalive running throughout, so it is a lifetime cap and not an idle timeout. Reconnecting afterwards takes five seconds during which this proxy does not exist as far as the registry is concerned. The connection is now replaced at ninety minutes and the replacement takes over FIRST: the new socket registers itself, the server atomically supersedes the old one, and only then does the old one close — so there is no instant with nothing registered. A socket that finds itself superseded says so rather than reporting the tunnel as down, and an abrupt close nobody asked for still reconnects as before. Pinned by a test against a real WebSocket server.
+
 ## 2.46.0
 
 - **New**: The cost of DECODING is measured per codec family, not once on H.264. A video that has to be re-encoded is by definition one the browser could not play — HEVC, 10-bit — so the one model the host had was fitted on the codec it is least often asked about, and those decode dearer per pixel on the same box. There are now sets for HEVC 8-bit and HEVC Main 10 beside the H.264 one (`assets/calibration/`, four clips each: two sizes at two bitrates, the smallest grid that keeps the axes independent and still leaves a spare), the source's own codec and bit depth choose the constants, and a family with no set of its own is priced as H.264 — said in the log rather than left to be inferred. Measured on a desktop 2026-08-20, the same 1080p picture at ~5.8 Mbit/s: 7.7x as 8-bit HEVC against 6.3x as 10-bit, which is why ten bits is its own family and not a multiplier. AV1 has no set yet; the release survey of 2026-07-10 found it rare where HEVC was 18 %.

package/package.json

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

package/services/tunnel-client.js

@@ -80,6 +80,28 @@ import { WebSocket } from "ws";
 const RECONNECT_DELAY_MS = 5_000;
 /** Send a keepalive ping every 30 s to prevent Cloudflare's idle WebSocket timeout (~100 s). */
 const KEEPALIVE_INTERVAL_MS = 30_000;
+/**
+ * Replace the connection before anything upstream ends it for us.
+ *
+ * Something between this process and the server closes the socket after
+ * exactly **100 min 15 s**, whatever is flowing over it. It is not an idle
+ * timeout — the keepalive above has been running for months — it is a lifetime
+ * cap. Measured across one day of logs (2026-08-20): 01:54:12 → 03:34:27 →
+ * ... the same 100:15 apart wherever a restart did not reset the clock, and
+ * with `code=1006`, an abrupt close with no closing handshake, which is what an
+ * intermediary killing a connection looks like.
+ *
+ * Reconnecting after the fact costs 5 s during which this proxy does not exist
+ * as far as the registry is concerned, and a viewer arriving in that window is
+ * told there is no proxy. So the connection is replaced BEFORE the cap, and the
+ * replacement is seamless: the new socket registers itself with the server,
+ * which atomically supersedes the old one, and only then does the old one
+ * close. There is no moment with nothing registered.
+ *
+ * Ninety minutes leaves ten minutes of margin against a cap that has been
+ * exact, and makes the replacement a quiet event rather than a race.
+ */
+const CONNECTION_LIFETIME_MS = 90 * 60_000;
 
 /**
  * Create and manage the outbound WebSocket tunnel to the registry server.
@@ -87,15 +109,30 @@ const KEEPALIVE_INTERVAL_MS = 30_000;
  * @param {TunnelClientOptions} options
  * @returns {TunnelClient}
  */
-export function createTunnelClient({ serverUrl, proxyId, token, proxyPort, onSignal, onConnect, onHealthRequest, onLog }) {
+export function createTunnelClient({
+  serverUrl,
+  proxyId,
+  token,
+  proxyPort,
+  onSignal,
+  onConnect,
+  onHealthRequest,
+  onLog,
+  connectionLifetimeMs = CONNECTION_LIFETIME_MS
+}) {
   const wsUrl = serverUrl.replace(/^http/, "ws").replace(/\/+$/, "") + "/ws/proxy-tunnel";
 
   /** @type {WebSocket | null} */
   let socket = null;
   /** @type {ReturnType<typeof setTimeout> | null} */
   let reconnectTimer = null;
-  /** @type {ReturnType<typeof setInterval> | null} */
-  let keepaliveTimer = null;
+  /**
+   * The renewal that will replace the live connection before the upstream cap
+   * ends it. Owned by the connection it belongs to, and cancelled with it.
+   *
+   * @type {ReturnType<typeof setTimeout> | null}
+   */
+  let renewalTimer = null;
   let stopped = false;
 
   /**
@@ -122,28 +159,46 @@ export function createTunnelClient({ serverUrl, proxyId, token, proxyPort, onSig
     }
     log(`Connecting tunnel to ${wsUrl}`);
 
-    socket = new WebSocket(wsUrl, {
+    // The connection being opened, held separately from `socket` so that a
+    // socket which has been SUPERSEDED can still recognise itself. During a
+    // renewal two exist for a moment, and the old one's close must not be
+    // mistaken for the tunnel going down.
+    const connection = new WebSocket(wsUrl, {
       headers: {
         "x-proxy-id": proxyId,
         "x-proxy-token": token,
         "user-agent": "torrent-tv-proxy/1.0"
       }
     });
+    /** @type {ReturnType<typeof setInterval> | null} */
+    let keepaliveTimer = null;
+    socket = connection;
 
-    socket.addEventListener("open", () => {
+    connection.addEventListener("open", () => {
       log("Tunnel connected.");
       // Start keepalive pings to prevent Cloudflare's idle WebSocket timeout.
       keepaliveTimer = setInterval(() => {
-        if (socket && socket.readyState === WebSocket.OPEN) {
-          send({ type: "ping" });
+        if (connection.readyState === WebSocket.OPEN) {
+          send({ type: "ping" }, connection);
         }
       }, KEEPALIVE_INTERVAL_MS);
+      // And replace this connection before the upstream lifetime cap does.
+      if (renewalTimer !== null) {
+        clearTimeout(renewalTimer);
+      }
+      renewalTimer = setTimeout(() => {
+        if (stopped || socket !== connection) {
+          return;
+        }
+        log("Tunnel renewing before the upstream lifetime cap; the replacement takes over first.");
+        connect();
+      }, connectionLifetimeMs);
       if (typeof onConnect === "function") {
         onConnect();
       }
     });
 
-    socket.addEventListener("message", (event) => {
+    connection.addEventListener("message", (event) => {
       let message;
       try {
         message = JSON.parse(event.data);
@@ -174,19 +229,31 @@ export function createTunnelClient({ serverUrl, proxyId, token, proxyPort, onSig
       }
     });
 
-    socket.addEventListener("close", (event) => {
-      log(`Tunnel disconnected (code=${event.code}). Reconnecting in ${RECONNECT_DELAY_MS}ms...`);
-      socket = null;
+    connection.addEventListener("close", (event) => {
       if (keepaliveTimer !== null) {
         clearInterval(keepaliveTimer);
         keepaliveTimer = null;
       }
+      // A connection this one replaced. The server closes it as soon as the
+      // replacement registers, which is the whole point of renewing early —
+      // there is nothing to report and nothing to reconnect, because the tunnel
+      // never went down.
+      if (socket !== connection) {
+        log(`Tunnel handed over (code=${event.code}); the replacement is already carrying it.`);
+        return;
+      }
+      log(`Tunnel disconnected (code=${event.code}). Reconnecting in ${RECONNECT_DELAY_MS}ms...`);
+      socket = null;
+      if (renewalTimer !== null) {
+        clearTimeout(renewalTimer);
+        renewalTimer = null;
+      }
       if (!stopped) {
         reconnectTimer = setTimeout(connect, RECONNECT_DELAY_MS);
       }
     });
 
-    socket.addEventListener("error", (event) => {
+    connection.addEventListener("error", (event) => {
       log(`Tunnel WebSocket error: ${event.message ?? "unknown"}`);
     });
   }
@@ -255,9 +322,14 @@ export function createTunnelClient({ serverUrl, proxyId, token, proxyPort, onSig
    * @param {object} message
    * @returns {void}
    */
-  function send(message) {
-    if (socket && socket.readyState === WebSocket.OPEN) {
-      socket.send(JSON.stringify(message));
+  function send(message, over = null) {
+    // Everything the proxy has to say goes over the LIVE connection. `over` is
+    // for the one thing that belongs to a particular socket rather than to the
+    // tunnel — its own keepalive — which must not be sent over a replacement
+    // that has already taken over.
+    const target = over ?? socket;
+    if (target && target.readyState === WebSocket.OPEN) {
+      target.send(JSON.stringify(message));
     }
   }
 
@@ -291,9 +363,9 @@ export function createTunnelClient({ serverUrl, proxyId, token, proxyPort, onSig
      */
     disconnect() {
       stopped = true;
-      if (keepaliveTimer !== null) {
-        clearInterval(keepaliveTimer);
-        keepaliveTimer = null;
+      if (renewalTimer !== null) {
+        clearTimeout(renewalTimer);
+        renewalTimer = null;
       }
       if (reconnectTimer != null) {
         clearTimeout(reconnectTimer);

package/test/tunnel-renewal.test.js

@@ -0,0 +1,126 @@
+/**
+ * @file The tunnel is replaced before anything upstream ends it, and the
+ * replacement takes over first.
+ *
+ * Something between the proxy and the server closes the socket after exactly
+ * 100 min 15 s whatever is flowing over it — measured across a day of logs on
+ * 2026-08-20, `code=1006` each time, with a 30 s keepalive running throughout,
+ * so it is a lifetime cap and not an idle timeout. Reconnecting afterwards
+ * costs five seconds in which the proxy does not exist as far as the registry
+ * is concerned, and a viewer arriving then is told there is no proxy.
+ *
+ * What is pinned here is the property that removes that window: at no instant
+ * is the server without a registered connection for this proxy.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { WebSocketServer } from "ws";
+
+import { createTunnelClient } from "../services/tunnel-client.js";
+
+/**
+ * A stand-in for the registry's tunnel endpoint, with the one behaviour that
+ * matters here: a new connection for a proxy REPLACES the previous one, which
+ * is what `registerConnection` does in `server/services/proxy-tunnel-server.js`.
+ *
+ * @returns {Promise<{ url: string, close: () => Promise<void>, registered: () => number, opened: () => number, everEmpty: () => boolean }>}
+ */
+async function startRegistry() {
+  const server = new WebSocketServer({ port: 0 });
+  await new Promise((resolve) => { server.on("listening", resolve); });
+  /** @type {import("ws").WebSocket | null} */
+  let current = null;
+  let opened = 0;
+  let everEmpty = false;
+  server.on("connection", (socket) => {
+    opened += 1;
+    const previous = current;
+    current = socket;
+    // The replacement is registered BEFORE the old one is closed, so a reader
+    // of `current` never sees nothing.
+    if (previous && previous.readyState < 2) {
+      previous.close(1000, "replaced");
+    }
+    socket.on("close", () => {
+      if (current === socket) {
+        current = null;
+        everEmpty = true;
+      }
+    });
+  });
+  const { port } = server.address();
+  return {
+    url: `http://127.0.0.1:${port}`,
+    close: () => new Promise((resolve) => { server.close(resolve); }),
+    registered: () => (current && current.readyState === 1 ? 1 : 0),
+    killCurrent: () => { current?.terminate(); },
+    opened: () => opened,
+    everEmpty: () => everEmpty
+  };
+}
+
+test("the connection is replaced before its lifetime runs out, without a gap", async (t) => {
+  const registry = await startRegistry();
+  /** @type {string[]} */
+  const lines = [];
+  const client = createTunnelClient({
+    serverUrl: registry.url,
+    proxyId: "p1",
+    token: "t",
+    proxyPort: 9090,
+    onLog: (line) => lines.push(line),
+    // The real cap is 100 min 15 s and the real renewal is at 90 min; the
+    // ratio is what matters, not the magnitude.
+    connectionLifetimeMs: 150
+  });
+  t.after(async () => {
+    client.disconnect();
+    await registry.close();
+  });
+
+  client.connect();
+  // Long enough for several renewals at 150 ms each.
+  await new Promise((resolve) => { setTimeout(resolve, 700); });
+
+  assert.ok(registry.opened() >= 3, `expected several renewals, saw ${registry.opened()}`);
+  // The property this exists for: the registry was never left with nothing.
+  assert.equal(registry.everEmpty(), false, "the registry lost its connection at some point");
+  assert.equal(registry.registered(), 1);
+  // And the proxy knows the difference between a handover and going down. A
+  // "Reconnecting in" line here would mean it had treated its own renewal as a
+  // failure and waited five seconds before coming back.
+  assert.ok(lines.some((line) => line.includes("Tunnel renewing")), lines.join("\n"));
+  assert.ok(lines.some((line) => line.includes("Tunnel handed over")), lines.join("\n"));
+  assert.equal(lines.filter((line) => line.includes("Reconnecting in")).length, 0, lines.join("\n"));
+});
+
+test("a connection killed from outside is still reconnected", async (t) => {
+  const registry = await startRegistry();
+  /** @type {string[]} */
+  const lines = [];
+  const client = createTunnelClient({
+    serverUrl: registry.url,
+    proxyId: "p2",
+    token: "t",
+    proxyPort: 9090,
+    onLog: (line) => lines.push(line),
+    // Far longer than this test runs, so nothing renews and the only close is
+    // the one forced below — which is what the upstream cap looks like from
+    // here: an abrupt end nobody asked for.
+    connectionLifetimeMs: 60_000
+  });
+  t.after(async () => {
+    client.disconnect();
+    await registry.close();
+  });
+
+  client.connect();
+  await new Promise((resolve) => { setTimeout(resolve, 200); });
+  assert.equal(registry.opened(), 1);
+
+  registry.killCurrent();
+  await new Promise((resolve) => { setTimeout(resolve, 300); });
+  // The renewal must not have taken the ordinary reconnect away with it.
+  assert.ok(lines.some((line) => line.includes("Reconnecting in")), lines.join("\n"));
+});