`57532bd`

first pass, cli, gui, installer

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

SHA: 57532bd23fc50213e2af31c80e4df6a56423f75c
Parents: ea4ad0a
Tree: b570c6d

46 changed files

Status	File	+
A	`crates/wanda-cli/Cargo.toml`	24
A	`crates/wanda-cli/src/commands/config.rs`	202
A	`crates/wanda-cli/src/commands/doctor.rs`	243
A	`crates/wanda-cli/src/commands/init.rs`	175
A	`crates/wanda-cli/src/commands/launch.rs`	149
A	`crates/wanda-cli/src/commands/mod.rs`	9
A	`crates/wanda-cli/src/commands/prefix.rs`	301
A	`crates/wanda-cli/src/commands/scan.rs`	136
A	`crates/wanda-cli/src/commands/wemod.rs`	299
A	`crates/wanda-cli/src/main.rs`	101
A	`crates/wanda-core/Cargo.toml`	23
A	`crates/wanda-core/src/config.rs`	182
A	`crates/wanda-core/src/error.rs`	114
A	`crates/wanda-core/src/launcher.rs`	352
A	`crates/wanda-core/src/lib.rs`	13
A	`crates/wanda-core/src/prefix/builder.rs`	342
A	`crates/wanda-core/src/prefix/manager.rs`	361
A	`crates/wanda-core/src/prefix/mod.rs`	9
A	`crates/wanda-core/src/steam/library.rs`	348
A	`crates/wanda-core/src/steam/mod.rs`	11
A	`crates/wanda-core/src/steam/proton.rs`	326
A	`crates/wanda-core/src/steam/vdf.rs`	238
A	`crates/wanda-core/src/wemod/downloader.rs`	193
A	`crates/wanda-core/src/wemod/installer.rs`	297
A	`crates/wanda-core/src/wemod/mod.rs`	7
A	`crates/wanda-gui/Cargo.toml`	23
A	`crates/wanda-gui/build.rs`	3
A	`crates/wanda-gui/capabilities/default.json`	10
A	`crates/wanda-gui/frontend/index.html`	30
A	`crates/wanda-gui/frontend/package.json`	24
A	`crates/wanda-gui/frontend/src/App.tsx`	99
A	`crates/wanda-gui/frontend/src/components/GameCard.tsx`	37
A	`crates/wanda-gui/frontend/src/hooks/useApi.ts`	73
A	`crates/wanda-gui/frontend/src/main.tsx`	13
A	`crates/wanda-gui/frontend/src/styles.css`	441
A	`crates/wanda-gui/frontend/src/types/index.ts`	59
A	`crates/wanda-gui/frontend/src/views/GamesView.tsx`	119
A	`crates/wanda-gui/frontend/src/views/PrefixesView.tsx`	188
A	`crates/wanda-gui/frontend/src/views/SettingsView.tsx`	257
A	`crates/wanda-gui/frontend/src/views/SetupView.tsx`	147
A	`crates/wanda-gui/frontend/tsconfig.json`	20
A	`crates/wanda-gui/frontend/vite.config.ts`	17
A	`crates/wanda-gui/src/commands.rs`	584
A	`crates/wanda-gui/src/main.rs`	34
A	`crates/wanda-gui/src/state.rs`	77
A	`crates/wanda-gui/tauri.conf.json`	45

crates/wanda-cli/Cargo.tomladded

 +[package]
 +name = "wanda-cli"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
 +description = "CLI for WANDA - WeMod launcher for Linux"
++
 +[[bin]]
 +name = "wanda"
 +path = "src/main.rs"
++
 +[dependencies]
 +wanda-core = { path = "../wanda-core" }
++
 +tokio.workspace = true
 +serde.workspace = true
 +serde_json.workspace = true
 +thiserror.workspace = true
 +anyhow.workspace = true
 +tracing.workspace = true
 +tracing-subscriber.workspace = true
 +clap.workspace = true
 +indicatif.workspace = true
 +console.workspace = true

crates/wanda-cli/src/commands/config.rsadded

 +//! wanda config - Manage configuration
++
 +use clap::Subcommand;
 +use console::style;
 +use std::path::PathBuf;
 +use wanda_core::{config::WandaConfig, Result};
++
 +#[derive(Subcommand)]
 +pub enum ConfigCommands {
 +    /// Display current configuration
 +    Show,
++
 +    /// Open config file in editor
 +    Edit,
++
 +    /// Set a configuration value
 +    Set {
 +        /// Configuration key (e.g., "proton.preferred_version")
 +        key: String,
 +        /// Value to set
 +        value: String,
 +    },
++
 +    /// Reset configuration to defaults
 +    Reset,
++
 +    /// Show config file path
 +    Path,
 +}
++
 +pub async fn run(cmd: ConfigCommands, config_path: Option<PathBuf>) -> Result<()> {
 +    match cmd {
 +        ConfigCommands::Show => show(config_path),
 +        ConfigCommands::Edit => edit(config_path).await,
 +        ConfigCommands::Set { key, value } => set(key, value, config_path),
 +        ConfigCommands::Reset => reset(config_path),
 +        ConfigCommands::Path => path(config_path),
 +    }
 +}
++
 +fn show(config_path: Option<PathBuf>) -> Result<()> {
 +    let config = match &config_path {
 +        Some(path) => WandaConfig::load_from(path)?,
 +        None => WandaConfig::load()?,
 +    };
++
 +    println!("WANDA Configuration:\n");
++
 +    // Steam settings
 +    println!("[steam]");
 +    if let Some(ref path) = config.steam.install_path {
 +        println!("  install_path = \"{}\"", path.display());
 +    }
 +    if !config.steam.additional_libraries.is_empty() {
 +        println!("  additional_libraries = [");
 +        for lib in &config.steam.additional_libraries {
 +            println!("    \"{}\",", lib.display());
 +        }
 +        println!("  ]");
 +    }
 +    println!("  scan_flatpak = {}", config.steam.scan_flatpak);
++
 +    // Proton settings
 +    println!("\n[proton]");
 +    if let Some(ref version) = config.proton.preferred_version {
 +        println!("  preferred_version = \"{}\"", version);
 +    }
 +    if !config.proton.search_paths.is_empty() {
 +        println!("  search_paths = [");
 +        for path in &config.proton.search_paths {
 +            println!("    \"{}\",", path.display());
 +        }
 +        println!("  ]");
 +    }
++
 +    // WeMod settings
 +    println!("\n[wemod]");
 +    println!("  auto_update = {}", config.wemod.auto_update);
 +    if let Some(ref version) = config.wemod.version {
 +        println!("  version = \"{}\"", version);
 +    }
++
 +    // Prefix settings
 +    println!("\n[prefix]");
 +    if let Some(ref path) = config.prefix.base_path {
 +        println!("  base_path = \"{}\"", path.display());
 +    }
 +    println!("  auto_repair = {}", config.prefix.auto_repair);
++
 +    Ok(())
 +}
++
 +async fn edit(config_path: Option<PathBuf>) -> Result<()> {
 +    let path = config_path.unwrap_or_else(WandaConfig::default_path);
++
 +    // Ensure config file exists
 +    if !path.exists() {
 +        println!("Config file doesn't exist, creating default...");
 +        let config = WandaConfig::default();
 +        config.save_to(&path)?;
 +    }
++
 +    // Try common editors
 +    let editors = ["$EDITOR", "code", "nano", "vim", "vi"];
++
 +    for editor in &editors {
 +        let editor_cmd = if *editor == "$EDITOR" {
 +            std::env::var("EDITOR").ok()
 +        } else {
 +            Some(editor.to_string())
 +        };
++
 +        if let Some(cmd) = editor_cmd {
 +            let status = tokio::process::Command::new(&cmd)
 +                .arg(&path)
 +                .status()
 +                .await;
++
 +            if status.is_ok() {
 +                return Ok(());
 +            }
 +        }
 +    }
++
 +    println!("Could not open editor. Config file is at:");
 +    println!("  {}", path.display());
++
 +    Ok(())
 +}
++
 +fn set(key: String, value: String, config_path: Option<PathBuf>) -> Result<()> {
 +    let path = config_path.unwrap_or_else(WandaConfig::default_path);
 +    let mut config = if path.exists() {
 +        WandaConfig::load_from(&path)?
 +    } else {
 +        WandaConfig::default()
 +    };
++
 +    match key.as_str() {
 +        "steam.install_path" => {
 +            config.steam.install_path = Some(PathBuf::from(&value));
 +        }
 +        "steam.scan_flatpak" => {
 +            config.steam.scan_flatpak = value.parse().unwrap_or(false);
 +        }
 +        "proton.preferred_version" => {
 +            config.proton.preferred_version = Some(value.clone());
 +        }
 +        "wemod.auto_update" => {
 +            config.wemod.auto_update = value.parse().unwrap_or(true);
 +        }
 +        "wemod.version" => {
 +            config.wemod.version = Some(value.clone());
 +        }
 +        "prefix.base_path" => {
 +            config.prefix.base_path = Some(PathBuf::from(&value));
 +        }
 +        "prefix.auto_repair" => {
 +            config.prefix.auto_repair = value.parse().unwrap_or(true);
 +        }
 +        _ => {
 +            println!("Unknown configuration key: {}", key);
 +            println!("\nAvailable keys:");
 +            println!("  steam.install_path");
 +            println!("  steam.scan_flatpak");
 +            println!("  proton.preferred_version");
 +            println!("  wemod.auto_update");
 +            println!("  wemod.version");
 +            println!("  prefix.base_path");
 +            println!("  prefix.auto_repair");
 +            return Ok(());
 +        }
 +    }
++
 +    config.save_to(&path)?;
 +    println!("{} {} = {}", style("Set").green(), key, value);
++
 +    Ok(())
 +}
++
 +fn reset(config_path: Option<PathBuf>) -> Result<()> {
 +    let path = config_path.unwrap_or_else(WandaConfig::default_path);
++
 +    println!(
 +        "This will reset all configuration to defaults. Are you sure?"
 +    );
 +    println!("Config file: {}", path.display());
 +    println!("\nRun with --force to confirm (not implemented yet).");
++
 +    // For now, just create a default config
 +    let config = WandaConfig::default();
 +    config.save_to(&path)?;
 +    println!("\nConfiguration reset to defaults.");
++
 +    Ok(())
 +}
++
 +fn path(config_path: Option<PathBuf>) -> Result<()> {
 +    let path = config_path.unwrap_or_else(WandaConfig::default_path);
 +    println!("{}", path.display());
 +    Ok(())
 +}

crates/wanda-cli/src/commands/doctor.rsadded

 +//! wanda doctor - Diagnose issues
++
 +use clap::Args;
 +use console::style;
 +use std::path::PathBuf;
 +use wanda_core::{
 +    config::WandaConfig,
 +    prefix::{PrefixHealth, PrefixManager},
 +    steam::{ProtonCompatibility, ProtonManager, SteamInstallation},
 +    Result,
 +};
++
 +#[derive(Args)]
 +pub struct DoctorArgs {
 +    /// Generate full diagnostic report
 +    #[arg(long)]
 +    full: bool,
++
 +    /// Export report to file
 +    #[arg(long)]
 +    export: Option<PathBuf>,
++
 +    /// Attempt to fix detected issues
 +    #[arg(long)]
 +    fix: bool,
 +}
++
 +pub async fn run(args: DoctorArgs, config_path: Option<PathBuf>) -> Result<()> {
 +    let config = match &config_path {
 +        Some(path) => WandaConfig::load_from(path)?,
 +        None => WandaConfig::load()?,
 +    };
++
 +    println!("WANDA Diagnostic Report\n");
 +    println!("{}\n", "=".repeat(50));
++
 +    let mut issues = Vec::new();
++
 +    // Check Steam
 +    print_section("Steam Installation");
 +    match SteamInstallation::discover(&config) {
 +        Ok(steam) => {
 +            println!(
 +                "  {} Found at {}{}",
 +                style("OK").green(),
 +                steam.root_path.display(),
 +                if steam.is_flatpak { " (Flatpak)" } else { "" }
 +            );
 +            println!("  {} {} libraries", style("OK").green(), steam.libraries.len());
++
 +            let total_games: usize = steam.libraries.iter().map(|l| l.apps.len()).sum();
 +            let proton_games = steam
 +                .get_all_games()
 +                .iter()
 +                .filter(|g| g.uses_proton())
 +                .count();
 +            println!("  {} {} games ({} using Proton)", style("OK").green(), total_games, proton_games);
++
 +            // Check Proton
 +            print_section("Proton");
 +            match ProtonManager::discover(&steam, &config) {
 +                Ok(proton_mgr) => {
 +                    if proton_mgr.versions.is_empty() {
 +                        println!("  {} No Proton versions found", style("ERROR").red());
 +                        issues.push("No Proton versions installed".to_string());
 +                    } else {
 +                        println!(
 +                            "  {} {} versions found",
 +                            style("OK").green(),
 +                            proton_mgr.versions.len()
 +                        );
++
 +                        // List versions in full mode
 +                        if args.full {
 +                            for v in &proton_mgr.versions {
 +                                let compat = match v.compatibility {
 +                                    ProtonCompatibility::Recommended => {
 +                                        style("RECOMMENDED").green()
 +                                    }
 +                                    ProtonCompatibility::Supported => style("SUPPORTED").blue(),
 +                                    ProtonCompatibility::Experimental => {
 +                                        style("EXPERIMENTAL").yellow()
 +                                    }
 +                                    ProtonCompatibility::Unsupported => style("UNSUPPORTED").red(),
 +                                };
 +                                println!("      {} {}", v.name, compat);
 +                            }
 +                        }
++
 +                        if let Some(recommended) = proton_mgr.get_recommended() {
 +                            println!(
 +                                "  {} Recommended: {}",
 +                                style("OK").green(),
 +                                recommended.name
 +                            );
 +                        } else {
 +                            println!(
 +                                "  {} No recommended Proton version",
 +                                style("WARN").yellow()
 +                            );
 +                            issues.push("No recommended Proton version found".to_string());
 +                        }
 +                    }
 +                }
 +                Err(e) => {
 +                    println!("  {} Error: {}", style("ERROR").red(), e);
 +                    issues.push(format!("Proton detection failed: {}", e));
 +                }
 +            }
 +        }
 +        Err(e) => {
 +            println!("  {} Not found: {}", style("ERROR").red(), e);
 +            issues.push("Steam installation not found".to_string());
 +        }
 +    }
++
 +    // Check WANDA prefix
 +    print_section("WANDA Prefix");
 +    let mut prefix_manager = PrefixManager::new(&config);
 +    prefix_manager.load()?;
++
 +    if let Some(prefix) = prefix_manager.get("default") {
 +        println!("  {} Found at {}", style("OK").green(), prefix.path.display());
++
 +        let health = prefix_manager.validate("default")?;
 +        match health {
 +            PrefixHealth::Healthy => {
 +                println!("  {} Prefix is healthy", style("OK").green());
 +            }
 +            PrefixHealth::NeedsRepair(ref issue_list) => {
 +                println!("  {} Prefix needs repair:", style("WARN").yellow());
 +                for issue in issue_list {
 +                    println!("      - {}", issue);
 +                    issues.push(format!("Prefix issue: {}", issue));
 +                }
 +            }
 +            PrefixHealth::Corrupted(reason) => {
 +                println!("  {} Prefix is corrupted: {}", style("ERROR").red(), reason);
 +                issues.push(format!("Prefix corrupted: {}", reason));
 +            }
 +            PrefixHealth::NotCreated => {
 +                println!("  {} Prefix not initialized", style("WARN").yellow());
 +                issues.push("WANDA prefix not created".to_string());
 +            }
 +        }
++
 +        // Check WeMod
 +        print_section("WeMod");
 +        if prefix.wemod_installed {
 +            println!(
 +                "  {} Installed (version {})",
 +                style("OK").green(),
 +                prefix.wemod_version.as_deref().unwrap_or("unknown")
 +            );
++
 +            if prefix.wemod_exe().exists() {
 +                println!("  {} Executable found", style("OK").green());
 +            } else {
 +                println!("  {} Executable missing", style("ERROR").red());
 +                issues.push("WeMod executable not found".to_string());
 +            }
 +        } else {
 +            println!("  {} Not installed", style("WARN").yellow());
 +            issues.push("WeMod not installed".to_string());
 +        }
 +    } else {
 +        println!("  {} Not initialized", style("WARN").yellow());
 +        issues.push("WANDA not initialized".to_string());
 +    }
++
 +    // Check system dependencies
 +    print_section("System Dependencies");
 +    check_command("wine", "Wine", &mut issues).await;
 +    check_command("winetricks", "Winetricks", &mut issues).await;
 +    check_command("steam", "Steam CLI", &mut issues).await;
 +    check_command("xdg-open", "XDG utilities", &mut issues).await;
++
 +    // Summary
 +    println!("\n{}", "=".repeat(50));
 +    if issues.is_empty() {
 +        println!(
 +            "\n{} All checks passed! WANDA is ready to use.",
 +            style("SUCCESS").green().bold()
 +        );
 +    } else {
 +        println!(
 +            "\n{} Found {} issue(s):\n",
 +            style("ISSUES").yellow().bold(),
 +            issues.len()
 +        );
 +        for (i, issue) in issues.iter().enumerate() {
 +            println!("  {}. {}", i + 1, issue);
 +        }
++
 +        println!("\nSuggestions:");
 +        if issues.iter().any(|i| i.contains("not initialized")) {
 +            println!("  - Run 'wanda init' to initialize WANDA");
 +        }
 +        if issues.iter().any(|i| i.contains("WeMod")) {
 +            println!("  - Run 'wanda wemod install' to install WeMod");
 +        }
 +        if issues.iter().any(|i| i.contains("Prefix")) {
 +            println!("  - Run 'wanda prefix repair' to fix prefix issues");
 +        }
 +        if issues.iter().any(|i| i.contains("Proton")) {
 +            println!("  - Install GE-Proton via ProtonUp-Qt or Steam");
 +        }
 +    }
++
 +    // Export if requested
 +    if let Some(export_path) = args.export {
 +        let report = format!(
 +            "WANDA Diagnostic Report\n\nIssues:\n{}\n",
 +            issues.join("\n")
 +        );
 +        std::fs::write(&export_path, report)?;
 +        println!("\nReport exported to: {}", export_path.display());
 +    }
++
 +    Ok(())
 +}
++
 +fn print_section(name: &str) {
 +    println!("\n{}", style(format!("[{}]", name)).bold());
 +}
++
 +async fn check_command(cmd: &str, name: &str, issues: &mut Vec<String>) {
 +    let result = tokio::process::Command::new("which")
 +        .arg(cmd)
 +        .output()
 +        .await;
++
 +    match result {
 +        Ok(output) if output.status.success() => {
 +            let path = String::from_utf8_lossy(&output.stdout);
 +            println!("  {} {} ({})", style("OK").green(), name, path.trim());
 +        }
 +        _ => {
 +            println!("  {} {} not found", style("WARN").yellow(), name);
 +            issues.push(format!("{} not found in PATH", name));
 +        }
 +    }
 +}

crates/wanda-cli/src/commands/init.rsadded

 +//! wanda init - Initialize WANDA
++
 +use clap::Args;
 +use indicatif::{ProgressBar, ProgressStyle};
 +use std::path::PathBuf;
 +use wanda_core::{
 +    config::WandaConfig,
 +    prefix::PrefixManager,
 +    steam::{ProtonManager, SteamInstallation},
 +    wemod::{WemodDownloader, WemodInstaller},
 +    Result, WandaError,
 +};
++
 +#[derive(Args)]
 +pub struct InitArgs {
 +    /// Override Steam installation path
 +    #[arg(long)]
 +    steam_path: Option<PathBuf>,
++
 +    /// Specify Proton version to use
 +    #[arg(long)]
 +    proton: Option<String>,
++
 +    /// Skip WeMod installation
 +    #[arg(long)]
 +    skip_wemod: bool,
++
 +    /// Force reinitialization even if already set up
 +    #[arg(long, short)]
 +    force: bool,
 +}
++
 +pub async fn run(args: InitArgs, config_path: Option<PathBuf>) -> Result<()> {
 +    println!("Initializing WANDA...\n");
++
 +    // Load or create config
 +    let mut config = match &config_path {
 +        Some(path) => WandaConfig::load_from(path)?,
 +        None => WandaConfig::load()?,
 +    };
++
 +    // Override steam path if provided
 +    if let Some(ref path) = args.steam_path {
 +        config.steam.install_path = Some(path.clone());
 +    }
++
 +    // Discover Steam
 +    println!("Looking for Steam installation...");
 +    let steam = SteamInstallation::discover(&config)?;
 +    println!(
 +        "  Found Steam at: {}{}",
 +        steam.root_path.display(),
 +        if steam.is_flatpak { " (Flatpak)" } else { "" }
 +    );
 +    println!("  Libraries: {}", steam.libraries.len());
++
 +    let total_games: usize = steam.libraries.iter().map(|l| l.apps.len()).sum();
 +    println!("  Games: {}", total_games);
++
 +    // Discover Proton
 +    println!("\nLooking for Proton versions...");
 +    let proton_manager = ProtonManager::discover(&steam, &config)?;
++
 +    if proton_manager.versions.is_empty() {
 +        return Err(WandaError::ProtonNotFound);
 +    }
++
 +    // Select Proton version
 +    let proton = if let Some(ref name) = args.proton {
 +        proton_manager.find_by_name(name).ok_or_else(|| {
 +            eprintln!("Available Proton versions:");
 +            for v in &proton_manager.versions {
 +                eprintln!("  - {}", v.name);
 +            }
 +            WandaError::ProtonNotFound
 +        })?
 +    } else {
 +        proton_manager.get_recommended().ok_or(WandaError::ProtonNotFound)?
 +    };
++
 +    println!("  Using: {} ({:?})", proton.name, proton.compatibility);
++
 +    // Set up prefix
 +    println!("\nSetting up Wine prefix...");
 +    let mut prefix_manager = PrefixManager::new(&config);
 +    prefix_manager.load()?;
++
 +    let existing = prefix_manager.get("default");
 +    if existing.is_some() && !args.force {
 +        println!("  Prefix already exists. Use --force to reinitialize.");
 +    } else {
 +        if existing.is_some() && args.force {
 +            println!("  Removing existing prefix...");
 +            prefix_manager.delete("default")?;
 +        }
++
 +        println!("  Creating prefix (this may take several minutes)...");
 +        let pb = ProgressBar::new_spinner();
 +        pb.set_style(
 +            ProgressStyle::default_spinner()
 +                .template("{spinner:.green} {msg}")
 +                .unwrap(),
 +        );
 +        pb.set_message("Initializing Wine prefix...");
 +        pb.enable_steady_tick(std::time::Duration::from_millis(100));
++
 +        prefix_manager.create("default", proton).await?;
++
 +        pb.finish_with_message("Prefix created successfully");
 +    }
++
 +    // Reload prefix after creation
 +    prefix_manager.load()?;
 +    let prefix = prefix_manager.get("default").unwrap();
++
 +    // Install WeMod
 +    if !args.skip_wemod {
 +        println!("\nInstalling WeMod...");
++
 +        let downloader = WemodDownloader::new(&config);
++
 +        // Get latest release info
 +        let release = downloader.get_latest().await?;
 +        if let Some(ref version) = release.version {
 +            println!("  Latest version: {}", version);
 +        }
++
 +        // Download with progress
 +        let pb = ProgressBar::new(release.size.unwrap_or(0));
 +        pb.set_style(
 +            ProgressStyle::default_bar()
 +                .template("{spinner:.green} [{bar:40.cyan/blue}] {bytes}/{total_bytes} ({eta})")
 +                .unwrap()
 +                .progress_chars("#>-"),
 +        );
++
 +        let installer_path = downloader
 +            .download(&release, |downloaded, total| {
 +                pb.set_length(total);
 +                pb.set_position(downloaded);
 +            })
 +            .await?;
++
 +        pb.finish_with_message("Download complete");
++
 +        // Install
 +        println!("  Installing WeMod...");
 +        let installer = WemodInstaller::new(prefix, proton);
 +        installer.install(&installer_path).await?;
++
 +        // Update prefix metadata
 +        let version = release.version.clone();
 +        prefix_manager.update_metadata("default", |p| {
 +            p.wemod_installed = true;
 +            p.wemod_version = version;
 +        })?;
++
 +        println!("  WeMod installed successfully");
 +    }
++
 +    // Save config
 +    config.proton.preferred_version = Some(proton.name.clone());
 +    match &config_path {
 +        Some(path) => config.save_to(path)?,
 +        None => config.save()?,
 +    }
++
 +    println!("\nWANDA initialization complete!");
 +    println!("\nNext steps:");
 +    println!("  wanda scan          - View available games");
 +    println!("  wanda launch <game> - Launch a game with WeMod");
 +    println!("  wanda doctor        - Check for issues");
++
 +    Ok(())
 +}

crates/wanda-cli/src/commands/launch.rsadded

 +//! wanda launch - Launch a game with WeMod
++
 +use clap::Args;
 +use console::style;
 +use std::path::PathBuf;
 +use wanda_core::{
 +    config::WandaConfig,
 +    launcher::{GameLauncher, LaunchConfig},
 +    prefix::PrefixManager,
 +    steam::{ProtonManager, SteamInstallation},
 +    Result, WandaError,
 +};
++
 +#[derive(Args)]
 +pub struct LaunchArgs {
 +    /// Game name or App ID
 +    game: String,
++
 +    /// Launch without WeMod
 +    #[arg(long)]
 +    no_wemod: bool,
++
 +    /// Delay in seconds before launching game (after WeMod starts)
 +    #[arg(long, default_value = "3")]
 +    delay: u64,
++
 +    /// Additional arguments to pass to the game
 +    #[arg(long)]
 +    args: Option<String>,
++
 +    /// Wait for the game to exit
 +    #[arg(long, short)]
 +    wait: bool,
 +}
