auto steam path detection

Author: ershisan99

README.md

@@ -34,3 +34,20 @@ $ npm run build:linux:local
 ```
 
 Remove :local to publish to Github.
+
+## Game path detection
+
+The launcher automatically detects your Balatro installation if you haven’t set a custom path.
+
+How it works:
+- Windows: Reads the Steam install path from the registry (HKLM\SOFTWARE\WOW6432Node\Valve\Steam → InstallPath), parses steamapps/libraryfolders.vdf to enumerate libraries, then looks for steamapps/common/Balatro. Falls back to C:\Program Files (x86)\Steam if needed.
+- macOS: Looks under ~/Library/Application Support/Steam/steamapps/common/Balatro and validates the Balatro.app bundle.
+- Linux: Looks under ~/.local/share/Steam/steamapps/common/Balatro (Proton layout) and validates presence of Balatro.exe.
+
+Validation rules:
+- Windows: Directory is considered valid if any of love.dll, lua51.dll, SDL2.dll, or Balatro.exe exists.
+- macOS: Checks for Balatro.app/Contents/Resources/Balatro.love.
+- Linux: Checks for Balatro.exe in the Balatro directory.
+
+Custom path:
+- You can set a custom game directory in Settings. The path is validated before being saved. If you select the executable, the launcher will normalize it to the containing folder.

src/main/index.ts

@@ -115,9 +115,21 @@ app.whenReady().then(() => {
 
   // Settings IPC handlers
   ipcMain.handle('settings:get-game-directory', () => settingsService.getGameDirectory())
-  ipcMain.handle('settings:set-game-directory', (_, directory) => {
-    settingsService.setGameDirectory(directory)
-    return true
+  ipcMain.handle('settings:set-game-directory', async (_, directory) => {
+    try {
+      const { isBalatroInstallDirValid, normalizeCustomPath } = await import(
+        './services/balatro-path.service'
+      )
+      const normalized = normalizeCustomPath(directory)
+      if (await isBalatroInstallDirValid(normalized)) {
+        settingsService.setGameDirectory(normalized)
+        return true
+      }
+      return false
+    } catch (e) {
+      loggerService.error('Failed to validate and set game directory:', e)
+      return false
+    }
   })
   ipcMain.handle('settings:open-directory-dialog', async (event) => {
     const mainWindow = BrowserWindow.fromWebContents(event.sender)
@@ -131,17 +143,20 @@ app.whenReady().then(() => {
     return canceled ? null : filePaths[0]
   })
   ipcMain.handle('settings:get-default-game-directory', async () => {
+    try {
+      const { resolveBalatroPath } = await import('./services/balatro-path.service')
+      // Try to find an install automatically
+      const saved = settingsService.getGameDirectory()
+      const detected = await resolveBalatroPath(saved)
+      if (detected) return detected
+    } catch (e) {
+      loggerService.error('Auto-detect default game directory failed:', e)
+    }
+
+    // Fallback to simple platform defaults if they exist
     const platform = process.platform
     const defaultPath = {
-      win32: path.join(
-        os.homedir(),
-        'AppData',
-        'Roaming',
-        'Steam',
-        'steamapps',
-        'common',
-        'Balatro'
-      ),
+      win32: path.join('C:', 'Program Files (x86)', 'Steam', 'steamapps', 'common', 'Balatro'),
       darwin: path.join(
         os.homedir(),
         'Library',

src/main/services/balatro-path.service.ts

@@ -0,0 +1,149 @@
+import os from 'node:os'
+import path from 'node:path'
+import fs from 'fs-extra'
+import { promisify } from 'node:util'
+import { exec } from 'node:child_process'
+import { loggerService } from './logger.service'
+
+const execAsync = promisify(exec)
+
+async function pathExists(p: string): Promise<boolean> {
+  try {
+    return await fs.pathExists(p)
+  } catch {
+    return false
+  }
+}
+
+function dedupCaseInsensitive(items: string[]): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const s of items) {
+    const key = s.toLowerCase()
+    if (!seen.has(key)) {
+      seen.add(key)
+      out.push(s)
+    }
+  }
+  return out
+}
+
+async function readText(p: string): Promise<string | null> {
+  try {
+    if (!(await pathExists(p))) return null
+    return await fs.readFile(p, 'utf8')
+  } catch {
+    return null
+  }
+}
+
+function parseLibraryFoldersVdfToPaths(vdfContents: string): string[] {
+  const paths: string[] = []
+  const re = /"path"\s*"([^"]+)"/g
+  let m: RegExpExecArray | null
+  while ((m = re.exec(vdfContents))) {
+    paths.push(m[1])
+  }
+  return paths
+}
+
+async function getSteamInstallPathWindows(): Promise<string | null> {
+  try {
+    const { stdout } = await execAsync(
+      'reg query "HKLM\\SOFTWARE\\WOW6432Node\\Valve\\Steam" /v InstallPath'
+    )
+    // Output typically contains a line like: InstallPath    REG_SZ    C:\\Program Files (x86)\\Steam
+    const line = stdout
+      .split(/\r?\n/)
+      .map((l) => l.trim())
+      .find((l) => l.toLowerCase().startsWith('installpath'))
+    if (line) {
+      const parts = line.split(/\s{2,}/)
+      const value = parts[parts.length - 1]
+      if (value) return value
+    }
+  } catch (e) {
+    // ignore, will fallback
+    loggerService.debug?.('Windows registry query for Steam failed, falling back to default', e)
+  }
+  return 'C:\\Program Files (x86)\\Steam'
+}
+
+export async function getSteamLibraries(): Promise<string[]> {
+  const platform = os.platform()
+
+  if (platform === 'win32') {
+    const installPath = await getSteamInstallPathWindows()
+    if (!installPath) return []
+
+    const libraryVdf = path.join(installPath, 'steamapps', 'libraryfolders.vdf')
+    const contents = await readText(libraryVdf)
+    if (!contents) return dedupCaseInsensitive([installPath])
+
+    const libs = parseLibraryFoldersVdfToPaths(contents)
+    return dedupCaseInsensitive([installPath, ...libs])
+  }
+
+  if (platform === 'darwin') {
+    return [path.join(os.homedir(), 'Library', 'Application Support', 'Steam')]
+  }
+
+  // linux
+  return [path.join(os.homedir(), '.local', 'share', 'Steam')]
+}
+
+export async function getBalatroCandidates(): Promise<string[]> {
+  const libs = await getSteamLibraries()
+  const candidates = libs.map((lib) => path.join(lib, 'steamapps', 'common', 'Balatro'))
+  const existing: string[] = []
+  for (const c of candidates) {
+    if (await pathExists(c)) existing.push(c)
+  }
+  return existing
+}
+
+export async function isBalatroInstallDirValid(dir: string): Promise<boolean> {
+  const platform = os.platform()
+
+  if (platform === 'win32') {
+    const dlls = ['love.dll', 'lua51.dll', 'SDL2.dll']
+    for (const dll of dlls) {
+      if (await pathExists(path.join(dir, dll))) return true
+    }
+    if (await pathExists(path.join(dir, 'Balatro.exe'))) return true
+    return false
+  }
+
+  if (platform === 'darwin') {
+    return await pathExists(
+      path.join(dir, 'Balatro.app', 'Contents', 'Resources', 'Balatro.love')
+    )
+  }
+
+  // linux (Proton layout)
+  return await pathExists(path.join(dir, 'Balatro.exe'))
+}
+
+export async function resolveBalatroPath(savedPath?: string | null): Promise<string | null> {
+  // 1) Use saved path first if valid
+  if (savedPath && (await isBalatroInstallDirValid(savedPath))) return savedPath
+
+  // 2) Discover candidates
+  const candidates = await getBalatroCandidates()
+  for (const c of candidates) {
+    if (await isBalatroInstallDirValid(c)) {
+      return c
+    }
+  }
+
+  return null
+}
+
+export function normalizeCustomPath(userSelectedPath: string): string {
+  // If a file like an exe is provided, normalize to its directory
+  const lower = userSelectedPath.toLowerCase()
+  if (lower.endsWith('.exe')) {
+    return path.dirname(userSelectedPath)
+  }
+  return userSelectedPath
+}

src/main/services/mod-installation.service.ts

@@ -58,14 +58,26 @@ async function getGameDirectory() {
     return customDir
   }
 
-  // If no custom directory is set, check if the default Steam path exists
+  // Attempt automatic detection via Steam libraries
+  try {
+    const { resolveBalatroPath } = await import('./balatro-path.service')
+    const detected = await resolveBalatroPath(null)
+    if (detected) {
+      // Persist for future runs
+      settingsService.setGameDirectory(detected)
+      return detected
+    }
+  } catch (e) {
+    loggerService.error('Automatic game path detection failed:', e)
+  }
+
+  // Legacy fallback: check a common default Steam path for this platform
   const defaultPath = STEAM_GAME_DIR[platform]
   if (defaultPath && (await fs.pathExists(defaultPath))) {
     return defaultPath
   }
 
-  // If not found, we could implement more sophisticated detection in the future
-  // For now, return null to indicate that the game directory couldn't be determined
+  // Not found
   return null
 }
 

src/renderer/src/components/onboarding-page.tsx

@@ -1,4 +1,4 @@
-import { useState, useEffect } from 'react'
+import { useState, useEffect, useRef } from 'react'
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
 import { gameDirectoryQueryOptions, defaultGameDirectoryQueryOptions } from '@renderer/queries'
 import { settingsService } from '@renderer/servicies/settings.service'
@@ -11,9 +11,13 @@ export function OnboardingPage() {
   const queryClient = useQueryClient()
   const { data: gameDirectory, isLoading: isLoadingGameDirectory } =
     useQuery(gameDirectoryQueryOptions)
-  const { data: defaultGameDirectory } = useQuery(defaultGameDirectoryQueryOptions)
+  const { data: defaultGameDirectory, isLoading: isLoadingDefault } = useQuery(
+    defaultGameDirectoryQueryOptions
+  )
 
   const [customDirectory, setCustomDirectory] = useState<string>('')
+  const [isAutoDetecting, setIsAutoDetecting] = useState<boolean>(false)
+  const autoTriedRef = useRef(false)
 
   // Initialize the custom directory input when data is loaded
   useEffect(() => {
@@ -43,6 +47,34 @@ export function OnboardingPage() {
     }
   })
 
+  // Auto-detect on first load: if we don't already have a saved directory but a default
+  // (auto-detected) directory is available, save it automatically and finish onboarding.
+  useEffect(() => {
+    if (autoTriedRef.current) return
+    if (isLoadingGameDirectory || isLoadingDefault) return
+    if (gameDirectory) return
+
+    if (defaultGameDirectory) {
+      autoTriedRef.current = true
+      setIsAutoDetecting(true)
+      settingsService
+        .setGameDirectory(defaultGameDirectory)
+        .then(async (success) => {
+          if (success) {
+            await settingsService.setOnboardingCompleted(true)
+            queryClient.invalidateQueries({ queryKey: ['game-directory'] })
+            queryClient.invalidateQueries({ queryKey: ['onboarding-completed'] })
+            toast.success('Detected your Balatro installation and finished onboarding')
+          }
+        })
+        .catch((error) => {
+          // Just log a toast; UI remains for manual selection
+          toast.error(`Failed to apply detected directory automatically: ${error}`)
+        })
+        .finally(() => setIsAutoDetecting(false))
+    }
+  }, [gameDirectory, defaultGameDirectory, isLoadingGameDirectory, isLoadingDefault, queryClient])
+
   const handleSave = () => {
     if (customDirectory) {
       updateGameDirectoryMutation.mutate(customDirectory)
@@ -70,6 +102,8 @@ export function OnboardingPage() {
     }
   }
 
+  const isBusy = isAutoDetecting || updateGameDirectoryMutation.isPending
+
   return (
     <div className="flex flex-col">
       <div className="flex-1 flex items-center justify-center p-4">
@@ -79,7 +113,9 @@ export function OnboardingPage() {
               Welcome to Balatro Multiplayer Launcher!
             </h1>
             <p className="text-muted-foreground mt-2">
-              To get started, please set your Balatro game directory.
+              {isAutoDetecting
+                ? 'Detecting your Balatro installation...'
+                : 'To get started, please set your Balatro game directory.'}
             </p>
           </div>
 
@@ -95,18 +131,20 @@ export function OnboardingPage() {
                   className="flex-1"
                   readOnly
                 />
-                <Button
-                  type="button"
-                  onClick={handleBrowse}
-                  variant="outline"
-                >
+                <Button type="button" onClick={handleBrowse} variant="outline" disabled={isBusy}>
                   Browse
                 </Button>
               </div>
             </div>
 
             {defaultGameDirectory && (
-              <Button variant="outline" size="sm" onClick={handleUseDefault} className="w-full">
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={handleUseDefault}
+                className="w-full"
+                disabled={isBusy}
+              >
                 Use Default Steam Path
               </Button>
             )}
@@ -117,12 +155,12 @@ export function OnboardingPage() {
                 : 'Default Steam path not detected'}
             </p>
 
-            <Button
-              className="w-full mt-4"
-              onClick={handleSave}
-              disabled={updateGameDirectoryMutation.isPending}
-            >
-              {updateGameDirectoryMutation.isPending ? 'Saving...' : 'Continue'}
+            <Button className="w-full mt-4" onClick={handleSave} disabled={isBusy}>
+              {updateGameDirectoryMutation.isPending
+                ? 'Saving...'
+                : isAutoDetecting
+                  ? 'Detecting...'
+                  : 'Continue'}
             </Button>
           </div>
         </div>