Merge pull request #586 from silentrald/feat/578

[feat-578] remove dotnet and screen dependency on linux

src/main/constants.ts

@@ -16,3 +16,9 @@ export const CACHE_PATH = path.join(app.getPath("userData"), "CachedData");
 export const IMAGE_CACHE_PATH = path.join(CACHE_PATH, "imagescache");
 
 export const HTTP_STATUS_CODES = constants;
+
+// Linux related stuff
+
+export const PROTON_BINARY_PREFIX = "proton";
+export const WINE_BINARY_PREFIX = path.join("files", "bin", "wine64");
+

src/main/ipcs/index.ts

@@ -14,3 +14,4 @@ import "./model-saber.ipcs";
 import "./bs-model-ipcs";
 import "./bs-version-download/bs-download-ipcs";
 import "./static-configuration.ipcs";
+import "./linux.ipcs.ts";

src/main/ipcs/linux.ipcs.ts

@@ -0,0 +1,11 @@
+import { LinuxService } from "main/services/linux.service";
+import { IpcService } from "../services/ipc.service";
+import { of } from "rxjs";
+
+const ipc = IpcService.getInstance();
+
+ipc.on("linux.verify-proton-folder", (_, reply) => {
+    const linuxService = LinuxService.getInstance();
+    reply(of(linuxService.verifyProtonPath()));
+});
+

src/main/ipcs/os-controls-ipcs.ts

@@ -1,9 +1,10 @@
-import { shell, dialog, app, BrowserWindow } from "electron";
+import { shell, dialog, app, BrowserWindow, OpenDialogOptions } from "electron";
 import { NotificationService } from "../services/notification.service";
 import { IpcService } from "../services/ipc.service";
 import { from, of } from "rxjs";
 import { readFileSync } from "fs-extra";
 import log from "electron-log";
+import path from "path";
 
 // TODO IMPROVE WINDOW CONTROL BY USING WINDOW SERVICE
 
