feat: changing permission verify strategy

python_rpc/main.py

@@ -94,7 +94,7 @@ def seed_status():
 
 @app.route("/healthcheck", methods=["GET"])
 def healthcheck():
-    return "", 200
+    return "ok", 200
 
 @app.route("/process-list", methods=["GET"])
 def process_list():

src/locales/pt-BR/translation.json

@@ -172,7 +172,8 @@
     "reset_achievements_description": "Isso irá resetar todas as conquistas de {{game}}",
     "reset_achievements_title": "Tem certeza?",
     "reset_achievements_success": "Conquistas resetadas com sucesso",
-    "reset_achievements_error": "Falha ao resetar conquistas"
+    "reset_achievements_error": "Falha ao resetar conquistas",
+    "no_write_permission": "Não é possível baixar nesse diretório. Clique aqui para saber mais."
   },
   "activation": {
     "title": "Ativação",

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

@@ -1,47 +1,8 @@
-import type { AppUpdaterEvent } from "@types";
 import { registerEvent } from "../register-event";
-import updater, { UpdateInfo } from "electron-updater";
-import { WindowManager } from "@main/services";
-import { app } from "electron";
-import { publishNotificationUpdateReadyToInstall } from "@main/services/notifications";
-
-const { autoUpdater } = updater;
-
-const sendEvent = (event: AppUpdaterEvent) => {
-  WindowManager.mainWindow?.webContents.send("autoUpdaterEvent", event);
-};
-
-const sendEventsForDebug = false;
-
-const isAutoInstallAvailable =
-  process.platform !== "darwin" && process.env.PORTABLE_EXECUTABLE_FILE == null;
-
-const mockValuesForDebug = () => {
-  sendEvent({ type: "update-available", info: { version: "1.3.0" } });
-  sendEvent({ type: "update-downloaded" });
-};
-
-const newVersionInfo = { version: "" };
+import { UpdateManager } from "@main/services/update-manager";
 
 const checkForUpdates = async (_event: Electron.IpcMainInvokeEvent) => {
-  autoUpdater
-    .once("update-available", (info: UpdateInfo) => {
-      sendEvent({ type: "update-available", info });
-      newVersionInfo.version = info.version;
-    })
-    .once("update-downloaded", () => {
-      sendEvent({ type: "update-downloaded" });
-      publishNotificationUpdateReadyToInstall(newVersionInfo.version);
-    });
-
-  if (app.isPackaged) {
-    autoUpdater.autoDownload = isAutoInstallAvailable;
-    autoUpdater.checkForUpdates();
-  } else if (sendEventsForDebug) {
-    mockValuesForDebug();
-  }
-
-  return isAutoInstallAvailable;
+  return UpdateManager.checkForUpdates();
 };
 
 registerEvent("checkForUpdates", checkForUpdates);

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

@@ -1,15 +1,21 @@
 import fs from "node:fs";
+import path from "node:path";
 
 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);
