style: only allow user to switch between releases

src-tauri/src/auto_updater.rs

@@ -509,6 +509,7 @@ mod tests {
       process_id: None,
       proxy: None,
       last_launch: None,
+      release_type: "stable".to_string(),
     }
   }
 

src-tauri/src/browser_runner.rs

@@ -27,6 +27,12 @@ pub struct BrowserProfile {
   pub process_id: Option<u32>,
   #[serde(default)]
   pub last_launch: Option<u64>,
+  #[serde(default = "default_release_type")]
+  pub release_type: String, // "stable" or "nightly"
+}
+
+fn default_release_type() -> String {
+  "stable".to_string()
 }
 
 // Platform-specific modules
@@ -1049,6 +1055,7 @@ impl BrowserRunner {
     name: &str,
     browser: &str,
     version: &str,
+    release_type: &str,
     proxy: Option<ProxySettings>,
   ) -> Result<BrowserProfile, Box<dyn std::error::Error>> {
     // Check if a profile with this name already exists (case insensitive)
@@ -1075,6 +1082,7 @@ impl BrowserRunner {
       proxy: proxy.clone(),
       process_id: None,
       last_launch: None,
+      release_type: release_type.to_string(),
     };
 
     // Save profile info
@@ -1245,6 +1253,14 @@ impl BrowserRunner {
     // Update version
     profile.version = version.to_string();
 
+    // Update the release_type based on the version and browser
+    profile.release_type =
+      if crate::api_client::is_browser_version_nightly(&profile.browser, version, None) {
+        "nightly".to_string()
+      } else {
+        "stable".to_string()
+      };
+
     // Save the updated profile
     self.save_profile(&profile)?;
 
@@ -2195,11 +2211,12 @@ pub fn create_browser_profile(
   name: String,
   browser: String,
   version: String,
+  release_type: String,
   proxy: Option<ProxySettings>,
 ) -> Result<BrowserProfile, String> {
   let browser_runner = BrowserRunner::new();
   browser_runner
-    .create_profile(&name, &browser, &version, proxy)
+    .create_profile(&name, &browser, &version, &release_type, proxy)
     .map_err(|e| format!("Failed to create profile: {e}"))
 }
 
@@ -2638,11 +2655,18 @@ pub fn create_browser_profile_new(
   name: String,
   browser_str: String,
   version: String,
+  release_type: String,
   proxy: Option<ProxySettings>,
 ) -> Result<BrowserProfile, String> {
   let browser_type =
     BrowserType::from_str(&browser_str).map_err(|e| format!("Invalid browser type: {e}"))?;
-  create_browser_profile(name, browser_type.as_str().to_string(), version, proxy)
+  create_browser_profile(
+    name,
+    browser_type.as_str().to_string(),
+    version,
+    release_type,
+    proxy,
+  )
 }
 
 #[tauri::command]
@@ -2663,6 +2687,17 @@ pub fn get_downloaded_browser_versions(browser_str: String) -> Result<Vec<String
   Ok(registry.get_downloaded_versions(&browser_str))
 }
 
+#[tauri::command]
+pub async fn get_browser_release_types(
+  browser_str: String,
+) -> Result<crate::browser_version_service::BrowserReleaseTypes, String> {
+  let service = BrowserVersionService::new();
+  service
+    .get_browser_release_types(&browser_str)
+    .await
+    .map_err(|e| format!("Failed to get browser release types: {e}"))
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;
@@ -2708,7 +2743,7 @@ mod tests {
     let (runner, _temp_dir) = create_test_browser_runner();
 
     let profile = runner
-      .create_profile("Test Profile", "firefox", "139.0", None)
+      .create_profile("Test Profile", "firefox", "139.0", "stable", None)
       .unwrap();
 
     assert_eq!(profile.name, "Test Profile");
@@ -2736,6 +2771,7 @@ mod tests {
         "Test Profile with Proxy",
         "firefox",
         "139.0",
+        "stable",
         Some(proxy.clone()),
       )
       .unwrap();
@@ -2753,7 +2789,7 @@ mod tests {
     let (runner, _temp_dir) = create_test_browser_runner();
 
     let profile = runner
-      .create_profile("Test Save Load", "firefox", "139.0", None)
+      .create_profile("Test Save Load", "firefox", "139.0", "stable", None)
       .unwrap();
 
     // Save the profile
@@ -2773,7 +2809,7 @@ mod tests {
 
     // Create profile
     let _ = runner
-      .create_profile("Original Name", "firefox", "139.0", None)
+      .create_profile("Original Name", "firefox", "139.0", "stable", None)
       .unwrap();
 
     // Rename profile
@@ -2793,7 +2829,7 @@ mod tests {
 
     // Create profile
     let _ = runner
-      .create_profile("To Delete", "firefox", "139.0", None)
+      .create_profile("To Delete", "firefox", "139.0", "stable", None)
       .unwrap();
 
     // Verify profile exists
@@ -2814,7 +2850,13 @@ mod tests {
 
     // Create profile with spaces and special characters
     let profile = runner
-      .create_profile("Test Profile With Spaces", "firefox", "139.0", None)
+      .create_profile(
+        "Test Profile With Spaces",
+        "firefox",
+        "139.0",
+        "stable",
+        None,
+      )
       .unwrap();
 
     // Profile path should use snake_case
@@ -2827,13 +2869,13 @@ mod tests {
 
     // Create multiple profiles
     let _ = runner
-      .create_profile("Profile 1", "firefox", "139.0", None)
+      .create_profile("Profile 1", "firefox", "139.0", "stable", None)
       .unwrap();
     let _ = runner
-      .create_profile("Profile 2", "chromium", "1465660", None)
+      .create_profile("Profile 2", "chromium", "1465660", "stable", None)
       .unwrap();
     let _ = runner
-      .create_profile("Profile 3", "brave", "v1.81.9", None)
+      .create_profile("Profile 3", "brave", "v1.81.9", "stable", None)
       .unwrap();
 
     // List profiles
@@ -2852,10 +2894,10 @@ mod tests {
 
     // Test that we can't rename to an existing profile name
     let _ = runner
-      .create_profile("Profile 1", "firefox", "139.0", None)
+      .create_profile("Profile 1", "firefox", "139.0", "stable", None)
       .unwrap();
     let _ = runner
-      .create_profile("Profile 2", "firefox", "139.0", None)
+      .create_profile("Profile 2", "firefox", "139.0", "stable", None)
       .unwrap();
 
     // Try to rename profile2 to profile1's name (should fail)
@@ -2870,7 +2912,7 @@ mod tests {
 
     // Create profile without proxy
     let profile = runner
-      .create_profile("Test Firefox Prefs", "firefox", "139.0", None)
+      .create_profile("Test Firefox Prefs", "firefox", "139.0", "stable", None)
       .unwrap();
 
     // Check that user.js file was created with default browser preference
@@ -2896,7 +2938,13 @@ mod tests {
     };
 
     let profile_with_proxy = runner
-      .create_profile("Test Firefox Prefs Proxy", "firefox", "139.0", Some(proxy))
+      .create_profile(
+        "Test Firefox Prefs Proxy",
+        "firefox",
+        "139.0",
+        "stable",
+        Some(proxy),
+      )
       .unwrap();
 
     // Check that user.js file contains both proxy settings and default browser preference

src-tauri/src/browser_version_service.rs

@@ -17,6 +17,12 @@ pub struct BrowserVersionsResult {
   pub total_versions_count: usize,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct BrowserReleaseTypes {
+  pub stable: Option<String>,
+  pub nightly: Option<String>,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct DownloadInfo {
   pub url: String,
@@ -136,6 +142,39 @@ impl BrowserVersionService {
     self.api_client.is_cache_expired(browser)
   }
 
+  /// Get latest stable and nightly versions for a browser
+  pub async fn get_browser_release_types(
+    &self,
+    browser: &str,
+  ) -> Result<BrowserReleaseTypes, Box<dyn std::error::Error + Send + Sync>> {
+    // For Chromium, only return stable since all releases are stable
+    if browser == "chromium" {
+      let detailed_versions = self.fetch_browser_versions_detailed(browser, false).await?;
+      let latest_stable = detailed_versions.first().map(|v| v.version.clone());
+      return Ok(BrowserReleaseTypes {
+        stable: latest_stable,
+        nightly: None,
+      });
+    }
+
+    let detailed_versions = self.fetch_browser_versions_detailed(browser, false).await?;
+
+    let latest_stable = detailed_versions
+      .iter()
+      .find(|v| !v.is_prerelease)
+      .map(|v| v.version.clone());
+
+    let latest_nightly = detailed_versions
+      .iter()
+      .find(|v| v.is_prerelease)
+      .map(|v| v.version.clone());
+
+    Ok(BrowserReleaseTypes {
+      stable: latest_stable,
+      nightly: latest_nightly,
+    })
+  }
+
   /// Fetch browser versions with optional caching
   pub async fn fetch_browser_versions(
     &self,

src-tauri/src/lib.rs

@@ -28,10 +28,10 @@ extern crate lazy_static;
 use browser_runner::{
   check_browser_exists, check_browser_status, create_browser_profile_new, delete_profile,
   download_browser, fetch_browser_versions_cached_first, fetch_browser_versions_with_count,
-  fetch_browser_versions_with_count_cached_first, get_downloaded_browser_versions,
-  get_supported_browsers, is_browser_supported_on_platform, kill_browser_profile,
-  launch_browser_profile, list_browser_profiles, rename_profile, update_profile_proxy,
-  update_profile_version,
+  fetch_browser_versions_with_count_cached_first, get_browser_release_types,
+  get_downloaded_browser_versions, get_supported_browsers, is_browser_supported_on_platform,
+  kill_browser_profile, launch_browser_profile, list_browser_profiles, rename_profile,
+  update_profile_proxy, update_profile_version,
 };
 
 use settings_manager::{
@@ -331,6 +331,7 @@ pub fn run() {
       fetch_browser_versions_cached_first,
       fetch_browser_versions_with_count_cached_first,
       get_downloaded_browser_versions,
+      get_browser_release_types,
       update_profile_proxy,
       update_profile_version,
       check_browser_status,

src-tauri/src/profile_importer.rs

@@ -686,6 +686,7 @@ impl ProfileImporter {
       proxy: None,
       process_id: None,
       last_launch: None,
+      release_type: "stable".to_string(),
     };
 
     // Save the profile metadata