@@ -19,7 +20,20 @@ ipc.on("open-dialog", (args, reply) => {
 })
 
 ipc.on("choose-folder", (args, reply) => {
-    reply(from(dialog.showOpenDialog({ properties: ["openDirectory"], defaultPath: args ?? "" })));
+    const options: OpenDialogOptions = {
+        properties: ["openDirectory"],
+        defaultPath: args?.defaultPath ?? ""
+    };
+
+    if (args?.showHidden) {
+        options.properties.push("showHiddenFiles");
+    }
+
+    if (args?.parent) {
+        options.defaultPath = path.join(app.getPath(args.parent), options.defaultPath);
+    }
+
+    reply(from(dialog.showOpenDialog(options)));
 });
 
 ipc.on("choose-file", async (args, reply) => {

src/main/ipcs/static-configuration.ipcs.ts

@@ -1,4 +1,4 @@
-import { of } from "rxjs";
+import { from, of } from "rxjs";
 import { IpcService } from "../services/ipc.service";
 import { StaticConfigurationService } from "../services/static-configuration.service";
 
@@ -10,5 +10,5 @@ ipc.on("static-configuration.get", (args, reply) => {
 });
 
 ipc.on("static-configuration.set", (args, reply) => {
-    reply(of(staticConfig.set(args.key, args.value)));
+    reply(from(staticConfig.set(args.key, args.value)));
 });

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

@@ -1,16 +1,17 @@
 import { Observable } from "rxjs";
 import { BSLaunchError, BSLaunchEvent, BSLaunchEventData, BSLaunchWarning, LaunchOption } from "../../../shared/models/bs-launch";
 import { StoreLauncherInterface } from "./store-launcher.interface";
-import { pathExists, rename } from "fs-extra";
+import { pathExists, pathExistsSync, rename } from "fs-extra";
 import { SteamService } from "../steam.service";
 import path from "path";
-import { BS_APP_ID, BS_EXECUTABLE, STEAMVR_APP_ID } from "../../constants";
+import { BS_APP_ID, BS_EXECUTABLE, PROTON_BINARY_PREFIX, 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 { UtilsService } from "../utils.service";
 import { exec } from "child_process";
 import fs from 'fs';
+import { StaticConfigurationService } from "../static-configuration.service";
 
 export class SteamLauncherService extends AbstractLauncherService implements StoreLauncherInterface{
 
@@ -23,11 +24,13 @@ export class SteamLauncherService extends AbstractLauncherService implements Sto
         return SteamLauncherService.instance;
     }
 
+    private readonly staticConfig: StaticConfigurationService;
     private readonly steam: SteamService;
     private readonly util: UtilsService;
 
     private constructor(){
         super();
+        this.staticConfig = StaticConfigurationService.getInstance();
         this.steam = SteamService.getInstance();
         this.util = UtilsService.getInstance();
     }
@@ -128,9 +131,16 @@ export class SteamLauncherService extends AbstractLauncherService implements Sto
                     `${exePath}`,
                     ...launchArgs,
                 ];
-                exePath = launchOptions.protonPath;
-                if (!exePath) {
-                    throw CustomError.fromError(new Error("Proton path not set"), BSLaunchError.PROTON_NOT_SET);
+
+                if (!this.staticConfig.has("proton-folder")) {
+                    throw CustomError.fromError(new Error("Proton folder not set"), BSLaunchError.PROTON_NOT_SET);
+                }
+                exePath = path.join(this.staticConfig.get("proton-folder"), PROTON_BINARY_PREFIX);
+                if (!pathExistsSync(exePath)) {
+                    throw CustomError.fromError(
+                        new Error("Could not locate proton binary"),
+                        BSLaunchError.PROTON_NOT_FOUND
+                    );
                 }
 
                 // Setup Proton environment variables

src/main/services/linux.service.ts

@@ -0,0 +1,51 @@
+import path from "path";
+import { pathExistsSync } from "fs-extra";
+import { PROTON_BINARY_PREFIX, WINE_BINARY_PREFIX } from "main/constants";
+import { StaticConfigurationService } from "./static-configuration.service";
+
+export class LinuxService {
+    private static instance: LinuxService;
+
+    public static getInstance(): LinuxService {
+        if (!LinuxService.instance) {
+            LinuxService.instance = new LinuxService();
+        }
+        return LinuxService.instance;
+    }
+
+    private readonly staticConfig: StaticConfigurationService;
+
+    private constructor() {
+        this.staticConfig = StaticConfigurationService.getInstance();
+    }
+
+    public verifyProtonPath(protonFolder: string = ""): boolean {
+        if (protonFolder === "") {
+            if (!this.staticConfig.has("proton-folder")) {
+                return false;
+            }
+
+            protonFolder = this.staticConfig.get("proton-folder");
+        }
+
+        const protonPath = path.join(protonFolder, PROTON_BINARY_PREFIX);
+        const winePath = path.join(protonFolder, WINE_BINARY_PREFIX);
+        return pathExistsSync(protonPath) && pathExistsSync(winePath);
+    }
+
+    public getWinePath(): string {
+        if (!this.staticConfig.has("proton-folder")) {
+            throw new Error("proton-folder variable not set");
+        }
+
+        const winePath = path.join(
+            this.staticConfig.get("proton-folder"),
+            WINE_BINARY_PREFIX
+        );
+        if (!pathExistsSync(winePath)) {
+            throw new Error(`"${winePath}" binary file not found`);
+        }
+
+        return winePath;
+    }
+}

src/main/services/mods/bs-mods-manager.service.ts

@@ -17,12 +17,15 @@ import { sToMs } from "../../../shared/helpers/time.helpers";
 import { ensureDir, pathExistsSync } from "fs-extra";
 import { CustomError } from "shared/models/exceptions/custom-error.class";
 import { popElement } from "shared/helpers/array.helpers";
+import { LinuxService } from "../linux.service";
+import { tryit } from "shared/helpers/error.helpers";
 
 export class BsModsManagerService {
     private static instance: BsModsManagerService;
 
     private readonly beatModsApi: BeatModsApiService;
     private readonly bsLocalService: BSLocalVersionService;
+    private readonly linuxService: LinuxService;
     private readonly requestService: RequestService;
 
     private manifestMatches: Mod[];
@@ -37,6 +40,7 @@ export class BsModsManagerService {
     private constructor() {
         this.beatModsApi = BeatModsApiService.getInstance();
         this.bsLocalService = BSLocalVersionService.getInstance();
+        this.linuxService = LinuxService.getInstance();
         this.requestService = RequestService.getInstance();
     }
 
@@ -140,25 +144,34 @@ export class BsModsManagerService {
             return false;
         }
 
-        return new Promise<boolean>(resolve => {
-            const cmd = process.platform === 'linux'
-                ? `screen -dmS "BSIPA" dotnet "${ipaPath}" ${args.join(" ")}` // Must run through screen, otherwise BSIPA tries to move console cursor and crashes.
-                : `"${ipaPath}" ${args.join(" ")}`;
+        let cmd = `"${ipaPath}" "${bsExePath}" ${args.join(" ")}`;
+        if (process.platform === "linux") {
+            const { error, result: winePath } = tryit(() => this.linuxService.getWinePath());
+            if (error) {
+                log.error(error);
+                return false;
+            }
+            cmd = `"${winePath}" ${cmd}`;
+        }
 
+        return new Promise<boolean>(resolve => {
             log.info("START IPA PROCESS", cmd);
             const processIPA = spawn(cmd, { cwd: versionPath, detached: true, shell: true });
 
-            const timemout = setTimeout(() => {
+            const timeout = setTimeout(() => {
                 log.info("Ipa process timeout");
                 resolve(false)
             }, sToMs(30));
 
+            processIPA.stdout.on("data", data => {
+                log.info("IPA process stdout", data.toString());
+            });
             processIPA.stderr.on("data", data => {
                 log.error("IPA process stderr", data.toString());
             })
 
             processIPA.once("exit", code => {
-                clearTimeout(timemout);
+                clearTimeout(timeout);
                 if (code === 0) {
                     log.info("Ipa process exist with code 0");
                     return resolve(true);
@@ -195,7 +208,7 @@ export class BsModsManagerService {
         }
 
         const crypto = require("crypto");
-        const files = await zip.files;
+        const { files } = zip;
 
         const checkedEntries = (
             await Promise.all(

src/main/services/static-configuration.service.ts

@@ -1,6 +1,10 @@
 import ElectronStore from "electron-store";
+import { pathExistsSync } from "fs-extra";
+import path from "path";
+import { PROTON_BINARY_PREFIX, WINE_BINARY_PREFIX } from "main/constants";
 import { Observable, Subject } from "rxjs";
 import { BSVersion } from "shared/bs-version.interface";
+import { CustomError } from "shared/models/exceptions/custom-error.class";
 
 export class StaticConfigurationService {
     private static instance: StaticConfigurationService;
@@ -34,7 +38,17 @@ export class StaticConfigurationService {
         cb(this.get(key));
     }
 
-    public set<K extends StaticConfigKeys>(key: K, value: StaticConfigKeyValues[K]): void {
+    public async set<K extends StaticConfigKeys>(key: K, value: StaticConfigKeyValues[K]): Promise<void> {
+        // Validate the setters
+        switch (key) {
+            case "proton-folder":
+                this.validateProtonFolder(value as string);
+                break;
+
+            default:
+                break;
+        }
+
         this.store.set(key, value);
 
         if (this.watchers[key]) {
@@ -42,6 +56,16 @@ export class StaticConfigurationService {
         }
     }
 
+    // Setters with validation
+
+    private validateProtonFolder(protonFolder: string): void {
+        const protonPath = path.join(protonFolder, PROTON_BINARY_PREFIX);
+        const winePath = path.join(protonFolder, WINE_BINARY_PREFIX);
+        if (!pathExistsSync(protonPath) || !pathExistsSync(winePath)) {
+            throw new CustomError("Invalid proton folder path", "invalid-folder");
+        }
+    }
+
     public delete<K extends StaticConfigKeys>(key: K): void {
         this.store.delete(key);
     }
@@ -60,12 +84,15 @@ export class StaticConfigurationService {
 }
 
 export interface StaticConfigKeyValues {
-    "versions": BSVersion[];
     "installation-folder": string;
     "song-details-cache-etag": string;
     "disable-hadware-acceleration": boolean;
     "use-symlinks": boolean;
-}
+
+    // Linux Specific static configs
+    "versions": BSVersion[];
+    "proton-folder": string;
+};
 
 export type StaticConfigKeys = keyof StaticConfigKeyValues;
 
@@ -77,5 +104,5 @@ export type StaticConfigGetIpcRequestResponse<K extends StaticConfigKeys> = {
 export type StaticConfigSetIpcRequest<K extends StaticConfigKeys> = {
     request: { key: K, value: StaticConfigKeyValues[K] };
     response: void;
-}
+};
 

src/renderer/components/modal/modal-types/setup/ask-install-path.component.tsx

@@ -75,7 +75,7 @@ export const AskInstallPathModal: ModalComponent<{ installPath: string }, {}> =
                 <BsmButton
                     onClick={selectInstallPath}
                     className="shrink-0 whitespace-nowrap mr-2 px-2 font-bold italic text-sm rounded-md"
-                    text="modals.ask-install-path.choose-folder"
+                    text="misc.choose-folder"
                     withBar={false}
                 />
             </div>

src/renderer/components/modal/modal-types/setup/choose-proton-folder-modal.component.tsx

@@ -0,0 +1,97 @@
+import { lastValueFrom } from "rxjs";
+import { useState } from "react";
+import { useTranslation } from "renderer/hooks/use-translation.hook";
+import { useService } from "renderer/hooks/use-service.hook";
+
+import { IpcService } from "renderer/services/ipc.service";
+import { ModalComponent, ModalExitCode } from "renderer/services/modale.service";
+import { NotificationService } from "renderer/services/notification.service";
+import { StaticConfigurationService } from "renderer/services/static-configuration.service";
+
+import { BsmButton } from "renderer/components/shared/bsm-button.component";
+
+export const ChooseProtonFolderModal: ModalComponent<{}, {}> = ({ resolver }) => {
+
+    const t = useTranslation();
+    const ipcService = useService(IpcService);
+    const notificationService = useService(NotificationService);
+    const staticConfigService = useService(StaticConfigurationService);
+
+    const [protonFolder, setProtonFolder] = useState(null);
+
+    const selectProtonPath = async () => {
+        const response = await lastValueFrom(ipcService.sendV2("choose-folder", {
+            parent: "home",
+            defaultPath: ".local/share/Steam/steamapps/common",
+            showHidden: true,
+        }));
+
+        if (response.canceled || !response.filePaths?.length) {
+            return;
+        }
+
+        const path = response.filePaths[0];
+
+        await staticConfigService.set("proton-folder", path).then(() => {
+            setProtonFolder(path);
+        }).catch(err => {
+            notificationService.notifyError({
+                title: "pages.settings.proton-folder.errors.title",
+                desc: ["invalid-folder"].includes(err?.code)
+                    ? `pages.settings.proton-folder.errors.${err.code}`
+                    : "misc.unknown"
+            });
+        });
+    }
+
+    const onConfirmButtonPressed = async () => {
+        resolver({
+            exitCode: ModalExitCode.COMPLETED
+        });
+    }
+
+    return (
+        <form
+            className="max-w-lg w-max flex flex-col gap-3"
+            onSubmit={event => {
+                event.preventDefault();
+                onConfirmButtonPressed();
+            }}>
+
+            <h1 className="tracking-wide w-full uppercase text-3xl text-center mb-4">{t("modals.choose-proton-folder.title")}</h1>
+
+            <p>{t("modals.choose-proton-folder.proton-folder-description")}</p>
+
+            <a className="underline" href="https://github.com/ValveSoftware/Proton/wiki/Proton-FAQ#where-is-proton-installed" target="_blank">{t("modals.choose-proton-folder.where-is-proton-installed")}</a>
+            <div className="relative flex items-center justify-between w-full h-8 bg-light-main-color-1 dark:bg-main-color-1 rounded-md pl-2 py-1">
+                    {protonFolder ? (
+                        <span
+                            className="block text-ellipsis overflow-hidden min-w-0 whitespace-nowrap"
+                            title={protonFolder}
+                        >
+                            {protonFolder}
+                        </span>
+                    ) : (
+                        <span className="text-gray-500 italic font-bold">{t("modals.choose-proton-folder.proton-folder-placeholder")}</span>
+                    )}
+                    <BsmButton
+                        onClick={selectProtonPath}
+                        className="shrink-0 whitespace-nowrap mr-2 px-2 font-bold italic text-sm rounded-md"
+                        text="misc.choose-folder"
+                        withBar={false}
+                    />
+            </div>
+
+            <div className="h-8 grid grid-flow-col grid-cols-1">
+                <BsmButton
+                    typeColor="primary"
+                    className="rounded-md text-center transition-all"
+                    type="submit"
+                    withBar={false}
+                    text="misc.confirm"
+                    disabled={!protonFolder}
+                />
+            </div>
+        </form>
+    )
+}

src/renderer/components/modal/modal-types/share-folders-modal.component.tsx

@@ -47,7 +47,9 @@ export const ShareFoldersModal: ModalComponent<void, BSVersion> = ({ options: {d
 
     const addFolder = async () => {
         const versionPath = await lastValueFrom(versionManager.getVersionPath(data));
-        const folder = await lastValueFrom(ipc.sendV2("choose-folder", versionPath));
+        const folder = await lastValueFrom(ipc.sendV2("choose-folder", {
+            defaultPath: versionPath
+        }));
 
         if (!folder || folder.canceled || !folder.filePaths?.length) {
             return;

src/renderer/components/shared/bsm-button.component.tsx

@@ -90,7 +90,7 @@ export const BsmButton = forwardRef<unknown, Props>(({ className, style, iconSty
             {icon && <BsmIcon icon={icon} className={iconClassName ?? "size-full text-gray-800 dark:text-white"} style={{ ...(iconStyle ?? {}), color: (iconColor || textColor) }} />}
             {text &&
                 (type === "submit" ? (
-                    <button type="submit" className={textClassName || "size-full"} style={{ ...(!!textColor && { color: textColor }) }}>
+                    <button type="submit" className={textClassName || "size-full"} style={{ ...(!!textColor && { color: textColor }) }} disabled={disabled}>
                         {t(text)}
                     </button>
                 ) : (

src/renderer/components/version-viewer/slides/launch/launch-slide.component.tsx

@@ -66,7 +66,6 @@ export function LaunchSlide({ version }: Props) {
             desktop: desktopMode,
             debug: debugMode,
             additionalArgs: advancedLaunch ? additionalArgs : [],
-            protonPath: bsLauncherService.getProtonPath(),
         });
 
         return lastValueFrom(launch$).catch(() => {});

src/renderer/pages/settings-page.component.tsx

@@ -43,7 +43,6 @@ import { AutoUpdaterService } from "renderer/services/auto-updater.service";
 import BeatWaitingImg from "../../../assets/images/apngs/beat-waiting.png";
 import BeatConflict from "../../../assets/images/apngs/beat-conflict.png";
 import { logRenderError } from "renderer";
-import { BSLauncherService } from "renderer/services/bs-launcher.service";
 import { SettingToogleSwitchGrid } from "renderer/components/settings/setting-toogle-switch-grid.component";
 import { BasicModal } from "renderer/components/modal/basic-modal.component";
 import { StaticConfigurationService } from "renderer/services/static-configuration.service";
@@ -57,7 +56,6 @@ export function SettingsPage() {
     const ipcService = useService(IpcService);
     const modalService = useService(ModalService);
     const bsDownloader = useService(BsDownloaderService);
-    const bsLauncher = useService(BSLauncherService);
     const steamDownloader = useService(SteamDownloaderService);
     const progressBarService = useService(ProgressBarService);
     const notificationService = useService(NotificationService);
@@ -94,7 +92,7 @@ export function SettingsPage() {
     const downloadStore = useObservable(() => bsDownloader.defaultStore$);
 
     const [installationFolder, setInstallationFolder] = useState(null);
-    const [protonPath, setProtonPath] = useState(bsLauncher.getProtonPath());
+    const [protonFolder, setProtonFolder] = useState("");
     const [showSupporters, setShowSupporters] = useState(false);
     const [mapDeepLinksEnabled, setMapDeepLinksEnabled] = useState(false);
     const [playlistsDeepLinkEnabled, setPlaylistsDeepLinkEnabled] = useState(false);
@@ -116,6 +114,7 @@ export function SettingsPage() {
 
         staticConfig.get("disable-hadware-acceleration").then(disabled =>setHardwareAccelerationEnabled(() => disabled !== true));
         staticConfig.get("use-symlinks").then(useSymlinks => setUseSymlink(() => useSymlinks));
+        staticConfig.get("proton-folder").then(setProtonFolder);
     }, []);
 
     const allDeepLinkEnabled = mapDeepLinksEnabled && playlistsDeepLinkEnabled && modelsDeepLinkEnabled;
@@ -180,18 +179,36 @@ export function SettingsPage() {
         clearTimeout(timeoutId);
     };
 
-    const setDefaultProtonPath = () => {
+    const setDefaultProtonFolder = async () => {
         if (!progressBarService.require()) {
             return;
         }
 
-        lastValueFrom(ipcService.sendV2("choose-file")).then(res => {
-            if (!res.canceled && res.filePaths?.length) {
-                const protonPath = res.filePaths[0];
-                setProtonPath(protonPath);
-                bsLauncher.setProtonPath(protonPath);
+        try {
+            const pathResponse = await lastValueFrom(ipcService.sendV2("choose-folder", {
+                parent: "home",
+                defaultPath: ".local/share/Steam/steamapps/common",
+                showHidden: true,
+        }));
+            if (
+                pathResponse.canceled
+                || !pathResponse.filePaths
+                || pathResponse.filePaths.length === 0
+            ) {
+                return;
             }
-        });
+
+            const folder = pathResponse.filePaths[0];
+            await staticConfig.set("proton-folder", folder);
+            setProtonFolder(folder);
+        } catch (error: any) {
+            notificationService.notifyError({
+                title: "pages.settings.proton-folder.errors.title",
+                desc: ["invalid-folder"].includes(error?.code)
+                    ? `pages.settings.proton-folder.errors.${error.code}`
+                    : "misc.unknown",
+            });
+        }
     };
 
     const setDefaultInstallationFolder = () => {
@@ -390,16 +407,16 @@ export function SettingsPage() {
                         <span className="block text-ellipsis overflow-hidden min-w-0" title={installationFolder}>
                             {installationFolder}
                         </span>
-                        <BsmButton onClick={setDefaultInstallationFolder} className="shrink-1 whitespace-nowrap mr-2 px-2 font-bold italic text-sm rounded-md" text="pages.settings.installation-folder.choose-folder" withBar={false} />
+                        <BsmButton onClick={setDefaultInstallationFolder} className="shrink-1 whitespace-nowrap mr-2 px-2 font-bold italic text-sm rounded-md" text="misc.choose-folder" withBar={false} />
                     </div>
                 </SettingContainer>
 
-                <SettingContainer os="linux" title="pages.settings.proton-path.title" description="pages.settings.proton-path.description">
+                <SettingContainer os="linux" title="pages.settings.proton-folder.title" description="pages.settings.proton-folder.description">
                     <div className="relative flex items-center justify-between w-full h-8 bg-light-main-color-1 dark:bg-main-color-1 rounded-md pl-2 py-1">
-                        <span className="block text-ellipsis overflow-hidden min-w-0 whitespace-nowrap" title={protonPath}>
-                            {protonPath}
+                        <span className="block text-ellipsis overflow-hidden min-w-0 whitespace-nowrap" title={protonFolder}>
+                            {protonFolder}
                         </span>
-                        <BsmButton onClick={setDefaultProtonPath} className="shrink-0 whitespace-nowrap mr-2 px-2 font-bold italic text-sm rounded-md" text="pages.settings.proton-path.choose-file" withBar={false} />
+                        <BsmButton onClick={setDefaultProtonFolder} className="shrink-0 whitespace-nowrap mr-2 px-2 font-bold italic text-sm rounded-md" text="misc.choose-folder" withBar={false} />
                     </div>
                 </SettingContainer>
 

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

@@ -23,8 +23,6 @@ export class BSLauncherService {
 
     public readonly versionRunning$: BehaviorSubject<BSVersion> = new BehaviorSubject(null);
 
-    private readonly PROTON_PATH_KEY = "protonPath";
-
     public static getInstance(){
         if(!BSLauncherService.instance){ BSLauncherService.instance = new BSLauncherService(); }
         return BSLauncherService.instance;
@@ -38,14 +36,6 @@ export class BSLauncherService {
         this.modals = ModalService.getInstance();
     }
 
-    public setProtonPath(protonPath: string|undefined): void {
-        this.config.set(this.PROTON_PATH_KEY, protonPath);
-    }
-
-    public getProtonPath(): string|undefined {
-        return this.config.get<string>(this.PROTON_PATH_KEY);
-    }
-
     private notRewindBackupOculus(): boolean{
         return this.config.get<boolean>("not-rewind-backup-oculus");
     }
@@ -93,7 +83,6 @@ export class BSLauncherService {
     }
 
     public doLaunch(launchOptions: LaunchOption): Observable<BSLaunchEventData>{
-        launchOptions.protonPath = this.getProtonPath();
         return this.ipcService.sendV2("bs-launch.launch", launchOptions);
     }
 

src/renderer/services/setup.service.ts

@@ -6,7 +6,8 @@ import { InstallationLocationService } from "./installation-location.service";
 import { IpcService } from "./ipc.service";
 import { ModalService } from "./modale.service";
 
-import { AskInstallPathModal } from "renderer/components/modal/modal-types/ask-install-path.component";
+import { AskInstallPathModal } from "renderer/components/modal/modal-types/setup/ask-install-path.component";
+import { ChooseProtonFolderModal } from "renderer/components/modal/modal-types/setup/choose-proton-folder-modal.component";
 
 // Handle setup modals/prompts, ordering of the modals/prompts may be done here
 export class SetupService {
@@ -35,6 +36,10 @@ export class SetupService {
         try {
             // NOTE: for modal sequencing
             await this.checkInstallationPath();
+
+            if (window.electron.platform === "linux") {
+                await this.checkProtonFolder();
+            }
         } catch (error) {
             logRenderError(error);
         }
@@ -61,4 +66,20 @@ export class SetupService {
         }
     }
 
+    private async checkProtonFolder(): Promise<void> {
+        try {
+            const valid = await lastValueFrom(this.ipcService.sendV2("linux.verify-proton-folder"));
+            if (valid) {
+                return;
+            }
+
+            await this.modalService.openModal(
+                ChooseProtonFolderModal,
+                { closable: false }
+            );
+        } catch (error) {
+            logRenderError(error);
+        }
+    }
+
 }

src/shared/models/bs-launch/launch-event.model.ts

@@ -15,6 +15,7 @@ export enum BSLaunchError{
     BS_EXIT_ERROR = "EXIT",
     OCULUS_LIB_NOT_FOUND = "OCULUS_LIB_NOT_FOUND",
     PROTON_NOT_SET = "PROTON_NOT_SET",
+    PROTON_NOT_FOUND = "PROTON_NOT_FOUND",
     UNKNOWN_ERROR = "UNKNOWN_ERROR",
 }
 

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

@@ -7,5 +7,4 @@ export interface LaunchOption {
     debug?: boolean,
     additionalArgs?: string[],
     admin?: boolean,
-    protonPath?: string,
 }

src/shared/models/ipc/ipc-routes.ts

@@ -124,7 +124,7 @@ export interface IpcChannelMapping {
     /* ** os-controls-ipcs ** */
     "new-window": { request: string, response: void };
     "open-dialog": { request: OpenDialogOptions, response: OpenDialogReturnValue };
-    "choose-folder": { request: string, response: OpenDialogReturnValue };
+    "choose-folder": { request: { defaultPath?: string, parent?: "home", showHidden?: boolean }, response: OpenDialogReturnValue };
     "choose-file": { request: string, response: OpenDialogReturnValue }
     "choose-image": { request: { multiple?: boolean, base64?: boolean }, response: string[] }
     "window.progression": { request: number, response: void };
@@ -150,6 +150,9 @@ export interface IpcChannelMapping {
     "static-configuration.get": StaticConfigGetIpcRequestResponse<StaticConfigKeys>;
     "static-configuration.set": StaticConfigSetIpcRequest<StaticConfigKeys>;
 
+    /* ** linux.ipcs ** */
+    "linux.verify-proton-folder": { request: void, response: boolean };
+
     /* ** OTHERS (if your IPC channel is not in a "-ipcs" file, put it here) ** */
     "shortcut-launch-options": { request: void, response: LaunchOption };
 }