tech: use callRunner to launch steam

Author: flavioislima

src/backend/constants.ts

@@ -80,8 +80,13 @@ const cachedUbisoftInstallerPath = join(
 const ipdtPatcher = join(toolsPath, 'ipdt')
 const ipdtManifestsPath = join(appConfigFolder, 'manifests')
 
-const { currentLogFile, lastLogFile, legendaryLogFile, gogdlLogFile } =
-  createNewLogFileAndClearOldOnes()
+const {
+  currentLogFile,
+  lastLogFile,
+  legendaryLogFile,
+  gogdlLogFile,
+  steamLogFile
+} = createNewLogFileAndClearOldOnes()
 
 const gogdlAuthConfig = join(app.getPath('userData'), 'gog_store', 'auth.json')
 const iconDark = fixAsarPath(join(publicDir, 'trayIconDark24x24.png'))
@@ -251,6 +256,7 @@ export {
   lastLogFile,
   legendaryLogFile,
   gogdlLogFile,
+  steamLogFile,
   discordLink,
   twitterLink,
   execOptions,

src/backend/logger/logfile.ts

@@ -16,6 +16,7 @@ interface createLogFileReturn {
   lastLogFile: string
   legendaryLogFile: string
   gogdlLogFile: string
+  steamLogFile: string
 }
 
 let longestPrefix = 0
@@ -47,10 +48,12 @@ export function createNewLogFileAndClearOldOnes(): createLogFileReturn {
   const newLogFile = join(logDir, `hyperplay-${fmtDate}.log`)
   const newLegendaryLogFile = join(logDir, `legendary-${fmtDate}.log`)
   const newGogdlLogFile = join(logDir, `gogdl-${fmtDate}.log`)
+  const newSteamLogFile = join(logDir, `steam-${fmtDate}.log`)
 
   createLogFile(newLogFile)
   createLogFile(newLegendaryLogFile)
   createLogFile(newGogdlLogFile)
+  createLogFile(newSteamLogFile)
 
   // Clean out logs that are more than a month old
   if (existsSync(logDir)) {
@@ -88,7 +91,8 @@ export function createNewLogFileAndClearOldOnes(): createLogFileReturn {
     currentLogFile: '',
     lastLogFile: '',
     legendaryLogFile: '',
-    gogdlLogFile: ''
+    gogdlLogFile: '',
+    steamLogFile: ''
   })
 
   if (!isNewInstance) {
@@ -99,6 +103,7 @@ export function createNewLogFileAndClearOldOnes(): createLogFileReturn {
   logs.currentLogFile = newLogFile
   logs.legendaryLogFile = newLegendaryLogFile
   logs.gogdlLogFile = newGogdlLogFile
+  logs.steamLogFile = newSteamLogFile
   configStore.set('general-logs', logs)
 
   // get longest prefix to log lines in a kind of table
@@ -121,7 +126,8 @@ export function getLogFile(appNameOrRunner: string): string {
     currentLogFile: '',
     lastLogFile: '',
     legendaryLogFile: '',
-    gogdlLogFile: ''
+    gogdlLogFile: '',
+    steamLogFile: ''
   })
 
   switch (appNameOrRunner) {

src/backend/storeManagers/steam/games.ts

@@ -1,6 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
+
+import { dirname, join } from 'node:path'
+import { GlobalConfig } from 'backend/config'
+import { isWindows, steamLogFile, userHome } from 'backend/constants'
+
 import { getGameInfo as getSteamLibraryGameInfo } from './library'
-import { logError, LogPrefix } from 'backend/logger/logger'
+import { logError, logInfo, LogPrefix, logWarning } from 'backend/logger/logger'
 import {
   GameInfo,
   GameSettings,
@@ -13,6 +18,8 @@ import {
 import { existsSync } from 'graceful-fs'
 import { GOGCloudSavesLocation } from 'common/types/gog'
 import { InstallResult, RemoveArgs } from 'common/types/game_manager'
+import { callRunner, setupEnvVars } from 'backend/launcher'
+import { createAbortController } from 'backend/utils/aborthandler/aborthandler'
 
 export function getGameInfo(appName: string): GameInfo {
   const info = getSteamLibraryGameInfo(appName)
@@ -88,8 +95,8 @@ export async function install(
 }
 
 export function isNative(appName: string): boolean {
-  // not used
-  return false
+  // Steam games are considered native if they run on the Steam client
+  return true
 }
 
 export async function addShortcuts(
@@ -107,8 +114,59 @@ export async function launch(
   appName: string,
   launchArguments?: string
 ): Promise<boolean> {
-  // not used
-  return false
+  const gameInfo = getGameInfo(appName)
+  if (!gameInfo || !gameInfo.is_installed) {
+    logWarning(`Game ${appName} is not installed or does not exist`, {
+      prefix: LogPrefix.Steam
+    })
+    return false
+  }
+
+  const steamBinaryPath = getSteamBinaryPath()
+  if (!existsSync(steamBinaryPath)) {
+    logError('Steam binary not found', { prefix: LogPrefix.Steam })
+    return false
+  }
+
+  const bin = getSteamBinaryPath()
+  const dir = dirname(bin)
+  const commandParts = [bin, '-applaunch', gameInfo.app_name]
+  const gameSettings = await getSettings(appName)
+  const commandEnv = isWindows
+    ? process.env
+    : { ...process.env, ...setupEnvVars(gameSettings) }
+  const options = {
+    env: {
+      ...commandEnv
+    },
+    logMessagePrefix: `Launching ${gameInfo.title}`
+  }
+  const abortController = createAbortController(appName)
+
+  const { error, abort } = await callRunner(
+    [...commandParts],
+    { name: 'steam', logPrefix: LogPrefix.Steam, bin, dir },
+    abortController,
+    {
+      ...options,
+      verboseLogFile: steamLogFile
+    },
+    gameInfo
+  )
+
+  if (error) {
+    logError(`Failed to launch game ${appName}: ${error}`, {
+      prefix: LogPrefix.Steam
+    })
+    return false
+  }
+
+  if (abort) {
+    logWarning(`Game ${appName} launch aborted`, { prefix: LogPrefix.Steam })
+    return false
+  }
+  logInfo(`Game ${appName} launched successfully`, { prefix: LogPrefix.Steam })
+  return true
 }
 
 export async function moveInstall(
@@ -158,3 +216,33 @@ export async function stop(appName: string): Promise<void> {
 export async function pause(appName: string): Promise<void> {
   // not used
 }
+
+function getSteamBinaryPath(): string {
+  const { defaultSteamPath } = GlobalConfig.get().getSettings()
+  const steamPath = defaultSteamPath.replaceAll("'", '')
+
+  if (process.platform === 'win32') {
+    return join(steamPath, 'steam.exe')
+  } else if (process.platform === 'darwin') {
+    const steamApp = join('/Applications', 'Steam.app')
+    if (existsSync(steamApp)) {
+      return join(steamApp, 'Contents', 'MacOS', 'steam_osx')
+    }
+  } else {
+    // For Linux it could be on /usr/bin/steam or in the flatpak path from home/.var/app/com.valvesoftware.Steam/.steam/steam
+    const flatpakSteamPath = join(
+      userHome,
+      '.var',
+      'app',
+      'com.valvesoftware.Steam',
+      '.steam',
+      'steam'
+    )
+
+    if (existsSync(flatpakSteamPath)) {
+      return flatpakSteamPath
+    }
+    return join('/usr', 'bin', 'steam')
+  }
+  return ''
+}

src/common/types/electron_store.ts

@@ -39,6 +39,7 @@ export interface StoreStructure {
       lastLogFile: string
       legendaryLogFile: string
       gogdlLogFile: string
+      steamLogFile: string
     }
     'window-props': Electron.Rectangle
     settings: AppSettings

src/frontend/helpers/library.ts

@@ -153,13 +153,6 @@ const launch = async ({
   showDialogModal,
   isNotNative
 }: LaunchOptions): Promise<{ status: 'done' | 'error' | 'abort' }> => {
-  if (runner === 'steam') {
-    return new Promise((resolve) => {
-      window.api.openExternalUrl(`steam://run/${appName}`)
-      resolve({ status: 'done' })
-    })
-  }
-
   const showCompatibilityWarningDialog: boolean =
     isNotNative &&
     JSON.parse(

src/frontend/screens/Game/GamePage/index.tsx

@@ -702,7 +702,7 @@ export default observer(function GamePage(): React.JSX.Element | null {
                   runner={runner}
                 />
               )}
-              {is_installed && !isSteam && (
+              {is_installed && (
                 <span
                   onClick={() => setIsSettingsModalOpen(true, 'log', gameInfo)}
                   className="clickable reportProblem"