Merge pull request #53 from BegoniaHe/fix/windows-java-path

3 files changed, 264 insertions, 4 deletions

diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index 5ccbe96..463bd5d 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -526,12 +526,28 @@ async fn start_game(
         emit_log!(window, format!("Java Args: {:?}", &args));
     }
 
+    // Get Java path from config or detect
+    let java_path_str = if !config.java_path.is_empty() && config.java_path != "java" {
+        config.java_path.clone()
+    } else {
+        // Try to find a suitable Java installation
+        let javas = core::java::detect_all_java_installations(&app_handle);
+        if let Some(java) = javas.first() {
+            java.path.clone()
+        } else {
+            return Err(
+                "No Java installation found. Please configure Java in settings.".to_string(),
+            );
+        }
+    };
+    let java_path = utils::path::normalize_java_path(&java_path_str)?;
+
     // Spawn the process
     emit_log!(
         window,
-        format!("Starting Java process: {}", config.java_path)
+        format!("Starting Java process: {}", java_path.display())
     );
-    let mut command = Command::new(&config.java_path);
+    let mut command = Command::new(&java_path);
     command.args(&args);
     command.current_dir(&game_dir); // Run in game directory
     command.stdout(Stdio::piped());
@@ -551,7 +567,7 @@ async fn start_game(
     // Spawn and handle output
     let mut child = command
         .spawn()
-        .map_err(|e| format!("Failed to launch java: {}", e))?;
+        .map_err(|e| format!("Failed to launch Java at '{}': {}\nPlease check your Java installation and path configuration in Settings.", java_path.display(), e))?;
 
     emit_log!(window, "Java process started successfully".to_string());
 
@@ -1540,7 +1556,7 @@ async fn install_forge(
             );
         }
     };
-    let java_path = std::path::PathBuf::from(&java_path_str);
+    let java_path = utils::path::normalize_java_path(&java_path_str)?;
 
     emit_log!(window, "Running Forge installer...".to_string());
 
diff --git a/src-tauri/src/utils/mod.rs b/src-tauri/src/utils/mod.rs
index 00b9087..651d26b 100644
--- a/src-tauri/src/utils/mod.rs
+++ b/src-tauri/src/utils/mod.rs
@@ -1,4 +1,5 @@
 pub mod zip;
+pub mod path;
 
 // File system related utility functions
 #[allow(dead_code)]
