zeroed-some/wanda / 02ba0b5

+use futures::StreamExt;

+use std::time::Duration;

+use tokio::time::timeout;

+/// Microsoft .NET Framework 4.8 offline installer (stable URL)

+const DOTNET48_URL: &str = "https://download.visualstudio.microsoft.com/download/pr/2d6bb6b2-226a-4baa-bdec-798822606ff1/8494001c276a4b96804cde7829c04d7f/ndp48-x86-x64-allos-enu.exe";

+const DOTNET48_FILENAME: &str = "ndp48-x86-x64-allos-enu.exe";

+/// Timeout for the .NET installer (5 minutes)

+const DOTNET_INSTALL_TIMEOUT: Duration = Duration::from_secs(300);

+

+        // Tell winetricks which wineserver to use (must match wine version)

+        let wineserver_path = self.proton.path.join("files/bin/wineserver");

+        if wineserver_path.exists() {

+            debug!("Using Proton wineserver: {}", wineserver_path.display());

+            env.insert("WINESERVER".to_string(), wineserver_path.to_string_lossy().to_string());

+        }

+

+        // Pass display variables for GUI installers (required for .NET, vcrun, etc.)

+        if let Ok(disp) = std::env::var("DISPLAY") {

+            info!("Captured DISPLAY={}", disp);

+            env.insert("DISPLAY".to_string(), disp);

+        } else {

+            warn!("DISPLAY not set in environment!");

+        }

+        if let Ok(wayland_disp) = std::env::var("WAYLAND_DISPLAY") {

+            info!("Captured WAYLAND_DISPLAY={}", wayland_disp);

+            env.insert("WAYLAND_DISPLAY".to_string(), wayland_disp);

+        }

+        if let Ok(xdg_dir) = std::env::var("XDG_RUNTIME_DIR") {

+            info!("Captured XDG_RUNTIME_DIR={}", xdg_dir);

+            env.insert("XDG_RUNTIME_DIR".to_string(), xdg_dir);

+        }

+

+        // Patch mscorlib.dll version so WeMod's .NET check passes.

+        // WeMod reads the PE FileVersion from mscorlib.dll and requires >= 4.7.2556.0.

+        // Wine Mono ships 4.0.30319.1 which fails the check. We patch the version

+        // resource to report 4.8.9232.0 (.NET 4.8) — Wine Mono's runtime still works

+        // fine, this is purely metadata in the PE resource section.

+        self.patch_mscorlib_version()?;

+    /// Initialize the prefix with wineboot via Proton's script

+    ///

+    /// We must run through `./proton run wineboot` rather than calling wine64

+    /// directly so that Proton sets up its own prefix layout: steam.exe stubs,

+    /// DLL symlinks into the Proton distribution, lsteamclient, etc. Without

+    /// this, `proton waitforexitandrun` fails with STATUS_DLL_NOT_FOUND

+    /// (c0000135) because the symlinks point nowhere.

+        info!("Initializing Wine prefix via Proton script...");

+        let proton_script = self.proton.path.join("proton");

+        let env = self.build_proton_env();

+        info!(

+            "Running: ./proton run wineboot --init (from {})",

+            self.proton.path.display()

+        );

+        let output = Command::new(&proton_script)

+            .arg("run")

+            .current_dir(&self.proton.path)

+                path: self.base_path.clone(),

+                reason: format!("Proton wineboot failed to start: {}", e),

+            error!("proton wineboot stdout: {}", stdout);

+            error!("proton wineboot stderr: {}", stderr);

+                path: self.base_path.clone(),

+                reason: format!(

+                    "Proton wineboot failed with exit code: {:?}",

+                    output.status.code()

+                ),

+        debug!("Proton wineboot completed successfully");

+    /// Build environment for running through the Proton script.

+    ///

+    /// Proton uses STEAM_COMPAT_DATA_PATH (not WINEPREFIX) and creates

+    /// the actual Wine prefix at `$STEAM_COMPAT_DATA_PATH/pfx/`.