++
 +pub async fn run(args: LaunchArgs, config_path: Option<PathBuf>) -> Result<()> {
 +    let config = match &config_path {
 +        Some(path) => WandaConfig::load_from(path)?,
 +        None => WandaConfig::load()?,
 +    };
++
 +    // Discover Steam and find the game
 +    let steam = SteamInstallation::discover(&config)?;
++
 +    // Try to parse as App ID first
 +    let game = if let Ok(app_id) = args.game.parse::<u32>() {
 +        steam.find_game(app_id).ok_or(WandaError::GameNotFound { app_id })?
 +    } else {
 +        // Search by name
 +        let matches = steam.find_game_by_name(&args.game);
 +        match matches.len() {
 +            0 => {
 +                return Err(WandaError::LaunchFailed {
 +                    reason: format!("No game found matching '{}'", args.game),
 +                })
 +            }
 +            1 => matches[0],
 +            _ => {
 +                println!("Multiple games found matching '{}':", args.game);
 +                for game in &matches {
 +                    println!("  {} - {}", game.app_id, game.name);
 +                }
 +                return Err(WandaError::LaunchFailed {
 +                    reason: "Please specify the exact App ID".to_string(),
 +                });
 +            }
 +        }
 +    };
++
 +    println!(
 +        "Launching {} {}",
 +        style(&game.name).bold(),
 +        style(format!("({})", game.app_id)).dim()
 +    );
++
 +    // Check if launching with WeMod
 +    let with_wemod = !args.no_wemod;
++
 +    if with_wemod {
 +        // Load WANDA prefix
 +        let mut prefix_manager = PrefixManager::new(&config);
 +        prefix_manager.load()?;
++
 +        let prefix = prefix_manager.get("default").ok_or_else(|| WandaError::LaunchFailed {
 +            reason: "WANDA not initialized. Run 'wanda init' first.".to_string(),
 +        })?;
++
 +        // Check if WeMod is installed
 +        if !prefix.wemod_installed {
 +            return Err(WandaError::WemodNotInstalled);
 +        }
++
 +        // Get Proton version
 +        let proton_manager = ProtonManager::discover(&steam, &config)?;
 +        let proton = proton_manager.get_preferred(&config)?;
++
 +        println!("  Using WeMod with {}", proton.name);
++
 +        // Create launcher
 +        let launcher = GameLauncher::new(&steam, prefix, proton);
++
 +        let launch_config = LaunchConfig {
 +            app_id: game.app_id,
 +            with_wemod: true,
 +            wemod_delay: args.delay,
 +            extra_args: args
 +                .args
 +                .map(|a| a.split_whitespace().map(String::from).collect())
 +                .unwrap_or_default(),
 +            ..Default::default()
 +        };
++
 +        let mut handle = launcher.launch(launch_config).await?;
++
 +        println!(
 +            "\n{} Game launched with WeMod!",
 +            style("SUCCESS").green().bold()
 +        );
 +        println!("\nWeMod should appear in a separate window.");
 +        println!("Select your game in WeMod and click Play to activate trainers.\n");
++
 +        if args.wait {
 +            println!("Waiting for session to end...");
 +            handle.wait().await?;
 +            println!(
 +                "Session ended. Play time: {:?}",
 +                handle.elapsed()
 +            );
 +        }
 +    } else {
 +        // Launch without WeMod (just use Steam)
 +        println!("  Launching via Steam (without WeMod)...");
++
 +        let steam_url = format!("steam://rungameid/{}", game.app_id);
 +        let status = tokio::process::Command::new("xdg-open")
 +            .arg(&steam_url)
 +            .status()
 +            .await
 +            .map_err(|e| WandaError::LaunchFailed {
 +                reason: format!("Failed to launch: {}", e),
 +            })?;
++
 +        if status.success() {
 +            println!("\n{} Game launched!", style("SUCCESS").green().bold());
 +        }
 +    }
++
 +    Ok(())
 +}

crates/wanda-cli/src/commands/mod.rsadded

 +//! CLI command implementations
++
 +pub mod config;
 +pub mod doctor;
 +pub mod init;
 +pub mod launch;
 +pub mod prefix;
 +pub mod scan;
 +pub mod wemod;

crates/wanda-cli/src/commands/prefix.rsadded

 +//! wanda prefix - Manage Wine/Proton prefixes
++
 +use clap::{Args, Subcommand};
 +use console::style;
 +use std::path::PathBuf;
 +use wanda_core::{
 +    config::WandaConfig,
 +    prefix::{PrefixHealth, PrefixManager},
 +    steam::{ProtonManager, SteamInstallation},
 +    Result, WandaError,
 +};
++
 +#[derive(Subcommand)]
 +pub enum PrefixCommands {
 +    /// List all WANDA prefixes
 +    List,
++
 +    /// Create a new prefix
 +    Create(CreateArgs),
++
 +    /// Delete a prefix
 +    Delete(DeleteArgs),
++
 +    /// Repair a prefix
 +    Repair(RepairArgs),
++
 +    /// Validate prefix health
 +    Validate(ValidateArgs),
++
 +    /// Show prefix details
 +    Info(InfoArgs),
 +}
++
 +#[derive(Args)]
 +pub struct CreateArgs {
 +    /// Name for the new prefix
 +    name: String,
 +}
++
 +#[derive(Args)]
 +pub struct DeleteArgs {
 +    /// Name of the prefix to delete
 +    name: String,
++
 +    /// Skip confirmation
 +    #[arg(long, short)]
 +    force: bool,
 +}
++
 +#[derive(Args)]
 +pub struct RepairArgs {
 +    /// Name of the prefix to repair (default: "default")
 +    #[arg(default_value = "default")]
 +    name: String,
 +}
++
 +#[derive(Args)]
 +pub struct ValidateArgs {
 +    /// Name of the prefix to validate (default: "default")
 +    #[arg(default_value = "default")]
 +    name: String,
 +}
++
 +#[derive(Args)]
 +pub struct InfoArgs {
 +    /// Name of the prefix (default: "default")
 +    #[arg(default_value = "default")]
 +    name: String,
 +}
++
 +pub async fn run(cmd: PrefixCommands, config_path: Option<PathBuf>) -> Result<()> {
 +    let config = match &config_path {
 +        Some(path) => WandaConfig::load_from(path)?,
 +        None => WandaConfig::load()?,
 +    };
++
 +    let mut prefix_manager = PrefixManager::new(&config);
 +    prefix_manager.load()?;
++
 +    match cmd {
 +        PrefixCommands::List => list(&prefix_manager),
 +        PrefixCommands::Create(args) => create(&mut prefix_manager, &config, args).await,
 +        PrefixCommands::Delete(args) => delete(&mut prefix_manager, args),
 +        PrefixCommands::Repair(args) => repair(&mut prefix_manager, &config, args).await,
 +        PrefixCommands::Validate(args) => validate(&prefix_manager, args),
 +        PrefixCommands::Info(args) => info(&prefix_manager, args),
 +    }
 +}
++
 +fn list(manager: &PrefixManager) -> Result<()> {
 +    let prefixes = manager.list();
++
 +    if prefixes.is_empty() {
 +        println!("No prefixes found.");
 +        println!("Run 'wanda init' to create the default prefix.");
 +        return Ok(());
 +    }
++
 +    println!("WANDA Prefixes:\n");
++
 +    for prefix in prefixes {
 +        let health = manager.validate(&prefix.name)?;
 +        let health_indicator = match health {
 +            PrefixHealth::Healthy => style("HEALTHY").green(),
 +            PrefixHealth::NeedsRepair(_) => style("NEEDS REPAIR").yellow(),
 +            PrefixHealth::Corrupted(_) => style("CORRUPTED").red(),
 +            PrefixHealth::NotCreated => style("NOT CREATED").dim(),
 +        };
++
 +        let wemod_status = if prefix.wemod_installed {
 +            format!(
 +                "WeMod {}",
 +                prefix.wemod_version.as_deref().unwrap_or("(unknown version)")
 +            )
 +        } else {
 +            "WeMod not installed".to_string()
 +        };
++
 +        println!(
 +            "  {} {}",
 +            style(&prefix.name).bold(),
 +            health_indicator
 +        );
 +        println!("    Path: {}", prefix.path.display());
 +        println!("    {}", wemod_status);
 +        if let Some(ref proton) = prefix.proton_version {
 +            println!("    Proton: {}", proton);
 +        }
 +        println!();
 +    }
++
 +    Ok(())
 +}
++
 +async fn create(
 +    manager: &mut PrefixManager,
 +    config: &WandaConfig,
 +    args: CreateArgs,
 +) -> Result<()> {
 +    if manager.get(&args.name).is_some() {
 +        return Err(WandaError::PrefixCreationFailed {
 +            path: manager.base_path.join(&args.name),
 +            reason: "Prefix already exists".to_string(),
 +        });
 +    }
++
 +    println!("Creating prefix '{}'...", args.name);
++
 +    // Get Proton version
 +    let steam = SteamInstallation::discover(config)?;
 +    let proton_manager = ProtonManager::discover(&steam, config)?;
 +    let proton = proton_manager.get_preferred(config)?;
++
 +    println!("  Using Proton: {}", proton.name);
 +    println!("  This may take several minutes...");
++
 +    manager.create(&args.name, proton).await?;
++
 +    println!("\n{} Prefix '{}' created successfully!",
 +        style("SUCCESS").green().bold(),
 +        args.name
 +    );
++
 +    Ok(())
 +}
++
 +fn delete(manager: &mut PrefixManager, args: DeleteArgs) -> Result<()> {
 +    let prefix = manager.get(&args.name).ok_or_else(|| WandaError::PrefixNotFound {
 +        path: manager.base_path.join(&args.name),
 +    })?;
++
 +    if !args.force {
 +        println!(
 +            "Are you sure you want to delete prefix '{}'?",
 +            args.name
 +        );
 +        println!("  Path: {}", prefix.path.display());
 +        println!("\nThis action cannot be undone.");
 +        println!("Use --force to skip this confirmation.");
 +        return Ok(());
 +    }
++
 +    manager.delete(&args.name)?;
 +    println!("Prefix '{}' deleted.", args.name);
++
 +    Ok(())
 +}
++
 +async fn repair(
 +    manager: &mut PrefixManager,
 +    config: &WandaConfig,
 +    args: RepairArgs,
 +) -> Result<()> {
 +    let health = manager.validate(&args.name)?;
++
 +    match health {
 +        PrefixHealth::Healthy => {
 +            println!("Prefix '{}' is healthy, no repair needed.", args.name);
 +            return Ok(());
 +        }
 +        PrefixHealth::NotCreated => {
 +            println!("Prefix '{}' doesn't exist.", args.name);
 +            return Ok(());
 +        }
 +        PrefixHealth::Corrupted(reason) => {
 +            println!(
 +                "Prefix '{}' is corrupted: {}",
 +                args.name, reason
 +            );
 +            println!("Consider deleting and recreating the prefix.");
 +            return Err(WandaError::PrefixCorrupted {
 +                path: manager.base_path.join(&args.name),
 +                reason,
 +            });
 +        }
 +        PrefixHealth::NeedsRepair(issues) => {
 +            println!("Repairing prefix '{}'...", args.name);
 +            for issue in &issues {
 +                println!("  - {}", issue);
 +            }
 +        }
 +    }
++
 +    let steam = SteamInstallation::discover(config)?;
 +    let proton_manager = ProtonManager::discover(&steam, config)?;
 +    let proton = proton_manager.get_preferred(config)?;
++
 +    manager.repair(&args.name, proton).await?;
++
 +    println!("\n{} Prefix repaired!", style("SUCCESS").green().bold());
++
 +    Ok(())
 +}
++
 +fn validate(manager: &PrefixManager, args: ValidateArgs) -> Result<()> {
 +    let health = manager.validate(&args.name)?;
++
 +    println!("Prefix '{}' health check:\n", args.name);
++
 +    match health {
 +        PrefixHealth::Healthy => {
 +            println!("  {} All checks passed!", style("HEALTHY").green().bold());
 +        }
 +        PrefixHealth::NeedsRepair(issues) => {
 +            println!("  {} Issues found:", style("NEEDS REPAIR").yellow().bold());
 +            for issue in issues {
 +                println!("    - {}", issue);
 +            }
 +            println!("\nRun 'wanda prefix repair {}' to fix.", args.name);
 +        }
 +        PrefixHealth::Corrupted(reason) => {
 +            println!("  {} {}", style("CORRUPTED").red().bold(), reason);
 +            println!("\nConsider deleting and recreating the prefix.");
 +        }
 +        PrefixHealth::NotCreated => {
 +            println!("  {} Prefix has not been created yet.", style("NOT CREATED").dim());
 +            println!("\nRun 'wanda init' to create the default prefix.");
 +        }
 +    }
++
 +    Ok(())
 +}
++
 +fn info(manager: &PrefixManager, args: InfoArgs) -> Result<()> {
 +    let prefix = manager.get(&args.name).ok_or_else(|| WandaError::PrefixNotFound {
 +        path: manager.base_path.join(&args.name),
 +    })?;
++
 +    let health = manager.validate(&args.name)?;
++
 +    println!("Prefix: {}\n", style(&args.name).bold());
 +    println!("  Path:          {}", prefix.path.display());
 +    println!(
 +        "  Health:        {:?}",
 +        match health {
 +            PrefixHealth::Healthy => style("Healthy").green(),
 +            PrefixHealth::NeedsRepair(_) => style("Needs Repair").yellow(),
 +            PrefixHealth::Corrupted(_) => style("Corrupted").red(),
 +            PrefixHealth::NotCreated => style("Not Created").dim(),
 +        }
 +    );
 +    println!(
 +        "  WeMod:         {}",
 +        if prefix.wemod_installed {
 +            format!(
 +                "Installed ({})",
 +                prefix.wemod_version.as_deref().unwrap_or("unknown")
 +            )
 +        } else {
 +            "Not installed".to_string()
 +        }
 +    );
 +    if let Some(ref proton) = prefix.proton_version {
 +        println!("  Proton:        {}", proton);
 +    }
 +    if let Some(ref created) = prefix.created_at {
 +        println!("  Created:       {}", created);
 +    }
++
 +    Ok(())
 +}

crates/wanda-cli/src/commands/scan.rsadded

 +//! wanda scan - Scan for Steam games
++
 +use clap::Args;
 +use console::style;
 +use std::path::PathBuf;
 +use wanda_core::{config::WandaConfig, steam::SteamInstallation, Result};
++
 +#[derive(Args)]
 +pub struct ScanArgs {
 +    /// Filter games by name
 +    #[arg(short, long)]
 +    filter: Option<String>,
++
 +    /// Show all games, including non-Proton
 +    #[arg(long)]
 +    all: bool,
++
 +    /// Show detailed information
 +    #[arg(short, long)]
 +    long: bool,
 +}
++
 +pub async fn run(args: ScanArgs, config_path: Option<PathBuf>) -> Result<()> {
 +    let config = match &config_path {
 +        Some(path) => WandaConfig::load_from(path)?,
 +        None => WandaConfig::load()?,
 +    };
++
 +    let steam = SteamInstallation::discover(&config)?;
 +    let mut games: Vec<_> = steam.get_all_games();
++
 +    // Filter by name if specified
 +    if let Some(ref filter) = args.filter {
 +        let filter_lower = filter.to_lowercase();
 +        games.retain(|g| g.name.to_lowercase().contains(&filter_lower));
 +    }
++
 +    // Filter to Proton games unless --all
 +    if !args.all {
 +        games.retain(|g| g.uses_proton());
 +    }
++
 +    // Sort by name
 +    games.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
++
 +    if games.is_empty() {
 +        println!("No games found.");
 +        if !args.all {
 +            println!("(Use --all to show non-Proton games)");
 +        }
 +        return Ok(());
 +    }
++
 +    println!(
 +        "Found {} games{}:\n",
 +        games.len(),
 +        if !args.all {
 +            " (Proton/Windows)"
 +        } else {
 +            ""
 +        }
 +    );
++
 +    if args.long {
 +        // Detailed view
 +        for game in &games {
 +            let proton_indicator = if game.uses_proton() {
 +                style("PROTON").green()
 +            } else {
 +                style("NATIVE").blue()
 +            };
++
 +            println!(
 +                "{} {} {}",
 +                style(format!("[{}]", game.app_id)).dim(),
 +                style(&game.name).bold(),
 +                proton_indicator
 +            );
 +            println!("    Path: {}", game.install_path.display());
 +            println!("    Size: {}", game.size_human());
 +            if let Some(ref compat) = game.compat_data_path {
 +                println!("    Prefix: {}", compat.display());
 +            }
 +            println!();
 +        }
 +    } else {
 +        // Compact view
 +        let max_name_len = games
 +            .iter()
 +            .map(|g| g.name.len())
 +            .max()
 +            .unwrap_or(20)
 +            .min(50);
++
 +        println!(
 +            "{:>8}  {:<width$}  {:>10}  {}",
 +            "App ID",
 +            "Name",
 +            "Size",
 +            "Type",
 +            width = max_name_len
 +        );
 +        println!("{}", "-".repeat(8 + 2 + max_name_len + 2 + 10 + 2 + 8));
++
 +        for game in &games {
 +            let name = if game.name.len() > max_name_len {
 +                format!("{}...", &game.name[..max_name_len - 3])
 +            } else {
 +                game.name.clone()
 +            };
++
 +            let game_type = if game.uses_proton() {
 +                style("Proton").green()
 +            } else {
 +                style("Native").blue()
 +            };
++
 +            println!(
 +                "{:>8}  {:<width$}  {:>10}  {}",
 +                game.app_id,
 +                name,
 +                game.size_human(),
 +                game_type,
 +                width = max_name_len
 +            );
 +        }
 +    }
++
 +    println!();
 +    println!(
 +        "Launch a game with: {} <name or app_id>",
 +        style("wanda launch").cyan()
 +    );
++
 +    Ok(())
 +}

crates/wanda-cli/src/commands/wemod.rsadded

 +//! wanda wemod - Manage WeMod installation
++
 +use clap::Subcommand;
 +use console::style;
 +use indicatif::{ProgressBar, ProgressStyle};
 +use std::path::PathBuf;
 +use wanda_core::{
 +    config::WandaConfig,
 +    prefix::PrefixManager,
 +    steam::{ProtonManager, SteamInstallation},
 +    wemod::{WemodDownloader, WemodInstaller},
 +    Result, WandaError,
 +};
++
 +#[derive(Subcommand)]
 +pub enum WemodCommands {
 +    /// Show WeMod installation status
 +    Status,
++
 +    /// Update WeMod to the latest version
 +    Update,
++
 +    /// Install WeMod into a prefix
 +    Install,
++
 +    /// Uninstall WeMod from a prefix
 +    Uninstall,
++
 +    /// Run WeMod standalone (for testing)
 +    Run,
 +}
++
 +pub async fn run(cmd: WemodCommands, config_path: Option<PathBuf>) -> Result<()> {
 +    let config = match &config_path {
 +        Some(path) => WandaConfig::load_from(path)?,
 +        None => WandaConfig::load()?,
 +    };
++
 +    match cmd {
 +        WemodCommands::Status => status(&config).await,
 +        WemodCommands::Update => update(&config).await,
 +        WemodCommands::Install => install(&config).await,
 +        WemodCommands::Uninstall => uninstall(&config).await,
 +        WemodCommands::Run => run_wemod(&config).await,
 +    }
 +}
++
 +async fn status(config: &WandaConfig) -> Result<()> {
 +    let mut prefix_manager = PrefixManager::new(config);
 +    prefix_manager.load()?;
++
 +    let prefix = prefix_manager.get("default");
++
 +    println!("WeMod Status:\n");
++
 +    match prefix {
 +        Some(p) if p.wemod_installed => {
 +            println!(
 +                "  Status:  {} Installed",
 +                style("OK").green().bold()
 +            );
 +            if let Some(ref version) = p.wemod_version {
 +                println!("  Version: {}", version);
 +            }
 +            println!("  Path:    {}", p.wemod_path().display());
++
 +            // Check for updates
 +            println!("\nChecking for updates...");
 +            let downloader = WemodDownloader::new(config);
 +            match downloader.get_latest().await {
 +                Ok(release) => {
 +                    if let Some(ref latest) = release.version {
 +                        let current = p.wemod_version.as_deref().unwrap_or("unknown");
 +                        if current != latest {
 +                            println!(
 +                                "  {} Update available: {} -> {}",
 +                                style("UPDATE").yellow(),
 +                                current,
 +                                latest
 +                            );
 +                            println!("\n  Run 'wanda wemod update' to update.");
 +                        } else {
 +                            println!("  {} Up to date", style("OK").green());
 +                        }
 +                    }
 +                }
 +                Err(e) => {
 +                    println!("  Could not check for updates: {}", e);
 +                }
 +            }
 +        }
 +        Some(_) => {
 +            println!(
 +                "  Status: {} Not installed",
 +                style("WARNING").yellow().bold()
 +            );
 +            println!("\n  Run 'wanda wemod install' to install WeMod.");
 +        }
 +        None => {
 +            println!(
 +                "  Status: {} WANDA not initialized",
 +                style("ERROR").red().bold()
 +            );
 +            println!("\n  Run 'wanda init' first.");
 +        }
 +    }
++
 +    Ok(())
 +}
++
 +async fn update(config: &WandaConfig) -> Result<()> {
 +    let mut prefix_manager = PrefixManager::new(config);
 +    prefix_manager.load()?;
++
 +    let prefix = prefix_manager.get("default").ok_or_else(|| WandaError::LaunchFailed {
 +        reason: "WANDA not initialized. Run 'wanda init' first.".to_string(),
 +    })?;
++
 +    println!("Checking for WeMod updates...\n");
++
 +    let downloader = WemodDownloader::new(config);
 +    let release = downloader.get_latest().await?;
++
 +    let current = prefix.wemod_version.as_deref().unwrap_or("unknown");
 +    let latest = release.version.as_deref().unwrap_or("unknown");
++
 +    if current == latest {
 +        println!("WeMod is already up to date (version {}).", current);
 +        return Ok(());
 +    }
++
 +    println!("Current version: {}", current);
 +    println!("Latest version:  {}", latest);
 +    println!("\nDownloading update...");
++
 +    let pb = ProgressBar::new(release.size.unwrap_or(0));
 +    pb.set_style(
 +        ProgressStyle::default_bar()
 +            .template("{spinner:.green} [{bar:40.cyan/blue}] {bytes}/{total_bytes} ({eta})")
 +            .unwrap()
 +            .progress_chars("#>-"),
 +    );
++
 +    let installer_path = downloader
 +        .download(&release, |downloaded, total| {
 +            pb.set_length(total);
 +            pb.set_position(downloaded);
 +        })
 +        .await?;
++
 +    pb.finish_with_message("Download complete");
++
 +    println!("\nInstalling update...");
++
 +    let steam = SteamInstallation::discover(config)?;
 +    let proton_manager = ProtonManager::discover(&steam, config)?;
 +    let proton = proton_manager.get_preferred(config)?;
++
 +    let installer = WemodInstaller::new(prefix, proton);
 +    installer.install(&installer_path).await?;
++
 +    // Update metadata
 +    let version = release.version.clone();
 +    prefix_manager.update_metadata("default", |p| {
 +        p.wemod_version = version;
 +    })?;
++
 +    println!(
 +        "\n{} WeMod updated to version {}!",
 +        style("SUCCESS").green().bold(),
 +        latest
 +    );
++
 +    Ok(())
 +}
++
 +async fn install(config: &WandaConfig) -> Result<()> {
 +    let mut prefix_manager = PrefixManager::new(config);
 +    prefix_manager.load()?;
++
 +    let prefix = prefix_manager.get("default").ok_or_else(|| WandaError::LaunchFailed {
 +        reason: "WANDA not initialized. Run 'wanda init' first.".to_string(),
 +    })?;
++
 +    if prefix.wemod_installed {
 +        println!("WeMod is already installed.");
 +        println!("Use 'wanda wemod update' to update to the latest version.");
 +        return Ok(());
 +    }
++
 +    println!("Installing WeMod...\n");
++
 +    let downloader = WemodDownloader::new(config);
 +    let release = downloader.get_latest().await?;
++
 +    if let Some(ref version) = release.version {
 +        println!("Version: {}", version);
 +    }
++
 +    let pb = ProgressBar::new(release.size.unwrap_or(0));
 +    pb.set_style(
 +        ProgressStyle::default_bar()
 +            .template("{spinner:.green} [{bar:40.cyan/blue}] {bytes}/{total_bytes} ({eta})")
 +            .unwrap()
 +            .progress_chars("#>-"),
 +    );
++
 +    let installer_path = downloader
 +        .download(&release, |downloaded, total| {
 +            pb.set_length(total);
 +            pb.set_position(downloaded);
 +        })
 +        .await?;
++
 +    pb.finish_with_message("Download complete");
++
 +    println!("\nInstalling...");
++
 +    let steam = SteamInstallation::discover(config)?;
 +    let proton_manager = ProtonManager::discover(&steam, config)?;
 +    let proton = proton_manager.get_preferred(config)?;
++
 +    let installer = WemodInstaller::new(prefix, proton);
 +    installer.install(&installer_path).await?;
++
 +    let version = release.version.clone();
 +    prefix_manager.update_metadata("default", |p| {
 +        p.wemod_installed = true;
 +        p.wemod_version = version;
 +    })?;
++
 +    println!(
 +        "\n{} WeMod installed successfully!",
 +        style("SUCCESS").green().bold()
 +    );
++
 +    Ok(())
 +}
++
 +async fn uninstall(config: &WandaConfig) -> Result<()> {
 +    let mut prefix_manager = PrefixManager::new(config);
 +    prefix_manager.load()?;
++
 +    let prefix = prefix_manager.get("default").ok_or_else(|| WandaError::LaunchFailed {
 +        reason: "WANDA not initialized.".to_string(),
 +    })?;
++
 +    if !prefix.wemod_installed {
 +        println!("WeMod is not installed.");
 +        return Ok(());
 +    }
++
 +    let steam = SteamInstallation::discover(config)?;
 +    let proton_manager = ProtonManager::discover(&steam, config)?;
 +    let proton = proton_manager.get_preferred(config)?;
++
 +    println!("Uninstalling WeMod...");
++
 +    let installer = WemodInstaller::new(prefix, proton);
 +    installer.uninstall().await?;
++
 +    prefix_manager.update_metadata("default", |p| {
 +        p.wemod_installed = false;
 +        p.wemod_version = None;
 +    })?;
++
 +    println!("WeMod uninstalled.");
++
 +    Ok(())
 +}
++
 +async fn run_wemod(config: &WandaConfig) -> Result<()> {
 +    let mut prefix_manager = PrefixManager::new(config);
 +    prefix_manager.load()?;
++
 +    let prefix = prefix_manager.get("default").ok_or(WandaError::WemodNotInstalled)?;
++
 +    if !prefix.wemod_installed {
 +        return Err(WandaError::WemodNotInstalled);
 +    }
++
 +    let steam = SteamInstallation::discover(config)?;
 +    let proton_manager = ProtonManager::discover(&steam, config)?;
 +    let proton = proton_manager.get_preferred(config)?;
++
 +    println!("Starting WeMod...");
++
 +    let installer = WemodInstaller::new(prefix, proton);
 +    let mut child = installer.run().await?;
++
 +    println!("WeMod is running. Press Ctrl+C to stop.");
++
 +    // Wait for WeMod to exit
 +    let _ = child.wait().await;
++
 +    println!("WeMod closed.");
++
 +    Ok(())
 +}

crates/wanda-cli/src/main.rsadded

 +//! WANDA CLI - WeMod launcher for Linux
++
 +mod commands;
++
 +use clap::{Parser, Subcommand};
 +use std::path::PathBuf;
 +use tracing_subscriber::{fmt, prelude::*, EnvFilter};
++
 +#[derive(Parser)]
 +#[command(name = "wanda")]
 +#[command(author = "WANDA Contributors")]
 +#[command(version)]
 +#[command(about = "WeMod launcher for Linux", long_about = None)]
 +struct Cli {
 +    /// Increase verbosity (-v, -vv, -vvv)
 +    #[arg(short, long, action = clap::ArgAction::Count, global = true)]
 +    verbose: u8,
++
 +    /// Suppress non-essential output
 +    #[arg(short, long, global = true)]
 +    quiet: bool,
++
 +    /// Output in JSON format
 +    #[arg(long, global = true)]
 +    json: bool,
++
 +    /// Use a custom config file
 +    #[arg(long, global = true)]
 +    config: Option<PathBuf>,
++
 +    #[command(subcommand)]
 +    command: Commands,
 +}
