Merge branch 'feature/game-achievements' into chore/test-preview

# Conflicts:
#	src/main/services/window-manager.ts
#	src/renderer/src/context/game-details/game-details.context.tsx
#	src/renderer/src/declaration.d.ts
#	src/types/index.ts
#	yarn.lock

src/main/services/achievements/achievement-watcher.ts

@@ -0,0 +1,14 @@
+import { gameRepository } from "@main/repository";
+import { startGameAchievementObserver as searchForAchievements } from "./game-achievements-observer";
+
+export const watchAchievements = async () => {
+  const games = await gameRepository.find({
+    where: {
+      isDeleted: false,
+    },
+  });
+
+  if (games.length === 0) return;
+
+  await searchForAchievements(games);
+};

src/main/services/achievements/check-unlocked-achievements.ts

@@ -0,0 +1,82 @@
+import { Cracker } from "@shared";
+import type { UnlockedAchievement } from "@types";
+
+export const checkUnlockedAchievements = (
+  type: Cracker,
+  unlockedAchievements: any
+): UnlockedAchievement[] => {
+  if (type === Cracker.onlineFix) return onlineFixMerge(unlockedAchievements);
+  if (type === Cracker.goldberg)
+    return goldbergUnlockedAchievements(unlockedAchievements);
+  if (type == Cracker.generic) return genericMerge(unlockedAchievements);
+  return defaultMerge(unlockedAchievements);
+};
+
+const onlineFixMerge = (unlockedAchievements: any): UnlockedAchievement[] => {
+  const parsedUnlockedAchievements: UnlockedAchievement[] = [];
+
+  for (const achievement of Object.keys(unlockedAchievements)) {
+    const unlockedAchievement = unlockedAchievements[achievement];
+
+    if (unlockedAchievement?.achieved) {
+      parsedUnlockedAchievements.push({
+        name: achievement,
+        unlockTime: unlockedAchievement.timestamp,
+      });
+    }
+  }
+
+  return parsedUnlockedAchievements;
+};
+
+const goldbergUnlockedAchievements = (
+  unlockedAchievements: any
+): UnlockedAchievement[] => {
+  const newUnlockedAchievements: UnlockedAchievement[] = [];
+
+  for (const achievement of Object.keys(unlockedAchievements)) {
+    const unlockedAchievement = unlockedAchievements[achievement];
+
+    if (unlockedAchievement?.earned) {
+      newUnlockedAchievements.push({
+        name: achievement,
+        unlockTime: unlockedAchievement.earned_time,
+      });
+    }
+  }
+  return newUnlockedAchievements;
+};
+
+const defaultMerge = (unlockedAchievements: any): UnlockedAchievement[] => {
+  const newUnlockedAchievements: UnlockedAchievement[] = [];
+
+  for (const achievement of Object.keys(unlockedAchievements)) {
+    const unlockedAchievement = unlockedAchievements[achievement];
+
+    if (unlockedAchievement?.Achieved) {
+      newUnlockedAchievements.push({
+        name: achievement,
+        unlockTime: unlockedAchievement.UnlockTime,
+      });
+    }
+  }
+
+  return newUnlockedAchievements;
+};
+
+const genericMerge = (unlockedAchievements: any): UnlockedAchievement[] => {
+  const newUnlockedAchievements: UnlockedAchievement[] = [];
+
+  for (const achievement of Object.keys(unlockedAchievements)) {
+    const unlockedAchievement = unlockedAchievements[achievement];
+
+    if (unlockedAchievement?.unlocked) {
+      newUnlockedAchievements.push({
+        name: achievement,
+        unlockTime: unlockedAchievement.time,
+      });
+    }
+  }
+
+  return newUnlockedAchievements;
+};

src/main/services/achievements/find-steam-game-achivement-files.ts