+    fn build_proton_env(&self) -> HashMap<String, String> {

+        let mut env = HashMap::new();

+

+        // Proton manages WINEPREFIX internally from this path

+        env.insert(

+            "STEAM_COMPAT_DATA_PATH".to_string(),

+            self.base_path.to_string_lossy().to_string(),

+        );

+

+        // Try to find Steam root from Proton's location for Steam integration

+        if let Some(steam_root) = self.find_steam_root() {

+            debug!("Derived Steam root: {}", steam_root.display());

+            env.insert(

+                "STEAM_COMPAT_CLIENT_INSTALL_PATH".to_string(),

+                steam_root.to_string_lossy().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());

+

+        // Display variables for GUI initialization

+        if let Ok(disp) = std::env::var("DISPLAY") {

+            env.insert("DISPLAY".to_string(), disp);

+        }

+        if let Ok(wayland) = std::env::var("WAYLAND_DISPLAY") {

+            env.insert("WAYLAND_DISPLAY".to_string(), wayland);

+        }

+        if let Ok(xdg) = std::env::var("XDG_RUNTIME_DIR") {

+            env.insert("XDG_RUNTIME_DIR".to_string(), xdg);

+        }

+

+        env

+    }

+

+    /// Walk up from Proton's path to find the Steam root directory.

+    ///

+    /// Proton lives under either:

+    ///   `<steam>/compatibilitytools.d/<version>/`  (GE-Proton, custom)

+    ///   `<steam>/steamapps/common/<version>/`      (official Proton)

+    fn find_steam_root(&self) -> Option<PathBuf> {

+        let mut current = self.proton.path.as_path();

+        for _ in 0..5 {

+            current = current.parent()?;

+            // Steam root has steam.sh (native) or ubuntu12_32 (runtime)

+            if current.join("steam.sh").exists()

+                || current.join("ubuntu12_32").exists()

+                || current.join("steamapps").exists()

+            {

+                return Some(current.to_path_buf());

+            }

+        }

+        None

+    }

+

+    /// Patch mscorlib.dll PE version info so WeMod's .NET check passes.

+    ///

+    /// WeMod parses the VS_FIXEDFILEINFO from mscorlib.dll and requires

+    /// FileVersion >= 4.7.2556.0. Wine Mono ships 4.0.30319.1 which fails.

+    /// We patch dwFileVersionMS/LS and dwProductVersionMS/LS to report

+    /// 4.8.9232.0 (.NET Framework 4.8). This is safe because the version

+    /// resource is metadata only — Wine Mono's actual runtime is unaffected.

+    pub fn patch_mscorlib_version(&self) -> Result<()> {

+        // .NET 4.8 version: 4.8.9232.0

+        let new_file_version_ms: u32 = (4 << 16) | 8;      // major=4, minor=8

+        let new_file_version_ls: u32 = (9232 << 16) | 0;    // build=9232, revision=0

+

+        let paths = [

+            self.prefix_path.join("drive_c/windows/Microsoft.NET/Framework64/v4.0.30319/mscorlib.dll"),

+            self.prefix_path.join("drive_c/windows/Microsoft.NET/Framework/v4.0.30319/mscorlib.dll"),

+        ];

+

+        let signature: [u8; 4] = 0xFEEF04BDu32.to_le_bytes();

+

+        for path in &paths {

+            if !path.exists() {

+                debug!("mscorlib.dll not found at {}, skipping", path.display());

+                continue;

+            }

+

+            let mut data = std::fs::read(path).map_err(|e| WandaError::PrefixCreationFailed {

+                path: path.clone(),

+                reason: format!("Failed to read mscorlib.dll: {}", e),

+            })?;

+

+            // Find VS_FIXEDFILEINFO signature

+            let pos = data

+                .windows(4)

+                .position(|w| w == signature);

+

+            let pos = match pos {

+                Some(p) => p,

+                None => {

+                    warn!("VS_FIXEDFILEINFO signature not found in {}", path.display());

+                    continue;

+                }

+            };

+

+            // Verify we have enough bytes after the signature

+            // Layout: signature(4) + struc_version(4) + file_ver_ms(4) + file_ver_ls(4)

+            //       + product_ver_ms(4) + product_ver_ls(4)

+            if pos + 24 > data.len() {

+                warn!("VS_FIXEDFILEINFO too close to end of file in {}", path.display());

+                continue;

+            }

+

+            // Read current version for logging

+            let old_ms = u32::from_le_bytes(data[pos + 8..pos + 12].try_into().unwrap());

+            let old_ls = u32::from_le_bytes(data[pos + 12..pos + 16].try_into().unwrap());

+            info!(

+                "Patching {} version {}.{}.{}.{} -> 4.8.9232.0",

+                path.display(),

+                old_ms >> 16, old_ms & 0xFFFF,

+                old_ls >> 16, old_ls & 0xFFFF,

+            );

+

+            // Patch FileVersion (offset +8, +12 from signature)

+            data[pos + 8..pos + 12].copy_from_slice(&new_file_version_ms.to_le_bytes());

+            data[pos + 12..pos + 16].copy_from_slice(&new_file_version_ls.to_le_bytes());

+

+            // Patch ProductVersion (offset +16, +20 from signature)

+            data[pos + 16..pos + 20].copy_from_slice(&new_file_version_ms.to_le_bytes());

+            data[pos + 20..pos + 24].copy_from_slice(&new_file_version_ls.to_le_bytes());

+

+            std::fs::write(path, &data).map_err(|e| WandaError::PrefixCreationFailed {

+                path: path.clone(),

+                reason: format!("Failed to write patched mscorlib.dll: {}", e),

+            })?;

+        }

+

+        info!("mscorlib.dll version patched for WeMod compatibility");

+        Ok(())

+    }

+

+    /// Install .NET Framework 4.8 (required for WeMod's trainer engine)

+    ///

+    /// Downloads the official Microsoft offline installer and runs it directly

+    /// via Proton — avoids winetricks which corrupts 64-bit Proton prefixes

+    /// by changing the Windows version and removing Wine Mono.

+        info!("Installing .NET Framework 4.8 via direct Proton install...");

+

+        // Download the offline installer to cache

+        let cache_dir = dirs::cache_dir()

+            .unwrap_or_else(|| PathBuf::from("/tmp"))

+            .join("wanda/downloads");

+        std::fs::create_dir_all(&cache_dir)?;

+

+        let installer_path = cache_dir.join(DOTNET48_FILENAME);

+

+        if installer_path.exists() {

+            info!("Using cached .NET installer: {}", installer_path.display());

+        } else {

+            info!("Downloading .NET 4.8 offline installer...");

+            self.download_file(DOTNET48_URL, &installer_path).await?;

+            info!("Downloaded to: {}", installer_path.display());

+        }

+

+        // Run the installer via Proton's runinprefix verb.

+        // This uses Proton's wine with proper DLL overrides and library paths

+        // WITHOUT changing Windows version or removing Wine Mono.

+        let proton_script = self.proton.path.join("proton");

+        let env = self.build_proton_env();

+

+        info!("Running .NET installer via Proton (timeout: {:?})...", DOTNET_INSTALL_TIMEOUT);

+

+        let install_future = Command::new(&proton_script)

+            .arg("runinprefix")

+            .arg(&installer_path)

+            .arg("/q")        // Quiet mode

+            .arg("/norestart") // Don't try to restart

+            .current_dir(&self.proton.path)

+            .envs(&env)

+            .stdout(std::process::Stdio::inherit())

+            .stderr(std::process::Stdio::inherit())

+            .status();

+

+        match timeout(DOTNET_INSTALL_TIMEOUT, install_future).await {

+            Ok(Ok(status)) => {

+                if status.success() {

+                    info!(".NET 4.8 installed successfully");

+                } else {

+                    let code = status.code();

+                    // .NET installer exit codes:

+                    // 0 = success, 1602 = user cancelled, 1603 = fatal error,

+                    // 1641/3010 = success (reboot needed), 5100 = prerequisites

+                    match code {

+                        Some(1641) | Some(3010) => {

+                            info!(".NET 4.8 installed (reboot requested but not needed under Wine)");

+                        }

+                        _ => {

+                            warn!(".NET installer exited with code: {:?}", code);

+                            return Err(WandaError::WinetricksFailed {

+                                reason: format!(".NET 4.8 installer failed with exit code {:?}", code),

+                            });

+                        }

+                    }

+                }

+            }

+            Ok(Err(e)) => {

+                return Err(WandaError::WinetricksFailed {

+                    reason: format!("Failed to run .NET installer: {}", e),

+                });

+            }

+            Err(_) => {

+                warn!(".NET installer timed out after {:?}", DOTNET_INSTALL_TIMEOUT);

+                return Err(WandaError::WinetricksFailed {

+                    reason: format!(".NET installer timed out after {:?}", DOTNET_INSTALL_TIMEOUT),

+                });

+            }

+        }

+

+        // Wait for wineserver to finish

+        self.wait_wineserver().await;

+

+        Ok(())

+    }

