@torrent-tv/proxy 2.9.27 → 2.9.30

package/services/language-detect.js

@@ -0,0 +1,73 @@
+/**
+ * @file Content-based subtitle language detection (proxy side).
+ *
+ * Uses `franc` (n-gram / trigram frequency against per-language reference
+ * profiles — MIT). Runs on the proxy where the full subtitle text and
+ * node_modules live, so no detection model ships to the browser. Detection is
+ * restricted to a curated set of plausible subtitle languages via franc's
+ * `only` option: this both maps ISO 639-3 → ISO 639-1 + English name and
+ * avoids exotic false positives on short text (e.g. English mis-detected as
+ * Scots). Returns null when franc is not confident (too little text, or
+ * undetermined).
+ */
+
+import { franc } from "franc";
+
+/** ISO 639-3 (franc output) → { code: ISO 639-1 / BCP-47, name }. Curated allowlist. */
+const LANG_3_TO_1 = {
+  eng: { code: "en", name: "English" },
+  rus: { code: "ru", name: "Russian" },
+  ukr: { code: "uk", name: "Ukrainian" },
+  bel: { code: "be", name: "Belarusian" },
+  jpn: { code: "ja", name: "Japanese" },
+  kor: { code: "ko", name: "Korean" },
+  cmn: { code: "zh", name: "Chinese" },
+  spa: { code: "es", name: "Spanish" },
+  fra: { code: "fr", name: "French" },
+  deu: { code: "de", name: "German" },
+  ita: { code: "it", name: "Italian" },
+  por: { code: "pt", name: "Portuguese" },
+  pol: { code: "pl", name: "Polish" },
+  nld: { code: "nl", name: "Dutch" },
+  arb: { code: "ar", name: "Arabic" },
+  tur: { code: "tr", name: "Turkish" },
+  vie: { code: "vi", name: "Vietnamese" },
+  tha: { code: "th", name: "Thai" },
+  hin: { code: "hi", name: "Hindi" },
+  ind: { code: "id", name: "Indonesian" },
+  zlm: { code: "ms", name: "Malay" },
+  ces: { code: "cs", name: "Czech" },
+  slk: { code: "sk", name: "Slovak" },
+  ron: { code: "ro", name: "Romanian" },
+  hun: { code: "hu", name: "Hungarian" },
+  srp: { code: "sr", name: "Serbian" },
+  hrv: { code: "hr", name: "Croatian" },
+  bul: { code: "bg", name: "Bulgarian" },
+  ell: { code: "el", name: "Greek" },
+  heb: { code: "he", name: "Hebrew" },
+  dan: { code: "da", name: "Danish" },
+  fin: { code: "fi", name: "Finnish" },
+  nob: { code: "no", name: "Norwegian" },
+  swe: { code: "sv", name: "Swedish" },
+  fas: { code: "fa", name: "Persian" }
+};
+
+const ONLY = Object.keys(LANG_3_TO_1);
+
+/**
+ * Best-effort detect the language of subtitle text.
+ *
+ * @param {string} text - Decoded subtitle text (VTT/SRT/ASS — franc ignores markup well enough).
+ * @returns {{ code: string, name: string } | null} Detected language, or null when uncertain.
+ */
+export function detectLanguage(text) {
+  if (typeof text !== "string" || text.trim().length < 15) {
+    return null;
+  }
+  // Restrict to plausible subtitle languages; require a little text.
+  const iso3 = franc(text, { only: ONLY, minLength: 15 });
+  if (iso3 === "und") {
+    return null;
+  }
+  return LANG_3_TO_1[iso3] ?? null;
+}

package/services/subtitle-convert.js

