Merge branch 'master' into feature/add-changelog-modal/178

src/main/decorators/log.decorator.ts

@@ -0,0 +1,67 @@
+import log from "electron-log";
+import { isPromise } from "../../shared/helpers/promise.helpers";
+import { tryit } from "../../shared/helpers/error.helpers";
+
+type LogOptions = {
+    logInput?: boolean;
+    logOutput?: boolean;
+    logArgs?: boolean;
+};
+
+const stringifyArgs = (args: unknown[]) => {
+    return args?.map(a => JSON.stringify(a)).join(', ');
+};
+
+const logInfo = (message: string, propertyKey: string, args: unknown[], logArgs: boolean, result: unknown) => {
+    log.info(`[${message}] ${propertyKey}(${logArgs ? stringifyArgs(args) : ''})`, result);
+};
+
+const logError = (propertyKey: string, args: unknown[], logArgs: boolean, error: unknown) => {
+    log.error(`[ERROR] ${propertyKey}(${logArgs ? stringifyArgs(args) : ''})`, error);
+    throw error;
+};
+
+export function Log(options?: LogOptions){
+
+    const logInput = options?.logInput ?? false;
+    const logOutput = options?.logOutput ?? true;
+    const logArgs = options?.logArgs ?? true;
+
+    return (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => {
+        const originalMethod = descriptor.value;
+
+        descriptor.value = function(...args: unknown[]) {
+
+            if (logInput) {
+                logInfo('INPUT', propertyKey, args, logArgs, null);
+            }
+
+            const outcome = tryit(() => originalMethod.apply(this, args));
+
+            if (isPromise(outcome)) {
+                return outcome.then(({ result, error }) => {
+
+                    if (error) {
+                        logError(propertyKey, args, logArgs, error);
+                    }
+                    if (logOutput) {
+                        logInfo('OUTPUT', propertyKey, args, logArgs, result);
+                    }
+                    return result;
+                });
+            }
+
+            const { result, error } = outcome;
+
+            if (error) {
+                logError(propertyKey, args, logArgs, error);
+            }
+
+            if (logOutput) {
+                logInfo('OUTPUT', propertyKey, args, logArgs, result);
+            }
+
+            return result;
+        };
+    };
+}

src/main/helpers/os.helpers.ts

@@ -10,4 +10,16 @@ export async function taskRunning(task: string): Promise<boolean> {
         log.error(error);
         return false;
     }
-}
+}
+
+export async function getProcessPid(task: string): Promise<number> {
+    try {
+        const processes = await psList();
+        const process = processes.find(process => process.name?.includes(task) || process.cmd?.includes(task));
+        return process?.pid;
+    }
+    catch(error){
+        log.error(error);
+        return null;
+    }
+}

src/main/ipcs/bs-launcher-ipcs.ts

@@ -5,6 +5,9 @@ import { IpcService } from '../services/ipc.service';
 import { from } from "rxjs";
 import { SteamLauncherService } from "../services/bs-launcher/steam-launcher.service";
 import { OculusLauncherService } from "../services/bs-launcher/oculus-launcher.service";
+import { SteamService } from "../services/steam.service";
+import log from "electron-log";
+import isElevated from "is-elevated";
 
 const ipc = IpcService.getInstance();
 
@@ -13,6 +16,17 @@ ipc.on<LaunchOption>('bs-launch.launch', (req, reply) => {
     reply(bsLauncher.launch(req.args));
 });
 
