@torrent-tv/proxy 2.9.17 → 2.9.18

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.9.18
+
+- **New**: WebRTC is now reachable behind NAT via a static UDP port mapping. All sessions are pinned to a single UDP port (same number as the HTTP port, default 9090) and multiplexed over it (`enableIceUdpMux` + `portRangeBegin`/`portRangeEnd` in `webrtc-manager.js`), and that UDP port is UPnP/NAT-PMP-mapped at startup (a second `port-mapper.js` instance, protocol UDP, removed on shutdown). Because the socket is bound to a fixed, statically-mapped port, the proxy's `srflx` ICE candidate now carries `publicIP:9090` — reachable from the browser even behind symmetric NAT for that port (previously WebRTC used an ephemeral UDP port that UPnP could not map). Verified: two PeerConnections share the one UDP port with no bind conflict; host + srflx (v4 and global v6) candidates all carry the fixed port. The UDP endpoint is not reported to the server (the browser learns it via ICE, not the TCP dial-back probe).
+
 ## 2.9.17
 
 - **New**: The proxy reports its UPnP-mapped external endpoint to the server over the tunnel (new `proxy-endpoint` message: `{ externalIp, externalPort, protocol }` from `port-mapper.getMappedEndpoint()`). Sent when the mapping completes and re-sent on every tunnel (re)connect, so the server can dial back and verify the proxy is reachable from the internet (server 0.8.22). No effect if port mapping is disabled or failed.

package/bin/cli.js

@@ -122,6 +122,9 @@ let tunnelClient = null;
 /** @type {ReturnType<typeof createPortMapper> | null} */
 let portMapper = null;
 
+/** @type {ReturnType<typeof createPortMapper> | null} UDP mapping for the WebRTC port. */
+let udpPortMapper = null;
+
 
 /**
  * Register this proxy with the registry server.
@@ -190,12 +193,16 @@ async function shutdown(signal) {
   }
   logger.warn(`Received ${signal}, shutting down...`);
   try {
-    // Remove the router port mapping before exiting (lease expiry is the
+    // Remove the router port mappings before exiting (lease expiry is the
     // backstop if this is skipped on a hard kill).
     if (portMapper) {
       await portMapper.stop();
       portMapper = null;
     }
+    if (udpPortMapper) {
+      await udpPortMapper.stop();
+      udpPortMapper = null;
+    }
     if (app) {
       await app.close();
     }
@@ -248,6 +255,21 @@ try {
         const message = error instanceof Error ? error.message : String(error);
         logger.warn(`Port mapping failed to start: ${message}`);
       });
+
+    // Also map the WebRTC UDP port (same number, different protocol). All
+    // WebRTC sessions are multiplexed onto this single UDP port (ICE UDP mux),
+    // so a static mapping makes the proxy's WebRTC path reachable even behind
+    // symmetric NAT. This endpoint is NOT reported to the server: the browser
+    // discovers it via ICE (srflx) candidates, not the TCP dial-back probe.
+    udpPortMapper = createPortMapper({
+      port: actualPort,
+      protocol: "UDP",
+      description: "torrent-tv proxy (WebRTC)"
+    });
+    void udpPortMapper.start().catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.warn(`UDP port mapping failed to start: ${message}`);
+    });
   } else {
     logger.info("Automatic port mapping is disabled (--no-port-mapping).");
   }
@@ -297,6 +319,9 @@ try {
   });
 
   webRtcManager = createWebRtcManager({
+    // Pin all WebRTC sessions to this single UDP port (multiplexed via ICE UDP
+    // mux) so the UPnP UDP mapping above makes the WebRTC path reachable.
+    udpPort: actualPort,
     sendSignal(sessionId, signal) {
       tunnelClient?.sendSignal(sessionId, signal);
     },

package/package.json

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

package/services/webrtc-manager.js

@@ -70,6 +70,11 @@ function isPrivateHostCandidate(candidate) {
  *   `node-datachannel` `DataChannel` object; hand it to `createDataChannelHandler`.
  * @property {(message: string) => void} [onLog]
  *   Optional log sink.
+ * @property {number} [udpPort]
+ *   When set, every PeerConnection is pinned to this single UDP port and ICE
+ *   UDP multiplexing is enabled, so all sessions share one port that can be
+ *   statically UPnP-mapped (makes the WebRTC path reachable behind NAT). When
+ *   omitted, node-datachannel uses an ephemeral UDP port (previous behaviour).
  */
 
 /**
@@ -89,10 +94,20 @@ function isPrivateHostCandidate(candidate) {
  * @param {WebRtcManagerOptions} options
  * @returns {WebRtcManager}
  */
-export function createWebRtcManager({ sendSignal, onDataChannel, onLog }) {
+export function createWebRtcManager({ sendSignal, onDataChannel, onLog, udpPort }) {
   /** @type {Map<string, import("node-datachannel").PeerConnection>} */
   const peers = new Map();
 
+  // Base PeerConnection config shared by every session. When a UDP port is
+  // configured, pin all sessions to it and enable ICE UDP mux so they share the
+  // single (UPnP-mapped) port; otherwise fall back to an ephemeral UDP port.
+  const pcConfig = { iceServers: ICE_SERVERS };
+  if (Number.isInteger(udpPort) && udpPort > 0 && udpPort <= 65535) {
+    pcConfig.enableIceUdpMux = true;
+    pcConfig.portRangeBegin = udpPort;
+    pcConfig.portRangeEnd = udpPort;
+  }
+
   /**
    * @param {string} message
    * @returns {void}
@@ -118,9 +133,7 @@ export function createWebRtcManager({ sendSignal, onDataChannel, onLog }) {
       return existing;
     }
 
-    const pc = new nodeDataChannel.PeerConnection(`proxy-${sessionId.slice(0, 8)}`, {
-      iceServers: ICE_SERVERS
-    });
+    const pc = new nodeDataChannel.PeerConnection(`proxy-${sessionId.slice(0, 8)}`, pcConfig);
 
     // Forward all ICE candidates to the browser through the tunnel.
     //