++
 +#[derive(Subcommand)]
 +enum Commands {
 +    /// Initialize WANDA and set up WeMod prefix
 +    Init(commands::init::InitArgs),
++
 +    /// Scan for Steam games
 +    Scan(commands::scan::ScanArgs),
++
 +    /// Launch a game with WeMod
 +    Launch(commands::launch::LaunchArgs),
++
 +    /// Manage Wine/Proton prefixes
 +    #[command(subcommand)]
 +    Prefix(commands::prefix::PrefixCommands),
++
 +    /// Manage WeMod installation
 +    #[command(subcommand)]
 +    Wemod(commands::wemod::WemodCommands),
++
 +    /// Manage configuration
 +    #[command(subcommand)]
 +    Config(commands::config::ConfigCommands),
++
 +    /// Diagnose issues and generate reports
 +    Doctor(commands::doctor::DoctorArgs),
 +}
++
 +fn setup_logging(verbose: u8, quiet: bool) {
 +    let filter = if quiet {
 +        "warn"
 +    } else {
 +        match verbose {
 +            0 => "info",
 +            1 => "debug",
 +            _ => "trace",
 +        }
 +    };
++
 +    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(filter));
++
 +    tracing_subscriber::registry()
 +        .with(fmt::layer().with_target(false).without_time())
 +        .with(filter)
 +        .init();
 +}
++
 +#[tokio::main]
 +async fn main() {
 +    let cli = Cli::parse();
++
 +    setup_logging(cli.verbose, cli.quiet);
++
 +    let result = match cli.command {
 +        Commands::Init(args) => commands::init::run(args, cli.config).await,
 +        Commands::Scan(args) => commands::scan::run(args, cli.config).await,
 +        Commands::Launch(args) => commands::launch::run(args, cli.config).await,
 +        Commands::Prefix(cmd) => commands::prefix::run(cmd, cli.config).await,
 +        Commands::Wemod(cmd) => commands::wemod::run(cmd, cli.config).await,
 +        Commands::Config(cmd) => commands::config::run(cmd, cli.config).await,
 +        Commands::Doctor(args) => commands::doctor::run(args, cli.config).await,
 +    };
++
 +    if let Err(e) = result {
 +        eprintln!("Error: {}", e.user_message());
 +        std::process::exit(1);
 +    }
 +}

crates/wanda-core/Cargo.tomladded

 +[package]
 +name = "wanda-core"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
 +description = "Core library for WANDA - WeMod launcher for Linux"
++
 +[dependencies]
 +tokio.workspace = true
 +serde.workspace = true
 +serde_json.workspace = true
 +toml.workspace = true
 +thiserror.workspace = true
 +anyhow.workspace = true
 +tracing.workspace = true
 +reqwest.workspace = true
 +dirs.workspace = true
 +walkdir.workspace = true
 +futures.workspace = true
++
 +# VDF parsing (Steam config files)
 +keyvalues-parser = "0.2"
 +keyvalues-serde = "0.2"

crates/wanda-core/src/config.rsadded

 +//! Configuration management for WANDA
++
 +use crate::error::Result;
 +use serde::{Deserialize, Serialize};
 +use std::path::PathBuf;
 +use tracing::{debug, info};
++
 +/// Main WANDA configuration
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(default)]
 +pub struct WandaConfig {
 +    /// Config schema version for future migrations
 +    pub version: u32,
 +    /// Steam-related configuration
 +    pub steam: SteamConfig,
 +    /// Proton-related configuration
 +    pub proton: ProtonConfig,
 +    /// WeMod-related configuration
 +    pub wemod: WemodConfig,
 +    /// Prefix-related configuration
 +    pub prefix: PrefixConfig,
 +}
++
 +impl Default for WandaConfig {
 +    fn default() -> Self {
 +        Self {
 +            version: 1,
 +            steam: SteamConfig::default(),
 +            proton: ProtonConfig::default(),
 +            wemod: WemodConfig::default(),
 +            prefix: PrefixConfig::default(),
 +        }
 +    }
 +}
++
 +/// Steam configuration
 +#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 +#[serde(default)]
 +pub struct SteamConfig {
 +    /// Override auto-detected Steam installation path
 +    pub install_path: Option<PathBuf>,
 +    /// Additional Steam library folders to scan
 +    pub additional_libraries: Vec<PathBuf>,
 +    /// Whether to scan Flatpak Steam installation
 +    pub scan_flatpak: bool,
 +}
++
 +/// Proton configuration
 +#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 +#[serde(default)]
 +pub struct ProtonConfig {
 +    /// Preferred Proton version (e.g., "GE-Proton9-5")
 +    pub preferred_version: Option<String>,
 +    /// Additional paths to search for Proton installations
 +    pub search_paths: Vec<PathBuf>,
 +}
++
 +/// WeMod configuration
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(default)]
 +pub struct WemodConfig {
 +    /// Whether to automatically update WeMod
 +    pub auto_update: bool,
 +    /// Pin to a specific WeMod version
 +    pub version: Option<String>,
 +}
++
 +impl Default for WemodConfig {
 +    fn default() -> Self {
 +        Self {
 +            auto_update: true,
 +            version: None,
 +        }
 +    }
 +}
++
 +/// Prefix configuration
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(default)]
 +pub struct PrefixConfig {
 +    /// Custom base path for WANDA prefixes
 +    pub base_path: Option<PathBuf>,
 +    /// Whether to attempt auto-repair of corrupted prefixes
 +    pub auto_repair: bool,
 +}
++
 +impl Default for PrefixConfig {
 +    fn default() -> Self {
 +        Self {
 +            base_path: None,
 +            auto_repair: true,
 +        }
 +    }
 +}
++
 +impl WandaConfig {
 +    /// Get the default config file path
 +    pub fn default_path() -> PathBuf {
 +        dirs::config_dir()
 +            .unwrap_or_else(|| PathBuf::from("."))
 +            .join("wanda")
 +            .join("config.toml")
 +    }
++
 +    /// Get the default data directory
 +    pub fn default_data_dir() -> PathBuf {
 +        dirs::data_local_dir()
 +            .unwrap_or_else(|| PathBuf::from("."))
 +            .join("wanda")
 +    }
++
 +    /// Get the default cache directory
 +    pub fn default_cache_dir() -> PathBuf {
 +        dirs::cache_dir()
 +            .unwrap_or_else(|| PathBuf::from("."))
 +            .join("wanda")
 +    }
++
 +    /// Load configuration from the default path
 +    pub fn load() -> Result<Self> {
 +        Self::load_from(&Self::default_path())
 +    }
++
 +    /// Load configuration from a specific path
 +    pub fn load_from(path: &PathBuf) -> Result<Self> {
 +        if !path.exists() {
 +            debug!("Config file not found at {}, using defaults", path.display());
 +            return Ok(Self::default());
 +        }
++
 +        let content = std::fs::read_to_string(path)?;
 +        let config: WandaConfig = toml::from_str(&content)?;
 +        debug!("Loaded config from {}", path.display());
 +        Ok(config)
 +    }
++
 +    /// Save configuration to the default path
 +    pub fn save(&self) -> Result<()> {
 +        self.save_to(&Self::default_path())
 +    }
++
 +    /// Save configuration to a specific path
 +    pub fn save_to(&self, path: &PathBuf) -> Result<()> {
 +        // Ensure parent directory exists
 +        if let Some(parent) = path.parent() {
 +            std::fs::create_dir_all(parent)?;
 +        }
++
 +        let content = toml::to_string_pretty(self)?;
 +        std::fs::write(path, content)?;
 +        info!("Saved config to {}", path.display());
 +        Ok(())
 +    }
++
 +    /// Get the prefix base path (custom or default)
 +    pub fn prefix_base_path(&self) -> PathBuf {
 +        self.prefix
 +            .base_path
 +            .clone()
 +            .unwrap_or_else(|| Self::default_data_dir().join("prefix"))
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_default_config() {
 +        let config = WandaConfig::default();
 +        assert_eq!(config.version, 1);
 +        assert!(config.wemod.auto_update);
 +    }
++
 +    #[test]
 +    fn test_serialize_deserialize() {
 +        let config = WandaConfig::default();
 +        let toml_str = toml::to_string_pretty(&config).unwrap();
 +        let parsed: WandaConfig = toml::from_str(&toml_str).unwrap();
 +        assert_eq!(parsed.version, config.version);
 +    }
 +}

crates/wanda-core/src/error.rsadded

 +//! Error types for WANDA
++
 +use std::path::PathBuf;
 +use thiserror::Error;
++
 +/// Result type alias using WandaError
 +pub type Result<T> = std::result::Result<T, WandaError>;
++
 +/// Main error type for WANDA operations
 +#[derive(Error, Debug)]
 +pub enum WandaError {
 +    // Steam errors
 +    #[error("Steam installation not found")]
 +    SteamNotFound,
++
 +    #[error("Steam library at {path} is inaccessible: {reason}")]
 +    SteamLibraryInaccessible { path: PathBuf, reason: String },
++
 +    #[error("Failed to parse VDF file {path}: {reason}")]
 +    VdfParseError { path: PathBuf, reason: String },
++
 +    #[error("Game with app ID {app_id} not found")]
 +    GameNotFound { app_id: u32 },
++
 +    // Proton errors
 +    #[error("No compatible Proton version found")]
 +    ProtonNotFound,
++
 +    #[error("Proton version {version} is incompatible: {reason}")]
 +    ProtonIncompatible { version: String, reason: String },
++
 +    // Prefix errors
 +    #[error("Prefix at {path} is corrupted: {reason}")]
 +    PrefixCorrupted { path: PathBuf, reason: String },
++
 +    #[error("Failed to create prefix at {path}: {reason}")]
 +    PrefixCreationFailed { path: PathBuf, reason: String },
++
 +    #[error("Prefix at {path} not found")]
 +    PrefixNotFound { path: PathBuf },
++
 +    #[error("Winetricks failed: {reason}")]
 +    WinetricksFailed { reason: String },
++
 +    // WeMod errors
 +    #[error("Failed to download WeMod: {reason}")]
 +    WemodDownloadFailed { reason: String },
++
 +    #[error("WeMod installation failed: {reason}")]
 +    WemodInstallFailed { reason: String },
++
 +    #[error("WeMod not installed")]
 +    WemodNotInstalled,
++
 +    // Launch errors
 +    #[error("Failed to launch game: {reason}")]
 +    LaunchFailed { reason: String },
++
 +    #[error("Process terminated unexpectedly: {reason}")]
 +    ProcessCrashed { reason: String },
++
 +    // Configuration errors
 +    #[error("Configuration error: {reason}")]
 +    ConfigError { reason: String },
++
 +    #[error("Configuration file not found at {path}")]
 +    ConfigNotFound { path: PathBuf },
++
 +    // Generic errors
 +    #[error("IO error: {0}")]
 +    Io(#[from] std::io::Error),
++
 +    #[error("HTTP error: {0}")]
 +    Http(#[from] reqwest::Error),
++
 +    #[error("JSON error: {0}")]
 +    Json(#[from] serde_json::Error),
++
 +    #[error("TOML parse error: {0}")]
 +    TomlParse(#[from] toml::de::Error),
++
 +    #[error("TOML serialize error: {0}")]
 +    TomlSerialize(#[from] toml::ser::Error),
 +}
++
 +impl WandaError {
 +    /// Get a user-friendly message with suggestions
 +    pub fn user_message(&self) -> String {
 +        match self {
 +            Self::SteamNotFound => {
 +                "Steam installation not found. Please ensure Steam is installed, \
 +                or specify the path manually in the config."
 +                    .into()
 +            }
 +            Self::ProtonNotFound => {
 +                "No compatible Proton version found. Please install GE-Proton \
 +                or Proton Experimental from Steam."
 +                    .into()
 +            }
 +            Self::PrefixCorrupted { path, reason } => {
 +                format!(
 +                    "The Wine prefix at {} appears to be corrupted: {}\n\
 +                    Try running 'wanda prefix repair' to fix this issue.",
 +                    path.display(),
 +                    reason
 +                )
 +            }
 +            Self::WemodNotInstalled => {
 +                "WeMod is not installed. Run 'wanda init' to set up WANDA.".into()
 +            }
 +            _ => self.to_string(),
 +        }
 +    }
 +}

crates/wanda-core/src/launcher.rsadded

 +//! Game launching with WeMod
 +//!
 +//! Handles launching Steam games alongside WeMod through Proton.
++
 +use crate::error::{Result, WandaError};
 +use crate::prefix::WandaPrefix;
 +use crate::steam::{ProtonVersion, SteamApp, SteamInstallation};
 +use std::collections::HashMap;
 +use std::path::PathBuf;
 +use std::process::Stdio;
 +use std::time::Duration;
 +use tokio::process::{Child, Command};
 +use tracing::{debug, info, warn};
++
 +/// Configuration for launching a game
 +#[derive(Debug, Clone)]
 +pub struct LaunchConfig {
 +    /// The game to launch
 +    pub app_id: u32,
 +    /// Whether to launch with WeMod
 +    pub with_wemod: bool,
 +    /// Additional command-line arguments for the game
 +    pub extra_args: Vec<String>,
 +    /// Additional environment variables
 +    pub extra_env: HashMap<String, String>,
 +    /// Delay between starting WeMod and the game (in seconds)
 +    pub wemod_delay: u64,
 +}
++
 +impl Default for LaunchConfig {
 +    fn default() -> Self {
 +        Self {
 +            app_id: 0,
 +            with_wemod: true,
 +            extra_args: Vec::new(),
 +            extra_env: HashMap::new(),
 +            wemod_delay: 3,
 +        }
 +    }
 +}
++
 +/// Handle to a launched game session
 +pub struct LaunchHandle {
 +    /// WeMod process (if launched with WeMod)
 +    wemod_process: Option<Child>,
 +    /// Game App ID
 +    pub app_id: u32,
 +    /// Start time
 +    start_time: std::time::Instant,
 +}
++
 +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 {
 +            match wemod.try_wait() {
 +                Ok(Some(_)) => return false, // WeMod exited
 +                Ok(None) => return true,     // Still running
 +                Err(_) => return false,
 +            }
 +        }
 +        false
 +    }
++
 +    /// Get elapsed time since launch
 +    pub fn elapsed(&self) -> Duration {
 +        self.start_time.elapsed()
 +    }
++
 +    /// Terminate the session
 +    pub async fn terminate(&mut self) -> Result<()> {
 +        if let Some(ref mut wemod) = self.wemod_process {
 +            let _ = wemod.kill().await;
 +        }
 +        Ok(())
 +    }
++
 +    /// Wait for WeMod to exit
 +    pub async fn wait(&mut self) -> Result<()> {
 +        if let Some(ref mut wemod) = self.wemod_process {
 +            let _ = wemod.wait().await;
 +        }
 +        Ok(())
 +    }
 +}
++
 +/// Game launcher that coordinates WeMod and game startup
 +pub struct GameLauncher<'a> {
 +    /// Steam installation
 +    steam: &'a SteamInstallation,
 +    /// WANDA prefix with WeMod
 +    prefix: &'a WandaPrefix,
 +    /// Proton version to use
 +    proton: &'a ProtonVersion,
 +}
++
 +impl<'a> GameLauncher<'a> {
 +    /// Create a new game launcher
 +    pub fn new(
 +        steam: &'a SteamInstallation,
 +        prefix: &'a WandaPrefix,
 +        proton: &'a ProtonVersion,
 +    ) -> Self {
 +        Self {
 +            steam,
 +            prefix,
 +            proton,
 +        }
 +    }
++
 +    /// Build environment variables for launching
 +    fn build_env(&self, game: &SteamApp) -> HashMap<String, String> {
 +        let mut env = HashMap::new();
++
 +        // Wine prefix (WANDA's prefix for WeMod)
 +        env.insert(
 +            "WINEPREFIX".to_string(),
 +            self.prefix.path.to_string_lossy().to_string(),
 +        );
++
 +        // Steam compatibility data path (for the game's own prefix if needed)
 +        if let Some(ref compat_path) = game.compat_data_path {
 +            env.insert(
 +                "STEAM_COMPAT_DATA_PATH".to_string(),
 +                compat_path.to_string_lossy().to_string(),
 +            );
 +        }
++
 +        // Steam client install path
 +        env.insert(
 +            "STEAM_COMPAT_CLIENT_INSTALL_PATH".to_string(),
 +            self.steam.root_path.to_string_lossy().to_string(),
 +        );
++
 +        // Proton flags that may help stability
 +        env.insert("PROTON_NO_ESYNC".to_string(), "1".to_string());
 +        env.insert("PROTON_NO_FSYNC".to_string(), "1".to_string());
++
 +        // Reduce Wine debug noise
 +        env.insert("WINEDEBUG".to_string(), "-all".to_string());
++
 +        env
 +    }
++
 +    /// Get the Wine executable path
 +    fn wine_exe(&self) -> PathBuf {
 +        let proton_wine = self.proton.wine_exe();
 +        if proton_wine.exists() {
 +            proton_wine
 +        } else {
 +            PathBuf::from("wine")
 +        }
 +    }
++
 +    /// Launch a game with WeMod
 +    pub async fn launch(&self, config: LaunchConfig) -> Result<LaunchHandle> {
 +        let game = self
 +            .steam
 +            .find_game(config.app_id)
 +            .ok_or(WandaError::GameNotFound {
 +                app_id: config.app_id,
 +            })?;
++
 +        info!(
 +            "Launching {} (AppID: {}) {}",
 +            game.name,
 +            game.app_id,
 +            if config.with_wemod {
 +                "with WeMod"
 +            } else {
 +                "without WeMod"
 +            }
 +        );
++
 +        let mut env = self.build_env(game);
 +        env.extend(config.extra_env);
++
 +        let wine = self.wine_exe();
 +        let mut wemod_process = None;
++
 +        // Start WeMod first if requested
 +        if config.with_wemod {
 +            let wemod_exe = self.prefix.wemod_exe();
 +            if !wemod_exe.exists() {
 +                return Err(WandaError::WemodNotInstalled);
 +            }
++
 +            info!("Starting WeMod...");
 +            let child = Command::new(&wine)
 +                .arg(&wemod_exe)
 +                .envs(&env)
 +                .stdout(Stdio::null())
 +                .stderr(Stdio::null())
 +                .spawn()
 +                .map_err(|e| WandaError::LaunchFailed {
 +                    reason: format!("Failed to start WeMod: {}", e),
 +                })?;
++
 +            wemod_process = Some(child);
++
 +            // Wait for WeMod to initialize
 +            info!(
 +                "Waiting {} seconds for WeMod to initialize...",
 +                config.wemod_delay
 +            );
 +            tokio::time::sleep(Duration::from_secs(config.wemod_delay)).await;
 +        }
++
 +        // Launch the game via Steam
 +        // Using steam:// URL protocol ensures Steam handles Proton setup correctly
 +        info!("Launching game via Steam...");
 +        self.launch_via_steam(config.app_id).await?;
++
 +        Ok(LaunchHandle {
 +            wemod_process,
 +            app_id: config.app_id,
 +            start_time: std::time::Instant::now(),
 +        })
 +    }
++
 +    /// Launch a game via Steam's URL protocol
 +    async fn launch_via_steam(&self, app_id: u32) -> Result<()> {
 +        // Use xdg-open to launch via steam:// protocol
 +        // This ensures Steam handles all the Proton setup correctly
 +        let steam_url = format!("steam://rungameid/{}", app_id);
++
 +        let status = Command::new("xdg-open")
 +            .arg(&steam_url)
 +            .stdout(Stdio::null())
 +            .stderr(Stdio::null())
 +            .status()
 +            .await
 +            .map_err(|e| WandaError::LaunchFailed {
 +                reason: format!("Failed to launch Steam URL: {}", e),
 +            })?;
++
 +        if !status.success() {
 +            // Try alternative: steam command directly
 +            let status = Command::new("steam")
 +                .arg(&steam_url)
 +                .stdout(Stdio::null())
 +                .stderr(Stdio::null())
 +                .status()
 +                .await
 +                .map_err(|e| WandaError::LaunchFailed {
 +                    reason: format!("Failed to launch via steam command: {}", e),
 +                })?;
++
 +            if !status.success() {
 +                warn!("Steam launch returned non-zero, game may still start");
 +            }
 +        }
++
 +        debug!("Game launch initiated via Steam");
 +        Ok(())
 +    }
++
 +    /// Launch a game directly via Proton (without Steam)
 +    /// This is an alternative method that gives more control
 +    #[allow(dead_code)]
 +    async fn launch_directly(&self, game: &SteamApp, args: &[String]) -> Result<Child> {
 +        let proton_exe = self.proton.proton_exe();
++
 +        if !proton_exe.exists() {
 +            return Err(WandaError::ProtonNotFound);
 +        }
++
 +        // Find the game executable
 +        let game_exe = self.find_game_executable(game)?;
++
 +        let mut env = self.build_env(game);
++
 +        // Set up Proton environment
 +        env.insert("STEAM_COMPAT_DATA_PATH".to_string(),
 +            game.compat_data_path
 +                .as_ref()
 +                .map(|p| p.to_string_lossy().to_string())
 +                .unwrap_or_else(|| {
 +                    self.steam.root_path
 +                        .join("steamapps/compatdata")
 +                        .join(game.app_id.to_string())
 +                        .to_string_lossy()
 +                        .to_string()
 +                })
 +        );
++
 +        let mut cmd = Command::new(&proton_exe);
 +        cmd.arg("run").arg(&game_exe);
 +        cmd.args(args);
 +        cmd.envs(&env);
 +        cmd.stdout(Stdio::null());
 +        cmd.stderr(Stdio::null());
++
 +        let child = cmd.spawn().map_err(|e| WandaError::LaunchFailed {
 +            reason: format!("Failed to start game: {}", e),
 +        })?;
++
 +        Ok(child)
 +    }
++
 +    /// Try to find the main executable for a game
 +    fn find_game_executable(&self, game: &SteamApp) -> Result<PathBuf> {
 +        let install_path = &game.install_path;
++
 +        if !install_path.exists() {
 +            return Err(WandaError::GameNotFound {
 +                app_id: game.app_id,
 +            });
 +        }
++
 +        // Common executable patterns
 +        let patterns = [
 +            format!("{}.exe", game.install_dir),
 +            "game.exe".to_string(),
 +            "start.exe".to_string(),
 +            "launcher.exe".to_string(),
 +        ];
++
 +        // Try to find a matching executable
 +        for pattern in &patterns {
 +            let exe_path = install_path.join(pattern);
 +            if exe_path.exists() {
 +                return Ok(exe_path);
 +            }
 +        }
++
 +        // Walk the directory looking for .exe files
 +        for entry in walkdir::WalkDir::new(install_path)
 +            .max_depth(2)
 +            .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();
 +                    // Skip common non-game executables
 +                    if !name.to_lowercase().contains("unins")
 +                        && !name.to_lowercase().contains("redist")
 +                        && !name.to_lowercase().contains("setup")
 +                    {
 +                        return Ok(path.to_path_buf());
 +                    }
 +                }
 +            }
 +        }
++
 +        Err(WandaError::LaunchFailed {
 +            reason: format!("Could not find executable for {}", game.name),
 +        })
 +    }
 +}

crates/wanda-core/src/lib.rsadded

 +//! WANDA Core Library
 +//!
 +//! Core functionality for running WeMod on Linux via Wine/Proton.
++
 +pub mod config;
 +pub mod error;
 +pub mod launcher;
 +pub mod prefix;
 +pub mod steam;
 +pub mod wemod;
++
 +pub use config::WandaConfig;
 +pub use error::{Result, WandaError};

crates/wanda-core/src/prefix/builder.rsadded

 +//! Prefix building and initialization
++
 +use crate::error::{Result, WandaError};
 +use crate::steam::ProtonVersion;
 +use std::collections::HashMap;
 +use std::path::{Path, PathBuf};
 +use tokio::process::Command;
 +use tracing::{debug, error, info, warn};
++
 +/// Builds and initializes Wine prefixes for WeMod
 +pub struct PrefixBuilder<'a> {
 +    /// Path where the prefix will be created
 +    prefix_path: PathBuf,
 +    /// Proton version to use
 +    proton: &'a ProtonVersion,
 +}
++
 +impl<'a> PrefixBuilder<'a> {
 +    /// Create a new prefix builder
 +    pub fn new(prefix_path: &Path, proton: &'a ProtonVersion) -> Self {
 +        Self {
 +            prefix_path: prefix_path.to_path_buf(),
 +            proton,
 +        }
 +    }
++
 +    /// Get path to Wine executable (prefer Proton's bundled wine)
 +    fn get_wine_path(&self) -> PathBuf {
 +        // Try Proton's wine64 first
 +        let proton_wine = self.proton.path.join("files/bin/wine64");
 +        debug!("Checking for Proton wine64 at: {}", proton_wine.display());
 +        if proton_wine.exists() {
 +            debug!("Found Proton wine64");
 +            return proton_wine;
 +        }
++
 +        // Try Proton's wine
 +        let proton_wine = self.proton.path.join("files/bin/wine");
 +        debug!("Checking for Proton wine at: {}", proton_wine.display());
 +        if proton_wine.exists() {
 +            debug!("Found Proton wine");
 +            return proton_wine;
 +        }
++
 +        // Fall back to system wine
 +        warn!("No Proton wine found, falling back to system wine");
 +        PathBuf::from("wine")
 +    }
++
 +    /// Build environment variables for Wine/Proton commands
 +    fn build_env(&self) -> HashMap<String, String> {
 +        let mut env = HashMap::new();
++
 +        let wine_path = self.get_wine_path();
 +        debug!("Building environment for Wine at: {}", wine_path.display());
++
 +        // Wine prefix location
 +        env.insert(
 +            "WINEPREFIX".to_string(),
 +            self.prefix_path.to_string_lossy().to_string(),
 +        );
++
 +        // Use 64-bit Windows
 +        env.insert("WINEARCH".to_string(), "win64".to_string());
++
 +        // Tell winetricks which wine to use
 +        env.insert("WINE".to_string(), wine_path.to_string_lossy().to_string());
++
 +        // Proton lib paths for finding dependencies
 +        let proton_lib64 = self.proton.path.join("files/lib64");
 +        let proton_lib = self.proton.path.join("files/lib");
 +        debug!("Checking Proton lib64: {} (exists: {})", proton_lib64.display(), proton_lib64.exists());
 +        debug!("Checking Proton lib: {} (exists: {})", proton_lib.display(), proton_lib.exists());
++
 +        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());
 +            }
 +            // Append existing LD_LIBRARY_PATH
 +            if let Ok(existing) = std::env::var("LD_LIBRARY_PATH") {
 +                ld_path.push(':');
 +                ld_path.push_str(&existing);
 +            }
 +            debug!("Setting LD_LIBRARY_PATH: {}", ld_path);
 +            env.insert("LD_LIBRARY_PATH".to_string(), ld_path);
 +        } else {
 +            warn!("No Proton lib directories found - Wine may have trouble finding libraries");
 +        }
++
 +        // Proton-specific variables
 +        env.insert("PROTON_NO_ESYNC".to_string(), "1".to_string());
 +        env.insert("PROTON_NO_FSYNC".to_string(), "1".to_string());
++
 +        // Enable debug output for troubleshooting
 +        env.insert("WINEDEBUG".to_string(), "warn+all".to_string());
++
 +        // Log all environment variables at trace level
 +        for (key, value) in &env {
 +            debug!("ENV {}={}", key, value);
 +        }
++
 +        env
 +    }
