Upload 25 files

Dockerfile

@@ -0,0 +1,51 @@
+ARG NODE_VERSION=20.11.1
+ARG PNPM_VERSION=8.15.4
+ARG TS_VERSION=5.3.3
+
+# Builder stage
+FROM node:${NODE_VERSION} as build
+
+WORKDIR /usr/src/app
+
+RUN npm install -g typescript@${TS_VERSION}
+RUN --mount=type=cache,target=/root/.npm \
+    npm install -g pnpm@${PNPM_VERSION}
+RUN --mount=type=bind,source=package.json,target=package.json \
+    --mount=type=bind,source=pnpm-lock.yaml,target=pnpm-lock.yaml \
+    --mount=type=bind,source=patches,target=patches \
+    --mount=type=cache,target=/root/.local/share/pnpm/store \
+    pnpm install --frozen-lockfile
+
+COPY . .
+
+RUN pnpm run build
+RUN pnpm prune --prod
+
+# Runner stage
+FROM node:${NODE_VERSION}-slim as final
+
+COPY package.json .
+COPY --from=build /usr/src/app/node_modules ./node_modules
+COPY --from=build /usr/src/app/dist ./dist
+
+ENV NODE_ENV production
+ENV HTTPS_METHOD local-ip.medicmobile.org
+ENV DOWNLOAD_DIR /data
+ENV KEEP_DOWNLOADED_FILES false
+ENV MAX_CONNS_PER_TORRENT 50
+ENV DOWNLOAD_SPEED_LIMIT 20971520
+ENV UPLOAD_SPEED_LIMIT 1048576
+ENV SEED_TIME 60000
+ENV TORRENT_TIMEOUT 5000
+
+VOLUME /data
+
+RUN mkdir -p /data
+RUN chown -R node /data
+
+USER node
+
+EXPOSE 58827
+EXPOSE 58828
+
+CMD npm start

package.json

@@ -0,0 +1,48 @@
+{
+  "name": "stremio-torrent-stream",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node --no-warnings dist/index.js",
+    "dev": "esrun --node-no-warnings --watch src/index.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/bytes": "^3.1.4",
+    "@types/express": "^4.17.21",
+    "@types/fs-extra": "^11.0.4",
+    "@types/localtunnel": "^2.0.4",
+    "@types/node": "^20.11.20",
+    "@types/stremio-addon-sdk": "^1.6.11",
+    "@types/tough-cookie": "^4.0.5",
+    "@types/webtorrent": "~0.109.8",
+    "esrun": "^3.2.26"
+  },
+  "dependencies": {
+    "axios": "^1.6.5",
+    "axios-cookiejar-support": "^4.0.7",
+    "cheerio": "1.0.0-rc.12",
+    "dotenv": "^16.4.5",
+    "express": "^4.19.2",
+    "eztv-crawler": "^1.3.6",
+    "fs-extra": "^11.2.0",
+    "localtunnel": "^2.0.2",
+    "memory-chunk-store": "^1.3.5",
+    "mime": "^4.0.1",
+    "stremio-addon-sdk": "^1.6.10",
+    "tough-cookie": "^4.1.3",
+    "ts-jackett-api": "^1.0.0",
+    "webtorrent": "^2.4.2",
+    "yts-api-node": "^1.1.3"
+  },
+  "pnpm": {
+    "patchedDependencies": {
+      "[email protected]": "patches/[email protected]"
+    }
+  }
+}

patches/[email protected]

