Merge branch 'main' into feature/better-repack-modal

src/main/services/download-manager.ts

@@ -0,0 +1,76 @@
+import { gameRepository } from "@main/repository";
+
+import type { Game } from "@main/entity";
+import { Downloader } from "@shared";
+
+import { writePipe } from "./fifo";
+import { RealDebridDownloader } from "./downloaders";
+
+export class DownloadManager {
+  private static gameDownloading: Game;
+
+  static async getGame(gameId: number) {
+    return gameRepository.findOne({
+      where: { id: gameId, isDeleted: false },
+      relations: {
+        repack: true,
+      },
+    });
+  }
+
+  static async cancelDownload() {
+    if (
+      this.gameDownloading &&
+      this.gameDownloading.downloader === Downloader.Torrent
+    ) {
+      writePipe.write({ action: "cancel" });
+    } else {
+      RealDebridDownloader.destroy();
+    }
+  }
+
+  static async pauseDownload() {
+    if (
+      this.gameDownloading &&
+      this.gameDownloading.downloader === Downloader.Torrent
+    ) {
+      writePipe.write({ action: "pause" });
+    } else {
+      RealDebridDownloader.destroy();
+    }
+  }
+
+  static async resumeDownload(gameId: number) {
+    const game = await this.getGame(gameId);
+
+    if (game!.downloader === Downloader.Torrent) {
+      writePipe.write({
+        action: "start",
+        game_id: game!.id,
+        magnet: game!.repack.magnet,
+        save_path: game!.downloadPath,
+      });
+    } else {
+      RealDebridDownloader.startDownload(game!);
+    }
+
+    this.gameDownloading = game!;
+  }
+
+  static async downloadGame(gameId: number) {
+    const game = await this.getGame(gameId);
+
+    if (game!.downloader === Downloader.Torrent) {
+      writePipe.write({
+        action: "start",
+        game_id: game!.id,
+        magnet: game!.repack.magnet,
+        save_path: game!.downloadPath,
+      });
+    } else {
+      RealDebridDownloader.startDownload(game!);
+    }
+
+    this.gameDownloading = game!;
+  }
+}

src/main/services/downloaders/downloader.ts

