Merge remote-tracking branch 'origin/main' into feature/reset-achievements

src/main/data-source.ts

@@ -1,10 +1,8 @@
 import { DataSource } from "typeorm";
 import {
   DownloadQueue,
-  DownloadSource,
   Game,
   GameShopCache,
-  Repack,
   UserPreferences,
   UserAuth,
   GameAchievement,
@@ -17,12 +15,10 @@ export const dataSource = new DataSource({
   type: "better-sqlite3",
   entities: [
     Game,
-    Repack,
     UserAuth,
     UserPreferences,
     UserSubscription,
     GameShopCache,
-    DownloadSource,
     DownloadQueue,
     GameAchievement,
   ],

src/main/entity/download-source.entity.ts

@@ -1,41 +0,0 @@
-import {
-  Entity,
-  PrimaryGeneratedColumn,
-  Column,
-  CreateDateColumn,
-  UpdateDateColumn,
-  OneToMany,
-} from "typeorm";
-import type { Repack } from "./repack.entity";
-
-import { DownloadSourceStatus } from "@shared";
-
-@Entity("download_source")
-export class DownloadSource {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column("text", { nullable: true, unique: true })
-  url: string;
-
-  @Column("text")
-  name: string;
-
-  @Column("text", { nullable: true })
-  etag: string | null;
-
-  @Column("int", { default: 0 })
-  downloadCount: number;
-
-  @Column("text", { default: DownloadSourceStatus.UpToDate })
-  status: DownloadSourceStatus;
-
-  @OneToMany("Repack", "downloadSource", { cascade: true })
-  repacks: Repack[];
-
-  @CreateDateColumn()
-  createdAt: Date;
-
-  @UpdateDateColumn()
-  updatedAt: Date;
-}

src/main/entity/game.entity.ts

@@ -5,9 +5,7 @@ import {
   CreateDateColumn,
   UpdateDateColumn,
   OneToOne,
-  JoinColumn,
 } from "typeorm";
-import { Repack } from "./repack.entity";
 
 import type { GameShop, GameStatus } from "@types";
 import { Downloader } from "@shared";
@@ -39,6 +37,9 @@ export class Game {
   @Column("text", { nullable: true })
   executablePath: string | null;
 
+  @Column("text", { nullable: true })
+  launchOptions: string | null;
+
   @Column("text", { nullable: true })
   winePrefixPath: string | null;
 
@@ -72,19 +73,15 @@ export class Game {
   @Column("text", { nullable: true })
   uri: string | null;
 
-  /**
-   * @deprecated
-   */
-  @OneToOne("Repack", "game", { nullable: true })
-  @JoinColumn()
-  repack: Repack;
-
   @OneToOne("DownloadQueue", "game")
   downloadQueue: DownloadQueue;
 
   @Column("boolean", { default: false })
   isDeleted: boolean;
 
+  @Column("boolean", { default: false })
+  shouldSeed: boolean;
+
   @CreateDateColumn()
   createdAt: Date;
 

src/main/entity/index.ts

@@ -1,10 +1,8 @@
 export * from "./game.entity";
-export * from "./repack.entity";
 export * from "./user-auth.entity";
 export * from "./user-preferences.entity";
 export * from "./user-subscription.entity";
 export * from "./game-shop-cache.entity";
 export * from "./game.entity";
 export * from "./game-achievements.entity";
-export * from "./download-source.entity";
 export * from "./download-queue.entity";

src/main/entity/repack.entity.ts

@@ -1,45 +0,0 @@
-import {
-  Entity,
-  PrimaryGeneratedColumn,
-  Column,
-  CreateDateColumn,
-  UpdateDateColumn,
-  ManyToOne,
-} from "typeorm";
-import { DownloadSource } from "./download-source.entity";
-
-@Entity("repack")
-export class Repack {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column("text", { unique: true })
-  title: string;
-
-  /**
-   * @deprecated Use uris instead
-   */
-  @Column("text", { unique: true })
-  magnet: string;
-
-  @Column("text")
-  repacker: string;
-
-  @Column("text")
-  fileSize: string;
-
-  @Column("datetime")
-  uploadDate: Date | string;
-
-  @ManyToOne(() => DownloadSource, { nullable: true, onDelete: "CASCADE" })
-  downloadSource: DownloadSource;
-
-  @Column("text", { default: "[]" })
-  uris: string;
-
-  @CreateDateColumn()
-  createdAt: Date;
-
-  @UpdateDateColumn()
-  updatedAt: Date;
-}

src/main/entity/user-preferences.entity.ts

@@ -41,6 +41,12 @@ export class UserPreferences {
   @Column("boolean", { default: false })
   disableNsfwAlert: boolean;
 
+  @Column("boolean", { default: true })
+  seedAfterDownloadComplete: boolean;
+
+  @Column("boolean", { default: false })
+  showHiddenAchievementsDescription: boolean;
+
   @CreateDateColumn()
   createdAt: Date;
 

src/main/events/auth/get-session-hash.ts

@@ -9,6 +9,8 @@ const getSessionHash = async (_event: Electron.IpcMainInvokeEvent) => {
   if (!auth) return null;
   const payload = jwt.decode(auth.accessToken) as jwt.JwtPayload;
 
+  if (!payload) return null;
+
   return payload.sessionId;
 };
 

src/main/events/auth/sign-out.ts

@@ -1,12 +1,8 @@
 import { registerEvent } from "../register-event";
-import {
-  DownloadManager,
-  HydraApi,
-  PythonInstance,
-  gamesPlaytime,
-} from "@main/services";
+import { DownloadManager, HydraApi, gamesPlaytime } from "@main/services";
 import { dataSource } from "@main/data-source";
 import { DownloadQueue, Game, UserAuth, UserSubscription } from "@main/entity";
+import { PythonRPC } from "@main/services/python-rpc";
 
 const signOut = async (_event: Electron.IpcMainInvokeEvent) => {
   const databaseOperations = dataSource
@@ -32,7 +28,7 @@ const signOut = async (_event: Electron.IpcMainInvokeEvent) => {
   DownloadManager.cancelDownload();
 
   /* Disconnects libtorrent */
-  PythonInstance.killTorrent();
+  PythonRPC.kill();
 
   HydraApi.handleSignOut();
 

src/main/events/catalogue/get-catalogue.ts

@@ -1,9 +1,6 @@
-import type { GameShop } from "@types";
-
 import { registerEvent } from "../register-event";
 import { HydraApi } from "@main/services";
-import { CatalogueCategory, steamUrlBuilder } from "@shared";
-import { steamGamesWorker } from "@main/workers";
+import { CatalogueCategory } from "@shared";
 
 const getCatalogue = async (
   _event: Electron.IpcMainInvokeEvent,
@@ -14,26 +11,11 @@ const getCatalogue = async (
     skip: "0",
   });
 
-  const response = await HydraApi.get<{ objectId: string; shop: GameShop }[]>(
+  return HydraApi.get(
     `/catalogue/${category}?${params.toString()}`,
     {},
     { needsAuth: false }
   );
-
-  return Promise.all(
-    response.map(async (game) => {
-      const steamGame = await steamGamesWorker.run(Number(game.objectId), {
-        name: "getById",
-      });
-
-      return {
-        title: steamGame.name,
-        shop: game.shop,
-        cover: steamUrlBuilder.library(game.objectId),
-        objectId: game.objectId,
-      };
-    })
-  );
 };
 
 registerEvent("getCatalogue", getCatalogue);

src/main/events/catalogue/get-developers.ts

@@ -0,0 +1,10 @@
+import { HydraApi } from "@main/services";
+import { registerEvent } from "../register-event";
+
+const getDevelopers = async (_event: Electron.IpcMainInvokeEvent) => {
+  return HydraApi.get<string[]>(`/catalogue/developers`, null, {
+    needsAuth: false,
+  });
+};
+
+registerEvent("getDevelopers", getDevelopers);

src/main/events/catalogue/get-games.ts

@@ -1,29 +0,0 @@
-import type { CatalogueEntry } from "@types";
-
-import { registerEvent } from "../register-event";
-import { HydraApi } from "@main/services";
-import { steamUrlBuilder } from "@shared";
-
-const getGames = async (
-  _event: Electron.IpcMainInvokeEvent,
-  take = 12,
-  skip = 0
-): Promise<CatalogueEntry[]> => {
-  const searchParams = new URLSearchParams({
-    take: take.toString(),
-    skip: skip.toString(),
-  });
-
-  const games = await HydraApi.get<CatalogueEntry[]>(
-    `/games/catalogue?${searchParams.toString()}`,
-    undefined,
-    { needsAuth: false }
-  );
-
-  return games.map((game) => ({
-    ...game,
-    cover: steamUrlBuilder.library(game.objectId),
-  }));
-};
-
-registerEvent("getGames", getGames);

src/main/events/catalogue/get-publishers.ts

@@ -0,0 +1,10 @@
+import { HydraApi } from "@main/services";
+import { registerEvent } from "../register-event";
+
+const getPublishers = async (_event: Electron.IpcMainInvokeEvent) => {
+  return HydraApi.get<string[]>(`/catalogue/publishers`, null, {
+    needsAuth: false,
+  });
+};
+
+registerEvent("getPublishers", getPublishers);

src/main/events/catalogue/search-games.ts

@@ -1,23 +1,18 @@
+import type { CatalogueSearchPayload } from "@types";
 import { registerEvent } from "../register-event";
-import { convertSteamGameToCatalogueEntry } from "../helpers/search-games";
-import type { CatalogueEntry } from "@types";
 import { HydraApi } from "@main/services";
 
-const searchGamesEvent = async (
+const searchGames = async (
   _event: Electron.IpcMainInvokeEvent,
-  query: string
-): Promise<CatalogueEntry[]> => {
-  const games = await HydraApi.get<
-    { objectId: string; title: string; shop: string }[]
-  >("/games/search", { title: query, take: 12, skip: 0 }, { needsAuth: false });
-
-  return games.map((game) => {
-    return convertSteamGameToCatalogueEntry({
-      id: Number(game.objectId),
-      name: game.title,
-      clientIcon: null,
-    });
-  });
+  payload: CatalogueSearchPayload,
+  take: number,
+  skip: number
+) => {
+  return HydraApi.post(
+    "/catalogue/search",
+    { ...payload, take, skip },
+    { needsAuth: false }
+  );
 };
 
-registerEvent("searchGames", searchGamesEvent);
+registerEvent("searchGames", searchGames);

src/main/events/cloud-save/get-game-artifacts.ts

@@ -1,6 +1,7 @@
 import { HydraApi } from "@main/services";
 import { registerEvent } from "../register-event";
 import type { GameArtifact, GameShop } from "@types";
+import { SubscriptionRequiredError, UserNotLoggedInError } from "@shared";
 
 const getGameArtifacts = async (
   _event: Electron.IpcMainInvokeEvent,
@@ -13,8 +14,20 @@ const getGameArtifacts = async (
   });
 
   return HydraApi.get<GameArtifact[]>(
-    `/profile/games/artifacts?${params.toString()}`
-  );
+    `/profile/games/artifacts?${params.toString()}`,
+    {},
+    { needsSubscription: true }
+  ).catch((err) => {
+    if (err instanceof SubscriptionRequiredError) {
+      return [];
+    }
+
+    if (err instanceof UserNotLoggedInError) {
+      return [];
+    }
+
+    throw err;
+  });
 };
 
 registerEvent("getGameArtifacts", getGameArtifacts);

src/main/events/cloud-save/upload-save-game.ts

@@ -89,7 +89,7 @@ const uploadSaveGame = async (
           "Content-Type": "application/tar",
         },
         onUploadProgress: (progressEvent) => {
-          console.log(progressEvent);
+          logger.log(progressEvent);
         },
       });
 

src/main/events/download-sources/delete-download-source.ts

@@ -1,9 +0,0 @@
-import { registerEvent } from "../register-event";
-import { knexClient } from "@main/knex-client";
-
-const deleteDownloadSource = async (
-  _event: Electron.IpcMainInvokeEvent,
-  id: number
-) => knexClient("download_source").where({ id }).delete();
-
-registerEvent("deleteDownloadSource", deleteDownloadSource);

src/main/events/download-sources/get-download-sources.ts

@@ -1,7 +0,0 @@
-import { registerEvent } from "../register-event";
-import { knexClient } from "@main/knex-client";
-
-const getDownloadSources = async (_event: Electron.IpcMainInvokeEvent) =>
-  knexClient.select("*").from("download_source");
-
-registerEvent("getDownloadSources", getDownloadSources);

src/main/events/download-sources/put-download-source.ts

@@ -0,0 +1,17 @@
+import { HydraApi } from "@main/services";
+import { registerEvent } from "../register-event";
+
+const putDownloadSource = async (
+  _event: Electron.IpcMainInvokeEvent,
+  objectIds: string[]
+) => {
+  return HydraApi.put<{ fingerprint: string }>(
+    "/download-sources",
+    {
+      objectIds,
+    },
+    { needsAuth: false }
+  );
+};
+
+registerEvent("putDownloadSource", putDownloadSource);

src/main/events/hardware/check-folder-write-permission.ts

@@ -0,0 +1,15 @@
+import fs from "node:fs";
+
+import { registerEvent } from "../register-event";
+
+const checkFolderWritePermission = async (
+  _event: Electron.IpcMainInvokeEvent,
+  path: string
+) =>
+  new Promise((resolve) => {
+    fs.access(path, fs.constants.W_OK, (err) => {
+      resolve(!err);
+    });
+  });
+
+registerEvent("checkFolderWritePermission", checkFolderWritePermission);

src/main/events/hardware/get-disk-free-space.ts

@@ -1,10 +1,10 @@
-import checkDiskSpace from "check-disk-space";
+import disk from "diskusage";
 
 import { registerEvent } from "../register-event";
 
 const getDiskFreeSpace = async (
   _event: Electron.IpcMainInvokeEvent,
   path: string
-) => checkDiskSpace(path);
+) => disk.check(path);
 
 registerEvent("getDiskFreeSpace", getDiskFreeSpace);

src/main/events/helpers/search-games.ts

@@ -1,31 +0,0 @@
-import type { GameShop, CatalogueEntry, SteamGame } from "@types";
-
-import { steamGamesWorker } from "@main/workers";
-import { steamUrlBuilder } from "@shared";
-
-export interface SearchGamesArgs {
-  query?: string;
-  take?: number;
-  skip?: number;
-}
-
-export const convertSteamGameToCatalogueEntry = (
-  game: SteamGame
-): CatalogueEntry => ({
-  objectId: String(game.id),
-  title: game.name,
-  shop: "steam" as GameShop,
-  cover: steamUrlBuilder.library(String(game.id)),
-});
-
-export const getSteamGameById = async (
-  objectId: string
-): Promise<CatalogueEntry | null> => {
-  const steamGame = await steamGamesWorker.run(Number(objectId), {
-    name: "getById",
-  });
-
-  if (!steamGame) return null;
-
-  return convertSteamGameToCatalogueEntry(steamGame);
-};

src/main/events/index.ts

@@ -3,13 +3,15 @@ import { ipcMain } from "electron";
 
 import "./catalogue/get-catalogue";
 import "./catalogue/get-game-shop-details";
-import "./catalogue/get-games";
 import "./catalogue/get-how-long-to-beat";
 import "./catalogue/get-random-game";
 import "./catalogue/search-games";
 import "./catalogue/get-game-stats";
 import "./catalogue/get-trending-games";
+import "./catalogue/get-publishers";
+import "./catalogue/get-developers";
 import "./hardware/get-disk-free-space";
+import "./hardware/check-folder-write-permission";
 import "./library/add-game-to-library";
 import "./library/create-game-shortcut";
 import "./library/close-game";
@@ -21,6 +23,7 @@ import "./library/open-game-executable-path";
 import "./library/open-game-installer";
 import "./library/open-game-installer-path";
 import "./library/update-executable-path";
+import "./library/update-launch-options";
 import "./library/verify-executable-path";
 import "./library/remove-game";
 import "./library/remove-game-from-library";
@@ -29,18 +32,21 @@ import "./library/reset-game-achievements";
 import "./misc/open-checkout";
 import "./misc/open-external";
 import "./misc/show-open-dialog";
+import "./misc/get-features";
+import "./misc/show-item-in-folder";
 import "./torrenting/cancel-game-download";
 import "./torrenting/pause-game-download";
 import "./torrenting/resume-game-download";
 import "./torrenting/start-game-download";
+import "./torrenting/pause-game-seed";
+import "./torrenting/resume-game-seed";
 import "./user-preferences/get-user-preferences";
 import "./user-preferences/update-user-preferences";
 import "./user-preferences/auto-launch";
 import "./autoupdater/check-for-updates";
 import "./autoupdater/restart-and-install-update";
 import "./user-preferences/authenticate-real-debrid";
-import "./download-sources/delete-download-source";
-import "./download-sources/get-download-sources";
+import "./download-sources/put-download-source";
 import "./auth/sign-out";
 import "./auth/open-auth-window";
 import "./auth/get-session-hash";
@@ -69,7 +75,6 @@ import "./cloud-save/delete-game-artifact";
 import "./cloud-save/select-game-backup-path";
 import "./notifications/publish-new-repacks-notification";
 import { isPortableVersion } from "@main/helpers";
-import "./misc/show-item-in-folder";
 
 ipcMain.handle("ping", () => "pong");
 ipcMain.handle("getVersion", () => appVersion);

src/main/events/library/close-game.ts

@@ -1,8 +1,10 @@
 import { gameRepository } from "@main/repository";
 import { registerEvent } from "../register-event";
-import { PythonInstance, logger } from "@main/services";
+import { logger } from "@main/services";
 import sudo from "sudo-prompt";
 import { app } from "electron";
+import { PythonRPC } from "@main/services/python-rpc";
+import { ProcessPayload } from "@main/services/download/types";
 
 const getKillCommand = (pid: number) => {
   if (process.platform == "win32") {
@@ -16,7 +18,10 @@ const closeGame = async (
   _event: Electron.IpcMainInvokeEvent,
   gameId: number
 ) => {
-  const processes = await PythonInstance.getProcessList();
+  const processes =
+    (await PythonRPC.rpc.get<ProcessPayload[] | null>("/process-list")).data ||
+    [];
+
   const game = await gameRepository.findOne({
     where: { id: gameId, isDeleted: false },
   });

src/main/events/library/open-game.ts

@@ -7,11 +7,16 @@ import { parseExecutablePath } from "../helpers/parse-executable-path";
 const openGame = async (
   _event: Electron.IpcMainInvokeEvent,
   gameId: number,
-  executablePath: string
+  executablePath: string,
+  launchOptions: string | null
 ) => {
+  // TODO: revisit this for launchOptions
   const parsedPath = parseExecutablePath(executablePath);
 
-  await gameRepository.update({ id: gameId }, { executablePath: parsedPath });
+  await gameRepository.update(
+    { id: gameId },
+    { executablePath: parsedPath, launchOptions }
+  );
 
   shell.openPath(parsedPath);
 };

src/main/events/library/update-launch-options.ts

@@ -0,0 +1,19 @@
+import { gameRepository } from "@main/repository";
+import { registerEvent } from "../register-event";
+
+const updateLaunchOptions = async (
+  _event: Electron.IpcMainInvokeEvent,
+  id: number,
+  launchOptions: string | null
+) => {
+  return gameRepository.update(
+    {
+      id,
+    },
+    {
+      launchOptions: launchOptions?.trim() != "" ? launchOptions : null,
+    }
+  );
+};
+
+registerEvent("updateLaunchOptions", updateLaunchOptions);

src/main/events/misc/get-features.ts

@@ -0,0 +1,8 @@
+import { registerEvent } from "../register-event";
+import { HydraApi } from "@main/services";
+
+const getFeatures = async (_event: Electron.IpcMainInvokeEvent) => {
+  return HydraApi.get<string[]>("/features", null, { needsAuth: false });
+};
+
+registerEvent("getFeatures", getFeatures);

src/main/events/misc/open-checkout.ts

@@ -1,16 +1,10 @@
 import { shell } from "electron";
 import { registerEvent } from "../register-event";
-import {
-  userAuthRepository,
-  userPreferencesRepository,
-} from "@main/repository";
+import { userAuthRepository } from "@main/repository";
 import { HydraApi } from "@main/services";
 
 const openCheckout = async (_event: Electron.IpcMainInvokeEvent) => {
-  const [userAuth, userPreferences] = await Promise.all([
-    userAuthRepository.findOne({ where: { id: 1 } }),
-    userPreferencesRepository.findOne({ where: { id: 1 } }),
-  ]);
+  const userAuth = await userAuthRepository.findOne({ where: { id: 1 } });
 
   if (!userAuth) {
     return;
@@ -22,7 +16,6 @@ const openCheckout = async (_event: Electron.IpcMainInvokeEvent) => {
 
   const params = new URLSearchParams({
     token: paymentToken,
-    lng: userPreferences?.language || "en",
   });
 
   shell.openExternal(

src/main/events/profile/process-profile-image.ts

@@ -1,11 +1,16 @@
 import { registerEvent } from "../register-event";
-import { PythonInstance } from "@main/services";
+import { PythonRPC } from "@main/services/python-rpc";
 
 const processProfileImage = async (
   _event: Electron.IpcMainInvokeEvent,
   path: string
 ) => {
-  return PythonInstance.processProfileImage(path);
+  return PythonRPC.rpc
+    .post<{
+      imagePath: string;
+      mimeType: string;
+    }>("/profile-image", { image_path: path })
+    .then((response) => response.data);
 };
 
 registerEvent("processProfileImage", processProfileImage);

src/main/events/torrenting/pause-game-seed.ts

@@ -0,0 +1,17 @@
+import { registerEvent } from "../register-event";
+import { DownloadManager } from "@main/services";
+import { gameRepository } from "@main/repository";
+
+const pauseGameSeed = async (
+  _event: Electron.IpcMainInvokeEvent,
+  gameId: number
+) => {
+  await gameRepository.update(gameId, {
+    status: "complete",
+    shouldSeed: false,
+  });
+
+  await DownloadManager.pauseSeeding(gameId);
+};
+
+registerEvent("pauseGameSeed", pauseGameSeed);

src/main/events/torrenting/resume-game-seed.ts

@@ -0,0 +1,29 @@
+import { registerEvent } from "../register-event";
+import { gameRepository } from "../../repository";
+import { DownloadManager } from "@main/services";
+import { Downloader } from "@shared";
+
+const resumeGameSeed = async (
+  _event: Electron.IpcMainInvokeEvent,
+  gameId: number
+) => {
+  const game = await gameRepository.findOne({
+    where: {
+      id: gameId,
+      isDeleted: false,
+      downloader: Downloader.Torrent,
+      progress: 1,
+    },
+  });
+
+  if (!game) return;
+
+  await gameRepository.update(gameId, {
+    status: "seeding",
+    shouldSeed: true,
+  });
+
+  await DownloadManager.resumeSeeding(game);
+};
+
+registerEvent("resumeGameSeed", resumeGameSeed);

src/main/events/torrenting/start-game-download.ts

@@ -1,6 +1,6 @@
 import { registerEvent } from "../register-event";
 import type { StartGameDownloadPayload } from "@types";
-import { DownloadManager, HydraApi, logger } from "@main/services";
+import { DownloadManager, HydraApi } from "@main/services";
 
 import { Not } from "typeorm";
 import { steamGamesWorker } from "@main/workers";
@@ -76,24 +76,23 @@ const startGameDownload = async (
       },
     });
 
-    createGame(updatedGame!).catch(() => {});
-
-    HydraApi.post(
-      "/games/download",
-      {
-        objectId: updatedGame!.objectID,
-        shop: updatedGame!.shop,
-      },
-      { needsAuth: false }
-    ).catch((err) => {
-      logger.error("Failed to create game download", err);
-    });
-
     await DownloadManager.cancelDownload(updatedGame!.id);
     await DownloadManager.startDownload(updatedGame!);
 
     await downloadQueueRepository.delete({ game: { id: updatedGame!.id } });
     await downloadQueueRepository.insert({ game: { id: updatedGame!.id } });
+
+    await Promise.all([
+      createGame(updatedGame!).catch(() => {}),
+      HydraApi.post(
+        "/games/download",
+        {
+          objectId: updatedGame!.objectID,
+          shop: updatedGame!.shop,
+        },
+        { needsAuth: false }
+      ).catch(() => {}),
+    ]);
   });
 };
 

src/main/events/user-preferences/authenticate-real-debrid.ts

@@ -1,4 +1,4 @@
-import { RealDebridClient } from "@main/services/real-debrid";
+import { RealDebridClient } from "@main/services/download/real-debrid";
 import { registerEvent } from "../register-event";
 
 const authenticateRealDebrid = async (

src/main/events/user/get-compared-unlocked-achievements.ts

@@ -13,6 +13,9 @@ const getComparedUnlockedAchievements = async (
     where: { id: 1 },
   });
 
+  const showHiddenAchievementsDescription =
+    userPreferences?.showHiddenAchievementsDescription || false;
+
   return HydraApi.get<ComparedAchievements>(
     `/users/${userId}/games/achievements/compare`,
     {
@@ -21,15 +24,35 @@ const getComparedUnlockedAchievements = async (
       language: userPreferences?.language || "en",
     }
   ).then((achievements) => {
-    const sortedAchievements = achievements.achievements.sort((a, b) => {
-      if (a.targetStat.unlocked && !b.targetStat.unlocked) return -1;
-      if (!a.targetStat.unlocked && b.targetStat.unlocked) return 1;
-      if (a.targetStat.unlocked && b.targetStat.unlocked) {
-        return b.targetStat.unlockTime! - a.targetStat.unlockTime!;
-      }
+    const sortedAchievements = achievements.achievements
+      .sort((a, b) => {
+        if (a.targetStat.unlocked && !b.targetStat.unlocked) return -1;
+        if (!a.targetStat.unlocked && b.targetStat.unlocked) return 1;
+        if (a.targetStat.unlocked && b.targetStat.unlocked) {
+          return b.targetStat.unlockTime! - a.targetStat.unlockTime!;
+        }
 
-      return Number(a.hidden) - Number(b.hidden);
-    });
+        return Number(a.hidden) - Number(b.hidden);
+      })
+      .map((achievement) => {
+        if (!achievement.hidden) return achievement;
+
+        if (!achievement.ownerStat) {
+          return {
+            ...achievement,
+            description: "",
+          };
+        }
+
+        if (!showHiddenAchievementsDescription && achievement.hidden) {
+          return {
+            ...achievement,
+            description: "",
+          };
+        }
+
+        return achievement;
+      });
 
     return {
       ...achievements,

src/main/events/user/get-unlocked-achievements.ts

@@ -1,6 +1,9 @@
 import type { GameShop, UnlockedAchievement, UserAchievement } from "@types";
 import { registerEvent } from "../register-event";
-import { gameAchievementRepository } from "@main/repository";
+import {
+  gameAchievementRepository,
+  userPreferencesRepository,
+} from "@main/repository";
 import { getGameAchievementData } from "@main/services/achievements/get-game-achievement-data";
 
 export const getUnlockedAchievements = async (
@@ -12,10 +15,17 @@ export const getUnlockedAchievements = async (
     where: { objectId, shop },
   });
 
+  const userPreferences = await userPreferencesRepository.findOne({
+    where: { id: 1 },
+  });
+
+  const showHiddenAchievementsDescription =
+    userPreferences?.showHiddenAchievementsDescription || false;
+
   const achievementsData = await getGameAchievementData(
     objectId,
     shop,
-    useCachedData
+    useCachedData ? cachedAchievements : null
   );
 
   const unlockedAchievements = JSON.parse(
@@ -50,6 +60,10 @@ export const getUnlockedAchievements = async (
         unlocked: false,
         unlockTime: null,
         icongray: icongray,
+        description:
+          !achievementData.hidden || showHiddenAchievementsDescription
+            ? achievementData.description
+            : undefined,
       } as UserAchievement;
     })
     .sort((a, b) => {

src/main/events/user/get-user.ts

@@ -11,7 +11,7 @@ const getSteamGame = async (objectId: string) => {
     });
 
     return {
-      title: steamGame.name,
+      title: steamGame.name as string,
       iconUrl: steamUrlBuilder.icon(objectId, steamGame.clientIcon),
     };
   } catch (err) {
@@ -67,8 +67,25 @@ const getUser = async (
       }
     }
 
+    const friends = await Promise.all(
+      profile.friends.map(async (friend) => {
+        if (!friend.currentGame) return friend;
+
+        const currentGame = await getSteamGame(friend.currentGame.objectId);
+
+        return {
+          ...friend,
+          currentGame: {
+            ...friend.currentGame,
+            ...currentGame,
+          },
+        };
+      })
+    );
+
     return {
       ...profile,
+      friends,
       libraryGames,
       recentGames,
     };

src/main/index.ts

@@ -5,12 +5,14 @@ import path from "node:path";
 import url from "node:url";
 import fs from "node:fs";
 import { electronApp, optimizer } from "@electron-toolkit/utils";
-import { logger, PythonInstance, WindowManager } from "@main/services";
+import { logger, WindowManager } from "@main/services";
 import { dataSource } from "@main/data-source";
 import resources from "@locales";
 import { userPreferencesRepository } from "@main/repository";
 import { knexClient, migrationConfig } from "./knex-client";
 import { databaseDirectory } from "./constants";
+import { PythonRPC } from "./services/python-rpc";
+import { Aria2 } from "./services/aria2";
 
 const { autoUpdater } = updater;
 
@@ -146,7 +148,8 @@ app.on("window-all-closed", () => {
 
 app.on("before-quit", () => {
   /* Disconnects libtorrent */
-  PythonInstance.kill();
+  PythonRPC.kill();
+  Aria2.kill();
 });
 
 app.on("activate", () => {

src/main/knex-client.ts

@@ -13,6 +13,11 @@ import { AddBackgroundImageUrl } from "./migrations/20241016100249_add_backgroun
 import { AddWinePrefixToGame } from "./migrations/20241019081648_add_wine_prefix_to_game";
 import { AddStartMinimizedColumn } from "./migrations/20241030171454_add_start_minimized_column";
 import { AddDisableNsfwAlertColumn } from "./migrations/20241106053733_add_disable_nsfw_alert_column";
+import { AddShouldSeedColumn } from "./migrations/20241108200154_add_should_seed_colum";
+import { AddSeedAfterDownloadColumn } from "./migrations/20241108201806_add_seed_after_download";
+import { AddHiddenAchievementDescriptionColumn } from "./migrations/20241216140633_add_hidden_achievement_description_column ";
+import { AddLaunchOptionsColumnToGame } from "./migrations/20241226044022_add_launch_options_column_to_game";
+
 export type HydraMigration = Knex.Migration & { name: string };
 
 class MigrationSource implements Knex.MigrationSource<HydraMigration> {
@@ -30,6 +35,10 @@ class MigrationSource implements Knex.MigrationSource<HydraMigration> {
       AddWinePrefixToGame,
       AddStartMinimizedColumn,
       AddDisableNsfwAlertColumn,
+      AddShouldSeedColumn,
+      AddSeedAfterDownloadColumn,
+      AddHiddenAchievementDescriptionColumn,
+      AddLaunchOptionsColumnToGame,
     ]);
   }
   getMigrationName(migration: HydraMigration): string {

src/main/main.ts

@@ -1,21 +1,22 @@
-import {
-  DownloadManager,
-  Ludusavi,
-  PythonInstance,
-  startMainLoop,
-} from "./services";
+import { DownloadManager, Ludusavi, startMainLoop } from "./services";
 import {
   downloadQueueRepository,
+  gameRepository,
   userPreferencesRepository,
 } from "./repository";
 import { UserPreferences } from "./entity";
-import { RealDebridClient } from "./services/real-debrid";
+import { RealDebridClient } from "./services/download/real-debrid";
 import { HydraApi } from "./services/hydra-api";
 import { uploadGamesBatch } from "./services/library-sync";
+import { Aria2 } from "./services/aria2";
+import { Downloader } from "@shared";
+import { IsNull, Not } from "typeorm";
 
 const loadState = async (userPreferences: UserPreferences | null) => {
   import("./events");
 
+  Aria2.spawn();
+
   if (userPreferences?.realDebridApiToken) {
     RealDebridClient.authorize(userPreferences?.realDebridApiToken);
   }
@@ -35,11 +36,16 @@ const loadState = async (userPreferences: UserPreferences | null) => {
     },
   });
 
-  if (nextQueueItem?.game.status === "active") {
-    DownloadManager.startDownload(nextQueueItem.game);
-  } else {
-    PythonInstance.spawn();
-  }
+  const seedList = await gameRepository.find({
+    where: {
+      shouldSeed: true,
+      downloader: Downloader.Torrent,
+      progress: 1,
+      uri: Not(IsNull()),
+    },
+  });
+
+  await DownloadManager.startRPC(nextQueueItem?.game, seedList);
 
   startMainLoop();
 };

src/main/migrations/20241108200154_add_should_seed_colum.ts

@@ -0,0 +1,17 @@
+import type { HydraMigration } from "@main/knex-client";
+import type { Knex } from "knex";
+
+export const AddShouldSeedColumn: HydraMigration = {
+  name: "AddShouldSeedColumn",
+  up: (knex: Knex) => {
+    return knex.schema.alterTable("game", (table) => {
+      return table.boolean("shouldSeed").notNullable().defaultTo(true);
+    });
+  },
+
+  down: async (knex: Knex) => {
+    return knex.schema.alterTable("game", (table) => {
+      return table.dropColumn("shouldSeed");
+    });
+  },
+};

src/main/migrations/20241108201806_add_seed_after_download.ts

@@ -0,0 +1,20 @@
+import type { HydraMigration } from "@main/knex-client";
+import type { Knex } from "knex";
+
+export const AddSeedAfterDownloadColumn: HydraMigration = {
+  name: "AddSeedAfterDownloadColumn",
+  up: (knex: Knex) => {
+    return knex.schema.alterTable("user_preferences", (table) => {
+      return table
+        .boolean("seedAfterDownloadComplete")
+        .notNullable()
+        .defaultTo(true);
+    });
+  },
+
+  down: async (knex: Knex) => {
+    return knex.schema.alterTable("user_preferences", (table) => {
+      return table.dropColumn("seedAfterDownloadComplete");
+    });
+  },
+};

src/main/migrations/20241216140633_add_hidden_achievement_description_column .ts

@@ -0,0 +1,20 @@
+import type { HydraMigration } from "@main/knex-client";
+import type { Knex } from "knex";
+
+export const AddHiddenAchievementDescriptionColumn: HydraMigration = {
+  name: "AddHiddenAchievementDescriptionColumn",
+  up: (knex: Knex) => {
+    return knex.schema.alterTable("user_preferences", (table) => {
+      return table
+        .boolean("showHiddenAchievementsDescription")
+        .notNullable()
+        .defaultTo(0);
+    });
+  },
+
+  down: async (knex: Knex) => {
+    return knex.schema.alterTable("user_preferences", (table) => {
+      return table.dropColumn("showHiddenAchievementsDescription");
+    });
+  },
+};

src/main/migrations/20241226044022_add_launch_options_column_to_game.ts

@@ -0,0 +1,17 @@
+import type { HydraMigration } from "@main/knex-client";
+import type { Knex } from "knex";
+
+export const AddLaunchOptionsColumnToGame: HydraMigration = {
+  name: "AddLaunchOptionsColumnToGame",
+  up: (knex: Knex) => {
+    return knex.schema.alterTable("game", (table) => {
+      return table.string("launchOptions").nullable();
+    });
+  },
+
+  down: async (knex: Knex) => {
+    return knex.schema.alterTable("game", (table) => {
+      return table.dropColumn("launchOptions");
+    });
+  },
+};

src/main/repository.ts

@@ -1,10 +1,8 @@
 import { dataSource } from "./data-source";
 import {
   DownloadQueue,
-  DownloadSource,
   Game,
   GameShopCache,
-  Repack,
   UserPreferences,
   UserAuth,
   GameAchievement,
@@ -13,16 +11,11 @@ import {
 
 export const gameRepository = dataSource.getRepository(Game);
 
-export const repackRepository = dataSource.getRepository(Repack);
-
 export const userPreferencesRepository =
   dataSource.getRepository(UserPreferences);
 
 export const gameShopCacheRepository = dataSource.getRepository(GameShopCache);
 
-export const downloadSourceRepository =
-  dataSource.getRepository(DownloadSource);
-
 export const downloadQueueRepository = dataSource.getRepository(DownloadQueue);
 
 export const userAuthRepository = dataSource.getRepository(UserAuth);

src/main/scripts/get-games-icon-hash.ts

@@ -1,40 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-
-import { getSteamGameClientIcon, logger } from "@main/services";
-import { chunk } from "lodash-es";
-import { seedsPath } from "@main/constants";
-
-import type { SteamGame } from "@types";
-
-const steamGamesPath = path.join(seedsPath, "steam-games.json");
-
-const steamGames = JSON.parse(
-  fs.readFileSync(steamGamesPath, "utf-8")
-) as SteamGame[];
-
-const chunks = chunk(steamGames, 1500);
-
-for (const chunk of chunks) {
-  await Promise.all(
-    chunk.map(async (steamGame) => {
-      if (steamGame.clientIcon) return;
-
-      const index = steamGames.findIndex((game) => game.id === steamGame.id);
-
-      try {
-        const clientIcon = await getSteamGameClientIcon(String(steamGame.id));
-
-        steamGames[index].clientIcon = clientIcon;
-
-        logger.log("info", `Set ${steamGame.name} client icon`);
-      } catch (err) {
-        steamGames[index].clientIcon = null;
-        logger.log("info", `Could not set icon for ${steamGame.name}`);
-      }
-    })
-  );
-
-  fs.writeFileSync(steamGamesPath, JSON.stringify(steamGames));
-  logger.log("info", "Updated steam games");
-}

src/main/services/achievements/get-game-achievement-data.ts

@@ -6,20 +6,15 @@ import { HydraApi } from "../hydra-api";
 import type { AchievementData, GameShop } from "@types";
 import { UserNotLoggedInError } from "@shared";
 import { logger } from "../logger";
+import { GameAchievement } from "@main/entity";
 
 export const getGameAchievementData = async (
   objectId: string,
   shop: GameShop,
-  useCachedData: boolean
+  cachedAchievements: GameAchievement | null
 ) => {
-  if (useCachedData) {
-    const cachedAchievements = await gameAchievementRepository.findOne({
-      where: { objectId, shop },
-    });
-
-    if (cachedAchievements && cachedAchievements.achievements) {
-      return JSON.parse(cachedAchievements.achievements) as AchievementData[];
-    }
+  if (cachedAchievements && cachedAchievements.achievements) {
+    return JSON.parse(cachedAchievements.achievements) as AchievementData[];
   }
 
   const userPreferences = await userPreferencesRepository.findOne({

src/main/services/achievements/merge-achievements.ts

@@ -7,8 +7,9 @@ import { WindowManager } from "../window-manager";
 import { HydraApi } from "../hydra-api";
 import { getUnlockedAchievements } from "@main/events/user/get-unlocked-achievements";
 import { Game } from "@main/entity";
-import { achievementsLogger } from "../logger";
 import { publishNewAchievementNotification } from "../notifications";
+import { SubscriptionRequiredError } from "@shared";
+import { achievementsLogger } from "../logger";
 
 const saveAchievementsOnLocal = async (
   objectId: string,
@@ -120,10 +121,14 @@ export const mergeAchievements = async (
   }
 
   if (game.remoteId) {
-    await HydraApi.put("/profile/games/achievements", {
-      id: game.remoteId,
-      achievements: mergedLocalAchievements,
-    })
+    await HydraApi.put(
+      "/profile/games/achievements",
+      {
+        id: game.remoteId,
+        achievements: mergedLocalAchievements,
+      },
+      { needsSubscription: !newAchievements.length }
+    )
       .then((response) => {
         return saveAchievementsOnLocal(
           response.objectId,
@@ -133,7 +138,13 @@ export const mergeAchievements = async (
         );
       })
       .catch((err) => {
-        achievementsLogger.error(err);
+        if (err! instanceof SubscriptionRequiredError) {
+          achievementsLogger.log(
+            "Achievements not synchronized on API due to lack of subscription",
+            game.objectID,
+            game.title
+          );
+        }
 
         return saveAchievementsOnLocal(
           game.objectID,

src/main/services/aria2.ts

@@ -0,0 +1,30 @@
+import path from "node:path";
+import cp from "node:child_process";
+import { app } from "electron";
+
+export const startAria2 = () => {};
+
+export class Aria2 {
+  private static process: cp.ChildProcess | null = null;
+
+  public static spawn() {
+    const binaryPath = app.isPackaged
+      ? path.join(process.resourcesPath, "aria2", "aria2c")
+      : path.join(__dirname, "..", "..", "aria2", "aria2c");
+
+    this.process = cp.spawn(
+      binaryPath,
+      [
+        "--enable-rpc",
+        "--rpc-listen-all",
+        "--file-allocation=none",
+        "--allow-overwrite=true",
+      ],
+      { stdio: "inherit", windowsHide: true }
+    );
+  }
+
+  public static kill() {
+    this.process?.kill();
+  }
+}

src/main/services/download/download-manager.ts

@@ -1,39 +1,116 @@
 import { Game } from "@main/entity";
 import { Downloader } from "@shared";
-import { PythonInstance } from "./python-instance";
 import { WindowManager } from "../window-manager";
-import { downloadQueueRepository, gameRepository } from "@main/repository";
+import {
+  downloadQueueRepository,
+  gameRepository,
+  userPreferencesRepository,
+} from "@main/repository";
 import { publishDownloadCompleteNotification } from "../notifications";
-import { RealDebridDownloader } from "./real-debrid-downloader";
 import type { DownloadProgress } from "@types";
 import { GofileApi, QiwiApi } from "../hosters";
-import { GenericHttpDownloader } from "./generic-http-downloader";
+import { PythonRPC } from "../python-rpc";
+import {
+  LibtorrentPayload,
+  LibtorrentStatus,
+  PauseDownloadPayload,
+} from "./types";
+import { calculateETA, getDirSize } from "./helpers";
+import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+import { RealDebridClient } from "./real-debrid";
+import path from "path";
+import { logger } from "../logger";
 
 export class DownloadManager {
-  private static currentDownloader: Downloader | null = null;
   private static downloadingGameId: number | null = null;
 
-  public static async watchDownloads() {
-    let status: DownloadProgress | null = null;
+  public static async startRPC(game?: Game, initialSeeding?: Game[]) {
+    PythonRPC.spawn(
+      game?.status === "active"
+        ? await this.getDownloadPayload(game).catch(() => undefined)
+        : undefined,
+      initialSeeding?.map((game) => ({
+        game_id: game.id,
+        url: game.uri!,
+        save_path: game.downloadPath!,
+      }))
+    );
 
-    if (this.currentDownloader === Downloader.Torrent) {
-      status = await PythonInstance.getStatus();
-    } else if (this.currentDownloader === Downloader.RealDebrid) {
-      status = await RealDebridDownloader.getStatus();
-    } else {
-      status = await GenericHttpDownloader.getStatus();
+    this.downloadingGameId = game?.id ?? null;
+  }
+
+  private static async getDownloadStatus() {
+    const response = await PythonRPC.rpc.get<LibtorrentPayload | null>(
+      "/status"
+    );
+
+    if (response.data === null || !this.downloadingGameId) return null;
+
+    const gameId = this.downloadingGameId;
+
+    try {
+      const {
+        progress,
+        numPeers,
+        numSeeds,
+        downloadSpeed,
+        bytesDownloaded,
+        fileSize,
+        folderName,
+        status,
+      } = response.data;
+
+      const isDownloadingMetadata =
+        status === LibtorrentStatus.DownloadingMetadata;
+
+      const isCheckingFiles = status === LibtorrentStatus.CheckingFiles;
+
+      if (!isDownloadingMetadata && !isCheckingFiles) {
+        const update: QueryDeepPartialEntity<Game> = {
+          bytesDownloaded,
+          fileSize,
+          progress,
+          status: "active",
+        };
+
+        await gameRepository.update(
+          { id: gameId },
+          {
+            ...update,
+            folderName,
+          }
+        );
+      }
+
+      return {
+        numPeers,
+        numSeeds,
+        downloadSpeed,
+        timeRemaining: calculateETA(fileSize, bytesDownloaded, downloadSpeed),
+        isDownloadingMetadata,
+        isCheckingFiles,
+        progress,
+        gameId,
+      } as DownloadProgress;
+    } catch (err) {
+      return null;
     }
+  }
+
+  public static async watchDownloads() {
+    const status = await this.getDownloadStatus();
 
     if (status) {
       const { gameId, progress } = status;
-
       const game = await gameRepository.findOne({
         where: { id: gameId, isDeleted: false },
       });
+      const userPreferences = await userPreferencesRepository.findOneBy({
+        id: 1,
+      });
 
       if (WindowManager.mainWindow && game) {
         WindowManager.mainWindow.setProgressBar(progress === 1 ? -1 : progress);
-
         WindowManager.mainWindow.webContents.send(
           "on-download-progress",
           JSON.parse(
@@ -44,12 +121,27 @@ export class DownloadManager {
           )
         );
       }
-
       if (progress === 1 && game) {
         publishDownloadCompleteNotification(game);
 
-        await downloadQueueRepository.delete({ game });
+        if (
+          userPreferences?.seedAfterDownloadComplete &&
+          game.downloader === Downloader.Torrent
+        ) {
+          gameRepository.update(
+            { id: gameId },
+            { status: "seeding", shouldSeed: true }
+          );
+        } else {
+          gameRepository.update(
+            { id: gameId },
+            { status: "complete", shouldSeed: false }
+          );
 
+          this.cancelDownload(gameId);
+        }
+
+        await downloadQueueRepository.delete({ game });
         const [nextQueueItem] = await downloadQueueRepository.find({
           order: {
             id: "DESC",
@@ -58,25 +150,61 @@ export class DownloadManager {
             game: true,
           },
         });
-
         if (nextQueueItem) {
           this.resumeDownload(nextQueueItem.game);
+        } else {
+          this.downloadingGameId = -1;
         }
       }
     }
   }
 
+  public static async getSeedStatus() {
+    const seedStatus = await PythonRPC.rpc
+      .get<LibtorrentPayload[] | []>("/seed-status")
+      .then((res) => res.data);
+
+    if (!seedStatus.length) return;
+
+    logger.log(seedStatus);
+
+    seedStatus.forEach(async (status) => {
+      const game = await gameRepository.findOne({
+        where: { id: status.gameId },
+      });
+
+      if (!game) return;
+
+      const totalSize = await getDirSize(
+        path.join(game.downloadPath!, status.folderName)
+      );
+
+      if (totalSize < status.fileSize) {
+        await this.cancelDownload(game.id);
+
+        await gameRepository.update(game.id, {
+          status: "paused",
+          shouldSeed: false,
+          progress: totalSize / status.fileSize,
+        });
+
+        WindowManager.mainWindow?.webContents.send("on-hard-delete");
+      }
+    });
+
+    WindowManager.mainWindow?.webContents.send("on-seeding-status", seedStatus);
+  }
+
   static async pauseDownload() {
-    if (this.currentDownloader === Downloader.Torrent) {
-      await PythonInstance.pauseDownload();
-    } else if (this.currentDownloader === Downloader.RealDebrid) {
-      await RealDebridDownloader.pauseDownload();
-    } else {
-      await GenericHttpDownloader.pauseDownload();
-    }
+    await PythonRPC.rpc
+      .post("/action", {
+        action: "pause",
+        game_id: this.downloadingGameId,
+      } as PauseDownloadPayload)
+      .catch(() => {});
 
     WindowManager.mainWindow?.setProgressBar(-1);
-    this.currentDownloader = null;
+
     this.downloadingGameId = null;
   }
 
@@ -85,55 +213,95 @@ export class DownloadManager {
   }
 
   static async cancelDownload(gameId = this.downloadingGameId!) {
-    if (this.currentDownloader === Downloader.Torrent) {
-      PythonInstance.cancelDownload(gameId);
-    } else if (this.currentDownloader === Downloader.RealDebrid) {
-      RealDebridDownloader.cancelDownload(gameId);
-    } else {
-      GenericHttpDownloader.cancelDownload(gameId);
-    }
+    await PythonRPC.rpc.post("/action", {
+      action: "cancel",
+      game_id: gameId,
+    });
 
     WindowManager.mainWindow?.setProgressBar(-1);
-    this.currentDownloader = null;
-    this.downloadingGameId = null;
+
+    if (gameId === this.downloadingGameId) {
+      this.downloadingGameId = null;
+    }
   }
 
-  static async startDownload(game: Game) {
+  static async resumeSeeding(game: Game) {
+    await PythonRPC.rpc.post("/action", {
+      action: "resume_seeding",
+      game_id: game.id,
+      url: game.uri,
+      save_path: game.downloadPath,
+    });
+  }
+
+  static async pauseSeeding(gameId: number) {
+    await PythonRPC.rpc.post("/action", {
+      action: "pause_seeding",
+      game_id: gameId,
+    });
+  }
+
+  private static async getDownloadPayload(game: Game) {
     switch (game.downloader) {
       case Downloader.Gofile: {
-        const id = game!.uri!.split("/").pop();
+        const id = game.uri!.split("/").pop();
 
         const token = await GofileApi.authorize();
         const downloadLink = await GofileApi.getDownloadLink(id!);
 
-        GenericHttpDownloader.startDownload(game, downloadLink, {
-          Cookie: `accountToken=${token}`,
-        });
-        break;
+        return {
+          action: "start",
+          game_id: game.id,
+          url: downloadLink,
+          save_path: game.downloadPath!,
+          header: `Cookie: accountToken=${token}`,
+        };
       }
       case Downloader.PixelDrain: {
-        const id = game!.uri!.split("/").pop();
+        const id = game.uri!.split("/").pop();
 
-        await GenericHttpDownloader.startDownload(
-          game,
-          `https://pixeldrain.com/api/file/${id}?download`
-        );
-        break;
+        return {
+          action: "start",
+          game_id: game.id,
+          url: `https://pixeldrain.com/api/file/${id}?download`,
+          save_path: game.downloadPath!,
+        };
       }
       case Downloader.Qiwi: {
         const downloadUrl = await QiwiApi.getDownloadUrl(game.uri!);
 
-        await GenericHttpDownloader.startDownload(game, downloadUrl);
-        break;
+        return {
+          action: "start",
+          game_id: game.id,
+          url: downloadUrl,
+          save_path: game.downloadPath!,
+        };
       }
       case Downloader.Torrent:
-        PythonInstance.startDownload(game);
-        break;
-      case Downloader.RealDebrid:
-        RealDebridDownloader.startDownload(game);
-    }
+        return {
+          action: "start",
+          game_id: game.id,
+          url: game.uri!,
+          save_path: game.downloadPath!,
+        };
+      case Downloader.RealDebrid: {
+        const downloadUrl = await RealDebridClient.getDownloadUrl(game.uri!);
+
+        return {
+          action: "start",
+          game_id: game.id,
+          url: downloadUrl!,
+          save_path: game.downloadPath!,
+        };
+      }
+    }
+  }
+
+  static async startDownload(game: Game) {
+    const payload = await this.getDownloadPayload(game);
+
+    await PythonRPC.rpc.post("/action", payload);
 
-    this.currentDownloader = game.downloader;
     this.downloadingGameId = game.id;
   }
 }

src/main/services/download/generic-http-downloader.ts

@@ -1,109 +0,0 @@
-import { Game } from "@main/entity";
-import { gameRepository } from "@main/repository";
-import { calculateETA } from "./helpers";
-import { DownloadProgress } from "@types";
-import { HttpDownload } from "./http-download";
-
-export class GenericHttpDownloader {
-  public static downloads = new Map<number, HttpDownload>();
-  public static downloadingGame: Game | null = null;
-
-  public static async getStatus() {
-    if (this.downloadingGame) {
-      const download = this.downloads.get(this.downloadingGame.id)!;
-      const status = download.getStatus();
-
-      if (status) {
-        const progress =
-          Number(status.completedLength) / Number(status.totalLength);
-
-        await gameRepository.update(
-          { id: this.downloadingGame!.id },
-          {
-            bytesDownloaded: Number(status.completedLength),
-            fileSize: Number(status.totalLength),
-            progress,
-            status: "active",
-            folderName: status.folderName,
-          }
-        );
-
-        const result = {
-          numPeers: 0,
-          numSeeds: 0,
-          downloadSpeed: status.downloadSpeed,
-          timeRemaining: calculateETA(
-            status.totalLength,
-            status.completedLength,
-            status.downloadSpeed
-          ),
-          isDownloadingMetadata: false,
-          isCheckingFiles: false,
-          progress,
-          gameId: this.downloadingGame!.id,
-        } as DownloadProgress;
-
-        if (progress === 1) {
-          this.downloads.delete(this.downloadingGame.id);
-          this.downloadingGame = null;
-        }
-
-        return result;
-      }
-    }
-
-    return null;
-  }
-
-  static async pauseDownload() {
-    if (this.downloadingGame) {
-      const httpDownload = this.downloads.get(this.downloadingGame!.id!);
-
-      if (httpDownload) {
-        await httpDownload.pauseDownload();
-      }
-
-      this.downloadingGame = null;
-    }
-  }
-
-  static async startDownload(
-    game: Game,
-    downloadUrl: string,
-    headers?: Record<string, string>
-  ) {
-    this.downloadingGame = game;
-
-    if (this.downloads.has(game.id)) {
-      await this.resumeDownload(game.id!);
-      return;
-    }
-
-    const httpDownload = new HttpDownload(
-      game.downloadPath!,
-      downloadUrl,
-      headers
-    );
-
-    httpDownload.startDownload();
-
-    this.downloads.set(game.id!, httpDownload);
-  }
-
-  static async cancelDownload(gameId: number) {
-    const httpDownload = this.downloads.get(gameId);
-
-    if (httpDownload) {
-      await httpDownload.cancelDownload();
-      this.downloads.delete(gameId);
-    }
-  }
-
-  static async resumeDownload(gameId: number) {
-    const httpDownload = this.downloads.get(gameId);
-
-    if (httpDownload) {
-      await httpDownload.resumeDownload();
-    }
-  }
-}

src/main/services/download/helpers.ts

@@ -1,3 +1,7 @@
+import path from "node:path";
+import fs from "node:fs";
+import { logger } from "../logger";
+
 export const calculateETA = (
   totalLength: number,
   completedLength: number,
@@ -11,3 +15,26 @@ export const calculateETA = (
 
   return -1;
 };
+
+export const getDirSize = async (dir: string): Promise<number> => {
+  const getItemSize = async (filePath: string): Promise<number> => {
+    const stat = await fs.promises.stat(filePath);
+
+    if (stat.isDirectory()) {
+      return getDirSize(filePath);
+    }
+
+    return stat.size;
+  };
+
+  try {
+    const files = await fs.promises.readdir(dir);
+    const filePaths = files.map((file) => path.join(dir, file));
+    const sizes = await Promise.all(filePaths.map(getItemSize));
+
+    return sizes.reduce((total, size) => total + size, 0);
+  } catch (error) {
+    logger.error(error);
+    return 0;
+  }
+};

src/main/services/download/http-download.ts

@@ -1,54 +0,0 @@
-import { WindowManager } from "../window-manager";
-import path from "node:path";
-
-export class HttpDownload {
-  private downloadItem: Electron.DownloadItem;
-
-  constructor(
-    private downloadPath: string,
-    private downloadUrl: string,
-    private headers?: Record<string, string>
-  ) {}
-
-  public getStatus() {
-    return {
-      completedLength: this.downloadItem.getReceivedBytes(),
-      totalLength: this.downloadItem.getTotalBytes(),
-      downloadSpeed: this.downloadItem.getCurrentBytesPerSecond(),
-      folderName: this.downloadItem.getFilename(),
-    };
-  }
-
-  async cancelDownload() {
-    this.downloadItem.cancel();
-  }
-
-  async pauseDownload() {
-    this.downloadItem.pause();
-  }
-
-  async resumeDownload() {
-    this.downloadItem.resume();
-  }
-
-  async startDownload() {
-    return new Promise((resolve) => {
-      const options = this.headers ? { headers: this.headers } : {};
-      WindowManager.mainWindow?.webContents.downloadURL(
-        this.downloadUrl,
-        options
-      );
-
-      WindowManager.mainWindow?.webContents.session.once(
-        "will-download",
-        (_event, item, _webContents) => {
-          this.downloadItem = item;
-
-          item.setSavePath(path.join(this.downloadPath, item.getFilename()));
-
-          resolve(null);
-        }
-      );
-    });
-  }
-}

src/main/services/download/index.ts

@@ -1,2 +1 @@
 export * from "./download-manager";
-export * from "./python-instance";

src/main/services/download/python-instance.ts

@@ -1,188 +0,0 @@
-import cp from "node:child_process";
-
-import { Game } from "@main/entity";
-import {
-  RPC_PASSWORD,
-  RPC_PORT,
-  startTorrentClient as startRPCClient,
-} from "./torrent-client";
-import { gameRepository } from "@main/repository";
-import type { DownloadProgress } from "@types";
-import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
-import { calculateETA } from "./helpers";
-import axios from "axios";
-import {
-  CancelDownloadPayload,
-  StartDownloadPayload,
-  PauseDownloadPayload,
-  LibtorrentStatus,
-  LibtorrentPayload,
-  ProcessPayload,
-} from "./types";
-import { pythonInstanceLogger as logger } from "../logger";
-
-export class PythonInstance {
-  private static pythonProcess: cp.ChildProcess | null = null;
-  private static downloadingGameId = -1;
-
-  private static rpc = axios.create({
-    baseURL: `http://localhost:${RPC_PORT}`,
-    headers: {
-      "x-hydra-rpc-password": RPC_PASSWORD,
-    },
-  });
-
-  public static spawn(args?: StartDownloadPayload) {
-    logger.log("spawning python process with args:", args);
-    this.pythonProcess = startRPCClient(args);
-  }
-
-  public static kill() {
-    if (this.pythonProcess) {
-      logger.log("killing python process");
-      this.pythonProcess.kill();
-      this.pythonProcess = null;
-      this.downloadingGameId = -1;
-    }
-  }
-
-  public static killTorrent() {
-    if (this.pythonProcess) {
-      logger.log("killing torrent in python process");
-      this.rpc.post("/action", { action: "kill-torrent" });
-      this.downloadingGameId = -1;
-    }
-  }
-
-  public static async getProcessList() {
-    return (
-      (await this.rpc.get<ProcessPayload[] | null>("/process-list")).data || []
-    );
-  }
-
-  public static async getStatus() {
-    if (this.downloadingGameId === -1) return null;
-
-    const response = await this.rpc.get<LibtorrentPayload | null>("/status");
-
-    if (response.data === null) return null;
-
-    try {
-      const {
-        progress,
-        numPeers,
-        numSeeds,
-        downloadSpeed,
-        bytesDownloaded,
-        fileSize,
-        folderName,
-        status,
-        gameId,
-      } = response.data;
-
-      this.downloadingGameId = gameId;
-
-      const isDownloadingMetadata =
-        status === LibtorrentStatus.DownloadingMetadata;
-
-      const isCheckingFiles = status === LibtorrentStatus.CheckingFiles;
-
-      if (!isDownloadingMetadata && !isCheckingFiles) {
-        const update: QueryDeepPartialEntity<Game> = {
-          bytesDownloaded,
-          fileSize,
-          progress,
-          status: "active",
-        };
-
-        await gameRepository.update(
-          { id: gameId },
-          {
-            ...update,
-            folderName,
-          }
-        );
-      }
-
-      if (progress === 1 && !isCheckingFiles) {
-        this.downloadingGameId = -1;
-      }
-
-      return {
-        numPeers,
-        numSeeds,
-        downloadSpeed,
-        timeRemaining: calculateETA(fileSize, bytesDownloaded, downloadSpeed),
-        isDownloadingMetadata,
-        isCheckingFiles,
-        progress,
-        gameId,
-      } as DownloadProgress;
-    } catch (err) {
-      return null;
-    }
-  }
-
-  static async pauseDownload() {
-    await this.rpc
-      .post("/action", {
-        action: "pause",
-        game_id: this.downloadingGameId,
-      } as PauseDownloadPayload)
-      .catch(() => {});
-
-    this.downloadingGameId = -1;
-  }
-
-  static async startDownload(game: Game) {
-    if (!this.pythonProcess) {
-      this.spawn({
-        game_id: game.id,
-        magnet: game.uri!,
-        save_path: game.downloadPath!,
-      });
-    } else {
-      await this.rpc
-        .post("/action", {
-          action: "start",
-          game_id: game.id,
-          magnet: game.uri,
-          save_path: game.downloadPath,
-        } as StartDownloadPayload)
-        .catch(this.handleRpcError);
-    }
-
-    this.downloadingGameId = game.id;
-  }
-
-  static async cancelDownload(gameId: number) {
-    await this.rpc
-      .post("/action", {
-        action: "cancel",
-        game_id: gameId,
-      } as CancelDownloadPayload)
-      .catch(() => {});
-
-    this.downloadingGameId = -1;
-  }
-
-  static async processProfileImage(imagePath: string) {
-    return this.rpc
-      .post<{ imagePath: string; mimeType: string }>("/profile-image", {
-        image_path: imagePath,
-      })
-      .then((response) => response.data);
-  }
-
-  private static async handleRpcError(error: unknown) {
-    logger.error(error);
-
-    return this.rpc.get("/healthcheck").catch(() => {
-      logger.error(
-        "RPC healthcheck failed. Killing process and starting again"
-      );
-      this.kill();
-      this.spawn();
-    });
-  }
-}

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

@@ -1,72 +0,0 @@
-import { Game } from "@main/entity";
-import { RealDebridClient } from "../real-debrid";
-import { HttpDownload } from "./http-download";
-import { GenericHttpDownloader } from "./generic-http-downloader";
-
-export class RealDebridDownloader extends GenericHttpDownloader {
-  private static realDebridTorrentId: string | null = null;
-
-  private static async getRealDebridDownloadUrl() {
-    if (this.realDebridTorrentId) {
-      let torrentInfo = await RealDebridClient.getTorrentInfo(
-        this.realDebridTorrentId
-      );
-
-      if (torrentInfo.status === "waiting_files_selection") {
-        await RealDebridClient.selectAllFiles(this.realDebridTorrentId);
-
-        torrentInfo = await RealDebridClient.getTorrentInfo(
-          this.realDebridTorrentId
-        );
-      }
-
-      const { links, status } = torrentInfo;
-
-      if (status === "downloaded") {
-        const [link] = links;
-
-        const { download } = await RealDebridClient.unrestrictLink(link);
-        return decodeURIComponent(download);
-      }
-
-      return null;
-    }
-
-    if (this.downloadingGame?.uri) {
-      const { download } = await RealDebridClient.unrestrictLink(
-        this.downloadingGame?.uri
-      );
-
-      return decodeURIComponent(download);
-    }
-
-    return null;
-  }
-
-  static async startDownload(game: Game) {
-    if (this.downloads.has(game.id)) {
-      await this.resumeDownload(game.id!);
-      this.downloadingGame = game;
-      return;
-    }
-
-    if (game.uri?.startsWith("magnet:")) {
-      this.realDebridTorrentId = await RealDebridClient.getTorrentId(
-        game!.uri!
-      );
-    }
-
-    this.downloadingGame = game;
-
-    const downloadUrl = await this.getRealDebridDownloadUrl();
-
-    if (downloadUrl) {
-      this.realDebridTorrentId = null;
-
-      const httpDownload = new HttpDownload(game.downloadPath!, downloadUrl);
-      httpDownload.startDownload();
-
-      this.downloads.set(game.id!, httpDownload);
-    }
-  }
-}

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

@@ -9,7 +9,7 @@ import type {
 
 export class RealDebridClient {
   private static instance: AxiosInstance;
-  private static baseURL = "https://api.real-debrid.com/rest/1.0";
+  private static readonly baseURL = "https://api.real-debrid.com/rest/1.0";
 
   static authorize(apiToken: string) {
     this.instance = axios.create({
@@ -83,4 +83,37 @@ export class RealDebridClient {
     const torrent = await RealDebridClient.addMagnet(magnetUri);
     return torrent.id;
   }
+
+  public static async getDownloadUrl(uri: string) {
+    let realDebridTorrentId: string | null = null;
+
+    if (uri.startsWith("magnet:")) {
+      realDebridTorrentId = await this.getTorrentId(uri);
+    }
+
+    if (realDebridTorrentId) {
+      let torrentInfo = await this.getTorrentInfo(realDebridTorrentId);
+
+      if (torrentInfo.status === "waiting_files_selection") {
+        await this.selectAllFiles(realDebridTorrentId);
+
+        torrentInfo = await this.getTorrentInfo(realDebridTorrentId);
+      }
+
+      const { links, status } = torrentInfo;
+
+      if (status === "downloaded") {
+        const [link] = links;
+
+        const { download } = await this.unrestrictLink(link);
+        return decodeURIComponent(download);
+      }
+
+      return null;
+    }
+
+    const { download } = await this.unrestrictLink(uri);
+
+    return decodeURIComponent(download);
+  }
 }

src/main/services/download/torbox.ts

@@ -0,0 +1,97 @@
+import axios, { AxiosInstance } from "axios";
+import parseTorrent from "parse-torrent";
+import type {
+  TorBoxUserRequest,
+  TorBoxTorrentInfoRequest,
+  TorBoxAddTorrentRequest,
+  TorBoxRequestLinkRequest,
+} from "@types";
+import { logger } from "../logger";
+
+export class TorBoxClient {
+  private static instance: AxiosInstance;
+  private static readonly baseURL = "https://api.torbox.app/v1/api";
+  public static apiToken: string;
+
+  static authorize(apiToken: string) {
+    this.instance = axios.create({
+      baseURL: this.baseURL,
+      headers: {
+        Authorization: `Bearer ${apiToken}`,
+      },
+    });
+    this.apiToken = apiToken;
+  }
+
+  static async addMagnet(magnet: string) {
+    const form = new FormData();
+    form.append("magnet", magnet);
+
+    const response = await this.instance.post<TorBoxAddTorrentRequest>(
+      "/torrents/createtorrent",
+      form
+    );
+
+    return response.data.data;
+  }
+
+  static async getTorrentInfo(id: number) {
+    const response =
+      await this.instance.get<TorBoxTorrentInfoRequest>("/torrents/mylist");
+    const data = response.data.data;
+
+    const info = data.find((item) => item.id === id);
+
+    if (!info) {
+      return null;
+    }
+
+    return info;
+  }
+
+  static async getUser() {
+    const response = await this.instance.get<TorBoxUserRequest>(`/user/me`);
+    return response.data.data;
+  }
+
+  static async requestLink(id: number) {
+    const searchParams = new URLSearchParams({});
+
+    searchParams.set("token", this.apiToken);
+    searchParams.set("torrent_id", id.toString());
+    searchParams.set("zip_link", "true");
+
+    const response = await this.instance.get<TorBoxRequestLinkRequest>(
+      "/torrents/requestdl?" + searchParams.toString()
+    );
+
+    if (response.status !== 200) {
+      logger.error(response.data.error);
+      logger.error(response.data.detail);
+      return null;
+    }
+
+    return response.data.data;
+  }
+
+  private static async getAllTorrentsFromUser() {
+    const response =
+      await this.instance.get<TorBoxTorrentInfoRequest>("/torrents/mylist");
+
+    return response.data.data;
+  }
+
+  static async getTorrentId(magnetUri: string) {
+    const userTorrents = await this.getAllTorrentsFromUser();
+
+    const { infoHash } = await parseTorrent(magnetUri);
+    const userTorrent = userTorrents.find(
+      (userTorrent) => userTorrent.hash === infoHash
+    );
+
+    if (userTorrent) return userTorrent.id;
+
+    const torrent = await this.addMagnet(magnetUri);
+    return torrent.torrent_id;
+  }
+}

src/main/services/download/torrent-client.ts

@@ -1,77 +0,0 @@
-import path from "node:path";
-import cp from "node:child_process";
-import crypto from "node:crypto";
-import fs from "node:fs";
-import { app, dialog } from "electron";
-import type { StartDownloadPayload } from "./types";
-import { Readable } from "node:stream";
-import { pythonInstanceLogger as logger } from "../logger";
-
-const binaryNameByPlatform: Partial<Record<NodeJS.Platform, string>> = {
-  darwin: "hydra-download-manager",
-  linux: "hydra-download-manager",
-  win32: "hydra-download-manager.exe",
-};
-
-export const BITTORRENT_PORT = "5881";
-export const RPC_PORT = "8084";
-export const RPC_PASSWORD = crypto.randomBytes(32).toString("hex");
-
-const logStderr = (readable: Readable | null) => {
-  if (!readable) return;
-
-  readable.setEncoding("utf-8");
-  readable.on("data", logger.log);
-};
-
-export const startTorrentClient = (args?: StartDownloadPayload) => {
-  const commonArgs = [
-    BITTORRENT_PORT,
-    RPC_PORT,
-    RPC_PASSWORD,
-    args ? encodeURIComponent(JSON.stringify(args)) : "",
-  ];
-
-  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();
-    }
-
-    const childProcess = cp.spawn(binaryPath, commonArgs, {
-      windowsHide: true,
-      stdio: ["inherit", "inherit"],
-    });
-
-    logStderr(childProcess.stderr);
-
-    return childProcess;
-  } else {
-    const scriptPath = path.join(
-      __dirname,
-      "..",
-      "..",
-      "torrent-client",
-      "main.py"
-    );
-
-    const childProcess = cp.spawn("python3", [scriptPath, ...commonArgs], {
-      stdio: ["inherit", "inherit"],
-    });
-
-    logStderr(childProcess.stderr);
-
-    return childProcess;
-  }
-};

src/main/services/download/types.ts

@@ -1,9 +1,3 @@
-export interface StartDownloadPayload {
-  game_id: number;
-  magnet: string;
-  save_path: string;
-}
-
 export interface PauseDownloadPayload {
   game_id: number;
 }
@@ -25,6 +19,7 @@ export interface LibtorrentPayload {
   numPeers: number;
   numSeeds: number;
   downloadSpeed: number;
+  uploadSpeed: number;
   bytesDownloaded: number;
   fileSize: number;
   folderName: string;
@@ -33,7 +28,15 @@ export interface LibtorrentPayload {
 }
 
 export interface ProcessPayload {
-  exe: string;
+  exe: string | null;
   pid: number;
   name: string;
 }
+
+export interface PauseSeedingPayload {
+  game_id: number;
+}
+
+export interface ResumeSeedingPayload {
+  game_id: number;
+}

src/main/services/hydra-api.ts

@@ -23,7 +23,7 @@ interface HydraApiUserAuth {
   authToken: string;
   refreshToken: string;
   expirationTimestamp: number;
-  subscription: { expiresAt: Date | null } | null;
+  subscription: { expiresAt: Date | string | null } | null;
 }
 
 export class HydraApi {
@@ -159,7 +159,11 @@ export class HydraApi {
             config.method,
             config.baseURL,
             config.url,
-            omit(config.headers, ["accessToken", "refreshToken"]),
+            omit(config.headers, [
+              "accessToken",
+              "refreshToken",
+              "Authorization",
+            ]),
             Array.isArray(data)
               ? data
               : omit(data, ["accessToken", "refreshToken"])
@@ -182,8 +186,6 @@ export class HydraApi {
       );
     }
 
-    await getUserData();
-
     const userAuth = await userAuthRepository.findOne({
       where: { id: 1 },
       relations: { subscription: true },
@@ -197,6 +199,14 @@ export class HydraApi {
         ? { expiresAt: userAuth.subscription?.expiresAt }
         : null,
     };
+
+    const updatedUserData = await getUserData();
+
+    this.userAuth.subscription = updatedUserData?.subscription
+      ? {
+          expiresAt: updatedUserData.subscription.expiresAt,
+        }
+      : null;
   }
 
   private static sendSignOutEvent() {
@@ -284,10 +294,8 @@ export class HydraApi {
       await this.revalidateAccessTokenIfExpired();
     }
 
-    if (needsSubscription) {
-      if (!(await this.hasActiveSubscription())) {
-        throw new SubscriptionRequiredError();
-      }
+    if (needsSubscription && !this.hasActiveSubscription()) {
+      throw new SubscriptionRequiredError();
     }
   }
 

src/main/services/index.ts

@@ -1,7 +1,6 @@
 export * from "./logger";
 export * from "./steam";
 export * from "./steam-250";
-export * from "./steam-grid";
 export * from "./window-manager";
 export * from "./download";
 export * from "./process-watcher";

src/main/services/logger.ts

@@ -31,6 +31,6 @@ log.errorHandler.startCatching({
 
 log.initialize();
 
-export const pythonInstanceLogger = log.scope("python-instance");
+export const pythonRpcLogger = log.scope("python-rpc");
 export const logger = log.scope("main");
 export const achievementsLogger = log.scope("achievements");

src/main/services/main-loop.ts

@@ -10,6 +10,7 @@ export const startMainLoop = async () => {
       watchProcesses(),
       DownloadManager.watchDownloads(),
       AchievementWatcherManager.watchAchievements(),
+      DownloadManager.getSeedStatus(),
     ]);
 
     await sleep(1500);

src/main/services/process-watcher.ts

@@ -1,53 +1,190 @@
-import { IsNull, Not } from "typeorm";
 import { gameRepository } from "@main/repository";
 import { WindowManager } from "./window-manager";
 import { createGame, updateGamePlaytime } from "./library-sync";
 import type { GameRunning } from "@types";
-import { PythonInstance } from "./download";
+import { PythonRPC } from "./python-rpc";
 import { Game } from "@main/entity";
+import axios from "axios";
+import { exec } from "child_process";
+import { ProcessPayload } from "./download/types";
+
+const commands = {
+  findWineDir: `lsof -c wine 2>/dev/null | grep '/drive_c/windows$' | head -n 1 | awk '{for(i=9;i<=NF;i++) printf "%s ", $i; print ""}'`,
+  findWineExecutables: `lsof -c wine 2>/dev/null | grep '\\.exe$' | awk '{for(i=9;i<=NF;i++) printf "%s ", $i; print ""}'`,
+};
 
 export const gamesPlaytime = new Map<
   number,
   { lastTick: number; firstTick: number; lastSyncTick: number }
 >();
 
+interface ExecutableInfo {
+  name: string;
+  os: string;
+  exe: string;
+}
+
+interface GameExecutables {
+  [key: string]: ExecutableInfo[];
+}
+
 const TICKS_TO_UPDATE_API = 120;
 let currentTick = 1;
 
-const getSystemProcessSet = async () => {
-  const processes = await PythonInstance.getProcessList();
+const isWindowsPlatform = process.platform === "win32";
+const isLinuxPlatform = process.platform === "linux";
 
-  if (process.platform === "linux")
-    return new Set(processes.map((process) => process.name));
-  return new Set(processes.map((process) => process.exe));
+const getGameExecutables = async () => {
+  const gameExecutables = (
+    await axios
+      .get(
+        import.meta.env.MAIN_VITE_EXTERNAL_RESOURCES_URL +
+          "/game-executables.json"
+      )
+      .catch(() => {
+        return { data: {} };
+      })
+  ).data as GameExecutables;
+
+  Object.keys(gameExecutables).forEach((key) => {
+    gameExecutables[key] = gameExecutables[key]
+      .filter((executable) => {
+        if (isWindowsPlatform) {
+          return executable.os === "win32";
+        } else if (isLinuxPlatform) {
+          return executable.os === "linux" || executable.os === "win32";
+        }
+        return false;
+      })
+      .map((executable) => {
+        return {
+          name: isWindowsPlatform
+            ? executable.name.replace(/\//g, "\\")
+            : executable.name,
+          os: executable.os,
+          exe: executable.name.slice(executable.name.lastIndexOf("/") + 1),
+        };
+      });
+  });
+
+  return gameExecutables;
 };
 
-const getExecutable = (game: Game) => {
-  if (process.platform === "linux")
-    return game.executablePath?.split("/").at(-1);
-  return game.executablePath;
+const gameExecutables = await getGameExecutables();
+
+const findGamePathByProcess = (
+  processMap: Map<string, Set<string>>,
+  gameId: string
+) => {
+  const executables = gameExecutables[gameId];
+
+  for (const executable of executables) {
+    const pathSet = processMap.get(executable.exe);
+
+    if (pathSet) {
+      pathSet.forEach((path) => {
+        if (path.toLowerCase().endsWith(executable.name)) {
+          gameRepository.update(
+            { objectID: gameId, shop: "steam" },
+            { executablePath: path }
+          );
+
+          if (isLinuxPlatform) {
+            exec(commands.findWineDir, (err, out) => {
+              if (err) return;
+
+              gameRepository.update(
+                { objectID: gameId, shop: "steam" },
+                {
+                  winePrefixPath: out.trim().replace("/drive_c/windows", ""),
+                }
+              );
+            });
+          }
+        }
+      });
+    }
+  }
+};
+
+const getSystemProcessMap = async () => {
+  const processes =
+    (await PythonRPC.rpc.get<ProcessPayload[] | null>("/process-list")).data ||
+    [];
+
+  const map = new Map<string, Set<string>>();
+
+  processes.forEach((process) => {
+    const key = process.name?.toLowerCase();
+    const value = process.exe;
+
+    if (!key || !value) return;
+
+    const currentSet = map.get(key) ?? new Set();
+    map.set(key, currentSet.add(value));
+  });
+
+  if (isLinuxPlatform) {
+    await new Promise((res) => {
+      exec(commands.findWineExecutables, (err, out) => {
+        if (err) {
+          res(null);
+          return;
+        }
+
+        const pathSet = new Set(
+          out
+            .trim()
+            .split("\n")
+            .map((path) => path.trim())
+        );
+
+        pathSet.forEach((path) => {
+          if (path.startsWith("/usr")) return;
+
+          const key = path.slice(path.lastIndexOf("/") + 1).toLowerCase();
+
+          if (!key || !path) return;
+
+          const currentSet = map.get(key) ?? new Set();
+          map.set(key, currentSet.add(path));
+        });
+
+        res(null);
+      });
+    });
+  }
+
+  return map;
 };
 
 export const watchProcesses = async () => {
   const games = await gameRepository.find({
     where: {
-      executablePath: Not(IsNull()),
       isDeleted: false,
     },
   });
 
-  if (games.length === 0) return;
+  if (!games.length) return;
 
-  const processSet = await getSystemProcessSet();
+  const processMap = await getSystemProcessMap();
 
   for (const game of games) {
-    const executable = getExecutable(game);
+    const executablePath = game.executablePath;
+    if (!executablePath) {
+      if (gameExecutables[game.objectID]) {
+        findGamePathByProcess(processMap, game.objectID);
+      }
+      continue;
+    }
 
-    if (!executable) continue;
+    const executable = executablePath
+      .slice(executablePath.lastIndexOf(isWindowsPlatform ? "\\" : "/") + 1)
+      .toLowerCase();
 
-    const gameProcess = processSet.has(executable);
+    const hasProcess = processMap.get(executable)?.has(executablePath);
 
-    if (gameProcess) {
+    if (hasProcess) {
       if (gamesPlaytime.has(game.id)) {
         onTickGame(game);
       } else {

src/main/services/python-rpc.ts

@@ -0,0 +1,108 @@
+import axios from "axios";
+
+import cp from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+
+import { pythonRpcLogger } from "./logger";
+import { Readable } from "node:stream";
+import { app, dialog } from "electron";
+
+interface GamePayload {
+  game_id: number;
+  url: string;
+  save_path: string;
+}
+
+const binaryNameByPlatform: Partial<Record<NodeJS.Platform, string>> = {
+  darwin: "hydra-python-rpc",
+  linux: "hydra-python-rpc",
+  win32: "hydra-python-rpc.exe",
+};
+
+export class PythonRPC {
+  public static readonly BITTORRENT_PORT = "5881";
+  public static readonly RPC_PORT = "8084";
+  private static readonly RPC_PASSWORD = crypto.randomBytes(32).toString("hex");
+
+  private static pythonProcess: cp.ChildProcess | null = null;
+
+  public static readonly rpc = axios.create({
+    baseURL: `http://localhost:${this.RPC_PORT}`,
+    headers: {
+      "x-hydra-rpc-password": this.RPC_PASSWORD,
+    },
+  });
+
+  private static logStderr(readable: Readable | null) {
+    if (!readable) return;
+
+    readable.setEncoding("utf-8");
+    readable.on("data", pythonRpcLogger.log);
+  }
+
+  public static spawn(
+    initialDownload?: GamePayload,
+    initialSeeding?: GamePayload[]
+  ) {
+    const commonArgs = [
+      this.BITTORRENT_PORT,
+      this.RPC_PORT,
+      this.RPC_PASSWORD,
+      initialDownload ? JSON.stringify(initialDownload) : "",
+      initialSeeding ? JSON.stringify(initialSeeding) : "",
+    ];
+
+    if (app.isPackaged) {
+      const binaryName = binaryNameByPlatform[process.platform]!;
+      const binaryPath = path.join(
+        process.resourcesPath,
+        "hydra-python-rpc",
+        binaryName
+      );
+
+      if (!fs.existsSync(binaryPath)) {
+        dialog.showErrorBox(
+          "Fatal",
+          "Hydra Python Instance binary not found. Please check if it has been removed by Windows Defender."
+        );
+
+        app.quit();
+      }
+
+      const childProcess = cp.spawn(binaryPath, commonArgs, {
+        windowsHide: true,
+        stdio: ["inherit", "inherit"],
+      });
+
+      this.logStderr(childProcess.stderr);
+
+      this.pythonProcess = childProcess;
+    } else {
+      const scriptPath = path.join(
+        __dirname,
+        "..",
+        "..",
+        "python_rpc",
+        "main.py"
+      );
+
+      const childProcess = cp.spawn("python3", [scriptPath, ...commonArgs], {
+        stdio: ["inherit", "inherit"],
+      });
+
+      this.logStderr(childProcess.stderr);
+
+      this.pythonProcess = childProcess;
+    }
+  }
+
+  public static kill() {
+    if (this.pythonProcess) {
+      pythonRpcLogger.log("Killing python process");
+      this.pythonProcess.kill();
+      this.pythonProcess = null;
+    }
+  }
+}

src/main/services/steam-grid.ts

@@ -1,69 +0,0 @@
-import type { GameShop } from "@types";
-import axios from "axios";
-
-export interface SteamGridResponse {
-  success: boolean;
-  data: {
-    id: number;
-  };
-}
-
-export interface SteamGridGameResponse {
-  data: {
-    platforms: {
-      steam: {
-        metadata: {
-          clienticon: string;
-        };
-      };
-    };
-  };
-}
-
-export const getSteamGridData = async (
-  objectId: string,
-  path: string,
-  shop: GameShop,
-  params: Record<string, string> = {}
-): Promise<SteamGridResponse> => {
-  const searchParams = new URLSearchParams(params);
-
-  if (!import.meta.env.MAIN_VITE_STEAMGRIDDB_API_KEY) {
-    throw new Error("MAIN_VITE_STEAMGRIDDB_API_KEY is not set");
-  }
-
-  const response = await axios.get(
-    `https://www.steamgriddb.com/api/v2/${path}/${shop}/${objectId}?${searchParams.toString()}`,
-    {
-      headers: {
-        Authorization: `Bearer ${import.meta.env.MAIN_VITE_STEAMGRIDDB_API_KEY}`,
-      },
-    }
-  );
-
-  return response.data;
-};
-
-export const getSteamGridGameById = async (
-  id: number
-): Promise<SteamGridGameResponse> => {
-  const response = await axios.get(
-    `https://www.steamgriddb.com/api/public/game/${id}`,
-    {
-      headers: {
-        Referer: "https://www.steamgriddb.com/",
-      },
-    }
-  );
-
-  return response.data;
-};
-
-export const getSteamGameClientIcon = async (objectId: string) => {
-  const {
-    data: { id: steamGridGameId },
-  } = await getSteamGridData(objectId, "games", "steam");
-
-  const steamGridGame = await getSteamGridGameById(steamGridGameId);
-  return steamGridGame.data.platforms.steam.metadata.clienticon;
-};

src/main/services/user/get-user-data.ts

@@ -42,6 +42,7 @@ export const getUserData = () => {
     })
     .catch(async (err) => {
       if (err instanceof UserNotLoggedInError) {
+        logger.info("User is not logged in", err);
         return null;
       }
       logger.error("Failed to get logged user");
@@ -58,6 +59,9 @@ export const getUserData = () => {
           bio: "",
           email: null,
           profileVisibility: "PUBLIC" as ProfileVisibility,
+          quirks: {
+            backupsPerGameLimit: 0,
+          },
           subscription: loggedUser.subscription
             ? {
                 id: loggedUser.subscription.subscriptionId,

src/main/services/window-manager.ts

@@ -64,7 +64,10 @@ export class WindowManager {
 
     this.mainWindow.webContents.session.webRequest.onBeforeSendHeaders(
       (details, callback) => {
-        if (details.webContentsId !== this.mainWindow?.webContents.id) {
+        if (
+          details.webContentsId !== this.mainWindow?.webContents.id ||
+          details.url.includes("chatwoot")
+        ) {
           return callback(details);
         }
 
@@ -81,15 +84,11 @@ export class WindowManager {
 
     this.mainWindow.webContents.session.webRequest.onHeadersReceived(
       (details, callback) => {
-        if (details.webContentsId !== this.mainWindow?.webContents.id) {
-          return callback(details);
-        }
-
-        if (details.url.includes("featurebase")) {
-          return callback(details);
-        }
-
-        if (details.url.includes("chatwoot")) {
+        if (
+          details.webContentsId !== this.mainWindow?.webContents.id ||
+          details.url.includes("featurebase") ||
+          details.url.includes("chatwoot")
+        ) {
           return callback(details);
         }
 
@@ -277,14 +276,9 @@ export class WindowManager {
     if (process.platform !== "darwin") {
       await updateSystemTray();
 
-      tray.addListener("click", () => {
+      tray.addListener("double-click", () => {
         if (this.mainWindow) {
-          if (
-            WindowManager.mainWindow?.isMinimized() ||
-            !WindowManager.mainWindow?.isVisible()
-          ) {
-            WindowManager.mainWindow?.show();
-          }
+          this.mainWindow.show();
         } else {
           this.createMainWindow();
         }

src/main/vite-env.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="vite/client" />
 
 interface ImportMetaEnv {
-  readonly MAIN_VITE_STEAMGRIDDB_API_KEY: string;
   readonly MAIN_VITE_API_URL: string;
   readonly MAIN_VITE_ANALYTICS_API_URL: string;
   readonly MAIN_VITE_AUTH_URL: string;
   readonly MAIN_VITE_CHECKOUT_URL: string;
+  readonly MAIN_VITE_EXTERNAL_RESOURCES_URL: string;
 }
 
 interface ImportMeta {