+ipc.on<boolean>("bs-launch.need-start-as-admin", (_, reply) => {
+    const steam = SteamService.getInstance();
+    reply(from(isElevated().then(elevated => {
+        if(elevated){ return false; }
+        return steam.isElevated().catch(e => {
+            log.error("Error while checking if Steam is running as admin", e);
+            return false;
+        });
+    })));
+});
+
 ipc.on<LaunchOption>("create-launch-shortcut", (req, reply) => {
     const bsLauncher = BSLauncherService.getInstance();
     reply(from(bsLauncher.createLaunchShortcut(req.args)));

src/main/services/bs-launcher/oculus-launcher.service.ts

@@ -61,13 +61,13 @@ export class OculusLauncherService extends AbstractLauncherService implements St
         log.info("Symlinks found in Oculus library", symlinks);
 
         const bsSymlinks = symlinks.filter(dirent => dirent.startsWith(OCULUS_BS_DIR));
-        
+
         const bsmSymlinks = (await Promise.all(bsSymlinks.map(async symlink => {
             const symlinkPath = path.join(oculusLibPath, symlink);
             const targetPath = await readlink(symlinkPath).catch(err => log.error(err));
 
             log.info("Oculus Symlink", symlink, "target", targetPath);
-            
+
             if(!targetPath){ return null; }
 
             const bsmVersionsDir = path.join(this.pathsService.INSTALLATION_FOLDER, this.pathsService.VERSIONS_FOLDER);
@@ -138,20 +138,24 @@ export class OculusLauncherService extends AbstractLauncherService implements St
                 if(bsRunning){
                     throw CustomError.fromError(new Error("Cannot start two instance of Beat Saber for Oculus"), BSLaunchError.BS_ALREADY_RUNNING);
                 }
-                
+
                 // Remove previously symlinks created by BSM
                 await this.deleteBsSymlinks().catch(err => log.error("Error while deleting BSM symlinks", err));
 
                 const bsPath = await (launchOptions.version.oculus ? prepareOriginalVersion() : prepareDowngradedVersion());
 
-                // Launch Beat Saber
                 const exePath = path.join(bsPath, BS_EXECUTABLE);
 
                 if(!(await pathExists(exePath))){
                     throw CustomError.fromError(new Error(`BS Path not exist ${bsPath}`), BSLaunchError.BS_NOT_FOUND);
                 }
 
+                // Make sure Oculus is running
+                await this.oculus.startOculus().catch(err => log.error("Error while starting Oculus", err));
+
                 obs.next({type: BSLaunchEvent.BS_LAUNCHING});
+
+                // Launch Beat Saber
                 return this.launchBs(exePath, this.buildBsLaunchArgs(launchOptions)).catch(err => {
                     throw CustomError.fromError(err, BSLaunchError.BS_EXIT_ERROR);
                 });
@@ -170,4 +174,4 @@ export class OculusLauncherService extends AbstractLauncherService implements St
         });
     }
 
-}
+}

src/main/services/bs-launcher/steam-launcher.service.ts

@@ -8,6 +8,9 @@ import { BS_APP_ID, BS_EXECUTABLE, STEAMVR_APP_ID } from "../../constants";
 import log from "electron-log";
 import { AbstractLauncherService } from "./abstract-launcher.service";
 import { CustomError } from "../../../shared/models/exceptions/custom-error.class";
+import isElevated from "is-elevated";
+import { UtilsService } from "../utils.service";
+import { exec } from "child_process";
 
 export class SteamLauncherService extends AbstractLauncherService implements StoreLauncherInterface{
 
@@ -21,10 +24,12 @@ export class SteamLauncherService extends AbstractLauncherService implements Sto
     }
 
     private readonly steam: SteamService;
+    private readonly util: UtilsService;
 
     private constructor(){
         super();
         this.steam = SteamService.getInstance();
+        this.util = UtilsService.getInstance();
     }
 
     private getSteamVRPath(): Promise<string> {
@@ -41,6 +46,17 @@ export class SteamLauncherService extends AbstractLauncherService implements Sto
         });
     }
 
+    private needStartBsAsAdmin(): Promise<boolean> {
+        return isElevated().then(elevated => {
+            if(elevated){ return false; }
+            return this.steam.isElevated();
+        })
+    }
+
+    private getStartBsAsAdminExePath(): string {
+        return path.join(this.util.getAssetsScriptsPath(), "start_beat_saber_admin.exe");
+    }
+
     public async restoreSteamVR(): Promise<void> {
         const steamVrFolder = await this.getSteamVRPath();
         const steamVrBackup = `${steamVrFolder}.bak`;
@@ -53,7 +69,7 @@ export class SteamLauncherService extends AbstractLauncherService implements Sto
             log.error("Error while restoring SteamVR", err);
         });
     }