@@ -0,0 +1,85 @@
+import { t } from "i18next";
+import { Notification } from "electron";
+
+import { Game } from "@main/entity";
+
+import type { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+
+import { WindowManager } from "../window-manager";
+import type { TorrentUpdate } from "./torrent.downloader";
+
+import { GameStatus } from "@shared";
+import { gameRepository, userPreferencesRepository } from "@main/repository";
+
+interface DownloadStatus {
+  numPeers?: number;
+  numSeeds?: number;
+  downloadSpeed?: number;
+  timeRemaining?: number;
+}
+
+export class Downloader {
+  static getGameProgress(game: Game) {
+    if (game.status === GameStatus.CheckingFiles)
+      return game.fileVerificationProgress;
+
+    return game.progress;
+  }
+
+  static async updateGameProgress(
+    gameId: number,
+    gameUpdate: QueryDeepPartialEntity<Game>,
+    downloadStatus: DownloadStatus
+  ) {
+    await gameRepository.update({ id: gameId }, gameUpdate);
+
+    const game = await gameRepository.findOne({
+      where: { id: gameId, isDeleted: false },
+      relations: { repack: true },
+    });
+
+    if (game?.progress === 1) {
+      const userPreferences = await userPreferencesRepository.findOne({
+        where: { id: 1 },
+      });
+
+      if (userPreferences?.downloadNotificationsEnabled) {
+        new Notification({
+          title: t("download_complete", {
+            ns: "notifications",
+            lng: userPreferences.language,
+          }),
+          body: t("game_ready_to_install", {
+            ns: "notifications",
+            lng: userPreferences.language,
+            title: game?.title,
+          }),
+        }).show();
+      }
+    }
+
+    if (WindowManager.mainWindow && game) {
+      const progress = this.getGameProgress(game);
+      WindowManager.mainWindow.setProgressBar(progress === 1 ? -1 : progress);
+
+      WindowManager.mainWindow.webContents.send(
+        "on-download-progress",
+        JSON.parse(
+          JSON.stringify({
+            ...({
+              progress: gameUpdate.progress,
+              bytesDownloaded: gameUpdate.bytesDownloaded,
+              fileSize: gameUpdate.fileSize,
+              gameId,
+              numPeers: downloadStatus.numPeers,
+              numSeeds: downloadStatus.numSeeds,
+              downloadSpeed: downloadStatus.downloadSpeed,
+              timeRemaining: downloadStatus.timeRemaining,
+            } as TorrentUpdate),
+            game,
+          })
+        )
+      );
+    }
+  }
+}

src/main/services/downloaders/index.ts

@@ -0,0 +1,2 @@
+export * from "./real-debrid.downloader";
+export * from "./torrent.downloader";

src/main/services/downloaders/real-debrid.downloader.ts

@@ -0,0 +1,115 @@
+import { Game } from "@main/entity";
+import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+import path from "node:path";
+import fs from "node:fs";
+import EasyDL from "easydl";
+import { GameStatus } from "@shared";
+// import { fullArchive } from "node-7z-archive";
+
+import { Downloader } from "./downloader";
+import { RealDebridClient } from "../real-debrid";
+
+export class RealDebridDownloader extends Downloader {
+  private static download: EasyDL;
+  private static downloadSize = 0;
+
+  private static getEta(bytesDownloaded: number, speed: number) {
+    const remainingBytes = this.downloadSize - bytesDownloaded;
+
+    if (remainingBytes >= 0 && speed > 0) {
+      return (remainingBytes / speed) * 1000;
+    }
+
+    return 1;
+  }
+
+  private static createFolderIfNotExists(path: string) {
+    if (!fs.existsSync(path)) {
+      fs.mkdirSync(path);
+    }
+  }
+
+  // private static async startDecompression(
+  //   rarFile: string,
+  //   dest: string,
+  //   game: Game
+  // ) {
+  //   await fullArchive(rarFile, dest);
+
+  //   const updatePayload: QueryDeepPartialEntity<Game> = {
+  //     status: GameStatus.Finished,
+  //   };
+
+  //   await this.updateGameProgress(game.id, updatePayload, {});
+  // }
+
+  static destroy() {
+    if (this.download) {
+      this.download.destroy();
+    }
+  }
+
+  static async startDownload(game: Game) {
+    if (this.download) this.download.destroy();
+    const downloadUrl = decodeURIComponent(
+      await RealDebridClient.getDownloadUrl(game)
+    );
+
+    const filename = path.basename(downloadUrl);
+    const folderName = path.basename(filename, path.extname(filename));
+
+    const downloadPath = path.join(game.downloadPath!, folderName);
+    this.createFolderIfNotExists(downloadPath);
+
+    this.download = new EasyDL(downloadUrl, path.join(downloadPath, filename));
+
+    const metadata = await this.download.metadata();
+
+    this.downloadSize = metadata.size;
+
+    const updatePayload: QueryDeepPartialEntity<Game> = {
+      status: GameStatus.Downloading,
+      fileSize: metadata.size,
+      folderName,
+    };
+
+    const downloadStatus = {
+      timeRemaining: Number.POSITIVE_INFINITY,
+    };
+
+    await this.updateGameProgress(game.id, updatePayload, downloadStatus);
+
+    this.download.on("progress", async ({ total }) => {
+      const updatePayload: QueryDeepPartialEntity<Game> = {
+        status: GameStatus.Downloading,
+        progress: Math.min(0.99, total.percentage / 100),
+        bytesDownloaded: total.bytes,
+      };
+
+      const downloadStatus = {
+        downloadSpeed: total.speed,
+        timeRemaining: this.getEta(total.bytes ?? 0, total.speed ?? 0),
+      };
+
+      await this.updateGameProgress(game.id, updatePayload, downloadStatus);
+    });
+
+    this.download.on("end", async () => {
+      const updatePayload: QueryDeepPartialEntity<Game> = {
+        status: GameStatus.Finished,
+        progress: 1,
+      };
+
+      await this.updateGameProgress(game.id, updatePayload, {
+        timeRemaining: 0,
+      });
+
+      /* This has to be improved */
+      // this.startDecompression(
+      //   path.join(downloadPath, filename),
+      //   downloadPath,
+      //   game
+      // );
+    });
+  }
+}

src/main/services/downloaders/torrent.downloader.ts

@@ -0,0 +1,160 @@
+import path from "node:path";
+import cp from "node:child_process";
+import fs from "node:fs";
+import * as Sentry from "@sentry/electron/main";
+import { app, dialog } from "electron";
+import type { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+
+import { Game } from "@main/entity";
+import { GameStatus } from "@shared";
+import { Downloader } from "./downloader";
+import { readPipe, writePipe } from "../fifo";
+
+const binaryNameByPlatform: Partial<Record<NodeJS.Platform, string>> = {
+  darwin: "hydra-download-manager",
+  linux: "hydra-download-manager",
+  win32: "hydra-download-manager.exe",
+};
+
+enum TorrentState {
+  CheckingFiles = 1,
+  DownloadingMetadata = 2,
+  Downloading = 3,
+  Finished = 4,
+  Seeding = 5,
+}
+
+export interface TorrentUpdate {
+  gameId: number;
+  progress: number;
+  downloadSpeed: number;
+  timeRemaining: number;
+  numPeers: number;
+  numSeeds: number;
+  status: TorrentState;
+  folderName: string;
+  fileSize: number;
+  bytesDownloaded: number;
+}
+
+export const BITTORRENT_PORT = "5881";
+
+export class TorrentDownloader extends Downloader {
+  private static messageLength = 1024 * 2;
+
+  public static async attachListener() {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const buffer = readPipe.socket?.read(this.messageLength);
+
+      if (buffer === null) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        continue;
+      }
+
+      const message = Buffer.from(
+        buffer.slice(0, buffer.indexOf(0x00))
+      ).toString("utf-8");
+
+      try {
+        const payload = JSON.parse(message) as TorrentUpdate;
+
+        const updatePayload: QueryDeepPartialEntity<Game> = {
+          bytesDownloaded: payload.bytesDownloaded,
+          status: this.getTorrentStateName(payload.status),
+        };
+
+        if (payload.status === TorrentState.CheckingFiles) {
+          updatePayload.fileVerificationProgress = payload.progress;
+        } else {
+          if (payload.folderName) {
+            updatePayload.folderName = payload.folderName;
+            updatePayload.fileSize = payload.fileSize;
+          }
+        }
+
+        if (
+          [TorrentState.Downloading, TorrentState.Seeding].includes(
+            payload.status
+          )
+        ) {
+          updatePayload.progress = payload.progress;
+        }
+
+        this.updateGameProgress(payload.gameId, updatePayload, {
+          numPeers: payload.numPeers,
+          numSeeds: payload.numSeeds,
+          downloadSpeed: payload.downloadSpeed,
+          timeRemaining: payload.timeRemaining,
+        });
+      } catch (err) {
+        Sentry.captureException(err);
+      } finally {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    }
+  }
+
+  public static startClient() {
+    return new Promise((resolve) => {
+      const commonArgs = [
+        BITTORRENT_PORT,
+        writePipe.socketPath,
+        readPipe.socketPath,
+      ];
+
+      if (app.isPackaged) {
+        const binaryName = binaryNameByPlatform[process.platform]!;
+        const binaryPath = path.join(
+          process.resourcesPath,
+          "hydra-download-manager",
+          binaryName
+        );
+
+        if (!fs.existsSync(binaryPath)) {
+          dialog.showErrorBox(
+            "Fatal",
+            "Hydra download manager binary not found. Please check if it has been removed by Windows Defender."
+          );
+
+          app.quit();
+        }
+
+        cp.spawn(binaryPath, commonArgs, {
+          stdio: "inherit",
+          windowsHide: true,
+        });
+        return;
+      }
+
+      const scriptPath = path.join(
+        __dirname,
+        "..",
+        "..",
+        "torrent-client",
+        "main.py"
+      );
+
+      cp.spawn("python3", [scriptPath, ...commonArgs], {
+        stdio: "inherit",
+      });
+
+      Promise.all([writePipe.createPipe(), readPipe.createPipe()]).then(
+        async () => {
+          this.attachListener();
+          resolve(null);
+        }
+      );
+    });
+  }
+
+  private static getTorrentStateName(state: TorrentState) {
+    if (state === TorrentState.CheckingFiles) return GameStatus.CheckingFiles;
+    if (state === TorrentState.Downloading) return GameStatus.Downloading;
+    if (state === TorrentState.DownloadingMetadata)
+      return GameStatus.DownloadingMetadata;
+    if (state === TorrentState.Finished) return GameStatus.Finished;
+    if (state === TorrentState.Seeding) return GameStatus.Seeding;
+    return null;
+  }
+}

src/main/services/index.ts

@@ -6,6 +6,7 @@ export * from "./steam-grid";
 export * from "./update-resolver";
 export * from "./window-manager";
 export * from "./fifo";
-export * from "./torrent-client";
+export * from "./downloaders";
+export * from "./download-manager";
 export * from "./how-long-to-beat";
 export * from "./process-watcher";

src/main/services/process-watcher.ts

@@ -16,6 +16,7 @@ export const startProcessWatcher = async () => {
     const games = await gameRepository.find({
       where: {
         executablePath: Not(IsNull()),
+        isDeleted: false,
       },
     });
 

src/main/services/real-debrid.ts

@@ -0,0 +1,102 @@
+import { Game } from "@main/entity";
+import type {
+  RealDebridAddMagnet,
+  RealDebridTorrentInfo,
+  RealDebridUnrestrictLink,
+} from "./real-debrid.types";
+import axios, { AxiosInstance } from "axios";
+
+const base = "https://api.real-debrid.com/rest/1.0";
+
+export class RealDebridClient {
+  private static instance: AxiosInstance;
+
+  static async addMagnet(magnet: string) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("magnet", magnet);
+
+    const response = await this.instance.post<RealDebridAddMagnet>(
+      "/torrents/addMagnet",
+      searchParams.toString()
+    );
+
+    return response.data;
+  }
+
+  static async getInfo(id: string) {
+    const response = await this.instance.get<RealDebridTorrentInfo>(
+      `/torrents/info/${id}`
+    );
+    return response.data;
+  }
+
+  static async selectAllFiles(id: string) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("files", "all");
+
+    await this.instance.post(
+      `/torrents/selectFiles/${id}`,
+      searchParams.toString()
+    );
+  }
+
+  static async unrestrictLink(link: string) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("link", link);
+
+    const response = await this.instance.post<RealDebridUnrestrictLink>(
+      "/unrestrict/link",
+      searchParams.toString()
+    );
+
+    return response.data;
+  }
+
+  static async getAllTorrentsFromUser() {
+    const response =
+      await this.instance.get<RealDebridTorrentInfo[]>("/torrents");
+
+    return response.data;
+  }
+
+  static extractSHA1FromMagnet(magnet: string) {
+    return magnet.match(/btih:([0-9a-fA-F]*)/)?.[1].toLowerCase();
+  }
+
+  static async getDownloadUrl(game: Game) {
+    const torrents = await RealDebridClient.getAllTorrentsFromUser();
+    const hash = RealDebridClient.extractSHA1FromMagnet(game!.repack.magnet);
+    let torrent = torrents.find((t) => t.hash === hash);
+
+    if (!torrent) {
+      const magnet = await RealDebridClient.addMagnet(game!.repack.magnet);
+
+      if (magnet && magnet.id) {
+        await RealDebridClient.selectAllFiles(magnet.id);
+        torrent = await RealDebridClient.getInfo(magnet.id);
+      }
+    }
+
+    if (torrent) {
+      const { links } = torrent;
+      const { download } = await RealDebridClient.unrestrictLink(links[0]);
+
+      if (!download) {
+        throw new Error("Torrent not cached on Real Debrid");
+      }
+
+      return download;
+    }
+
+    throw new Error();
+  }
+
+  static async authorize(apiToken: string) {
+    this.instance = axios.create({
+      baseURL: base,
+      headers: {
+        Authorization: `Bearer ${apiToken}`,
+      },
+    });
+  }
+}

