Add files via upload

Author: TheHolyOneZ

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "zgamelib"
-version = "0.4.1"
+version = "0.5.0"
 description = "ZGameLib - Personal Game Library"
 authors = ["TheHolyOneZ"]
 license = "MIT"

src-tauri/Cargo.toml

@@ -82,7 +82,17 @@ pub fn toggle_favorite(state: State<DbState>, id: String) -> Result<bool, String
     Ok(game.is_favorite)
 }
 
-// Notes
+#[tauri::command]
+pub fn check_exe_health(state: State<DbState>, id: String) -> Result<bool, String> {
+    let conn = state.0.lock().map_err(|e| e.to_string())?;
+    let game = queries::get_game_by_id(&conn, &id)
+        .map_err(|e| e.to_string())?
+        .ok_or("Game not found")?;
+    match &game.exe_path {
+        Some(p) if !p.is_empty() => Ok(std::path::Path::new(p).exists()),
+        _ => Ok(false),
+    }
+}
 
 #[tauri::command]
 pub fn get_notes(state: State<DbState>, game_id: String) -> Result<Vec<Note>, String> {
@@ -108,7 +118,6 @@ pub fn create_note(state: State<DbState>, game_id: String, content: String) -> R
 #[tauri::command]
 pub fn update_note(state: State<DbState>, id: String, content: String) -> Result<Note, String> {
     let conn = state.0.lock().map_err(|e| e.to_string())?;
-    // fetch existing note
     let mut stmt = conn.prepare("SELECT id, game_id, content, created_at, updated_at FROM notes WHERE id=?1")
         .map_err(|e| e.to_string())?;
     let mut rows = stmt.query_map(rusqlite::params![id], |row| {

src-tauri/src/commands/games.rs

@@ -12,8 +12,6 @@ impl ActivePids {
     }
 }
 
-// ── Windows-only process helpers (no extra crates needed) ─────────────────
-
 #[cfg(windows)]
 use std::os::windows::process::CommandExt;
 #[cfg(windows)]
@@ -50,12 +48,9 @@ fn is_pid_running(pid: u32) -> bool {
         .output()
         .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
         .unwrap_or_default();
-    // Output has a data row if running; "INFO: No tasks..." if not
     out.contains('"')
 }
 
-// ── Session-end helper: update DB + emit + restore window ─────────────────
-
 fn finish_session(app: &AppHandle, game_id: &str, elapsed_mins: i64) {
     let now = Utc::now().to_rfc3339();
     {
@@ -69,18 +64,14 @@ fn finish_session(app: &AppHandle, game_id: &str, elapsed_mins: i64) {
         }
     }
     let _ = app.emit("game-session-ended", game_id);
-    // Restore window after game exits
     if let Some(win) = app.get_webview_window("main") {
         let _ = win.unminimize();
         let _ = win.set_focus();
     }
 }
 
-// ── Commands ──────────────────────────────────────────────────────────────
-
 #[tauri::command]
 pub fn launch_game(app: AppHandle, state: State<DbState>, id: String) -> Result<(), String> {
-    // Phase 1: gather data, release mutex
     let (exe_path, minimize) = {
         let conn = state.0.lock().map_err(|e| e.to_string())?;
         let game = queries::get_game_by_id(&conn, &id)
@@ -92,12 +83,10 @@ pub fn launch_game(app: AppHandle, state: State<DbState>, id: String) -> Result<
         (exe, min)
     };
 
-    // Phase 2: spawn process
     let child = std::process::Command::new(&exe_path)
         .spawn()
         .map_err(|e| format!("Failed to launch: {}", e))?;
 
-    // Record last_played immediately
     let now = Utc::now().to_rfc3339();
     {
         let conn = state.0.lock().map_err(|e| e.to_string())?;
@@ -110,16 +99,13 @@ pub fn launch_game(app: AppHandle, state: State<DbState>, id: String) -> Result<
     if minimize {
         let app_min = app.clone();
         std::thread::spawn(move || {
-            // Short delay so the game window can appear and grab focus first,
-            // preventing Windows from immediately re-focusing ZGameLib
             std::thread::sleep(std::time::Duration::from_millis(400));
             if let Some(win) = app_min.get_webview_window("main") {
                 let _ = win.minimize();
             }
         });
     }
 
-    // Phase 3: background thread — wait for exit, record playtime
     let app_clone = app.clone();
     let game_id = id.clone();
     let start = std::time::Instant::now();
@@ -142,7 +128,6 @@ pub fn launch_steam_game(
     app_id: String,
     game_id: String,
 ) -> Result<(), String> {
-    // Get exe_path for process monitoring + minimize setting
     let (exe_path, minimize) = {
         let conn = state.0.lock().map_err(|e| e.to_string())?;
         let exe = queries::get_game_by_id(&conn, &game_id)
@@ -153,11 +138,9 @@ pub fn launch_steam_game(
         (exe, min)
     };
 
-    // Launch via Steam URI
     open::that(format!("steam://run/{}", app_id))
         .map_err(|e| format!("Failed to launch Steam game: {}", e))?;
 
-    // Record last_played immediately
     let now = Utc::now().to_rfc3339();
     {
         let conn = state.0.lock().map_err(|e| e.to_string())?;
@@ -177,7 +160,6 @@ pub fn launch_steam_game(
         });
     }
 
-    // Background: find game process by exe name, wait for exit, record playtime
     if let Some(exe) = exe_path {
         let app_clone = app.clone();
         let gid = game_id.clone();
@@ -195,7 +177,6 @@ pub fn launch_steam_game(
 
                 let start = std::time::Instant::now();
 
-                // Wait up to 120 s for process to appear (Steam can be slow to launch)
                 let mut pid: Option<u32> = None;
                 for _ in 0..120 {
                     if let Some(p) = find_pid_by_exe_name(&exe_name) {
@@ -212,7 +193,6 @@ pub fn launch_steam_game(
                             return;
                         }
                     }
-                    // Poll every 5 s until the process disappears
                     loop {
                         std::thread::sleep(std::time::Duration::from_secs(5));
                         if !is_pid_running(pid) { break; }
@@ -236,7 +216,6 @@ pub fn launch_epic_game(
     app_name: String,
     game_id: String,
 ) -> Result<(), String> {
-    // Get exe_path for process monitoring + minimize setting
     let (exe_path, minimize) = {
         let conn = state.0.lock().map_err(|e| e.to_string())?;
         let exe = queries::get_game_by_id(&conn, &game_id)
@@ -247,15 +226,13 @@ pub fn launch_epic_game(
         (exe, min)
     };
 
-    // Launch via Epic Games Launcher URI
     let uri = format!(
         "com.epicgames.launcher://apps/{}?action=launch&silent=true",
         app_name
     );
     open::that(&uri)
         .map_err(|e| format!("Failed to launch Epic game: {}", e))?;
 
-    // Record last_played immediately
     let now = Utc::now().to_rfc3339();
     {
         let conn = state.0.lock().map_err(|e| e.to_string())?;
@@ -275,7 +252,6 @@ pub fn launch_epic_game(
         });
     }
 
-    // Background: find game process by exe name, wait for exit, record playtime
     if let Some(exe) = exe_path {
         let app_clone = app.clone();
         let gid = game_id.clone();
@@ -293,7 +269,6 @@ pub fn launch_epic_game(
 
                 let start = std::time::Instant::now();
 
-                // Wait up to 180 s for process to appear (Epic launcher can be slow)
                 let mut pid: Option<u32> = None;
                 for _ in 0..180 {
                     if let Some(p) = find_pid_by_exe_name(&exe_name) {
@@ -310,7 +285,6 @@ pub fn launch_epic_game(
                             return;
                         }
                     }
-                    // Poll every 5 s until the process disappears
                     loop {
                         std::thread::sleep(std::time::Duration::from_secs(5));
                         if !is_pid_running(pid) { break; }

src-tauri/src/commands/launcher.rs

@@ -3,8 +3,6 @@ use std::io::Read;
 use std::path::{Path, PathBuf};
 use tauri::{AppHandle, Emitter};
 
-// ── helpers ────────────────────────────────────────────────────────────────
-
 fn p(install_dir: &str, sub: &str) -> PathBuf {
     Path::new(install_dir).join(sub)
 }
@@ -53,6 +51,7 @@ fn fetch_json(url: &str) -> Result<serde_json::Value, String> {
     let mut body = String::new();
     ureq::get(url)
         .set("User-Agent", "ZGameLib")
+        .timeout(std::time::Duration::from_secs(15))
         .call()
         .map_err(|e| e.to_string())?
         .into_reader()
@@ -65,6 +64,7 @@ fn download_bytes(url: &str) -> Result<Vec<u8>, String> {
     let mut bytes = Vec::new();
     ureq::get(url)
         .set("User-Agent", "ZGameLib")
+        .timeout(std::time::Duration::from_secs(15))
         .call()
         .map_err(|e| e.to_string())?
         .into_reader()
@@ -73,8 +73,6 @@ fn download_bytes(url: &str) -> Result<Vec<u8>, String> {
     Ok(bytes)
 }
 
-// ── types ──────────────────────────────────────────────────────────────────
-
 #[derive(Debug, serde::Serialize, Clone)]
 pub struct ModLoaderStatus {
     pub bepinex_installed: bool,
@@ -90,14 +88,11 @@ pub struct ModInfo {
     pub size_bytes: u64,
 }
 
-// ── commands ───────────────────────────────────────────────────────────────
-
 #[tauri::command]
 pub fn check_modloader_status(install_dir: String) -> Result<ModLoaderStatus, String> {
     let bepinex = is_bepinex_installed(&install_dir);
     let melonloader = is_melonloader_installed(&install_dir);
 
-    // If both somehow installed, prefer BepInEx for the mods folder
     let (mods_folder, mods) = if bepinex {
         let dir = bepinex_plugins_dir(&install_dir);
         (Some(dir.to_string_lossy().to_string()), list_mods(&dir))
@@ -152,12 +147,10 @@ pub fn install_bepinex(app: AppHandle, install_dir: String) -> Result<(), String
 
 #[tauri::command]
 pub fn uninstall_bepinex(install_dir: String) -> Result<(), String> {
-    // Remove BepInEx folder
     let bepinex_dir = p(&install_dir, "BepInEx");
     if bepinex_dir.exists() {
         fs::remove_dir_all(&bepinex_dir).map_err(|e| e.to_string())?;
     }
-    // Remove hook DLLs and config files BepInEx places at game root
     for file in &["winhttp.dll", "doorstop_config.ini", ".doorstop_version", "changelog.txt"] {
         let path = p(&install_dir, file);
         if path.exists() { let _ = fs::remove_file(path); }
@@ -169,12 +162,9 @@ pub fn uninstall_bepinex(install_dir: String) -> Result<(), String> {
 pub fn install_melonloader(app: AppHandle, install_dir: String) -> Result<(), String> {
     emit_log(&app, "info", "Fetching MelonLoader releases from GitHub...");
 
-    // Use /releases list — MelonLoader ships as pre-releases so /latest often misses them
     let releases = fetch_json("https://api.github.com/repos/LavaGang/MelonLoader/releases?per_page=10")?;
     let releases_arr = releases.as_array().ok_or("Unexpected response from GitHub")?;
 
-    // Find the first non-draft release that has MelonLoader.x64.zip
-    // We use the zip directly — the GUI installer has no reliable silent CLI mode
     let (asset_url, version) = releases_arr.iter()
         .filter(|r| !r["draft"].as_bool().unwrap_or(false))
         .find_map(|r| {
@@ -207,8 +197,6 @@ pub fn install_melonloader(app: AppHandle, install_dir: String) -> Result<(), St
         }
     }
 
-    // Pre-create Mods/ and Plugins/ — MelonLoader creates these on first game launch
-    // but we want them visible immediately in the panel
     fs::create_dir_all(melonloader_mods_dir(&install_dir)).map_err(|e| e.to_string())?;
     fs::create_dir_all(p(&install_dir, "Plugins")).map_err(|e| e.to_string())?;
 
@@ -218,12 +206,10 @@ pub fn install_melonloader(app: AppHandle, install_dir: String) -> Result<(), St
 
 #[tauri::command]
 pub fn uninstall_melonloader(install_dir: String) -> Result<(), String> {
-    // Remove MelonLoader folder
     let ml_dir = p(&install_dir, "MelonLoader");
     if ml_dir.exists() {
         fs::remove_dir_all(&ml_dir).map_err(|e| e.to_string())?;
     }
-    // Remove hook files MelonLoader places at game root
     for file in &["version.dll", "dobby.dll"] {
         let path = p(&install_dir, file);
         if path.exists() { let _ = fs::remove_file(path); }