-    });
-  });
+  testPath: string
+) => {
+  const testFilePath = path.join(testPath, ".hydra-write-test");
+
+  try {
+    fs.writeFileSync(testFilePath, "");
+    fs.rmSync(testFilePath);
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
 
 registerEvent("checkFolderWritePermission", checkFolderWritePermission);

src/main/events/helpers/parse-launch-options.ts

@@ -0,0 +1,7 @@
+export const parseLaunchOptions = (params: string | null): string[] => {
+  if (!params) {
+    return [];
+  }
+
+  return params.split(" ");
+};

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

@@ -2,23 +2,30 @@ import { gameRepository } from "@main/repository";
 
 import { registerEvent } from "../register-event";
 import { shell } from "electron";
+import { spawn } from "child_process";
 import { parseExecutablePath } from "../helpers/parse-executable-path";
+import { parseLaunchOptions } from "../helpers/parse-launch-options";
 
 const openGame = async (
   _event: Electron.IpcMainInvokeEvent,
   gameId: number,
   executablePath: string,
   launchOptions: string | null
 ) => {
-  // TODO: revisit this for launchOptions
   const parsedPath = parseExecutablePath(executablePath);
+  const parsedParams = parseLaunchOptions(launchOptions);
 
   await gameRepository.update(
     { id: gameId },
     { executablePath: parsedPath, launchOptions }
   );
 
-  shell.openPath(parsedPath);
+  if (parsedParams.length === 0) {
+    shell.openPath(parsedPath);
+    return;
+  }
+
+  spawn(parsedPath, parsedParams, { shell: false, detached: true });
 };
 
 registerEvent("openGame", openGame);

src/main/events/profile/update-profile.ts

@@ -7,7 +7,7 @@ import { omit } from "lodash-es";
 import axios from "axios";
 import { fileTypeFromFile } from "file-type";
 
-const patchUserProfile = async (updateProfile: UpdateProfileRequest) => {
+export const patchUserProfile = async (updateProfile: UpdateProfileRequest) => {
   return HydraApi.patch<UserProfile>("/profile", updateProfile);
 };
 

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

@@ -3,13 +3,15 @@ import { registerEvent } from "../register-event";
 
 import type { UserPreferences } from "@types";
 import i18next from "i18next";
+import { patchUserProfile } from "../profile/update-profile";
 
 const updateUserPreferences = async (
   _event: Electron.IpcMainInvokeEvent,
   preferences: Partial<UserPreferences>
 ) => {
   if (preferences.language) {
     i18next.changeLanguage(preferences.language);
+    patchUserProfile({ language: preferences.language }).catch(() => {});
   }
 
   return userPreferencesRepository.upsert(

src/main/index.ts

@@ -13,6 +13,7 @@ import { knexClient, migrationConfig } from "./knex-client";
 import { databaseDirectory } from "./constants";
 import { PythonRPC } from "./services/python-rpc";
 import { Aria2 } from "./services/aria2";
+import { loadState } from "./main";
 
 const { autoUpdater } = updater;
 
@@ -86,12 +87,12 @@ app.whenReady().then(async () => {
 
   await dataSource.initialize();
 
-  await import("./main");
-
   const userPreferences = await userPreferencesRepository.findOne({
     where: { id: 1 },
   });
 
+  await loadState(userPreferences);
+
   if (userPreferences?.language) {
     i18n.changeLanguage(userPreferences.language);
   }

src/main/main.ts

@@ -1,9 +1,5 @@
 import { DownloadManager, Ludusavi, startMainLoop } from "./services";
-import {
-  downloadQueueRepository,
-  gameRepository,
-  userPreferencesRepository,
-} from "./repository";
+import { downloadQueueRepository, gameRepository } from "./repository";
 import { UserPreferences } from "./entity";
 import { RealDebridClient } from "./services/download/real-debrid";
 import { HydraApi } from "./services/hydra-api";
@@ -12,8 +8,8 @@ import { Aria2 } from "./services/aria2";
 import { Downloader } from "@shared";
 import { IsNull, Not } from "typeorm";
 
-const loadState = async (userPreferences: UserPreferences | null) => {
-  import("./events");
+export const loadState = async (userPreferences: UserPreferences | null) => {
+  await import("./events");
 
   Aria2.spawn();
 
@@ -49,11 +45,3 @@ const loadState = async (userPreferences: UserPreferences | null) => {
 
   startMainLoop();
 };
-
-userPreferencesRepository
-  .findOne({
-    where: { id: 1 },
-  })
-  .then((userPreferences) => {
-    loadState(userPreferences);
-  });

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

@@ -144,20 +144,20 @@ const processAchievementFileDiff = async (
 export class AchievementWatcherManager {
   private static hasFinishedMergingWithRemote = false;
 
-  public static watchAchievements = () => {
+  public static watchAchievements() {
     if (!this.hasFinishedMergingWithRemote) return;
 
     if (process.platform === "win32") {
       return watchAchievementsWindows();
     }
 
     return watchAchievementsWithWine();
-  };
+  }
 
-  private static preProcessGameAchievementFiles = (
+  private static preProcessGameAchievementFiles(
     game: Game,
     gameAchievementFiles: AchievementFile[]
-  ) => {
+  ) {
     const unlockedAchievements: UnlockedAchievement[] = [];
     for (const achievementFile of gameAchievementFiles) {
       const parsedAchievements = parseAchievementFile(
@@ -185,9 +185,9 @@ export class AchievementWatcherManager {
     }
 
     return mergeAchievements(game, unlockedAchievements, false);
-  };
+  }
 
-  private static preSearchAchievementsWindows = async () => {
+  private static async preSearchAchievementsWindows() {
     const games = await gameRepository.find({
       where: {
         isDeleted: false,
@@ -213,9 +213,9 @@ export class AchievementWatcherManager {
         return this.preProcessGameAchievementFiles(game, gameAchievementFiles);
       })
     );
-  };
+  }
 
-  private static preSearchAchievementsWithWine = async () => {
+  private static async preSearchAchievementsWithWine() {
     const games = await gameRepository.find({
       where: {
         isDeleted: false,
@@ -233,9 +233,9 @@ export class AchievementWatcherManager {
         return this.preProcessGameAchievementFiles(game, gameAchievementFiles);
       })
     );
-  };
+  }
 
-  public static preSearchAchievements = async () => {
+  public static async preSearchAchievements() {
     try {
       const newAchievementsCount =
         process.platform === "win32"
@@ -261,5 +261,5 @@ export class AchievementWatcherManager {
     }
 
     this.hasFinishedMergingWithRemote = true;
-  };
+  }
 }

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

@@ -13,7 +13,7 @@ export const getGameAchievementData = async (
   shop: GameShop,
   cachedAchievements: GameAchievement | null
 ) => {
-  if (cachedAchievements && cachedAchievements.achievements) {
+  if (cachedAchievements?.achievements) {
     return JSON.parse(cachedAchievements.achievements) as AchievementData[];
   }
 
@@ -42,7 +42,7 @@ export const getGameAchievementData = async (
       if (err instanceof UserNotLoggedInError) {
         throw err;
       }
-      logger.error("Failed to get game achievements", err);
+      logger.error("Failed to get game achievements for", objectId, err);
       return gameAchievementRepository
         .findOne({
           where: { objectId, shop },

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

@@ -64,7 +64,7 @@ export const mergeAchievements = async (
   ).filter((achievement) => achievement.name) as UnlockedAchievement[];
 
   const newAchievementsMap = new Map(
-    achievements.reverse().map((achievement) => {
+    achievements.toReversed().map((achievement) => {
       return [achievement.name.toUpperCase(), achievement];
     })
   );
@@ -92,7 +92,7 @@ export const mergeAchievements = async (
     userPreferences?.achievementNotificationsEnabled
   ) {
     const achievementsInfo = newAchievements
-      .sort((a, b) => {
+      .toSorted((a, b) => {
         return a.unlockTime - b.unlockTime;
       })
       .map((achievement) => {

src/main/services/hosters/datanodes.ts

@@ -33,7 +33,8 @@ export class DatanodesApi {
           "User-Agent":
             "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
         },
-        maxRedirects: 0,        validateStatus: (status: number) => status === 302 || status < 400,
+        maxRedirects: 0,
+        validateStatus: (status: number) => status === 302 || status < 400,
       }
     );