-    
+
     public launch(launchOptions: LaunchOption): Observable<BSLaunchEventData>{
 
         return new Observable<BSLaunchEventData>(obs => {(async () => {
@@ -90,7 +106,24 @@ export class SteamLauncherService extends AbstractLauncherService implements Sto
 
             obs.next({type: BSLaunchEvent.BS_LAUNCHING});
 
-            await this.launchBs(exePath, launchArgs, { env: {...process.env, "SteamAppId": BS_APP_ID} }).then(exitCode => {
+            const launchPromise = !launchOptions.admin ? (
+                this.launchBs(exePath, launchArgs, { env: {...process.env, "SteamAppId": BS_APP_ID} })
+            ) : (
+                new Promise<number>(resolve => {
+                    const adminProcess = exec(`"${this.getStartBsAsAdminExePath()}" "${exePath}" ${launchArgs.join(" ")}`, { env: {...process.env, "SteamAppId": BS_APP_ID} });
+                    adminProcess.on("error", err => {
+                        log.error("Error while starting BS as Admin", err);
+                        resolve(-1)
+                    });
+
+                    setTimeout(() => {
+                        adminProcess.removeAllListeners("error");
+                        resolve(-1);
+                    }, 35_000);
+                })
+            );
+
+            await launchPromise.then(exitCode => {
                 log.info("BS process exit code", exitCode);
             }).catch(err => {
                 throw CustomError.fromError(err, BSLaunchError.BS_EXIT_ERROR);
@@ -109,4 +142,4 @@ export class SteamLauncherService extends AbstractLauncherService implements Sto
         })});
     }
 
-}
+}

src/main/services/liv/liv.service.ts

@@ -1,6 +1,8 @@
 import { execOnOs } from "../../helpers/env.helpers";
-import { list, createKey, putValue, deleteKey, RegSzValue } from "regedit-rs";
 import path from "path";
+import { Log } from "../../decorators/log.decorator";
+
+const { list, createKey, putValue, deleteKey, RegSzValue } = (execOnOs({ win32: () => require("regedit-rs") }, true) ?? {}) as typeof import("regedit-rs");
 
 export class LivService {
 
@@ -20,6 +22,7 @@ export class LivService {
 
     }
 
+    @Log()
     public async isLivInstalled(): Promise<boolean> {
         return execOnOs({
             win32: async () => {
@@ -29,6 +32,7 @@ export class LivService {
         }, true);
     }
 
+    @Log()
     public async createLivShortcut(entry: LivEntry): Promise<void> {
         return execOnOs({
             win32: async () => {
@@ -46,6 +50,7 @@ export class LivService {
         });
     }
 
+    @Log()
     public async deleteLivShortcuts(ids: string[]): Promise<void> {
         return execOnOs({
             win32: async () => {
@@ -55,11 +60,13 @@ export class LivService {
         })
     }
 
+    @Log()
     public getLivShortcuts(): Promise<LivEntry[]> {
+
         return execOnOs({
             win32: async () => {
                 const regRes = await list(this.livExternalAppsRegeditKey).then(res => res[this.livExternalAppsRegeditKey]);
-                
+
                 if(!regRes.exists){
                     return [];
                 }

src/main/services/oculus.service.ts

@@ -1,9 +1,14 @@
-import { list } from "regedit-rs";
 import path from "path";
 import { pathExist, resolveGUIDPath } from "../helpers/fs.helpers";
 import log from "electron-log";
 import { lstat } from "fs-extra";
 import { tryit } from "../../shared/helpers/error.helpers";
+import { shell } from "electron";
+import { taskRunning } from "../helpers/os.helpers";
+import { sToMs } from "../../shared/helpers/time.helpers";
+import { execOnOs } from "../helpers/env.helpers";
+
+const { list } = (execOnOs({ win32: () => require("regedit-rs") }, true) ?? {}) as typeof import("regedit-rs");
 
 export class OculusService {
     private static instance: OculusService;
@@ -42,11 +47,11 @@ export class OculusService {
         const libsPath: OculusLibrary[] = (
             await Promise.all(libsRegData.keys.map(async key => {
                 const originalPath = await list([`${oculusLibsRegKey}\\${key}`]).then(res => res[`${oculusLibsRegKey}\\${key}`]);
-                
+
                 if (originalPath.values?.OriginalPath) {
                     return { id: key, path: originalPath.values.OriginalPath.value, isDefault: defaultLibraryId === key } as OculusLibrary;
-                } 
-                
+                }
+
                 if(originalPath.values?.Path) {
                     const { result } = tryit(() => resolveGUIDPath(originalPath.values.Path.value as string));
                     return result ? { id: key, path: result, isDefault: defaultLibraryId === key } as OculusLibrary : null;
@@ -82,7 +87,7 @@ export class OculusService {
 
     /**
      * Return the first game folder found in the list
-     * @param {string[]} gameFolders 
+     * @param {string[]} gameFolders
      */
     public async tryGetGameFolder(gameFolders: string[]): Promise<string> {
         for(const gameFolder of gameFolders){
@@ -92,6 +97,29 @@ export class OculusService {
 
         return null;
     }
+
+    public oculusRunning(): Promise<boolean> {
+        return taskRunning("OculusClient");
+    }
+
+    public async startOculus(): Promise<void>{
+        if(await this.oculusRunning()){ return; }
+
+        await shell.openPath("oculus://view/homepage");
+
+        return new Promise((resolve, reject) => {
+            const interval = setInterval(async () => {
+                if(!(await this.oculusRunning())){ return; }
+                clearInterval(interval);
+                resolve();
+            }, sToMs(3));
+
+            setTimeout(() => {
+                clearInterval(interval);
+                reject(new Error("Unable to open Oculus"));
+            }, sToMs(30));
+        });
+    }
 }
 
 export interface OculusLibrary {

src/main/services/steam.service.ts

@@ -1,15 +1,22 @@
-import { list, RegDwordValue } from "regedit-rs"
+import { RegDwordValue } from "regedit-rs"
 import path from "path";
 import { parse } from "@node-steam/vdf";
 import { readFile } from "fs/promises";
 import { pathExist } from "../helpers/fs.helpers";
 import log from "electron-log";
 import { app, shell } from "electron";
-import { taskRunning } from "../helpers/os.helpers";
+import { getProcessPid, taskRunning } from "../helpers/os.helpers";
+import { isElevated } from "query-process";
+import { execOnOs } from "../helpers/env.helpers";
+
+const { list } = (execOnOs({ win32: () => require("regedit-rs") }, true) ?? {}) as typeof import("regedit-rs");
 
 export class SteamService {
 
+    private static readonly PROCESS_NAME = "steam";
+
     private static instance: SteamService;
+
     private steamPath: string = '';
 
     private constructor(){}
@@ -29,12 +36,30 @@ export class SteamService {
     }
 
     public async steamRunning(): Promise<boolean>{
-        const steamProcessRunning = await taskRunning("steam");
+        const steamProcessRunning = await taskRunning(SteamService.PROCESS_NAME);
         if(process.platform === "linux") { return steamProcessRunning; }
         const activeUser = await this.getActiveUser().catch(err => log.error(err));
         return steamProcessRunning && !!activeUser;
     }
 
+    public async getSteamPid(): Promise<number>{
+        return getProcessPid(SteamService.PROCESS_NAME);
+    }
+
+    /**
+     * Check if the Steam process is running as administrator
+     * @throws Can throw an error if the Steam process is running as admin
+     * @returns true if the Steam process is running as administrator
+     */
+    public async isElevated(): Promise<boolean>{
+        if(process.platform === "linux"){ return true; }
+        const steamPid = await this.getSteamPid();
+
+        if(!steamPid){ return false; }
+
+        return isElevated(steamPid);
+    }
+
     public async getSteamPath(): Promise<string>{
 
         if(this.steamPath){ return this.steamPath; }
@@ -68,7 +93,7 @@ export class SteamService {
             let libraryFolders: any = path.join(steamPath, "steamapps", "libraryfolders.vdf");
 
             if (!(await pathExist(libraryFolders))) { return null; }
-            
+
             libraryFolders = parse(await readFile(libraryFolders, { encoding: "utf-8" }));
 
             if (!libraryFolders.libraryfolders) { return null; }
@@ -83,7 +108,7 @@ export class SteamService {
             }
 
             return null;
-            
+
         } catch (e) {
             log.error(e);
             return null;
@@ -91,7 +116,7 @@ export class SteamService {
     }
 
     public async openSteam(): Promise<void> {
-        
+
         await shell.openPath("steam://open/games");
 
         return new Promise((resolve, reject) => {

src/renderer/components/modal/modal-types/need-launch-admin-modal.component.tsx

@@ -0,0 +1,34 @@
+import { BsmButton } from "renderer/components/shared/bsm-button.component"
+import { BsmImage } from "renderer/components/shared/bsm-image.component"
+import { ModalComponent, ModalExitCode } from "renderer/services/modale.service"
+import BeatConflict from "../../../../../assets/images/apngs/beat-conflict.png";
+import { useTranslation } from "renderer/hooks/use-translation.hook";
+import { BsmCheckbox } from "renderer/components/shared/bsm-checkbox.component";
+import { useState } from "react";
+
+export const NeedLaunchAdminModal: ModalComponent<boolean, void> = ({resolver}) => {
+
+    const t = useTranslation();
+
+    const [dontShowAgain, setDontShowAgain] = useState(false);
+
+    return (
+        <form className="text-gray-800 dark:text-gray-200 flex flex-col min-w-[350px]">
+            <h1 className="text-3xl uppercase tracking-wide w-full text-center">{t("modals.launch-as-admin.title")}</h1>
+            <BsmImage className="mx-auto h-24" image={BeatConflict} />
+            <div className="flex flex-col gap-3">
+                <p className="w-0 min-w-full">{t("modals.launch-as-admin.body.info")}</p>
+                <p className="w-0 min-w-full">{t("modals.launch-as-admin.body.info-2")}</p>
+                <p className="w-0 min-w-full text-sm italic">{t("modals.launch-as-admin.body.info-3")}</p>
+            </div>
+            <div className="flex flex-row justify-start items-center gap-1.5 my-4">
+                <BsmCheckbox className="relative z-[1] w-6 aspect-square" checked={dontShowAgain} onChange={setDontShowAgain} />
+                <span>{t("modals.launch-as-admin.not-remind-me")}</span>
+            </div>
+            <div className="grid grid-flow-col grid-cols-2 gap-4">
+                <BsmButton typeColor="cancel" className="rounded-md text-center flex items-center justify-center transition-all h-8" onClick={() => resolver({ exitCode: ModalExitCode.CANCELED })} withBar={false} text="misc.cancel" />
+                <BsmButton typeColor="primary" className="rounded-md text-center flex items-center justify-center transition-all h-8" onClick={() => resolver({ exitCode: ModalExitCode.COMPLETED, data: dontShowAgain })} withBar={false} text="modals.launch-as-admin.launch-as-admin" />
+            </div>
+        </form>
+    )
+}

src/renderer/services/bs-launcher.service.ts

@@ -10,6 +10,7 @@ import { ModalExitCode, ModalService } from "./modale.service";
 import { OriginalOculusVersionBackupModal } from "renderer/components/modal/modal-types/original-oculus-version-backup.modal";
 import { CustomError } from "shared/models/exceptions/custom-error.class";
 import { sToMs } from "shared/helpers/time.helpers";
+import { NeedLaunchAdminModal } from "renderer/components/modal/modal-types/need-launch-admin-modal.component";
 
 export class BSLauncherService {
     private static instance: BSLauncherService;
@@ -21,7 +22,7 @@ export class BSLauncherService {
     private readonly modals: ModalService;
 
     public readonly versionRunning$: BehaviorSubject<BSVersion> = new BehaviorSubject(null);
-   
+
     public static getInstance(){
         if(!BSLauncherService.instance){ BSLauncherService.instance = new BSLauncherService(); }
         return BSLauncherService.instance;
@@ -70,7 +71,17 @@ export class BSLauncherService {
             }
         }))
     }
-    
+
+    private async doMustStartAsAdmin(): Promise<boolean> {
+        const needAdmin = await lastValueFrom(this.ipcService.sendV2<boolean, void>("bs-launch.need-start-as-admin"));
+        if(!needAdmin){ return false; }
+        if(this.config.get("dont-remind-admin")){ return true; }
+        const modalRes = await this.modals.openModal(NeedLaunchAdminModal);
+        if(modalRes.exitCode !== ModalExitCode.COMPLETED){ throw new Error("Admin launch canceled"); }
+        this.config.set("dont-remind-admin", modalRes.data);
+        return true;
+    }
+
     public doLaunch(launchOptions: LaunchOption): Observable<BSLaunchEventData>{
         return this.ipcService.sendV2<BSLaunchEventData, LaunchOption>("bs-launch.launch", {args: launchOptions});
     }
@@ -79,17 +90,21 @@ export class BSLauncherService {
 
         return new Observable<BSLaunchEventData>(obs => {
             (async () => {
-                
+
                 if(launchOptions.version.metadata?.store === BsStore.OCULUS && !this.notRewindBackupOculus()){
                     const { exitCode, data: notRewind } = await this.modals.openModal(OriginalOculusVersionBackupModal);
                     if(exitCode !== ModalExitCode.COMPLETED){ return; }
                     this.setNotRewindBackupOculus(notRewind);
                 }
-                
+
+                if(launchOptions.version.metadata?.store !== BsStore.OCULUS){
+                    launchOptions.admin = await this.doMustStartAsAdmin();
+                }
+
                 const launch$ = this.handleLaunchEvents(this.doLaunch(launchOptions));
 
                 await lastValueFrom(launch$);
-                
+
             })().then(() => {
                 obs.complete();
             }).catch(err => {

src/shared/helpers/error.helpers.ts

@@ -1,7 +1,22 @@
-export function tryit<Return>(func: () => Return): {error: Error, result: Return} {
+import { isPromise } from "./promise.helpers";
+
+type TryitReturn<Return> = Return extends Promise<any> ? Promise<{ error: Error | null, result: Awaited<Return> | null }> : { error: Error | null, result: Return | null };
+
+export function tryit<Return>(func: () => Return): TryitReturn<Return> {
     try {
-        return { error: null, result: func() };
+        const result = func();
+
+        if(isPromise(result)){
+            return result
+                .then((value) => ({ error: null, result: value }))
+                .catch((err) => ({ error: err instanceof Error ? err : new Error(`${err}`), result: null })) as Return extends Promise<any>
+                ? Promise<{error: Error, result: undefined} | {error: undefined, result: Awaited<Return>}>
+                : {error: Error, result: undefined} | {error: undefined, result: Return};
+        }
+
+        return { error: undefined, result } as TryitReturn<Return>;
+
     } catch (err) {
-        return { error: err instanceof Error ? err : new Error(`${err}`), result: null }
+        return { error: err, result: undefined } as TryitReturn<Return>;
     }
-}
+}

src/shared/helpers/function.helpers.ts

@@ -0,0 +1,3 @@
+export function isFunction(value: any): value is Function {
+    return !!(value && value.constructor && value.call && value.apply)
+}

src/shared/helpers/promise.helpers.ts

@@ -1,3 +1,5 @@
+import { isFunction } from "./function.helpers";
+
 export type AllSettledHelperOptions = {
     keepStructure?: boolean;
     removeFalsy?: boolean;
@@ -19,3 +21,10 @@ export async function allSettled<T>(promises: Promise<T>[], options?: AllSettled
         return acc;
     }, []);
 }
+
+export function isPromise(value: any): value is Promise<unknown> {
+    if(!value) { return false; }
+    if(!value.then) { return false; }
+    if(!isFunction(value.then)) { return false; }
+    return true;
+}

src/shared/models/bs-launch/launch-option.interface.ts

@@ -5,5 +5,6 @@ export interface LaunchOption {
     oculus?: boolean,
     desktop?: boolean,
     debug?: boolean,
-    additionalArgs?: string[]
+    additionalArgs?: string[],
+    admin?: boolean,
 }