++
 +    /// Build the prefix from scratch
 +    pub async fn build(&self) -> Result<()> {
 +        info!("Building prefix at {}", self.prefix_path.display());
 +        info!("Using Proton: {}", self.proton.name);
 +        info!("Wine path: {}", self.get_wine_path().display());
++
 +        // Create directory structure
 +        std::fs::create_dir_all(&self.prefix_path)?;
++
 +        // Initialize with wineboot
 +        self.init_wineboot().await?;
++
 +        // Try to install .NET Framework (but don't fail if it doesn't work)
 +        match self.install_dotnet().await {
 +            Ok(_) => info!(".NET Framework installed successfully"),
 +            Err(e) => {
 +                warn!(".NET Framework installation failed: {}", e);
 +                warn!("WeMod may still work - continuing with installation");
 +            }
 +        }
++
 +        // Install additional dependencies (optional)
 +        self.install_dependencies().await?;
++
 +        info!("Prefix built successfully");
 +        Ok(())
 +    }
++
 +    /// Initialize the prefix with wineboot
 +    async fn init_wineboot(&self) -> Result<()> {
 +        info!("Initializing Wine prefix with wineboot...");
++
 +        let wine_path = self.get_wine_path();
 +        let env = self.build_env();
++
 +        info!("Running: {} wineboot --init", wine_path.display());
++
 +        let output = Command::new(&wine_path)
 +            .arg("wineboot")
 +            .arg("--init")
 +            .envs(&env)
 +            .output()
 +            .await
 +            .map_err(|e| WandaError::PrefixCreationFailed {
 +                path: self.prefix_path.clone(),
 +                reason: format!("wineboot failed to start: {}", e),
 +            })?;
++
 +        if !output.status.success() {
 +            let stderr = String::from_utf8_lossy(&output.stderr);
 +            let stdout = String::from_utf8_lossy(&output.stdout);
 +            error!("wineboot stdout: {}", stdout);
 +            error!("wineboot stderr: {}", stderr);
 +            return Err(WandaError::PrefixCreationFailed {
 +                path: self.prefix_path.clone(),
 +                reason: format!("wineboot failed with exit code: {:?}", output.status.code()),
 +            });
 +        }
++
 +        debug!("wineboot completed successfully");
++
 +        // Wait for wineserver to finish
 +        self.wait_wineserver().await;
++
 +        Ok(())
 +    }
++
 +    /// Wait for wineserver to finish
 +    async fn wait_wineserver(&self) {
 +        let env = self.build_env();
++
 +        // Try Proton's wineserver first
 +        let proton_wineserver = self.proton.path.join("files/bin/wineserver");
 +        let wineserver = if proton_wineserver.exists() {
 +            proton_wineserver.to_string_lossy().to_string()
 +        } else {
 +            "wineserver".to_string()
 +        };
++
 +        let _ = Command::new(&wineserver)
 +            .arg("-w")
 +            .envs(&env)
 +            .status()
 +            .await;
 +    }
++
 +    /// Install .NET Framework 4.8 (required for WeMod)
 +    pub async fn install_dotnet(&self) -> Result<()> {
 +        info!("Installing .NET Framework 4.8 via winetricks...");
 +        info!("This may take 10-15 minutes and requires internet connection");
++
 +        // Try dotnet48 first, fall back to dotnet40 if it fails
 +        match self.install_winetricks_verbose(&["dotnet48"]).await {
 +            Ok(_) => return Ok(()),
 +            Err(e) => {
 +                warn!("dotnet48 failed: {}", e);
 +                warn!("Trying dotnet40 as fallback...");
 +            }
 +        }
++
 +        // Try dotnet40 as fallback
 +        self.install_winetricks_verbose(&["dotnet40"]).await
 +    }
