Merge branch 'main' into linux-install

src/main/constants.ts

@@ -12,34 +12,20 @@ export const repackersOn1337x = [
 export const repackers = [
   ...repackersOn1337x,
   "Xatab",
-  "CPG",
   "TinyRepacks",
+  "CPG",
   "GOG",
   "onlinefix",
 ] as const;
 
-export const months = [
-  "Jan",
-  "Feb",
-  "Mar",
-  "Apr",
-  "May",
-  "Jun",
-  "Jul",
-  "Aug",
-  "Sep",
-  "Oct",
-  "Nov",
-  "Dec",
-];
-
 export const defaultDownloadsPath = app.getPath("downloads");
 
 export const databasePath = path.join(
   app.getPath("appData"),
-  app.getName(),
+  "hydra",
   "hydra.db"
 );
 
-export const INSTALLATION_ID_LENGTH = 6;
-export const ACTIVATION_KEY_MULTIPLIER = 7;
+export const seedsPath = app.isPackaged
+  ? path.join(process.resourcesPath, "seeds")
+  : path.join(__dirname, "..", "..", "seeds");

src/main/data-source.ts

@@ -1,33 +1,21 @@
 import { DataSource } from "typeorm";
-import {
-  Game,
-  GameShopCache,
-  Repack,
-  RepackerFriendlyName,
-  UserPreferences,
-  MigrationScript,
-  SteamGame,
-} from "@main/entity";
-import type { SqliteConnectionOptions } from "typeorm/driver/sqlite/SqliteConnectionOptions";
+import { Game, GameShopCache, Repack, UserPreferences } from "@main/entity";
+import type { BetterSqlite3ConnectionOptions } from "typeorm/driver/better-sqlite3/BetterSqlite3ConnectionOptions";
 
 import { databasePath } from "./constants";
+import migrations from "./migrations";
 
-export const createDataSource = (options: Partial<SqliteConnectionOptions>) =>
+export const createDataSource = (
+  options: Partial<BetterSqlite3ConnectionOptions>
+) =>
   new DataSource({
     type: "better-sqlite3",
+    entities: [Game, Repack, UserPreferences, GameShopCache],
+    synchronize: true,
     database: databasePath,
-    entities: [
-      Game,
-      Repack,
-      RepackerFriendlyName,
-      UserPreferences,
-      GameShopCache,
-      MigrationScript,
-      SteamGame,
-    ],
     ...options,
   });
 
 export const dataSource = createDataSource({
-  synchronize: true,
+  migrations,
 });

src/main/entity/game.entity.ts

@@ -23,8 +23,8 @@ export class Game {
   @Column("text")
   title: string;
 
-  @Column("text")
-  iconUrl: string;
+  @Column("text", { nullable: true })
+  iconUrl: string | null;
 
   @Column("text", { nullable: true })
   folderName: string | null;

src/main/entity/index.ts

@@ -1,7 +1,4 @@
 export * from "./game.entity";
 export * from "./repack.entity";
-export * from "./repacker-friendly-name.entity";
 export * from "./user-preferences.entity";
 export * from "./game-shop-cache.entity";
-export * from "./migration-script.entity";
-export * from "./steam-game.entity";

src/main/entity/migration-script.entity.ts

@@ -1,22 +0,0 @@
-import {
-  Entity,
-  PrimaryGeneratedColumn,
-  Column,
-  CreateDateColumn,
-  UpdateDateColumn,
-} from "typeorm";
-
-@Entity("migration_script")
-export class MigrationScript {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column("text", { unique: true })
-  version: string;
-
-  @CreateDateColumn()
-  createdAt: Date;
-
-  @UpdateDateColumn()
-  updatedAt: Date;
-}

src/main/entity/repacker-friendly-name.entity.ts

@@ -1,25 +0,0 @@
-import {
-  Entity,
-  PrimaryGeneratedColumn,
-  Column,
-  CreateDateColumn,
-  UpdateDateColumn,
-} from "typeorm";
-
-@Entity("repacker_friendly_name")
-export class RepackerFriendlyName {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column("text", { unique: true })
-  name: string;
-
-  @Column("text")
-  friendlyName: string;
-
-  @CreateDateColumn()
-  createdAt: Date;
-
-  @UpdateDateColumn()
-  updatedAt: Date;
-}

src/main/entity/steam-game.entity.ts

@@ -1,10 +0,0 @@
-import { Column, Entity, PrimaryColumn } from "typeorm";
-
-@Entity("steam_game")
-export class SteamGame {
-  @PrimaryColumn()
-  id: number;
-
-  @Column()
-  name: string;
-}

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

@@ -26,9 +26,6 @@ export class UserPreferences {
   @Column("boolean", { default: false })
   repackUpdatesNotificationsEnabled: boolean;
 
-  @Column("boolean", { default: true })
-  telemetryEnabled: boolean;
-
   @Column("boolean", { default: false })
   preferQuitInsteadOfHiding: boolean;
 

src/main/events/autoupdater/check-for-updates.ts

@@ -0,0 +1,48 @@
+import { AppUpdaterEvents } from "@types";
+import { registerEvent } from "../register-event";
+import updater, { ProgressInfo, UpdateInfo } from "electron-updater";
+import { WindowManager } from "@main/services";
+import { app } from "electron";
+
+const { autoUpdater } = updater;
+
+const sendEvent = (event: AppUpdaterEvents) => {
+  WindowManager.splashWindow?.webContents.send("autoUpdaterEvent", event);
+};
+
+const mockValuesForDebug = async () => {
+  sendEvent({ type: "update-downloaded" });
+};
+
+const checkForUpdates = async (_event: Electron.IpcMainInvokeEvent) => {
+  autoUpdater
+    .addListener("error", () => {
+      sendEvent({ type: "error" });
+    })
+    .addListener("checking-for-update", () => {
+      sendEvent({ type: "checking-for-updates" });
+    })
+    .addListener("update-not-available", () => {
+      sendEvent({ type: "update-not-available" });
+    })
+    .addListener("update-available", (info: UpdateInfo) => {
+      sendEvent({ type: "update-available", info });
+    })
+    .addListener("update-downloaded", () => {
+      sendEvent({ type: "update-downloaded" });
+    })
+    .addListener("download-progress", (info: ProgressInfo) => {
+      sendEvent({ type: "download-progress", info });
+    })
+    .addListener("update-cancelled", () => {
+      sendEvent({ type: "update-cancelled" });
+    });
+
+  if (app.isPackaged) {
+    autoUpdater.checkForUpdates();
+  } else {
+    await mockValuesForDebug();
+  }
+};
+
+registerEvent("checkForUpdates", checkForUpdates);

src/main/events/autoupdater/continue-to-main-window.ts

@@ -0,0 +1,12 @@
+import { WindowManager } from "@main/services";
+import { registerEvent } from "../register-event";
+import updater from "electron-updater";
+
+const { autoUpdater } = updater;
+
+const continueToMainWindow = async (_event: Electron.IpcMainInvokeEvent) => {
+  autoUpdater.removeAllListeners();
+  WindowManager.prepareMainWindowAndCloseSplash();
+};
+
+registerEvent("continueToMainWindow", continueToMainWindow);

src/main/events/autoupdater/restart-and-install-update.ts

@@ -0,0 +1,17 @@
+import { app } from "electron";
+import { registerEvent } from "../register-event";
+import updater from "electron-updater";
+import { WindowManager } from "@main/services";
+
+const { autoUpdater } = updater;
+
+const restartAndInstallUpdate = async (_event: Electron.IpcMainInvokeEvent) => {
+  if (app.isPackaged) {
+    autoUpdater.quitAndInstall(true, true);
+  } else {
+    autoUpdater.removeAllListeners();
+    WindowManager.prepareMainWindowAndCloseSplash();
+  }
+};
+
+registerEvent("restartAndInstallUpdate", restartAndInstallUpdate);

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

@@ -92,7 +92,4 @@ const getRecentlyAddedCatalogue = async (
   return results.slice(0, resultSize);
 };
 
-registerEvent(getCatalogue, {
-  name: "getCatalogue",
-  memoize: true,
-});
+registerEvent("getCatalogue", getCatalogue);

src/main/events/catalogue/get-game-shop-details.ts

@@ -1,9 +1,10 @@
-import { gameShopCacheRepository, steamGameRepository } from "@main/repository";
+import { gameShopCacheRepository } from "@main/repository";
 import { getSteamAppDetails } from "@main/services";
 
 import type { ShopDetails, GameShop, SteamAppDetails } from "@types";
 
 import { registerEvent } from "../register-event";
+import { stateManager } from "@main/state-manager";
 
 const getLocalizedSteamAppDetails = (
   objectID: string,
@@ -13,10 +14,11 @@ const getLocalizedSteamAppDetails = (
     return getSteamAppDetails(objectID, language);
   }
 
-  return Promise.all([
-    steamGameRepository.findOne({ where: { id: Number(objectID) } }),
-    getSteamAppDetails(objectID, language),
-  ]).then(([steamGame, localizedAppDetails]) => {
+  return getSteamAppDetails(objectID, language).then((localizedAppDetails) => {
+    const steamGame = stateManager
+      .getValue("steamGames")
+      .find((game) => game.id === Number(objectID));
+
     if (steamGame && localizedAppDetails) {
       return {
         ...localizedAppDetails,
@@ -72,7 +74,4 @@ const getGameShopDetails = async (
   throw new Error("Not implemented");
 };
 
-registerEvent(getGameShopDetails, {
-  name: "getGameShopDetails",
-  memoize: true,
-});
+registerEvent("getGameShopDetails", getGameShopDetails);

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

@@ -36,7 +36,4 @@ const getGames = async (
   return { results, cursor: i };
 };
 
-registerEvent(getGames, {
-  name: "getGames",
-  memoize: true,
-});
+registerEvent("getGames", getGames);

src/main/events/catalogue/get-how-long-to-beat.ts

@@ -42,7 +42,4 @@ const getHowLongToBeat = async (
   });
 };
 
-registerEvent(getHowLongToBeat, {
-  name: "getHowLongToBeat",
-  memoize: true,
-});
+registerEvent("getHowLongToBeat", getHowLongToBeat);

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

@@ -36,6 +36,4 @@ const getRandomGame = async (_event: Electron.IpcMainInvokeEvent) => {
   return state.games[state.index];
 };
 
-registerEvent(getRandomGame, {
-  name: "getRandomGame",
-});
+registerEvent("getRandomGame", getRandomGame);

src/main/events/catalogue/search-game-repacks.ts

@@ -8,7 +8,4 @@ const searchGameRepacks = (
   return searchRepacks(query);
 };
 
-registerEvent(searchGameRepacks, {
-  name: "searchGameRepacks",
-  memoize: true,
-});
+registerEvent("searchGameRepacks", searchGameRepacks);

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

@@ -9,7 +9,4 @@ const searchGamesEvent = async (
   return searchGames({ query, take: 12 });
 };
 
-registerEvent(searchGamesEvent, {
-  name: "searchGames",
-  memoize: true,
-});
+registerEvent("searchGames", searchGamesEvent);

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

@@ -7,6 +7,4 @@ const getDiskFreeSpace = async (
   path: string
 ) => checkDiskSpace(path);
 
-registerEvent(getDiskFreeSpace, {
-  name: "getDiskFreeSpace",
-});
+registerEvent("getDiskFreeSpace", getDiskFreeSpace);

src/main/events/index.ts

@@ -14,7 +14,6 @@ import "./library/close-game";
 import "./library/delete-game-folder";
 import "./library/get-game-by-object-id";
 import "./library/get-library";
-import "./library/get-repackers-friendly-names";
 import "./library/open-game";
 import "./library/open-game-installer";
 import "./library/remove-game";
@@ -28,6 +27,9 @@ import "./torrenting/start-game-download";
 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 "./autoupdater/continue-to-main-window";
 
 ipcMain.handle("ping", () => "pong");
 ipcMain.handle("getVersion", () => app.getVersion());

src/main/events/library/add-game-to-library.ts

@@ -3,8 +3,8 @@ import { gameRepository } from "@main/repository";
 import { registerEvent } from "../register-event";
 
 import type { GameShop } from "@types";
-import { getFileBase64 } from "@main/helpers";
-import { getSteamGameIconUrl } from "@main/services";
+import { getFileBase64, getSteamAppAsset } from "@main/helpers";
+import { stateManager } from "@main/state-manager";
 
 const addGameToLibrary = async (
   _event: Electron.IpcMainInvokeEvent,
@@ -27,21 +27,31 @@ const addGameToLibrary = async (
     )
     .then(async ({ affected }) => {
       if (!affected) {
-        const iconUrl = await getFileBase64(
-          await getSteamGameIconUrl(objectID)
-        );
+        const steamGame = stateManager
+          .getValue("steamGames")
+          .find((game) => game.id === Number(objectID));
 
-        await gameRepository.insert({
-          title,
-          iconUrl,
-          objectID,
-          shop: gameShop,
-          executablePath,
-        });
+        const iconUrl = steamGame?.clientIcon
+          ? getSteamAppAsset("icon", objectID, steamGame.clientIcon)
+          : null;
+
+        await gameRepository
+          .insert({
+            title,
+            iconUrl,
+            objectID,
+            shop: gameShop,
+            executablePath,
+          })
+          .then(() => {
+            if (iconUrl) {
+              getFileBase64(iconUrl).then((base64) =>
+                gameRepository.update({ objectID }, { iconUrl: base64 })
+              );
+            }
+          });
       }
     });
 };
 
-registerEvent(addGameToLibrary, {
-  name: "addGameToLibrary",
-});
+registerEvent("addGameToLibrary", addGameToLibrary);

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

@@ -36,6 +36,4 @@ const closeGame = async (
   return false;
 };
 
-registerEvent(closeGame, {
-  name: "closeGame",
-});
+registerEvent("closeGame", closeGame);

src/main/events/library/delete-game-folder.ts

@@ -47,6 +47,4 @@ const deleteGameFolder = async (
   }
 };
 
-registerEvent(deleteGameFolder, {
-  name: "deleteGameFolder",
-});
+registerEvent("deleteGameFolder", deleteGameFolder);

src/main/events/library/get-game-by-object-id.ts

@@ -16,6 +16,4 @@ const getGameByObjectID = async (
     },
   });
 
-registerEvent(getGameByObjectID, {
-  name: "getGameByObjectID",
-});
+registerEvent("getGameByObjectID", getGameByObjectID);

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

@@ -28,6 +28,4 @@ const getLibrary = async () =>
       )
     );
 
-registerEvent(getLibrary, {
-  name: "getLibrary",
-});
+registerEvent("getLibrary", getLibrary);

src/main/events/library/get-repackers-friendly-names.ts

@@ -1,12 +0,0 @@
-import { registerEvent } from "../register-event";
-import { stateManager } from "@main/state-manager";
-
-const getRepackersFriendlyNames = async () =>
-  stateManager.getValue("repackersFriendlyNames").reduce((prev, next) => {
-    return { ...prev, [next.name]: next.friendlyName };
-  }, {});
-
-registerEvent(getRepackersFriendlyNames, {
-  name: "getRepackersFriendlyNames",
-  memoize: true,
-});

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

@@ -54,6 +54,4 @@ const openGameInstaller = async (
   return false;
 };
 
-registerEvent(openGameInstaller, {
-  name: "openGameInstaller",
-});
+registerEvent("openGameInstaller", openGameInstaller);

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

@@ -13,6 +13,4 @@ const openGame = async (
   shell.openPath(executablePath);
 };
 
-registerEvent(openGame, {
-  name: "openGame",
-});
+registerEvent("openGame", openGame);

src/main/events/library/remove-game-from-library.ts

@@ -8,6 +8,4 @@ const removeGameFromLibrary = async (
   gameRepository.update({ id: gameId }, { isDeleted: true });
 };
 
-registerEvent(removeGameFromLibrary, {
-  name: "removeGameFromLibrary",
-});
+registerEvent("removeGameFromLibrary", removeGameFromLibrary);

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

@@ -20,6 +20,4 @@ const removeGame = async (
   );
 };
 
-registerEvent(removeGame, {
-  name: "removeGame",
-});
+registerEvent("removeGame", removeGame);

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

@@ -4,6 +4,4 @@ import { registerEvent } from "../register-event";
 const openExternal = async (_event: Electron.IpcMainInvokeEvent, src: string) =>
   shell.openExternal(src);
 
-registerEvent(openExternal, {
-  name: "openExternal",
-});
+registerEvent("openExternal", openExternal);

src/main/events/misc/show-open-dialog.ts

@@ -13,6 +13,4 @@ const showOpenDialog = async (
   throw new Error("Main window is not available");
 };
 
-registerEvent(showOpenDialog, {
-  name: "showOpenDialog",
-});
+registerEvent("showOpenDialog", showOpenDialog);

src/main/events/register-event.ts

@@ -1,37 +1,11 @@
 import { ipcMain } from "electron";
 
-import { stateManager } from "@main/state-manager";
-
-interface EventArgs {
-  name: string;
-  memoize?: boolean;
-}
-
 export const registerEvent = (
-  listener: (event: Electron.IpcMainInvokeEvent, ...args: any[]) => any,
-  { name, memoize = false }: EventArgs
+  name: string,
+  listener: (event: Electron.IpcMainInvokeEvent, ...args: any[]) => any
 ) => {
-  ipcMain.handle(name, (event: Electron.IpcMainInvokeEvent, ...args) => {
-    const eventResults = stateManager.getValue("eventResults");
-    const keys = Array.from(eventResults.keys());
-
-    const key = [name, args] as [string, any[]];
-
-    const memoizationKey = keys.find(([memoizedEvent, memoizedArgs]) => {
-      const sameEvent = name === memoizedEvent;
-      const sameArgs = memoizedArgs.every((arg, index) => arg === args[index]);
-
-      return sameEvent && sameArgs;
-    });
-
-    if (memoizationKey) return eventResults.get(memoizationKey);
-
+  ipcMain.handle(name, async (event: Electron.IpcMainInvokeEvent, ...args) => {
     return Promise.resolve(listener(event, ...args)).then((result) => {
-      if (memoize) {
-        eventResults.set(key, JSON.parse(JSON.stringify(result)));
-        stateManager.setValue("eventResults", eventResults);
-      }
-
       if (!result) return result;
       return JSON.parse(JSON.stringify(result));
     });

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

@@ -50,6 +50,4 @@ const cancelGameDownload = async (
     });
 };
 
-registerEvent(cancelGameDownload, {
-  name: "cancelGameDownload",
-});
+registerEvent("cancelGameDownload", cancelGameDownload);

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

@@ -27,6 +27,4 @@ const pauseGameDownload = async (
     });
 };
 
-registerEvent(pauseGameDownload, {
-  name: "pauseGameDownload",
-});
+registerEvent("pauseGameDownload", pauseGameDownload);

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

@@ -46,6 +46,4 @@ const resumeGameDownload = async (
   }
 };
 
-registerEvent(resumeGameDownload, {
-  name: "resumeGameDownload",
-});
+registerEvent("resumeGameDownload", resumeGameDownload);

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

@@ -1,4 +1,3 @@
-import { getSteamGameIconUrl } from "@main/services";
 import {
   gameRepository,
   repackRepository,
@@ -8,10 +7,11 @@ import {
 import { registerEvent } from "../register-event";
 
 import type { GameShop } from "@types";
-import { getFileBase64 } from "@main/helpers";
+import { getFileBase64, getSteamAppAsset } from "@main/helpers";
 import { In } from "typeorm";
 import { DownloadManager } from "@main/services";
 import { Downloader, GameStatus } from "@shared";
+import { stateManager } from "@main/state-manager";
 
 const startGameDownload = async (
   _event: Electron.IpcMainInvokeEvent,
@@ -76,18 +76,34 @@ const startGameDownload = async (
 
     return game;
   } else {
-    const iconUrl = await getFileBase64(await getSteamGameIconUrl(objectID));
+    const steamGame = stateManager
+      .getValue("steamGames")
+      .find((game) => game.id === Number(objectID));
 
-    const createdGame = await gameRepository.save({
-      title,
-      iconUrl,
-      objectID,
-      downloader,
-      shop: gameShop,
-      status: GameStatus.Downloading,
-      downloadPath,
-      repack: { id: repackId },
-    });
+    const iconUrl = steamGame?.clientIcon
+      ? getSteamAppAsset("icon", objectID, steamGame.clientIcon)
+      : null;
+
+    const createdGame = await gameRepository
+      .save({
+        title,
+        iconUrl,
+        objectID,
+        downloader,
+        shop: gameShop,
+        status: GameStatus.Downloading,
+        downloadPath,
+        repack: { id: repackId },
+      })
+      .then((result) => {
+        if (iconUrl) {
+          getFileBase64(iconUrl).then((base64) =>
+            gameRepository.update({ objectID }, { iconUrl: base64 })
+          );
+        }
+
+        return result;
+      });
 
     DownloadManager.downloadGame(createdGame.id);
 
@@ -97,6 +113,4 @@ const startGameDownload = async (
   }
 };
 
-registerEvent(startGameDownload, {
-  name: "startGameDownload",
-});
+registerEvent("startGameDownload", startGameDownload);

src/main/events/user-preferences/auto-launch.ts

@@ -16,6 +16,4 @@ const autoLaunch = async (
   }
 };
 
-registerEvent(autoLaunch, {
-  name: "autoLaunch",
-});
+registerEvent("autoLaunch", autoLaunch);

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

@@ -6,6 +6,4 @@ const getUserPreferences = async () =>
     where: { id: 1 },
   });
 
-registerEvent(getUserPreferences, {
-  name: "getUserPreferences",
-});
+registerEvent("getUserPreferences", getUserPreferences);

src/main/events/user-preferences/update-user-preferences.ts

@@ -21,6 +21,4 @@ const updateUserPreferences = async (
   );
 };
 
-registerEvent(updateUserPreferences, {
-  name: "updateUserPreferences",
-});
+registerEvent("updateUserPreferences", updateUserPreferences);

src/main/helpers/index.ts

@@ -13,7 +13,7 @@ import {
   gogFormatter,
   onlinefixFormatter,
 } from "./formatters";
-import { months, repackers } from "../constants";
+import { repackers } from "../constants";
 
 export const pipe =
   <T>(...fns: ((arg: T) => any)[]) =>
@@ -44,19 +44,6 @@ export const repackerFormatter: Record<
   onlinefix: onlinefixFormatter,
 };
 