@@ -0,0 +1,141 @@
+import path from "node:path";
+import fs from "node:fs";
+import { app } from "electron";
+import type { AchievementFile } from "@types";
+import { Cracker } from "@shared";
+import { Game } from "@main/entity";
+
+//TODO: change to a automatized method
+const publicDir = path.join("C:", "Users", "Public", "Documents");
+const appData = app.getPath("appData");
+
+const addGame = (
+  achievementFiles: Map<string, AchievementFile[]>,
+  achievementPath: string,
+  objectId: string,
+  fileLocation: string[],
+  type: Cracker
+) => {
+  const filePath = path.join(achievementPath, objectId, ...fileLocation);
+
+  if (!fs.existsSync(filePath)) return;
+
+  const achivementFile = {
+    type,
+    filePath,
+  };
+
+  achievementFiles.get(objectId)
+    ? achievementFiles.get(objectId)!.push(achivementFile)
+    : achievementFiles.set(objectId, [achivementFile]);
+};
+
+const getObjectIdsInFolder = (path: string) => {
+  if (fs.existsSync(path)) {
+    return fs.readdirSync(path);
+  }
+
+  return [];
+};
+
+export const findSteamGameAchievementFiles = (game: Game) => {
+  const crackers = [
+    Cracker.codex,
+    Cracker.goldberg,
+    Cracker.rune,
+    Cracker.onlineFix,
+    Cracker.generic,
+  ];
+
+  const achievementFiles: AchievementFile[] = [];
+  for (const cracker of crackers) {
+    let achievementPath: string;
+    let fileLocation: string[];
+
+    if (cracker === Cracker.onlineFix) {
+      achievementPath = path.join(publicDir, Cracker.onlineFix);
+      fileLocation = ["Stats", "Achievements.ini"];
+    } else if (cracker === Cracker.goldberg) {
+      achievementPath = path.join(appData, "Goldberg SteamEmu Saves");
+      fileLocation = ["achievements.json"];
+    } else if (cracker === Cracker.generic) {
+      achievementPath = path.join(publicDir, Cracker.generic);
+      fileLocation = ["user_stats.ini"];
+    } else {
+      achievementPath = path.join(publicDir, "Steam", cracker);
+      fileLocation = ["achievements.ini"];
+    }
+
+    const filePath = path.join(achievementPath, game.objectID, ...fileLocation);
+
+    if (fs.existsSync(filePath)) {
+      achievementFiles.push({
+        type: cracker,
+        filePath: path.join(achievementPath, game.objectID, ...fileLocation),
+      });
+    }
+  }
+
+  return achievementFiles;
+};
+
+export const findAchievementFileInExecutableDirectory = (
+  game: Game
+): AchievementFile | null => {
+  if (!game.executablePath) {
+    return null;
+  }
+
+  const steamDataPath = path.join(
+    game.executablePath,
+    "..",
+    "SteamData",
+    "user_stats.ini"
+  );
+
+  return {
+    type: Cracker.generic,
+    filePath: steamDataPath,
+  };
+};
+
+export const findAllSteamGameAchievementFiles = () => {
+  const gameAchievementFiles = new Map<string, AchievementFile[]>();
+
+  const crackers = [
+    Cracker.codex,
+    Cracker.goldberg,
+    Cracker.rune,
+    Cracker.onlineFix,
+  ];
+
+  for (const cracker of crackers) {
+    let achievementPath: string;
+    let fileLocation: string[];
+
+    if (cracker === Cracker.onlineFix) {
+      achievementPath = path.join(publicDir, Cracker.onlineFix);
+      fileLocation = ["Stats", "Achievements.ini"];
+    } else if (cracker === Cracker.goldberg) {
+      achievementPath = path.join(appData, "Goldberg SteamEmu Saves");
+      fileLocation = ["achievements.json"];
+    } else {
+      achievementPath = path.join(publicDir, "Steam", cracker);
+      fileLocation = ["achievements.ini"];
+    }
+
+    const objectIds = getObjectIdsInFolder(achievementPath);
+
+    for (const objectId of objectIds) {
+      addGame(
+        gameAchievementFiles,
+        achievementPath,
+        objectId,
+        fileLocation,
+        cracker
+      );
+    }
+  }
+
+  return gameAchievementFiles;
+};

src/main/services/achievements/game-achievements-observer.ts