++
 +    /// Install additional dependencies
 +    async fn install_dependencies(&self) -> Result<()> {
 +        info!("Installing additional dependencies...");
++
 +        // Install common dependencies WeMod might need
 +        let deps = ["vcrun2019", "corefonts"];
++
 +        for dep in deps {
 +            info!("Installing {}...", dep);
 +            match self.install_winetricks_verbose(&[dep]).await {
 +                Ok(_) => info!("{} installed successfully", dep),
 +                Err(e) => warn!("Failed to install {}: {} (may not be critical)", dep, e),
 +            }
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Install components via winetricks with verbose output
 +    pub async fn install_winetricks_verbose(&self, components: &[&str]) -> Result<()> {
 +        let env = self.build_env();
++
 +        // Check if winetricks is available
 +        let winetricks_check = Command::new("which").arg("winetricks").output().await;
++
 +        if winetricks_check.is_err() || !winetricks_check.unwrap().status.success() {
 +            return Err(WandaError::WinetricksFailed {
 +                reason: "winetricks not found. Please install winetricks.".to_string(),
 +            });
 +        }
++
 +        for component in components {
 +            info!("Installing {} via winetricks...", component);
 +            debug!("Environment: WINE={}", env.get("WINE").unwrap_or(&"".to_string()));
 +            debug!("Environment: WINEPREFIX={}", env.get("WINEPREFIX").unwrap_or(&"".to_string()));
++
 +            // Run winetricks without -q so we can see progress
 +            let output = Command::new("winetricks")
 +                .arg("--force") // Force installation even if already installed
 +                .arg(component)
 +                .envs(&env)
 +                .output()
 +                .await
 +                .map_err(|e| WandaError::WinetricksFailed {
 +                    reason: format!("Failed to run winetricks: {}", e),
 +                })?;
++
 +            let stdout = String::from_utf8_lossy(&output.stdout);
 +            let stderr = String::from_utf8_lossy(&output.stderr);
++
 +            // Log output for debugging
 +            if !stdout.is_empty() {
 +                for line in stdout.lines().take(20) {
 +                    debug!("winetricks: {}", line);
 +                }
 +                if stdout.lines().count() > 20 {
 +                    debug!("winetricks: ... ({} more lines)", stdout.lines().count() - 20);
 +                }
 +            }
++
 +            if !output.status.success() {
 +                error!("winetricks {} failed!", component);
 +                error!("stderr: {}", stderr);
 +                return Err(WandaError::WinetricksFailed {
 +                    reason: format!(
 +                        "winetricks {} failed with exit code {:?}",
 +                        component,
 +                        output.status.code()
 +                    ),
 +                });
 +            }
 +        }
++
 +        // Wait for wineserver to finish
 +        self.wait_wineserver().await;
++
 +        Ok(())
 +    }
++
 +    /// Install components via winetricks (quiet mode)
 +    pub async fn install_winetricks(&self, components: &[&str]) -> Result<()> {
 +        self.install_winetricks_verbose(components).await
 +    }
++
 +    /// Run a command in the prefix using Wine
 +    pub async fn run_wine_command(&self, args: &[&str]) -> Result<std::process::Output> {
 +        let wine_path = self.get_wine_path();
 +        let env = self.build_env();
++
 +        info!("Running: {} {:?}", wine_path.display(), args);
++
 +        let output = Command::new(&wine_path)
 +            .args(args)
 +            .envs(&env)
 +            .output()
 +            .await
 +            .map_err(|e| WandaError::PrefixCreationFailed {
 +                path: self.prefix_path.clone(),
 +                reason: format!("Wine command failed: {}", e),
 +            })?;
++
 +        Ok(output)
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_build_env() {
 +        let proton = ProtonVersion {
 +            name: "test".to_string(),
 +            path: PathBuf::from("/test"),
 +            version: (9, 0, 0),
 +            is_ge: true,
 +            is_experimental: false,
 +            compatibility: crate::steam::ProtonCompatibility::Recommended,
 +        };
++
 +        let builder = PrefixBuilder::new(Path::new("/tmp/test"), &proton);
 +        let env = builder.build_env();
++
 +        assert_eq!(env.get("WINEPREFIX"), Some(&"/tmp/test".to_string()));
 +        assert_eq!(env.get("WINEARCH"), Some(&"win64".to_string()));
 +    }
 +}

crates/wanda-core/src/prefix/manager.rsadded

 +//! Prefix lifecycle management
++
 +use crate::config::WandaConfig;
 +use crate::error::{Result, WandaError};
 +use crate::prefix::PrefixBuilder;
 +use crate::steam::ProtonVersion;
 +use serde::{Deserialize, Serialize};
 +use std::path::{Path, PathBuf};
 +use tracing::{debug, info, warn};
++
 +/// Health status of a Wine prefix
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum PrefixHealth {
 +    /// Prefix is healthy and ready for use
 +    Healthy,
 +    /// Prefix has issues that may be repairable
 +    NeedsRepair(Vec<PrefixIssue>),
 +    /// Prefix is corrupted beyond repair
 +    Corrupted(String),
 +    /// Prefix doesn't exist yet
 +    NotCreated,
 +}
++
 +/// Specific issues that can affect a prefix
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum PrefixIssue {
 +    /// .NET Framework is missing
 +    MissingDotNet,
 +    /// Required dependency is missing
 +    MissingDependency(String),
 +    /// Registry appears corrupted
 +    CorruptedRegistry,
 +    /// WeMod is not installed
 +    WemodNotInstalled,
 +    /// WeMod version is outdated
 +    WemodOutdated,
 +    /// Wine prefix structure is incomplete
 +    IncompletePrefix,
 +}
++
 +impl std::fmt::Display for PrefixIssue {
 +    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 +        match self {
 +            Self::MissingDotNet => write!(f, ".NET Framework 4.8 not installed"),
 +            Self::MissingDependency(dep) => write!(f, "Missing dependency: {}", dep),
 +            Self::CorruptedRegistry => write!(f, "Windows registry is corrupted"),
 +            Self::WemodNotInstalled => write!(f, "WeMod is not installed"),
 +            Self::WemodOutdated => write!(f, "WeMod is outdated"),
 +            Self::IncompletePrefix => write!(f, "Wine prefix structure is incomplete"),
 +        }
 +    }
 +}
++
 +/// Metadata about a WANDA prefix
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct WandaPrefix {
 +    /// Name of this prefix
 +    pub name: String,
 +    /// Path to the prefix
 +    pub path: PathBuf,
 +    /// Whether WeMod is installed in this prefix
 +    pub wemod_installed: bool,
 +    /// Installed WeMod version
 +    pub wemod_version: Option<String>,
 +    /// Proton version used to create this prefix
 +    pub proton_version: Option<String>,
 +    /// When the prefix was created
 +    pub created_at: Option<String>,
 +    /// When the prefix was last used
 +    pub last_used: Option<String>,
 +}
++
 +impl WandaPrefix {
 +    /// Get the path to drive_c
 +    pub fn drive_c(&self) -> PathBuf {
 +        self.path.join("drive_c")
 +    }
++
 +    /// Get the path to the Windows user folder
 +    pub fn user_folder(&self) -> PathBuf {
 +        self.drive_c().join("users/steamuser")
 +    }
++
 +    /// Get the expected WeMod installation path
 +    pub fn wemod_path(&self) -> PathBuf {
 +        self.user_folder().join("AppData/Local/WeMod")
 +    }
++
 +    /// Get the WeMod executable path
 +    pub fn wemod_exe(&self) -> PathBuf {
 +        self.wemod_path().join("WeMod.exe")
 +    }
++
 +    /// Get the system32 directory
 +    pub fn system32(&self) -> PathBuf {
 +        self.drive_c().join("windows/system32")
 +    }
 +}
++
 +/// Manages WANDA Wine prefixes
 +pub struct PrefixManager {
 +    /// Base directory for prefixes
 +    pub base_path: PathBuf,
 +    /// Currently loaded prefixes
 +    prefixes: Vec<WandaPrefix>,
 +}
++
 +impl PrefixManager {
 +    /// Create a new prefix manager
 +    pub fn new(config: &WandaConfig) -> Self {
 +        Self {
 +            base_path: config.prefix_base_path(),
 +            prefixes: Vec::new(),
 +        }
 +    }
++
 +    /// Load all existing prefixes
 +    pub fn load(&mut self) -> Result<()> {
 +        self.prefixes.clear();
++
 +        if !self.base_path.exists() {
 +            debug!("Prefix base path doesn't exist yet: {}", self.base_path.display());
 +            return Ok(());
 +        }
++
 +        // Look for prefix metadata files
 +        let entries = std::fs::read_dir(&self.base_path)?;
++
 +        for entry in entries.flatten() {
 +            let path = entry.path();
 +            if path.is_dir() {
 +                let meta_path = path.join("wanda.json");
 +                if meta_path.exists() {
 +                    match self.load_prefix_metadata(&meta_path) {
 +                        Ok(prefix) => {
 +                            debug!("Loaded prefix: {}", prefix.name);
 +                            self.prefixes.push(prefix);
 +                        }
 +                        Err(e) => {
 +                            warn!("Failed to load prefix at {}: {}", path.display(), e);
 +                        }
 +                    }
 +                }
 +            }
 +        }
++
 +        info!("Loaded {} prefixes", self.prefixes.len());
 +        Ok(())
 +    }
++
 +    /// Load prefix metadata from file
 +    fn load_prefix_metadata(&self, path: &Path) -> Result<WandaPrefix> {
 +        let content = std::fs::read_to_string(path)?;
 +        let prefix: WandaPrefix = serde_json::from_str(&content)?;
 +        Ok(prefix)
 +    }
++
 +    /// Save prefix metadata to file
 +    fn save_prefix_metadata(prefix: &WandaPrefix) -> Result<()> {
 +        let meta_path = prefix.path.join("wanda.json");
 +        let content = serde_json::to_string_pretty(prefix)?;
 +        std::fs::write(meta_path, content)?;
 +        Ok(())
 +    }
++
 +    /// Get all prefixes
 +    pub fn list(&self) -> &[WandaPrefix] {
 +        &self.prefixes
 +    }
++
 +    /// Get a prefix by name
 +    pub fn get(&self, name: &str) -> Option<&WandaPrefix> {
 +        self.prefixes.iter().find(|p| p.name == name)
 +    }
++
 +    /// Get the default prefix (creates one if it doesn't exist)
 +    pub async fn get_or_create_default(
 +        &mut self,
 +        proton: &ProtonVersion,
 +    ) -> Result<&WandaPrefix> {
 +        const DEFAULT_NAME: &str = "default";
++
 +        // Check if default exists
 +        if self.get(DEFAULT_NAME).is_some() {
 +            // Validate health
 +            let health = self.validate(DEFAULT_NAME)?;
 +            if health != PrefixHealth::Healthy {
 +                warn!("Default prefix needs attention: {:?}", health);
 +            }
 +            return Ok(self.get(DEFAULT_NAME).unwrap());
 +        }
++
 +        // Create the default prefix
 +        self.create(DEFAULT_NAME, proton).await?;
 +        Ok(self.get(DEFAULT_NAME).unwrap())
 +    }
++
 +    /// Create a new prefix
 +    pub async fn create(&mut self, name: &str, proton: &ProtonVersion) -> Result<WandaPrefix> {
 +        let prefix_path = self.base_path.join(name);
++
 +        if prefix_path.exists() {
 +            return Err(WandaError::PrefixCreationFailed {
 +                path: prefix_path,
 +                reason: "Prefix already exists".to_string(),
 +            });
 +        }
++
 +        info!("Creating prefix '{}' at {}", name, prefix_path.display());
++
 +        // Use PrefixBuilder to set up the prefix
 +        let builder = PrefixBuilder::new(&prefix_path, proton);
 +        builder.build().await?;
++
 +        // Create metadata
 +        let prefix = WandaPrefix {
 +            name: name.to_string(),
 +            path: prefix_path,
 +            wemod_installed: false,
 +            wemod_version: None,
 +            proton_version: Some(proton.name.clone()),
 +            created_at: Some(chrono_lite_now()),
 +            last_used: None,
 +        };
++
 +        Self::save_prefix_metadata(&prefix)?;
 +        self.prefixes.push(prefix.clone());
++
 +        info!("Prefix '{}' created successfully", name);
 +        Ok(prefix)
 +    }
++
 +    /// Validate a prefix's health
 +    pub fn validate(&self, name: &str) -> Result<PrefixHealth> {
 +        let prefix = self.get(name).ok_or_else(|| WandaError::PrefixNotFound {
 +            path: self.base_path.join(name),
 +        })?;
++
 +        let mut issues = Vec::new();
++
 +        // Check basic structure
 +        if !prefix.drive_c().exists() {
 +            return Ok(PrefixHealth::NotCreated);
 +        }
++
 +        if !prefix.system32().exists() {
 +            issues.push(PrefixIssue::IncompletePrefix);
 +        }
++
 +        // Check for registry files
 +        let system_reg = prefix.path.join("system.reg");
 +        let user_reg = prefix.path.join("user.reg");
 +        if !system_reg.exists() || !user_reg.exists() {
 +            issues.push(PrefixIssue::CorruptedRegistry);
 +        }
++
 +        // Check .NET (look for mscorlib.dll as indicator)
 +        let dotnet_indicator = prefix.drive_c().join("windows/Microsoft.NET");
 +        if !dotnet_indicator.exists() {
 +            issues.push(PrefixIssue::MissingDotNet);
 +        }
++
 +        // Check WeMod
 +        if !prefix.wemod_exe().exists() {
 +            issues.push(PrefixIssue::WemodNotInstalled);
 +        }
++
 +        if issues.is_empty() {
 +            Ok(PrefixHealth::Healthy)
 +        } else if issues.contains(&PrefixIssue::CorruptedRegistry) {
 +            Ok(PrefixHealth::Corrupted("Registry files are missing or corrupted".to_string()))
 +        } else {
 +            Ok(PrefixHealth::NeedsRepair(issues))
 +        }
 +    }
++
 +    /// Attempt to repair a prefix
 +    pub async fn repair(&mut self, name: &str, proton: &ProtonVersion) -> Result<()> {
 +        let health = self.validate(name)?;
++
 +        match health {
 +            PrefixHealth::Healthy => {
 +                info!("Prefix '{}' is already healthy", name);
 +                return Ok(());
 +            }
 +            PrefixHealth::Corrupted(reason) => {
 +                return Err(WandaError::PrefixCorrupted {
 +                    path: self.base_path.join(name),
 +                    reason,
 +                });
 +            }
 +            PrefixHealth::NotCreated => {
 +                info!("Prefix doesn't exist, creating it");
 +                self.create(name, proton).await?;
 +                return Ok(());
 +            }
 +            PrefixHealth::NeedsRepair(issues) => {
 +                info!("Repairing prefix '{}': {:?}", name, issues);
 +                // Get prefix path before mutable borrow
 +                let prefix_path = self.base_path.join(name);
 +                let builder = PrefixBuilder::new(&prefix_path, proton);
++
 +                for issue in issues {
 +                    match issue {
 +                        PrefixIssue::MissingDotNet => {
 +                            info!("Installing .NET Framework...");
 +                            builder.install_dotnet().await?;
 +                        }
 +                        PrefixIssue::MissingDependency(dep) => {
 +                            info!("Installing dependency: {}", dep);
 +                            builder.install_winetricks(&[&dep]).await?;
 +                        }
 +                        PrefixIssue::WemodNotInstalled | PrefixIssue::WemodOutdated => {
 +                            // WeMod installation is handled separately
 +                            info!("WeMod needs to be installed/updated");
 +                        }
 +                        _ => {
 +                            warn!("Cannot automatically repair: {:?}", issue);
 +                        }
 +                    }
 +                }
 +            }
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Delete a prefix
 +    pub fn delete(&mut self, name: &str) -> Result<()> {
 +        let prefix_path = self.base_path.join(name);
++
 +        if !prefix_path.exists() {
 +            return Err(WandaError::PrefixNotFound { path: prefix_path });
 +        }
++
 +        info!("Deleting prefix '{}' at {}", name, prefix_path.display());
 +        std::fs::remove_dir_all(&prefix_path)?;
++
 +        self.prefixes.retain(|p| p.name != name);
++
 +        Ok(())
 +    }
++
 +    /// Update prefix metadata (e.g., after WeMod installation)
 +    pub fn update_metadata(&mut self, name: &str, updater: impl FnOnce(&mut WandaPrefix)) -> Result<()> {
 +        if let Some(prefix) = self.prefixes.iter_mut().find(|p| p.name == name) {
 +            updater(prefix);
 +            Self::save_prefix_metadata(prefix)?;
 +        }
 +        Ok(())
 +    }
 +}
++
 +/// Get current timestamp as ISO string (simple implementation)
 +fn chrono_lite_now() -> String {
 +    use std::time::{SystemTime, UNIX_EPOCH};
 +    let duration = SystemTime::now()
 +        .duration_since(UNIX_EPOCH)
 +        .unwrap_or_default();
 +    format!("{}", duration.as_secs())
 +}

crates/wanda-core/src/prefix/mod.rsadded

 +//! Wine/Proton prefix management
 +//!
 +//! Handles creation, validation, and repair of Wine prefixes for WeMod.
++
 +mod builder;
 +mod manager;
++
 +pub use builder::PrefixBuilder;
 +pub use manager::{PrefixHealth, PrefixIssue, PrefixManager, WandaPrefix};

crates/wanda-core/src/steam/library.rsadded

 +//! Steam library and game discovery
++
 +use crate::config::WandaConfig;
 +use crate::error::{Result, WandaError};
 +use crate::steam::vdf::parse_vdf_file;
 +use std::collections::HashMap;
 +use std::path::{Path, PathBuf};
 +use tracing::{debug, info, warn};
++
 +/// A Steam installation with all its libraries
 +#[derive(Debug, Clone)]
 +pub struct SteamInstallation {
 +    /// Root Steam installation path
 +    pub root_path: PathBuf,
 +    /// All discovered library folders
 +    pub libraries: Vec<SteamLibrary>,
 +    /// Whether this is a Flatpak installation
 +    pub is_flatpak: bool,
 +}
++
 +/// A Steam library folder containing games
 +#[derive(Debug, Clone)]
 +pub struct SteamLibrary {
 +    /// Path to the library folder
 +    pub path: PathBuf,
 +    /// Optional label for this library
 +    pub label: Option<String>,
 +    /// Installed apps in this library (app_id -> SteamApp)
 +    pub apps: HashMap<u32, SteamApp>,
 +}
++
 +/// A Steam game/application
 +#[derive(Debug, Clone)]
 +pub struct SteamApp {
 +    /// Steam App ID
 +    pub app_id: u32,
 +    /// Game name
 +    pub name: String,
 +    /// Installation directory name (relative to steamapps/common/)
 +    pub install_dir: String,
 +    /// Full path to the game installation
 +    pub install_path: PathBuf,
 +    /// Library this game belongs to
 +    pub library_path: PathBuf,
 +    /// Size on disk in bytes
 +    pub size_on_disk: u64,
 +    /// Path to the Proton compatdata directory (if using Proton)
 +    pub compat_data_path: Option<PathBuf>,
 +}
++
 +impl SteamInstallation {
 +    /// Discover Steam installation on the system
 +    pub fn discover(config: &WandaConfig) -> Result<Self> {
 +        // Check for user-specified path first
 +        if let Some(ref path) = config.steam.install_path {
 +            if Self::is_valid_steam_path(path) {
 +                info!("Using configured Steam path: {}", path.display());
 +                return Self::from_path(path.clone(), false);
 +            }
 +            warn!(
 +                "Configured Steam path {} is invalid, falling back to auto-detection",
 +                path.display()
 +            );
 +        }
++
 +        // Try standard locations
 +        let candidates = Self::get_candidate_paths(config.steam.scan_flatpak);
++
 +        for (path, is_flatpak) in candidates {
 +            if Self::is_valid_steam_path(&path) {
 +                info!("Found Steam installation at: {}", path.display());
 +                return Self::from_path(path, is_flatpak);
 +            }
 +        }
++
 +        Err(WandaError::SteamNotFound)
 +    }
++
 +    /// Get candidate Steam installation paths
 +    fn get_candidate_paths(scan_flatpak: bool) -> Vec<(PathBuf, bool)> {
 +        let mut candidates = Vec::new();
++
 +        // Standard native Steam locations
 +        if let Some(data_dir) = dirs::data_local_dir() {
 +            candidates.push((data_dir.join("Steam"), false));
 +        }
 +        if let Some(home) = dirs::home_dir() {
 +            candidates.push((home.join(".steam/steam"), false));
 +            candidates.push((home.join(".steam/root"), false));
 +        }
++
 +        // Flatpak Steam
 +        if scan_flatpak {
 +            if let Some(home) = dirs::home_dir() {
 +                candidates.push((
 +                    home.join(".var/app/com.valvesoftware.Steam/.local/share/Steam"),
 +                    true,
 +                ));
 +            }
 +        }
++
 +        candidates
 +    }
++
 +    /// Check if a path is a valid Steam installation
 +    fn is_valid_steam_path(path: &Path) -> bool {
 +        // Steam should have a config directory with libraryfolders.vdf
 +        let config_vdf = path.join("config/libraryfolders.vdf");
 +        let steamapps_vdf = path.join("steamapps/libraryfolders.vdf");
++
 +        config_vdf.exists() || steamapps_vdf.exists()
 +    }
++
 +    /// Create SteamInstallation from a known valid path
 +    fn from_path(root_path: PathBuf, is_flatpak: bool) -> Result<Self> {
 +        let mut installation = Self {
 +            root_path: root_path.clone(),
 +            libraries: Vec::new(),
 +            is_flatpak,
 +        };
++
 +        // Parse library folders
 +        let library_folders_path = if root_path.join("config/libraryfolders.vdf").exists() {
 +            root_path.join("config/libraryfolders.vdf")
 +        } else {
 +            root_path.join("steamapps/libraryfolders.vdf")
 +        };
++
 +        installation.parse_library_folders(&library_folders_path)?;
++
 +        Ok(installation)
 +    }
++
 +    /// Parse libraryfolders.vdf to discover all library locations
 +    fn parse_library_folders(&mut self, vdf_path: &Path) -> Result<()> {
 +        let vdf = parse_vdf_file(vdf_path)?;
++
 +        let folders = vdf
 +            .get("libraryfolders")
 +            .ok_or_else(|| WandaError::VdfParseError {
 +                path: vdf_path.to_path_buf(),
 +                reason: "Missing 'libraryfolders' key".to_string(),
 +            })?;
++
 +        let folders_obj = folders.as_object().ok_or_else(|| WandaError::VdfParseError {
 +            path: vdf_path.to_path_buf(),
 +            reason: "'libraryfolders' is not an object".to_string(),
 +        })?;
++
 +        for (key, value) in folders_obj {
 +            // Library entries are numbered: "0", "1", "2", etc.
 +            if key.parse::<u32>().is_err() {
 +                continue;
 +            }
++
 +            if let Some(path_str) = value.get_str("path") {
 +                let library_path = PathBuf::from(path_str);
 +                let label = value.get_str("label").map(String::from);
++
 +                debug!("Found Steam library: {}", library_path.display());
++
 +                let mut library = SteamLibrary {
 +                    path: library_path.clone(),
 +                    label,
 +                    apps: HashMap::new(),
 +                };
++
 +                // Scan for installed apps
 +                library.scan_apps()?;
 +                self.libraries.push(library);
 +            }
 +        }
++
 +        info!("Discovered {} Steam libraries", self.libraries.len());
 +        Ok(())
 +    }
++
 +    /// Get all installed games across all libraries
 +    pub fn get_all_games(&self) -> Vec<&SteamApp> {
 +        self.libraries
 +            .iter()
 +            .flat_map(|lib| lib.apps.values())
 +            .collect()
 +    }
++
 +    /// Find a game by app ID
 +    pub fn find_game(&self, app_id: u32) -> Option<&SteamApp> {
 +        for library in &self.libraries {
 +            if let Some(app) = library.apps.get(&app_id) {
 +                return Some(app);
 +            }
 +        }
 +        None
 +    }
++
 +    /// Find a game by name (case-insensitive partial match)
 +    pub fn find_game_by_name(&self, name: &str) -> Vec<&SteamApp> {
 +        let name_lower = name.to_lowercase();
 +        self.get_all_games()
 +            .into_iter()
 +            .filter(|app| app.name.to_lowercase().contains(&name_lower))
 +            .collect()
 +    }
 +}
++
 +impl SteamLibrary {
 +    /// Scan for installed apps in this library
 +    fn scan_apps(&mut self) -> Result<()> {
 +        let steamapps_dir = self.path.join("steamapps");
 +        if !steamapps_dir.exists() {
 +            return Ok(());
 +        }
++
 +        // Look for appmanifest_*.acf files
 +        let entries = std::fs::read_dir(&steamapps_dir).map_err(|e| {
 +            WandaError::SteamLibraryInaccessible {
 +                path: self.path.clone(),
 +                reason: e.to_string(),
 +            }
 +        })?;
++
 +        for entry in entries.flatten() {
 +            let path = entry.path();
 +            let filename = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
++
 +            if filename.starts_with("appmanifest_") && filename.ends_with(".acf") {
 +                match self.parse_app_manifest(&path) {
 +                    Ok(app) => {
 +                        debug!("Found game: {} ({})", app.name, app.app_id);
 +                        self.apps.insert(app.app_id, app);
 +                    }
 +                    Err(e) => {
 +                        warn!("Failed to parse {}: {}", path.display(), e);
 +                    }
 +                }
 +            }
 +        }
++
 +        info!(
 +            "Found {} games in library {}",
 +            self.apps.len(),
 +            self.path.display()
 +        );
 +        Ok(())
 +    }
++
 +    /// Parse an appmanifest_*.acf file
 +    fn parse_app_manifest(&self, acf_path: &Path) -> Result<SteamApp> {
 +        let vdf = parse_vdf_file(acf_path)?;
++
 +        let app_state = vdf.get("AppState").ok_or_else(|| WandaError::VdfParseError {
 +            path: acf_path.to_path_buf(),
 +            reason: "Missing 'AppState' key".to_string(),
 +        })?;
++
 +        let app_id: u32 = app_state
 +            .get_str("appid")
 +            .ok_or_else(|| WandaError::VdfParseError {
 +                path: acf_path.to_path_buf(),
 +                reason: "Missing 'appid'".to_string(),
 +            })?
 +            .parse()
 +            .map_err(|_| WandaError::VdfParseError {
 +                path: acf_path.to_path_buf(),
 +                reason: "Invalid 'appid'".to_string(),
 +            })?;
++
 +        let name = app_state
 +            .get_str("name")
 +            .unwrap_or("Unknown")
 +            .to_string();
++
 +        let install_dir = app_state
 +            .get_str("installdir")
 +            .unwrap_or("")
 +            .to_string();
++
 +        let size_on_disk: u64 = app_state
 +            .get_str("SizeOnDisk")
 +            .and_then(|s| s.parse().ok())
 +            .unwrap_or(0);
++
 +        let install_path = self.path.join("steamapps/common").join(&install_dir);
 +        let compat_data_path = self.path.join("steamapps/compatdata").join(app_id.to_string());
++
 +        Ok(SteamApp {
 +            app_id,
 +            name,
 +            install_dir,
 +            install_path,
 +            library_path: self.path.clone(),
 +            size_on_disk,
 +            compat_data_path: if compat_data_path.exists() {
 +                Some(compat_data_path)
 +            } else {
 +                None
 +            },
 +        })
 +    }
 +}
++
 +impl SteamApp {
 +    /// Check if this game uses Proton (has compatdata)
 +    pub fn uses_proton(&self) -> bool {
 +        self.compat_data_path.is_some()
 +    }
++
 +    /// Get the Wine prefix path for this game (inside compatdata)
 +    pub fn get_prefix_path(&self) -> Option<PathBuf> {
 +        self.compat_data_path.as_ref().map(|p| p.join("pfx"))
 +    }
++
 +    /// Format size as human-readable string
 +    pub fn size_human(&self) -> String {
 +        const KB: u64 = 1024;
 +        const MB: u64 = KB * 1024;
 +        const GB: u64 = MB * 1024;
++
 +        if self.size_on_disk >= GB {
 +            format!("{:.1} GB", self.size_on_disk as f64 / GB as f64)
 +        } else if self.size_on_disk >= MB {
 +            format!("{:.1} MB", self.size_on_disk as f64 / MB as f64)
 +        } else if self.size_on_disk >= KB {
 +            format!("{:.1} KB", self.size_on_disk as f64 / KB as f64)
 +        } else {
 +            format!("{} B", self.size_on_disk)
 +        }
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_size_human() {
 +        let app = SteamApp {
 +            app_id: 1,
 +            name: "Test".to_string(),
 +            install_dir: "test".to_string(),
 +            install_path: PathBuf::new(),
 +            library_path: PathBuf::new(),
 +            size_on_disk: 50 * 1024 * 1024 * 1024, // 50 GB
 +            compat_data_path: None,
 +        };
 +        assert_eq!(app.size_human(), "50.0 GB");
 +    }
 +}

crates/wanda-core/src/steam/mod.rsadded

 +//! Steam integration module
 +//!
 +//! Handles Steam library discovery, game detection, and Proton version management.
++
 +mod library;
 +mod proton;
 +mod vdf;
++
 +pub use library::{SteamApp, SteamInstallation, SteamLibrary};
 +pub use proton::{ProtonCompatibility, ProtonManager, ProtonVersion};
 +pub use vdf::parse_vdf_file;

crates/wanda-core/src/steam/proton.rsadded

 +//! Proton version detection and management
++
 +use crate::config::WandaConfig;
 +use crate::error::{Result, WandaError};
 +use crate::steam::SteamInstallation;
 +use std::cmp::Ordering;
 +use std::path::{Path, PathBuf};
 +use tracing::{debug, info, warn};
++
 +/// Proton compatibility level with WeMod
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum ProtonCompatibility {
 +    /// Known to work well with WeMod (GE-Proton 8+)
 +    Recommended,
 +    /// Should work with WeMod
 +    Supported,
 +    /// May work but not tested
 +    Experimental,
 +    /// Known to have issues
 +    Unsupported,
 +}
++
 +/// A detected Proton installation
 +#[derive(Debug, Clone)]
 +pub struct ProtonVersion {
 +    /// Display name (e.g., "GE-Proton9-5", "Proton 8.0")
 +    pub name: String,
 +    /// Path to the Proton installation
 +    pub path: PathBuf,
 +    /// Parsed version numbers (major, minor, patch)
 +    pub version: (u32, u32, u32),
 +    /// Whether this is a GE-Proton build
 +    pub is_ge: bool,
 +    /// Whether this is Proton Experimental
 +    pub is_experimental: bool,
 +    /// Compatibility level with WeMod
 +    pub compatibility: ProtonCompatibility,
 +}
++
 +impl ProtonVersion {
 +    /// Get the path to the proton executable
 +    pub fn proton_exe(&self) -> PathBuf {
 +        self.path.join("proton")
 +    }
++
 +    /// Get the path to the Wine binary
 +    pub fn wine_exe(&self) -> PathBuf {
 +        self.path.join("files/bin/wine64")
 +    }
 +}
++
 +impl PartialOrd for ProtonVersion {
 +    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
 +        Some(self.cmp(other))
 +    }
 +}
++
 +impl Ord for ProtonVersion {
 +    fn cmp(&self, other: &Self) -> Ordering {
 +        // Prefer GE-Proton over standard
 +        match (self.is_ge, other.is_ge) {
 +            (true, false) => return Ordering::Greater,
 +            (false, true) => return Ordering::Less,
 +            _ => {}
 +        }
 +        // Then compare by version
 +        self.version.cmp(&other.version)
 +    }
 +}
++
 +impl PartialEq for ProtonVersion {
 +    fn eq(&self, other: &Self) -> bool {
 +        self.name == other.name && self.path == other.path
 +    }
 +}
++
 +impl Eq for ProtonVersion {}
++
 +/// Manages Proton version discovery and selection
 +pub struct ProtonManager {
 +    /// All discovered Proton versions
 +    pub versions: Vec<ProtonVersion>,
 +}
++
 +impl ProtonManager {
 +    /// Discover all Proton versions on the system
 +    pub fn discover(steam: &SteamInstallation, config: &WandaConfig) -> Result<Self> {
 +        let mut versions = Vec::new();
++
 +        // Search in Steam's common folder (official Proton)
 +        let common_dir = steam.root_path.join("steamapps/common");
 +        Self::scan_directory(&common_dir, &mut versions);
++
 +        // Search in compatibility tools directory (GE-Proton, custom builds)
 +        let compat_tools_dir = steam.root_path.join("compatibilitytools.d");
 +        Self::scan_directory(&compat_tools_dir, &mut versions);
++
 +        // System-wide compatibility tools
 +        let system_compat = PathBuf::from("/usr/share/steam/compatibilitytools.d");
 +        if system_compat.exists() {
 +            Self::scan_directory(&system_compat, &mut versions);
 +        }
++
 +        // User-configured additional paths
 +        for path in &config.proton.search_paths {
 +            if path.exists() {
 +                Self::scan_directory(path, &mut versions);
 +            }
 +        }
++
 +        // Sort by preference (GE-Proton first, then by version descending)
 +        versions.sort_by(|a, b| b.cmp(a));
++
 +        info!("Discovered {} Proton versions", versions.len());
 +        for v in &versions {
 +            debug!(
 +                "  {} ({:?}) at {}",
 +                v.name,
 +                v.compatibility,
 +                v.path.display()
 +            );
 +        }
++
 +        Ok(Self { versions })
 +    }
++
 +    /// Scan a directory for Proton installations
 +    fn scan_directory(dir: &Path, versions: &mut Vec<ProtonVersion>) {
 +        let entries = match std::fs::read_dir(dir) {
 +            Ok(e) => e,
 +            Err(_) => return,
 +        };
++
 +        for entry in entries.flatten() {
 +            let path = entry.path();
 +            if path.is_dir() {
 +                if let Some(version) = Self::detect_proton(&path) {
 +                    versions.push(version);
 +                }
 +            }
 +        }
 +    }
++
 +    /// Detect if a directory contains a Proton installation
 +    fn detect_proton(path: &Path) -> Option<ProtonVersion> {
 +        // Proton directories should have a 'proton' script
 +        let proton_script = path.join("proton");
 +        if !proton_script.exists() {
 +            return None;
 +        }
++
 +        let name = path.file_name()?.to_str()?.to_string();
++
 +        // Parse version from name
 +        let (version, is_ge, is_experimental) = Self::parse_version_from_name(&name);
 +        let compatibility = Self::determine_compatibility(&name, version, is_ge, is_experimental);
++
 +        Some(ProtonVersion {
 +            name,
 +            path: path.to_path_buf(),
 +            version,
 +            is_ge,
 +            is_experimental,
 +            compatibility,
 +        })
 +    }
++
 +    /// Parse version numbers from Proton directory name
 +    fn parse_version_from_name(name: &str) -> ((u32, u32, u32), bool, bool) {
 +        let is_ge = name.contains("GE-Proton") || name.contains("Proton-GE");
 +        let is_experimental = name.contains("Experimental");
++
 +        // Try to extract version numbers
 +        // GE-Proton format: "GE-Proton9-5" -> (9, 5, 0)
 +        // Standard format: "Proton 8.0-5" -> (8, 0, 5)
 +        // Experimental: "Proton - Experimental" -> (999, 0, 0) to sort high
++
 +        if is_experimental {
 +            return ((999, 0, 0), is_ge, is_experimental);
 +        }
++
 +        let version = Self::extract_version_numbers(name);
 +        (version, is_ge, is_experimental)
 +    }
++
 +    /// Extract version numbers from a string
 +    fn extract_version_numbers(s: &str) -> (u32, u32, u32) {
 +        let numbers: Vec<u32> = s
 +            .chars()
 +            .filter(|c| c.is_ascii_digit() || *c == '.' || *c == '-')
 +            .collect::<String>()
 +            .split(|c| c == '.' || c == '-')
 +            .filter_map(|n| n.parse().ok())
 +            .collect();
++
 +        match numbers.as_slice() {
 +            [major, minor, patch, ..] => (*major, *minor, *patch),
 +            [major, minor] => (*major, *minor, 0),
 +            [major] => (*major, 0, 0),
 +            [] => (0, 0, 0),
 +        }
 +    }
++
 +    /// Determine compatibility level based on version info
 +    fn determine_compatibility(
 +        name: &str,
 +        version: (u32, u32, u32),
 +        is_ge: bool,
 +        is_experimental: bool,
 +    ) -> ProtonCompatibility {
 +        // GE-Proton 8+ is recommended for WeMod
 +        if is_ge && version.0 >= 8 {
 +            return ProtonCompatibility::Recommended;
 +        }
++
 +        // GE-Proton 7.x should work
 +        if is_ge && version.0 >= 7 {
 +            return ProtonCompatibility::Supported;
 +        }
++
 +        // Proton Experimental might work
 +        if is_experimental {
 +            return ProtonCompatibility::Experimental;
 +        }
++
 +        // Standard Proton 8+ should work
 +        if version.0 >= 8 {
 +            return ProtonCompatibility::Supported;
 +        }
++
 +        // Wine-GE has known issues
 +        if name.contains("Wine-GE") {
 +            return ProtonCompatibility::Unsupported;
 +        }
++
 +        // Older versions might have issues
 +        if version.0 < 7 {
 +            return ProtonCompatibility::Unsupported;
 +        }
++
 +        ProtonCompatibility::Experimental
 +    }
++
 +    /// Get the recommended Proton version for WeMod
 +    pub fn get_recommended(&self) -> Option<&ProtonVersion> {
 +        // First try to find a Recommended version
 +        if let Some(v) = self
 +            .versions
 +            .iter()
 +            .find(|v| v.compatibility == ProtonCompatibility::Recommended)
 +        {
 +            return Some(v);
 +        }
++
 +        // Fall back to Supported
 +        if let Some(v) = self
 +            .versions
 +            .iter()
 +            .find(|v| v.compatibility == ProtonCompatibility::Supported)
 +        {
 +            return Some(v);
 +        }
++
 +        // Fall back to Experimental
 +        self.versions
 +            .iter()
 +            .find(|v| v.compatibility == ProtonCompatibility::Experimental)
 +    }
++
 +    /// Find a Proton version by name
 +    pub fn find_by_name(&self, name: &str) -> Option<&ProtonVersion> {
 +        let name_lower = name.to_lowercase();
 +        self.versions
 +            .iter()
 +            .find(|v| v.name.to_lowercase().contains(&name_lower))
 +    }
++
 +    /// Get a version by preference: user-specified, then recommended
 +    pub fn get_preferred(&self, config: &WandaConfig) -> Result<&ProtonVersion> {
 +        // Check user preference first
 +        if let Some(ref preferred) = config.proton.preferred_version {
 +            if let Some(v) = self.find_by_name(preferred) {
 +                if v.compatibility == ProtonCompatibility::Unsupported {
 +                    warn!(
 +                        "Preferred Proton version {} has known compatibility issues",
 +                        v.name
 +                    );
 +                }
 +                return Ok(v);
 +            }
 +            warn!(
 +                "Preferred Proton version '{}' not found, using recommended",
 +                preferred
 +            );
 +        }
++
 +        self.get_recommended().ok_or(WandaError::ProtonNotFound)
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_version_parsing() {
 +        let (v, is_ge, _) = ProtonManager::parse_version_from_name("GE-Proton9-5");
 +        assert_eq!(v, (9, 5, 0));
 +        assert!(is_ge);
++
 +        let (v, is_ge, _) = ProtonManager::parse_version_from_name("Proton 8.0-5");
 +        assert_eq!(v, (8, 0, 5));
 +        assert!(!is_ge);
 +    }
++
 +    #[test]
 +    fn test_compatibility() {
 +        let compat =
 +            ProtonManager::determine_compatibility("GE-Proton9-5", (9, 5, 0), true, false);
 +        assert_eq!(compat, ProtonCompatibility::Recommended);
++
 +        let compat =
 +            ProtonManager::determine_compatibility("Proton 6.0", (6, 0, 0), false, false);
 +        assert_eq!(compat, ProtonCompatibility::Unsupported);
 +    }
 +}

crates/wanda-core/src/steam/vdf.rsadded

 +//! VDF (Valve Data Format) file parsing
 +//!
 +//! Steam uses VDF files for configuration (libraryfolders.vdf, appmanifest_*.acf, etc.)
++
 +use crate::error::{Result, WandaError};
 +use std::collections::HashMap;
 +use std::path::Path;
++
 +/// Parsed VDF value - can be a string or a nested object
 +#[derive(Debug, Clone)]
 +pub enum VdfValue {
 +    String(String),
 +    Object(HashMap<String, VdfValue>),
 +}
++
 +impl VdfValue {
 +    /// Get as string if this is a string value
 +    pub fn as_str(&self) -> Option<&str> {
 +        match self {
 +            VdfValue::String(s) => Some(s),
 +            VdfValue::Object(_) => None,
 +        }
 +    }
++
 +    /// Get as object if this is an object value
 +    pub fn as_object(&self) -> Option<&HashMap<String, VdfValue>> {
 +        match self {
 +            VdfValue::String(_) => None,
 +            VdfValue::Object(obj) => Some(obj),
 +        }
 +    }
++
 +    /// Get a nested value by key
 +    pub fn get(&self, key: &str) -> Option<&VdfValue> {
 +        self.as_object()?.get(key)
 +    }
++
 +    /// Get a string value by key
 +    pub fn get_str(&self, key: &str) -> Option<&str> {
 +        self.get(key)?.as_str()
 +    }
 +}
++
 +/// Parse a VDF file from disk
 +pub fn parse_vdf_file(path: &Path) -> Result<VdfValue> {
 +    let content = std::fs::read_to_string(path).map_err(|e| WandaError::VdfParseError {
 +        path: path.to_path_buf(),
 +        reason: e.to_string(),
 +    })?;
++
 +    parse_vdf(&content).map_err(|e| WandaError::VdfParseError {
 +        path: path.to_path_buf(),
 +        reason: e,
 +    })
 +}
++
 +/// Parse VDF content from a string
 +pub fn parse_vdf(content: &str) -> std::result::Result<VdfValue, String> {
 +    let mut parser = VdfParser::new(content);
 +    parser.parse_root()
 +}
++
 +struct VdfParser<'a> {
 +    chars: std::iter::Peekable<std::str::Chars<'a>>,
 +}
++
 +impl<'a> VdfParser<'a> {
 +    fn new(content: &'a str) -> Self {
 +        Self {
 +            chars: content.chars().peekable(),
 +        }
 +    }
++
 +    fn parse_root(&mut self) -> std::result::Result<VdfValue, String> {
 +        self.skip_whitespace();
++
 +        // Root is typically a single key-value pair where value is an object
 +        let mut root = HashMap::new();
++
 +        while self.chars.peek().is_some() {
 +            self.skip_whitespace();
 +            if self.chars.peek().is_none() {
 +                break;
 +            }
++
 +            let key = self.parse_string()?;
 +            self.skip_whitespace();
 +            let value = self.parse_value()?;
 +            root.insert(key, value);
 +            self.skip_whitespace();
 +        }
++
 +        Ok(VdfValue::Object(root))
 +    }
++
 +    fn parse_value(&mut self) -> std::result::Result<VdfValue, String> {
 +        self.skip_whitespace();
++
 +        match self.chars.peek() {
 +            Some('{') => self.parse_object(),
 +            Some('"') => Ok(VdfValue::String(self.parse_string()?)),
 +            Some(c) => Err(format!("Unexpected character: {}", c)),
 +            None => Err("Unexpected end of input".to_string()),
 +        }
 +    }
++
 +    fn parse_object(&mut self) -> std::result::Result<VdfValue, String> {
 +        self.expect_char('{')?;
 +        let mut obj = HashMap::new();
++
 +        loop {
 +            self.skip_whitespace();
 +            match self.chars.peek() {
 +                Some('}') => {
 +                    self.chars.next();
 +                    break;
 +                }
 +                Some('"') => {
 +                    let key = self.parse_string()?;
 +                    self.skip_whitespace();
 +                    let value = self.parse_value()?;
 +                    obj.insert(key, value);
 +                }
 +                Some(c) => return Err(format!("Expected '\"' or '}}', got '{}'", c)),
 +                None => return Err("Unexpected end of input in object".to_string()),
 +            }
 +        }
++
 +        Ok(VdfValue::Object(obj))
 +    }
++
 +    fn parse_string(&mut self) -> std::result::Result<String, String> {
 +        self.expect_char('"')?;
 +        let mut result = String::new();
++
 +        loop {
 +            match self.chars.next() {
 +                Some('"') => break,
 +                Some('\\') => {
 +                    // Handle escape sequences
 +                    match self.chars.next() {
 +                        Some('n') => result.push('\n'),
 +                        Some('t') => result.push('\t'),
 +                        Some('\\') => result.push('\\'),
 +                        Some('"') => result.push('"'),
 +                        Some(c) => {
 +                            result.push('\\');
 +                            result.push(c);
 +                        }
 +                        None => return Err("Unexpected end of input in escape sequence".to_string()),
 +                    }
 +                }
 +                Some(c) => result.push(c),
 +                None => return Err("Unexpected end of input in string".to_string()),
 +            }
 +        }
++
 +        Ok(result)
 +    }
++
 +    fn skip_whitespace(&mut self) {
 +        while let Some(&c) = self.chars.peek() {
 +            if c.is_whitespace() {
 +                self.chars.next();
 +            } else if c == '/' {
 +                // Handle // comments
 +                self.chars.next();
 +                if self.chars.peek() == Some(&'/') {
 +                    // Skip until end of line
 +                    while let Some(&c) = self.chars.peek() {
 +                        self.chars.next();
 +                        if c == '\n' {
 +                            break;
 +                        }
 +                    }
 +                }
 +            } else {
 +                break;
 +            }
 +        }
 +    }
++
 +    fn expect_char(&mut self, expected: char) -> std::result::Result<(), String> {
 +        match self.chars.next() {
 +            Some(c) if c == expected => Ok(()),
 +            Some(c) => Err(format!("Expected '{}', got '{}'", expected, c)),
 +            None => Err(format!("Expected '{}', got end of input", expected)),
 +        }
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_parse_simple_vdf() {
 +        let vdf = r#"
 +        "libraryfolders"
 +        {
 +            "0"
 +            {
 +                "path"      "/home/user/.local/share/Steam"
 +                "label"     ""
 +            }
 +        }
 +        "#;
++
 +        let result = parse_vdf(vdf).unwrap();
 +        let folders = result.get("libraryfolders").unwrap();
 +        let folder0 = folders.get("0").unwrap();
 +        assert_eq!(
 +            folder0.get_str("path"),
 +            Some("/home/user/.local/share/Steam")
 +        );
 +    }
++
 +    #[test]
 +    fn test_parse_app_manifest() {
 +        let acf = r#"
 +        "AppState"
 +        {
 +            "appid"     "292030"
 +            "name"      "The Witcher 3: Wild Hunt"
 +            "installdir"    "The Witcher 3 Wild Hunt"
 +            "SizeOnDisk"    "50000000000"
 +        }
 +        "#;
++
 +        let result = parse_vdf(acf).unwrap();
 +        let app_state = result.get("AppState").unwrap();
 +        assert_eq!(app_state.get_str("appid"), Some("292030"));
 +        assert_eq!(
 +            app_state.get_str("name"),
 +            Some("The Witcher 3: Wild Hunt")
 +        );
 +    }
 +}

crates/wanda-core/src/wemod/downloader.rsadded

 +//! WeMod download functionality
++
 +use crate::config::WandaConfig;
 +use crate::error::{Result, WandaError};
 +use futures::StreamExt;
 +use std::path::PathBuf;
 +use tokio::fs::File;
 +use tokio::io::AsyncWriteExt;
 +use tracing::{debug, info};
++
 +/// WeMod download API endpoint
 +const WEMOD_DOWNLOAD_URL: &str = "https://api.wemod.com/client/download";
++
 +/// Information about a WeMod release
 +#[derive(Debug, Clone)]
 +pub struct WemodRelease {
 +    /// Download URL
 +    pub url: String,
 +    /// Version string (if known)
 +    pub version: Option<String>,
 +    /// File size in bytes (if known)
 +    pub size: Option<u64>,
 +}
++
 +/// Handles downloading WeMod
 +pub struct WemodDownloader {
 +    /// HTTP client
 +    client: reqwest::Client,
 +    /// Cache directory for downloads
 +    cache_dir: PathBuf,
 +}
++
 +impl WemodDownloader {
 +    /// Create a new downloader
 +    pub fn new(_config: &WandaConfig) -> Self {
 +        Self {
 +            client: reqwest::Client::builder()
 +                .user_agent("WANDA/0.1.0")
 +                .build()
 +                .expect("Failed to create HTTP client"),
 +            cache_dir: WandaConfig::default_cache_dir().join("downloads"),
 +        }
 +    }
++
 +    /// Get the latest WeMod release info
 +    pub async fn get_latest(&self) -> Result<WemodRelease> {
 +        info!("Fetching WeMod download info...");
++
 +        // The WeMod API redirects to the actual download URL
 +        // We need to follow the redirect to get the final URL
 +        let response = self
 +            .client
 +            .head(WEMOD_DOWNLOAD_URL)
 +            .send()
 +            .await
 +            .map_err(|e| WandaError::WemodDownloadFailed {
 +                reason: format!("Failed to fetch download info: {}", e),
 +            })?;
++
 +        let final_url = response.url().to_string();
 +        let content_length = response
 +            .headers()
 +            .get(reqwest::header::CONTENT_LENGTH)
 +            .and_then(|v| v.to_str().ok())
 +            .and_then(|v| v.parse().ok());
++
 +        // Try to extract version from URL
 +        // URL format is typically: https://storage.wemod.com/app/releases/stable/WeMod-X.Y.Z.exe
 +        let version = final_url
 +            .split('/')
 +            .last()
 +            .and_then(|filename| {
 +                filename
 +                    .strip_prefix("WeMod-")
 +                    .and_then(|v| v.strip_suffix(".exe"))
 +                    .map(String::from)
 +            });
++
 +        debug!("WeMod download URL: {}", final_url);
 +        if let Some(ref v) = version {
 +            debug!("Detected version: {}", v);
 +        }
++
 +        Ok(WemodRelease {
 +            url: final_url,
 +            version,
 +            size: content_length,
 +        })
 +    }
++
 +    /// Download WeMod installer to cache
 +    pub async fn download<F>(&self, release: &WemodRelease, progress_callback: F) -> Result<PathBuf>
 +    where
 +        F: Fn(u64, u64),
 +    {
 +        // Ensure cache directory exists
 +        tokio::fs::create_dir_all(&self.cache_dir).await?;
++
 +        let filename = release
 +            .version
 +            .as_ref()
 +            .map(|v| format!("WeMod-{}.exe", v))
 +            .unwrap_or_else(|| "WeMod-latest.exe".to_string());
++
 +        let dest_path = self.cache_dir.join(&filename);
++
 +        // Check if we already have this version cached
 +        if dest_path.exists() {
 +            if let Some(expected_size) = release.size {
 +                let actual_size = tokio::fs::metadata(&dest_path).await?.len();
 +                if actual_size == expected_size {
 +                    info!("Using cached WeMod installer: {}", dest_path.display());
 +                    return Ok(dest_path);
 +                }
 +            }
 +        }
++
 +        info!("Downloading WeMod from {}...", release.url);
++
 +        let response = self
 +            .client
 +            .get(&release.url)
 +            .send()
 +            .await
 +            .map_err(|e| WandaError::WemodDownloadFailed {
 +                reason: format!("Download request failed: {}", e),
 +            })?;
++
 +        if !response.status().is_success() {
 +            return Err(WandaError::WemodDownloadFailed {
 +                reason: format!("HTTP error: {}", response.status()),
 +            });
 +        }
++
 +        let total_size = response.content_length().unwrap_or(0);
 +        let mut downloaded: u64 = 0;
++
 +        let mut file = File::create(&dest_path).await?;
 +        let mut stream = response.bytes_stream();
++
 +        while let Some(chunk_result) = stream.next().await {
 +            let chunk = chunk_result.map_err(|e| WandaError::WemodDownloadFailed {
 +                reason: format!("Error reading download stream: {}", e),
 +            })?;
++
 +            file.write_all(&chunk).await?;
++
 +            downloaded += chunk.len() as u64;
 +            progress_callback(downloaded, total_size);
 +        }
++
 +        file.flush().await?;
++
 +        info!("Downloaded WeMod to {}", dest_path.display());
 +        Ok(dest_path)
 +    }
++
 +    /// Check if we have a cached version matching the release
 +    pub async fn get_cached(&self, release: &WemodRelease) -> Option<PathBuf> {
 +        if let Some(ref version) = release.version {
 +            let path = self.cache_dir.join(format!("WeMod-{}.exe", version));
 +            if path.exists() {
 +                return Some(path);
 +            }
 +        }
 +        None
 +    }
++
 +    /// Clear the download cache
 +    pub async fn clear_cache(&self) -> Result<()> {
 +        if self.cache_dir.exists() {
 +            tokio::fs::remove_dir_all(&self.cache_dir).await?;
 +        }
 +        Ok(())
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_version_extraction() {
 +        let url = "https://storage.wemod.com/app/releases/stable/WeMod-8.12.5.exe";
 +        let version = url
 +            .split('/')
 +            .last()
 +            .and_then(|f| f.strip_prefix("WeMod-"))
 +            .and_then(|v| v.strip_suffix(".exe"));
++
 +        assert_eq!(version, Some("8.12.5"));
 +    }
 +}

crates/wanda-core/src/wemod/installer.rsadded

 +//! WeMod installation into Wine prefixes
++
 +use crate::error::{Result, WandaError};
 +use crate::prefix::WandaPrefix;
 +use crate::steam::ProtonVersion;
 +use std::collections::HashMap;
 +use std::path::Path;
 +use std::process::Stdio;
 +use tokio::process::Command;
 +use tracing::{debug, error, info, warn};
++
 +/// Handles WeMod installation into Wine prefixes
 +pub struct WemodInstaller<'a> {
 +    /// The prefix to install into
 +    prefix: &'a WandaPrefix,
 +    /// Proton version for running installer
 +    proton: &'a ProtonVersion,
 +}
++
 +impl<'a> WemodInstaller<'a> {
 +    /// Create a new installer
 +    pub fn new(prefix: &'a WandaPrefix, proton: &'a ProtonVersion) -> Self {
 +        Self { prefix, proton }
 +    }
++
 +    /// Build environment variables for Wine
 +    fn build_env(&self) -> HashMap<String, String> {
 +        let mut env = HashMap::new();
++
 +        env.insert(
 +            "WINEPREFIX".to_string(),
 +            self.prefix.path.to_string_lossy().to_string(),
 +        );
 +        env.insert("WINEARCH".to_string(), "win64".to_string());
 +        env.insert("WINEDEBUG".to_string(), "warn+all".to_string());
++
 +        // Proton compatibility flags
 +        env.insert("PROTON_NO_ESYNC".to_string(), "1".to_string());
 +        env.insert("PROTON_NO_FSYNC".to_string(), "1".to_string());
++
 +        // Set Proton lib paths for finding dependencies
 +        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);
 +        }
++
 +        debug!("Installer environment:");
 +        for (key, value) in &env {
 +            debug!("  {}={}", key, value);
 +        }
++
 +        env
 +    }
++
 +    /// Get the path to wine executable
 +    fn wine_exe(&self) -> String {
 +        let proton_wine = self.proton.wine_exe();
 +        debug!("Checking Proton wine at: {}", proton_wine.display());
 +        if proton_wine.exists() {
 +            debug!("Using Proton wine");
 +            proton_wine.to_string_lossy().to_string()
 +        } else {
 +            warn!("Proton wine not found, falling back to system wine");
 +            "wine".to_string()
 +        }
 +    }
++
 +    /// Get the path to wineserver executable
 +    fn wineserver_exe(&self) -> String {
 +        let proton_wineserver = self.proton.path.join("files/bin/wineserver");
 +        if proton_wineserver.exists() {
 +            proton_wineserver.to_string_lossy().to_string()
 +        } else {
 +            "wineserver".to_string()
 +        }
 +    }
++
 +    /// Install WeMod from the downloaded installer
 +    pub async fn install(&self, installer_path: &Path) -> Result<()> {
 +        if !installer_path.exists() {
 +            return Err(WandaError::WemodInstallFailed {
 +                reason: format!("Installer not found at {}", installer_path.display()),
 +            });
 +        }
++
 +        info!("Installing WeMod from {}...", installer_path.display());
++
 +        let env = self.build_env();
 +        let wine = self.wine_exe();
++
 +        info!("Using wine: {}", wine);
 +        info!("Running: {} {} /S", wine, installer_path.display());
++
 +        // WeMod installer supports silent installation with /S flag
 +        let output = Command::new(&wine)
 +            .arg(installer_path)
 +            .arg("/S") // Silent install
 +            .envs(&env)
 +            .stdout(Stdio::piped())
 +            .stderr(Stdio::piped())
 +            .output()
 +            .await
 +            .map_err(|e| WandaError::WemodInstallFailed {
 +                reason: format!("Failed to run installer: {}", e),
 +            })?;
++
 +        let stdout = String::from_utf8_lossy(&output.stdout);
 +        let stderr = String::from_utf8_lossy(&output.stderr);
++
 +        if !stdout.is_empty() {
 +            debug!("Installer stdout: {}", stdout);
 +        }
++
 +        if !output.status.success() {
 +            error!("WeMod installer exited with status: {:?}", output.status.code());
 +            if !stderr.is_empty() {
 +                error!("Installer stderr: {}", stderr);
 +            }
 +            // Don't fail immediately - installer might still have worked
 +        } else {
 +            debug!("Installer completed with success status");
 +        }
++
 +        // Wait for wineserver using Proton's wineserver
 +        let wineserver = self.wineserver_exe();
 +        debug!("Waiting for wineserver: {}", wineserver);
 +        let _ = Command::new(&wineserver)
 +            .arg("-w")
 +            .envs(&env)
 +            .status()
 +            .await;
++
 +        // Verify installation
 +        info!("Verifying WeMod installation...");
 +        if self.verify()? {
 +            info!("WeMod installed successfully");
 +            Ok(())
 +        } else {
 +            error!("WeMod executable not found after installation");
 +            error!("Checked locations:");
 +            error!("  - {}", self.prefix.wemod_exe().display());
 +            error!("  - {}", self.prefix.user_folder().join("AppData/Local/WeMod/WeMod.exe").display());
 +            error!("  - {}", self.prefix.drive_c().join("Program Files/WeMod/WeMod.exe").display());
 +            Err(WandaError::WemodInstallFailed {
 +                reason: "WeMod executable not found after installation".to_string(),
 +            })
 +        }
 +    }
++
 +    /// Verify WeMod installation
 +    pub fn verify(&self) -> Result<bool> {
 +        // Check if WeMod.exe exists
 +        let wemod_exe = self.prefix.wemod_exe();
 +        debug!("Checking for WeMod at: {}", wemod_exe.display());
++
 +        if wemod_exe.exists() {
 +            info!("WeMod found at {}", wemod_exe.display());
 +            return Ok(true);
 +        }
++
 +        // Also check alternative locations
 +        let alt_locations = [
 +            self.prefix
 +                .user_folder()
 +                .join("AppData/Local/WeMod/WeMod.exe"),
 +            self.prefix
 +                .drive_c()
 +                .join("Program Files/WeMod/WeMod.exe"),
 +            self.prefix
 +                .drive_c()
 +                .join("Program Files (x86)/WeMod/WeMod.exe"),
 +        ];
++
 +        for loc in &alt_locations {
 +            debug!("Checking alternative location: {}", loc.display());
 +            if loc.exists() {
 +                info!("WeMod found at alternative location: {}", loc.display());
 +                return Ok(true);
 +            }
 +        }
++
 +        // List what's in the WeMod directory if it exists
 +        let wemod_dir = self.prefix.wemod_path();
 +        debug!("WeMod directory: {}", wemod_dir.display());
 +        if wemod_dir.exists() {
 +            debug!("WeMod directory exists, contents:");
 +            if let Ok(entries) = std::fs::read_dir(&wemod_dir) {
 +                for entry in entries.flatten() {
 +                    debug!("  - {}", entry.path().display());
 +                }
 +            }
 +        } else {
 +            debug!("WeMod directory does not exist");
 +        }
++
 +        // Also check what's in AppData/Local
 +        let local_appdata = self.prefix.user_folder().join("AppData/Local");
 +        if local_appdata.exists() {
 +            debug!("Listing AppData/Local contents:");
 +            if let Ok(entries) = std::fs::read_dir(&local_appdata) {
 +                for entry in entries.flatten() {
 +                    debug!("  - {}", entry.file_name().to_string_lossy());
 +                }
 +            }
 +        }
++
 +        debug!("WeMod not found in prefix");
 +        Ok(false)
 +    }
++
 +    /// Get the installed WeMod version (if available)
 +    pub fn get_version(&self) -> Option<String> {
 +        // Try to read version from WeMod's app data
 +        let version_file = self.prefix.wemod_path().join("current");
 +        if version_file.exists() {
 +            if let Ok(content) = std::fs::read_to_string(&version_file) {
 +                // The 'current' file contains the version directory name
 +                let version = content.trim().to_string();
 +                if !version.is_empty() {
 +                    return Some(version);
 +                }
 +            }
 +        }
++
 +        // Try to detect from installed app directories
 +        let wemod_dir = self.prefix.wemod_path();
 +        if wemod_dir.exists() {
 +            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();
 +                    // Look for version directories like "app-8.12.5"
 +                    if name.starts_with("app-") {
 +                        return Some(name.strip_prefix("app-").unwrap_or(&name).to_string());
 +                    }
 +                }
 +            }
 +        }
++
 +        None
 +    }
++
 +    /// Uninstall WeMod from the prefix
 +    pub async fn uninstall(&self) -> Result<()> {
 +        info!("Uninstalling WeMod...");
++
 +        let wemod_dir = self.prefix.wemod_path();
 +        if wemod_dir.exists() {
 +            tokio::fs::remove_dir_all(&wemod_dir).await?;
 +            info!("WeMod uninstalled");
 +        } else {
 +            info!("WeMod was not installed");
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Run WeMod standalone (for testing or manual use)
 +    pub async fn run(&self) -> Result<tokio::process::Child> {
 +        let wemod_exe = self.prefix.wemod_exe();
++
 +        if !wemod_exe.exists() {
 +            return Err(WandaError::WemodNotInstalled);
 +        }
++
 +        let env = self.build_env();
 +        let wine = self.wine_exe();
++
 +        info!("Starting WeMod...");
++
 +        let child = Command::new(&wine)
 +            .arg(&wemod_exe)
 +            .envs(&env)
 +            .stdout(Stdio::null())
 +            .stderr(Stdio::null())
 +            .spawn()
 +            .map_err(|e| WandaError::LaunchFailed {
 +                reason: format!("Failed to start WeMod: {}", e),
 +            })?;
++
 +        Ok(child)
 +    }
 +}

crates/wanda-core/src/wemod/mod.rsadded

 +//! WeMod download and installation management
++
 +mod downloader;
 +mod installer;
++
 +pub use downloader::{WemodDownloader, WemodRelease};
 +pub use installer::WemodInstaller;

crates/wanda-gui/Cargo.tomladded

 +[package]
 +name = "wanda-gui"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
 +description = "GUI for WANDA - WeMod launcher for Linux"
++
 +[build-dependencies]
 +tauri-build.workspace = true
++
 +[dependencies]
 +wanda-core = { path = "../wanda-core" }
++
 +tauri.workspace = true
 +tauri-plugin-shell.workspace = true
 +tokio.workspace = true
 +serde.workspace = true
 +serde_json.workspace = true
 +tracing.workspace = true
++
 +[features]
 +default = ["custom-protocol"]
 +custom-protocol = ["tauri/custom-protocol"]

crates/wanda-gui/build.rsadded

 +fn main() {
 +    tauri_build::build()
 +}

crates/wanda-gui/capabilities/default.jsonadded

 +{
 +  "$schema": "https://schema.tauri.app/config/2",
 +  "identifier": "default",
 +  "description": "Default capabilities for WANDA",
 +  "windows": ["main"],
 +  "permissions": [
 +    "core:default",
 +    "shell:allow-open"
 +  ]
 +}

crates/wanda-gui/frontend/index.htmladded

 +<!DOCTYPE html>
 +<html lang="en">
 +  <head>
 +    <meta charset="UTF-8" />
 +    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 +    <title>WANDA</title>
 +    <style>
 +      * {
 +        margin: 0;
 +        padding: 0;
 +        box-sizing: border-box;
 +      }
++
 +      body {
 +        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
 +        background-color: #1a1a2e;
 +        color: #eaeaea;
 +        min-height: 100vh;
 +      }
++
 +      #root {
 +        min-height: 100vh;
 +      }
 +    </style>
 +  </head>
 +  <body>
 +    <div id="root"></div>
 +    <script type="module" src="/src/main.tsx"></script>
 +  </body>
 +</html>

crates/wanda-gui/frontend/package.jsonadded

 +{
 +  "name": "wanda-frontend",
 +  "private": true,
 +  "version": "0.1.0",
 +  "type": "module",
 +  "scripts": {
 +    "dev": "vite",
 +    "build": "tsc && vite build",
 +    "preview": "vite preview"
 +  },
 +  "dependencies": {
 +    "react": "^18.3.1",
 +    "react-dom": "^18.3.1",
 +    "react-router-dom": "^6.28.0"
 +  },
 +  "devDependencies": {
 +    "@tauri-apps/api": "^2.0.0",
 +    "@types/react": "^18.3.12",
 +    "@types/react-dom": "^18.3.1",
 +    "@vitejs/plugin-react": "^4.3.3",
 +    "typescript": "^5.6.3",
 +    "vite": "^5.4.11"
 +  }
 +}

crates/wanda-gui/frontend/src/App.tsxadded

 +import { useEffect, useState } from "react";
 +import { Routes, Route, NavLink, useNavigate } from "react-router-dom";
 +import { getInitStatus } from "./hooks/useApi";
 +import type { InitStatus } from "./types";
 +import GamesView from "./views/GamesView";
 +import SettingsView from "./views/SettingsView";
 +import PrefixesView from "./views/PrefixesView";
 +import SetupView from "./views/SetupView";
++
 +function App() {
 +  const [initStatus, setInitStatus] = useState<InitStatus | null>(null);
 +  const [loading, setLoading] = useState(true);
 +  const navigate = useNavigate();
++
 +  useEffect(() => {
 +    checkInit();
 +  }, []);
++
 +  async function checkInit() {
 +    try {
 +      const status = await getInitStatus();
 +      setInitStatus(status);
 +      if (!status.initialized) {
 +        navigate("/setup");
 +      }
 +    } catch (err) {
 +      console.error("Failed to check init status:", err);
 +    } finally {
 +      setLoading(false);
 +    }
 +  }
++
 +  if (loading) {
 +    return (
 +      <div className="setup-container">
 +        <div className="spinner" />
 +      </div>
 +    );
 +  }
++
 +  // Show setup if not initialized
 +  if (!initStatus?.initialized) {
 +    return (
 +      <Routes>
 +        <Route path="*" element={<SetupView onComplete={() => checkInit()} />} />
 +      </Routes>
 +    );
 +  }
++
 +  return (
 +    <div className="app">
 +      <aside className="sidebar">
 +        <div className="sidebar-header">
 +          <h1>WANDA</h1>
 +          <p>WeMod on Linux</p>
 +        </div>
 +        <nav>
 +          <ul className="nav-list">
 +            <li className="nav-item">
 +              <NavLink
 +                to="/"
 +                className={({ isActive }) => `nav-link ${isActive ? "active" : ""}`}
 +                end
 +              >
 +                Games
 +              </NavLink>
 +            </li>
 +            <li className="nav-item">
 +              <NavLink
 +                to="/prefixes"
 +                className={({ isActive }) => `nav-link ${isActive ? "active" : ""}`}
 +              >
 +                Prefixes
 +              </NavLink>
 +            </li>
 +            <li className="nav-item">
 +              <NavLink
 +                to="/settings"
 +                className={({ isActive }) => `nav-link ${isActive ? "active" : ""}`}
 +              >
 +                Settings
 +              </NavLink>
 +            </li>
 +          </ul>
 +        </nav>
 +      </aside>
 +      <main className="main-content">
 +        <Routes>
 +          <Route path="/" element={<GamesView />} />
 +          <Route path="/prefixes" element={<PrefixesView />} />
 +          <Route path="/settings" element={<SettingsView />} />
 +          <Route path="/setup" element={<SetupView onComplete={() => checkInit()} />} />
 +        </Routes>
 +      </main>
 +    </div>
 +  );
 +}
++
 +export default App;

crates/wanda-gui/frontend/src/components/GameCard.tsxadded

 +import type { GameInfo } from "../types";
++
 +interface Props {
 +  game: GameInfo;
 +  onLaunch: (appId: number, withWemod: boolean) => void;
 +  launching: boolean;
 +}
++
 +export default function GameCard({ game, onLaunch, launching }: Props) {
 +  return (
 +    <div className="game-card">
 +      <h3 className="game-name" title={game.name}>
 +        {game.name}
 +      </h3>
 +      <div className="game-meta">
 +        <span>App ID: {game.app_id}</span>
 +        <span>{game.size}</span>
 +      </div>
 +      <div className="game-actions">
 +        <button
 +          className="btn btn-primary btn-small"
 +          onClick={() => onLaunch(game.app_id, true)}
 +          disabled={launching}
 +        >
 +          {launching ? "Launching..." : "Launch with WeMod"}
 +        </button>
 +        <button
 +          className="btn btn-secondary btn-small"
 +          onClick={() => onLaunch(game.app_id, false)}
 +          disabled={launching}
 +        >
 +          Launch
 +        </button>
 +      </div>
 +    </div>
 +  );
 +}

crates/wanda-gui/frontend/src/hooks/useApi.tsadded

 +import { invoke } from "@tauri-apps/api/core";
 +import type {
 +  GameInfo,
 +  PrefixInfo,
 +  ProtonInfo,
 +  WemodStatus,
 +  InitStatus,
 +  DoctorReport,
 +  ConfigDto,
 +} from "../types";
++
 +// Game API
 +export async function getGames(): Promise<GameInfo[]> {
 +  return invoke("get_games");
 +}
++
 +export async function getGame(appId: number): Promise<GameInfo> {
 +  return invoke("get_game", { appId });
 +}
++
 +export async function launchGame(appId: number, withWemod: boolean): Promise<void> {
 +  return invoke("launch_game", { appId, withWemod });
 +}
++
 +// Prefix API
 +export async function getPrefixes(): Promise<PrefixInfo[]> {
 +  return invoke("get_prefixes");
 +}
++
 +export async function getPrefixHealth(name: string): Promise<PrefixInfo> {
 +  return invoke("get_prefix_health", { name });
 +}
++
 +export async function repairPrefix(name: string): Promise<void> {
 +  return invoke("repair_prefix", { name });
 +}
++
 +// Init API
 +export async function getInitStatus(): Promise<InitStatus> {
 +  return invoke("get_init_status");
 +}
++
 +export async function initWanda(): Promise<void> {
 +  return invoke("init_wanda");
 +}
++
 +// Config API
 +export async function getConfig(): Promise<ConfigDto> {
 +  return invoke("get_config");
 +}
++
 +export async function updateConfig(config: ConfigDto): Promise<void> {
 +  return invoke("update_config", { configDto: config });
 +}
++
 +// WeMod API
 +export async function getWemodStatus(): Promise<WemodStatus> {
 +  return invoke("get_wemod_status");
 +}
++
 +export async function updateWemod(): Promise<void> {
 +  return invoke("update_wemod");
 +}
++
 +// Proton API
 +export async function getProtonVersions(): Promise<ProtonInfo[]> {
 +  return invoke("get_proton_versions");
 +}
++
 +// Doctor API
 +export async function runDoctor(): Promise<DoctorReport> {
 +  return invoke("run_doctor");
 +}

crates/wanda-gui/frontend/src/main.tsxadded

 +import React from "react";
 +import ReactDOM from "react-dom/client";
 +import { BrowserRouter } from "react-router-dom";
 +import App from "./App";
 +import "./styles.css";
++
 +ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
 +  <React.StrictMode>
 +    <BrowserRouter>
 +      <App />
 +    </BrowserRouter>
 +  </React.StrictMode>
 +);

