`e03a3fe`

launcher: standalone mode, batch coordination, Steam library setup

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 months ago

SHA: e03a3fe93ce62d72f1ed6598cb8798760a11a044
Parents: 02ba0b5
Tree: 7015b78

1 changed file

Status	File	+	-
M	`crates/wanda-core/src/launcher.rs`	684	89

crates/wanda-core/src/launcher.rsmodified

  //!
  //! Key insight: WeMod and the game MUST run in the same Wine prefix
  //! for WeMod to be able to hook into the game process. We achieve this by
--//! running both from wanda's prefix (which has .NET and WeMod installed).
++//! running both in a single Proton session using a batch file coordinator.
  use crate::error::{Result, WandaError};
  use crate::prefix::WandaPrefix;
  use crate::steam::{ProtonVersion, SteamApp, SteamInstallation};
  use std::collections::HashMap;
++use std::fs::OpenOptions;
++use std::io::Write;
  use std::path::PathBuf;
  use std::process::Stdio;
  use std::time::Duration;
  use tokio::process::{Child, Command};
--use tracing::info;
++use tracing::{debug, info};
++
++/// Get the log file path
++fn log_file_path() -> PathBuf {
++    dirs::data_local_dir()
++        .unwrap_or_else(|| PathBuf::from("."))
++        .join("wanda")
++        .join("wanda.log")
++}
++
++/// Log a message to file
++fn log_to_file(msg: &str) {
++    let log_path = log_file_path();
++    if let Some(parent) = log_path.parent() {
++        let _ = std::fs::create_dir_all(parent);
++    }
++    if let Ok(mut file) = OpenOptions::new()
++        .create(true)
++        .append(true)
++        .open(&log_path)
++    {
++        let timestamp = std::time::SystemTime::now()
++            .duration_since(std::time::UNIX_EPOCH)
++            .map(|d| d.as_secs())
++            .unwrap_or(0);
++        let _ = writeln!(file, "[{}] {}", timestamp, msg);
++    }
++}
  /// Configuration for launching a game
  #[derive(Debug, Clone)]
      pub extra_env: HashMap<String, String>,
      /// Delay between starting WeMod and the game (in seconds)
      pub wemod_delay: u64,
