@torrent-tv/proxy 2.2.0 → 2.5.0

package/Dockerfile

@@ -1,5 +1,5 @@
 # syntax=docker/dockerfile:1.7
-FROM node:22-alpine
+FROM node:24-alpine
 
 ENV NODE_ENV=production
 ENV PORT=9090

package/README.md

@@ -1,230 +1,335 @@
-# Torrent Proxy Client
+# @torrent-tv/proxy
 
-`@torrent-tv/proxy` is a lightweight Node.js service that turns torrent content into HTTP endpoints that are easy to consume from web players and backend services.
-
-It is designed for setups where a central registry/UI needs a simple direct media URL, while the actual torrent fetching happens on a separate edge/client machine.
+A lightweight Node.js service that streams torrent content to browsers via a direct WebRTC P2P data channel or, when needed, HTTP. It handles torrent fetching, codec detection, and on-demand HLS transcoding with ffmpeg.
 
 ## Why this exists
 
-- Browsers and many media players cannot consume torrents directly.
-- This service exposes torrent files through regular HTTP (`/stream`) with range support.
-- It can optionally create HLS sessions with AAC audio when direct playback is not suitable.
-- It can also create HLS sessions with video transcoding when browser-side decode still fails.
-- It registers itself in an external registry service and sends heartbeats, so other services can discover and use it.
+- Browsers cannot consume torrents directly.
+- This service exposes torrent files through HTTP (`/stream`) with Range support, and through a WebRTC data channel for NAT-traversed streaming.
+- It can transcode audio (or video + audio) to HLS on demand so the browser can always play the content regardless of codec support.
+- It registers itself in an external registry server and maintains a persistent tunnel WebSocket so the server can route browser requests and WebRTC signals to it.
 
-## What it does
+## Architecture Overview
 