crates/wanda-gui/frontend/src/styles.cssadded

 +:root {
 +  --bg-primary: #1a1a2e;
 +  --bg-secondary: #16213e;
 +  --bg-card: #0f3460;
 +  --accent: #e94560;
 +  --accent-hover: #ff6b6b;
 +  --text-primary: #eaeaea;
 +  --text-secondary: #a0a0a0;
 +  --success: #4ade80;
 +  --warning: #fbbf24;
 +  --error: #f87171;
 +  --border: #2a2a4e;
 +}
++
 +* {
 +  margin: 0;
 +  padding: 0;
 +  box-sizing: border-box;
 +}
++
 +body {
 +  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
 +  background-color: var(--bg-primary);
 +  color: var(--text-primary);
 +  min-height: 100vh;
 +  line-height: 1.6;
 +}
++
 +/* Layout */
 +.app {
 +  display: flex;
 +  min-height: 100vh;
 +}
++
 +.sidebar {
 +  width: 220px;
 +  background-color: var(--bg-secondary);
 +  padding: 20px;
 +  border-right: 1px solid var(--border);
 +  display: flex;
 +  flex-direction: column;
 +}
++
 +.sidebar-header {
 +  margin-bottom: 30px;
 +}
++
 +.sidebar-header h1 {
 +  font-size: 1.5rem;
 +  color: var(--accent);
 +  font-weight: 700;
 +}
++
 +.sidebar-header p {
 +  font-size: 0.75rem;
 +  color: var(--text-secondary);
 +}
++
 +.nav-list {
 +  list-style: none;
 +  flex: 1;
 +}
++
 +.nav-item {
 +  margin-bottom: 5px;
 +}
++
 +.nav-link {
 +  display: block;
 +  padding: 12px 15px;
 +  color: var(--text-secondary);
 +  text-decoration: none;
 +  border-radius: 8px;
 +  transition: all 0.2s;
 +}
++
 +.nav-link:hover {
 +  background-color: var(--bg-card);
 +  color: var(--text-primary);
 +}
++
 +.nav-link.active {
 +  background-color: var(--accent);
 +  color: white;
 +}
++
 +.main-content {
 +  flex: 1;
 +  padding: 30px;
 +  overflow-y: auto;
 +}
++
 +/* Cards */
 +.card {
 +  background-color: var(--bg-card);
 +  border-radius: 12px;
 +  padding: 20px;
 +  margin-bottom: 20px;
 +}
++
 +.card-header {
 +  display: flex;
 +  justify-content: space-between;
 +  align-items: center;
 +  margin-bottom: 15px;
 +}
++
 +.card-title {
 +  font-size: 1.1rem;
 +  font-weight: 600;
 +}
++
 +/* Buttons */
 +.btn {
 +  display: inline-flex;
 +  align-items: center;
 +  gap: 8px;
 +  padding: 10px 20px;
 +  border: none;
 +  border-radius: 8px;
 +  font-size: 0.9rem;
 +  font-weight: 500;
 +  cursor: pointer;
 +  transition: all 0.2s;
 +}
++
 +.btn-primary {
 +  background-color: var(--accent);
 +  color: white;
 +}
++
 +.btn-primary:hover {
 +  background-color: var(--accent-hover);
 +}
++
 +.btn-secondary {
 +  background-color: var(--bg-secondary);
 +  color: var(--text-primary);
 +  border: 1px solid var(--border);
 +}
++
 +.btn-secondary:hover {
 +  background-color: var(--bg-card);
 +}
++
 +.btn-small {
 +  padding: 6px 12px;
 +  font-size: 0.8rem;
 +}
++
 +.btn:disabled {
 +  opacity: 0.5;
 +  cursor: not-allowed;
 +}
++
 +/* Game Grid */
 +.game-grid {
 +  display: grid;
 +  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
 +  gap: 20px;
 +}
++
 +.game-card {
 +  background-color: var(--bg-card);
 +  border-radius: 12px;
 +  padding: 20px;
 +  transition: transform 0.2s, box-shadow 0.2s;
 +  cursor: pointer;
 +}
++
 +.game-card:hover {
 +  transform: translateY(-2px);
 +  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
 +}
++
 +.game-name {
 +  font-size: 1rem;
 +  font-weight: 600;
 +  margin-bottom: 8px;
 +  white-space: nowrap;
 +  overflow: hidden;
 +  text-overflow: ellipsis;
 +}
++
 +.game-meta {
 +  display: flex;
 +  justify-content: space-between;
 +  align-items: center;
 +  font-size: 0.8rem;
 +  color: var(--text-secondary);
 +  margin-bottom: 15px;
 +}
++
 +.game-actions {
 +  display: flex;
 +  gap: 10px;
 +}
++
 +/* Status badges */
 +.badge {
 +  display: inline-block;
 +  padding: 4px 10px;
 +  border-radius: 20px;
 +  font-size: 0.75rem;
 +  font-weight: 500;
 +}
++
 +.badge-success {
 +  background-color: rgba(74, 222, 128, 0.2);
 +  color: var(--success);
 +}
++
 +.badge-warning {
 +  background-color: rgba(251, 191, 36, 0.2);
 +  color: var(--warning);
 +}
++
 +.badge-error {
 +  background-color: rgba(248, 113, 113, 0.2);
 +  color: var(--error);
 +}
++
 +/* Forms */
 +.form-group {
 +  margin-bottom: 20px;
 +}
++
 +.form-label {
 +  display: block;
 +  margin-bottom: 8px;
 +  font-size: 0.9rem;
 +  color: var(--text-secondary);
 +}
++
 +.form-input {
 +  width: 100%;
 +  padding: 12px;
 +  background-color: var(--bg-secondary);
 +  border: 1px solid var(--border);
 +  border-radius: 8px;
 +  color: var(--text-primary);
 +  font-size: 0.9rem;
 +}
