Fix installed-game detection and post-install install path handling

.github/workflows/rust.yaml

@@ -3,7 +3,10 @@ name: SteamFlow Rust Build
 on:
   push:
     paths:
-      - "SteamFlow/**"
+      - "src/**"
+      - "assets/**"
+      - "Cargo.toml"
+      - "Cargo.lock"
       - ".github/workflows/rust.yaml"
   pull_request:
 
@@ -40,16 +43,16 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
 
       - name: Build SteamFlow (release)
-        run: cargo build --release --manifest-path SteamFlow/Cargo.toml
+        run: cargo build --release
 
       - name: Install cargo-deb
         run: cargo install cargo-deb --locked
 
       - name: Build .deb package
-        run: cargo deb --no-build --manifest-path SteamFlow/Cargo.toml
+        run: cargo deb --no-build
 
       - name: Upload .deb artifact
         uses: actions/upload-artifact@v4
         with:
           name: steamflow-deb
-          path: SteamFlow/target/debian/*.deb
+          path: target/debian/*.deb

README.md

@@ -42,7 +42,7 @@ sudo apt-get install build-essential pkg-config libssl-dev libx11-dev libxi-dev
 ## Build and Run
 ```bash
 git clone https://github.com/OpenSteamClient/OpenSteamClient.git --recursive
-cd OpenSteamClient/SteamFlow
+cd OpenSteamClient
 cargo run --release
 ```
 

SteamFlow/README.md → STEAMFLOW_TECHNICAL.md

@@ -48,7 +48,7 @@ Guard data is persisted through `FileGuardDataStore::user_cache()` so repeated S
 
 ## Run
 ```bash
-cargo run --manifest-path SteamFlow/Cargo.toml
+cargo run
 ```
 
 ## Install/download pipeline

SteamFlow/src/config.rs → src/config.rs

@@ -26,9 +26,15 @@ impl LauncherConfig {
 
 impl Default for LauncherConfig {
     fn default() -> Self {
-        let home = std::env::var("HOME").unwrap_or_else(|_| "~".to_string());
+        let steam_library_path = detect_steam_path()
+            .map(|path| path.to_string_lossy().to_string())
+            .unwrap_or_else(|| {
+                let home = std::env::var("HOME").unwrap_or_else(|_| "~".to_string());
+                format!("{home}/Games/SteamFlow")
+            });
+
         Self {
-            steam_library_path: format!("{home}/Games/SteamFlow"),
+            steam_library_path,
             proton_version: "experimental".to_string(),
             enable_cloud_sync: true,
             use_shared_compat_data: false,

SteamFlow/src/library.rs → src/library.rs

@@ -64,19 +64,18 @@ pub async fn scan_installed_app_paths() -> Result<HashMap<u32, String>> {
 }
 
 pub async fn scan_installed_app_paths_pathbuf() -> Result<HashMap<u32, PathBuf>> {
-    let config_path = if let Ok(cfg) = load_launcher_config().await {
+    let config_path = load_launcher_config().await.ok().and_then(|cfg| {
         let p = PathBuf::from(cfg.steam_library_path);
         if p.join("steamapps").exists() || p.join("Steam").join("steamapps").exists() {
             Some(p)
         } else {
             None
         }
-    } else {
-        None
-    };
+    });
 
     let root = config_path
-        .unwrap_or_else(|| detect_steam_path().unwrap_or_else(|| PathBuf::from("~/.steam/steam")));
+        .or_else(detect_steam_path)
+        .unwrap_or_else(default_steam_root);
     println!("Scanning Library Root: {:?}", root);
     scan_library(&root).await
 }
@@ -86,7 +85,12 @@ pub async fn scan_library(root_path: &Path) -> Result<HashMap<u32, PathBuf>> {
     let mut libraries = vec![root_path.to_path_buf()];
 
     let library_folders_path = root_path.join("steamapps").join("libraryfolders.vdf");
-    let extra_libraries = parse_library_folders(library_folders_path).await?;
+    let extra_libraries = parse_library_folders(library_folders_path)
+        .await
+        .unwrap_or_else(|e| {
+            println!("Warning: Could not parse libraryfolders.vdf: {}", e);
+            Vec::new()
+        });
     libraries.extend(extra_libraries);
 
     libraries.sort();
@@ -108,8 +112,12 @@ pub async fn scan_library(root_path: &Path) -> Result<HashMap<u32, PathBuf>> {
                 continue;
             }
 
-            if let Some((app_id, install_dir)) = parse_app_manifest_install_path(&path).await? {
-                installed.insert(app_id, install_dir);
+            match parse_app_manifest_install_path(&path).await {
+                Ok(Some((app_id, install_dir))) => {
+                    installed.insert(app_id, install_dir);
+                }
+                Ok(None) => {}
+                Err(e) => println!("Skipping bad manifest {:?}: {}", path, e),
             }
         }
     }

SteamFlow/src/ui.rs → src/ui.rs

@@ -235,14 +235,15 @@ impl SteamLauncher {
                     DownloadProgressState::Completed => {
                         self.status = "Install completed".to_string();
                         if let Some(appid) = self.active_download_appid {
+                            let installed_paths = self
+                                .runtime
+                                .block_on(scan_installed_app_paths())
+                                .unwrap_or_default();
+
                             for g in &mut self.library {
                                 if g.app_id == appid {
-                                    g.is_installed = true;
-                                    let install_dir = std::env::temp_dir()
-                                        .join("steamflow_downloads")
-                                        .join(appid.to_string());
-                                    g.install_path =
-                                        Some(install_dir.to_string_lossy().to_string());
+                                    g.install_path = installed_paths.get(&appid).cloned();
+                                    g.is_installed = g.install_path.is_some();
                                 }
                             }
                         }