++    /// Standalone mode: launch WeMod only, user starts game from WeMod UI
++    pub standalone: bool,
+ }
  impl Default for LaunchConfig {
              extra_args: Vec::new(),
              extra_env: HashMap::new(),
              wemod_delay: 3,
++            standalone: false,
+         }
+     }
+ }
  /// Handle to a launched game session
  pub struct LaunchHandle {
--    /// WeMod process (if launched with WeMod)
++    /// The main process (proton running the batch file)
--    wemod_process: Option<Child>,
++    process: Option<Child>,
      /// Game App ID
      pub app_id: u32,
      /// Start time
  impl LaunchHandle {
      /// Check if the session is still running
      pub fn is_running(&mut self) -> bool {
--        if let Some(ref mut wemod) = self.wemod_process {
++        if let Some(ref mut proc) = self.process {
--            match wemod.try_wait() {
++            match proc.try_wait() {
                  Ok(Some(_)) => return false,
                  Ok(None) => return true,
                  Err(_) => return false,
      /// Terminate the session
      pub async fn terminate(&mut self) -> Result<()> {
--        if let Some(ref mut wemod) = self.wemod_process {
++        if let Some(ref mut proc) = self.process {
--            let _ = wemod.kill().await;
++            let _ = proc.kill().await;
+         }
          Ok(())
+     }
--    /// Wait for WeMod to exit
++    /// Wait for the session to exit
      pub async fn wait(&mut self) -> Result<()> {
--        if let Some(ref mut wemod) = self.wemod_process {
++        if let Some(ref mut proc) = self.process {
--            let _ = wemod.wait().await;
++            let _ = proc.wait().await;
+         }
          Ok(())
+     }
+     }
      /// Build environment variables for launching
--    fn build_env(&self) -> HashMap<String, String> {
++    fn build_env(&self, app_id: Option<u32>) -> HashMap<String, String> {
          let mut env = HashMap::new();
--        env.insert(
++        // Primary Proton/Wine environment
--            "WINEPREFIX".to_string(),
--            self.prefix.pfx_path().to_string_lossy().to_string(),
--        );
          env.insert(
              "STEAM_COMPAT_DATA_PATH".to_string(),
              self.prefix.path.to_string_lossy().to_string(),
              "STEAM_COMPAT_CLIENT_INSTALL_PATH".to_string(),
              self.steam.root_path.to_string_lossy().to_string(),
          );
++
++        // Add Steam app ID for proper Steam API initialization
++        if let Some(id) = app_id {
++            env.insert("SteamAppId".to_string(), id.to_string());
++            env.insert("SteamGameId".to_string(), id.to_string());
++            env.insert("STEAM_COMPAT_APP_ID".to_string(), id.to_string());
++        }
++
++        // Pass display variables for GUI apps (Wayland/X11)
++        if let Ok(disp) = std::env::var("DISPLAY") {
++            debug!("Passing DISPLAY={}", disp);
++            env.insert("DISPLAY".to_string(), disp);
++        }
++        if let Ok(wayland) = std::env::var("WAYLAND_DISPLAY") {
++            debug!("Passing WAYLAND_DISPLAY={}", wayland);
++            env.insert("WAYLAND_DISPLAY".to_string(), wayland);
++        }
++        if let Ok(xdg) = std::env::var("XDG_RUNTIME_DIR") {
++            debug!("Passing XDG_RUNTIME_DIR={}", xdg);
++            env.insert("XDG_RUNTIME_DIR".to_string(), xdg);
++        }
++        // Pass XAUTHORITY for X11 authentication
++        if let Ok(xauth) = std::env::var("XAUTHORITY") {
++            debug!("Passing XAUTHORITY={}", xauth);
++            env.insert("XAUTHORITY".to_string(), xauth);
++        }
++        // Disable NTSync to avoid "Maximum number of clients reached" errors
++        env.insert("WINEESYNC".to_string(), "0".to_string());
++        env.insert("WINEFSYNC".to_string(), "0".to_string());
          env.insert("PROTON_NO_ESYNC".to_string(), "1".to_string());
          env.insert("PROTON_NO_FSYNC".to_string(), "1".to_string());
--        env.insert("WINEDEBUG".to_string(), "-all".to_string());
++
++        // Proton library paths for proper dependency resolution
++        let proton_lib64 = self.proton.path.join("files/lib64");
++        let proton_lib = self.proton.path.join("files/lib");
++        if proton_lib64.exists() || proton_lib.exists() {
++            let mut ld_path = String::new();
++            if proton_lib64.exists() {
++                ld_path.push_str(&proton_lib64.to_string_lossy());
++            }
++            if proton_lib.exists() {
++                if !ld_path.is_empty() {
++                    ld_path.push(':');
++                }
++                ld_path.push_str(&proton_lib.to_string_lossy());
++            }
++            if let Ok(existing) = std::env::var("LD_LIBRARY_PATH") {
++                ld_path.push(':');
++                ld_path.push_str(&existing);
++            }
++            env.insert("LD_LIBRARY_PATH".to_string(), ld_path);
++        }
          env
+     }
--    /// Get the Wine executable path
++    /// Convert a Linux path to a Wine path (Z: drive)
--    fn wine_exe(&self) -> PathBuf {
++    /// Uses forward slashes which Wine accepts and avoids bash escaping issues
--        let proton_wine = self.proton.wine_exe();
++    fn to_wine_path(path: &std::path::Path) -> String {
--        if proton_wine.exists() {
++        format!("Z:{}", path.to_string_lossy())
--            proton_wine
++    }
--        } else {
++
--            PathBuf::from("wine")
++    /// Convert a game executable's Linux path to the corresponding C: drive
++    /// path through the Steam library symlink inside the prefix.
++    ///
++    /// WeMod detects game processes by matching `QueryFullProcessImageName`
++    /// against the game's expected install directory. If we launch the game
++    /// via its `Z:\...` Linux path, the imagePath won't match WeMod's
++    /// `C:\Program Files (x86)\Steam\steamapps\common\...` expectation.
++    /// Launching through the symlinked C: path makes the paths match.
++    fn to_prefix_game_path(game: &SteamApp, game_exe: &std::path::Path) -> Option<String> {
++        let common_dir = game.library_path.join("steamapps/common");
++        let rel_path = game_exe.strip_prefix(&common_dir).ok()?;
++        Some(format!(
++            "C:\\Program Files (x86)\\Steam\\steamapps\\common\\{}",
++            rel_path.to_string_lossy().replace('/', "\\")
++        ))
++    }
++
++    /// Create a batch file that coordinates WeMod and game startup
++    fn create_launch_batch(
++        &self,
++        wemod_exe: &std::path::Path,
++        game: &SteamApp,
++        game_exe: &std::path::Path,
++        game_args: &[String],
++        delay_seconds: u64,
++    ) -> Result<PathBuf> {
++        let batch_path = self.prefix.path.join("wanda_launch.bat");
++
++        // For batch file internal paths, use backslashes (Windows convention)
++        let wemod_win_path = format!("Z:{}", wemod_exe.to_string_lossy().replace('/', "\\"));
++        // Use C: drive path through the Steam library symlink so that
++        // QueryFullProcessImageName returns a path WeMod recognizes
++        let game_win_path = Self::to_prefix_game_path(game, game_exe)
++            .unwrap_or_else(|| format!("Z:{}", game_exe.to_string_lossy().replace('/', "\\")));
++        let game_args_str = game_args.join(" ");
++
++        // Create batch file content
++        // Uses Windows batch syntax to:
++        // 1. Start WeMod in the background
++        // 2. Wait for WeMod to initialize (using ping for delay)
++        // 3. Start the game and wait for it to exit
++        // 4. Kill WeMod when game exits
++        let batch_content = format!(
++r#"@echo off
++@title WANDA Launcher
++
++echo WANDA Launcher starting...
++echo.
++
++REM WeMod executable path
++SET wemodpath={wemod_path}
++SET wemodname=WeMod.exe
++
++echo Starting WeMod: %wemodpath%
++start "" "%wemodpath%" --no-sandbox
++
++echo Waiting {delay} seconds for WeMod to initialize...
++ping localhost -n {ping_count} > NUL 2>&1
++
++echo.
++echo Starting game: {game_path}
++echo Arguments: {game_args}
++echo.
++
++REM Start the game and wait for it to exit
++start /wait "" "{game_path}" {game_args}
++
++echo.
++echo Game exited, closing WeMod...
++
++REM Find and kill WeMod process
++for /F "TOKENS=1,2,*" %%a in ('C:/windows/system32/tasklist /FI "IMAGENAME eq %wemodname%"') do (
++    set wemodPID=%%b
++)
++if defined wemodPID (
++    C:/windows/system32/taskkill.exe /PID %wemodPID% /F 2>NUL
++    echo Closed WeMod
++)
++
++echo.
++echo WANDA Launcher finished
++"#,
++            wemod_path = wemod_win_path,
++            delay = delay_seconds,
++            ping_count = delay_seconds + 1, // ping -n N waits N-1 seconds
++            game_path = game_win_path,
++            game_args = game_args_str,
++        );
++
++        // Windows cmd.exe requires CRLF line endings
++        let batch_content = batch_content.replace('\n', "\r\n");
++        std::fs::write(&batch_path, batch_content).map_err(|e| WandaError::LaunchFailed {
++            reason: format!("Failed to create launch batch file: {}", e),
++        })?;
++
++        log_to_file(&format!("Created batch file at: {}", batch_path.display()));
++        debug!("Created batch file at: {}", batch_path.display());
++
++        Ok(batch_path)
++    }
++
++    /// Create a batch file for standalone mode (WeMod only, no game)
++    ///
++    /// Launches WeMod via the Squirrel stub (identical to normal mode) then
++    /// keeps cmd.exe alive with an infinite ping loop so Wine doesn't tear
++    /// down the session. The user closes WeMod from its UI and Ctrl+C's the
++    /// terminal to end the Proton session.
++    fn create_standalone_batch(&self, wemod_exe: &std::path::Path) -> Result<PathBuf> {
++        let batch_path = self.prefix.path.join("wanda_standalone.bat");
++        let wemod_win_path = format!("Z:{}", wemod_exe.to_string_lossy().replace('/', "\\"));
++
++        let batch_content = format!(
++r#"@echo off
++@title WANDA Standalone Launcher
++
++echo WANDA Standalone Launcher starting...
++echo.
++
++SET wemodpath={wemod_path}
++
++echo Starting WeMod: %wemodpath%
++start "" "%wemodpath%" --no-sandbox
++
++echo Waiting for WeMod to initialize...
++ping localhost -n 6 > NUL 2>&1
++
++echo.
++echo WeMod is running in standalone mode.
++echo Launch your game from the WeMod UI.
++echo.
++
++:wait
++ping localhost -n 30 > NUL 2>&1
++goto wait
++"#,
++            wemod_path = wemod_win_path,
++        );
++
++        // Windows cmd.exe requires CRLF line endings
++        let batch_content = batch_content.replace('\n', "\r\n");
++        std::fs::write(&batch_path, batch_content).map_err(|e| WandaError::LaunchFailed {
++            reason: format!("Failed to create standalone batch file: {}", e),
++        })?;
++
++        log_to_file(&format!("Created standalone batch at: {}", batch_path.display()));
++        debug!("Created standalone batch at: {}", batch_path.display());
++
++        Ok(batch_path)
++    }
++
++    /// Set up Steam library structure inside the prefix so WeMod can find games
++    ///
++    /// WeMod locates games via the Windows registry path
++    /// `C:\Program Files (x86)\Steam` -> `steamapps\common\{game}\`. We create
++    /// symlinks from the prefix into the real Steam library so WeMod sees the
++    /// game without copying any files.
++    fn setup_steam_library(&self, game: &SteamApp) -> Result<()> {
++        let steamapps_dir = self.prefix.path
++            .join("pfx/drive_c/Program Files (x86)/Steam/steamapps");
++
++        // Create the steamapps directory structure
++        std::fs::create_dir_all(&steamapps_dir).map_err(|e| WandaError::LaunchFailed {
++            reason: format!("Failed to create Steam library structure in prefix: {}", e),
++        })?;
++
++        // Symlink common/ directory
++        let common_link = steamapps_dir.join("common");
++        let common_target = game.library_path.join("steamapps/common");
++        if !common_link.exists() {
++            info!("Symlinking Steam common: {} -> {}", common_link.display(), common_target.display());
++            log_to_file(&format!("Symlinking common: {} -> {}", common_link.display(), common_target.display()));
++            std::os::unix::fs::symlink(&common_target, &common_link).map_err(|e| {
++                WandaError::LaunchFailed {
++                    reason: format!(
++                        "Failed to symlink Steam common directory: {} -> {}: {}",
++                        common_link.display(), common_target.display(), e
++                    ),
++                }
++            })?;
++        }
++
++        // Symlink the game's appmanifest
++        let manifest_name = format!("appmanifest_{}.acf", game.app_id);
++        let manifest_link = steamapps_dir.join(&manifest_name);
++        let manifest_target = game.library_path.join("steamapps").join(&manifest_name);
++        if !manifest_link.exists() && manifest_target.exists() {
++            info!("Symlinking appmanifest: {} -> {}", manifest_link.display(), manifest_target.display());
++            log_to_file(&format!("Symlinking appmanifest: {} -> {}", manifest_link.display(), manifest_target.display()));
++            std::os::unix::fs::symlink(&manifest_target, &manifest_link).map_err(|e| {
++                WandaError::LaunchFailed {
++                    reason: format!(
++                        "Failed to symlink appmanifest: {} -> {}: {}",
++                        manifest_link.display(), manifest_target.display(), e
++                    ),
++                }
++            })?;
++        }
++
++        // Create libraryfolders.vdf so WeMod can discover the game library
++        let vdf_path = steamapps_dir.join("libraryfolders.vdf");
++        let vdf_content = format!(
++            r#""libraryfolders"
++{{
++	"0"
++	{{
++		"path"		"C:\\Program Files (x86)\\Steam"
++		"apps"
++		{{
++			"{app_id}"		"0"
++		}}
++	}}
++}}"#,
++            app_id = game.app_id,
++        );
++        info!("Writing libraryfolders.vdf with app {}", game.app_id);
++        log_to_file(&format!("Writing libraryfolders.vdf for app {}", game.app_id));
++        std::fs::write(&vdf_path, &vdf_content).map_err(|e| WandaError::LaunchFailed {
++            reason: format!("Failed to create libraryfolders.vdf: {}", e),
++        })?;
++
++        // Add Steam registry entries so WeMod can find the fake Steam installation
++        self.setup_steam_registry(game)?;
++
++        Ok(())
++    }
++
++    /// Write Steam registry entries into the Wine prefix so WeMod can locate Steam.
++    ///
++    /// WeMod checks `HKCU\Software\Valve\Steam\SteamPath` to find the Steam
++    /// installation directory and then reads `steamapps/libraryfolders.vdf`.
++    fn setup_steam_registry(&self, game: &SteamApp) -> Result<()> {
++        let user_reg = self.prefix.path.join("pfx/user.reg");
++        if !user_reg.exists() {
++            debug!("user.reg not found, skipping Steam registry setup");
++            return Ok(());
++        }
++
++        let content = std::fs::read_to_string(&user_reg).map_err(|e| WandaError::LaunchFailed {
++            reason: format!("Failed to read user.reg: {}", e),
++        })?;
++
++        // Only add if Valve\Steam key doesn't already exist
++        if content.contains("[Software\\\\Valve\\\\Steam]") {
++            debug!("Steam registry entries already exist");
++            return Ok(());
++        }
++
++        let timestamp = std::time::SystemTime::now()
++            .duration_since(std::time::UNIX_EPOCH)
++            .map(|d| d.as_secs())
++            .unwrap_or(0);
++
++        let steam_entry = format!(
++            r#"
++
++[Software\\Valve\\Steam] {ts}
++"Language"="english"
++"SteamExe"="C:\\\\Program Files (x86)\\\\Steam\\\\steam.exe"
++"SteamPath"="C:\\\\Program Files (x86)\\\\Steam"
++
++[Software\\Valve\\Steam\\Apps\\{app_id}] {ts}
++"Installed"=dword:00000001
++"Name"="{game_name}"
++"Running"=dword:00000000
++"#,
++            ts = timestamp,
++            app_id = game.app_id,
++            game_name = game.name.replace('\\', "\\\\").replace('"', ""),
++        );
++
++        info!("Adding Steam registry entries for app {}", game.app_id);
++        log_to_file(&format!("Adding Steam registry entries for app {}", game.app_id));
++
++        let mut file = OpenOptions::new()
++            .append(true)
++            .open(&user_reg)
++            .map_err(|e| WandaError::LaunchFailed {
++                reason: format!("Failed to open user.reg for writing: {}", e),
++            })?;
++        file.write_all(steam_entry.as_bytes()).map_err(|e| WandaError::LaunchFailed {
++            reason: format!("Failed to write Steam registry entries: {}", e),
++        })?;
++
++        Ok(())
++    }
++
++    /// Set up a Steam launch proxy so that when WeMod clicks "Play", the game
++    /// launches directly in the same Wine session instead of going through the
++    /// native Linux Steam client (which creates a separate Proton session that
++    /// WeMod cannot hook into).
++    ///
++    /// This works by:
++    /// 1. Writing a batch file at `C:\wanda\steam_proxy.bat` that launches
++    ///    the game executable directly
++    /// 2. Overriding the `steam://` protocol handler in the Wine registry
++    ///    to point to this batch file instead of Proton's `steam.exe` stub
++    ///
++    /// When WeMod calls `steam://run/<APPID>`, Wine routes it through our
++    /// proxy, which starts the game process in WeMod's Wine session.
++    fn setup_steam_launch_proxy(
++        &self,
++        game: &SteamApp,
++        game_exe: &std::path::Path,
++    ) -> Result<()> {
++        let pfx_path = self.prefix.path.join("pfx");
++
++        // Create the proxy batch file at C:\wanda\steam_proxy.bat
++        let wanda_dir = pfx_path.join("drive_c/wanda");
++        std::fs::create_dir_all(&wanda_dir).map_err(|e| WandaError::LaunchFailed {
++            reason: format!("Failed to create wanda directory in prefix: {}", e),
++        })?;
++
++        let proxy_path = wanda_dir.join("steam_proxy.bat");
++        // Use C: drive path so QueryFullProcessImageName returns a path
++        // that matches WeMod's expected Steam library location
++        let game_win_path = Self::to_prefix_game_path(game, game_exe)
++            .unwrap_or_else(|| format!("Z:{}", game_exe.to_string_lossy().replace('/', "\\")));
++
++        let proxy_content = format!(
++            r#"@echo off
++REM Wanda Steam Protocol Proxy
++REM Intercepts steam://run requests from WeMod and launches the game
++REM directly in the same Wine session (instead of via native Steam
++REM which would create a separate Proton session).
++REM
++REM Game: {game_name} (AppID: {app_id})
++
++echo [WANDA] Steam launch intercepted: %~1
++echo [WANDA] Launching: {game_path}
++
++start "" "{game_path}"
++"#,
++            game_name = game.name,
++            app_id = game.app_id,
++            game_path = game_win_path,
++        );
++
++        std::fs::write(&proxy_path, &proxy_content).map_err(|e| WandaError::LaunchFailed {
++            reason: format!("Failed to create Steam proxy batch: {}", e),
++        })?;
++
++        info!("Created Steam launch proxy at {}", proxy_path.display());
++        log_to_file(&format!(
++            "Created Steam launch proxy for {} ({})",
++            game.name, game.app_id
++        ));
++
++        // Override the steam:// protocol handler in user.reg so Wine routes
++        // steam://run/APPID to our proxy batch instead of Proton's steam.exe.
++        // Later entries in user.reg take precedence, so we always append.
++        let user_reg = self.prefix.path.join("pfx/user.reg");
++        if !user_reg.exists() {
++            debug!("user.reg not found, skipping steam:// protocol override");
++            return Ok(());
++        }
++
++        let content = std::fs::read_to_string(&user_reg).map_err(|e| WandaError::LaunchFailed {
++            reason: format!("Failed to read user.reg: {}", e),
++        })?;
++
++        // Skip if already configured (avoid growing user.reg on repeated launches)
++        if content.contains("wanda\\\\steam_proxy.bat") {
++            debug!("Steam protocol proxy already configured in registry");
++            return Ok(());
+         }
++
++        let timestamp = std::time::SystemTime::now()
++            .duration_since(std::time::UNIX_EPOCH)
++            .map(|d| d.as_secs())
++            .unwrap_or(0);
++
++        // Wine user.reg format: \\ = literal backslash, \" = literal quote
++        let registry_override = format!(
++            concat!(
++                "\n",
++                "[Software\\\\Classes\\\\steam] {ts}\n",
++                "@=\"URL:Steam Protocol\"\n",
++                "\"URL Protocol\"=\"\"\n",
++                "\n",
++                "[Software\\\\Classes\\\\steam\\\\shell\\\\open\\\\command] {ts}\n",
++                "@=\"\\\"C:\\\\wanda\\\\steam_proxy.bat\\\" \\\"%1\\\"\"\n",
++            ),
++            ts = timestamp,
++        );
++
++        let mut file = OpenOptions::new()
++            .append(true)
++            .open(&user_reg)
++            .map_err(|e| WandaError::LaunchFailed {
++                reason: format!("Failed to open user.reg: {}", e),
++            })?;
++        file.write_all(registry_override.as_bytes())
++            .map_err(|e| WandaError::LaunchFailed {
++                reason: format!("Failed to write steam:// protocol override: {}", e),
++            })?;
++
++        info!("Overrode steam:// protocol handler to use Wanda proxy");
++        log_to_file("Overrode steam:// protocol handler → C:\\wanda\\steam_proxy.bat");
++
++        Ok(())
+     }
      /// Launch a game with WeMod
      pub async fn launch(&self, config: LaunchConfig) -> Result<LaunchHandle> {
++        log_to_file("=== WANDA LAUNCH START ===");
++
          let game = self
              .steam
              .find_game(config.app_id)
              .ok_or(WandaError::GameNotFound { app_id: config.app_id })?;
--        info!(
++        let launch_msg = format!(
              "Launching {} (AppID: {}) {}",
              game.name,
              game.app_id,
              if config.with_wemod { "with WeMod" } else { "without WeMod" }
          );
++        info!("{}", launch_msg);
++        log_to_file(&launch_msg);
          info!("Using WANDA prefix: {}", self.prefix.path.display());
++        log_to_file(&format!("WANDA prefix: {}", self.prefix.path.display()));
++        log_to_file(&format!("Proton: {} at {}", self.proton.name, self.proton.path.display()));
--        // Kill stale wineservers to avoid conflicts
++        let game_exe = self.find_game_executable(&game)?;
--        info!("Cleaning up stale wineservers...");
++        info!("Game executable: {}", game_exe.display());
--        let _ = Command::new("pkill").args(["-9", "wineserver"]).output().await;
++        log_to_file(&format!("Game executable: {}", game_exe.display()));
--        tokio::time::sleep(Duration::from_secs(1)).await;
--        let mut env = self.build_env();
++        // Always include SteamAppId — the game needs it for Steam API
--        env.insert("SteamAppId".to_string(), config.app_id.to_string());
++        // initialization. Without it, many games exit immediately.
--        env.insert("SteamGameId".to_string(), config.app_id.to_string());
++        // In standalone CLI mode this is safe since Steam tracks games
--        env.extend(config.extra_env);
++        // via reaper/launch-wrapper, not env vars.
++        let mut env = self.build_env(Some(config.app_id));
--        let wine = self.wine_exe();
++        // Set STEAM_COMPAT_INSTALL_PATH so ProtonFixes knows where the game is
--        let mut wemod_process = None;
++        env.insert(
++            "STEAM_COMPAT_INSTALL_PATH".to_string(),
++            game.install_path.to_string_lossy().to_string(),
++        );
++        debug!("Setting STEAM_COMPAT_INSTALL_PATH={}", game.install_path.display());
--        if config.with_wemod {
++        env.extend(config.extra_env);
--            let wemod_exe = self.prefix.wemod_exe();
++
--            if !wemod_exe.exists() {
++        let process = if config.with_wemod {
++            let wemod_stub = self.prefix.wemod_exe();
++            if !wemod_stub.exists() {
++                log_to_file(&format!("WeMod not found at: {}", wemod_stub.display()));
                  return Err(WandaError::WemodNotInstalled);
+             }
--            info!("Starting WeMod...");
++            // Prefer the real Electron exe (app-X.Y.Z/WeMod.exe) over the Squirrel stub.
--            info!("WeMod path: {}", wemod_exe.display());
++            // The stub exits immediately after spawning the real app, which can cause
++            // Proton to tear down the Wine session before WeMod fully starts.
++            let wemod_exe = if let Some(app_exe) = self.prefix.wemod_app_exe() {
++                info!("Using real WeMod app exe: {}", app_exe.display());
++                log_to_file(&format!("Using real WeMod app exe: {}", app_exe.display()));
++                app_exe
++            } else {
++                info!("Real WeMod app exe not found, falling back to stub: {}", wemod_stub.display());
++                log_to_file(&format!("Real WeMod app exe not found, falling back to stub: {}", wemod_stub.display()));
++                wemod_stub
++            };
--            let child = Command::new(&wine)
++            info!("WeMod path: {}", wemod_exe.display());
--                .arg(&wemod_exe)
++            log_to_file(&format!("WeMod path: {}", wemod_exe.display()));
--                .arg("--no-sandbox")
++
++            // Set up Steam library so WeMod can find the game (both modes)
++            info!("Setting up Steam library in prefix");
++            log_to_file("Setting up Steam library in prefix");
++            self.setup_steam_library(&game)?;
++
++            // Override the steam:// protocol handler so WeMod launches the game
++            // directly in this Wine session instead of through the native Steam
++            // client (which would create a separate, unhookable Proton session)
++            self.setup_steam_launch_proxy(&game, &game_exe)?;
++
++            let cmd_str = if config.standalone {
++                let batch_path = self.create_standalone_batch(&wemod_exe)?;
++                let batch_win_path = Self::to_wine_path(&batch_path);
++
++                let cmd = format!(
++                    "cd \"{}\" && \"{}\" waitforexitandrun \"{}\"",
++                    self.proton.path.display(),
++                    self.proton.proton_exe().display(),
++                    batch_win_path,
++                );
++                info!("Launching WeMod standalone via batch: {}", cmd);
++                log_to_file(&format!("Standalone launch command: {}", cmd));
++                cmd
++            } else {
++                // Normal mode: batch file coordinates WeMod + game startup
++                let batch_path = self.create_launch_batch(
++                    &wemod_exe,
++                    &game,
++                    &game_exe,
++                    &config.extra_args,
++                    config.wemod_delay,
++                )?;
++                let batch_win_path = Self::to_wine_path(&batch_path);
++
++                let cmd = format!(
++                    "cd \"{}\" && \"{}\" waitforexitandrun \"{}\"",
++                    self.proton.path.display(),
++                    self.proton.proton_exe().display(),
++                    batch_win_path,
++                );
++                info!("Launching via batch file: {}", cmd);
++                log_to_file(&format!("Launch command: {}", cmd));
++                cmd
++            };
++
++            let child = Command::new("bash")
++                .arg("-c")
++                .arg(&cmd_str)
                  .envs(&env)
                  .stdout(Stdio::inherit())
                  .stderr(Stdio::inherit())
                  .spawn()
--                .map_err(|e| WandaError::LaunchFailed {
++                .map_err(|e| {
--                    reason: format!("Failed to start WeMod: {}", e),
++                    log_to_file(&format!("Failed to launch: {}", e));
++                    WandaError::LaunchFailed {
++                        reason: format!("Failed to launch: {}", e),
++                    }
                  })?;
--            wemod_process = Some(child);
++            log_to_file("Launch process started successfully");
--
++            Some(child)
--            info!("Waiting {} seconds for WeMod to initialize...", config.wemod_delay);
++        } else {
--            tokio::time::sleep(Duration::from_secs(config.wemod_delay)).await;
++            // Launch game without WeMod using direct Proton invocation
--        }
++            let game_win_path = Self::to_wine_path(&game_exe);
++            let cmd_str = format!(
++                "cd \"{}\" && \"{}\" waitforexitandrun \"{}\" {}",
++                self.proton.path.display(),
++                self.proton.proton_exe().display(),
++                game_win_path,
++                config.extra_args.join(" ")
++            );
++
++            info!("Launching game directly: {}", cmd_str);
++            log_to_file(&format!("Launch command: {}", cmd_str));
++
++            let child = Command::new("bash")
++                .arg("-c")
++                .arg(&cmd_str)
++                .envs(&env)
++                .stdout(Stdio::inherit())
++                .stderr(Stdio::inherit())
++                .spawn()
++                .map_err(|e| {
++                    log_to_file(&format!("Failed to launch game: {}", e));
++                    WandaError::LaunchFailed {
++                        reason: format!("Failed to launch game: {}", e),
++                    }
++                })?;
--        info!("Launching game via Proton...");
++            log_to_file("Game launched successfully");
--        self.launch_game_via_proton(&game, &config.extra_args, &env).await?;
++            Some(child)
++        };
          Ok(LaunchHandle {
--            wemod_process,
++            process,
              app_id: config.app_id,
              start_time: std::time::Instant::now(),
          })
+     }
--    /// Launch game via Proton
--    async fn launch_game_via_proton(
--        &self,
--        game: &SteamApp,
--        args: &[String],
--        env: &HashMap<String, String>,
--    ) -> Result<()> {
--        let proton_exe = self.proton.proton_exe();
--        if !proton_exe.exists() {
--            return Err(WandaError::ProtonNotFound);
--        }
--
--        let game_exe = self.find_game_executable(game)?;
--        info!("Game executable: {}", game_exe.display());
--
--        let mut cmd = Command::new(&proton_exe);
--        cmd.arg("run").arg(&game_exe).args(args).envs(env);
--        cmd.stdout(Stdio::inherit()).stderr(Stdio::inherit());
--
--        info!("Running: {} run {}", proton_exe.display(), game_exe.display());
--
--        cmd.spawn().map_err(|e| WandaError::LaunchFailed {
--            reason: format!("Failed to start game: {}", e),
--        })?;
--
--        Ok(())
--    }
--
      /// Find the main executable for a game
      fn find_game_executable(&self, game: &SteamApp) -> Result<PathBuf> {
          let install_path = &game.install_path;
              return Err(WandaError::GameNotFound { app_id: game.app_id });
+         }
++        // Generate name patterns from install_dir (e.g., "ELDEN RING" -> "eldenring")
++        let normalized_name = game.install_dir.to_lowercase().replace(' ', "");
++
          let patterns = [
              format!("{}.exe", game.install_dir),
++            format!("{}.exe", normalized_name),  // eldenring.exe
              "game.exe".to_string(),
              "start.exe".to_string(),
              "launcher.exe".to_string(),
          ];
++        // Check in root and Game/ subdirectory (common structure)
++        let search_dirs = [
++            install_path.clone(),
++            install_path.join("Game"),
++            install_path.join("game"),
++            install_path.join("Bin"),
++            install_path.join("bin"),
++        ];
++
          for pattern in &patterns {
--            let exe_path = install_path.join(pattern);
++            for dir in &search_dirs {
--            if exe_path.exists() {
++                let exe_path = dir.join(pattern);
--                return Ok(exe_path);
++                if exe_path.exists() {
++                    return Ok(exe_path);
++                }
++            }
++        }
++
++        // Exclusion list for anti-cheat, launchers, and utilities
++        let exclusions = [
++            "unins", "redist", "setup", "crash", "report",
++            "start_protected", "easyanticheat", "battleye", "eac_",
++            "dxsetup", "vcredist", "dotnet", "directx",
++            "ue4prereq", "installer", "updater",
++        ];
++
++        // Walk directory looking for game executables
++        for entry in walkdir::WalkDir::new(install_path)
++            .max_depth(3)
++            .into_iter()
++            .flatten()
++        {
++            let path = entry.path();
++            if let Some(ext) = path.extension() {
++                if ext == "exe" {
++                    let name = path.file_name().unwrap_or_default().to_string_lossy();
++                    let name_lower = name.to_lowercase();
++
++                    // Skip excluded executables
++                    if exclusions.iter().any(|ex| name_lower.contains(ex)) {
++                        continue;
++                    }
++
++                    // Prefer executables that match the game name
++                    if name_lower.contains(&normalized_name) {
++                        return Ok(path.to_path_buf());
++                    }
++                }
+             }
+         }
++        // Fallback: return first non-excluded exe found
          for entry in walkdir::WalkDir::new(install_path)
--            .max_depth(2)
++            .max_depth(3)
              .into_iter()
              .flatten()
+         {
              if let Some(ext) = path.extension() {
                  if ext == "exe" {
                      let name = path.file_name().unwrap_or_default().to_string_lossy();
--                    if !name.to_lowercase().contains("unins")
++                    let name_lower = name.to_lowercase();
--                        && !name.to_lowercase().contains("redist")
++
--                        && !name.to_lowercase().contains("setup")
++                    if !exclusions.iter().any(|ex| name_lower.contains(ex)) {
--                    {
                          return Ok(path.to_path_buf());
+                     }
+                 }