++
 +.form-input:focus {
 +  outline: none;
 +  border-color: var(--accent);
 +}
++
 +.form-checkbox {
 +  display: flex;
 +  align-items: center;
 +  gap: 10px;
 +}
++
 +.form-checkbox input {
 +  width: 18px;
 +  height: 18px;
 +  accent-color: var(--accent);
 +}
++
 +/* Setup screen */
 +.setup-container {
 +  display: flex;
 +  justify-content: center;
 +  align-items: center;
 +  min-height: 100vh;
 +  padding: 20px;
 +}
++
 +.setup-card {
 +  max-width: 500px;
 +  width: 100%;
 +  background-color: var(--bg-card);
 +  border-radius: 16px;
 +  padding: 40px;
 +  text-align: center;
 +}
++
 +.setup-icon {
 +  font-size: 4rem;
 +  margin-bottom: 20px;
 +}
++
 +.setup-title {
 +  font-size: 1.5rem;
 +  margin-bottom: 10px;
 +}
++
 +.setup-description {
 +  color: var(--text-secondary);
 +  margin-bottom: 30px;
 +}
++
 +.setup-steps {
 +  text-align: left;
 +  margin-bottom: 30px;
 +}
++
 +.setup-step {
 +  display: flex;
 +  align-items: center;
 +  gap: 15px;
 +  padding: 15px;
 +  background-color: var(--bg-secondary);
 +  border-radius: 8px;
 +  margin-bottom: 10px;
 +}
++
 +.step-icon {
 +  width: 30px;
 +  height: 30px;
 +  border-radius: 50%;
 +  display: flex;
 +  align-items: center;
 +  justify-content: center;
 +  font-size: 0.8rem;
 +  font-weight: 600;
 +}
++
 +.step-icon.pending {
 +  background-color: var(--border);
 +  color: var(--text-secondary);
 +}
++
 +.step-icon.done {
 +  background-color: var(--success);
 +  color: var(--bg-primary);
 +}
++
 +.step-icon.error {
 +  background-color: var(--error);
 +  color: white;
 +}
++
 +/* Loading spinner */
 +.spinner {
 +  width: 40px;
 +  height: 40px;
 +  border: 3px solid var(--border);
 +  border-top-color: var(--accent);
 +  border-radius: 50%;
 +  animation: spin 1s linear infinite;
 +}
++
 +@keyframes spin {
 +  to {
 +    transform: rotate(360deg);
 +  }
 +}
++
 +/* Page header */
 +.page-header {
 +  display: flex;
 +  justify-content: space-between;
 +  align-items: center;
 +  margin-bottom: 30px;
 +}
++
 +.page-title {
 +  font-size: 1.5rem;
 +  font-weight: 600;
 +}
++
 +/* Prefix list */
 +.prefix-list {
 +  display: flex;
 +  flex-direction: column;
 +  gap: 15px;
 +}
++
 +.prefix-item {
 +  display: flex;
 +  justify-content: space-between;
 +  align-items: center;
 +  padding: 20px;
 +  background-color: var(--bg-card);
 +  border-radius: 12px;
 +}
++
 +.prefix-info h3 {
 +  font-size: 1rem;
 +  margin-bottom: 5px;
 +}
++
 +.prefix-info p {
 +  font-size: 0.8rem;
 +  color: var(--text-secondary);
 +}
++
 +/* Doctor report */
 +.doctor-section {
 +  margin-bottom: 20px;
 +}
++
 +.doctor-item {
 +  display: flex;
 +  align-items: center;
 +  gap: 15px;
 +  padding: 15px;
 +  background-color: var(--bg-secondary);
 +  border-radius: 8px;
 +  margin-bottom: 10px;
 +}
++
 +.doctor-status {
 +  width: 12px;
 +  height: 12px;
 +  border-radius: 50%;
 +}
++
 +.doctor-status.ok {
 +  background-color: var(--success);
 +}
++
 +.doctor-status.error {
 +  background-color: var(--error);
 +}
++
 +/* Responsive */
 +@media (max-width: 768px) {
 +  .app {
 +    flex-direction: column;
 +  }
++
 +  .sidebar {
 +    width: 100%;
 +    border-right: none;
 +    border-bottom: 1px solid var(--border);
 +  }
++
 +  .nav-list {
 +    display: flex;
 +    gap: 10px;
 +    overflow-x: auto;
 +  }
++
 +  .game-grid {
 +    grid-template-columns: 1fr;
 +  }
 +}

crates/wanda-gui/frontend/src/types/index.tsadded

 +// Types matching Rust DTOs
++
 +export interface GameInfo {
 +  app_id: number;
 +  name: string;
 +  size: string;
 +  uses_proton: boolean;
 +  install_path: string;
 +}
++
 +export interface PrefixInfo {
 +  name: string;
 +  path: string;
 +  wemod_installed: boolean;
 +  wemod_version: string | null;
 +  proton_version: string | null;
 +  health: "healthy" | "needs_repair" | "corrupted" | "not_created";
 +  issues: string[];
 +}
++
 +export interface ProtonInfo {
 +  name: string;
 +  path: string;
 +  compatibility: "recommended" | "supported" | "experimental" | "unsupported";
 +  is_ge: boolean;
 +  is_recommended: boolean;
 +}
++
 +export interface WemodStatus {
 +  installed: boolean;
 +  version: string | null;
 +  update_available: boolean;
 +  latest_version: string | null;
 +}
++
 +export interface InitStatus {
 +  initialized: boolean;
 +  steam_found: boolean;
 +  proton_found: boolean;
 +  prefix_exists: boolean;
 +  wemod_installed: boolean;
 +}
++
 +export interface DoctorReport {
 +  steam_ok: boolean;
 +  steam_path: string | null;
 +  proton_ok: boolean;
 +  proton_count: number;
 +  prefix_ok: boolean;
 +  wemod_ok: boolean;
 +  issues: string[];
 +}
++
 +export interface ConfigDto {
 +  steam_path: string | null;
 +  scan_flatpak: boolean;
 +  preferred_proton: string | null;
 +  auto_update_wemod: boolean;
 +}

crates/wanda-gui/frontend/src/views/GamesView.tsxadded

 +import { useState, useEffect } from "react";
 +import { getGames, launchGame } from "../hooks/useApi";
 +import type { GameInfo } from "../types";
 +import GameCard from "../components/GameCard";
++
 +export default function GamesView() {
 +  const [games, setGames] = useState<GameInfo[]>([]);
 +  const [loading, setLoading] = useState(true);
 +  const [error, setError] = useState<string | null>(null);
 +  const [search, setSearch] = useState("");
 +  const [launching, setLaunching] = useState<number | null>(null);
++
 +  useEffect(() => {
 +    loadGames();
 +  }, []);
++
 +  async function loadGames() {
 +    try {
 +      setLoading(true);
 +      const gamesList = await getGames();
 +      // Sort by name
 +      gamesList.sort((a, b) => a.name.localeCompare(b.name));
 +      setGames(gamesList);
 +    } catch (err) {
 +      setError(String(err));
 +    } finally {
 +      setLoading(false);
 +    }
 +  }
++
 +  async function handleLaunch(appId: number, withWemod: boolean) {
 +    setLaunching(appId);
 +    try {
 +      await launchGame(appId, withWemod);
 +    } catch (err) {
 +      setError(String(err));
 +    } finally {
 +      setLaunching(null);
 +    }
 +  }
++
 +  const filteredGames = games.filter((game) =>
 +    game.name.toLowerCase().includes(search.toLowerCase())
 +  );
++
 +  if (loading) {
 +    return (
 +      <div>
 +        <div className="page-header">
 +          <h1 className="page-title">Games</h1>
 +        </div>
 +        <div style={{ textAlign: "center", padding: "50px" }}>
 +          <div className="spinner" style={{ margin: "0 auto" }} />
 +          <p style={{ marginTop: "20px", color: "var(--text-secondary)" }}>Loading games...</p>
 +        </div>
 +      </div>
 +    );
 +  }
++
 +  return (
 +    <div>
 +      <div className="page-header">
 +        <h1 className="page-title">Games</h1>
 +        <button className="btn btn-secondary" onClick={loadGames}>
 +          Refresh
 +        </button>
 +      </div>
++
 +      {error && (
 +        <div
 +          className="card"
 +          style={{ backgroundColor: "rgba(248, 113, 113, 0.1)", marginBottom: "20px" }}
 +        >
 +          <p style={{ color: "var(--error)" }}>{error}</p>
 +        </div>
 +      )}
++
 +      <div className="form-group">
 +        <input
 +          type="text"
 +          className="form-input"
 +          placeholder="Search games..."
 +          value={search}
 +          onChange={(e) => setSearch(e.target.value)}
 +        />
 +      </div>
++
 +      {filteredGames.length === 0 ? (
 +        <div className="card" style={{ textAlign: "center" }}>
 +          <p style={{ color: "var(--text-secondary)" }}>
 +            {search ? "No games match your search" : "No Proton games found"}
 +          </p>
 +        </div>
 +      ) : (
 +        <div className="game-grid">
 +          {filteredGames.map((game) => (
 +            <GameCard
 +              key={game.app_id}
 +              game={game}
 +              onLaunch={handleLaunch}
 +              launching={launching === game.app_id}
 +            />
 +          ))}
 +        </div>
 +      )}
++
 +      <p
 +        style={{
 +          marginTop: "20px",
 +          fontSize: "0.8rem",
 +          color: "var(--text-secondary)",
 +          textAlign: "center",
 +        }}
 +      >
 +        Showing {filteredGames.length} of {games.length} Proton games
 +      </p>
 +    </div>
 +  );
 +}

crates/wanda-gui/frontend/src/views/PrefixesView.tsxadded

 +import { useState, useEffect } from "react";
 +import { getPrefixes, repairPrefix, getWemodStatus, updateWemod } from "../hooks/useApi";
 +import type { PrefixInfo, WemodStatus } from "../types";
++
 +export default function PrefixesView() {
 +  const [prefixes, setPrefixes] = useState<PrefixInfo[]>([]);
 +  const [wemodStatus, setWemodStatus] = useState<WemodStatus | null>(null);
 +  const [loading, setLoading] = useState(true);
 +  const [repairing, setRepairing] = useState<string | null>(null);
 +  const [updating, setUpdating] = useState(false);
 +  const [error, setError] = useState<string | null>(null);
++
 +  useEffect(() => {
 +    loadData();
 +  }, []);
++
 +  async function loadData() {
 +    try {
 +      setLoading(true);
 +      const [prefixList, wemod] = await Promise.all([getPrefixes(), getWemodStatus()]);
 +      setPrefixes(prefixList);
 +      setWemodStatus(wemod);
 +    } catch (err) {
 +      setError(String(err));
 +    } finally {
 +      setLoading(false);
 +    }
 +  }
++
 +  async function handleRepair(name: string) {
 +    setRepairing(name);
 +    try {
 +      await repairPrefix(name);
 +      await loadData();
 +    } catch (err) {
 +      setError(String(err));
 +    } finally {
 +      setRepairing(null);
 +    }
 +  }
++
 +  async function handleUpdateWemod() {
 +    setUpdating(true);
 +    try {
 +      await updateWemod();
 +      await loadData();
 +    } catch (err) {
 +      setError(String(err));
 +    } finally {
 +      setUpdating(false);
 +    }
 +  }
++
 +  function getHealthBadge(health: string) {
 +    switch (health) {
 +      case "healthy":
 +        return <span className="badge badge-success">Healthy</span>;
 +      case "needs_repair":
 +        return <span className="badge badge-warning">Needs Repair</span>;
 +      case "corrupted":
 +        return <span className="badge badge-error">Corrupted</span>;
 +      default:
 +        return <span className="badge">Unknown</span>;
 +    }
 +  }
++
 +  if (loading) {
 +    return (
 +      <div>
 +        <div className="page-header">
 +          <h1 className="page-title">Prefixes</h1>
 +        </div>
 +        <div style={{ textAlign: "center", padding: "50px" }}>
 +          <div className="spinner" style={{ margin: "0 auto" }} />
 +        </div>
 +      </div>
 +    );
 +  }
++
 +  return (
 +    <div>
 +      <div className="page-header">
 +        <h1 className="page-title">Prefixes</h1>
 +      </div>
++
 +      {error && (
 +        <div
 +          className="card"
 +          style={{ backgroundColor: "rgba(248, 113, 113, 0.1)", marginBottom: "20px" }}
 +        >
 +          <p style={{ color: "var(--error)" }}>{error}</p>
 +        </div>
 +      )}
++
 +      {/* WeMod Status */}
 +      <div className="card">
 +        <div className="card-header">
 +          <h2 className="card-title">WeMod Status</h2>
 +          {wemodStatus?.update_available && (
 +            <button
 +              className="btn btn-primary btn-small"
 +              onClick={handleUpdateWemod}
 +              disabled={updating}
 +            >
 +              {updating ? "Updating..." : `Update to ${wemodStatus.latest_version}`}
 +            </button>
 +          )}
 +        </div>
 +        {wemodStatus ? (
 +          <div>
 +            <p>
 +              <strong>Installed:</strong>{" "}
 +              {wemodStatus.installed ? (
 +                <span style={{ color: "var(--success)" }}>Yes</span>
 +              ) : (
 +                <span style={{ color: "var(--error)" }}>No</span>
 +              )}
 +            </p>
 +            {wemodStatus.version && (
 +              <p>
 +                <strong>Version:</strong> {wemodStatus.version}
 +              </p>
 +            )}
 +            {wemodStatus.update_available && (
 +              <p style={{ color: "var(--warning)" }}>
 +                Update available: {wemodStatus.latest_version}
 +              </p>
 +            )}
 +          </div>
 +        ) : (
 +          <p style={{ color: "var(--text-secondary)" }}>Loading...</p>
 +        )}
 +      </div>
++
 +      {/* Prefix List */}
 +      <h2 className="card-title" style={{ marginBottom: "15px" }}>
 +        Wine Prefixes
 +      </h2>
++
 +      {prefixes.length === 0 ? (
 +        <div className="card">
 +          <p style={{ color: "var(--text-secondary)" }}>No prefixes found</p>
 +        </div>
 +      ) : (
 +        <div className="prefix-list">
 +          {prefixes.map((prefix) => (
 +            <div key={prefix.name} className="prefix-item">
 +              <div className="prefix-info">
 +                <h3>
 +                  {prefix.name} {getHealthBadge(prefix.health)}
 +                </h3>
 +                <p>{prefix.path}</p>
 +                {prefix.proton_version && (
 +                  <p>
 +                    <small>Proton: {prefix.proton_version}</small>
 +                  </p>
 +                )}
 +                {prefix.wemod_installed && prefix.wemod_version && (
 +                  <p>
 +                    <small>WeMod: {prefix.wemod_version}</small>
 +                  </p>
 +                )}
 +                {prefix.issues.length > 0 && (
 +                  <ul style={{ marginTop: "10px", color: "var(--warning)", fontSize: "0.8rem" }}>
 +                    {prefix.issues.map((issue, i) => (
 +                      <li key={i}>{issue}</li>
 +                    ))}
 +                  </ul>
 +                )}
 +              </div>
 +              <div>
 +                {prefix.health === "needs_repair" && (
 +                  <button
 +                    className="btn btn-secondary btn-small"
 +                    onClick={() => handleRepair(prefix.name)}
 +                    disabled={repairing === prefix.name}
 +                  >
 +                    {repairing === prefix.name ? "Repairing..." : "Repair"}
 +                  </button>
 +                )}
 +              </div>
 +            </div>
 +          ))}
 +        </div>
 +      )}
 +    </div>
 +  );
 +}

crates/wanda-gui/frontend/src/views/SettingsView.tsxadded

 +import { useState, useEffect } from "react";
 +import { getConfig, updateConfig, getProtonVersions, runDoctor } from "../hooks/useApi";
 +import type { ConfigDto, ProtonInfo, DoctorReport } from "../types";
++
 +export default function SettingsView() {
 +  const [config, setConfig] = useState<ConfigDto | null>(null);
 +  const [protonVersions, setProtonVersions] = useState<ProtonInfo[]>([]);
 +  const [doctor, setDoctor] = useState<DoctorReport | null>(null);
 +  const [loading, setLoading] = useState(true);
 +  const [saving, setSaving] = useState(false);
 +  const [runningDoctor, setRunningDoctor] = useState(false);
 +  const [error, setError] = useState<string | null>(null);
 +  const [success, setSuccess] = useState<string | null>(null);
++
 +  useEffect(() => {
 +    loadData();
 +  }, []);
++
 +  async function loadData() {
 +    try {
 +      setLoading(true);
 +      const [cfg, proton] = await Promise.all([getConfig(), getProtonVersions()]);
 +      setConfig(cfg);
 +      setProtonVersions(proton);
 +    } catch (err) {
 +      setError(String(err));
 +    } finally {
 +      setLoading(false);
 +    }
 +  }
++
 +  async function handleSave() {
 +    if (!config) return;
++
 +    setSaving(true);
 +    setError(null);
 +    setSuccess(null);
++
 +    try {
 +      await updateConfig(config);
 +      setSuccess("Settings saved successfully!");
 +      setTimeout(() => setSuccess(null), 3000);
 +    } catch (err) {
 +      setError(String(err));
 +    } finally {
 +      setSaving(false);
 +    }
 +  }
++
 +  async function handleRunDoctor() {
 +    setRunningDoctor(true);
 +    try {
 +      const report = await runDoctor();
 +      setDoctor(report);
 +    } catch (err) {
 +      setError(String(err));
 +    } finally {
 +      setRunningDoctor(false);
 +    }
 +  }
++
 +  if (loading || !config) {
 +    return (
 +      <div>
 +        <div className="page-header">
 +          <h1 className="page-title">Settings</h1>
 +        </div>
 +        <div style={{ textAlign: "center", padding: "50px" }}>
 +          <div className="spinner" style={{ margin: "0 auto" }} />
 +        </div>
 +      </div>
 +    );
 +  }
++
 +  return (
 +    <div>
 +      <div className="page-header">
 +        <h1 className="page-title">Settings</h1>
 +      </div>
++
 +      {error && (
 +        <div
 +          className="card"
 +          style={{ backgroundColor: "rgba(248, 113, 113, 0.1)", marginBottom: "20px" }}
 +        >
 +          <p style={{ color: "var(--error)" }}>{error}</p>
 +        </div>
 +      )}
++
 +      {success && (
 +        <div
 +          className="card"
 +          style={{ backgroundColor: "rgba(74, 222, 128, 0.1)", marginBottom: "20px" }}
 +        >
 +          <p style={{ color: "var(--success)" }}>{success}</p>
 +        </div>
 +      )}
++
 +      {/* Steam Settings */}
 +      <div className="card">
 +        <h2 className="card-title" style={{ marginBottom: "20px" }}>
 +          Steam
 +        </h2>
++
 +        <div className="form-group">
 +          <label className="form-label">Steam Installation Path (leave empty for auto-detect)</label>
 +          <input
 +            type="text"
 +            className="form-input"
 +            value={config.steam_path || ""}
 +            onChange={(e) => setConfig({ ...config, steam_path: e.target.value || null })}
 +            placeholder="Auto-detect"
 +          />
 +        </div>
++
 +        <div className="form-group">
 +          <label className="form-checkbox">
 +            <input
 +              type="checkbox"
 +              checked={config.scan_flatpak}
 +              onChange={(e) => setConfig({ ...config, scan_flatpak: e.target.checked })}
 +            />
 +            <span>Scan Flatpak Steam installation</span>
 +          </label>
 +        </div>
 +      </div>
++
 +      {/* Proton Settings */}
 +      <div className="card">
 +        <h2 className="card-title" style={{ marginBottom: "20px" }}>
 +          Proton
 +        </h2>
++
 +        <div className="form-group">
 +          <label className="form-label">Preferred Proton Version</label>
 +          <select
 +            className="form-input"
 +            value={config.preferred_proton || ""}
 +            onChange={(e) => setConfig({ ...config, preferred_proton: e.target.value || null })}
 +          >
 +            <option value="">Auto (Recommended)</option>
 +            {protonVersions.map((v) => (
 +              <option key={v.name} value={v.name}>
 +                {v.name}{" "}
 +                {v.compatibility === "recommended"
 +                  ? "(Recommended)"
 +                  : v.compatibility === "unsupported"
 +                  ? "(Unsupported)"
 +                  : ""}
 +              </option>
 +            ))}
 +          </select>
 +        </div>
++
 +        {protonVersions.length > 0 && (
 +          <div style={{ marginTop: "15px" }}>
 +            <p style={{ fontSize: "0.8rem", color: "var(--text-secondary)", marginBottom: "10px" }}>
 +              Available Proton versions:
 +            </p>
 +            <div style={{ display: "flex", flexWrap: "wrap", gap: "8px" }}>
 +              {protonVersions.map((v) => (
 +                <span
 +                  key={v.name}
 +                  className={`badge ${
 +                    v.compatibility === "recommended"
 +                      ? "badge-success"
 +                      : v.compatibility === "supported"
 +                      ? "badge-success"
 +                      : v.compatibility === "experimental"
 +                      ? "badge-warning"
 +                      : "badge-error"
 +                  }`}
 +                >
 +                  {v.name}
 +                </span>
 +              ))}
 +            </div>
 +          </div>
 +        )}
 +      </div>
++
 +      {/* WeMod Settings */}
 +      <div className="card">
 +        <h2 className="card-title" style={{ marginBottom: "20px" }}>
 +          WeMod
 +        </h2>
++
 +        <div className="form-group">
 +          <label className="form-checkbox">
 +            <input
 +              type="checkbox"
 +              checked={config.auto_update_wemod}
 +              onChange={(e) => setConfig({ ...config, auto_update_wemod: e.target.checked })}
 +            />
 +            <span>Automatically update WeMod</span>
 +          </label>
 +        </div>
 +      </div>
++
 +      <button className="btn btn-primary" onClick={handleSave} disabled={saving}>
 +        {saving ? "Saving..." : "Save Settings"}
 +      </button>
++
 +      {/* Diagnostics */}
 +      <div className="card" style={{ marginTop: "30px" }}>
 +        <div className="card-header">
 +          <h2 className="card-title">Diagnostics</h2>
 +          <button
 +            className="btn btn-secondary btn-small"
 +            onClick={handleRunDoctor}
 +            disabled={runningDoctor}
 +          >
 +            {runningDoctor ? "Running..." : "Run Doctor"}
 +          </button>
 +        </div>
++
 +        {doctor && (
 +          <div className="doctor-section">
 +            <div className="doctor-item">
 +              <span className={`doctor-status ${doctor.steam_ok ? "ok" : "error"}`} />
 +              <span>
 +                Steam: {doctor.steam_ok ? `Found at ${doctor.steam_path}` : "Not found"}
 +              </span>
 +            </div>
 +            <div className="doctor-item">
 +              <span className={`doctor-status ${doctor.proton_ok ? "ok" : "error"}`} />
 +              <span>
 +                Proton: {doctor.proton_ok ? `${doctor.proton_count} versions found` : "Not found"}
 +              </span>
 +            </div>
 +            <div className="doctor-item">
 +              <span className={`doctor-status ${doctor.prefix_ok ? "ok" : "error"}`} />
 +              <span>Prefix: {doctor.prefix_ok ? "OK" : "Not initialized"}</span>
 +            </div>
 +            <div className="doctor-item">
 +              <span className={`doctor-status ${doctor.wemod_ok ? "ok" : "error"}`} />
 +              <span>WeMod: {doctor.wemod_ok ? "Installed" : "Not installed"}</span>
 +            </div>
++
 +            {doctor.issues.length > 0 && (
 +              <div style={{ marginTop: "15px" }}>
 +                <p style={{ color: "var(--warning)", marginBottom: "10px" }}>Issues:</p>
 +                <ul style={{ paddingLeft: "20px" }}>
 +                  {doctor.issues.map((issue, i) => (
 +                    <li key={i} style={{ color: "var(--text-secondary)", fontSize: "0.9rem" }}>
 +                      {issue}
 +                    </li>
 +                  ))}
 +                </ul>
 +              </div>
 +            )}
 +          </div>
 +        )}
 +      </div>
 +    </div>
 +  );
 +}

crates/wanda-gui/frontend/src/views/SetupView.tsxadded

 +import { useState, useEffect } from "react";
 +import { initWanda, getInitStatus, runDoctor } from "../hooks/useApi";
 +import type { InitStatus, DoctorReport } from "../types";
++
 +interface Props {
 +  onComplete: () => void;
 +}
++
 +type SetupStep = "checking" | "ready" | "initializing" | "complete" | "error";
++
 +export default function SetupView({ onComplete }: Props) {
 +  const [step, setStep] = useState<SetupStep>("checking");
 +  const [status, setStatus] = useState<InitStatus | null>(null);
 +  const [doctor, setDoctor] = useState<DoctorReport | null>(null);
 +  const [error, setError] = useState<string | null>(null);
 +  const [progress, setProgress] = useState("");
++
 +  useEffect(() => {
 +    checkSystem();
 +  }, []);
++
 +  async function checkSystem() {
 +    try {
 +      const [initStatus, doctorReport] = await Promise.all([
 +        getInitStatus(),
 +        runDoctor(),
 +      ]);
 +      setStatus(initStatus);
 +      setDoctor(doctorReport);
++
 +      if (initStatus.initialized) {
 +        setStep("complete");
 +        onComplete();
 +      } else if (doctorReport.steam_ok && doctorReport.proton_ok) {
 +        setStep("ready");
 +      } else {
 +        setStep("error");
 +      }
 +    } catch (err) {
 +      setError(String(err));
 +      setStep("error");
 +    }
 +  }
++
 +  async function startSetup() {
 +    setStep("initializing");
 +    setProgress("Creating Wine prefix...");
++
 +    try {
 +      await initWanda();
 +      setStep("complete");
 +      setTimeout(onComplete, 1500);
 +    } catch (err) {
 +      setError(String(err));
 +      setStep("error");
 +    }
 +  }
++
 +  return (
 +    <div className="setup-container">
 +      <div className="setup-card">
 +        <div className="setup-icon">🪄</div>
 +        <h1 className="setup-title">Welcome to WANDA</h1>
 +        <p className="setup-description">
 +          Let's set up WeMod for Linux. This will create a Wine prefix and install WeMod.
 +        </p>
++
 +        {step === "checking" && (
 +          <>
 +            <div className="spinner" style={{ margin: "20px auto" }} />
 +            <p>Checking system requirements...</p>
 +          </>
 +        )}
++
 +        {step === "ready" && (
 +          <>
 +            <div className="setup-steps">
 +              <div className="setup-step">
 +                <span className={`step-icon ${status?.steam_found ? "done" : "error"}`}>
 +                  {status?.steam_found ? "✓" : "✕"}
 +                </span>
 +                <span>Steam detected{doctor?.steam_path ? ` at ${doctor.steam_path}` : ""}</span>
 +              </div>
 +              <div className="setup-step">
 +                <span className={`step-icon ${status?.proton_found ? "done" : "error"}`}>
 +                  {status?.proton_found ? "✓" : "✕"}
 +                </span>
 +                <span>
 +                  Proton found ({doctor?.proton_count || 0} version
 +                  {doctor?.proton_count !== 1 ? "s" : ""})
 +                </span>
 +              </div>
 +              <div className="setup-step">
 +                <span className="step-icon pending">3</span>
 +                <span>Create Wine prefix & install WeMod</span>
 +              </div>
 +            </div>
 +            <button className="btn btn-primary" onClick={startSetup}>
 +              Initialize WANDA
 +            </button>
 +          </>
 +        )}
++
 +        {step === "initializing" && (
 +          <>
 +            <div className="spinner" style={{ margin: "20px auto" }} />
 +            <p>{progress || "This may take several minutes..."}</p>
 +            <p style={{ fontSize: "0.8rem", color: "var(--text-secondary)", marginTop: "10px" }}>
 +              Installing .NET Framework and WeMod
 +            </p>
 +          </>
 +        )}
++
 +        {step === "complete" && (
 +          <>
 +            <div style={{ fontSize: "4rem", marginBottom: "20px" }}>✓</div>
 +            <p style={{ color: "var(--success)" }}>WANDA is ready!</p>
 +          </>
 +        )}
++
 +        {step === "error" && (
 +          <>
 +            <div style={{ fontSize: "4rem", marginBottom: "20px" }}>⚠️</div>
 +            <p style={{ color: "var(--error)", marginBottom: "20px" }}>
 +              {error || "Setup failed"}
 +            </p>
 +            {doctor?.issues && doctor.issues.length > 0 && (
 +              <div style={{ textAlign: "left", marginBottom: "20px" }}>
 +                <p style={{ marginBottom: "10px", color: "var(--text-secondary)" }}>Issues:</p>
 +                <ul style={{ listStyle: "disc", paddingLeft: "20px" }}>
 +                  {doctor.issues.map((issue, i) => (
 +                    <li key={i} style={{ color: "var(--error)", fontSize: "0.9rem" }}>
 +                      {issue}
 +                    </li>
 +                  ))}
 +                </ul>
 +              </div>
 +            )}
 +            <button className="btn btn-secondary" onClick={checkSystem}>
 +              Retry
 +            </button>
 +          </>
 +        )}
 +      </div>
 +    </div>
 +  );
 +}