diff --git a/src-tauri/src/utils/path.rs b/src-tauri/src/utils/path.rs
new file mode 100644
index 0000000..deaebb5
--- /dev/null
+++ b/src-tauri/src/utils/path.rs
@@ -0,0 +1,243 @@
+/// Path utilities for cross-platform compatibility
+use std::path::PathBuf;
+
+/// Helper to strip UNC prefix on Windows (\\?\)
+/// This is needed because std::fs::canonicalize adds UNC prefix on Windows
+#[cfg(target_os = "windows")]
+fn strip_unc_prefix(path: PathBuf) -> PathBuf {
+    let s = path.to_string_lossy().to_string();
+    if s.starts_with(r"\\?\") {
+        return PathBuf::from(&s[4..]);
+    }
+    path
+}
+
+#[cfg(not(target_os = "windows"))]
+fn strip_unc_prefix(path: PathBuf) -> PathBuf {
+    path
+}
+
+/// Normalize a Java executable path for the current platform.
+///
+/// This function handles platform-specific requirements and validates that
+/// the resulting path points to an executable Java binary.
+///
+/// On Windows:
+/// - Adds .exe extension if missing
+/// - Attempts to locate java.exe in PATH if only "java" is provided
+/// - Resolves symlinks and strips UNC prefix
+/// - Validates that the path exists
+///
+/// On Unix:
+/// - Attempts to locate java in PATH using `which` if only "java" is provided
+/// - Resolves symlinks to get canonical path
+/// - Validates that the path exists
+///
+/// # Arguments
+/// * `java_path` - The Java executable path to normalize (can be relative, absolute, or "java")
+///
+/// # Returns
+/// * `Ok(PathBuf)` - Canonicalized, validated path to Java executable
+/// * `Err(String)` - Error if the path cannot be found or validated
+#[cfg(target_os = "windows")]
+pub fn normalize_java_path(java_path: &str) -> Result<PathBuf, String> {
+    let mut path = PathBuf::from(java_path);
+
+    // If path doesn't exist and doesn't end with .exe, try adding .exe
+    if !path.exists() && path.extension().is_none() {
+        path.set_extension("exe");
+    }
+
+    // If still not found and it's just "java.exe", try to find it in PATH
+    if !path.exists() && path.file_name() == Some(std::ffi::OsStr::new("java.exe")) {
+        // Try to locate java.exe in PATH
+        if let Ok(output) = std::process::Command::new("where").arg("java").output() {
+            if output.status.success() {
+                let paths = String::from_utf8_lossy(&output.stdout);
+                if let Some(first_path) = paths.lines().next() {
+                    path = PathBuf::from(first_path.trim());
+                }
+            }
+        }
+        
+        // If still not found after PATH search, return specific error
+        if !path.exists() {
+            return Err(
+                "Java not found in PATH. Please install Java or configure the full path in Settings."
+                    .to_string(),
+            );
+        }
+    }
+
+    // Verify the path exists before canonicalization
+    if !path.exists() {
+        return Err(format!(
+            "Java executable not found at: {}\nPlease configure a valid Java path in Settings.",
+            path.display()
+        ));
+    }
+
+    // Canonicalize and strip UNC prefix for clean path
+    let canonical = std::fs::canonicalize(&path)
+        .map_err(|e| format!("Failed to resolve Java path '{}': {}", path.display(), e))?;
+    
+    Ok(strip_unc_prefix(canonical))
+}
+
+#[cfg(not(target_os = "windows"))]
+pub fn normalize_java_path(java_path: &str) -> Result<PathBuf, String> {
+    let mut path = PathBuf::from(java_path);
+
+    // If path doesn't exist and it's just "java", try to find java in PATH
+    if !path.exists() && java_path == "java" {
+        if let Ok(output) = std::process::Command::new("which").arg("java").output() {
+            if output.status.success() {
+                let path_str = String::from_utf8_lossy(&output.stdout);
+                if let Some(first_path) = path_str.lines().next() {
+                    path = PathBuf::from(first_path.trim());
+                }
+            }
+        }
+        
+        // If still not found after PATH search, return specific error
+        if !path.exists() {
+            return Err(
+                "Java not found in PATH. Please install Java or configure the full path in Settings."
+                    .to_string(),
+            );
+        }
+    }
+
+    // Verify the path exists before canonicalization
+    if !path.exists() {
+        return Err(format!(
+            "Java executable not found at: {}\nPlease configure a valid Java path in Settings.",
+            path.display()
+        ));
+    }
+
+    // Canonicalize to resolve symlinks and get absolute path
+    let canonical = std::fs::canonicalize(&path)
+        .map_err(|e| format!("Failed to resolve Java path '{}': {}", path.display(), e))?;
+    
+    Ok(strip_unc_prefix(canonical))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use std::io::Write;
+
+    #[test]
+    #[cfg(target_os = "windows")]
+    fn test_normalize_nonexistent_path_windows() {
+        // Non-existent path should return error
+        let result = normalize_java_path("C:\\NonExistent\\Path\\java.exe");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("not found"));
+    }
+
+    #[test]
+    #[cfg(not(target_os = "windows"))]
+    fn test_normalize_nonexistent_path_unix() {
+        // Non-existent path should return error
+        let result = normalize_java_path("/nonexistent/path/java");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("not found"));
+    }
+
+    #[test]
+    #[cfg(target_os = "windows")]
+    fn test_normalize_adds_exe_extension() {
+        // This test assumes java is not in the current directory
+        let result = normalize_java_path("nonexistent_java");
+        // Should fail since the file doesn't exist
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_normalize_existing_path_returns_canonical() {
+        // Test with a path that should exist on most systems
+        #[cfg(target_os = "windows")]
+        let test_path = "C:\\Windows\\System32\\cmd.exe";
+        #[cfg(not(target_os = "windows"))]
+        let test_path = "/bin/sh";
+
+        if std::path::Path::new(test_path).exists() {
+            let result = normalize_java_path(test_path);
+            assert!(result.is_ok());
+            let normalized = result.unwrap();
+            // Should be absolute path after canonicalization
+            assert!(normalized.is_absolute());
+            // Should not contain UNC prefix on Windows
+            #[cfg(target_os = "windows")]
+            assert!(!normalized.to_string_lossy().starts_with(r"\\?\"));
+        }
+    }
+
+    #[test]
+    fn test_normalize_java_not_in_path() {
+        // When "java" is provided but not in PATH, should return error
+        // This test may pass if java IS in PATH, so we check error message format
+        let result = normalize_java_path("java");
+        if result.is_err() {
+            let err = result.unwrap_err();
+            assert!(
+                err.contains("not found in PATH") || err.contains("not found at"),
+                "Expected PATH error, got: {}",
+                err
+            );
+        }
+        // If Ok, java was found in PATH - test passes
+    }
+
+    #[test]
+    fn test_normalize_with_temp_file() {
+        // Create a temporary file to test with an actual existing path
+        let temp_dir = std::env::temp_dir();
+        
+        #[cfg(target_os = "windows")]
+        let temp_file = temp_dir.join("test_java_normalize.exe");
+        #[cfg(not(target_os = "windows"))]
+        let temp_file = temp_dir.join("test_java_normalize");
+        
+        // Create the file
+        if let Ok(mut file) = fs::File::create(&temp_file) {
+            let _ = file.write_all(b"#!/bin/sh\necho test");
+            drop(file);
+            
+            // Test normalization
+            let result = normalize_java_path(temp_file.to_str().unwrap());
+            
+            // Clean up
+            let _ = fs::remove_file(&temp_file);
+            
+            // Verify result
+            assert!(result.is_ok(), "Failed to normalize temp file path");
+            let normalized = result.unwrap();
+            assert!(normalized.is_absolute());
+        }
+    }
+
+    #[test]
+    fn test_strip_unc_prefix() {
+        #[cfg(target_os = "windows")]
+        {
+            let unc_path = PathBuf::from(r"\\?\C:\Windows\System32\cmd.exe");
+            let stripped = strip_unc_prefix(unc_path);
+            assert_eq!(stripped.to_string_lossy(), r"C:\Windows\System32\cmd.exe");
+            
+            let normal_path = PathBuf::from(r"C:\Windows\System32\cmd.exe");
+            let unchanged = strip_unc_prefix(normal_path.clone());
+            assert_eq!(unchanged, normal_path);
+        }
+        
+        #[cfg(not(target_os = "windows"))]
+        {
+            let path = PathBuf::from("/usr/bin/java");
+            let unchanged = strip_unc_prefix(path.clone());
+            assert_eq!(unchanged, path);
+        }
+    }
+}