-export const formatUploadDate = (str: string) => {
-  const date = new Date();
-
-  const [month, day, year] = str.split(" ");
-
-  date.setMonth(months.indexOf(month.replace(".", "")));
-  date.setDate(Number(day.substring(0, 2)));
-  date.setFullYear(Number("20" + year.replace("'", "")));
-  date.setHours(0, 0, 0, 0);
-
-  return date;
-};
-
 export const getSteamAppAsset = (
   category: "library" | "hero" | "logo" | "icon",
   objectID: string,

src/main/index.ts

@@ -1,29 +1,26 @@
 import { app, BrowserWindow, net, protocol } from "electron";
-import { init } from "@sentry/electron/main";
+import updater from "electron-updater";
 import i18n from "i18next";
 import path from "node:path";
 import { electronApp, optimizer } from "@electron-toolkit/utils";
-import { resolveDatabaseUpdates, WindowManager } from "@main/services";
+import { logger, resolveDatabaseUpdates, WindowManager } from "@main/services";
 import { dataSource } from "@main/data-source";
 import * as resources from "@locales";
 import { userPreferencesRepository } from "@main/repository";
+const { autoUpdater } = updater;
+
+autoUpdater.setFeedURL({
+  provider: "github",
+  owner: "hydralauncher",
+  repo: "hydra",
+});
+
+autoUpdater.logger = logger;
 
 const gotTheLock = app.requestSingleInstanceLock();
 if (!gotTheLock) app.quit();
 
-if (import.meta.env.MAIN_VITE_SENTRY_DSN) {
-  init({
-    dsn: import.meta.env.MAIN_VITE_SENTRY_DSN,
-    beforeSend: async (event) => {
-      const userPreferences = await userPreferencesRepository.findOne({
-        where: { id: 1 },
-      });
-
-      if (userPreferences?.telemetryEnabled) return event;
-      return null;
-    },
-  });
-}
+app.commandLine.appendSwitch("--no-sandbox");
 
 i18n.init({
   resources,
@@ -57,6 +54,8 @@ app.whenReady().then(() => {
   );
 
   dataSource.initialize().then(async () => {
+    await dataSource.runMigrations();
+
     await resolveDatabaseUpdates();
 
     await import("./main");
@@ -65,7 +64,7 @@ app.whenReady().then(() => {
       where: { id: 1 },
     });
 
-    WindowManager.createMainWindow();
+    WindowManager.createSplashScreen();
     WindowManager.createSystemTray(userPreferences?.language || "en");
   });
 });

src/main/main.ts

@@ -1,8 +1,7 @@
 import { stateManager } from "./state-manager";
-import { repackers } from "./constants";
+import { repackersOn1337x, seedsPath } from "./constants";
 import {
   getNewGOGGames,
-  getNewRepacksFromCPG,
   getNewRepacksFromUser,
   getNewRepacksFromXatab,
   getNewRepacksFromOnlineFix,
@@ -12,8 +11,6 @@ import {
 import {
   gameRepository,
   repackRepository,
-  repackerFriendlyNameRepository,
-  steamGameRepository,
   userPreferencesRepository,
 } from "./repository";
 import { TorrentDownloader } from "./services";
@@ -22,12 +19,16 @@ import { Notification } from "electron";
 import { t } from "i18next";
 import { GameStatus } from "@shared";
 import { In } from "typeorm";
+import fs from "node:fs";
+import path from "node:path";
 import { RealDebridClient } from "./services/real-debrid";
+import { orderBy } from "lodash-es";
+import { SteamGame } from "@types";
 
 startProcessWatcher();
 
 const track1337xUsers = async (existingRepacks: Repack[]) => {
-  for (const repacker of repackers) {
+  for (const repacker of repackersOn1337x) {
     await getNewRepacksFromUser(
       repacker,
       existingRepacks.filter((repack) => repack.repacker === repacker)
@@ -39,19 +40,16 @@ const checkForNewRepacks = async (userPreferences: UserPreferences | null) => {
   const existingRepacks = stateManager.getValue("repacks");
 
   Promise.allSettled([
-    getNewGOGGames(
-      existingRepacks.filter((repack) => repack.repacker === "GOG")
-    ),
+    track1337xUsers(existingRepacks),
     getNewRepacksFromXatab(
       existingRepacks.filter((repack) => repack.repacker === "Xatab")
     ),
-    getNewRepacksFromCPG(
-      existingRepacks.filter((repack) => repack.repacker === "CPG")
+    getNewGOGGames(
+      existingRepacks.filter((repack) => repack.repacker === "GOG")
     ),
     getNewRepacksFromOnlineFix(
       existingRepacks.filter((repack) => repack.repacker === "onlinefix")
     ),
-    track1337xUsers(existingRepacks),
   ]).then(() => {
     repackRepository.count().then((count) => {
       const total = count - stateManager.getValue("repacks").length;
@@ -74,23 +72,18 @@ const checkForNewRepacks = async (userPreferences: UserPreferences | null) => {
 };
 
 const loadState = async (userPreferences: UserPreferences | null) => {
-  const [friendlyNames, repacks, steamGames] = await Promise.all([
-    repackerFriendlyNameRepository.find(),
-    repackRepository.find({
-      order: {
-        createdAt: "desc",
-      },
-    }),
-    steamGameRepository.find({
-      order: {
-        name: "asc",
-      },
-    }),
-  ]);
+  const repacks = await repackRepository.find({
+    order: {
+      createdAt: "desc",
+    },
+  });
+
+  const steamGames = JSON.parse(
+    fs.readFileSync(path.join(seedsPath, "steam-games.json"), "utf-8")
+  ) as SteamGame[];
 
-  stateManager.setValue("repackersFriendlyNames", friendlyNames);
   stateManager.setValue("repacks", repacks);
-  stateManager.setValue("steamGames", steamGames);
+  stateManager.setValue("steamGames", orderBy(steamGames, ["name"], "asc"));
 
   import("./events");
 

src/main/migrations/1715900413313-fix_repack_uploadDate.ts

@@ -0,0 +1,78 @@
+import { createDataSource } from "@main/data-source";
+import { Repack } from "@main/entity";
+import { app } from "electron";
+import { chunk } from "lodash-es";
+import path from "path";
+import { In, MigrationInterface, QueryRunner, Table } from "typeorm";
+
+export class FixRepackUploadDate1715900413313 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(
+      new Table({
+        name: "repack_temp",
+        columns: [
+          { name: "title", type: "varchar" },
+          { name: "old_id", type: "int" },
+        ],
+      }),
+      true
+    );
+
+    await queryRunner.query(
+      `INSERT INTO repack_temp (title, old_id) SELECT title, id FROM repack WHERE repacker IN ('onlinefix', 'Xatab');`
+    );
+
+    await queryRunner.query(
+      `DELETE FROM repack WHERE repacker IN ('onlinefix', 'Xatab');`
+    );
+
+    const updateDataSource = createDataSource({
+      database: app.isPackaged
+        ? path.join(process.resourcesPath, "hydra.db")
+        : path.join(__dirname, "..", "..", "hydra.db"),
+    });
+
+    await updateDataSource.initialize();
+
+    const updateRepackRepository = updateDataSource.getRepository(Repack);
+
+    const updatedRepacks = await updateRepackRepository.find({
+      where: {
+        repacker: In(["onlinefix", "Xatab"]),
+      },
+    });
+
+    const chunks = chunk(
+      updatedRepacks.map((repack) => {
+        const { id: _, ...rest } = repack;
+        return rest;
+      }),
+      500
+    );
+
+    for (const chunk of chunks) {
+      await queryRunner.manager
+        .createQueryBuilder(Repack, "repack")
+        .insert()
+        .values(chunk)
+        .orIgnore()
+        .execute();
+    }
+
+    await queryRunner.query(
+      `UPDATE game 
+      SET repackId = (
+        SELECT id 
+        from repack LEFT JOIN repack_temp ON repack_temp.title = repack.title
+        WHERE repack_temp.old_id = game.repackId
+      ) 
+      WHERE EXISTS (select old_id from repack_temp WHERE old_id = game.repackId)`
+    );
+
+    await queryRunner.dropTable("repack_temp");
+  }
+
+  public async down(_: QueryRunner): Promise<void> {
+    return;
+  }
+}

src/main/migrations/index.ts

@@ -0,0 +1,3 @@
+import { FixRepackUploadDate1715900413313 } from "./1715900413313-fix_repack_uploadDate";
+
+export default [FixRepackUploadDate1715900413313];

src/main/repository.ts

@@ -1,27 +1,11 @@
 import { dataSource } from "./data-source";
-import {
-  Game,
-  GameShopCache,
-  Repack,
-  RepackerFriendlyName,
-  UserPreferences,
-  MigrationScript,
-  SteamGame,
-} from "@main/entity";
+import { Game, GameShopCache, Repack, UserPreferences } from "@main/entity";
 
 export const gameRepository = dataSource.getRepository(Game);
 
 export const repackRepository = dataSource.getRepository(Repack);
 
-export const repackerFriendlyNameRepository =
-  dataSource.getRepository(RepackerFriendlyName);
-
 export const userPreferencesRepository =
   dataSource.getRepository(UserPreferences);
 
 export const gameShopCacheRepository = dataSource.getRepository(GameShopCache);
-
-export const migrationScriptRepository =
-  dataSource.getRepository(MigrationScript);
-
-export const steamGameRepository = dataSource.getRepository(SteamGame);

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

@@ -0,0 +1,40 @@
+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/downloaders/torrent.downloader.ts

@@ -1,7 +1,6 @@
 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";
 
@@ -87,8 +86,6 @@ export class TorrentDownloader extends Downloader {
           downloadSpeed: payload.downloadSpeed,
           timeRemaining: payload.timeRemaining,
         });
-      } catch (err) {
-        Sentry.captureException(err);
       } finally {
         await new Promise((resolve) => setTimeout(resolve, 100));
       }

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

@@ -1,13 +1,39 @@
 import { JSDOM } from "jsdom";
 
-import { formatUploadDate } from "@main/helpers";
-
 import { Repack } from "@main/entity";
 import { requestWebPage, savePage } from "./helpers";
 
+const months = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+
 export const request1337x = async (path: string) =>
   requestWebPage(`https://1337xx.to${path}`);
 
+const formatUploadDate = (str: string) => {
+  const date = new Date();
+
+  const [month, day, year] = str.split(" ");
+
+  date.setMonth(months.indexOf(month.replace(".", "")));
+  date.setDate(Number(day.substring(0, 2)));
+  date.setFullYear(Number("20" + year.replace("'", "")));
+  date.setHours(0, 0, 0, 0);
+
+  return date;
+};
+
 /* TODO: $a will often be null */
 const getTorrentDetails = async (path: string) => {
   const response = await request1337x(path);

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

@@ -1,64 +0,0 @@
-import { JSDOM } from "jsdom";
-
-import { Repack } from "@main/entity";
-
-import { requestWebPage, savePage } from "./helpers";
-import { logger } from "../logger";
-import type { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
-
-export const getNewRepacksFromCPG = async (
-  existingRepacks: Repack[] = [],
-  page = 1
-): Promise<void> => {
-  const data = await requestWebPage(`https://cpgrepacks.site/page/${page}`);
-
-  const { window } = new JSDOM(data);
-
-  const repacks: QueryDeepPartialEntity<Repack>[] = [];
-
-  try {
-    Array.from(window.document.querySelectorAll(".post")).forEach(($post) => {
-      const $title = $post.querySelector(".entry-title")!;
-      const uploadDate = $post.querySelector("time")?.getAttribute("datetime");
-
-      const $downloadInfo = Array.from(
-        $post.querySelectorAll(".wp-block-heading")
-      ).find(($heading) => $heading.textContent?.startsWith("Download"));
-
-      /* Side note: CPG often misspells "Magnet" as "Magent" */
-      const $magnet = Array.from($post.querySelectorAll("a")).find(
-        ($a) =>
-          $a.textContent?.startsWith("Magnet") ||
-          $a.textContent?.startsWith("Magent")
-      );
-
-      const fileSize = ($downloadInfo?.textContent ?? "")
-        .split("Download link => ")
-        .at(1);
-
-      repacks.push({
-        title: $title.textContent!,
-        fileSize: fileSize ?? "N/A",
-        magnet: $magnet!.href,
-        repacker: "CPG",
-        page,
-        uploadDate: uploadDate ? new Date(uploadDate) : new Date(),
-      });
-    });
-  } catch (err: unknown) {
-    logger.error((err as Error).message, { method: "getNewRepacksFromCPG" });
-  }
-
-  const newRepacks = repacks.filter(
-    (repack) =>
-      !existingRepacks.some(
-        (existingRepack) => existingRepack.title === repack.title
-      )
-  );
-
-  if (!newRepacks.length) return;
-
-  await savePage(newRepacks);
-
-  return getNewRepacksFromCPG(existingRepacks, page + 1);
-};

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

@@ -6,32 +6,57 @@ import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity
 
 const virtualConsole = new VirtualConsole();
 
+const getUploadDate = (document: Document) => {
+  const $modifiedTime = document.querySelector(
+    '[property="article:modified_time"]'
+  ) as HTMLMetaElement;
+  if ($modifiedTime) return $modifiedTime.content;
+
+  const $publishedTime = document.querySelector(
+    '[property="article:published_time"]'
+  ) as HTMLMetaElement;
+  return $publishedTime.content;
+};
+
+const getDownloadLink = (document: Document) => {
+  const $latestDownloadButton = document.querySelector(
+    ".download-btn:not(.lightweight-accordion *)"
+  ) as HTMLAnchorElement;
+  if ($latestDownloadButton) return $latestDownloadButton.href;
+
+  const $downloadButton = document.querySelector(
+    ".download-btn"
+  ) as HTMLAnchorElement;
+  if (!$downloadButton) return null;
+
+  return $downloadButton.href;
+};
+
+const getMagnet = (downloadLink: string) => {
+  if (downloadLink.startsWith("http")) {
+    const { searchParams } = new URL(downloadLink);
+    return Buffer.from(searchParams.get("url")!, "base64").toString("utf-8");
+  }
+
+  return downloadLink;
+};
+
 const getGOGGame = async (url: string) => {
   const data = await requestWebPage(url);
   const { window } = new JSDOM(data, { virtualConsole });
 
-  const $modifiedTime = window.document.querySelector(
-    '[property="article:modified_time"]'
-  ) as HTMLMetaElement;
+  const downloadLink = getDownloadLink(window.document);
+  if (!downloadLink) return null;
 
-  const $em = window.document.querySelector(
-    "p:not(.lightweight-accordion *) em"
-  )!;
+  const $em = window.document.querySelector("p em");
+  if (!$em) return null;
   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(
-    "utf-8"
-  );
 
   return {
     fileSize: fileSize ?? "N/A",
-    uploadDate: new Date($modifiedTime.content),
+    uploadDate: new Date(getUploadDate(window.document)),
     repacker: "GOG",
-    magnet,
+    magnet: getMagnet(downloadLink),
     page: 1,
   };
 };
@@ -62,7 +87,7 @@ export const getNewGOGGames = async (existingRepacks: Repack[] = []) => {
       if (!gameExists) {
         const game = await getGOGGame(href);
 
-        repacks.push({ ...game, title });
+        if (game) repacks.push({ ...game, title });
       }
     }
 

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

@@ -1,3 +1,4 @@
+import axios from "axios";
 import UserAgent from "user-agents";
 
 import type { Repack } from "@main/entity";
@@ -13,12 +14,13 @@ export const savePage = async (repacks: QueryDeepPartialEntity<Repack>[]) =>
 export const requestWebPage = async (url: string) => {
   const userAgent = new UserAgent();
 
-  return fetch(url, {
-    method: "GET",
-    headers: {
-      "User-Agent": userAgent.toString(),
-    },
-  }).then((response) => response.text());
+  return axios
+    .get(url, {
+      headers: {
+        "User-Agent": userAgent.toString(),
+      },
+    })
+    .then((response) => response.data);
 };
 
 export const decodeNonUtf8Response = async (res: Response) => {

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

@@ -1,5 +1,4 @@
 export * from "./1337x";
 export * from "./xatab";
-export * from "./cpg-repacks";
 export * from "./gog";
 export * from "./online-fix";

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

@@ -1,22 +1,21 @@
 import { Repack } from "@main/entity";
 import { decodeNonUtf8Response, savePage } from "./helpers";
 import { logger } from "../logger";
-import parseTorrent, {
-  toMagnetURI,
-  Instance as TorrentInstance,
-} from "parse-torrent";
 import { JSDOM } from "jsdom";
 
-import { format, parse, sub } from "date-fns";
-import { ru } from "date-fns/locale";
+import createWorker from "@main/workers/torrent-parser.worker?nodeWorker";
+import { toMagnetURI } from "parse-torrent";
+
+const worker = createWorker({});
 
-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/";
 
+let totalPages = 1;
+
 export const getNewRepacksFromOnlineFix = async (
   existingRepacks: Repack[] = [],
   page = 1,
@@ -73,18 +72,16 @@ export const getNewRepacksFromOnlineFix = async (
 
   const repacks: QueryDeepPartialEntity<Repack>[] = [];
   const articles = Array.from(document.querySelectorAll(".news"));
-  const totalPages = Number(
-    document.querySelector("nav > a:nth-child(13)")?.textContent
-  );
+
+  if (page == 1) {
+    totalPages = Number(
+      document.querySelector("nav > a:nth-child(13)")?.textContent
+    );
+  }
 
   try {
     await Promise.all(
       articles.map(async (article) => {
-        const gameText = article.querySelector("h2.title")?.textContent?.trim();
-        if (!gameText) return;
-
-        const gameName = onlinefixFormatter(gameText);
-
         const gameLink = article.querySelector("a")?.getAttribute("href");
         if (!gameLink) return;
 
@@ -93,32 +90,6 @@ export const getNewRepacksFromOnlineFix = async (
         );
         const gameDocument = new JSDOM(gamePage).window.document;
 
-        const uploadDateText = gameDocument.querySelector("time")?.textContent;
-        if (!uploadDateText) return;
-
-        let decodedDateText = uploadDateText;
-
-        // "Вчера" means yesterday.
-        if (decodedDateText.includes("Вчера")) {
-          const yesterday = sub(new Date(), { days: 1 });
-          const formattedYesterday = format(yesterday, "d LLLL yyyy", {
-            locale: ru,
-          });
-          decodedDateText = decodedDateText.replace(
-            "Вчера", // "Change yesterday to the default expected date format"
-            formattedYesterday
-          );
-        }
-
-        const uploadDate = parse(
-          decodedDateText,
-          "d LLLL yyyy, HH:mm",
-          new Date(),
-          {
-            locale: ru,
-          }
-        );
-
         const torrentButtons = Array.from(
           gameDocument.querySelectorAll("a")
         ).filter((a) => a.textContent?.includes("Torrent"));
@@ -139,27 +110,27 @@ export const getNewRepacksFromOnlineFix = async (
           ?.getAttribute("href");
 
         const torrentFile = Buffer.from(
-          await http(`${torrentPrePage}/${torrentLink}`).then((res) =>
+          await http(`${torrentPrePage}${torrentLink}`).then((res) =>
             res.arrayBuffer()
           )
         );
 
-        const torrent = parseTorrent(torrentFile) as TorrentInstance;
-        const magnetLink = toMagnetURI({
-          infoHash: torrent.infoHash,
+        worker.once("message", (torrent) => {
+          if (!torrent) return;
+
+          const { name, created } = torrent;
+
+          repacks.push({
+            fileSize: formatBytes(torrent.length ?? 0),
+            magnet: toMagnetURI(torrent),
+            page: 1,
+            repacker: "onlinefix",
+            title: name,
+            uploadDate: created,
+          });
         });
 
-        const torrentSizeInBytes = torrent.length;
-        if (!torrentSizeInBytes) return;
-
-        repacks.push({
-          fileSize: formatBytes(torrentSizeInBytes),
-          magnet: magnetLink,
-          page: 1,
-          repacker: "onlinefix",
-          title: gameName,
-          uploadDate: uploadDate,
-        });
+        worker.postMessage(torrentFile);
       })
     );
   } catch (err: unknown) {
@@ -177,9 +148,10 @@ export const getNewRepacksFromOnlineFix = async (
   );
 
   if (!newRepacks.length) return;
-  if (page === totalPages) return;
 
   await savePage(newRepacks);
 
+  if (page === totalPages) return;
+
   return getNewRepacksFromOnlineFix(existingRepacks, page + 1, cookieJar);
 };

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

@@ -9,8 +9,12 @@ import { toMagnetURI } from "parse-torrent";
 import type { Instance } from "parse-torrent";
 import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 import { formatBytes } from "@shared";
+import { getFileBuffer } from "@main/helpers";
 
 const worker = createWorker({});
+worker.setMaxListeners(11);
+
+let totalPages = 1;
 
 const formatXatabDate = (str: string) => {
   const date = new Date();
@@ -27,7 +31,7 @@ const formatXatabDate = (str: string) => {
 
 const getXatabRepack = (
   url: string
-): Promise<{ fileSize: string; magnet: string; uploadDate: Date }> => {
+): Promise<{ fileSize: string; magnet: string; uploadDate: Date } | null> => {
   return new Promise((resolve) => {
     (async () => {
       const data = await requestWebPage(url);
@@ -40,15 +44,20 @@ const getXatabRepack = (
         ".download-torrent"
       ) as HTMLAnchorElement;
 
-      if (!$downloadButton) throw new Error("Download button not found");
+      if (!$downloadButton) return resolve(null);
+
+      worker.once("message", (torrent: Instance | null) => {
+        if (!torrent) return resolve(null);
 
-      worker.once("message", (torrent: Instance) => {
         resolve({
           fileSize: formatBytes(torrent.length ?? 0),
           magnet: toMagnetURI(torrent),
           uploadDate: formatXatabDate($uploadDate!.textContent!),
         });
       });
+
+      const buffer = await getFileBuffer($downloadButton.href);
+      worker.postMessage(buffer);
     })();
   });
 };
@@ -63,25 +72,37 @@ export const getNewRepacksFromXatab = async (
 
   const repacks: QueryDeepPartialEntity<Repack>[] = [];
 
-  for (const $a of Array.from(
-    window.document.querySelectorAll(".entry__title a")
-  )) {
-    try {
-      const repack = await getXatabRepack(($a as HTMLAnchorElement).href);
-
-      repacks.push({
-        title: $a.textContent!,
-        repacker: "Xatab",
-        ...repack,
-        page,
-      });
-    } catch (err: unknown) {
-      logger.error((err as Error).message, {
-        method: "getNewRepacksFromXatab",
-      });
-    }
+  if (page === 1) {
+    totalPages = Number(
+      window.document.querySelector(
+        "#bottom-nav > div.pagination > a:nth-child(12)"
+      )?.textContent
+    );
   }
 
+  const repacksFromPage = Array.from(
+    window.document.querySelectorAll(".entry__title a")
+  ).map(($a) => {
+    return getXatabRepack(($a as HTMLAnchorElement).href)
+      .then((repack) => {
+        if (repack) {
+          repacks.push({
+            title: $a.textContent!,
+            repacker: "Xatab",
+            ...repack,
+            page,
+          });
+        }
+      })
+      .catch((err: unknown) => {
+        logger.error((err as Error).message, {
+          method: "getNewRepacksFromXatab",
+        });
+      });
+  });
+
+  await Promise.all(repacksFromPage);
+
   const newRepacks = repacks.filter(
     (repack) =>
       !existingRepacks.some(
@@ -93,5 +114,7 @@ export const getNewRepacksFromXatab = async (
 
   await savePage(newRepacks);
 
+  if (page === totalPages) return;
+
   return getNewRepacksFromXatab(existingRepacks, page + 1);
 };

src/main/services/steam-grid.ts

@@ -1,5 +1,4 @@
 import axios from "axios";
-import { getSteamAppAsset } from "@main/helpers";
 
 export interface SteamGridResponse {
   success: boolean;
@@ -59,16 +58,11 @@ export const getSteamGridGameById = async (
   return response.data;
 };
 
-export const getSteamGameIconUrl = async (objectID: string) => {
+export const getSteamGameClientIcon = async (objectID: string) => {
   const {
     data: { id: steamGridGameId },
   } = await getSteamGridData(objectID, "games", "steam");
 
   const steamGridGame = await getSteamGridGameById(steamGridGameId);
-
-  return getSteamAppAsset(
-    "icon",
-    objectID,
-    steamGridGame.data.platforms.steam.metadata.clienticon
-  );
+  return steamGridGame.data.platforms.steam.metadata.clienticon;
 };

src/main/services/update-resolver.ts

@@ -3,107 +3,9 @@ import { app } from "electron";
 
 import { chunk } from "lodash-es";
 
-import { createDataSource, dataSource } from "@main/data-source";
-import { Repack, RepackerFriendlyName, SteamGame } from "@main/entity";
-import {
-  migrationScriptRepository,
-  repackRepository,
-  repackerFriendlyNameRepository,
-  steamGameRepository,
-} from "@main/repository";
-import { MigrationScript } from "@main/entity/migration-script.entity";
-import { Like } from "typeorm";
-
-const migrationScripts = {
-  /*
-    0.0.6 -> 0.0.7
-    Xatab repacks were previously created with an incorrect upload date.
-    This migration script will update the upload date of all Xatab repacks.
-  */
-  "0.0.7": async (updateRepacks: Repack[]) => {
-    const VERSION = "0.0.7";
-
-    const migrationScript = await migrationScriptRepository.findOne({
-      where: {
-        version: VERSION,
-      },
-    });
-
-    if (!migrationScript) {
-      const xatabRepacks = updateRepacks.filter(
-        (repack) => repack.repacker === "Xatab"
-      );
-
-      await dataSource.transaction(async (transactionalEntityManager) => {
-        await Promise.all(
-          xatabRepacks.map((repack) =>
-            transactionalEntityManager.getRepository(Repack).update(
-              {
-                title: repack.title,
-                repacker: repack.repacker,
-              },
-              {
-                uploadDate: repack.uploadDate,
-              }
-            )
-          )
-        );
-
-        await transactionalEntityManager.getRepository(MigrationScript).insert({
-          version: VERSION,
-        });
-      });
-    }
-  },
-  /*
-    1.0.1 -> 1.1.0
-    A few torrents scraped from 1337x were previously created with an incorrect upload date.
-  */
-  "1.1.0": async () => {
-    const VERSION = "1.1.0";
-
-    const migrationScript = await migrationScriptRepository.findOne({
-      where: {
-        version: VERSION,
-      },
-    });
-
-    if (!migrationScript) {
-      await dataSource.transaction(async (transactionalEntityManager) => {
-        const repacks = await transactionalEntityManager
-          .getRepository(Repack)
-          .find({
-            where: {
-              uploadDate: Like("1%"),
-            },
-          });
-
-        await Promise.all(
-          repacks.map(async (repack) => {
-            return transactionalEntityManager
-              .getRepository(Repack)
-              .update(
-                { id: repack.id },
-                { uploadDate: new Date(repack.uploadDate) }
-              );
-          })
-        );
-
-        await transactionalEntityManager.getRepository(MigrationScript).insert({
-          version: VERSION,
-        });
-      });
-    }
-  },
-};
-
-export const runMigrationScripts = async (updateRepacks: Repack[]) => {
-  return Promise.all(
-    Object.values(migrationScripts).map((migrationScript) => {
-      return migrationScript(updateRepacks);
-    })
-  );
-};
+import { createDataSource } from "@main/data-source";
+import { Repack } from "@main/entity";
+import { repackRepository } from "@main/repository";
 
 export const resolveDatabaseUpdates = async () => {
   const updateDataSource = createDataSource({
@@ -114,25 +16,8 @@ export const resolveDatabaseUpdates = async () => {
 
   return updateDataSource.initialize().then(async () => {
     const updateRepackRepository = updateDataSource.getRepository(Repack);
-    const updateRepackerFriendlyNameRepository =
-      updateDataSource.getRepository(RepackerFriendlyName);
-    const updateSteamGameRepository = updateDataSource.getRepository(SteamGame);
 
-    const [updateRepacks, updateSteamGames, updateRepackerFriendlyNames] =
-      await Promise.all([
-        updateRepackRepository.find(),
-        updateSteamGameRepository.find(),
-        updateRepackerFriendlyNameRepository.find(),
-      ]);
-
-    await runMigrationScripts(updateRepacks);
-
-    await repackerFriendlyNameRepository
-      .createQueryBuilder()
-      .insert()
-      .values(updateRepackerFriendlyNames)
-      .orIgnore()
-      .execute();
+    const updateRepacks = await updateRepackRepository.find();
 
     const updateRepacksChunks = chunk(updateRepacks, 800);
 
@@ -144,16 +29,5 @@ export const resolveDatabaseUpdates = async () => {
         .orIgnore()
         .execute();
     }
-
-    const steamGamesChunks = chunk(updateSteamGames, 800);
-
-    for (const chunk of steamGamesChunks) {
-      await steamGameRepository
-        .createQueryBuilder()
-        .insert()
-        .values(chunk)
-        .orIgnore()
-        .execute();
-    }
   });
 };

src/main/services/window-manager.ts

@@ -1,13 +1,24 @@
-import { BrowserWindow, Menu, Tray, app } from "electron";
+import {
+  BrowserWindow,
+  Menu,
+  MenuItem,
+  MenuItemConstructorOptions,
+  Tray,
+  app,
+  shell,
+} from "electron";
 import { is } from "@electron-toolkit/utils";
 import { t } from "i18next";
 import path from "node:path";
 import icon from "@resources/icon.png?asset";
 import trayIcon from "@resources/tray-icon.png?asset";
-import { userPreferencesRepository } from "@main/repository";
+import { gameRepository, userPreferencesRepository } from "@main/repository";
+import { IsNull, Not } from "typeorm";
 
 export class WindowManager {
   public static mainWindow: Electron.BrowserWindow | null = null;
+  public static splashWindow: Electron.BrowserWindow | null = null;
+  public static isReadyToShowMainWindow = false;
 
   private static loadURL(hash = "") {
     // HMR for renderer base on electron-vite cli.
@@ -26,13 +37,51 @@ export class WindowManager {
     }
   }
 
+  private static loadSplashURL() {
+    // HMR for renderer base on electron-vite cli.
+    // Load the remote URL for development or the local html file for production.
+    if (is.dev && process.env["ELECTRON_RENDERER_URL"]) {
+      this.splashWindow?.loadURL(
+        `${process.env["ELECTRON_RENDERER_URL"]}#/splash`
+      );
+    } else {
+      this.splashWindow?.loadFile(
+        path.join(__dirname, "../renderer/index.html"),
+        {
+          hash: "splash",
+        }
+      );
+    }
+  }
+
+  public static createSplashScreen() {
+    if (this.splashWindow) return;
+
+    this.splashWindow = new BrowserWindow({
+      width: 380,
+      height: 380,
+      frame: false,
+      resizable: false,
+      backgroundColor: "#1c1c1c",
+      webPreferences: {
+        preload: path.join(__dirname, "../preload/index.mjs"),
+        sandbox: false,
+      },
+    });
+
+    this.loadSplashURL();
+    this.splashWindow.removeMenu();
+  }
+
   public static createMainWindow() {
-    // Create the browser window.
+    if (this.mainWindow || !this.isReadyToShowMainWindow) return;
+
     this.mainWindow = new BrowserWindow({
       width: 1200,
       height: 720,
       minWidth: 1024,
       minHeight: 540,
+      backgroundColor: "#1c1c1c",
       titleBarStyle: "hidden",
       ...(process.platform === "linux" ? { icon } : {}),
       trafficLightPosition: { x: 16, y: 16 },
@@ -66,6 +115,12 @@ export class WindowManager {
     });
   }
 
+  public static prepareMainWindowAndCloseSplash() {
+    this.isReadyToShowMainWindow = true;
+    this.splashWindow?.close();
+    this.createMainWindow();
+  }
+
   public static redirect(hash: string) {
     if (!this.mainWindow) this.createMainWindow();
     this.loadURL(hash);
@@ -77,33 +132,66 @@ export class WindowManager {
   public static createSystemTray(language: string) {
     const tray = new Tray(trayIcon);
 
-    const contextMenu = Menu.buildFromTemplate([
-      {
-        label: t("open", {
-          ns: "system_tray",
-          lng: language,
-        }),
-        type: "normal",
-        click: () => {
-          if (this.mainWindow) {
-            this.mainWindow.show();
-          } else {
-            this.createMainWindow();
-          }
+    const updateSystemTray = async () => {
+      const games = await gameRepository.find({
+        where: {
+          isDeleted: false,
+          executablePath: Not(IsNull()),
+          lastTimePlayed: Not(IsNull()),
         },
-      },
-      {
-        label: t("quit", {
-          ns: "system_tray",
-          lng: language,
-        }),
-        type: "normal",
-        click: () => app.quit(),
-      },
-    ]);
+        take: 5,
+        order: {
+          updatedAt: "DESC",
+        },
+      });
+
+      const recentlyPlayedGames: Array<MenuItemConstructorOptions | MenuItem> =
+        games.map(({ title, executablePath }) => ({
+          label: title,
+          type: "normal",
+          click: async () => {
+            if (!executablePath) return;
+
+            shell.openPath(executablePath);
+          },
+        }));
+
+      const contextMenu = Menu.buildFromTemplate([
+        {
+          label: t("open", {
+            ns: "system_tray",
+            lng: language,
+          }),
+          type: "normal",
+          click: () => {
+            if (this.mainWindow) {
+              this.mainWindow.show();
+            } else {
+              this.createMainWindow();
+            }
+          },
+        },
+        {
+          type: "separator",
+        },
+        ...recentlyPlayedGames,
+        {
+          type: "separator",
+        },
+        {
+          label: t("quit", {
+            ns: "system_tray",
+            lng: language,
+          }),
+          type: "normal",
+          click: () => app.quit(),
+        },
+      ]);
+
+      return contextMenu;
+    };
 
     tray.setToolTip("Hydra");
-    tray.setContextMenu(contextMenu);
 
     if (process.platform === "win32" || process.platform === "linux") {
       tray.addListener("click", () => {
@@ -117,6 +205,11 @@ export class WindowManager {
 
         this.createMainWindow();
       });
+
+      tray.addListener("right-click", async () => {
+        const contextMenu = await updateSystemTray();
+        tray.popUpContextMenu(contextMenu);
+      });
     }
   }
 }

src/main/state-manager.ts

@@ -1,17 +1,14 @@
-import type { Repack, RepackerFriendlyName, SteamGame } from "@main/entity";
+import type { Repack } from "@main/entity";
+import type { SteamGame } from "@types";
 
 interface State {
   repacks: Repack[];
-  repackersFriendlyNames: RepackerFriendlyName[];
   steamGames: SteamGame[];
-  eventResults: Map<[string, any[]], any>;
 }
 
 const initialState: State = {
   repacks: [],
-  repackersFriendlyNames: [],
   steamGames: [],
-  eventResults: new Map(),
 };
 
 export class StateManager {

src/main/vite-env.d.ts

@@ -4,7 +4,6 @@ interface ImportMetaEnv {
   readonly MAIN_VITE_STEAMGRIDDB_API_KEY: string;
   readonly MAIN_VITE_ONLINEFIX_USERNAME: string;
   readonly MAIN_VITE_ONLINEFIX_PASSWORD: string;
-  readonly MAIN_VITE_SENTRY_DSN: string;
 }
 
 interface ImportMeta {

src/main/workers/torrent-parser.worker.ts

@@ -4,13 +4,11 @@ import parseTorrent from "parse-torrent";
 const port = parentPort;
 if (!port) throw new Error("IllegalState");
 
-export const getFileBuffer = async (url: string) =>
-  fetch(url, { method: "GET" }).then((response) =>
-    response.arrayBuffer().then((buffer) => Buffer.from(buffer))
-  );
-
-port.on("message", async (url: string) => {
-  const buffer = await getFileBuffer(url);
-  const torrent = await parseTorrent(buffer);
-  port.postMessage(torrent);
+port.on("message", async (buffer: Buffer) => {
+  try {
+    const torrent = await parseTorrent(buffer);
+    port.postMessage(torrent);
+  } catch (err) {
+    port.postMessage(null);
+  }
 });