tech: add steam runner wip

Author: flavioislima

src/backend/storeManagers/index.ts

@@ -2,11 +2,13 @@ import * as HyperPlayGameManager from 'backend/storeManagers/hyperplay/games'
 import * as SideloadGameManager from 'backend/storeManagers/sideload/games'
 import * as GOGGameManager from 'backend/storeManagers/gog/games'
 import * as LegendaryGameManager from 'backend/storeManagers/legendary/games'
+import * as SteamGameManager from 'backend/storeManagers/steam/games'
 
 import * as HyperPlayLibraryManager from 'backend/storeManagers/hyperplay/library'
 import * as SideloadLibraryManager from 'backend/storeManagers/sideload/library'
 import * as GOGLibraryManager from 'backend/storeManagers/gog/library'
 import * as LegendaryLibraryManager from 'backend/storeManagers/legendary/library'
+import * as SteamLibraryManager from 'backend/storeManagers/steam/library'
 import { GameManager, LibraryManager } from 'common/types/game_manager'
 
 import { logInfo, RunnerToLogPrefixMap } from 'backend/logger/logger'
@@ -27,14 +29,16 @@ export const gameManagerMap: Record<Runner, GameManager> = {
   hyperplay: HyperPlayGameManager,
   sideload: SideloadGameManager,
   gog: GOGGameManager,
-  legendary: LegendaryGameManager
+  legendary: LegendaryGameManager,
+  steam: SteamGameManager
 }
 
 export const libraryManagerMap: Record<Runner, LibraryManager> = {
   hyperplay: HyperPlayLibraryManager,
   legendary: LegendaryLibraryManager,
   gog: GOGLibraryManager,
-  sideload: SideloadLibraryManager
+  sideload: SideloadLibraryManager,
+  steam: SteamLibraryManager
 }
 
 function getDMElement(gameInfo: GameInfo, appName: string) {
@@ -157,6 +161,7 @@ export async function sendGameUpdatesNotifications() {
 export async function initStoreManagers() {
   await LegendaryLibraryManager.initLegendaryLibraryManager()
   await GOGLibraryManager.refresh()
+  await SteamLibraryManager.refresh()
   loadEpicHyperPlayGameInfoMap()
 }
 

src/backend/storeManagers/steam/electronStores.ts

@@ -0,0 +1,13 @@
+import CacheStore from 'backend/cache'
+import { TypeCheckedStoreBackend } from 'backend/electron_store'
+import { GameInfo } from 'common/types'
+
+export const steamEnabledUsers = new TypeCheckedStoreBackend(
+  'steamEnabledUsersConfig',
+  { cwd: 'steam_store' }
+)
+
+export const libraryCache = new CacheStore<GameInfo[], 'games'>(
+  'steam_library',
+  null
+)

src/backend/storeManagers/steam/games.ts

@@ -0,0 +1,160 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { getGameInfo as getSteamLibraryGameInfo } from './library'
+import { logError, LogPrefix } from 'backend/logger/logger'
+import {
+  GameInfo,
+  GameSettings,
+  ExtraInfo,
+  InstallPlatform,
+  ExecResult,
+  InstallArgs,
+  UpdateArgs
+} from 'common/types'
+import { existsSync } from 'graceful-fs'
+import { GOGCloudSavesLocation } from 'common/types/gog'
+import { InstallResult, RemoveArgs } from 'common/types/game_manager'
+
+export function getGameInfo(appName: string): GameInfo {
+  const info = getSteamLibraryGameInfo(appName)
+  if (!info) {
+    logError(
+      [
+        'Could not get game info for',
+        `${appName},`,
+        'returning empty object. Something is probably gonna go wrong soon'
+      ],
+      LogPrefix.Gog
+    )
+    return {
+      app_name: '',
+      runner: 'steam',
+      art_cover: '',
+      art_square: '',
+      install: {},
+      is_installed: false,
+      title: '',
+      canRunOffline: false
+    }
+  }
+  return info
+}
+
+export async function isGameAvailable(appName: string): Promise<boolean> {
+  const info = getGameInfo(appName)
+  if (info && info.is_installed) {
+    if (info.install.install_path && existsSync(info.install.install_path!)) {
+      return true
+    } else {
+      return false
+    }
+  }
+  return false
+}
+
+export async function getSettings(appName: string): Promise<GameSettings> {
+  // not used
+  return {} as GameSettings
+}
+
+export async function getExtraInfo(appName: string): Promise<ExtraInfo> {
+  // not used
+  return {} as ExtraInfo
+}
+
+export async function importGame(
+  appName: string,
+  path: string,
+  platform: InstallPlatform
+): Promise<ExecResult> {
+  // not used
+  return { stderr: '', stdout: '' }
+}
+
+export function onInstallOrUpdateOutput(
+  appName: string,
+  action: 'installing' | 'updating',
+  data: string,
+  totalDownloadSize: number
+): void {
+  // not used
+}
+
+export async function install(
+  appName: string,
+  args: InstallArgs
+): Promise<InstallResult> {
+  // not used
+  return { status: 'error', error: 'Not implemented' }
+}
+
+export function isNative(appName: string): boolean {
+  // not used
+  return false
+}
+
+export async function addShortcuts(
+  appName: string,
+  fromMenu?: boolean
+): Promise<void> {
+  // not used
+}
+
+export async function removeShortcuts(appName: string): Promise<void> {
+  // not used
+}
+
+export async function launch(
+  appName: string,
+  launchArguments?: string
+): Promise<boolean> {
+  // not used
+  return false
+}
+
+export async function moveInstall(
+  appName: string,
+  newInstallPath: string
+): Promise<InstallResult> {
+  // not used
+  return { status: 'error', error: 'Not implemented' }
+}
+
+export async function repair(appName: string): Promise<ExecResult> {
+  // not used
+  return { stderr: '', stdout: '' }
+}
+
+export async function syncSaves(
+  appName: string,
+  arg: string,
+  path: string,
+  gogSaves?: GOGCloudSavesLocation[]
+): Promise<string> {
+  // not used
+  return ''
+}
+
+export async function uninstall(args: RemoveArgs): Promise<ExecResult> {
+  // not used
+  return { stderr: '', stdout: '' }
+}
+
+export async function update(
+  appName: string,
+  args?: UpdateArgs
+): Promise<InstallResult> {
+  // not used
+  return { status: 'error', error: 'Not implemented' }
+}
+
+export async function forceUninstall(appName: string): Promise<void> {
+  // not used
+}
+
+export async function stop(appName: string): Promise<void> {
+  // not used
+}
+
+export async function pause(appName: string): Promise<void> {
+  // not used
+}