@@ -0,0 +1,86 @@
+import { checkUnlockedAchievements } from "./check-unlocked-achievements";
+import { parseAchievementFile } from "./parse-achievement-file";
+import { Game } from "@main/entity";
+import { mergeAchievements } from "./merge-achievements";
+import fs from "node:fs";
+import {
+  findAchievementFileInExecutableDirectory,
+  findAllSteamGameAchievementFiles,
+} from "./find-steam-game-achivement-files";
+import type { AchievementFile } from "@types";
+import { logger } from "../logger";
+
+const fileStats: Map<string, number> = new Map();
+
+const processAchievementFile = async (game: Game, file: AchievementFile) => {
+  const localAchievementFile = await parseAchievementFile(
+    file.filePath,
+    file.type
+  );
+
+  logger.log("Parsed achievements file", file.filePath, localAchievementFile);
+  if (localAchievementFile) {
+    const unlockedAchievements = checkUnlockedAchievements(
+      file.type,
+      localAchievementFile
+    );
+    logger.log("Achievements from file", file.filePath, unlockedAchievements);
+
+    if (unlockedAchievements.length) {
+      return mergeAchievements(
+        game.objectID,
+        game.shop,
+        unlockedAchievements,
+        true
+      );
+    }
+  }
+};
+
+const compareFile = async (game: Game, file: AchievementFile) => {
+  try {
+    const stat = fs.statSync(file.filePath);
+    const currentFileStat = fileStats.get(file.filePath);
+    fileStats.set(file.filePath, stat.mtimeMs);
+
+    if (!currentFileStat || currentFileStat === stat.mtimeMs) {
+      return;
+    }
+
+    logger.log(
+      "Detected change in file",
+      file.filePath,
+      stat.mtimeMs,
+      fileStats.get(file.filePath)
+    );
+    await processAchievementFile(game, file);
+  } catch (err) {
+    fileStats.set(file.filePath, -1);
+  }
+};
+
+export const startGameAchievementObserver = async (games: Game[]) => {
+  const achievementFiles = findAllSteamGameAchievementFiles();
+
+  for (const game of games) {
+    const gameAchievementFiles = achievementFiles.get(game.objectID) || [];
+    const achievementFileInsideDirectory =
+      findAchievementFileInExecutableDirectory(game);
+
+    if (achievementFileInsideDirectory) {
+      gameAchievementFiles.push(achievementFileInsideDirectory);
+    }
+
+    if (!gameAchievementFiles.length) continue;
+
+    logger.log(
+      "Achievements files to observe for:",
+      game.title,
+      gameAchievementFiles
+    );
+
+    for (const file of gameAchievementFiles) {
+      compareFile(game, file);
+    }
+  }
+};

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

@@ -0,0 +1,17 @@
+import { userPreferencesRepository } from "@main/repository";
+import { HydraApi } from "../hydra-api";
+
+export const getGameAchievementData = async (
+  objectId: string,
+  shop: string
+) => {
+  const userPreferences = await userPreferencesRepository.findOne({
+    where: { id: 1 },
+  });
+
+  return HydraApi.get("/games/achievements", {
+    shop,
+    objectId,
+    language: userPreferences?.language || "en",
+  });
+};

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

