feat: changing permission verify strategy

python_rpc/main.py

@@ -4,6 +4,11 @@
 from http_downloader import HttpDownloader
 from profile_image_processor import ProfileImageProcessor
 import libtorrent as lt
+import logging
+
+log = logging.getLogger('werkzeug')
+
+log.setLevel(logging.ERROR)
 
 app = Flask(__name__)
 
@@ -94,7 +99,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/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,
       }
     );
 

src/main/services/hydra-api.ts

@@ -32,7 +32,8 @@ export class HydraApi {
   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;
+  private static readonly secondsToMilliseconds = (seconds: number) =>
+    seconds * 1000;
 
   private static userAuth: HydraApiUserAuth = {
     authToken: "",
@@ -153,7 +154,8 @@ export class HydraApi {
         (error) => {
           logger.error(" ---- RESPONSE ERROR -----");
           const { config } = error;
-          const data = JSON.parse(config.data);
+
+          const data = JSON.parse(config.data ?? null);
 
           logger.error(
             config.method,
@@ -174,14 +176,22 @@ export class HydraApi {
               error.response.status,
               error.response.data
             );
-          } else if (error.request) {
+
+            return Promise.reject(error as Error);
+          }
+
+          if (error.request) {
             const errorData = error.toJSON();
-            logger.error("Request error:", errorData.message);
-          } else {
-            logger.error("Error", error.message);
+            logger.error("Request error:", errorData.code, errorData.message);
+            return Promise.reject(
+              new Error(
+                `Request failed with ${errorData.code} ${errorData.message}`
+              )
+            );
           }
-          logger.error(" ----- END RESPONSE ERROR -------");
-          return Promise.reject(error);
+
+          logger.error("Error", error.message);
+          return Promise.reject(error as Error);
         }
       );
     }
@@ -261,7 +271,7 @@ export class HydraApi {
     };
   }
 
-  private static handleUnauthorizedError = (err) => {
+  private static readonly handleUnauthorizedError = (err) => {
     if (err instanceof AxiosError && err.response?.status === 401) {
       logger.error(
         "401 - Current credentials:",

src/main/services/logger.ts

@@ -6,8 +6,8 @@ log.transports.file.resolvePathFn = (
   _: log.PathVariables,
   message?: log.LogMessage | undefined
 ) => {
-  if (message?.scope === "python-instance") {
-    return path.join(logsPath, "pythoninstance.txt");
+  if (message?.scope === "python-rpc") {
+    return path.join(logsPath, "pythonrpc.txt");
   }
 
   if (message?.scope == "achievements") {

src/main/services/notifications/index.ts

@@ -11,6 +11,7 @@ import { achievementSoundPath } from "@main/constants";
 import icon from "@resources/icon.png?asset";
 import { NotificationOptions, toXmlString } from "./xml";
 import { logger } from "../logger";
+import { WindowManager } from "../window-manager";
 
 async function downloadImage(url: string | null) {
   if (!url) return undefined;
@@ -93,7 +94,9 @@ export const publishCombinedNewAchievementNotification = async (
     toastXml: toXmlString(options),
   }).show();
 
-  if (process.platform !== "linux") {
+  if (WindowManager.mainWindow) {
+    WindowManager.mainWindow.webContents.send("on-achievement-unlocked");
+  } else if (process.platform !== "linux") {
     sound.play(achievementSoundPath);
   }
 };
@@ -140,7 +143,9 @@ export const publishNewAchievementNotification = async (info: {
     toastXml: toXmlString(options),
   }).show();
 
-  if (process.platform !== "linux") {
+  if (WindowManager.mainWindow) {
+    WindowManager.mainWindow.webContents.send("on-achievement-unlocked");
+  } else if (process.platform !== "linux") {
     sound.play(achievementSoundPath);
   }
 };