[UI/UX] Improve error handling on BE and FE

electron/games.ts

@@ -35,6 +35,7 @@ abstract class Game {
   abstract moveInstall(newInstallPath: string): Promise<string>
   abstract repair(): Promise<ExecResult>
   abstract stop(): Promise<void>
+  abstract forceUninstall(appName: string, runner: string): void
   abstract syncSaves(arg: string, path: string): Promise<ExecResult>
   abstract uninstall(): Promise<ExecResult>
   abstract update(): Promise<{ status: 'done' | 'error' }>

electron/gog/user.ts

@@ -108,7 +108,7 @@ export class GOGUser {
     } else {
       logError('No credentials, auth required', LogPrefix.Gog)
       errorHandler({
-        error: { stderr: 'No credentials', stdout: '' },
+        error: 'No credentials',
         runner: 'GOG'
       })
       return null

electron/launcher.ts

@@ -447,6 +447,7 @@ async function runLegendaryOrGogdlCommand(
   }
 ): Promise<ExecResult> {
   const fullRunnerPath = join(runner.dir, runner.bin)
+  const appName = commandParts[commandParts.findIndex(() => 'launch') + 1]
   const safeCommand = getLegendaryOrGogdlCommand(
     commandParts,
     options?.env,
@@ -512,12 +513,15 @@ async function runLegendaryOrGogdlCommand(
 
     child.on('close', (code, signal) => {
       errorHandler({
-        error: { stderr: stderr.join(), stdout: stdout.join() },
+        error: `${stdout.join().concat(stderr.join())}`,
         logPath: options?.logFile,
         runner: runner.name
       })
 
-      if (stderr.join().includes('ERROR')) {
+      if (
+        stderr.join().includes('ERROR') ||
+        stderr.join().includes('CRITICAL')
+      ) {
         rej(stderr.join())
       }
 
@@ -543,15 +547,21 @@ async function runLegendaryOrGogdlCommand(
     })
     .catch((error) => {
       errorHandler({
-        error: { stderr: `${error}`, stdout: `${error}` },
+        error: `${error}`,
         logPath: options?.logFile,
-        runner: runner.name
+        runner: runner.name,
+        appName
       })
 
+      const dontShowDialog =
+        `${error}`.includes('signal') &&
+        `${error}`.includes('MemoryError:') &&
+        `${error}`.includes('appears to be deleted')
+
       logError(
         ['Error running', runner.name, 'command', `"${safeCommand}": ${error}`],
         runner.logPrefix,
-        false
+        dontShowDialog
       )
       return { stdout: '', stderr: '', fullCommand: safeCommand, error }
     })

electron/legendary/games.ts

@@ -1,8 +1,14 @@
-import { existsSync, mkdirSync } from 'graceful-fs'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'graceful-fs'
 import axios from 'axios'
 
 import { BrowserWindow } from 'electron'
-import { ExecResult, ExtraInfo, InstallArgs, LaunchResult } from '../types'
+import {
+  ExecResult,
+  ExtraInfo,
+  GameInfo,
+  InstallArgs,
+  LaunchResult
+} from '../types'
 import { Game } from '../games'
 import { GameConfig } from '../game_config'
 import { GlobalConfig } from '../config'
@@ -15,7 +21,8 @@ import {
   userHome,
   isLinux,
   isMac,
-  isWindows
+  isWindows,
+  installed
 } from '../constants'
 import { logError, logInfo, LogPrefix, logWarning } from '../logger/logger'
 import { spawn } from 'child_process'
@@ -31,6 +38,7 @@ import { addShortcuts, removeShortcuts } from '../shortcuts'
 import { basename, join } from 'path'
 import { runLegendaryCommand } from './library'
 import { gameInfoStore } from './electronStores'
+import { mainWindow } from '../main'
 
 class LegendaryGame extends Game {
   public appName: string
@@ -724,6 +732,23 @@ class LegendaryGame extends Game {
       return logInfo(`${pattern} killed`, LogPrefix.Legendary)
     })
   }
+
+  public forceUninstall(appName: string, runner: string) {
+    // Modify Legendary installed.json file:
+    try {
+      const file: Record<string, GameInfo> = JSON.parse(
+        readFileSync(installed, 'utf8')
+      )
+      delete file[appName]
+      writeFileSync(installed, JSON.stringify(file, null, 2))
+      mainWindow.webContents.send('refreshLibrary', runner)
+    } catch (error) {
+      logError(
+        `Error reading ${installed}, could not complete operation`,
+        LogPrefix.Legendary
+      )
+    }
+  }
 }
 
 export { LegendaryGame }

electron/legendary/library.ts

@@ -121,9 +121,14 @@ export class LegendaryLibrary {
           Object.entries(JSON.parse(readFileSync(installedJSON, 'utf-8')))
         )
       } catch (error) {
+        // disabling log here because its giving false positives on import command
         logError(
-          'Corrupted intalled.json file, cannot load installed games',
-          LogPrefix.Legendary
+          [
+            'Corrupted intalled.json file, cannot load installed games',
+            `${error}`
+          ],
+          LogPrefix.Legendary,
+          false
         )
         this.installedGames = new Map()
       }

electron/main.ts

@@ -63,7 +63,6 @@ import {
   getGOGdlBin,
   showErrorBoxModal,
   getFileSize,
-  showErrorBoxModalAuto,
   getWineFromProton
 } from './utils'
 import {
@@ -98,7 +97,7 @@ import { verifyWinePrefix } from './launcher'
 const { showMessageBox, showOpenDialog } = dialog
 const isWindows = platform() === 'win32'
 
-let mainWindow: BrowserWindow = null
+export let mainWindow: BrowserWindow = null
 
 async function createWindow(): Promise<BrowserWindow> {
   configStore.set('userHome', userHome)
@@ -848,39 +847,21 @@ ipcMain.handle(
     let logResult = ''
     return Game.get(appName, runner)
       .launch(launchArguments)
-      .then(
-        async ({
-          stdout,
-          stderr,
-          success,
-          command,
-          gameSettings
-        }: LaunchResult) => {
-          if (!success) {
-            showErrorBoxModalAuto(
-              i18next.t('box.error.title', 'Something Went Wrong'),
-              i18next.t(
-                'box.error.launch',
-                'Error when launching the game, check the logs!'
-              )
-            )
-          }
-
-          logResult = `Launch Command: ${command}
+      .then(async ({ stdout, stderr, command, gameSettings }: LaunchResult) => {
+        logResult = `Launch Command: ${command}
 
 System Info:
 ${await getSystemInfo()}
 
 Game Settings: ${JSON.stringify(gameSettings, null, '\t')}
 `
-          if (stderr) {
-            logResult += `\nError Log:\n${stderr}\n`
-          }
-          if (stdout) {
-            logResult += `\nGame Log:\n${stdout}\n`
-          }
+        if (stderr) {
+          logResult += `\nError Log:\n${stderr}\n`
         }
-      )
+        if (stdout) {
+          logResult += `\nGame Log:\n${stdout}\n`
+        }
+      })
       .catch((exception) => {
         logResult = `${exception.name} - ${exception.message}`
         logError(logResult, LogPrefix.Backend)

electron/utils.ts

@@ -1,3 +1,4 @@
+import { Runner } from './types'
 import * as axios from 'axios'
 import { app, dialog, net, shell, Notification, BrowserWindow } from 'electron'
 import { exec } from 'child_process'
@@ -31,6 +32,8 @@ import {
 import fileSize from 'filesize'
 import makeClient from 'discord-rich-presence-typescript'
 import { RpcClient, SteamRuntime } from 'types'
+import { Game } from './games'
+import { mainWindow } from './main'
 
 const execAsync = promisify(exec)
 const statAsync = promisify(stat)
@@ -287,17 +290,19 @@ export const getSystemInfo = async () => {
 }
 
 type ErrorHandlerMessage = {
-  error?: { stderr: string; stdout: string }
+  error?: string
   logPath?: string
+  appName?: string
   runner: string
 }
 
 async function errorHandler(
-  { error, logPath, runner: r }: ErrorHandlerMessage,
+  { error, logPath, runner: r, appName }: ErrorHandlerMessage,
   window?: BrowserWindow
 ): Promise<void> {
   const noSpaceMsg = 'Not enough available disk space'
-  const runner = r === 'Legendary' ? 'Legendary (Epic Games)' : r
+  const plat = r === 'legendary' ? 'Legendary (Epic Games)' : r
+  const deletedFolderMsg = 'appears to be deleted'
   const otherErrorMessages = [
     'No saved credentials',
     'in get_user_entitlements',
@@ -322,11 +327,30 @@ async function errorHandler(
       .catch(() => logInfo('operation interrupted', LogPrefix.Backend))
   }
   if (error) {
+    if (error.includes(deletedFolderMsg) && appName) {
+      const runner = r.toLocaleLowerCase() as Runner
+      const game = Game.get(appName, runner)
+      const { title } = await game.getGameInfo()
+      const { response } = await showMessageBox(mainWindow, {
+        type: 'question',
+        title,
+        message: i18next.t(
+          'box.error.folder-not-found.title',
+          'Game folder appears to be deleted, do you want to remove the game from the installed list?'
+        ),
+        buttons: [i18next.t('box.no'), i18next.t('box.yes')]
+      })
+
+      if (response === 1) {
+        return game.forceUninstall(appName, runner)
+      }
+    }
+
     otherErrorMessages.forEach((message) => {
-      if (error?.stderr?.includes(message)) {
+      if (error.includes(message)) {
         return showErrorBoxModal(
-          window,
-          runner,
+          mainWindow,
+          plat,
           i18next.t(
             'box.error.credentials.message',
             'Your Crendentials have expired, Logout and Login Again!'

src/state/GlobalState.tsx

@@ -528,6 +528,16 @@ export class GlobalState extends PureComponent<Props> {
       const { libraryStatus } = this.state
       this.handleGameStatus({ ...libraryStatus, ...args })
     })
+
+    ipcRenderer.on('refreshLibrary', async (e, runner) => {
+      this.refreshLibrary({
+        checkForUpdates: false,
+        fullRefresh: true,
+        runInBackground: true,
+        library: runner
+      })
+    })
+
     const legendaryUser = Boolean(configStore.get('userInfo', null))
     const gogUser = Boolean(gogConfigStore.get('userData', null))
     const platform = await getPlatform()