@@ -0,0 +1,116 @@
+import { gameAchievementRepository, gameRepository } from "@main/repository";
+import type { GameShop, UnlockedAchievement } from "@types";
+import { WindowManager } from "../window-manager";
+import { HydraApi } from "../hydra-api";
+
+const saveAchievementsOnLocal = async (
+  objectId: string,
+  shop: string,
+  achievements: any[]
+) => {
+  return gameAchievementRepository
+    .upsert(
+      {
+        objectId,
+        shop,
+        unlockedAchievements: JSON.stringify(achievements),
+      },
+      ["objectId", "shop"]
+    )
+    .then(() => {
+      WindowManager.mainWindow?.webContents.send(
+        "on-achievement-unlocked",
+        objectId,
+        shop
+      );
+    });
+};
+
+export const mergeAchievements = async (
+  objectId: string,
+  shop: string,
+  achievements: UnlockedAchievement[],
+  publishNotification: boolean
+) => {
+  const game = await gameRepository.findOne({
+    where: { objectID: objectId, shop: shop as GameShop },
+  });
+
+  if (!game) return;
+
+  const localGameAchievement = await gameAchievementRepository.findOne({
+    where: {
+      objectId,
+      shop,
+    },
+  });
+
+  const unlockedAchievements = JSON.parse(
+    localGameAchievement?.unlockedAchievements || "[]"
+  );
+
+  const newAchievements = achievements
+    .filter((achievement) => {
+      return !unlockedAchievements.some((localAchievement) => {
+        return localAchievement.name === achievement.name.toUpperCase();
+      });
+    })
+    .map((achievement) => {
+      return {
+        name: achievement.name.toUpperCase(),
+        unlockTime: achievement.unlockTime * 1000,
+      };
+    });
+
+  if (newAchievements.length && publishNotification) {
+    const achievementsInfo = newAchievements
+      .map((achievement) => {
+        return JSON.parse(localGameAchievement?.achievements || "[]").find(
+          (steamAchievement) => {
+            return achievement.name === steamAchievement.name;
+          }
+        );
+      })
+      .filter((achievement) => achievement)
+      .map((achievement) => {
+        return {
+          displayName: achievement.displayName,
+          iconUrl: achievement.icon,
+        };
+      });
+
+    WindowManager.notificationWindow?.webContents.send(
+      "on-achievement-unlocked",
+      objectId,
+      shop,
+      achievementsInfo
+    );
+
+    WindowManager.notificationWindow?.setBounds({ y: 50 });
+
+    setTimeout(() => {
+      WindowManager.notificationWindow?.setBounds({ y: -9999 });
+    }, 4000);
+  }
+
+  const mergedLocalAchievements = unlockedAchievements.concat(newAchievements);
+
+  if (game?.remoteId) {
+    return HydraApi.put("/profile/games/achievements", {
+      id: game.remoteId,
+      achievements: mergedLocalAchievements,
+    })
+      .then((response) => {
+        return saveAchievementsOnLocal(
+          response.objectId,
+          response.shop,
+          response.achievements
+        );
+      })
+      .catch(() => {
+        return saveAchievementsOnLocal(objectId, shop, mergedLocalAchievements);
+      });
+  }
+
+  return saveAchievementsOnLocal(objectId, shop, mergedLocalAchievements);
+};

src/main/services/achievements/parse-achievement-file.ts

@@ -0,0 +1,103 @@
+import { Cracker } from "@shared";
+import { existsSync, createReadStream, readFileSync } from "node:fs";
+import readline from "node:readline";
+
+export const parseAchievementFile = async (
+  filePath: string,
+  type: Cracker
+): Promise<any | null> => {
+  if (existsSync(filePath)) {
+    if (type === Cracker.generic) {
+      return genericParse(filePath);
+    }
+
+    if (filePath.endsWith(".ini")) {
+      return iniParse(filePath);
+    }
+
+    if (filePath.endsWith(".json")) {
+      return jsonParse(filePath);
+    }
+  }
+};
+
+const genericParse = async (filePath: string) => {
+  try {
+    const file = createReadStream(filePath);
+
+    const lines = readline.createInterface({
+      input: file,
+      crlfDelay: Infinity,
+    });
+
+    const object: Record<string, Record<string, string | number>> = {};
+
+    for await (const line of lines) {
+      if (line.startsWith("###") || !line.length) continue;
+
+      if (line.startsWith("[") && line.endsWith("]")) {
+        continue;
+      }
+
+      const [name, ...value] = line.split(" = ");
+      const objectName = name.slice(1, -1);
+      object[objectName] = {};
+
+      const joinedValue = value.join("=").slice(1, -1);
+
+      for (const teste of joinedValue.split(",")) {
+        const [name, value] = teste.split("=");
+        object[objectName][name.trim()] = value;
+      }
+    }
+    console.log(object);
+    return object;
+  } catch {
+    return null;
+  }
+};
+
+const iniParse = async (filePath: string) => {
+  try {
+    const file = createReadStream(filePath);
+
+    const lines = readline.createInterface({
+      input: file,
+      crlfDelay: Infinity,
+    });
+
+    let objectName = "";
+    const object: Record<string, Record<string, string | number>> = {};
+
+    for await (const line of lines) {
+      if (line.startsWith("###") || !line.length) continue;
+
+      if (line.startsWith("[") && line.endsWith("]")) {
+        objectName = line.slice(1, -1);
+        object[objectName] = {};
+      } else {
+        const [name, ...value] = line.split("=");
+        console.log(line);
+        console.log(name, value);
+
+        const joinedValue = value.join("").trim();
+
+        const number = Number(joinedValue);
+
+        object[objectName][name.trim()] = isNaN(number) ? joinedValue : number;
+      }
+    }
+
+    return object;
+  } catch {
+    return null;
+  }
+};
+
+const jsonParse = (filePath: string) => {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+};