crates/wanda-gui/frontend/tsconfig.jsonadded

 +{
 +  "compilerOptions": {
 +    "target": "ES2020",
 +    "useDefineForClassFields": true,
 +    "lib": ["ES2020", "DOM", "DOM.Iterable"],
 +    "module": "ESNext",
 +    "skipLibCheck": true,
 +    "moduleResolution": "bundler",
 +    "allowImportingTsExtensions": true,
 +    "isolatedModules": true,
 +    "moduleDetection": "force",
 +    "noEmit": true,
 +    "jsx": "react-jsx",
 +    "strict": true,
 +    "noUnusedLocals": true,
 +    "noUnusedParameters": true,
 +    "noFallthroughCasesInSwitch": true
 +  },
 +  "include": ["src"]
 +}

crates/wanda-gui/frontend/vite.config.tsadded

 +import { defineConfig } from "vite";
 +import react from "@vitejs/plugin-react";
++
 +export default defineConfig({
 +  plugins: [react()],
 +  clearScreen: false,
 +  server: {
 +    port: 5173,
 +    strictPort: true,
 +  },
 +  envPrefix: ["VITE_", "TAURI_"],
 +  build: {
 +    target: ["es2021", "chrome100", "safari13"],
 +    minify: !process.env.TAURI_DEBUG ? "esbuild" : false,
 +    sourcemap: !!process.env.TAURI_DEBUG,
 +  },
 +});

crates/wanda-gui/src/commands.rsadded

 +//! Tauri IPC commands
++
 +use crate::state::AppState;
 +use serde::{Deserialize, Serialize};
 +use std::sync::Arc;
 +use tauri::State;
 +use tokio::sync::Mutex;
 +use wanda_core::{
 +    config::WandaConfig,
 +    launcher::{GameLauncher, LaunchConfig},
 +    prefix::{PrefixHealth, PrefixIssue, PrefixManager},
 +    steam::{ProtonCompatibility, ProtonManager, SteamInstallation},
 +    wemod::{WemodDownloader, WemodInstaller},
 +};
++
 +// ============================================================================
 +// Data Transfer Objects
 +// ============================================================================
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct GameInfo {
 +    pub app_id: u32,
 +    pub name: String,
 +    pub size: String,
 +    pub uses_proton: bool,
 +    pub install_path: String,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct PrefixInfo {
 +    pub name: String,
 +    pub path: String,
 +    pub wemod_installed: bool,
 +    pub wemod_version: Option<String>,
 +    pub proton_version: Option<String>,
 +    pub health: String,
 +    pub issues: Vec<String>,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct ProtonInfo {
 +    pub name: String,
 +    pub path: String,
 +    pub compatibility: String,
 +    pub is_ge: bool,
 +    pub is_recommended: bool,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct WemodStatus {
 +    pub installed: bool,
 +    pub version: Option<String>,
 +    pub update_available: bool,
 +    pub latest_version: Option<String>,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct InitStatus {
 +    pub initialized: bool,
 +    pub steam_found: bool,
 +    pub proton_found: bool,
 +    pub prefix_exists: bool,
 +    pub wemod_installed: bool,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct DoctorReport {
 +    pub steam_ok: bool,
 +    pub steam_path: Option<String>,
 +    pub proton_ok: bool,
 +    pub proton_count: usize,
 +    pub prefix_ok: bool,
 +    pub wemod_ok: bool,
 +    pub issues: Vec<String>,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct ConfigDto {
 +    pub steam_path: Option<String>,
 +    pub scan_flatpak: bool,
 +    pub preferred_proton: Option<String>,
 +    pub auto_update_wemod: bool,
 +}
++
 +// ============================================================================
 +// Game Commands
 +// ============================================================================
++
 +#[tauri::command]
 +pub async fn get_games(state: State<'_, Arc<Mutex<AppState>>>) -> Result<Vec<GameInfo>, String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let steam = state.steam.as_ref().ok_or("Steam not loaded")?;
++
 +    let games: Vec<GameInfo> = steam
 +        .get_all_games()
 +        .iter()
 +        .filter(|g| g.uses_proton())
 +        .map(|g| GameInfo {
 +            app_id: g.app_id,
 +            name: g.name.clone(),
 +            size: g.size_human(),
 +            uses_proton: g.uses_proton(),
 +            install_path: g.install_path.to_string_lossy().to_string(),
 +        })
 +        .collect();
++
 +    Ok(games)
 +}
++
 +#[tauri::command]
 +pub async fn get_game(
 +    app_id: u32,
 +    state: State<'_, Arc<Mutex<AppState>>>,
 +) -> Result<GameInfo, String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let steam = state.steam.as_ref().ok_or("Steam not loaded")?;
 +    let game = steam
 +        .find_game(app_id)
 +        .ok_or_else(|| format!("Game {} not found", app_id))?;
++
 +    Ok(GameInfo {
 +        app_id: game.app_id,
 +        name: game.name.clone(),
 +        size: game.size_human(),
 +        uses_proton: game.uses_proton(),
 +        install_path: game.install_path.to_string_lossy().to_string(),
 +    })
 +}
++
 +#[tauri::command]
 +pub async fn launch_game(
 +    app_id: u32,
 +    with_wemod: bool,
 +    state: State<'_, Arc<Mutex<AppState>>>,
 +) -> Result<(), String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let steam = state.steam.as_ref().ok_or("Steam not loaded")?;
 +    let config = state.config.as_ref().ok_or("Config not loaded")?;
 +    let proton_mgr = state.proton.as_ref().ok_or("Proton not loaded")?;
 +    let prefix_mgr = state.prefix_manager.as_ref().ok_or("Prefix manager not loaded")?;
++
 +    let proton = proton_mgr
 +        .get_preferred(config)
 +        .map_err(|e| e.to_string())?;
++
 +    let prefix = prefix_mgr
 +        .get("default")
 +        .ok_or("WANDA not initialized")?;
++
 +    let launcher = GameLauncher::new(steam, prefix, proton);
++
 +    let launch_config = LaunchConfig {
 +        app_id,
 +        with_wemod,
 +        wemod_delay: 3,
 +        ..Default::default()
 +    };
++
 +    launcher.launch(launch_config).await.map_err(|e| e.to_string())?;
++
 +    Ok(())
 +}
++
 +// ============================================================================
 +// Prefix Commands
 +// ============================================================================
++
 +#[tauri::command]
 +pub async fn get_prefixes(state: State<'_, Arc<Mutex<AppState>>>) -> Result<Vec<PrefixInfo>, String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let prefix_mgr = state.prefix_manager.as_ref().ok_or("Prefix manager not loaded")?;
++
 +    let prefixes: Vec<PrefixInfo> = prefix_mgr
 +        .list()
 +        .iter()
 +        .map(|p| {
 +            let health = prefix_mgr.validate(&p.name).unwrap_or(PrefixHealth::NotCreated);
 +            let (health_str, issues) = match &health {
 +                PrefixHealth::Healthy => ("healthy".to_string(), vec![]),
 +                PrefixHealth::NeedsRepair(issues) => (
 +                    "needs_repair".to_string(),
 +                    issues.iter().map(|i| i.to_string()).collect(),
 +                ),
 +                PrefixHealth::Corrupted(reason) => ("corrupted".to_string(), vec![reason.clone()]),
 +                PrefixHealth::NotCreated => ("not_created".to_string(), vec![]),
 +            };
++
 +            PrefixInfo {
 +                name: p.name.clone(),
 +                path: p.path.to_string_lossy().to_string(),
 +                wemod_installed: p.wemod_installed,
 +                wemod_version: p.wemod_version.clone(),
 +                proton_version: p.proton_version.clone(),
 +                health: health_str,
 +                issues,
 +            }
 +        })
 +        .collect();
++
 +    Ok(prefixes)
 +}
++
 +#[tauri::command]
 +pub async fn get_prefix_health(
 +    name: String,
 +    state: State<'_, Arc<Mutex<AppState>>>,
 +) -> Result<PrefixInfo, String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let prefix_mgr = state.prefix_manager.as_ref().ok_or("Prefix manager not loaded")?;
++
 +    let prefix = prefix_mgr.get(&name).ok_or("Prefix not found")?;
 +    let health = prefix_mgr.validate(&name).map_err(|e| e.to_string())?;
++
 +    let (health_str, issues) = match &health {
 +        PrefixHealth::Healthy => ("healthy".to_string(), vec![]),
 +        PrefixHealth::NeedsRepair(issues) => (
 +            "needs_repair".to_string(),
 +            issues.iter().map(|i| i.to_string()).collect(),
 +        ),
 +        PrefixHealth::Corrupted(reason) => ("corrupted".to_string(), vec![reason.clone()]),
 +        PrefixHealth::NotCreated => ("not_created".to_string(), vec![]),
 +    };
++
 +    Ok(PrefixInfo {
 +        name: prefix.name.clone(),
 +        path: prefix.path.to_string_lossy().to_string(),
 +        wemod_installed: prefix.wemod_installed,
 +        wemod_version: prefix.wemod_version.clone(),
 +        proton_version: prefix.proton_version.clone(),
 +        health: health_str,
 +        issues,
 +    })
 +}
++
 +#[tauri::command]
 +pub async fn repair_prefix(
 +    name: String,
 +    state: State<'_, Arc<Mutex<AppState>>>,
 +) -> Result<(), String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let config = state.config.as_ref().ok_or("Config not loaded")?;
 +    let proton_mgr = state.proton.as_ref().ok_or("Proton not loaded")?;
 +    let prefix_mgr = state.prefix_manager.as_mut().ok_or("Prefix manager not loaded")?;
++
 +    let proton = proton_mgr
 +        .get_preferred(config)
 +        .map_err(|e| e.to_string())?;
++
 +    prefix_mgr.repair(&name, proton).await.map_err(|e| e.to_string())?;
++
 +    Ok(())
 +}
++
 +// ============================================================================
 +// Initialization Commands
 +// ============================================================================
++
 +#[tauri::command]
 +pub async fn get_init_status(state: State<'_, Arc<Mutex<AppState>>>) -> Result<InitStatus, String> {
 +    let mut state = state.lock().await;
++
 +    // Try to load, but don't fail if we can't
 +    let _ = state.load();
++
 +    let steam_found = state.steam.is_some();
 +    let proton_found = state.proton.as_ref().map(|p| !p.versions.is_empty()).unwrap_or(false);
 +    let prefix_exists = state
 +        .prefix_manager
 +        .as_ref()
 +        .map(|pm| pm.get("default").is_some())
 +        .unwrap_or(false);
 +    let wemod_installed = state
 +        .prefix_manager
 +        .as_ref()
 +        .and_then(|pm| pm.get("default"))
 +        .map(|p| p.wemod_installed)
 +        .unwrap_or(false);
++
 +    Ok(InitStatus {
 +        initialized: wemod_installed,
 +        steam_found,
 +        proton_found,
 +        prefix_exists,
 +        wemod_installed,
 +    })
 +}
++
 +#[tauri::command]
 +pub async fn init_wanda(state: State<'_, Arc<Mutex<AppState>>>) -> Result<(), String> {
 +    let mut state = state.lock().await;
++
 +    // Load config
 +    let config = WandaConfig::load().map_err(|e| e.to_string())?;
++
 +    // Discover Steam
 +    let steam = SteamInstallation::discover(&config).map_err(|e| e.to_string())?;
++
 +    // Discover Proton
 +    let proton_mgr = ProtonManager::discover(&steam, &config).map_err(|e| e.to_string())?;
 +    let proton = proton_mgr.get_preferred(&config).map_err(|e| e.to_string())?;
++
 +    // Create prefix manager and default prefix
 +    let mut prefix_mgr = PrefixManager::new(&config);
 +    prefix_mgr.load().map_err(|e| e.to_string())?;
++
 +    if prefix_mgr.get("default").is_none() {
 +        prefix_mgr.create("default", proton).await.map_err(|e| e.to_string())?;
 +    }
++
 +    // Download and install WeMod
 +    let downloader = WemodDownloader::new(&config);
 +    let release = downloader.get_latest().await.map_err(|e| e.to_string())?;
 +    let installer_path = downloader
 +        .download(&release, |_, _| {})
 +        .await
 +        .map_err(|e| e.to_string())?;
++
 +    let prefix = prefix_mgr.get("default").ok_or("Prefix not created")?;
 +    let installer = WemodInstaller::new(prefix, proton);
 +    installer.install(&installer_path).await.map_err(|e| e.to_string())?;
++
 +    // Update prefix metadata
 +    let version = release.version.clone();
 +    prefix_mgr.update_metadata("default", |p| {
 +        p.wemod_installed = true;
 +        p.wemod_version = version;
 +    }).map_err(|e| e.to_string())?;
++
 +    // Save config
 +    let mut config = config;
 +    config.proton.preferred_version = Some(proton.name.clone());
 +    config.save().map_err(|e| e.to_string())?;
++
 +    // Reload state
 +    state.load()?;
++
 +    Ok(())
 +}
++
 +// ============================================================================
 +// Config Commands
 +// ============================================================================
++
 +#[tauri::command]
 +pub async fn get_config(state: State<'_, Arc<Mutex<AppState>>>) -> Result<ConfigDto, String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let config = state.config.as_ref().ok_or("Config not loaded")?;
++
 +    Ok(ConfigDto {
 +        steam_path: config.steam.install_path.as_ref().map(|p| p.to_string_lossy().to_string()),
 +        scan_flatpak: config.steam.scan_flatpak,
 +        preferred_proton: config.proton.preferred_version.clone(),
 +        auto_update_wemod: config.wemod.auto_update,
 +    })
 +}
++
 +#[tauri::command]
 +pub async fn update_config(
 +    config_dto: ConfigDto,
 +    state: State<'_, Arc<Mutex<AppState>>>,
 +) -> Result<(), String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let config = state.config.as_mut().ok_or("Config not loaded")?;
++
 +    config.steam.install_path = config_dto.steam_path.map(std::path::PathBuf::from);
 +    config.steam.scan_flatpak = config_dto.scan_flatpak;
 +    config.proton.preferred_version = config_dto.preferred_proton;
 +    config.wemod.auto_update = config_dto.auto_update_wemod;
++
 +    config.save().map_err(|e| e.to_string())?;
++
 +    // Reload state to reflect changes
 +    state.load()?;
++
 +    Ok(())
 +}
++
 +// ============================================================================
 +// WeMod Commands
 +// ============================================================================
++
 +#[tauri::command]
 +pub async fn get_wemod_status(state: State<'_, Arc<Mutex<AppState>>>) -> Result<WemodStatus, String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let config = state.config.as_ref().ok_or("Config not loaded")?;
 +    let prefix_mgr = state.prefix_manager.as_ref().ok_or("Prefix manager not loaded")?;
++
 +    let prefix = prefix_mgr.get("default");
 +    let installed = prefix.map(|p| p.wemod_installed).unwrap_or(false);
 +    let version = prefix.and_then(|p| p.wemod_version.clone());
++
 +    // Check for updates
 +    let downloader = WemodDownloader::new(config);
 +    let (update_available, latest_version) = match downloader.get_latest().await {
 +        Ok(release) => {
 +            let latest = release.version.clone();
 +            let update = match (&version, &latest) {
 +                (Some(current), Some(new)) => current != new,
 +                _ => false,
 +            };
 +            (update, latest)
 +        }
 +        Err(_) => (false, None),
 +    };
++
 +    Ok(WemodStatus {
 +        installed,
 +        version,
 +        update_available,
 +        latest_version,
 +    })
 +}
++
 +#[tauri::command]
 +pub async fn update_wemod(state: State<'_, Arc<Mutex<AppState>>>) -> Result<(), String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let config = state.config.as_ref().ok_or("Config not loaded")?;
 +    let proton_mgr = state.proton.as_ref().ok_or("Proton not loaded")?;
 +    let prefix_mgr = state.prefix_manager.as_mut().ok_or("Prefix manager not loaded")?;
++
 +    let proton = proton_mgr.get_preferred(config).map_err(|e| e.to_string())?;
 +    let prefix = prefix_mgr.get("default").ok_or("WANDA not initialized")?;
++
 +    let downloader = WemodDownloader::new(config);
 +    let release = downloader.get_latest().await.map_err(|e| e.to_string())?;
 +    let installer_path = downloader
 +        .download(&release, |_, _| {})
 +        .await
 +        .map_err(|e| e.to_string())?;
++
 +    let installer = WemodInstaller::new(prefix, proton);
 +    installer.install(&installer_path).await.map_err(|e| e.to_string())?;
++
 +    let version = release.version.clone();
 +    prefix_mgr.update_metadata("default", |p| {
 +        p.wemod_version = version;
 +    }).map_err(|e| e.to_string())?;
++
 +    Ok(())
 +}
++
 +// ============================================================================
 +// Proton Commands
 +// ============================================================================
++
 +#[tauri::command]
 +pub async fn get_proton_versions(
 +    state: State<'_, Arc<Mutex<AppState>>>,
 +) -> Result<Vec<ProtonInfo>, String> {
 +    let mut state = state.lock().await;
 +    state.ensure_loaded()?;
++
 +    let config = state.config.as_ref().ok_or("Config not loaded")?;
 +    let proton_mgr = state.proton.as_ref().ok_or("Proton not loaded")?;
++
 +    let recommended = proton_mgr.get_preferred(config).ok();
++
 +    let versions: Vec<ProtonInfo> = proton_mgr
 +        .versions
 +        .iter()
 +        .map(|v| ProtonInfo {
 +            name: v.name.clone(),
 +            path: v.path.to_string_lossy().to_string(),
 +            compatibility: match v.compatibility {
 +                ProtonCompatibility::Recommended => "recommended".to_string(),
 +                ProtonCompatibility::Supported => "supported".to_string(),
 +                ProtonCompatibility::Experimental => "experimental".to_string(),
 +                ProtonCompatibility::Unsupported => "unsupported".to_string(),
 +            },
 +            is_ge: v.is_ge,
 +            is_recommended: recommended.map(|r| r.name == v.name).unwrap_or(false),
 +        })
 +        .collect();
++
 +    Ok(versions)
 +}
++
 +// ============================================================================
 +// Doctor Commands
 +// ============================================================================
++
 +#[tauri::command]
 +pub async fn run_doctor(state: State<'_, Arc<Mutex<AppState>>>) -> Result<DoctorReport, String> {
 +    let mut state = state.lock().await;
++
 +    let mut issues = Vec::new();
++
 +    // Try to load config
 +    let config = match WandaConfig::load() {
 +        Ok(c) => Some(c),
 +        Err(e) => {
 +            issues.push(format!("Config error: {}", e));
 +            None
 +        }
 +    };
++
 +    // Check Steam
 +    let (steam_ok, steam_path) = if let Some(ref cfg) = config {
 +        match SteamInstallation::discover(cfg) {
 +            Ok(steam) => (true, Some(steam.root_path.to_string_lossy().to_string())),
 +            Err(e) => {
 +                issues.push(format!("Steam not found: {}", e));
 +                (false, None)
 +            }
 +        }
 +    } else {
 +        (false, None)
 +    };
++
 +    // Check Proton
 +    let (proton_ok, proton_count) = if let (Some(ref cfg), true) = (&config, steam_ok) {
 +        let steam = SteamInstallation::discover(cfg).unwrap();
 +        match ProtonManager::discover(&steam, cfg) {
 +            Ok(pm) if !pm.versions.is_empty() => (true, pm.versions.len()),
 +            Ok(_) => {
 +                issues.push("No Proton versions found".to_string());
 +                (false, 0)
 +            }
 +            Err(e) => {
 +                issues.push(format!("Proton error: {}", e));
 +                (false, 0)
 +            }
 +        }
 +    } else {
 +        (false, 0)
 +    };
++
 +    // Check prefix
 +    let (prefix_ok, wemod_ok) = if let Some(ref cfg) = config {
 +        let mut pm = PrefixManager::new(cfg);
 +        let _ = pm.load();
 +        if let Some(prefix) = pm.get("default") {
 +            let health_ok = matches!(pm.validate("default"), Ok(PrefixHealth::Healthy));
 +            if !health_ok {
 +                issues.push("Prefix needs repair".to_string());
 +            }
 +            (true, prefix.wemod_installed)
 +        } else {
 +            issues.push("WANDA not initialized".to_string());
 +            (false, false)
 +        }
 +    } else {
 +        (false, false)
 +    };
++
 +    if !wemod_ok && prefix_ok {
 +        issues.push("WeMod not installed".to_string());
 +    }
++
 +    // Update state if load was successful
 +    if config.is_some() {
 +        let _ = state.load();
 +    }
++
 +    Ok(DoctorReport {
 +        steam_ok,
 +        steam_path,
 +        proton_ok,
 +        proton_count,
 +        prefix_ok,
 +        wemod_ok,
 +        issues,
 +    })
 +}

crates/wanda-gui/src/main.rsadded

 +//! WANDA GUI - Tauri application
++
 +#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
++
 +mod commands;
 +mod state;
++
 +use state::AppState;
 +use std::sync::Arc;
 +use tokio::sync::Mutex;
++
 +fn main() {
 +    tauri::Builder::default()
 +        .plugin(tauri_plugin_shell::init())
 +        .manage(Arc::new(Mutex::new(AppState::new())))
 +        .invoke_handler(tauri::generate_handler![
 +            commands::get_games,
 +            commands::get_game,
 +            commands::launch_game,
 +            commands::get_prefixes,
 +            commands::get_prefix_health,
 +            commands::repair_prefix,
 +            commands::init_wanda,
 +            commands::get_init_status,
 +            commands::get_config,
 +            commands::update_config,
 +            commands::get_wemod_status,
 +            commands::update_wemod,
 +            commands::get_proton_versions,
 +            commands::run_doctor,
 +        ])
 +        .run(tauri::generate_context!())
 +        .expect("error while running tauri application");
 +}

crates/wanda-gui/src/state.rsadded

 +//! Application state management
++
 +use wanda_core::{
 +    config::WandaConfig,
 +    prefix::PrefixManager,
 +    steam::{ProtonManager, SteamInstallation},
 +};
++
 +/// Shared application state
 +pub struct AppState {
 +    /// Loaded configuration
 +    pub config: Option<WandaConfig>,
 +    /// Steam installation (cached)
 +    pub steam: Option<SteamInstallation>,
 +    /// Proton manager (cached)
 +    pub proton: Option<ProtonManager>,
 +    /// Prefix manager
 +    pub prefix_manager: Option<PrefixManager>,
 +    /// Whether WANDA is initialized
 +    pub initialized: bool,
 +}
++
 +impl AppState {
 +    pub fn new() -> Self {
 +        Self {
 +            config: None,
 +            steam: None,
 +            proton: None,
 +            prefix_manager: None,
 +            initialized: false,
 +        }
 +    }
++
 +    /// Load or reload state from disk
 +    pub fn load(&mut self) -> Result<(), String> {
 +        // Load config
 +        let config = WandaConfig::load().map_err(|e| e.to_string())?;
++
 +        // Discover Steam
 +        let steam = SteamInstallation::discover(&config).map_err(|e| e.to_string())?;
++
 +        // Discover Proton
 +        let proton = ProtonManager::discover(&steam, &config).map_err(|e| e.to_string())?;
++
 +        // Load prefix manager
 +        let mut prefix_manager = PrefixManager::new(&config);
 +        prefix_manager.load().map_err(|e| e.to_string())?;
++
 +        // Check if initialized (has default prefix with WeMod)
 +        let initialized = prefix_manager
 +            .get("default")
 +            .map(|p| p.wemod_installed)
 +            .unwrap_or(false);
++
 +        self.config = Some(config);
 +        self.steam = Some(steam);
 +        self.proton = Some(proton);
 +        self.prefix_manager = Some(prefix_manager);
 +        self.initialized = initialized;
++
 +        Ok(())
 +    }
++
 +    /// Ensure state is loaded
 +    pub fn ensure_loaded(&mut self) -> Result<(), String> {
 +        if self.config.is_none() {
 +            self.load()?;
 +        }
 +        Ok(())
 +    }
 +}
++
 +impl Default for AppState {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}

crates/wanda-gui/tauri.conf.jsonadded

 +{
 +  "$schema": "https://schema.tauri.app/config/2",
 +  "productName": "WANDA",
 +  "version": "0.1.0",
 +  "identifier": "com.wanda.app",
 +  "build": {
 +    "frontendDist": "../frontend/dist",
 +    "devUrl": "http://localhost:5173",
 +    "beforeDevCommand": "cd ../frontend && npm run dev",
 +    "beforeBuildCommand": "cd ../frontend && npm run build"
 +  },
 +  "app": {
 +    "withGlobalTauri": true,
 +    "windows": [
 +      {
 +        "title": "WANDA",
 +        "width": 1200,
 +        "height": 800,
 +        "minWidth": 800,
 +        "minHeight": 600,
 +        "resizable": true,
 +        "fullscreen": false
 +      }
 +    ],
 +    "security": {
 +      "csp": null
 +    }
 +  },
 +  "bundle": {
 +    "active": true,
 +    "targets": "all",
 +    "icon": [
 +      "icons/32x32.png",
 +      "icons/128x128.png",
 +      "icons/128x128@2x.png",
 +      "icons/icon.icns",
 +      "icons/icon.ico"
 +    ],
 +    "linux": {
 +      "appimage": {
 +        "bundleMediaFramework": false
 +      }
 +    }
 +  }
 +}