feat: don't spam update notification, show more concise toasts, don't fetch unsupported browser updates

src-tauri/src/auto_updater.rs

@@ -54,23 +54,32 @@ impl AutoUpdater {
       return Ok(Vec::new());
     }
 
+    let mut notifications = Vec::new();
+    let mut browser_versions: HashMap<String, Vec<BrowserVersionInfo>> = HashMap::new();
+
+    // Group profiles by browser
     let profiles = self
       .browser_runner
       .list_profiles()
       .map_err(|e| format!("Failed to list profiles: {e}"))?;
-    let mut notifications = Vec::new();
-    let mut browser_versions: HashMap<String, Vec<BrowserVersionInfo>> = HashMap::new();
-
-    // Group profiles by browser type
     let mut browser_profiles: HashMap<String, Vec<BrowserProfile>> = HashMap::new();
+
     for profile in profiles {
+      // Only check supported browsers
+      if !self
+        .version_service
+        .is_browser_supported(&profile.browser)
+        .unwrap_or(false)
+      {
+        continue;
+      }
+
       browser_profiles
         .entry(profile.browser.clone())
         .or_default()
         .push(profile);
     }
 
-    // Check each browser type
     for (browser, profiles) in browser_profiles {
       // Get cached versions first, then try to fetch if needed
       let versions = if let Some(cached) = self
@@ -97,7 +106,23 @@ impl AutoUpdater {
       // Check each profile for updates
       for profile in profiles {
         if let Some(update) = self.check_profile_update(&profile, &versions)? {
-          notifications.push(update);
+          // Apply chromium threshold logic
+          if browser == "chromium" {
+            // For chromium, only show notifications if there are 100+ new versions
+            // Count how many versions are newer than the current profile version
+            let newer_versions_count = versions
+              .iter()
+              .filter(|v| self.is_version_newer(&v.version, &profile.version))
+              .count();
+
+            if newer_versions_count >= 100 {
+              notifications.push(update);
+            } else {
+              println!("Skipping chromium update notification: only {newer_versions_count} new versions (need 100+)");
+            }
+          } else {
+            notifications.push(update);
+          }
         }
       }
     }

src-tauri/src/settings_manager.rs

@@ -224,12 +224,12 @@ pub async fn clear_all_version_cache_and_refetch() -> Result<(), String> {
     .clear_all_cache()
     .map_err(|e| format!("Failed to clear version cache: {e}"))?;
 
-  // Trigger auto-fetch for all supported browsers
+  // Trigger auto-fetch for only supported browsers
   let service = BrowserVersionService::new();
   let supported_browsers = service.get_supported_browsers();
 
   for browser in supported_browsers {
-    // Start background fetch for each browser (don't wait for completion)
+    // Start background fetch for each supported browser (don't wait for completion)
     let service_clone = BrowserVersionService::new();
     let browser_clone = browser.clone();
     tokio::spawn(async move {

src-tauri/src/version_updater.rs

@@ -259,7 +259,7 @@ impl VersionUpdater {
   ) -> Result<Vec<BackgroundUpdateResult>, Box<dyn std::error::Error + Send + Sync>> {
     println!("Starting background version update for all browsers");
 
-    let browsers = [
+    let all_browsers = [
       "firefox",
       "firefox-developer",
       "mullvad-browser",
@@ -269,10 +269,28 @@ impl VersionUpdater {
       "tor-browser",
     ];
 
+    // Filter browsers to only include those supported on the current platform
+    let browsers: Vec<&str> = all_browsers
+      .iter()
+      .filter(|browser| {
+        self
+          .version_service
+          .is_browser_supported(browser)
+          .unwrap_or(false)
+      })
+      .copied()
+      .collect();
+
     let total_browsers = browsers.len();
     let mut results = Vec::new();
     let mut total_new_versions = 0;
 
+    println!(
+      "Updating {} supported browsers (filtered from {} total)",
+      browsers.len(),
+      all_browsers.len()
+    );
+
     // Emit start event
     let progress = VersionUpdateProgress {
       current_browser: "".to_string(),