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/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

@@ -9,10 +9,11 @@ import { logger, WindowManager } from "@main/services";
 import { dataSource } from "@main/data-source";
 import resources from "@locales";
 import { userPreferencesRepository } from "@main/repository";
-import { knexClient, migrationConfig } from "./knex-client";
-import { databaseDirectory } from "./constants";
+import { getKnexClient, migrationConfig } from "./knex-client";
+import { databaseDirectory, databasePath } from "./constants";
 import { PythonRPC } from "./services/python-rpc";
 import { Aria2 } from "./services/aria2";
+import { loadState } from "./main";
 
 const { autoUpdater } = updater;
 
@@ -55,14 +56,25 @@ const runMigrations = async () => {
     fs.mkdirSync(databaseDirectory, { recursive: true });
   }
 
-  await knexClient.migrate.list(migrationConfig).then((result) => {
-    logger.log(
-      "Migrations to run:",
-      result[1].map((migration) => migration.name)
-    );
-  });
-
-  await knexClient.migrate.latest(migrationConfig);
+  for (let trial = 0; trial < 2; trial++) {
+    const knexClient = getKnexClient();
+
+    try {
+      await knexClient.migrate.list(migrationConfig).then((result) => {
+        logger.log(
+          "Migrations to run:",
+          result[1].map((migration) => migration.name)
+        );
+      });
+
+      await knexClient.migrate.latest(migrationConfig);
+      return;
+    } catch (err) {
+      logger.log("Migrations failed to run, deleting db and trying again", err);
+      await knexClient.destroy();
+      fs.rmSync(databasePath);
+    }
+  }
 };
 
 // This method will be called when Electron has finished
@@ -76,22 +88,18 @@ app.whenReady().then(async () => {
     return net.fetch(url.pathToFileURL(decodeURI(filePath)).toString());
   });
 
-  await runMigrations()
-    .then(() => {
-      logger.log("Migrations executed successfully");
-    })
-    .catch((err) => {
-      logger.log("Migrations failed to run:", err);
-    });
+  await runMigrations().then(() => {
+    logger.log("Migrations executed successfully");
+  });
 
   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/knex-client.ts

@@ -49,13 +49,14 @@ class MigrationSource implements Knex.MigrationSource<HydraMigration> {
   }
 }
 
-export const knexClient = knex({
-  debug: !app.isPackaged,
-  client: "better-sqlite3",
-  connection: {
-    filename: databasePath,
-  },
-});
+export const getKnexClient = () =>
+  knex({
+    debug: !app.isPackaged,
+    client: "better-sqlite3",
+    connection: {
+      filename: databasePath,
+    },
+  });
 
 export const migrationConfig: Knex.MigratorConfig = {
   migrationSource: new MigrationSource(),

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) => {