@@ -0,0 +1,57 @@
+diff --git a/src/builder.js b/src/builder.js
+index 55f32d13d7f610aac4609a7e62dffc916794fb90..f74567b316cdd8a7e212d5231db86e97e64e1314 100644
+--- a/src/builder.js
++++ b/src/builder.js
+@@ -79,7 +79,7 @@ function AddonBuilder(manifest) {
+ 
+ function AddonInterface(manifest, handlers) {
+ 	this.manifest = Object.freeze(Object.assign({}, manifest))
+-	this.get = (resource, type, id, extra = {}, config = {}) => {
++	this.get = (resource, type, id, extra = {}, config = {}, req) => {
+ 		const handler = handlers[resource]
+ 		if (!handler) {
+ 			return Promise.reject({
+@@ -87,7 +87,7 @@ function AddonInterface(manifest, handlers) {
+ 				noHandler: true
+ 			})
+ 		}
+-		return handler({ type, id, extra, config })
++		return handler({ type, id, extra, config, req })
+ 	}
+ 	return this
+ }
+diff --git a/src/getRouter.js b/src/getRouter.js
+index 4c6269d65c851203811dab877cd8543238653378..c18f2f1c5f32703aa3ae22ea4388174b2c485337 100644
+--- a/src/getRouter.js
++++ b/src/getRouter.js
+@@ -61,7 +61,7 @@ function getRouter({ manifest , get }) {
+ 			}
+ 		}
+ 		res.setHeader('Content-Type', 'application/json; charset=utf-8')
+-		get(resource, type, id, extra, config)
++		get(resource, type, id, extra, config, req)
+ 			.then(resp => {
+ 
+ 				let cacheHeaders = {
+diff --git a/src/serveHTTP.js b/src/serveHTTP.js
+index db94ae3ef5874162bf4573ffa6372901c636a483..9a99fe597ebf50b2167bee11772af52952bce6bd 100644
+--- a/src/serveHTTP.js
++++ b/src/serveHTTP.js
+@@ -53,7 +53,7 @@ function serveHTTP(addonInterface, opts = {}) {
+ 	return new Promise(function(resolve, reject) {
+ 		server.on('listening', function() {
+ 			const url = `http://127.0.0.1:${server.address().port}/manifest.json`
+-			console.log('HTTP addon accessible at:', url)
++			console.log(`HTTP addon listening on port ${server.address().port}`)
+ 			if (process.argv.includes('--launch')) {
+ 				const base = 'https://staging.strem.io#'
+ 				//const base = 'https://app.strem.io/shell-v4.4#'
+@@ -63,7 +63,7 @@ function serveHTTP(addonInterface, opts = {}) {
+ 			if (process.argv.includes('--install')) {
+ 				opn(url.replace('http://', 'stremio://'))
+ 			}
+-			resolve({ url, server })
++			resolve({ url, server, app })
+ 		})
+ 		server.on('error', reject)
+ 	})

src/addon/manifest.ts

@@ -0,0 +1,116 @@
+import { Manifest } from "stremio-addon-sdk";
+
+export const manifest: Manifest = {
+  id: "community.torrent-stream",
+  version: "1.0.0",
+  catalogs: [],
+  resources: ["stream"],
+  types: ["movie", "series"],
+  name: "Torrent Stream",
+  logo: "https://upload.wikimedia.org/wikipedia/en/7/79/WebTorrent_logo.png",
+  background:
+    "https://i.etsystatic.com/35367581/r/il/53bf97/4463935832/il_fullxfull.4463935832_3k3g.jpg",
+  description:
+    "This addon enables Stremio to stream movies and shows from torrents",
+  idPrefixes: ["tt"],
+  behaviorHints: {
+    // @ts-ignore
+    configurable: true,
+    configurationRequired: true,
+  },
+  config: [
+    {
+      title: "Enable Jackett search",
+      key: "enableJackett",
+      type: "checkbox",
+    },
+    {
+      title: "Jackett API URL",
+      key: "jackettUrl",
+      type: "text",
+    },
+    {
+      title: "Jackett API Key",
+      key: "jackettKey",
+      type: "password",
+    },
+    {
+      title: "Enable nCore search",
+      key: "enableNcore",
+      type: "checkbox",
+      default: "checked",
+    },
+    {
+      title: "nCore username",
+      key: "nCoreUser",
+      type: "text",
+    },
+    {
+      title: "nCore password",
+      key: "nCorePassword",
+      type: "password",
+    },
+    {
+      title: "Enable iNSANE search",
+      key: "enableInsane",
+      type: "checkbox",
+    },
+    {
+      title: "iNSANE username",
+      key: "insaneUser",
+      type: "text",
+    },
+    {
+      title: "iNSANE password",
+      key: "insanePassword",
+      type: "password",
+    },
+    {
+      title: "Enable iTorrent search",
+      key: "enableItorrent",
+      type: "checkbox",
+    },
+    {
+      title: "Enable YTS search",
+      key: "enableYts",
+      type: "checkbox",
+    },
+    {
+      title: "Enable EZTV search",
+      key: "enableEztv",
+      type: "checkbox",
+    },
+    {
+      title: "Use titles for torrent search",
+      key: "searchByTitle",
+      type: "checkbox",
+    },
+    {
+      title: "Do not show HDR results",
+      key: "disableHdr",
+      type: "checkbox",
+    },
+    {
+      title: "Do not show HEVC results",
+      key: "disableHevc",
+      type: "checkbox",
+    },
+    {
+      title: "Do not show 4K results",
+      key: "disable4k",
+      type: "checkbox",
+    },
+    {
+      title: "Do not show CAM results",
+      key: "disableCam",
+      type: "checkbox",
+      default: "checked",
+    },
+    {
+      title: "Do not show 3D results",
+      key: "disable3d",
+      type: "checkbox",
+      default: "checked",
+    },
+  ],
+};

src/addon/server.ts

@@ -0,0 +1,23 @@
+import { Application } from "express";
+import stremio from "stremio-addon-sdk";
+import { streamHandler } from "./streams.js";
+import { manifest } from "./manifest.js";
+import { Server } from "http";
+
+export const serveHTTP = async (port: number) => {
+  const builder = new stremio.addonBuilder(manifest);
+
+  // @ts-ignore
+  builder.defineStreamHandler(streamHandler);
+  const addonInterface = builder.getInterface();
+
+  // @ts-ignore
+  const {
+    url,
+    server,
+    app,
+  }: { url: string; server: Server; app: Application } =
+    await stremio.serveHTTP(addonInterface, { port });
+
+  return app;
+};

src/addon/streams.ts

@@ -0,0 +1,247 @@
+import { Request } from "express";
+import Stremio from "stremio-addon-sdk";
+import {
+  TorrentCategory,
+  TorrentSearchResult,
+  TorrentSource,
+  searchTorrents,
+} from "../torrent/search.js";
+import { getTorrentInfo } from "../torrent/webtorrent.js";
+import { getReadableSize, isSubtitleFile, isVideoFile } from "../utils/file.js";
+import { getTitles } from "../utils/imdb.js";
+import { guessLanguage } from "../utils/language.js";
+import { guessQuality } from "../utils/quality.js";
+import { isFileNameMatch, isTorrentNameMatch } from "../utils/shows.js";
+
+interface HandlerArgs {
+  type: string;
+  id: string;
+  config?: {
+    enableJackett: string;
+    jackettUrl: string;
+    jackettKey: string;
+    enableNcore: string;
+    nCoreUser: string;
+    nCorePassword: string;
+    enableInsane: string;
+    insaneUser: string;
+    insanePassword: string;
+    enableItorrent: string;
+    enableYts: string;
+    enableEztv: string;
+    searchByTitle: string;
+    disableHdr: string;
+    disableHevc: string;
+    disable4k: string;
+    disableCam: string;
+    disable3d: string;
+  };
+  req: Request;
+}
+
+export const streamHandler = async ({ type, id, config, req }: HandlerArgs) => {
+  let torrents: TorrentSearchResult[] = [];
+
+  const categories: TorrentCategory[] = [];
+  if (type === "movie") categories.push("movie");
+  if (type === "series") categories.push("show");
+
+  const sources: TorrentSource[] = [];
+  if (config.enableJackett === "on") sources.push("jackett");
+  if (config.enableNcore === "on") sources.push("ncore");
+  if (config.enableInsane === "on") sources.push("insane");
+  if (config.enableItorrent === "on") sources.push("itorrent");
+  if (config.enableYts === "on") sources.push("yts");
+  if (config.enableEztv === "on") sources.push("eztv");
+
+  const [imdbId, season, episode] = id.split(":");
+
+  const queries = [imdbId];
+  if (config.searchByTitle === "on") queries.push(...(await getTitles(imdbId)));
+
+  torrents = (
+    await Promise.all(
+      queries.map((query) =>
+        searchTorrents(query, {
+          categories,
+          sources,
+          jackett: {
+            url: config.jackettUrl,
+            apiKey: config.jackettKey,
+          },
+          ncore: {
+            user: config.nCoreUser,
+            password: config.nCorePassword,
+          },
+          insane: {
+            user: config.insaneUser,
+            password: config.insanePassword,
+          },
+        })
+      )
+    )
+  ).flat();
+
+  torrents = dedupeTorrents(torrents);
+
+  torrents = torrents.filter((torrent) => {
+    if (!torrent.seeds) return false;
+    if (torrent.category?.includes("DVD")) return false;
+    if (!isAllowedFormat(config, torrent.name)) return false;
+    if (!isAllowedQuality(config, guessQuality(torrent.name).quality))
+      return false;
+
+    if (
+      season &&
+      episode &&
+      !isTorrentNameMatch(torrent.name, Number(season), Number(episode))
+    )
+      return false;
+
+    return true;
+  });
+
+  let streams = (
+    await Promise.all(
+      torrents.map((torrent) =>
+        getStreamsFromTorrent(req, torrent, season, episode)
+      )
+    )
+  ).flat();
+
+  streams = streams.filter((stream) => {
+    if (!isAllowedFormat(config, stream.fileName)) return false;
+    if (!isAllowedQuality(config, stream.quality)) return false;
+    return true;
+  });
+
+  streams.sort((a, b) => b.score - a.score);
+
+  return { streams: streams.map((stream) => stream.stream) };
+};
+
+const dedupeTorrents = (torrents: TorrentSearchResult[]) => {
+  const map = new Map(
+    torrents.map((torrent) => [`${torrent.tracker}:${torrent.name}`, torrent])
+  );
+
+  return [...map.values()];
+};
+
+export const getStreamsFromTorrent = async (
+  req: Request,
+  torrent: TorrentSearchResult,
+  season?: string,
+  episode?: string
+): Promise<
+  {
+    stream: Stremio.Stream;
+    torrentName: string;
+    fileName: string;
+    quality: string;
+    score: number;
+  }[]
+> => {
+  const uri = torrent.torrent || torrent.magnet;
+  if (!uri) return [];
+
+  const torrentInfo = await getTorrentInfo(uri);
+  if (!torrentInfo) return [];
+
+  let videos = torrentInfo.files.filter((file) => isVideoFile(file.name));
+
+  if (season && episode) {
+    videos = videos.filter((file) =>
+      isFileNameMatch(file.name, Number(season), Number(episode))
+    );
+  }
+
+  const videosSize = videos.reduce((acc, file) => acc + file.size, 0);
+
+  videos = videos.filter(
+    (file) => file.size > videosSize / (videos.length + 1)
+  );
+
+  const subs = torrentInfo.files.filter((file) => isSubtitleFile(file.name));
+
+  const torrentQuality = guessQuality(torrent.name);
+  const language = guessLanguage(torrent.name, torrent.category);
+
+  // @ts-ignore
+  return videos.map((file) => {
+    const fileQuality = guessQuality(file.name);
+
+    const { quality, score } =
+      fileQuality.score > torrentQuality.score ? fileQuality : torrentQuality;
+
+    const description = [
+      ...(season && episode ? [torrent.name, file.name] : [torrent.name]),
+      [
+        `💾 ${getReadableSize(file.size)}`,
+        `⬆️ ${torrent.seeds}`,
+        `⬇️ ${torrent.peers}`,
+      ].join(" "),
+      [`🔊 ${language}`, `⚙️ ${torrent.tracker}`].join(" "),
+    ].join("\n");
+
+    const streamEndpoint = `${req.protocol}://${req.get("host")}/stream`;
+
+    const url = [
+      streamEndpoint,
+      encodeURIComponent(uri),
+      encodeURIComponent(file.path),
+    ].join("/");
+
+    const subtitles = subs.map((sub, index) => ({
+      id: index.toString(),
+      url: [
+        streamEndpoint,
+        encodeURIComponent(uri),
+        encodeURIComponent(sub.path),
+      ].join("/"),
+      lang: sub.name,
+    }));
+
+    return {
+      stream: {
+        name: quality,
+        description,
+        url,
+        subtitles,
+        behaviorHints: {
+          bingeGroup: torrent.name,
+        },
+      },
+      torrentName: torrent.name,
+      fileName: file.name,
+      quality,
+      score,
+    };
+  });
+};
+
+const isAllowedQuality = (config: HandlerArgs["config"], quality: string) => {
+  if (config?.disable4k === "on" && quality.includes("4K")) return false;
+
+  if (config?.disableCam === "on" && quality.includes("CAM")) return false;
+
+  if (
+    config?.disableHdr === "on" &&
+    (quality.includes("HDR") || quality.includes("Dolby Vision"))
+  )
+    return false;
+
+  if (config?.disable3d === "on" && quality.includes("3D")) return false;
+
+  return true;
+};
+
+const isAllowedFormat = (config: HandlerArgs["config"], name: string) => {
+  if (config?.disableHevc === "on") {
+    const str = name.replace(/\W/g, "").toLowerCase();
+    if (str.includes("x265") || str.includes("h265") || str.includes("hevc"))
+      return false;
+  }
+
+  return true;
+};

src/index.ts

@@ -0,0 +1,17 @@
+import "./utils/dotenv.js";
+
+import express from "express";
+import { serveHTTP } from "./addon/server.js";
+import { router } from "./router.js";
+import { serveHTTPS } from "./utils/https.js";
+
+const PORT = Number(process.env.PORT) || 58827;
+const HTTPS_PORT = Number(process.env.HTTPS_PORT) || 58828;
+
+const main = async () => {
+  const app = await serveHTTP(PORT);
+  app.use(express.json()).use(router);
+  await serveHTTPS(app, HTTPS_PORT);
+};
+
+main();

src/router.ts

@@ -0,0 +1,112 @@
+import { Router } from "express";
+import { searchTorrents } from "./torrent/search.js";
+import {
+  getFile,
+  getOrAddTorrent,
+  getStats,
+  getTorrentInfo,
+  streamClosed,
+  streamOpened,
+} from "./torrent/webtorrent.js";
+import { getStreamingMimeType } from "./utils/file.js";
+
+export const router = Router();
+
+router.get("/stats", (req, res) => {
+  const stats = getStats();
+  res.json(stats);
+});
+
+router.get("/torrents/:query", async (req, res) => {
+  const { query } = req.params;
+  const torrents = await searchTorrents(query);
+  res.json(torrents);
+});
+
+router.post("/torrents/:query", async (req, res) => {
+  const { query } = req.params;
+  const options = req.body;
+  const torrents = await searchTorrents(query, options);
+  res.json(torrents);
+});
+
+router.get("/torrent/:torrentUri", async (req, res) => {
+  const { torrentUri } = req.params;
+
+  const torrent = await getTorrentInfo(torrentUri);
+  if (!torrent) return res.status(500).send("Failed to get torrent");
+
+  torrent.files.forEach((file) => {
+    file.url = [
+      `${req.protocol}://${req.get("host")}`,
+      "stream",
+      encodeURIComponent(torrentUri),
+      encodeURIComponent(file.path),
+    ].join("/");
+  });
+
+  res.json(torrent);
+});
+
+router.get("/stream/:torrentUri/:filePath", async (req, res) => {
+  const { torrentUri, filePath } = req.params;
+
+  const torrent = await getOrAddTorrent(torrentUri);
+  if (!torrent) return res.status(500).send("Failed to add torrent");
+
+  const file = getFile(torrent, filePath);
+  if (!file) return res.status(404).send("File not found");
+
+  const { range } = req.headers;
+  const positions = (range || "").replace(/bytes=/, "").split("-");
+  const start = Number(positions[0]);
+  const end = Number(positions[1]) || file.length - 1;
+
+  if (start >= file.length || end >= file.length) {
+    res.writeHead(416, {
+      "Content-Range": `bytes */${file.length}`,
+    });
+    return res.end();
+  }
+
+  const headers = {
+    "Content-Range": `bytes ${start}-${end}/${file.length}`,
+    "Accept-Ranges": "bytes",
+    "Content-Length": end - start + 1,
+    "Content-Type": getStreamingMimeType(file.name),
+  };
+
+  res.writeHead(206, headers);
+
+  try {
+    const noDataTimeout = setTimeout(() => {
+      res.status(500).end();
+    }, 10000);
+
+    const noReadTimeout = setTimeout(() => {
+      res.status(200).end();
+    }, 60000);
+
+    const videoStream = file.createReadStream({ start, end });
+
+    videoStream.on("data", () => {
+      clearTimeout(noDataTimeout);
+    });
+
+    videoStream.on("readable", () => {
+      noReadTimeout.refresh();
+    });
+
+    videoStream.on("error", (error) => {});
+
+    videoStream.pipe(res);
+
+    streamOpened(torrent.infoHash, file.name);
+
+    res.on("close", () => {
+      streamClosed(torrent.infoHash, file.name);
+    });
+  } catch (error) {
+    res.status(500).end();
+  }
+});

src/torrent/eztv.ts

@@ -0,0 +1,91 @@
+import axios from "axios";
+import * as cheerio from "cheerio";
+import { getTorrentsByImdbId } from "eztv-crawler";
+import { TorrentSearchResult } from "./search.js";
+import { isImdbId } from "../utils/imdb.js";
+
+export const searchEztv = async (
+  searchQuery: string
+): Promise<TorrentSearchResult[]> => {
+  try {
+    if (isImdbId(searchQuery)) {
+      const res = await getTorrentsByImdbId(searchQuery);
+
+      return res.torrents.map((torrent) => ({
+        name: torrent.title.replace("EZTV", "").trim(),
+        tracker: "EZTV",
+        category: parseCategory(torrent.title),
+        size: Number(torrent.size_bytes),
+        seeds: torrent.seeds,
+        peers: torrent.peers,
+        torrent: torrent.torrent_url,
+        magnet: torrent.magnet_url,
+      }));
+    } else {
+      const formData = new FormData();
+      formData.append("layout", "def_wlinks");
+
+      const eztvPage = await axios.post(
+        `https://eztv.wf/search/${encodeURIComponent(searchQuery)}`,
+        formData
+      );
+      const $ = cheerio.load(eztvPage.data);
+
+      const results = $('[name="hover"]').toArray();
+
+      return results.map((res) => {
+        const title = $(res).find("td:nth-child(2)").text()?.replace(/\n/g, "");
+        const size = $(res).find("td:nth-child(4)").text();
+        const seeds = $(res).find("td:nth-child(6)").text();
+
+        const torrent = $(res)
+          .find("td:nth-child(3) .download_1")
+          .attr("href")
+          ?.replace(/\n/g, "");
+
+        const magnet = $(res)
+          .find("td:nth-child(3) .magnet")
+          .attr("href")
+          ?.replace(/\n/g, "");
+
+        return {
+          name: title.replace("[eztv]", "").trim(),
+          tracker: "EZTV",
+          category: parseCategory(title),
+          size: parseSize(size),
+          seeds: Number(seeds) || 0,
+          peers: 0,
+          torrent,
+          magnet,
+        };
+      });
+    }
+  } catch (error) {
+    return [];
+  }
+};
+
+const parseCategory = (title: string) => {
+  let quality = "SD";
+  if (title.includes("720p")) quality = "720p";
+  if (title.includes("1080p")) quality = "1080p";
+  if (title.includes("2160p")) quality = "2160p";
+  return `TV/${quality}`;
+};
+
+const parseSize = (size: string) => {
+  const units: Record<string, number> = {
+    TB: 1024 ** 4,
+    GB: 1024 ** 3,
+    MB: 1024 ** 2,
+    KB: 1024,
+    B: 1,
+  };
+
+  const [sizeStr, unit] = size.split(" ");
+  const sizeNum = Number(sizeStr);
+
+  if (!sizeNum || !units[unit]) return 0;
+
+  return Math.ceil(sizeNum * units[unit]);
+};

src/torrent/insane.ts

@@ -0,0 +1,154 @@
+import axios from "axios";
+import { wrapper } from "axios-cookiejar-support";
+import * as cheerio from "cheerio";
+import { CookieJar } from "tough-cookie";
+import { TorrentSearchResult } from "./search.js";
+
+const INSANE_USER = process.env.INSANE_USER;
+const INSANE_PASSWORD = process.env.INSANE_PASSWORD;
+
+const USER_AGENT =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0";
+
+export enum InsaneCategory {
+  Film_Hun_SD = 41,
+  Film_Hun_HD = 27,
+  Film_Hun_UHD = 44,
+  Film_Eng_SD = 42,
+  Film_Eng_HD = 25,
+  Film_Eng_UHD = 45,
+  Sorozat_Hun = 8,
+  Sorozat_Hun_HD = 40,
+  Sorozat_Hun_UHD = 47,
+  Sorozat_Eng = 7,
+  Sorozat_Eng_HD = 39,
+  Sorozat_Eng_UHD = 46,
+}
+
+export const searchInsane = async (
+  searchQuery: string,
+  categories: InsaneCategory[],
+  insaneUser?: string,
+  insanePassword?: string
+): Promise<TorrentSearchResult[]> => {
+  try {
+    const user = insaneUser || INSANE_USER;
+    const password = insanePassword || INSANE_PASSWORD;
+
+    if (!user || !password) return [];
+
+    const jar = new CookieJar();
+
+    const client = wrapper(
+      // @ts-ignore
+      axios.create({
+        // @ts-ignore
+        jar,
+        baseURL: "https://newinsane.info",
+        headers: { "User-Agent": USER_AGENT },
+      })
+    );
+
+    const formData = new FormData();
+    formData.append("username", user);
+    formData.append("password", password);
+    await client.post("/login.php", formData);
+
+    const torrents: TorrentSearchResult[] = [];
+
+    let page = 0;
+
+    while (page <= 5) {
+      try {
+        let torrentsOnPage = 0;
+
+        let params = new URLSearchParams({
+          page: page.toString(),
+          search: searchQuery,
+          searchsort: "normal",
+          searchtype: "desc",
+          torart: "tor",
+        });
+
+        for (const category of categories) {
+          params.append("cat[]", category.toString());
+        }
+
+        const link = `/browse.php?${params.toString()}}`;
+        const torrentsPage = await client.get(link);
+        const $ = cheerio.load(torrentsPage.data);
+
+        for (const el of $("tr.torrentrow")) {
+          torrentsOnPage++;
+
+          const tracker = "iNSANE";
+          const name = $(el).find("a.torrentname").attr("title");
+          const category = parseCategory(
+            $(el).find("td.caticon > a > img").attr("title")
+          );
+          const size = parseSize($(el).find("td.size").text());
+          const seeds = Number($(el).find("td.data > a:nth-of-type(1)").text());
+          const peers = Number($(el).find("td.data > a:nth-of-type(2)").text());
+          const torrent = $(el).find("a.downloadicon").attr("href");
+
+          if (!name || !torrent) continue;
+
+          torrents.push({
+            name,
+            tracker,
+            category,
+            size,
+            seeds,
+            peers,
+            torrent,
+          });
+        }
+
+        if (torrentsOnPage < 25) break;
+
+        page++;
+      } catch {
+        continue;
+      }
+    }
+
+    return torrents;
+  } catch (error) {
+    return [];
+  }
+};
+
+const parseCategory = (category: string | undefined) => {
+  const categories: Record<string, string> = {
+    "Film/Hun/SD": "Movies/SD/HU",
+    "Film/Hun/HD": "Movies/HD/HU",
+    "Film/Hun/UHD": "Movies/UHD/HU",
+    "Film/Eng/SD": "Movies/SD/EN",
+    "Film/Eng/HD": "Movies/HD/EN",
+    "Film/Eng/UHD": "Movies/UHD/EN",
+    "Sorozat/Hun": "TV/SD/HU",
+    "Sorozat/Hun/HD": "TV/HD/HU",
+    "Sorozat/Hun/UHD": "TV/UHD/HU",
+    "Sorozat/Eng": "TV/SD/EN",
+    "Sorozat/Eng/HD": "TV/HD/EN",
+    "Sorozat/Eng/UHD": "TV/UHD/EN",
+  };
+
+  return categories[category as string];
+};
+
+const parseSize = (sizeStr: string) => {
+  const size = sizeStr.replace(",", ".").trim();
+  let bytes = 0;
+  if (size.endsWith("TiB"))
+    bytes = (Number(size.replace("TiB", "")) || 0) * 1024 ** 4;
+  else if (size.endsWith("GiB"))
+    bytes = (Number(size.replace("GiB", "")) || 0) * 1024 ** 3;
+  else if (size.endsWith("MiB"))
+    bytes = (Number(size.replace("MiB", "")) || 0) * 1024 ** 2;
+  else if (size.endsWith("KiB"))
+    bytes = (Number(size.replace("KiB", "")) || 0) * 1024;
+  else if (size.endsWith("B")) bytes = Number(size.replace("B", "")) || 0;
+
+  return Math.ceil(bytes);
+};

src/torrent/itorrent.ts

@@ -0,0 +1,130 @@
+import axios from "axios";
+import * as cheerio from "cheerio";
+import { TorrentSearchResult } from "./search.js";
+
+export enum ItorrentCategory {
+  Film = 3,
+  Sorozat = 4,
+}
+
+export enum ItorrentQuality {
+  SD = "sd",
+  HD = "hd",
+  CAM = "cam",
+}
+
+export const searchItorrent = async (
+  searchQuery: string,
+  categories: ItorrentCategory[],
+  qualities: ItorrentQuality[]
+): Promise<TorrentSearchResult[]> => {
+  const torrents: TorrentSearchResult[] = [];
+  const quality = qualities.join(",");
+
+  await Promise.all(
+    categories.map(async (category) => {
+      let page = 0;
+
+      while (page <= 5) {
+        try {
+          page++;
+
+          let torrentsOnPage = 0;
+
+          const link = `https://itorrent.ws/torrentek/category/${category}/title/${searchQuery}/qualities[]/${quality}/page/${page}/`;
+          const torrentsPage = await axios.get(link);
+          const $ = cheerio.load(torrentsPage.data);
+
+          await Promise.all(
+            [...$("tr.gradeX")].map(async (el) => {
+              torrentsOnPage++;
+
+              const tracker = "iTorrent";
+              const torrentAnchor = $(el).find("td.ellipse > a");
+              const torrentHref = torrentAnchor.attr("href");
+              const name = torrentAnchor.text().trim();
+
+              if (!torrentHref || !name) return;
+
+              const category = parseCategory($(el).find("i.zqf").attr("title"));
+              const size = parseSize(
+                $(el).find("td:nth-child(5)").text().trim()
+              );
+              const seeds = Number($(el).find("td:nth-child(7)").text());
+              const peers = Number($(el).find("td:nth-child(8)").text());
+
+              const torrentPageLink = `https://itorrent.ws${torrentHref}`;
+
+              let torrent: string | undefined;
+              let magnet: string | undefined;
+
+              try {
+                const torrentPage = await axios.get(torrentPageLink);
+                const $ = cheerio.load(torrentPage.data);
+
+                const torrentFileHref = $("a.btn-primary.seed-warning").attr(
+                  "href"
+                );
+
+                if (torrentFileHref)
+                  torrent = `https://itorrent.ws${torrentFileHref}`;
+
+                magnet = $("a.btn-success.seed-warning").attr("href");
+
+                if (!torrent && !magnet) return;
+              } catch {
+                return;
+              }
+
+              torrents.push({
+                name,
+                tracker,
+                category,
+                size,
+                seeds,
+                peers,
+                torrent,
+                magnet,
+              });
+            })
+          );
+
+          if (torrentsOnPage < 48) break;
+        } catch {
+          continue;
+        }
+      }
+    })
+  );
+
+  return torrents;
+};
+
+const parseCategory = (category: string | undefined) => {
+  const categories: Record<string, string> = {
+    "Film/HU/CAM": "Movies/CAM/HU",
+    "Film/HU/SD": "Movies/SD/HU",
+    "Film/HU/HD": "Movies/HD/HU",
+    "Sorozat/HU/SD": "TV/SD/HU",
+    "Sorozat/HU/HD": "TV/HD/HU",
+  };
+
+  return categories[category as string];
+};
+
+const parseSize = (size: string) => {
+  const units: Record<string, number> = {
+    TB: 1024 ** 4,
+    GB: 1024 ** 3,
+    MB: 1024 ** 2,
+    KB: 1024,
+    B: 1,
+  };
+
+  const [sizeStr, unit] = size.split(" ");
+  const sizeNum = Number(sizeStr);
+
+  if (!sizeNum || !units[unit]) return 0;
+
+  return Math.ceil(sizeNum * units[unit]);
+};

src/torrent/jackett.ts

@@ -0,0 +1,40 @@
+import { JackettApi } from "ts-jackett-api";
+import { JackettCategory } from "ts-jackett-api/lib/types/JackettCategory.js";
+import { TorrentSearchResult } from "./search.js";
+
+const JACKETT_URL = process.env.JACKETT_URL;
+const JACKETT_KEY = process.env.JACKETT_KEY;
+
+export const searchJackett = async (
+  searchQuery: string,
+  categories: JackettCategory[],
+  jackettUrl?: string,
+  jackettKey?: string
+): Promise<TorrentSearchResult[]> => {
+  try {
+    const url = jackettUrl || JACKETT_URL;
+    const key = jackettKey || JACKETT_KEY;
+
+    if (!url || !key) return [];
+
+    const client = new JackettApi(url, key);
+
+    const res = await client.search({
+      query: searchQuery,
+      category: categories,
+    });
+
+    return res.Results.map((result) => ({
+      name: result.Title,
+      tracker: result.Tracker,
+      category: result.CategoryDesc || undefined,
+      size: result.Size,
+      seeds: result.Seeders,
+      peers: result.Peers,
+      torrent: result.Link || undefined,
+      magnet: result.MagnetUri || undefined,
+    }));
+  } catch (error) {
+    return [];
+  }
+};

src/torrent/ncore.ts

@@ -0,0 +1,146 @@
+import axios from "axios";
+import { wrapper } from "axios-cookiejar-support";
+import * as cheerio from "cheerio";
+import { CookieJar } from "tough-cookie";
+import { TorrentSearchResult } from "./search.js";
+import { isImdbId } from "../utils/imdb.js";
+
+const NCORE_USER = process.env.NCORE_USER;
+const NCORE_PASSWORD = process.env.NCORE_PASSWORD;
+
+export enum NcoreCategory {
+  Film_SD_HU = "xvid_hun",
+  Film_SD_EN = "xvid",
+  Film_HD_HU = "hd_hun",
+  Film_HD_EN = "hd",
+  Sorozat_SD_HU = "xvidser_hun",
+  Sorozat_SD_EN = "xvidser",
+  Sorozat_HD_HU = "hdser_hun",
+  Sorozat_HD_EN = "hdser",
+}
+
+export const searchNcore = async (
+  searchQuery: string,
+  categories: NcoreCategory[],
+  ncoreUser?: string,
+  ncorePassword?: string
+): Promise<TorrentSearchResult[]> => {
+  try {
+    const user = ncoreUser || NCORE_USER;
+    const password = ncorePassword || NCORE_PASSWORD;
+
+    if (!user || !password) return [];
+
+    const jar = new CookieJar();
+    // @ts-ignore
+    const client = wrapper(axios.create({ jar, baseURL: "https://ncore.pro" }));
+
+    const formData = new FormData();
+    formData.append("nev", user);
+    formData.append("pass", password);
+    formData.append("set_lang", "hu");
+    formData.append("submitted", "1");
+    await client.post("/login.php", formData);
+
+    const torrents: TorrentSearchResult[] = [];
+
+    let page = 0;
+
+    while (page <= 5) {
+      try {
+        page++;
+
+        let torrentsOnPage = 0;
+
+        let params = new URLSearchParams({
+          oldal: page.toString(),
+          tipus: "kivalasztottak_kozott",
+          kivalasztott_tipus: categories.join(","),
+          mire: searchQuery,
+          miben: isImdbId(searchQuery) ? "imdb" : "name",
+          miszerint: "ctime",
+          hogyan: "DESC",
+        });
+
+        const link = `/torrents.php?${params.toString()}}`;
+        const torrentsPage = await client.get(link);
+        const $ = cheerio.load(torrentsPage.data);
+
+        const rssUrl = $("link[rel=alternate]").attr("href");
+        const downloadKey = rssUrl?.split("=")[1];
+        if (!downloadKey) return torrents;
+
+        for (const el of $("div.box_torrent")) {
+          torrentsOnPage++;
+
+          const name = $(el).find("div.torrent_txt > a").attr("title");
+
+          const categoryHref = $(el)
+            .find("a > img.categ_link")
+            .parent()
+            .attr("href");
+
+          const tracker = "nCore";
+          const category = parseCategory(categoryHref?.split("=")[1]);
+          const size = parseSize($(el).find("div.box_meret2").text());
+          const seeds = Number($(el).find("div.box_s2").text());
+          const peers = Number($(el).find("div.box_l2").text());
+          const torrentId = $(el).next().next().attr("id");
+          const torrent = `https://ncore.pro/torrents.php?action=download&id=${torrentId}&key=${downloadKey}`;
+
+          if (!name || !torrentId) continue;
+
+          torrents.push({
+            name,
+            tracker,
+            category,
+            size,
+            seeds,
+            peers,
+            torrent,
+          });
+        }
+
+        if (torrentsOnPage < 50) break;
+      } catch {
+        continue;
+      }
+    }
+
+    return torrents;
+  } catch (error) {
+    return [];
+  }
+};
+
+const parseCategory = (category: string | undefined) => {
+  const categories: Record<NcoreCategory, string> = {
+    [NcoreCategory.Film_SD_HU]: "Movies/SD/HU",
+    [NcoreCategory.Film_SD_EN]: "Movies/SD/EN",
+    [NcoreCategory.Film_HD_HU]: "Movies/HD/HU",
+    [NcoreCategory.Film_HD_EN]: "Movies/HD/EN",
+    [NcoreCategory.Sorozat_SD_HU]: "TV/SD/HU",
+    [NcoreCategory.Sorozat_SD_EN]: "TV/SD/EN",
+    [NcoreCategory.Sorozat_HD_HU]: "TV/HD/HU",
+    [NcoreCategory.Sorozat_HD_EN]: "TV/HD/EN",
+  };
+
+  return categories[category as NcoreCategory];
+};
+
+const parseSize = (size: string) => {
+  const units: Record<string, number> = {
+    TiB: 1024 ** 4,
+    GiB: 1024 ** 3,
+    MiB: 1024 ** 2,
+    KiB: 1024,
+    B: 1,
+  };
+
+  const [sizeStr, unit] = size.split(" ");
+  const sizeNum = Number(sizeStr);
+
+  if (!sizeNum || !units[unit]) return 0;
+
+  return Math.ceil(sizeNum * units[unit]);
+};

src/torrent/search.ts

@@ -0,0 +1,176 @@
+import { JackettCategory } from "ts-jackett-api/lib/types/JackettCategory.js";
+import { searchEztv } from "./eztv.js";
+import {
+  ItorrentCategory,
+  ItorrentQuality,
+  searchItorrent,
+} from "./itorrent.js";
+import { searchJackett } from "./jackett.js";
+import { NcoreCategory, searchNcore } from "./ncore.js";
+import { searchYts } from "./yts.js";
+import { InsaneCategory, searchInsane } from "./insane.js";
+
+export type TorrentCategory = "movie" | "show";
+
+export type TorrentSource =
+  | "jackett"
+  | "ncore"
+  | "insane"
+  | "itorrent"
+  | "yts"
+  | "eztv";
+
+export interface TorrentSearchOptions {
+  categories?: TorrentCategory[];
+  sources?: TorrentSource[];
+  jackett?: {
+    url?: string;
+    apiKey?: string;
+  };
+  ncore?: {
+    user?: string;
+    password?: string;
+  };
+  insane?: {
+    user?: string;
+    password?: string;
+  };
+}
+
+export interface TorrentSearchResult {
+  name: string;
+  tracker: string;
+  category?: string;
+  size?: number;
+  seeds?: number;
+  peers?: number;
+  torrent?: string;
+  magnet?: string;
+}
+
+export const searchTorrents = async (
+  query: string,
+  options?: TorrentSearchOptions
+) => {
+  const searchAllCategories = !options?.categories?.length;
+  const searchAllSources = !options?.sources?.length;
+
+  const promises: Promise<TorrentSearchResult[]>[] = [];
+
+  if (options?.sources?.includes("jackett") || searchAllSources) {
+    const categories = new Set<JackettCategory>();
+
+    if (options?.categories?.includes("movie") || searchAllCategories) {
+      categories.add(JackettCategory.Movies);
+    }
+
+    if (options?.categories?.includes("show") || searchAllCategories) {
+      categories.add(JackettCategory.TV);
+    }
+
+    promises.push(
+      searchJackett(
+        query,
+        Array.from(categories),
+        options?.jackett?.url,
+        options?.jackett?.apiKey
+      )
+    );
+  }
+
+  if (options?.sources?.includes("ncore") || searchAllSources) {
+    const categories = new Set<NcoreCategory>();
+
+    if (options?.categories?.includes("movie") || searchAllCategories) {
+      categories.add(NcoreCategory.Film_HD_HU);
+      categories.add(NcoreCategory.Film_HD_EN);
+      categories.add(NcoreCategory.Film_SD_HU);
+      categories.add(NcoreCategory.Film_SD_EN);
+    }
+
+    if (options?.categories?.includes("show") || searchAllCategories) {
+      categories.add(NcoreCategory.Sorozat_HD_HU);
+      categories.add(NcoreCategory.Sorozat_HD_EN);
+      categories.add(NcoreCategory.Sorozat_SD_HU);
+      categories.add(NcoreCategory.Sorozat_SD_EN);
+    }
+
+    promises.push(
+      searchNcore(
+        query,
+        Array.from(categories),
+        options?.ncore?.user,
+        options?.ncore?.password
+      )
+    );
+  }
+
+  if (options?.sources?.includes("insane") || searchAllSources) {
+    const categories = new Set<InsaneCategory>();
+
+    if (options?.categories?.includes("movie") || searchAllCategories) {
+      categories.add(InsaneCategory.Film_Hun_SD);
+      categories.add(InsaneCategory.Film_Hun_HD);
+      categories.add(InsaneCategory.Film_Hun_UHD);
+      categories.add(InsaneCategory.Film_Eng_SD);
+      categories.add(InsaneCategory.Film_Eng_HD);
+      categories.add(InsaneCategory.Film_Eng_UHD);
+    }
+
+    if (options?.categories?.includes("show") || searchAllCategories) {
+      categories.add(InsaneCategory.Sorozat_Hun);
+      categories.add(InsaneCategory.Sorozat_Hun_HD);
+      categories.add(InsaneCategory.Sorozat_Hun_UHD);
+      categories.add(InsaneCategory.Sorozat_Eng);
+      categories.add(InsaneCategory.Sorozat_Eng_HD);
+      categories.add(InsaneCategory.Sorozat_Eng_UHD);
+    }
+
+    promises.push(
+      searchInsane(
+        query,
+        Array.from(categories),
+        options?.insane?.user,
+        options?.insane?.password
+      )
+    );
+  }
+
+  if (options?.sources?.includes("itorrent") || searchAllSources) {
+    const categories = new Set<ItorrentCategory>();
+
+    if (options?.categories?.includes("movie") || searchAllCategories) {
+      categories.add(ItorrentCategory.Film);
+    }
+
+    if (options?.categories?.includes("show") || searchAllCategories) {
+      categories.add(ItorrentCategory.Sorozat);
+    }
+
+    const qualities = [
+      ItorrentQuality.HD,
+      ItorrentQuality.SD,
+      ItorrentQuality.CAM,
+    ];
+
+    promises.push(searchItorrent(query, Array.from(categories), qualities));
+  }
+
+  if (options?.sources?.includes("yts") || searchAllSources) {
+    if (options?.categories?.includes("movie") || searchAllCategories) {
+      promises.push(searchYts(query));
+    }
+  }
+
+  if (options?.sources?.includes("eztv") || searchAllSources) {
+    if (options?.categories?.includes("show") || searchAllCategories) {
+      promises.push(searchEztv(query));
+    }
+  }
+
+  const results = (await Promise.all(promises)).flat();
+
+  console.log(`Search: got ${results.length} results for ${query}`);
+
+  return results;
+};

src/torrent/webtorrent.ts

@@ -0,0 +1,214 @@
+import fs from "fs-extra";
+import MemoryStore from "memory-chunk-store";
+import os from "os";
+import path from "path";
+import WebTorrent, { Torrent } from "webtorrent";
+import { getReadableDuration } from "../utils/file.js";
+
+interface FileInfo {
+  name: string;
+  path: string;
+  size: number;
+  url?: string;
+}
+
+interface ActiveFileInfo extends FileInfo {
+  progress: number;
+  downloaded: number;
+}
+
+export interface TorrentInfo {
+  name: string;
+  infoHash: string;
+  size: number;
+  files: FileInfo[];
+}
+
+interface ActiveTorrentInfo extends TorrentInfo {
+  progress: number;
+  downloaded: number;
+  uploaded: number;
+  downloadSpeed: number;
+  uploadSpeed: number;
+  peers: number;
+  openStreams: number;
+  files: ActiveFileInfo[];
+}
+
+// Directory to store downloaded files (default OS temp directory)
+const DOWNLOAD_DIR =
+  process.env.DOWNLOAD_DIR || path.join(os.tmpdir(), "torrent-stream-server");
+
+// Keep downloaded files after all streams are closed (default false)
+const KEEP_DOWNLOADED_FILES = process.env.KEEP_DOWNLOADED_FILES
+  ? process.env.KEEP_DOWNLOADED_FILES === "true"
+  : false;
+
+if (!KEEP_DOWNLOADED_FILES) fs.emptyDirSync(DOWNLOAD_DIR);
+
+// Maximum number of connections per torrent (default 50)
+const MAX_CONNS_PER_TORRENT = Number(process.env.MAX_CONNS_PER_TORRENT) || 50;
+
+// Max download speed (bytes/s) over all torrents (default 20MB/s)
+const DOWNLOAD_SPEED_LIMIT =
+  Number(process.env.DOWNLOAD_SPEED_LIMIT) || 20 * 1024 * 1024;
+
+// Max upload speed (bytes/s) over all torrents (default 1MB/s)
+const UPLOAD_SPEED_LIMIT =
+  Number(process.env.UPLOAD_SPEED_LIMIT) || 1 * 1024 * 1024;
+
+// Time (ms) to seed torrents after all streams are closed (default 1 minute)
+const SEED_TIME = Number(process.env.SEED_TIME) || 60 * 1000;
+
+// Timeout (ms) when adding torrents if no metadata is received (default 5 seconds)
+const TORRENT_TIMEOUT = Number(process.env.TORRENT_TIMEOUT) || 5 * 1000;
+
+const infoClient = new WebTorrent();
+const streamClient = new WebTorrent({
+  // @ts-ignore
+  downloadLimit: DOWNLOAD_SPEED_LIMIT,
+  uploadLimit: UPLOAD_SPEED_LIMIT,
+  maxConns: MAX_CONNS_PER_TORRENT,
+});
+
+streamClient.on("torrent", (torrent) => {
+  console.log(`Added torrent: ${torrent.name}`);
+});
+
+streamClient.on("error", (error) => {
+  if (typeof error === "string") {
+    console.error(`Error: ${error}`);
+  } else {
+    if (error.message.startsWith("Cannot add duplicate torrent")) return;
+    console.error(`Error: ${error.message}`);
+  }
+});
+
+infoClient.on("error", () => {});
+
+const launchTime = Date.now();
+
+export const getStats = () => ({
+  uptime: getReadableDuration(Date.now() - launchTime),
+  openStreams: [...openStreams.values()].reduce((a, b) => a + b, 0),
+  downloadSpeed: streamClient.downloadSpeed,
+  uploadSpeed: streamClient.uploadSpeed,
+  activeTorrents: streamClient.torrents.map<ActiveTorrentInfo>((torrent) => ({
+    name: torrent.name,
+    infoHash: torrent.infoHash,
+    size: torrent.length,
+    progress: torrent.progress,
+    downloaded: torrent.downloaded,
+    uploaded: torrent.uploaded,
+    downloadSpeed: torrent.downloadSpeed,
+    uploadSpeed: torrent.uploadSpeed,
+    peers: torrent.numPeers,
+    openStreams: openStreams.get(torrent.infoHash) || 0,
+    files: torrent.files.map((file) => ({
+      name: file.name,
+      path: file.path,
+      size: file.length,
+      progress: file.progress,
+      downloaded: file.downloaded,
+    })),
+  })),
+});
+
+export const getOrAddTorrent = (uri: string) =>
+  new Promise<Torrent | undefined>((resolve) => {
+    const torrent = streamClient.add(
+      uri,
+      {
+        path: DOWNLOAD_DIR,
+        destroyStoreOnDestroy: !KEEP_DOWNLOADED_FILES,
+        // @ts-ignore
+        deselect: true,
+      },
+      (torrent) => {
+        clearTimeout(timeout);
+        resolve(torrent);
+      }
+    );
+
+    const timeout = setTimeout(() => {
+      torrent.destroy();
+      resolve(undefined);
+    }, TORRENT_TIMEOUT);
+  });
+
+export const getFile = (torrent: Torrent, path: string) =>
+  torrent.files.find((file) => file.path === path);
+
+export const getTorrentInfo = async (uri: string) => {
+  const getInfo = (torrent: Torrent): TorrentInfo => ({
+    name: torrent.name,
+    infoHash: torrent.infoHash,
+    size: torrent.length,
+    files: torrent.files.map((file) => ({
+      name: file.name,
+      path: file.path,
+      size: file.length,
+    })),
+  });
+
+  return await new Promise<TorrentInfo | undefined>((resolve) => {
+    const torrent = infoClient.add(
+      uri,
+      { store: MemoryStore, destroyStoreOnDestroy: true },
+      (torrent) => {
+        clearTimeout(timeout);
+        const info = getInfo(torrent);
+        console.log(`Fetched info: ${info.name}`);
+        torrent.destroy();
+        resolve(info);
+      }
+    );
+
+    const timeout = setTimeout(() => {
+      torrent.destroy();
+      resolve(undefined);
+    }, TORRENT_TIMEOUT);
+  });
+};
+
+const timeouts = new Map<string, NodeJS.Timeout>();
+const openStreams = new Map<string, number>();
+
+export const streamOpened = (hash: string, fileName: string) => {
+  console.log(`Stream opened: ${fileName}`);
+
+  const count = openStreams.get(hash) || 0;
+  openStreams.set(hash, count + 1);
+
+  const timeout = timeouts.get(hash);
+
+  if (timeout) {
+    clearTimeout(timeout);
+    timeouts.delete(hash);
+  }
+};
+
+export const streamClosed = (hash: string, fileName: string) => {
+  console.log(`Stream closed: ${fileName}`);
+
+  const count = openStreams.get(hash) || 1;
+  openStreams.set(hash, count - 1);
+
+  if (count > 1) return;
+
+  openStreams.delete(hash);
+
+  let timeout = timeouts.get(hash);
+  if (timeout) return;
+
+  timeout = setTimeout(async () => {
+    const torrent = await streamClient.get(hash);
+    // @ts-ignore
+    torrent?.destroy(undefined, () => {
+      console.log(`Removed torrent: ${torrent.name}`);
+      timeouts.delete(hash);
+    });
+  }, SEED_TIME);
+
+  timeouts.set(hash, timeout);
+};

src/torrent/yts.ts

@@ -0,0 +1,58 @@
+import { details, search } from "yts-api-node";
+import { TorrentSearchResult } from "./search.js";
+import { isImdbId } from "../utils/imdb.js";
+
+const trackers = [
+  "udp://glotorrents.pw:6969/announce",
+  "udp://tracker.opentrackr.org:1337/announce",
+  "udp://torrent.gresille.org:80/announce",
+  "udp://tracker.openbittorrent.com:80",
+  "udp://tracker.coppersurfer.tk:6969",
+  "udp://tracker.leechers-paradise.org:6969",
+  "udp://p4p.arenabg.ch:1337",
+  "udp://tracker.internetwarriors.net:1337",
+];
+
+const trackersString = "&tr=" + trackers.join("&tr=");
+
+export const searchYts = async (
+  searchQuery: string
+): Promise<TorrentSearchResult[]> => {
+  try {
+    if (isImdbId(searchQuery)) {
+      const res = await details({ movie_id: searchQuery });
+
+      return res.data.movie.torrents.map((torrent) => ({
+        name: `${res.data.movie.title_long} ${torrent.quality} ${torrent.type
+          .replace("bluray", "BluRay")
+          .replace("web", "WEB")}`,
+        tracker: "YTS",
+        category: `Movies/${torrent.quality}`,
+        size: torrent.size_bytes,
+        seeds: torrent.seeds,
+        peers: torrent.peers,
+        torrent: torrent.url,
+        magnet: `magnet:?xt=urn:btih:${torrent.hash}${trackersString}`,
+      }));
+    } else {
+      const res = await search({ query_term: searchQuery });
+
+      return res.data.movies.flatMap((movie) =>
+        movie.torrents.map((torrent) => ({
+          name: `${movie.title_long} ${torrent.quality} ${torrent.type
+            .replace("bluray", "BluRay")
+            .replace("web", "WEB")}`,
+          tracker: "YTS",
+          category: `Movies/${torrent.quality}`,
+          size: torrent.size_bytes,
+          seeds: torrent.seeds,
+          peers: torrent.peers,
+          torrent: torrent.url,
+          magnet: `magnet:?xt=urn:btih:${torrent.hash}${trackersString}`,
+        }))
+      );
+    }
+  } catch (error) {
+    return [];
+  }
+};

src/utils/dotenv.ts

@@ -0,0 +1,3 @@
+import dotenv from "dotenv";
+
+dotenv.config();

src/utils/file.ts

@@ -0,0 +1,47 @@
+import mime from "mime";
+
+export const isVideoFile = (filename: string) =>
+  mime.getType(filename)?.startsWith("video") || false;
+
+export const isSubtitleFile = (filename: string) =>
+  filename.toLowerCase().endsWith(".srt") ||
+  filename.toLowerCase().endsWith(".sub") ||
+  filename.toLowerCase().endsWith(".vtt") ||
+  filename.toLowerCase().endsWith(".smi") ||
+  filename.toLowerCase().endsWith(".ssa") ||
+  filename.toLowerCase().endsWith(".ass") ||
+  filename.toLowerCase().endsWith(".txt");
+
+export const getStreamingMimeType = (filename: string) => {
+  const mimeType = mime.getType(filename);
+  return mimeType?.startsWith("video")
+    ? "video/mp4"
+    : mimeType || "application/unknown";
+};
+
+export const getReadableSize = (bytes: number) => {
+  if (bytes == 0) {
+    return "0.00 B";
+  }
+  var e = Math.floor(Math.log(bytes) / Math.log(1024));
+  return (
+    (bytes / Math.pow(1024, e)).toFixed(2) + " " + " KMGTP".charAt(e) + "B"
+  );
+};
+
+export const getReadableDuration = (millisecs: number) => {
+  var seconds = (millisecs / 1000).toFixed(1);
+  var minutes = (millisecs / (1000 * 60)).toFixed(1);
+  var hours = (millisecs / (1000 * 60 * 60)).toFixed(1);
+  var days = (millisecs / (1000 * 60 * 60 * 24)).toFixed(1);
+
+  if (Number(seconds) < 60) {
+    return seconds + " seconds";
+  } else if (Number(minutes) < 60) {
+    return minutes + " minutes";
+  } else if (Number(hours) < 24) {
+    return hours + " hours";
+  } else {
+    return days + " days";
+  }
+};

src/utils/https.ts

@@ -0,0 +1,45 @@
+import axios from "axios";
+import { RequestListener } from "http";
+import https from "https";
+import localtunnel from "localtunnel";
+
+enum HttpsMethod {
+  None = "none",
+  LocalIpMedic = "local-ip.medicmobile.org",
+  LocalIpCo = "local-ip.co",
+  Localtunnel = "localtunnel",
+}
+
+const HTTPS_METHOD = process.env.HTTPS_METHOD || HttpsMethod.None;
+
+export const serveHTTPS = async (app: RequestListener, port: number) => {
+  if (HTTPS_METHOD === HttpsMethod.LocalIpMedic) {
+    const json = (await axios.get("https://local-ip.medicmobile.org/keys"))
+      .data;
+    const cert = `${json.cert}\n${json.chain}`;
+    const httpsServer = https.createServer({ key: json.privkey, cert }, app);
+    httpsServer.listen(port);
+    console.log(`HTTPS addon listening on port ${port}`);
+    return httpsServer;
+  }
+
+  if (HTTPS_METHOD === HttpsMethod.LocalIpCo) {
+    const key = (await axios.get("http://local-ip.co/cert/server.key")).data;
+    const serverPem = (await axios.get("http://local-ip.co/cert/server.pem"))
+      .data;
+    const chainPem = (await axios.get("http://local-ip.co/cert/chain.pem"))
+      .data;
+    const cert = `${serverPem}\n${chainPem}`;
+    const httpsServer = https.createServer({ key, cert }, app);
+    httpsServer.listen(port);
+    console.log(`HTTPS addon listening on port ${port}`);
+    return httpsServer;
+  }
+
+  if (HTTPS_METHOD === HttpsMethod.Localtunnel) {
+    const tunnel = await localtunnel({ port: Number(process.env.PORT) });
+    console.log(`Tunnel accessible at: ${tunnel.url}`);
+    const tunnelPassword = await axios.get("https://loca.lt/mytunnelpassword");
+    console.log(`Tunnel password: ${tunnelPassword.data}`);
+  }
+};

src/utils/imdb.ts

@@ -0,0 +1,37 @@
+import axios from "axios";
+
+export const getTitle = async (imdbId: string, language?: string) => {
+  try {
+    const data = (
+      await axios.get(`https://www.imdb.com/title/${imdbId}`, {
+        headers: {
+          "Accept-Language": language,
+          "Accept-Encoding": "gzip,deflate,compress",
+          "User-Agent":
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3",
+        },
+      })
+    ).data;
+
+    const title = data.match(/<title>(.*?)<\/title>/)[1] as string;
+    if (!title) return undefined;
+    return title.split(" (")[0];
+  } catch {
+    return undefined;
+  }
+};
+
+export const getTitles = async (imdbId: string) => {
+  const titles = new Set<string>();
+
+  (await Promise.all([getTitle(imdbId), getTitle(imdbId, "en")])).forEach(
+    (title) => {
+      if (title) titles.add(title);
+    }
+  );
+
+  return [...titles];
+};
+
+export const isImdbId = (str: string) =>
+  /ev\d{7}\/\d{4}(-\d)?|(ch|co|ev|nm|tt)\d{7}/.test(str);

src/utils/language.ts

@@ -0,0 +1,16 @@
+export const guessLanguage = (name: string, category?: string) => {
+  if (category?.includes("HU")) return "Hungarian";
+
+  const split = name
+    .toLowerCase()
+    .replace(/\W/g, " ")
+    .replace("x", " ")
+    .split(" ");
+
+  if (split.includes("hun") || split.includes("hungarian")) return "Hungarian";
+  if (split.includes("ger") || split.includes("german")) return "German";
+  if (split.includes("fre") || split.includes("french")) return "French";
+  if (split.includes("ita") || split.includes("italian")) return "Italian";
+
+  return "English";
+};

src/utils/quality.ts

@@ -0,0 +1,83 @@
+export const guessQuality = (name: string) => {
+  const split = name.replace(/\W/g, " ").toLowerCase().split(" ");
+
+  let score = 0;
+  const parts = [];
+
+  if (split.includes("2160p")) {
+    parts.push("4K");
+    score += 3000;
+  } else if (split.includes("1080p")) {
+    parts.push("1080p");
+    score += 2000;
+  } else if (split.includes("720p")) {
+    parts.push("720p");
+    score += 1000;
+  }
+
+  if (
+    (split.includes("dolby") && split.includes("vision")) ||
+    split.includes("dovi") ||
+    split.includes("dv")
+  ) {
+    parts.push("Dolby Vision");
+    score += 20;
+  } else if (split.includes("hdr")) {
+    parts.push("HDR");
+    score += 10;
+  }
+
+  if (
+    split.includes("bluray") ||
+    (split.includes("blu") && split.includes("ray")) ||
+    split.includes("bdrip") ||
+    split.includes("brrip")
+  ) {
+    parts.push("BluRay");
+    score += 500;
+
+    if (split.includes("remux")) {
+      parts.push("Remux");
+      score += 100;
+    }
+  } else if (
+    split.includes("webrip") ||
+    split.includes("webdl") ||
+    split.includes("web")
+  ) {
+    parts.push("WEB");
+    score += 400;
+  } else if (split.includes("dvdrip")) {
+    parts.push("DVD");
+    score += 300;
+  } else if (split.includes("hdtv")) {
+    parts.push("HDTV");
+    score += 200;
+  } else if (split.includes("sdtv")) {
+    parts.push("sdtv");
+    score += 100;
+  } else if (
+    split.includes("camrip") ||
+    split.includes("cam") ||
+    split.includes("hdcam") ||
+    split.includes("ts") ||
+    split.includes("hdts") ||
+    split.includes("tc") ||
+    split.includes("hdtc")
+  ) {
+    parts.push("CAM");
+    score -= 5000;
+  }
+
+  if (split.includes("3d")) {
+    parts.push("3D");
+    score -= 1;
+  }
+
+  if (parts.length === 0) {
+    parts.push("Unknown");
+    score = -Infinity;
+  }
+
+  return { quality: parts.join(" "), score };
+};

src/utils/shows.ts

@@ -0,0 +1,56 @@
+export const guessSeasonEpisode = (name: string) => {
+  const str = name.replace(/\W/g, " ").toLowerCase();
+
+  const seasonMatch = [...str.matchAll(/[s](?<season>\d+)/g)];
+  const episodeMatch = str.match(/[e](?<episode>\d+)/);
+
+  if (seasonMatch.length === 0 && str.includes("complete")) {
+    return { completeSeries: true };
+  } else if (seasonMatch.length === 1 && !episodeMatch) {
+    const season = Number(seasonMatch[0].groups?.season) || 0;
+    return { seasons: [season] };
+  } else if (seasonMatch.length > 1) {
+    const firstSeason = Number(seasonMatch[0].groups?.season) || 0;
+    const lastSeason =
+      Number(seasonMatch[seasonMatch.length - 1].groups?.season) || 0;
+    const seasons = [];
+    for (let i = firstSeason; i <= lastSeason; i++) seasons.push(i);
+    return { seasons };
+  } else if (seasonMatch[0] || episodeMatch) {
+    const season = Number(seasonMatch[0]?.groups?.season) || undefined;
+    const episode = Number(episodeMatch?.groups?.episode) || undefined;
+    return { season, episode };
+  } else {
+    const seasonEpisodeMatch = str.match(/(?<season>\d+)x(?<episode>\d+)/);
+    const season = Number(seasonEpisodeMatch?.groups?.season) || undefined;
+    const episode = Number(seasonEpisodeMatch?.groups?.episode) || undefined;
+    return { season, episode };
+  }
+};
+
+export const isTorrentNameMatch = (
+  name: string,
+  season: number,
+  episode: number
+) => {
+  const guess = guessSeasonEpisode(name);
+  if (guess.completeSeries) return true;
+  if (guess.seasons?.includes(season)) return true;
+  if (guess.season === season && guess.episode === episode) return true;
+  if (season === 0) {
+    if (name.toLowerCase().includes("special")) return true;
+    if (guess.season === undefined && guess.seasons === undefined) return true;
+  }
+  return false;
+};
+
+export const isFileNameMatch = (
+  name: string,
+  season: number,
+  episode: number
+) => {
+  const guess = guessSeasonEpisode(name);
+  if (guess.season === season && guess.episode === episode) return true;
+  if (season === 0) return true;
+  return false;
+};

tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "ESNext",
+    "sourceMap": true,
+    "rootDir": "src",
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  }
+}