-- Runs a Fastify server with health and media endpoints.
-- Accepts torrent sources (`magnet` or base64 `.torrent`) and returns a stable `sourceKey`.
-- Streams a selected file from a torrent by `fileIndex`.
-- Builds a playback plan (`direct` vs `hls`) based on detected audio codec and returns both audio/video codecs.
-- Starts ffmpeg-based HLS transcoding sessions (`audio-only` or `video+audio`) and serves generated playlist/segments.
-- Tracks multi-client consumers per transcode session and stops ffmpeg when the last consumer releases.
+```mermaid
+graph TB
+  subgraph Browser
+    WP[WebRtcProxy]
+    HLS[HLS.js + WebRtcHlsLoader]
+  end
 
-## Requirements
+  subgraph Server["Registry Server"]
+    API[REST API]
+    TS[ProxyTunnelServer]
+    SH[SignalHub /ws/browser-signal]
+  end
 
-- Node.js 18+ (ESM and built-in `fetch` are required).
-- npm.
-- ffmpeg is required only when audio transcoding is enabled.
-  - By default, the package uses `ffmpeg-static`.
-  - You can override binary path with `--ffmpeg-bin`.
-  - You can disable transcoding with `--no-transcode-audio`.
+  subgraph Proxy["@torrent-tv/proxy (Fastify)"]
+    TC[TunnelClient]
+    WM[WebRtcManager]
+    HC[HealthCollector]
+    DCH[DataChannelHandler]
+    PP[PlaybackPlanner]
+    HLM[HlsSessionManager]
+    TP[TorrentPool]
+    FF[ffmpeg]
+  end
 
-## Install
+  TC -->|"persistent WebSocket /ws/proxy-tunnel"| TS
+  TC -->|re-register on reconnect| API
+  HC -->|metrics: cpu, mem, load| TC
 
-```bash
-npm install
+  TS <-->|signal forward| SH
+  SH <-->|WebSocket| WP
+
+  WP <-->|"P2P data channel (STUN)"| WM
+  WM --> DCH
+  DCH --> TP
+  DCH --> HLM
+  HLM --> FF
+
+  HLS -->|segment/manifest fetches| WP
 ```
 
-## Run
+## Service Internals
 
-```bash
-npm start -- --server-url http://localhost:3000
+### TunnelClient
+
+Opens one persistent WebSocket to the registry server's `/ws/proxy-tunnel` endpoint on startup.
+Reconnects automatically with back-off on unexpected close.
+
+Handles three inbound message types from the server:
+
+| Message type | What the proxy does |
+|---|---|
+| `health-request` | Calls `HealthCollector`, sends `health-response` back through tunnel |
+| `signal` | Forwards SDP offer or ICE candidate to `WebRtcManager` |
+| `relay-request` | Fetches the path from local Fastify, streams `relay-response` back |
+
+### WebRtcManager
+
+Manages RTCPeerConnection sessions keyed by `sessionId`. On receiving an SDP offer from the server it creates a peer connection using [`node-datachannel`](https://github.com/murat-dogan/node-datachannel), generates an answer, and exchanges ICE candidates through the tunnel. When the data channel opens it hands it off to `DataChannelHandler`.
+
+```mermaid
+sequenceDiagram
+  participant S as Server (via TunnelClient)
+  participant WM as WebRtcManager
+  participant DC as DataChannelHandler
+
+  S->>WM: { type:"offer", sessionId, sdp }
+  WM->>WM: createPeerConnection(sessionId)
+  WM->>WM: setRemoteDescription(offer)
+  WM->>WM: createAnswer()
+  WM->>S: { type:"answer", sdp }
+
+  loop ICE candidates
+    WM->>S: { type:"candidate", candidate, mid }
+    S->>WM: { type:"candidate", … }
+  end
+
+  Note over WM: data channel opens
+  WM->>DC: handleChannel(dataChannel)
 ```
 
-Minimal required argument:
+### DataChannelHandler
+
+Receives JSON `request` messages over the data channel and dispatches them to the proxy's local Fastify server. Responses are streamed back as base64 `response-chunk` messages.
+
+**Wire protocol (browser ↔ proxy):**
 
-- `--server-url <url>`: base URL of your registry server.
+| Direction | Type | Key fields |
+|---|---|---|
+| Browser → Proxy | `request` | `requestId`, `method`, `path`, `query`, `headers`, `body` |
+| Proxy → Browser | `response-start` | `requestId`, `status`, `headers` |
+| Proxy → Browser | `response-chunk` | `requestId`, `data` (base64), `done: true\|false` |
+| Proxy → Browser | `response-error` | `requestId`, `error` |
+| Browser → Proxy | `ping` | `id` |
+| Proxy → Browser | `pong` | `id` |
 
-Useful optional arguments:
+### HealthCollector
+
+Collects system-level health metrics on every request from the server:
+
+| Metric | Range | Description |
+|---|---|---|
+| `cpuLoad` | 0 – ∞ | 1-minute load average divided by CPU count (>1 = overloaded) |
+| `memFree` | 0 – 1 | Free memory fraction |
+| `activeSessions` | 0 – ∞ | Number of active HLS transcode sessions |
+
+The browser uses these metrics together with tunnel RTT to score proxies:
+
+```
+score = memFree × 0.4 + (1 - clamp(cpuLoad, 0, 1)) × 0.4 − (rttMs / 2000) × 0.2
+```
+
+### HlsSessionManager & ffmpeg
+
+Creates and manages ffmpeg-based HLS transcode sessions. Sessions are keyed by `sourceKey:fileIndex:mode` and shared across consumers.
+
+```mermaid
+sequenceDiagram
+  participant B as Browser (via DataChannel)
+  participant H as HlsSessionManager
+  participant F as ffmpeg
+
+  B->>H: POST /api/transcode-sessions (consumerId, mode)
+  H->>F: start (or reuse) ffmpeg process
+  H-->>B: { sessionId, playlistPath }
+
+  loop segment requests
+    B->>H: GET /transcode/:sessionId/seg000.ts
+    H-->>B: MPEG-TS segment (via data channel chunk)
+  end
 
-- `--host <host>`: bind host (default `127.0.0.1`).
-- `--port <port>`: preferred local port (default `9090`; first free port in range is selected).
-- `--public-base-url <url>`: externally reachable base URL advertised to registry.
-- `--id <id>`: stable proxy client id.
-- `--name <name>`: display name for registry.
-- `--token <token>`: token sent to register/heartbeat endpoints.
-- `--ffmpeg-bin <path>`: custom ffmpeg binary path.
-- `--no-transcode-audio`: disable HLS audio transcoding.
-- `--help`: print all options with descriptions and examples, then exit.
+  B->>H: GET /api/transcode-sessions/:id/progress
+  H-->>B: { percent, speed, remainingSeconds, … }
+
+  B->>H: POST /api/transcode-sessions/:id/release (consumerId)
+  H->>H: remove consumer
+  alt last consumer released
+    H->>F: kill process + cleanup segments
+  end
+```
 
 ## HTTP API
 
-Base URL examples below use `http://127.0.0.1:9090`.
+Base URL examples use `http://127.0.0.1:9090`.
 
 ### Health
 
 ```bash
-curl http://127.0.0.1:9090/health
-curl http://127.0.0.1:9090/healthz
+GET /health
+GET /healthz
 ```
 
-### 1) Register a source
+### Register a source
 
 ```bash
-curl -X POST http://127.0.0.1:9090/api/sources \
-  -H "Content-Type: application/json" \
-  -d '{
-    "sourceType": "magnet",
-    "source": "magnet:?xt=urn:btih:..."
-  }'
-```
-
-Response:
+POST /api/sources
+Content-Type: application/json
 
-```json
-{ "sourceKey": "..." }
+{
+  "sourceType": "magnet",         # or "torrent" (base64-encoded bytes)
+  "source": "magnet:?xt=urn:btih:…"
+}
 ```
 
-Supported `sourceType` values:
-
-- `magnet`: magnet URI string.
-- `torrent`: base64-encoded raw `.torrent` file bytes.
+Response: `{ "sourceKey": "…" }`
 
-### 2) Build playback plan
+### Build playback plan
 
 ```bash
-curl -X POST http://127.0.0.1:9090/api/playback-plan \
-  -H "Content-Type: application/json" \
-  -d '{
-    "sourceKey": "<sourceKey>",
-    "fileIndex": 0,
-    "userAgent": "Mozilla/5.0"
-  }'
+POST /api/playback-plan
+Content-Type: application/json
+
+{
+  "sourceKey": "<sourceKey>",
+  "fileIndex": 0,
+  "userAgent": "Mozilla/5.0 …"
+}
 ```
 
-Typical response:
+Response:
 
 ```json
 {
   "mode": "direct",
-  "directUrl": "http://127.0.0.1:9090/stream?sourceKey=...&fileIndex=0",
+  "directUrl": "http://127.0.0.1:9090/stream?sourceKey=…&fileIndex=0",
   "reason": "audio-codec-supported",
   "audioCodec": "aac",
   "videoCodec": "h264"
 }
 ```
 
-`mode` can be:
-
-- `direct`: play `directUrl` directly.
-- `hls`: create an HLS session, then use playlist URL.
+`mode` is `"direct"` or `"hls"`.
 
-### 3) Direct stream endpoint
+### Direct stream
 
 ```bash
-curl -v "http://127.0.0.1:9090/stream?sourceKey=<sourceKey>&fileIndex=0"
+GET /stream?sourceKey=<key>&fileIndex=0
 ```
 
-Or without pre-registering source:
+Supports HTTP Range requests.
+
+### Create HLS transcode session
 
 ```bash
-curl -v "http://127.0.0.1:9090/stream?sourceType=magnet&source=magnet:?xt=...&fileIndex=0"
+POST /api/transcode-sessions
+Content-Type: application/json
+
+{
+  "sourceKey": "<key>",
+  "fileIndex": 0,
+  "transcodeVideo": false,
+  "consumerId": "uuid",
+  "fileName": "Episode01.mkv"
+}
 ```
 
-The endpoint supports HTTP Range requests.
+Response: `{ "sessionId": "…", "playlistPath": "/transcode/<id>/index.m3u8" }`
 
-### 4) Create HLS transcode session (optional)
+### Poll transcode progress
 
 ```bash
-curl -X POST http://127.0.0.1:9090/api/transcode-sessions \
-  -H "Content-Type: application/json" \
-  -d '{
-    "sourceKey": "<sourceKey>",
-    "fileIndex": 0,
-    "transcodeVideo": false,
-    "consumerId": "browser-session-uuid",
-    "fileName": "Episode01.mkv"
-  }'
+GET /api/transcode-sessions/:sessionId/progress
 ```
 
-Set `"transcodeVideo": true` to force video transcoding (for browser decode fallback cases).
+Returns: `percent`, `processedSeconds`, `totalSeconds`, `remainingSeconds`, `speed`, `warmupPercent`, `warmupRemainingSeconds`.
 
-Response:
+### Release consumer
 
-```json
-{
-  "sessionId": "...",
-  "playlistPath": "/transcode/<sessionId>/index.m3u8"
-}
+```bash
+POST /api/transcode-sessions/:sessionId/release
+Content-Type: application/json
+
+{ "consumerId": "uuid", "reason": "pagehide" }
 ```
 
-Open playlist as:
+When the last consumer is released, the transcode session stops and temp files are cleaned up.
 
-`http://127.0.0.1:9090/transcode/<sessionId>/index.m3u8`
+## Requirements
 
-### 5) Poll transcode progress
+- Node.js 18+ (ESM, built-in `fetch`).
+- ffmpeg is required only when transcoding is enabled (bundled via `ffmpeg-static` by default).
+
+## Run
 
 ```bash
-curl "http://127.0.0.1:9090/api/transcode-sessions/<sessionId>/progress"
+npm install
+npm start -- --server-url http://localhost:3000
 ```
 
-Response includes transcode and warmup metrics:
-- `percent`, `processedSeconds`, `totalSeconds`, `remainingSeconds`, `speed`
-- `warmupPercent`, `warmupRemainingSeconds`
+### CLI Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `--server-url` | — | **(Required)** Base URL of the registry server |
+| `--host` | `127.0.0.1` | Bind host |
+| `--port` | `9090` | Preferred local port (auto-increments if taken) |
+| `--public-base-url` | — | Externally reachable base URL advertised to registry |
+| `--id` | auto | Stable proxy client ID |
+| `--name` | hostname | Display name in registry |
+| `--token` | — | Auth token for register/heartbeat |
+| `--ffmpeg-bin` | bundled | Path to custom ffmpeg binary |
+| `--no-transcode-audio` | — | Disable HLS audio transcoding |
+| `--help` | — | Print all options and exit |
 
-### 6) Release transcode consumer
+## Docker
 
 ```bash
-curl -X POST http://127.0.0.1:9090/api/transcode-sessions/<sessionId>/release \
-  -H "Content-Type: application/json" \
-  -d '{
-    "consumerId": "browser-session-uuid",
-    "reason": "pagehide"
-  }'
+docker build -t torrent-tv-proxy .
+docker run torrent-tv-proxy --server-url http://my-server:8080
 ```
 
-When the last consumer is released, proxy disposes the session and stops ffmpeg.
-
-## End-to-end flow
-
-1. Start proxy client with `--server-url`.
-2. Register torrent source via `/api/sources` and get `sourceKey`.
-3. Request `/api/playback-plan`.
-4. If plan is `direct`, use `directUrl`.
-5. If plan is `hls`, create session and play generated playlist.
-6. Poll `/progress` for UI updates, then release session on client stop/close.
-
-## Transcode Session Lifecycle
+## Full End-to-End Flow
 
 ```mermaid
 sequenceDiagram
-  participant C as Client
+  participant B as Browser
+  participant S as Registry Server
   participant P as Proxy
-  participant F as FFmpeg
-
-  C->>P: POST /api/transcode-sessions (consumerId, mode, fileName)
-  P->>F: start/reuse transcode session
-  C->>P: GET /transcode/:sessionId/index.m3u8
-  C->>P: GET /api/transcode-sessions/:sessionId/progress
-  C->>P: POST /api/transcode-sessions/:sessionId/release (reason)
-  P->>P: remove consumer
-  alt no consumers left
-    P->>F: stop process and cleanup
-  end
+
+  Note over P,S: Startup
+  P->>S: POST /api/proxy-clients/register
+  P->>S: WebSocket /ws/proxy-tunnel (persistent)
+
+  Note over B,P: Playback start
+  B->>S: GET /api/proxy-clients/health
+  S->>P: health-request via tunnel
+  P-->>S: health-response (cpu, mem, activeSessions)
+  S-->>B: scored proxy list
+
+  Note over B,P: WebRTC setup
+  B->>S: WebSocket /ws/browser-signal
+  B->>B: RTCPeerConnection + DataChannel + createOffer
+  B->>S: { type:"offer", proxyId, sdp }
+  S->>P: forward via tunnel
+  P->>P: createAnswer
+  P->>S: { type:"answer", sdp }
+  S->>B: forward
+  Note over B,P: ICE candidates exchanged same way
+  Note over B,P: Data channel opens (P2P, STUN-assisted)
+
+  Note over B,P: Streaming
+  B->>P: request via data channel: POST /api/sources
+  P-->>B: response-chunk: { sourceKey }
+  B->>P: request via data channel: POST /api/playback-plan
+  P-->>B: response-chunk: { mode, audioCodec, videoCodec, … }
+  B->>P: request via data channel: POST /api/transcode-sessions
+  P-->>B: response-chunk: { sessionId, playlistPath }
+  B->>P: HLS.js fetches: GET /transcode/:id/index.m3u8
+  B->>P: HLS.js fetches: GET /transcode/:id/seg000.ts …
+  Note over B,P: All via data channel — no server relay
 ```
 
 ## Notes
 
-- HLS session files are stored in OS temp directory and cleaned up automatically.
-- Transcode sessions are cached by `sourceKey:fileIndex:mode`.
-- ffmpeg is bundled via `ffmpeg-static` for out-of-the-box availability.
-- Source registry is in-memory and bounded (old entries are evicted).
+- HLS session temp files are in the OS temp directory and cleaned up automatically.
+- Transcode sessions are cached by `sourceKey:fileIndex:mode` and shared across consumers.
+- The source registry is in-memory and bounded (old entries evicted).
+- The proxy reconnects to the server automatically on tunnel disconnect.
 
 ## License
 
-This project is distributed under GPL-3.0-or-later (see `LICENSE`).
-
-Third-party dependencies keep their own licenses. In particular, bundled ffmpeg binaries
-provided by `ffmpeg-static` are GPL-compatible.
-
+GPL-3.0-or-later (see `LICENSE`). Third-party dependencies keep their own licenses.
+Bundled ffmpeg binaries (`ffmpeg-static`) are GPL-compatible.

package/bin/cli.js

@@ -2,9 +2,10 @@
 /**
  * @file CLI entry point for the torrent-tv proxy.
  *
- * Parses command-line arguments, starts the local HTTP server, registers
- * this proxy with the registry server, establishes the WebSocket tunnel,
- * and maintains a periodic heartbeat.
+ * Parses command-line arguments, starts the local HTTP server, opens a
+ * persistent WebSocket tunnel to the registry server, and registers this
+ * proxy. Liveness is tracked via the tunnel connection — the proxy re-registers
+ * automatically on reconnect so the server's in-memory store stays consistent.
  */
 
 import { Command } from "commander";
@@ -12,8 +13,11 @@ import crypto from "node:crypto";
 import { spawnSync } from "node:child_process";
 import ffmpegStatic from "ffmpeg-static";
 import { startProxyServer } from "../server.js";
-import { registerClient, sendHeartbeat } from "../services/registry-api.js";
+import { registerClient } from "../services/registry-api.js";
 import { createTunnelClient } from "../services/tunnel-client.js";
+import { createWebRtcManager } from "../services/webrtc-manager.js";
+import { createDataChannelHandler } from "../services/data-channel-handler.js";
+import { collectHealthMetrics } from "../services/health-collector.js";
 import { logger } from "../utils/logger.js";
 
 const program = new Command();
@@ -96,9 +100,6 @@ function assertFfmpegAvailability() {
 /** @type {boolean} */
 let registrationInProgress = false;
 
-/** @type {ReturnType<typeof setInterval> | null} */
-let heartbeatTimer = null;
-
 /** @type {import("fastify").FastifyInstance | null} */
 let app = null;
 
@@ -108,9 +109,10 @@ let actualPort = localPort;
 /** @type {boolean} */
 let shutdownInProgress = false;
 
-/** @type {ReturnType<typeof import("../services/tunnel-client.js").createTunnelClient> | null} */
+/** @type {ReturnType<typeof createTunnelClient> | null} */
 let tunnelClient = null;
 
+
 /**
  * Register this proxy with the registry server.
  * Silently skips if a registration is already in flight.
@@ -130,7 +132,7 @@ async function registerClientSafe() {
       baseUrl: explicitBaseUrl || `http://${bindHost}:${actualPort}`,
       token
     });
-    logger.success(`Registered: ${JSON.stringify(result.client)}`);
+    logger.success(`Registered as "${result.client?.name}" (${result.client?.id?.slice(0, 8)})`);
   } finally {
     registrationInProgress = false;
   }
@@ -172,10 +174,6 @@ async function shutdown(signal) {
     return;
   }
   shutdownInProgress = true;
-  if (heartbeatTimer) {
-    clearInterval(heartbeatTimer);
-    heartbeatTimer = null;
-  }
   if (tunnelClient) {
     tunnelClient.disconnect();
     tunnelClient = null;
@@ -213,33 +211,56 @@ try {
     logger.info(`Optional HLS audio transcode is enabled (ffmpeg: ${ffmpegBin}).`);
   }
 
-  await registerWithRetry();
+  // Create tunnel + WebRTC manager.
+  // The tunnel forwards WebRTC signals between browser (via server) and this proxy.
+  // The WebRTC manager handles the actual peer connection and data channel.
+  //
+  // We use a late-binding ref so both objects can reference each other without
+  // running into the TDZ (tunnelClient is declared above; webRtcManager uses let
+  // so the closure in createTunnelClient can call it after both are initialised).
+  /** @type {ReturnType<typeof createWebRtcManager> | null} */
+  let webRtcManager = null;
 
   tunnelClient = createTunnelClient({
     serverUrl,
     proxyId: clientId,
     token,
     proxyPort: actualPort,
-    onLog: (msg) => logger.info(msg)
+    onSignal(sessionId, signal) {
+      webRtcManager?.handleSignal(sessionId, signal);
+    },
+    onHealthRequest() {
+      return collectHealthMetrics();
+    },
+    onConnect() {
+      // Re-register on every tunnel connect/reconnect so the server's
+      // in-memory store stays consistent after server restarts.
+      void registerClientSafe().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`Re-registration after tunnel connect failed: ${message}`);
+      });
+    },
+    onLog: (message) => logger.info(message)
+  });
+
+  const dataChannelHandler = createDataChannelHandler({
+    proxyPort: actualPort,
+    onLog: (message) => logger.info(message)
+  });
+
+  webRtcManager = createWebRtcManager({
+    sendSignal(sessionId, signal) {
+      tunnelClient?.sendSignal(sessionId, signal);
+    },
+    onDataChannel(sessionId, channel) {
+      dataChannelHandler.handleChannel(sessionId, channel);
+    },
+    onLog: (message) => logger.info(message)
   });