src/main/services/achievements/update-local-unlocked-achivements.ts

@@ -0,0 +1,123 @@
+import { gameAchievementRepository, gameRepository } from "@main/repository";
+import {
+  findAllSteamGameAchievementFiles,
+  findSteamGameAchievementFiles,
+} from "./find-steam-game-achivement-files";
+import { parseAchievementFile } from "./parse-achievement-file";
+import { checkUnlockedAchievements } from "./check-unlocked-achievements";
+import { mergeAchievements } from "./merge-achievements";
+import type { UnlockedAchievement } from "@types";
+import { getGameAchievementData } from "./get-game-achievement-data";
+
+export const updateAllLocalUnlockedAchievements = async () => {
+  const gameAchievementFilesMap = findAllSteamGameAchievementFiles();
+
+  for (const objectId of gameAchievementFilesMap.keys()) {
+    const gameAchievementFiles = gameAchievementFilesMap.get(objectId)!;
+
+    const [game, localAchievements] = await Promise.all([
+      gameRepository.findOne({
+        where: { objectID: objectId, shop: "steam", isDeleted: false },
+      }),
+      gameAchievementRepository.findOne({
+        where: { objectId, shop: "steam" },
+      }),
+    ]);
+
+    if (!game) continue;
+
+    console.log("Achievements files for", game.title, gameAchievementFiles);
+
+    if (!localAchievements || !localAchievements.achievements) {
+      await getGameAchievementData(objectId, "steam")
+        .then((achievements) => {
+          return gameAchievementRepository.upsert(
+            {
+              objectId,
+              shop: "steam",
+              achievements: JSON.stringify(achievements),
+            },
+            ["objectId", "shop"]
+          );
+        })
+        .catch(() => {});
+    }
+
+    const unlockedAchievements: UnlockedAchievement[] = [];
+
+    for (const achievementFile of gameAchievementFiles) {
+      const localAchievementFile = await parseAchievementFile(
+        achievementFile.filePath,
+        achievementFile.type
+      );
+
+      if (localAchievementFile) {
+        unlockedAchievements.push(
+          ...checkUnlockedAchievements(
+            achievementFile.type,
+            localAchievementFile
+          )
+        );
+      }
+    }
+
+    mergeAchievements(objectId, "steam", unlockedAchievements, false);
+  }
+};
+
+export const updateLocalUnlockedAchivements = async (
+  publishNotification: boolean,
+  objectId: string
+) => {
+  const [game, localAchievements] = await Promise.all([
+    gameRepository.findOne({
+      where: { objectID: objectId, shop: "steam", isDeleted: false },
+    }),
+    gameAchievementRepository.findOne({
+      where: { objectId, shop: "steam" },
+    }),
+  ]);
+
+  if (!game) return;
+
+  const gameAchievementFiles = findSteamGameAchievementFiles(game);
+
+  console.log("Achievements files for", game.title, gameAchievementFiles);
+
+  if (!localAchievements || !localAchievements.achievements) {
+    await getGameAchievementData(objectId, "steam")
+      .then((achievements) => {
+        return gameAchievementRepository.upsert(
+          {
+            objectId,
+            shop: "steam",
+            achievements: JSON.stringify(achievements),
+          },
+          ["objectId", "shop"]
+        );
+      })
+      .catch(() => {});
+  }
+
+  const unlockedAchievements: UnlockedAchievement[] = [];
+
+  for (const achievementFile of gameAchievementFiles) {
+    const localAchievementFile = await parseAchievementFile(
+      achievementFile.filePath,
+      achievementFile.type
+    );
+
+    if (localAchievementFile) {
+      unlockedAchievements.push(
+        ...checkUnlockedAchievements(achievementFile.type, localAchievementFile)
+      );
+    }
+  }
+
+  mergeAchievements(
+    objectId,
+    "steam",
+    unlockedAchievements,
+    publishNotification
+  );
+};