@@ -0,0 +1,150 @@
+/**
+ * @file Subtitle conversion (proxy side).
+ *
+ * Decodes subtitle file bytes (encoding-aware) and converts SubRip (.srt) and
+ * ASS/SSA (.ass/.ssa) to WebVTT so the browser can attach them to a `<track>`
+ * without any client-side conversion. The proxy owns subtitle conversion so it
+ * can also run language detection where the full text is available.
+ */
+
+/**
+ * Decode subtitle bytes to text. Prefers UTF-8 (honouring a BOM); if the UTF-8
+ * decode yields many replacement characters the bytes are re-decoded as
+ * Windows-1251 (very common for Russian .srt files) — otherwise both display
+ * and language detection would see mojibake.
+ *
+ * @param {Buffer | Uint8Array} bytes
+ * @returns {string}
+ */
+export function decodeSubtitleBytes(bytes) {
+  const buf = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  // UTF-8 BOM → definitely UTF-8.
+  if (buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) {
+    return new TextDecoder("utf-8").decode(buf);
+  }
+  const utf8 = new TextDecoder("utf-8").decode(buf);
+  const replacements = (utf8.match(/�/g) || []).length;
+  // >0.5% replacement chars ⇒ not valid UTF-8; try the common legacy Cyrillic
+  // codepage. TextDecoder supports windows-1251 with a full-ICU Node build.
+  if (replacements > Math.max(2, utf8.length * 0.005)) {
+    try {
+      return new TextDecoder("windows-1251").decode(buf);
+    } catch {
+      // Decoder unavailable — fall back to the UTF-8 attempt.
+    }
+  }
+  return utf8;
+}
+
+/** Strip a leading UTF-8 BOM so it never leaks into the WEBVTT signature or first cue. */
+function stripBom(text) {
+  return typeof text === "string" && text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+
+function srtTsToVtt(ts) {
+  return ts.replace(",", ".");
+}
+
+/**
+ * Convert SubRip (.srt) text to WebVTT.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function srtToVtt(text) {
+  const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const out = ["WEBVTT", ""];
+  for (const line of lines) {
+    const m = line.match(/^(\d{2}:\d{2}:\d{2},\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2},\d{3})(.*)?$/);
+    out.push(m ? `${srtTsToVtt(m[1])} --> ${srtTsToVtt(m[2])}${m[3] ?? ""}` : line);
+  }
+  return out.join("\n");
+}
+
+function assTsToVtt(ts) {
+  const m = ts.match(/^(\d+):(\d{2}):(\d{2})\.(\d{2})$/);
+  if (!m) {
+    return "00:00:00.000";
+  }
+  const ms = (parseInt(m[4], 10) * 10).toString().padStart(3, "0");
+  return `${m[1].padStart(2, "0")}:${m[2]}:${m[3]}.${ms}`;
+}
+
+function stripAssTags(text) {
+  return text
+    .replace(/\{[^}]*\}/g, "")
+    .replace(/\\N/g, "\n")
+    .replace(/\\n/g, "\n")
+    .replace(/\\h/g, " ")
+    .trim();
+}
+
+/**
+ * Convert ASS/SSA text to WebVTT (only the [Events] section; styling dropped).
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function assToVtt(text) {
+  const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  let inEvents = false;
+  let formatCols = null;
+  const cues = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "[Events]") {
+      inEvents = true;
+      continue;
+    }
+    if (trimmed.startsWith("[") && trimmed.endsWith("]") && inEvents) {
+      inEvents = false;
+      continue;
+    }
+    if (!inEvents) {
+      continue;
+    }
+    if (trimmed.startsWith("Format:")) {
+      formatCols = trimmed.slice("Format:".length).split(",").map((c) => c.trim().toLowerCase());
+      continue;
+    }
+    if (trimmed.startsWith("Dialogue:") && formatCols) {
+      const parts = trimmed.slice("Dialogue:".length).split(",");
+      const startIdx = formatCols.indexOf("start");
+      const endIdx = formatCols.indexOf("end");
+      const textIdx = formatCols.indexOf("text");
+      if (startIdx < 0 || endIdx < 0 || textIdx < 0) {
+        continue;
+      }
+      const cueText = stripAssTags(parts.slice(textIdx).join(","));
+      if (!cueText) {
+        continue;
+      }
+      cues.push(`${assTsToVtt((parts[startIdx] ?? "").trim())} --> ${assTsToVtt((parts[endIdx] ?? "").trim())}\n${cueText}`);
+    }
+  }
+  return cues.length === 0 ? "WEBVTT\n" : `WEBVTT\n\n${cues.join("\n\n")}`;
+}
+
+/**
+ * Convert subtitle text to WebVTT by file extension. Returns null for formats
+ * that cannot be converted in-place (image-based .sup, ambiguous .sub, .ttml).
+ *
+ * @param {string} text
+ * @param {string} ext - Lowercase extension including the dot, e.g. ".srt".
+ * @returns {string | null}
+ */
+export function convertSubtitleToVtt(text, ext) {
+  const clean = stripBom(text);
+  switch (ext) {
+    case ".vtt":
+    case ".webvtt":
+      return clean.trimStart().startsWith("WEBVTT") ? clean : `WEBVTT\n\n${clean}`;
+    case ".srt":
+      return srtToVtt(clean);
+    case ".ass":
+    case ".ssa":
+      return assToVtt(clean);
+    default:
+      return null;
+  }
+}

package/services/torrent-pool.js

@@ -9,7 +9,7 @@
 import crypto from "node:crypto";
 import os from "node:os";
 import path from "node:path";
-import { rmSync } from "node:fs";
+import { rmSync, statfsSync } from "node:fs";
 import WebTorrent from "webtorrent";
 import { logger } from "../utils/logger.js";
 
@@ -34,6 +34,37 @@ const PRIORITY_WINDOW_BYTES = 8 * 1024 * 1024;
 const HEADER_HEAD_BYTES = 256 * 1024;
 const HEADER_TAIL_BYTES = 2 * 1024 * 1024;
 
+// Global disk cap. Downloaded torrent data is removed on idle TTL and at
+// shutdown, but under pressure (several large files within the TTL window)
+// it can still fill a small HA host's disk (SD/eMMC), which can take down
+// Home Assistant itself. When the total exceeds the cap, whole torrents with
+// no active reader are evicted least-recently-used first. Active torrents are
+// never evicted (we cannot delete what is playing).
+const DISK_CAP_ABSOLUTE_MAX_BYTES = 10 * 1024 * 1024 * 1024; // 10 GB
+const DISK_CAP_SWEEP_INTERVAL_MS = 30_000;
+
+/**
+ * Compute the default disk cap: the smaller of a fixed 10 GB and half of the
+ * currently free space on the store's filesystem (so a tiny host is never
+ * asked to hold more than it can). Best-effort; falls back to the fixed max
+ * when the filesystem cannot be stat'd.
+ *
+ * @param {string} storePath
+ * @returns {number}
+ */
+function computeDefaultDiskCap(storePath) {
+  try {
+    const stat = statfsSync(storePath);
+    const freeBytes = stat.bavail * stat.bsize;
+    if (Number.isFinite(freeBytes) && freeBytes > 0) {
+      return Math.min(DISK_CAP_ABSOLUTE_MAX_BYTES, Math.floor(freeBytes / 2));
+    }
+  } catch {
+    // statfs unavailable (old Node / odd FS) — fall back to the fixed max.
+  }
+  return DISK_CAP_ABSOLUTE_MAX_BYTES;
+}
+
 /**
  * Decode a raw torrent source value into the format expected by WebTorrent.
  *
@@ -77,7 +108,27 @@ export class TorrentPool {
    */
   #idleTimers = new Map();
 
-  constructor() {
+  /**
+   * Last time each torrent was acquired or fetched, for LRU eviction under
+   * the disk cap.
+   *
+   * @type {Map<import("webtorrent").Torrent, number>}
+   */
+  #lastAccess = new Map();
+
+  /** Global disk cap in bytes (0 = disabled). */
+  #maxDiskBytes = 0;
+
+  /** Periodic disk-cap enforcement timer. */
+  #diskSweepTimer = null;
+
+  /**
+   * @param {{ maxDiskBytes?: number }} [options]
+   *   `maxDiskBytes` caps total downloaded torrent data; when omitted a
+   *   default is computed from free disk (min(10 GB, half free)). Pass 0 to
+   *   disable the cap.
+   */
+  constructor({ maxDiskBytes } = {}) {
     // Sweep orphaned torrent data left by a previous hard kill (no graceful
     // shutdown ran, so destroyAll never cleaned the store). Safe here: no
     // torrents are loaded yet at construction. Best-effort, synchronous so it
@@ -114,6 +165,71 @@ export class TorrentPool {
       const message = warning instanceof Error ? warning.message : String(warning);
       logger.warn(`torrent-pool: client warning: ${message}`);
     });
+
+    this.#maxDiskBytes = Number.isFinite(maxDiskBytes) && maxDiskBytes >= 0
+      ? maxDiskBytes
+      : computeDefaultDiskCap(os.tmpdir());
+    if (this.#maxDiskBytes > 0) {
+      const gb = (this.#maxDiskBytes / (1024 * 1024 * 1024)).toFixed(1);
+      logger.info(`torrent-pool: disk cap ${gb} GB (LRU eviction of idle torrents above it)`);
+      this.#diskSweepTimer = setInterval(() => this.#enforceDiskCap(), DISK_CAP_SWEEP_INTERVAL_MS);
+      this.#diskSweepTimer.unref?.();
+    }
+  }
+
+  /**
+   * Sum of downloaded bytes across pooled torrents — a cheap proxy for the
+   * on-disk footprint (the FS store writes downloaded pieces).
+   *
+   * @returns {number}
+   */
+  #currentDiskBytes() {
+    let total = 0;
+    for (const torrent of this.torrents.values()) {
+      const downloaded = typeof torrent?.downloaded === "number" ? torrent.downloaded : 0;
+      total += Math.max(0, downloaded);
+    }
+    return total;
+  }
+
+  /**
+   * Evict whole torrents, least-recently-used first, while the total on-disk
+   * footprint exceeds the cap. Only torrents with NO active file reader are
+   * evictable — a playing torrent cannot be deleted. Best-effort.
+   *
+   * @returns {void}
+   */
+  #enforceDiskCap() {
+    if (this.#maxDiskBytes <= 0) {
+      return;
+    }
+    let used = this.#currentDiskBytes();
+    if (used <= this.#maxDiskBytes) {
+      return;
+    }
+    // Candidates: pooled torrents with zero active readers, LRU first.
+    const candidates = [...this.torrents.values()]
+      .filter((t) => {
+        const usage = this.fileUsageByTorrent.get(t);
+        return !usage || usage.size === 0;
+      })
+      .sort((a, b) => (this.#lastAccess.get(a) ?? 0) - (this.#lastAccess.get(b) ?? 0));
+
+    for (const torrent of candidates) {
+      if (used <= this.#maxDiskBytes) {
+        break;
+      }
+      const freed = typeof torrent?.downloaded === "number" ? Math.max(0, torrent.downloaded) : 0;
+      const name = typeof torrent?.name === "string" ? torrent.name : "(unknown)";
+      const gb = (this.#maxDiskBytes / (1024 * 1024 * 1024)).toFixed(1);
+      logger.info(
+        `torrent-pool: disk cap ${gb} GB exceeded — evicting idle torrent "${name}" ` +
+          `(~${(freed / (1024 * 1024)).toFixed(0)} MB)`
+      );
+      this.#cancelIdleRemoval(torrent);
+      this.#removeTorrent(torrent);
+      used -= freed;
+    }
   }
 
   /**
@@ -173,6 +289,7 @@ export class TorrentPool {
     // Already resolved — return immediately.
     const existing = this.torrents.get(key);
     if (existing) {
+      this.#lastAccess.set(existing, Date.now());
       return existing;
     }
 
@@ -197,6 +314,7 @@ export class TorrentPool {
           if (existing) {
             const settle = () => {
               this.torrents.set(key, existing);
+              this.#lastAccess.set(existing, Date.now());
               this.#pending.delete(key);
               resolve(existing);
             };
@@ -215,6 +333,7 @@ export class TorrentPool {
       this.client.add(torrentId, (readyTorrent) => {
         this.client.off("error", onError);
         this.torrents.set(key, readyTorrent);
+        this.#lastAccess.set(readyTorrent, Date.now());
         this.#pending.delete(key);
         // Key layout is `${sourceType}:${sha1}`; log with the sha1 prefix so
         // lines correlate with the [stats] source key.
@@ -274,8 +393,10 @@ export class TorrentPool {
       usage = new Map();
       this.fileUsageByTorrent.set(torrent, usage);
     }
-    // The torrent is in use again — cancel any pending idle removal.
+    // The torrent is in use again — cancel any pending idle removal and mark
+    // it recently accessed so LRU eviction keeps it.
     this.#cancelIdleRemoval(torrent);
+    this.#lastAccess.set(torrent, Date.now());
     usage.set(fileIndex, (usage.get(fileIndex) ?? 0) + 1);
     this.#syncSelections(torrent, usage);
 
@@ -360,6 +481,7 @@ export class TorrentPool {
       }
     }
     this.fileUsageByTorrent.delete(torrent);
+    this.#lastAccess.delete(torrent);
     const name = typeof torrent.name === "string" ? torrent.name : "(unknown)";
     try {
       torrent.destroy({ destroyStore: true }, () => {
@@ -617,11 +739,17 @@ export class TorrentPool {
    * @returns {Promise<void>}
    */
   async destroyAll() {
+    // Stop periodic disk-cap enforcement.
+    if (this.#diskSweepTimer) {
+      clearInterval(this.#diskSweepTimer);
+      this.#diskSweepTimer = null;
+    }
     // Cancel any pending idle-removal timers — destroyAll handles teardown.
     for (const timer of this.#idleTimers.values()) {
       clearTimeout(timer);
     }
     this.#idleTimers.clear();
+    this.#lastAccess.clear();
 
     if (!this.client || this.client.destroyed) {
       return;