src/main/services/real-debrid.types.ts

@@ -0,0 +1,51 @@
+export interface RealDebridUnrestrictLink {
+  id: string;
+  filename: string;
+  mimeType: string;
+  filesize: number;
+  link: string;
+  host: string;
+  host_icon: string;
+  chunks: number;
+  crc: number;
+  download: string;
+  streamable: number;
+}
+
+export interface RealDebridAddMagnet {
+  id: string;
+  // URL of the created ressource
+  uri: string;
+}
+
+export interface RealDebridTorrentInfo {
+  id: string;
+  filename: string;
+  original_filename: string; // Original name of the torrent
+  hash: string; // SHA1 Hash of the torrent
+  bytes: number; // Size of selected files only
+  original_bytes: number; // Total size of the torrent
+  host: string; // Host main domain
+  split: number; // Split size of links
+  progress: number; // Possible values: 0 to 100
+  status: string; // Current status of the torrent: magnet_error, magnet_conversion, waiting_files_selection, queued, downloading, downloaded, error, virus, compressing, uploading, dead
+  added: string; // jsonDate
+  files: [
+    {
+      id: number;
+      path: string; // Path to the file inside the torrent, starting with "/"
+      bytes: number;
+      selected: number; // 0 or 1
+    },
+    {
+      id: number;
+      path: string; // Path to the file inside the torrent, starting with "/"
+      bytes: number;
+      selected: number; // 0 or 1
+    },
+  ];
+  links: string[];
+  ended: string; // !! Only present when finished, jsonDate
+  speed: number; // !! Only present in "downloading", "compressing", "uploading" status
+  seeders: number; // !! Only present in "downloading", "magnet_conversion" status
+}