src/main/services/hydra-api.ts

@@ -17,6 +17,7 @@ export class HydraApi {
   private static instance: AxiosInstance;
 
   private static readonly EXPIRATION_OFFSET_IN_MS = 1000 * 60 * 5; // 5 minutes
+  private static readonly ADD_LOG_INTERCEPTOR = true;
 
   private static secondsToMilliseconds = (seconds: number) => seconds * 1000;
 
@@ -87,60 +88,66 @@ export class HydraApi {
       headers: { "User-Agent": `Hydra Launcher v${appVersion}` },
     });
 
-    this.instance.interceptors.request.use(
-      (request) => {
-        logger.log(" ---- REQUEST -----");
-        const data = Array.isArray(request.data)
-          ? request.data
-          : omit(request.data, ["refreshToken"]);
-        logger.log(request.method, request.url, request.params, data);
-        return request;
-      },
-      (error) => {
-        logger.error("request error", error);
-        return Promise.reject(error);
-      }
-    );
-
-    this.instance.interceptors.response.use(
-      (response) => {
-        logger.log(" ---- RESPONSE -----");
-        const data = Array.isArray(response.data)
-          ? response.data
-          : omit(response.data, ["username", "accessToken", "refreshToken"]);
-        logger.log(
-          response.status,
-          response.config.method,
-          response.config.url,
-          data
-        );
-        return response;
-      },
-      (error) => {
-        logger.error(" ---- RESPONSE ERROR -----");
-
-        const { config } = error;
-
-        logger.error(
-          config.method,
-          config.baseURL,
-          config.url,
-          config.headers,
-          config.data
-        );
-
-        if (error.response) {
-          logger.error("Response", error.response.status, error.response.data);
-        } else if (error.request) {
-          logger.error("Request", error.request);
-        } else {
-          logger.error("Error", error.message);
+    if (this.ADD_LOG_INTERCEPTOR) {
+      this.instance.interceptors.request.use(
+        (request) => {
+          logger.log(" ---- REQUEST -----");
+          const data = Array.isArray(request.data)
+            ? request.data
+            : omit(request.data, ["refreshToken"]);
+          logger.log(request.method, request.url, request.params, data);
+          return request;
+        },
+        (error) => {
+          logger.error("request error", error);
+          return Promise.reject(error);
         }
+      );
 
-        logger.error(" ----- END RESPONSE ERROR -------");
-        return Promise.reject(error);
-      }
-    );
+      this.instance.interceptors.response.use(
+        (response) => {
+          logger.log(" ---- RESPONSE -----");
+          const data = Array.isArray(response.data)
+            ? response.data
+            : omit(response.data, ["username", "accessToken", "refreshToken"]);
+          logger.log(
+            response.status,
+            response.config.method,
+            response.config.url,
+            data
+          );
+          return response;
+        },
+        (error) => {
+          logger.error(" ---- RESPONSE ERROR -----");
+
+          const { config } = error;
+
+          logger.error(
+            config.method,
+            config.baseURL,
+            config.url,
+            config.headers,
+            config.data
+          );
+
+          if (error.response) {
+            logger.error(
+              "Response",
+              error.response.status,
+              error.response.data
+            );
+          } else if (error.request) {
+            logger.error("Request", error.request);
+          } else {
+            logger.error("Error", error.message);
+          }
+
+          logger.error(" ----- END RESPONSE ERROR -------");
+          return Promise.reject(error);
+        }
+      );
+    }
 
     const userAuth = await userAuthRepository.findOne({
       where: { id: 1 },

src/main/services/library-sync/upload-games-batch.ts

@@ -4,6 +4,7 @@ import { IsNull } from "typeorm";
 import { HydraApi } from "../hydra-api";
 import { mergeWithRemoteGames } from "./merge-with-remote-games";
 import { WindowManager } from "../window-manager";
+import { updateAllLocalUnlockedAchievements } from "../achievements/update-local-unlocked-achivements";
 
 export const uploadGamesBatch = async () => {
   const games = await gameRepository.find({
@@ -28,6 +29,8 @@ export const uploadGamesBatch = async () => {
 
   await mergeWithRemoteGames();
 
+  await updateAllLocalUnlockedAchievements();
+
   if (WindowManager.mainWindow)
     WindowManager.mainWindow.webContents.send("on-library-batch-complete");
 };

src/main/services/main-loop.ts

@@ -1,6 +1,7 @@
 import { sleep } from "@main/helpers";
 import { DownloadManager } from "./download";
 import { watchProcesses } from "./process-watcher";
+import { watchAchievements } from "./achievements/achievement-watcher";
 
 export const startMainLoop = async () => {
   // eslint-disable-next-line no-constant-condition
@@ -8,6 +9,7 @@ export const startMainLoop = async () => {
     await Promise.allSettled([
       watchProcesses(),
       DownloadManager.watchDownloads(),
+      watchAchievements(),
     ]);
 
     await sleep(1000);

src/main/services/process-watcher.ts

@@ -25,12 +25,12 @@ export const watchProcesses = async () => {
   if (games.length === 0) return;
   const processes = await PythonInstance.getProcessList();
 
+  const processSet = new Set(processes.map((process) => process.exe));
+
   for (const game of games) {
     const executablePath = game.executablePath!;
 
-    const gameProcess = processes.find((runningProcess) => {
-      return executablePath == runningProcess.exe;
-    });
+    const gameProcess = processSet.has(executablePath);
 
     if (gameProcess) {
       if (gamesPlaytime.has(game.id)) {

src/main/services/window-manager.ts

@@ -19,8 +19,9 @@ import { HydraApi } from "./hydra-api";
 
 export class WindowManager {
   public static mainWindow: Electron.BrowserWindow | null = null;
+  public static notificationWindow: Electron.BrowserWindow | null = null;
 
-  private static loadURL(hash = "") {
+  private static loadMainWindowURL(hash = "") {
     // 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"]) {
@@ -37,6 +38,21 @@ export class WindowManager {
     }
   }
 
+  private static loadNotificationWindowURL() {
+    if (is.dev && process.env["ELECTRON_RENDERER_URL"]) {
+      this.notificationWindow?.loadURL(
+        `${process.env["ELECTRON_RENDERER_URL"]}#/achievement-notification`
+      );
+    } else {
+      this.notificationWindow?.loadFile(
+        path.join(__dirname, "../renderer/index.html"),
+        {
+          hash: "achievement-notification",
+        }
+      );
+    }
+  }
+
   public static createMainWindow() {
     if (this.mainWindow) return;
 
@@ -108,7 +124,7 @@ export class WindowManager {
       }
     );
 
-    this.loadURL();
+    this.loadMainWindowURL();
     this.mainWindow.removeMenu();
 
     this.mainWindow.on("ready-to-show", () => {
@@ -125,9 +141,36 @@ export class WindowManager {
         app.quit();
       }
       WindowManager.mainWindow?.setProgressBar(-1);
+      WindowManager.mainWindow = null;
     });
   }
 
+  public static createNotificationWindow() {
+    this.notificationWindow = new BrowserWindow({
+      transparent: true,
+      maximizable: false,
+      autoHideMenuBar: true,
+      minimizable: false,
+      focusable: true,
+      skipTaskbar: true,
+      frame: false,
+      width: 240,
+      height: 60,
+      x: 25,
+      y: -9999,
+      webPreferences: {
+        preload: path.join(__dirname, "../preload/index.mjs"),
+        sandbox: false,
+      },
+    });
+
+    this.notificationWindow.setVisibleOnAllWorkspaces(true, {
+      visibleOnFullScreen: true,
+    });
+    this.notificationWindow.setAlwaysOnTop(true, "screen-saver", 1);
+    this.loadNotificationWindowURL();
+  }
+
   public static openAuthWindow() {
     if (this.mainWindow) {
       const authWindow = new BrowserWindow({
@@ -174,7 +217,7 @@ export class WindowManager {
 
   public static redirect(hash: string) {
     if (!this.mainWindow) this.createMainWindow();
-    this.loadURL(hash);
+    this.loadMainWindowURL(hash);
 
     if (this.mainWindow?.isMinimized()) this.mainWindow.restore();
     this.mainWindow?.focus();