+

+    /// Download a file from a URL to a local path

+    async fn download_file(&self, url: &str, dest: &Path) -> Result<()> {

+        let client = reqwest::Client::builder()

+            .timeout(Duration::from_secs(600))

+            .build()

+            .map_err(|e| WandaError::WinetricksFailed {

+                reason: format!("Failed to create HTTP client: {}", e),

+            })?;

+

+        let response = client.get(url).send().await.map_err(|e| {

+            WandaError::WinetricksFailed {

+                reason: format!("Failed to download {}: {}", url, e),

+        })?;

+

+        if !response.status().is_success() {

+            return Err(WandaError::WinetricksFailed {

+                reason: format!("Download failed with HTTP {}", response.status()),

+            });

+        let total_size = response.content_length().unwrap_or(0);

+        info!("Downloading {} ({:.1} MB)...", DOTNET48_FILENAME, total_size as f64 / 1_048_576.0);

+

+        let tmp_path = dest.with_extension("tmp");

+        let mut file = tokio::fs::File::create(&tmp_path).await.map_err(|e| {

+            WandaError::WinetricksFailed {

+                reason: format!("Failed to create file: {}", e),

+            }

+        })?;

+

+        let mut stream = response.bytes_stream();

+        while let Some(chunk) = stream.next().await {

+            let chunk = chunk.map_err(|e| WandaError::WinetricksFailed {

+                reason: format!("Download interrupted: {}", e),

+            })?;

+            tokio::io::AsyncWriteExt::write_all(&mut file, &chunk)

+                .await

+                .map_err(|e| WandaError::WinetricksFailed {

+                    reason: format!("Failed to write file: {}", e),

+                })?;

+        }

+

+        // Atomic rename

+        tokio::fs::rename(&tmp_path, dest).await.map_err(|e| {

+            WandaError::WinetricksFailed {

+                reason: format!("Failed to move downloaded file: {}", e),

+            }

+        })?;

+

+        Ok(())

+                .arg("-q")      // Unattended mode - no GUI dialogs

+        assert_eq!(env.get("WINEPREFIX"), Some(&"/tmp/test/pfx".to_string()));

+    /// Get the WeMod executable path (Squirrel stub)

+    /// Get the real WeMod executable inside the versioned app directory

+    ///

+    /// WeMod uses Squirrel for updates. The root WeMod.exe is a small stub

+    /// that spawns the real Electron app from `app-{version}/WeMod.exe` and

+    /// exits. For standalone mode we need the real exe so Proton keeps the

+    /// Wine session alive.

+    pub fn wemod_app_exe(&self) -> Option<PathBuf> {

+        let wemod_dir = self.wemod_path();

+        let mut best: Option<(String, PathBuf)> = None;

+

+        if let Ok(entries) = std::fs::read_dir(&wemod_dir) {

+            for entry in entries.flatten() {

+                let name = entry.file_name().to_string_lossy().to_string();

+                if name.starts_with("app-") && entry.path().is_dir() {

+                    let exe = entry.path().join("WeMod.exe");

+                    if exe.exists() {

+                        // Pick the highest version directory

+                        if best.as_ref().map_or(true, |(v, _)| name > *v) {

+                            best = Some((name, exe));

+                        }

+                    }

+                }

+            }

+        }

+

+        best.map(|(_, path)| path)

+    }

+