src/main/services/repack-tracker/1337x.ts

@@ -33,9 +33,9 @@ const getTorrentDetails = async (path: string) => {
 
   return {
     magnet: $a?.href,
-    fileSize: $totalSize.querySelector("span").textContent ?? undefined,
+    fileSize: $totalSize.querySelector("span")!.textContent,
     uploadDate: formatUploadDate(
-      $dateUploaded.querySelector("span").textContent!
+      $dateUploaded.querySelector("span")!.textContent!
     ),
   };
 };
@@ -65,8 +65,7 @@ export const getTorrentListLastPage = async (user: string) => {
 export const extractTorrentsFromDocument = async (
   page: number,
   user: string,
-  document: Document,
-  existingRepacks: Repack[] = []
+  document: Document
 ) => {
   const $trs = Array.from(document.querySelectorAll("tbody tr"));
 
@@ -78,24 +77,13 @@ export const extractTorrentsFromDocument = async (
       const url = $name.href;
       const title = $name.textContent ?? "";
 
-      if (existingRepacks.some((repack) => repack.title === title)) {
-        return {
-          title,
-          magnet: "",
-          fileSize: null,
-          uploadDate: null,
-          repacker: user,
-          page,
-        };
-      }
-
       const details = await getTorrentDetails(url);
 
       return {
         title,
         magnet: details.magnet,
-        fileSize: details.fileSize ?? null,
-        uploadDate: details.uploadDate ?? null,
+        fileSize: details.fileSize ?? "N/A",
+        uploadDate: details.uploadDate ?? new Date(),
         repacker: user,
         page,
       };
@@ -114,13 +102,11 @@ export const getNewRepacksFromUser = async (
   const repacks = await extractTorrentsFromDocument(
     page,
     user,
-    window.document,
-    existingRepacks
+    window.document
   );
 
   const newRepacks = repacks.filter(
     (repack) =>
-      repack.uploadDate &&
       !existingRepacks.some(
         (existingRepack) => existingRepack.title === repack.title
       )

src/main/services/repack-tracker/cpg-repacks.ts

@@ -4,6 +4,7 @@ import { Repack } from "@main/entity";
 
 import { requestWebPage, saveRepacks } from "./helpers";
 import { logger } from "../logger";
+import type { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 
 export const getNewRepacksFromCPG = async (
   existingRepacks: Repack[] = [],
@@ -13,11 +14,11 @@ export const getNewRepacksFromCPG = async (
 
   const { window } = new JSDOM(data);
 
-  const repacks = [];
+  const repacks: QueryDeepPartialEntity<Repack>[] = [];
 
   try {
     Array.from(window.document.querySelectorAll(".post")).forEach(($post) => {
-      const $title = $post.querySelector(".entry-title");
+      const $title = $post.querySelector(".entry-title")!;
       const uploadDate = $post.querySelector("time")?.getAttribute("datetime");
 
       const $downloadInfo = Array.from(
@@ -31,26 +32,25 @@ export const getNewRepacksFromCPG = async (
           $a.textContent?.startsWith("Magent")
       );
 
-      const fileSize = $downloadInfo.textContent
+      const fileSize = ($downloadInfo?.textContent ?? "")
         .split("Download link => ")
         .at(1);
 
       repacks.push({
-        title: $title.textContent,
+        title: $title.textContent!,
         fileSize: fileSize ?? "N/A",
-        magnet: $magnet.href,
+        magnet: $magnet!.href,
         repacker: "CPG",
         page,
-        uploadDate: new Date(uploadDate),
+        uploadDate: uploadDate ? new Date(uploadDate) : new Date(),
       });
     });
-  } catch (err) {
-    logger.error(err.message, { method: "getNewRepacksFromCPG" });
+  } catch (err: unknown) {
+    logger.error((err as Error).message, { method: "getNewRepacksFromCPG" });
   }
 
   const newRepacks = repacks.filter(
     (repack) =>
-      repack.uploadDate &&
       !existingRepacks.some(
         (existingRepack) => existingRepack.title === repack.title
       )

src/main/services/repack-tracker/gog.ts

@@ -16,14 +16,14 @@ const getGOGGame = async (url: string) => {
 
   const $em = window.document.querySelector(
     "p:not(.lightweight-accordion *) em"
-  );
-  const fileSize = $em.textContent.split("Size: ").at(1);
+  )!;
+  const fileSize = $em.textContent!.split("Size: ").at(1);
   const $downloadButton = window.document.querySelector(
     ".download-btn:not(.lightweight-accordion *)"
   ) as HTMLAnchorElement;
 
   const { searchParams } = new URL($downloadButton.href);
-  const magnet = Buffer.from(searchParams.get("url"), "base64").toString(
+  const magnet = Buffer.from(searchParams.get("url")!, "base64").toString(
     "utf-8"
   );
 
@@ -50,10 +50,10 @@ export const getNewGOGGames = async (existingRepacks: Repack[] = []) => {
     const $lis = Array.from($ul.querySelectorAll("li"));
 
     for (const $li of $lis) {
-      const $a = $li.querySelector("a");
+      const $a = $li.querySelector("a")!;
       const href = $a.href;
 
-      const title = $a.textContent.trim();
+      const title = $a.textContent!.trim();
 
       const gameExists = existingRepacks.some(
         (existingRepack) => existingRepack.title === title

src/main/services/repack-tracker/online-fix.ts

@@ -13,6 +13,9 @@ import { ru } from "date-fns/locale";
 import { onlinefixFormatter } from "@main/helpers";
 import makeFetchCookie from "fetch-cookie";
 import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+import { formatBytes } from "@shared";
+
+const ONLINE_FIX_URL = "https://online-fix.me/";
 
 export const getNewRepacksFromOnlineFix = async (
   existingRepacks: Repack[] = [],
@@ -27,14 +30,14 @@ export const getNewRepacksFromOnlineFix = async (
   const http = makeFetchCookie(fetch, cookieJar);
 
   if (page === 1) {
-    await http("https://online-fix.me/");
+    await http(ONLINE_FIX_URL);
 
     const preLogin =
       ((await http("https://online-fix.me/engine/ajax/authtoken.php", {
         method: "GET",
         headers: {
           "X-Requested-With": "XMLHttpRequest",
-          Referer: "https://online-fix.me/",
+          Referer: ONLINE_FIX_URL,
         },
       }).then((res) => res.json())) as {
         field: string;
@@ -50,11 +53,11 @@ export const getNewRepacksFromOnlineFix = async (
       [preLogin.field]: preLogin.value,
     });
 
-    await http("https://online-fix.me/", {
+    await http(ONLINE_FIX_URL, {
       method: "POST",
       headers: {
-        Referer: "https://online-fix.me",
-        Origin: "https://online-fix.me",
+        Referer: ONLINE_FIX_URL,
+        Origin: ONLINE_FIX_URL,
         "Content-Type": "application/x-www-form-urlencoded",
       },
       body: params.toString(),
@@ -149,13 +152,8 @@ export const getNewRepacksFromOnlineFix = async (
         const torrentSizeInBytes = torrent.length;
         if (!torrentSizeInBytes) return;
 
-        const fileSizeFormatted =
-          torrentSizeInBytes >= 1024 ** 3
-            ? `${(torrentSizeInBytes / 1024 ** 3).toFixed(1)}GBs`
-            : `${(torrentSizeInBytes / 1024 ** 2).toFixed(1)}MBs`;
-
         repacks.push({
-          fileSize: fileSizeFormatted,
+          fileSize: formatBytes(torrentSizeInBytes),
           magnet: magnetLink,
           page: 1,
           repacker: "onlinefix",

src/main/services/repack-tracker/xatab.ts

@@ -7,6 +7,8 @@ import { requestWebPage, saveRepacks } from "./helpers";
 import createWorker from "@main/workers/torrent-parser.worker?nodeWorker";
 import { toMagnetURI } from "parse-torrent";
 import type { Instance } from "parse-torrent";
+import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+import { formatBytes } from "@shared";
 
 const worker = createWorker({});
 
@@ -23,10 +25,9 @@ const formatXatabDate = (str: string) => {
   return date;
 };
 
-const formatXatabDownloadSize = (str: string) =>
-  str.replace(",", ".").replace(/Гб/g, "GB").replace(/Мб/g, "MB");
-
-const getXatabRepack = (url: string) => {
+const getXatabRepack = (
+  url: string
+): Promise<{ fileSize: string; magnet: string; uploadDate: Date }> => {
   return new Promise((resolve) => {
     (async () => {
       const data = await requestWebPage(url);
@@ -34,7 +35,6 @@ const getXatabRepack = (url: string) => {
       const { document } = window;
 
       const $uploadDate = document.querySelector(".entry__date");
-      const $size = document.querySelector(".entry__info-size");
 
       const $downloadButton = document.querySelector(
         ".download-torrent"
@@ -42,17 +42,13 @@ const getXatabRepack = (url: string) => {
 
       if (!$downloadButton) throw new Error("Download button not found");
 
-      const onMessage = (torrent: Instance) => {
+      worker.once("message", (torrent: Instance) => {
         resolve({
-          fileSize: formatXatabDownloadSize($size.textContent).toUpperCase(),
+          fileSize: formatBytes(torrent.length ?? 0),
           magnet: toMagnetURI(torrent),
-          uploadDate: formatXatabDate($uploadDate.textContent),
+          uploadDate: formatXatabDate($uploadDate!.textContent!),
         });
-
-        worker.removeListener("message", onMessage);
-      };
-
-      worker.once("message", onMessage);
+      });
     })();
   });
 };
@@ -65,7 +61,7 @@ export const getNewRepacksFromXatab = async (
 
   const { window } = new JSDOM(data);
 
-  const repacks = [];
+  const repacks: QueryDeepPartialEntity<Repack>[] = [];
 
   for (const $a of Array.from(
     window.document.querySelectorAll(".entry__title a")
@@ -74,7 +70,7 @@ export const getNewRepacksFromXatab = async (
       const repack = await getXatabRepack(($a as HTMLAnchorElement).href);
 
       repacks.push({
-        title: $a.textContent,
+        title: $a.textContent!,
         repacker: "Xatab",
         ...repack,
         page,

src/main/services/steam-grid.ts

@@ -1,3 +1,4 @@
+import axios from "axios";
 import { getSteamAppAsset } from "@main/helpers";
 
 export interface SteamGridResponse {
@@ -27,33 +28,35 @@ export const getSteamGridData = async (
 ): Promise<SteamGridResponse> => {
   const searchParams = new URLSearchParams(params);
 
-  const response = await fetch(
+  if (!import.meta.env.MAIN_VITE_STEAMGRIDDB_API_KEY) {
+    throw new Error("STEAMGRIDDB_API_KEY is not set");
+  }
+
+  const response = await axios.get(
     `https://www.steamgriddb.com/api/v2/${path}/${shop}/${objectID}?${searchParams.toString()}`,
     {
-      method: "GET",
       headers: {
         Authorization: `Bearer ${import.meta.env.MAIN_VITE_STEAMGRIDDB_API_KEY}`,
       },
     }
   );
 
-  return response.json();
+  return response.data;
 };
 
 export const getSteamGridGameById = async (
   id: number
 ): Promise<SteamGridGameResponse> => {
-  const response = await fetch(
+  const response = await axios.get(
     `https://www.steamgriddb.com/api/public/game/${id}`,
     {
-      method: "GET",
       headers: {
         Referer: "https://www.steamgriddb.com/",
       },
     }
   );
 
-  return response.json();
+  return response.data;
 };
 
 export const getSteamGameIconUrl = async (objectID: string) => {

src/main/services/torrent-client.ts

@@ -1,169 +0,0 @@
-import path from "node:path";
-import cp from "node:child_process";
-import fs from "node:fs";
-import * as Sentry from "@sentry/electron/main";
-import { Notification, app, dialog } from "electron";
-import type { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
-
-import { Game } from "@main/entity";
-import { gameRepository, userPreferencesRepository } from "@main/repository";
-import { t } from "i18next";
-import { WindowManager } from "./window-manager";
-
-const binaryNameByPlatform: Partial<Record<NodeJS.Platform, string>> = {
-  darwin: "hydra-download-manager",
-  linux: "hydra-download-manager",
-  win32: "hydra-download-manager.exe",
-};
-
-enum TorrentState {
-  CheckingFiles = 1,
-  DownloadingMetadata = 2,
-  Downloading = 3,
-  Finished = 4,
-  Seeding = 5,
-}
-
-export interface TorrentUpdate {
-  gameId: number;
-  progress: number;
-  downloadSpeed: number;
-  timeRemaining: number;
-  numPeers: number;
-  numSeeds: number;
-  status: TorrentState;
-  folderName: string;
-  fileSize: number;
-  bytesDownloaded: number;
-}
-
-export const BITTORRENT_PORT = "5881";
-
-export class TorrentClient {
-  public static startTorrentClient(
-    writePipePath: string,
-    readPipePath: string
-  ) {
-    const commonArgs = [BITTORRENT_PORT, writePipePath, readPipePath];
-
-    if (app.isPackaged) {
-      const binaryName = binaryNameByPlatform[process.platform]!;
-      const binaryPath = path.join(
-        process.resourcesPath,
-        "hydra-download-manager",
-        binaryName
-      );
-
-      if (!fs.existsSync(binaryPath)) {
-        dialog.showErrorBox(
-          "Fatal",
-          "Hydra download manager binary not found. Please check if it has been removed by Windows Defender."
-        );
-
-        app.quit();
-      }
-
-      cp.spawn(binaryPath, commonArgs, {
-        stdio: "inherit",
-        windowsHide: true,
-      });
-      return;
-    }
-
-    const scriptPath = path.join(
-      __dirname,
-      "..",
-      "..",
-      "torrent-client",
-      "main.py"
-    );
-
-    cp.spawn("python3", [scriptPath, ...commonArgs], {
-      stdio: "inherit",
-    });
-  }
-
-  private static getTorrentStateName(state: TorrentState) {
-    if (state === TorrentState.CheckingFiles) return "checking_files";
-    if (state === TorrentState.Downloading) return "downloading";
-    if (state === TorrentState.DownloadingMetadata)
-      return "downloading_metadata";
-    if (state === TorrentState.Finished) return "finished";
-    if (state === TorrentState.Seeding) return "seeding";
-    return "";
-  }
-
-  private static getGameProgress(game: Game) {
-    if (game.status === "checking_files") return game.fileVerificationProgress;
-    return game.progress;
-  }
-
-  public static async onSocketData(data: Buffer) {
-    const message = Buffer.from(data).toString("utf-8");
-
-    try {
-      const payload = JSON.parse(message) as TorrentUpdate;
-
-      const updatePayload: QueryDeepPartialEntity<Game> = {
-        bytesDownloaded: payload.bytesDownloaded,
-        status: this.getTorrentStateName(payload.status),
-      };
-
-      if (payload.status === TorrentState.CheckingFiles) {
-        updatePayload.fileVerificationProgress = payload.progress;
-      } else {
-        if (payload.folderName) {
-          updatePayload.folderName = payload.folderName;
-          updatePayload.fileSize = payload.fileSize;
-        }
-      }
-
-      if (
-        [TorrentState.Downloading, TorrentState.Seeding].includes(
-          payload.status
-        )
-      ) {
-        updatePayload.progress = payload.progress;
-      }
-
-      await gameRepository.update({ id: payload.gameId }, updatePayload);
-
-      const game = await gameRepository.findOne({
-        where: { id: payload.gameId },
-        relations: { repack: true },
-      });
-
-      if (game?.progress === 1) {
-        const userPreferences = await userPreferencesRepository.findOne({
-          where: { id: 1 },
-        });
-
-        if (userPreferences?.downloadNotificationsEnabled) {
-          new Notification({
-            title: t("download_complete", {
-              ns: "notifications",
-              lng: userPreferences.language,
-            }),
-            body: t("game_ready_to_install", {
-              ns: "notifications",
-              lng: userPreferences.language,
-              title: game.title,
-            }),
-          }).show();
-        }
-      }
-
-      if (WindowManager.mainWindow && game) {
-        const progress = this.getGameProgress(game);
-        WindowManager.mainWindow.setProgressBar(progress === 1 ? -1 : progress);
-
-        WindowManager.mainWindow.webContents.send(
-          "on-download-progress",
-          JSON.parse(JSON.stringify({ ...payload, game }))
-        );
-      }
-    } catch (err) {
-      Sentry.captureException(err);
-    }
-  }
-}

src/main/services/window-manager.ts

@@ -105,7 +105,7 @@ export class WindowManager {
     tray.setToolTip("Hydra");
     tray.setContextMenu(contextMenu);
 
-    if (process.platform === "win32") {
+    if (process.platform === "win32" || process.platform === "linux") {
       tray.addListener("click", () => {
         if (this.mainWindow) {
           if (WindowManager.mainWindow?.isMinimized())