+
   tunnelClient.connect();
 
-  heartbeatTimer = setInterval(async () => {
-    const status = await sendHeartbeat({
-      serverUrl,
-      id: clientId,
-      token
-    });
-    if (status === 404) {
-      logger.warn("Heartbeat returned 404, re-registering...");
-      try {
-        await registerClientSafe();
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error(`Re-register failed: ${message}`);
-      }
-    }
-  }, 20_000);
+  await registerWithRetry();
 } catch (error) {
   const message = error instanceof Error ? error.message : String(error);
   logger.error(message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.2.0",
+  "version": "2.5.0",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {
@@ -26,6 +26,8 @@
     "fastify": "^5.8.5",
     "ffmpeg-static": "^5.3.0",
     "get-port": "^7.1.0",
-    "webtorrent": "^2.8.4"
+    "node-datachannel": "^0.14.1",
+    "webtorrent": "^2.8.4",
+    "ws": "^8.18.2"
   }
 }

package/server.js

@@ -77,6 +77,12 @@ export async function startProxyServer({ host, port, transcodeAudio, ffmpegBin }
     allowedHeaders: ["Content-Type", "Range"]
   });
 
+  // Allow browser requests from an HTTPS page to this private-network proxy
+  // without triggering Chromium's Private Network Access permission prompt.
+  app.addHook("onRequest", async (_req, reply) => {
+    reply.header("Access-Control-Allow-Private-Network", "true");
+  });
+
   const sourceRegistry = createSourceRegistry(200);
   const torrentPool = new TorrentPool();
   const selectedPort = await getPort({