build: update codeql permissions

.github/workflows/codeql.yml

@@ -0,0 +1,61 @@
+name: "CodeQL"
+
+on:
+  workflow_call:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+  schedule:
+    - cron: "16 13 * * 5"
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      security-events: write
+      packages: read
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - language: actions
+            build-mode: none
+          - language: javascript-typescript
+            build-mode: none
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up pnpm package manager
+        uses: pnpm/action-setup@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: .node-version
+          cache: "pnpm"
+
+      - name: Install dependencies from lockfile
+        run: pnpm install --frozen-lockfile
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v3
+        with:
+          queries: security-extended
+          languages: ${{ matrix.language }}
+          build-mode: ${{ matrix.build-mode }}
+
+      - if: matrix.build-mode == 'manual'
+        shell: bash
+        run: |
+          pnpm run build
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v3
+        with:
+          category: "/language:${{matrix.language}}"

.github/workflows/lint-js.yml

@@ -36,7 +36,7 @@ jobs:
       - name: Set up pnpm package manager
         uses: pnpm/action-setup@v4
 
-      - name: Set up Node.js v22
+      - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
           node-version-file: .node-version

.github/workflows/release.yml

@@ -37,8 +37,23 @@ jobs:
     uses: ./.github/workflows/lint-rs.yml
     secrets: inherit
 
+  codeql:
+    name: CodeQL
+    uses: ./.github/workflows/codeql.yml
+    secrets: inherit
+    permissions:
+      security-events: write
+      contents: read
+      packages: read
+      actions: read
+
+  spellcheck:
+    name: Spell Check
+    uses: ./.github/workflows/spellcheck.yml
+    secrets: inherit
+
   release:
-    needs: [security-scan, lint-js, lint-rust]
+    needs: [security-scan, lint-js, lint-rust, codeql, spellcheck]
     permissions:
       contents: write
     strategy:

.github/workflows/rolling-release.yml

@@ -36,8 +36,23 @@ jobs:
     uses: ./.github/workflows/lint-rs.yml
     secrets: inherit
 
+  codeql:
+    name: CodeQL
+    uses: ./.github/workflows/codeql.yml
+    secrets: inherit
+    permissions:
+      security-events: write
+      contents: read
+      packages: read
+      actions: read
+
+  spellcheck:
+    name: Spell Check
+    uses: ./.github/workflows/spellcheck.yml
+    secrets: inherit
+
   rolling-release:
-    needs: [security-scan, lint-js, lint-rust]
+    needs: [security-scan, lint-js, lint-rust, codeql, spellcheck]
     permissions:
       contents: write
     strategy:

.github/workflows/spellcheck.yml

@@ -0,0 +1,26 @@
+name: Spell Check
+
+permissions:
+  contents: read
+
+on:
+  workflow_call:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  RUST_BACKTRACE: 1
+  CARGO_TERM_COLOR: always
+  CLICOLOR: 1
+
+jobs:
+  spelling:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Actions Repository
+        uses: actions/checkout@v4
+      - name: Spell Check Repo
+        uses: crate-ci/typos@v1.33.1

.vscode/settings.json

@@ -10,6 +10,7 @@
     "cdylib",
     "CFURL",
     "checkin",
+    "CLICOLOR",
     "clippy",
     "cmdk",
     "codegen",
@@ -41,6 +42,7 @@
     "msvc",
     "msys",
     "Mullvad",
+    "mullvadbrowser",
     "nodecar",
     "ntlm",
     "objc",
@@ -65,6 +67,7 @@
     "swatinem",
     "sysinfo",
     "systempreferences",
+    "taskkill",
     "tauri",
     "titlebar",
     "Torbrowser",

package.json

@@ -2,7 +2,7 @@
   "name": "donutbrowser",
   "private": true,
   "license": "AGPL-3.0",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "type": "module",
   "scripts": {
     "dev": "next dev --turbopack",

src-tauri/Cargo.lock

@@ -993,7 +993,7 @@ dependencies = [
 
 [[package]]
 name = "donutbrowser"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "async-trait",
  "base64 0.22.1",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "donutbrowser"
-version = "0.5.0"
+version = "0.5.1"
 description = "Simple Yet Powerful Browser Orchestrator"
 authors = ["zhom@github"]
 edition = "2021"

src-tauri/src/auto_updater.rs

@@ -5,6 +5,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::PathBuf;
+use tauri::Emitter;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct UpdateNotification {
@@ -45,15 +46,6 @@ impl AutoUpdater {
   pub async fn check_for_updates(
     &self,
   ) -> Result<Vec<UpdateNotification>, Box<dyn std::error::Error + Send + Sync>> {
-    // Check if auto-updates are enabled
-    let settings = self
-      .settings_manager
-      .load_settings()
-      .map_err(|e| format!("Failed to load settings: {e}"))?;
-    if !settings.auto_updates_enabled {
-      return Ok(Vec::new());
-    }
-
     let mut notifications = Vec::new();
     let mut browser_versions: HashMap<String, Vec<BrowserVersionInfo>> = HashMap::new();
 
@@ -130,6 +122,50 @@ impl AutoUpdater {
     Ok(notifications)
   }
 
+  pub async fn check_for_updates_with_progress(&self, app_handle: &tauri::AppHandle) {
+    // Check for browser updates and trigger auto-downloads
+    match self.check_for_updates().await {
+      Ok(update_notifications) => {
+        if !update_notifications.is_empty() {
+          println!(
+            "Found {} browser updates to auto-download",
+            update_notifications.len()
+          );
+
+          // Trigger automatic downloads for each update
+          for notification in update_notifications {
+            println!(
+              "Auto-downloading {} version {}",
+              notification.browser, notification.new_version
+            );
+
+            // Emit a custom event to trigger auto-download
+            let auto_update_event = serde_json::json!({
+              "browser": notification.browser,
+              "new_version": notification.new_version,
+              "notification_id": notification.id,
+              "affected_profiles": notification.affected_profiles
+            });
+
+            if let Err(e) = app_handle.emit("browser-auto-update-available", &auto_update_event) {
+              eprintln!(
+                "Failed to emit auto-update event for {}: {e}",
+                notification.browser
+              );
+            } else {
+              println!("Emitted auto-update event for {}", notification.browser);
+            }
+          }
+        } else {
+          println!("No browser updates needed");
+        }
+      }
+      Err(e) => {
+        eprintln!("Failed to check for browser updates: {e}");
+      }
+    }
+  }
+
   /// Check if a specific profile has an available update
   fn check_profile_update(
     &self,
@@ -206,43 +242,6 @@ impl AutoUpdater {
     result
   }
 
-  /// Mark download as auto-update
-  pub fn mark_auto_update_download(
-    &self,
-    browser: &str,
-    version: &str,
-  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    let mut state = self.load_auto_update_state()?;
-    let download_key = format!("{browser}-{version}");
-    state.auto_update_downloads.insert(download_key);
-    self.save_auto_update_state(&state)?;
-    Ok(())
-  }
-
-  /// Remove auto-update download tracking
-  pub fn remove_auto_update_download(
-    &self,
-    browser: &str,
-    version: &str,
-  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    let mut state = self.load_auto_update_state()?;
-    let download_key = format!("{browser}-{version}");
-    state.auto_update_downloads.remove(&download_key);
-    self.save_auto_update_state(&state)?;
-    Ok(())
-  }
-
-  /// Check if download is marked as auto-update
-  pub fn is_auto_update_download(
-    &self,
-    browser: &str,
-    version: &str,
-  ) -> Result<bool, Box<dyn std::error::Error + Send + Sync>> {
-    let state = self.load_auto_update_state()?;
-    let download_key = format!("{browser}-{version}");
-    Ok(state.auto_update_downloads.contains(&download_key))
-  }
-
   /// Automatically update all affected profile versions after browser download
   pub async fn auto_update_profile_versions(
     &self,
@@ -473,27 +472,9 @@ pub async fn complete_browser_update_with_auto_update(
 }
 
 #[tauri::command]
-pub async fn mark_auto_update_download(browser: String, version: String) -> Result<(), String> {
+pub async fn check_for_updates_with_progress(app_handle: tauri::AppHandle) {
   let updater = AutoUpdater::new();
-  updater
-    .mark_auto_update_download(&browser, &version)
-    .map_err(|e| format!("Failed to mark auto-update download: {e}"))
-}
-
-#[tauri::command]
-pub async fn remove_auto_update_download(browser: String, version: String) -> Result<(), String> {
-  let updater = AutoUpdater::new();
-  updater
-    .remove_auto_update_download(&browser, &version)
-    .map_err(|e| format!("Failed to remove auto-update download: {e}"))
-}
-
-#[tauri::command]
-pub async fn is_auto_update_download(browser: String, version: String) -> Result<bool, String> {
-  let updater = AutoUpdater::new();
-  updater
-    .is_auto_update_download(&browser, &version)
-    .map_err(|e| format!("Failed to check auto-update download: {e}"))
+  updater.check_for_updates_with_progress(&app_handle).await;
 }
 
 #[cfg(test)]

src-tauri/src/browser.rs

@@ -633,6 +633,7 @@ impl Browser for ChromiumBrowser {
       "--disable-component-update".to_string(),
       "--disable-background-timer-throttling".to_string(),
       "--crash-server-url=".to_string(),
+      "--disable-updater".to_string(),
     ];
 
     // Add proxy configuration if provided

src-tauri/src/browser_runner.rs

@@ -1277,9 +1277,13 @@ impl BrowserRunner {
   }
 
   /// Internal method to cleanup unused binaries (used by auto-cleanup)
-  fn cleanup_unused_binaries_internal(&self) -> Result<Vec<String>, Box<dyn std::error::Error>> {
+  fn cleanup_unused_binaries_internal(
+    &self,
+  ) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
     // Load current profiles
-    let profiles = self.list_profiles()?;
+    let profiles = self
+      .list_profiles()
+      .map_err(|e| format!("Failed to list profiles: {e}"))?;
 
     // Load registry
     let mut registry = crate::downloaded_browsers::DownloadedBrowsersRegistry::load()?;
@@ -1300,23 +1304,21 @@ impl BrowserRunner {
     vec![
       // Disable default browser check
       "user_pref(\"browser.shell.checkDefaultBrowser\", false);".to_string(),
-      // Disable automatic updates
       "user_pref(\"app.update.enabled\", false);".to_string(),
       "user_pref(\"app.update.auto\", false);".to_string(),
-      "user_pref(\"app.update.mode\", 0);".to_string(),
+      "user_pref(\"app.update.mode\", 2);".to_string(),
+      "user_pref(\"app.update.promptWaitTime\", 0);".to_string(),
       "user_pref(\"app.update.service.enabled\", false);".to_string(),
-      "user_pref(\"app.update.silent\", false);".to_string(),
-      // Disable update checking entirely
+      "user_pref(\"app.update.silent\", true);".to_string(),
       "user_pref(\"app.update.checkInstallTime\", false);".to_string(),
       "user_pref(\"app.update.url\", \"\");".to_string(),
       "user_pref(\"app.update.url.manual\", \"\");".to_string(),
       "user_pref(\"app.update.url.details\", \"\");".to_string(),
-      // Disable background update downloads
+      "user_pref(\"app.update.url.override\", \"\");".to_string(),
+      "user_pref(\"app.update.interval\", 9999999999);".to_string(),
+      "user_pref(\"app.update.background.interval\", 9999999999);".to_string(),
       "user_pref(\"app.update.download.attemptOnce\", false);".to_string(),
       "user_pref(\"app.update.idletime\", -1);".to_string(),
-      // Additional update-related preferences for completeness
-      "user_pref(\"security.tls.insecure_fallback_hosts\", \"\");".to_string(),
-      "user_pref(\"app.update.staging.enabled\", false);".to_string(),
     ]
   }
 
@@ -1911,7 +1913,10 @@ impl BrowserRunner {
     if let Ok(settings) = settings_manager.load_settings() {
       if settings.auto_delete_unused_binaries {
         // Perform cleanup in the background after profile deletion
-        let _ = self.cleanup_unused_binaries_internal();
+        // Ignore errors since this is not critical for profile deletion
+        if let Err(e) = self.cleanup_unused_binaries_internal() {
+          println!("Warning: Failed to cleanup unused binaries: {e}");
+        }
       }
     }
 
@@ -2912,7 +2917,13 @@ mod tests {
 
     // Create profile without proxy
     let profile = runner
-      .create_profile("Test Firefox Prefs", "firefox", "139.0", "stable", None)
+      .create_profile(
+        "Test Firefox Preferences",
+        "firefox",
+        "139.0",
+        "stable",
+        None,
+      )
       .unwrap();
 
     // Check that user.js file was created with default browser preference
@@ -2939,7 +2950,7 @@ mod tests {
 
     let profile_with_proxy = runner
       .create_profile(
-        "Test Firefox Prefs Proxy",
+        "Test Firefox Preferences Proxy",
         "firefox",
         "139.0",
         "stable",

src-tauri/src/browser_version_service.rs

@@ -142,11 +142,39 @@ impl BrowserVersionService {
     self.api_client.is_cache_expired(browser)
   }
 
-  /// Get latest stable and nightly versions for a browser
+  /// Get latest stable and nightly versions for a browser (cached first)
   pub async fn get_browser_release_types(
     &self,
     browser: &str,
   ) -> Result<BrowserReleaseTypes, Box<dyn std::error::Error + Send + Sync>> {
+    // Try to get from cache first
+    if let Some(cached_versions) = self.get_cached_browser_versions_detailed(browser) {
+      // For Chromium, only return stable since all releases are stable
+      if browser == "chromium" {
+        let latest_stable = cached_versions.first().map(|v| v.version.clone());
+        return Ok(BrowserReleaseTypes {
+          stable: latest_stable,
+          nightly: None,
+        });
+      }
+
+      let latest_stable = cached_versions
+        .iter()
+        .find(|v| !v.is_prerelease)
+        .map(|v| v.version.clone());
+
+      let latest_nightly = cached_versions
+        .iter()
+        .find(|v| v.is_prerelease)
+        .map(|v| v.version.clone());
+
+      return Ok(BrowserReleaseTypes {
+        stable: latest_stable,
+        nightly: latest_nightly,
+      });
+    }
+
+    // Fallback to fetching if not cached
     // For Chromium, only return stable since all releases are stable
     if browser == "chromium" {
       let detailed_versions = self.fetch_browser_versions_detailed(browser, false).await?;
@@ -338,6 +366,8 @@ impl BrowserVersionService {
         let releases = self.fetch_zen_releases_detailed(true).await?;
         merged_versions
           .into_iter()
+          // Filter out twilight releases at the detailed level too
+          .filter(|version| version.to_lowercase() != "twilight")
           .map(|version| {
             if let Some(release) = releases.iter().find(|r| r.tag_name == version) {
               BrowserVersionInfo {
@@ -424,7 +454,9 @@ impl BrowserVersionService {
           })
           .collect()
       }
-      _ => return Err(format!("Unsupported browser: {browser}").into()),
+      _ => {
+        return Err(format!("Unsupported browser: {browser}").into());
+      }
     };
 
     Ok(detailed_info)
@@ -785,7 +817,13 @@ impl BrowserVersionService {
     no_caching: bool,
   ) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
     let releases = self.fetch_zen_releases_detailed(no_caching).await?;
-    Ok(releases.into_iter().map(|r| r.tag_name).collect())
+    Ok(
+      releases
+        .into_iter()
+        .filter(|r| r.tag_name.to_lowercase() != "twilight")
+        .map(|r| r.tag_name)
+        .collect(),
+    )
   }
 
   async fn fetch_zen_releases_detailed(

src-tauri/src/downloaded_browsers.rs

@@ -27,7 +27,7 @@ impl DownloadedBrowsersRegistry {
     Self::default()
   }
 
-  pub fn load() -> Result<Self, Box<dyn std::error::Error>> {
+  pub fn load() -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
     let registry_path = Self::get_registry_path()?;
 
     if !registry_path.exists() {
@@ -39,7 +39,7 @@ impl DownloadedBrowsersRegistry {
     Ok(registry)
   }
 
-  pub fn save(&self) -> Result<(), Box<dyn std::error::Error>> {
+  pub fn save(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let registry_path = Self::get_registry_path()?;
 
     // Ensure parent directory exists
@@ -52,7 +52,7 @@ impl DownloadedBrowsersRegistry {
     Ok(())
   }
 
-  fn get_registry_path() -> Result<PathBuf, Box<dyn std::error::Error>> {
+  fn get_registry_path() -> Result<PathBuf, Box<dyn std::error::Error + Send + Sync>> {
     let base_dirs = BaseDirs::new().ok_or("Failed to get base directories")?;
     let mut path = base_dirs.data_local_dir().to_path_buf();
     path.push(if cfg!(debug_assertions) {
@@ -146,7 +146,7 @@ impl DownloadedBrowsersRegistry {
     &mut self,
     browser: &str,
     version: &str,
-  ) -> Result<(), Box<dyn std::error::Error>> {
+  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     if let Some(info) = self.remove_browser(browser, version) {
       // Clean up any files that might have been left behind
       if info.file_path.exists() {
@@ -180,7 +180,7 @@ impl DownloadedBrowsersRegistry {
   pub fn cleanup_unused_binaries(
     &mut self,
     active_profiles: &[(String, String)], // (browser, version) pairs
-  ) -> Result<Vec<String>, Box<dyn std::error::Error>> {
+  ) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
     let active_set: std::collections::HashSet<(String, String)> =
       active_profiles.iter().cloned().collect();
     let mut cleaned_up = Vec::new();

src-tauri/src/lib.rs

@@ -49,8 +49,7 @@ use version_updater::{
 
 use auto_updater::{
   check_for_browser_updates, complete_browser_update_with_auto_update, dismiss_update_notification,
-  is_auto_update_download, is_browser_disabled_for_update, mark_auto_update_download,
-  remove_auto_update_download,
+  is_browser_disabled_for_update,
 };
 
 use app_auto_updater::{
@@ -277,21 +276,36 @@ pub fn run() {
       let app_handle = app.handle().clone();
       tauri::async_runtime::spawn(async move {
         let version_updater = get_version_updater();
-        let mut updater_guard = version_updater.lock().await;
 
         // Set the app handle
-        updater_guard.set_app_handle(app_handle).await;
+        {
+          let mut updater_guard = version_updater.lock().await;
+          updater_guard.set_app_handle(app_handle);
+        }
 
-        // Start the background updates
-        updater_guard.start_background_updates().await;
+        // Run startup check without holding the lock
+        {
+          let updater_guard = version_updater.lock().await;
+          if let Err(e) = updater_guard.start_background_updates().await {
+            eprintln!("Failed to start background updates: {e}");
+          }
+        }
+      });
+
+      // Start the background update task separately
+      tauri::async_runtime::spawn(async move {
+        version_updater::VersionUpdater::run_background_task().await;
+      });
+
+      let app_handle_auto_updater = app.handle().clone();
+
+      // Start the auto-update check task separately
+      tauri::async_runtime::spawn(async move {
+        auto_updater::check_for_updates_with_progress(app_handle_auto_updater).await;
       });
 
-      // Check for app updates at startup
       let app_handle_update = app.handle().clone();
       tauri::async_runtime::spawn(async move {
-        // Add a small delay to ensure the app is fully loaded
-        tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
-
         println!("Starting app update check at startup...");
         let updater = app_auto_updater::AppAutoUpdater::new();
         match updater.check_for_updates().await {
@@ -354,9 +368,6 @@ pub fn run() {
       is_browser_disabled_for_update,
       dismiss_update_notification,
       complete_browser_update_with_auto_update,
-      mark_auto_update_download,
-      remove_auto_update_download,
-      is_auto_update_download,
       check_for_app_updates,
       check_for_app_updates_manual,
       download_and_install_app_update,

src-tauri/src/settings_manager.rs

@@ -4,7 +4,7 @@ use std::fs::{self, create_dir_all};
 use std::path::PathBuf;
 
 use crate::api_client::ApiClient;
-use crate::browser_version_service::BrowserVersionService;
+use crate::version_updater;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct TableSortingSettings {
@@ -25,40 +25,25 @@ impl Default for TableSortingSettings {
 pub struct AppSettings {
   #[serde(default)]
   pub set_as_default_browser: bool,
-  #[serde(default = "default_show_settings_on_startup")]
+  #[serde(default)]
   pub show_settings_on_startup: bool,
   #[serde(default = "default_theme")]
   pub theme: String, // "light", "dark", or "system"
-  #[serde(default = "default_auto_updates_enabled")]
-  pub auto_updates_enabled: bool,
-  #[serde(default = "default_auto_delete_unused_binaries")]
+  #[serde(default)]
   pub auto_delete_unused_binaries: bool,
 }
 
-fn default_show_settings_on_startup() -> bool {
-  true
-}
-
 fn default_theme() -> String {
   "system".to_string()
 }
 
-fn default_auto_updates_enabled() -> bool {
-  true
-}
-
-fn default_auto_delete_unused_binaries() -> bool {
-  true
-}
-
 impl Default for AppSettings {
   fn default() -> Self {
     Self {
       set_as_default_browser: false,
-      show_settings_on_startup: default_show_settings_on_startup(),
-      theme: default_theme(),
-      auto_updates_enabled: default_auto_updates_enabled(),
-      auto_delete_unused_binaries: default_auto_delete_unused_binaries(),
+      show_settings_on_startup: true,
+      theme: "system".to_string(),
+      auto_delete_unused_binaries: true,
     }
   }
 }
@@ -216,7 +201,9 @@ pub async fn save_table_sorting_settings(sorting: TableSortingSettings) -> Resul
 }
 
 #[tauri::command]
-pub async fn clear_all_version_cache_and_refetch() -> Result<(), String> {
+pub async fn clear_all_version_cache_and_refetch(
+  app_handle: tauri::AppHandle,
+) -> Result<(), String> {
   let api_client = ApiClient::new();
 
   // Clear all cache first
@@ -224,23 +211,13 @@ 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 only supported browsers
-  let service = BrowserVersionService::new();
-  let supported_browsers = service.get_supported_browsers();
+  let updater = version_updater::get_version_updater();
+  let updater_guard = updater.lock().await;
 
-  for browser in supported_browsers {
-    // 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 {
-      if let Err(e) = service_clone
-        .fetch_browser_versions_detailed(&browser_clone, false)
-        .await
-      {
-        eprintln!("Background version fetch failed for {browser_clone}: {e}");
-      }
-    });
-  }
+  updater_guard
+    .trigger_manual_update(&app_handle)
+    .await
+    .map_err(|e| format!("Failed to trigger version update: {e}"))?;
 
   Ok(())
 }

src-tauri/src/version_updater.rs

@@ -1,4 +1,3 @@
-use crate::browser_version_service::BrowserVersionService;
 use directories::BaseDirs;
 use serde::{Deserialize, Serialize};
 use std::fs;
@@ -8,7 +7,10 @@ use std::sync::OnceLock;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tauri::Emitter;
 use tokio::sync::Mutex;
-use tokio::time::{interval, Interval};
+use tokio::time::interval;
+
+use crate::auto_updater::AutoUpdater;
+use crate::browser_version_service::BrowserVersionService;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct VersionUpdateProgress {
@@ -46,22 +48,23 @@ impl Default for BackgroundUpdateState {
 
 pub struct VersionUpdater {
   version_service: BrowserVersionService,
-  app_handle: Arc<Mutex<Option<tauri::AppHandle>>>,
-  update_interval: Interval,
+  auto_updater: AutoUpdater,
+  app_handle: Option<tauri::AppHandle>,
 }
 
 impl VersionUpdater {
   pub fn new() -> Self {
-    let mut update_interval = interval(Duration::from_secs(5 * 60)); // Check every 5 minutes
-    update_interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
-
     Self {
       version_service: BrowserVersionService::new(),
-      app_handle: Arc::new(Mutex::new(None)),
-      update_interval,
+      auto_updater: AutoUpdater::new(),
+      app_handle: None,
     }
   }
 
+  pub fn set_app_handle(&mut self, app_handle: tauri::AppHandle) {
+    self.app_handle = Some(app_handle);
+  }
+
   fn get_cache_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
     let base_dirs = BaseDirs::new().ok_or("Failed to get base directories")?;
     let app_name = if cfg!(debug_assertions) {
@@ -143,11 +146,6 @@ impl VersionUpdater {
     should_update
   }
 
-  pub async fn set_app_handle(&self, app_handle: tauri::AppHandle) {
-    let mut handle = self.app_handle.lock().await;
-    *handle = Some(app_handle);
-  }
-
   pub async fn check_and_run_startup_update(
     &self,
   ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
@@ -157,15 +155,10 @@ impl VersionUpdater {
       return Ok(());
     }
 
-    let app_handle = {
-      let handle_guard = self.app_handle.lock().await;
-      handle_guard.clone()
-    };
-
-    if let Some(handle) = app_handle {
+    if let Some(ref app_handle) = self.app_handle {
       println!("Running startup version update...");
 
-      match self.update_all_browser_versions(&handle).await {
+      match self.update_all_browser_versions(app_handle).await {
         Ok(_) => {
           // Update the persistent state after successful update
           let state = BackgroundUpdateState {
@@ -191,7 +184,9 @@ impl VersionUpdater {
     Ok(())
   }
 
-  pub async fn start_background_updates(&mut self) {
+  pub async fn start_background_updates(
+    &self,
+  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     println!(
       "Starting background version update service (checking every 5 minutes for 3-hour intervals)"
     );
@@ -201,41 +196,54 @@ impl VersionUpdater {
       eprintln!("Startup version update failed: {e}");
     }
 
+    Ok(())
+  }
+
+  pub async fn run_background_task() {
+    let mut update_interval = interval(Duration::from_secs(5 * 60)); // Check every 5 minutes
+    update_interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+
     loop {
-      self.update_interval.tick().await;
+      update_interval.tick().await;
 
       // Check if we should run an update based on persistent state
       if !Self::should_run_background_update() {
         continue;
       }
 
-      // Check if we have an app handle
-      let app_handle = {
-        let handle_guard = self.app_handle.lock().await;
-        handle_guard.clone()
-      };
+      println!("Starting background version update...");
 
-      if let Some(handle) = app_handle {
-        println!("Starting background version update...");
+      // Get the updater instance for this update cycle
+      let updater = get_version_updater();
+      let result = {
+        let updater_guard = updater.lock().await;
+        if let Some(ref app_handle) = updater_guard.app_handle {
+          updater_guard.update_all_browser_versions(app_handle).await
+        } else {
+          Err("App handle not available for background update".into())
+        }
+      }; // Release the lock here
 
-        match self.update_all_browser_versions(&handle).await {
-          Ok(_) => {
-            // Update the persistent state after successful update
-            let state = BackgroundUpdateState {
-              last_update_time: Self::get_current_timestamp(),
-              update_interval_hours: 3,
-            };
+      match result {
+        Ok(_) => {
+          // Update the persistent state after successful update
+          let state = BackgroundUpdateState {
+            last_update_time: Self::get_current_timestamp(),
+            update_interval_hours: 3,
+          };
 
-            if let Err(e) = Self::save_background_update_state(&state) {
-              eprintln!("Failed to save background update state: {e}");
-            } else {
-              println!("Background version update completed successfully");
-            }
+          if let Err(e) = Self::save_background_update_state(&state) {
+            eprintln!("Failed to save background update state: {e}");
+          } else {
+            println!("Background version update completed successfully");
           }
-          Err(e) => {
-            eprintln!("Background version update failed: {e}");
+        }
+        Err(e) => {
+          eprintln!("Background version update failed: {e}");
 
-            // Emit error event
+          // Try to emit error event if we have an app handle
+          let updater_guard = updater.lock().await;
+          if let Some(ref app_handle) = updater_guard.app_handle {
             let progress = VersionUpdateProgress {
               current_browser: "".to_string(),
               total_browsers: 0,
@@ -244,11 +252,9 @@ impl VersionUpdater {
               browser_new_versions: 0,
               status: "error".to_string(),
             };
-            let _ = handle.emit("version-update-progress", &progress);
+            let _ = app_handle.emit("version-update-progress", &progress);
           }
         }
-      } else {
-        println!("App handle not available, skipping background update");
       }
     }
   }
@@ -300,10 +306,36 @@ impl VersionUpdater {
       browser_new_versions: 0,
       status: "updating".to_string(),
     };
-    let _ = app_handle.emit("version-update-progress", &progress);
+    if let Err(e) = app_handle.emit("version-update-progress", &progress) {
+      eprintln!("Failed to emit start progress: {e}");
+    } else {
+      println!("Emitted start progress event");
+    }
 
     for (index, browser) in browsers.iter().enumerate() {
-      // Check if individual browser cache is expired before updating
+      println!(
+        "Processing browser {} ({}/{}): {}",
+        browser,
+        index + 1,
+        total_browsers,
+        browser
+      );
+
+      // Emit progress for current browser
+      let progress = VersionUpdateProgress {
+        current_browser: browser.to_string(),
+        total_browsers,
+        completed_browsers: index,
+        new_versions_found: total_new_versions,
+        browser_new_versions: 0,
+        status: "updating".to_string(),
+      };
+      if let Err(e) = app_handle.emit("version-update-progress", &progress) {
+        eprintln!("Failed to emit progress for {browser}: {e}");
+      } else {
+        println!("Emitted progress event for browser: {browser}");
+      }
+
       if !self.version_service.should_update_cache(browser) {
         println!("Skipping {browser} - cache is still fresh");
 
@@ -318,18 +350,7 @@ impl VersionUpdater {
         continue;
       }
 
-      println!("Updating versions for browser: {browser}");
-
-      // Emit progress for current browser
-      let progress = VersionUpdateProgress {
-        current_browser: browser.to_string(),
-        total_browsers,
-        completed_browsers: index,
-        new_versions_found: total_new_versions,
-        browser_new_versions: 0,
-        status: "updating".to_string(),
-      };
-      let _ = app_handle.emit("version-update-progress", &progress);
+      println!("Fetching new versions for browser: {browser}");
 
       let result = self.update_browser_versions(browser).await;
 
@@ -361,9 +382,14 @@ impl VersionUpdater {
       }
 
       // Small delay between browsers to avoid overwhelming APIs
-      tokio::time::sleep(Duration::from_millis(500)).await;
+      tokio::time::sleep(Duration::from_millis(200)).await;
     }
 
+    self
+      .auto_updater
+      .check_for_updates_with_progress(app_handle)
+      .await;
+
     // Emit completion event
     let progress = VersionUpdateProgress {
       current_browser: "".to_string(),
@@ -373,9 +399,13 @@ impl VersionUpdater {
       browser_new_versions: 0,
       status: "completed".to_string(),
     };
-    let _ = app_handle.emit("version-update-progress", &progress);
+    if let Err(e) = app_handle.emit("version-update-progress", &progress) {
+      eprintln!("Failed to emit completion progress: {e}");
+    } else {
+      println!("Emitted completion progress event");
+    }
 
-    println!("Background version update completed. Found {total_new_versions} new versions total");
+    println!("Version update completed. Found {total_new_versions} new versions total");
 
     Ok(results)
   }

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Donut Browser",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "identifier": "com.donutbrowser",
   "build": {
     "beforeDevCommand": "pnpm dev",

src/app/page.tsx

@@ -25,6 +25,7 @@ import { useAppUpdateNotifications } from "@/hooks/use-app-update-notifications"
 import { usePermissions } from "@/hooks/use-permissions";
 import type { PermissionType } from "@/hooks/use-permissions";
 import { useUpdateNotifications } from "@/hooks/use-update-notifications";
+import { useVersionUpdater } from "@/hooks/use-version-updater";
 import { showErrorToast } from "@/lib/toast-utils";
 import type { BrowserProfile, ProxySettings } from "@/types";
 import { invoke } from "@tauri-apps/api/core";
@@ -81,7 +82,10 @@ export default function Home() {
     }
   }, []);
 
-  // Auto-update functionality - pass loadProfiles to refresh profiles after updates
+  // Version updater for handling version fetching progress events and auto-updates
+  useVersionUpdater();
+
+  // Auto-update functionality - use the existing hook for compatibility
   const updateNotifications = useUpdateNotifications(loadProfiles);
   const { checkForUpdates, isUpdating } = updateNotifications;
 

src/components/change-version-dialog.tsx

@@ -14,6 +14,7 @@ import {
 } from "@/components/ui/dialog";
 import { Label } from "@/components/ui/label";
 import { useBrowserDownload } from "@/hooks/use-browser-download";
+import { getBrowserDisplayName } from "@/lib/browser-utils";
 import type { BrowserProfile, BrowserReleaseTypes } from "@/types";
 import { invoke } from "@tauri-apps/api/core";
 import { useEffect, useState } from "react";
@@ -153,43 +154,51 @@ export function ChangeVersionDialog({
         <div className="grid gap-4 py-4">
           <div className="space-y-2">
             <Label className="text-sm font-medium">Profile:</Label>
-            <div className="p-2 bg-muted rounded text-sm">{profile.name}</div>
+            <div className="p-2 text-sm rounded bg-muted">{profile.name}</div>
           </div>
 
           <div className="space-y-2">
             <Label className="text-sm font-medium">Current Release:</Label>
-            <div className="p-2 bg-muted rounded text-sm capitalize">
+            <div className="p-2 text-sm capitalize rounded bg-muted">
               {profile.release_type} ({profile.version})
             </div>
           </div>
 
-          {/* Release Type Selection */}
-          <div className="grid gap-2">
-            <Label>New Release Type</Label>
-            {isLoadingReleaseTypes ? (
-              <div className="text-sm text-muted-foreground">
-                Loading release types...
-              </div>
-            ) : (
-              <ReleaseTypeSelector
-                selectedReleaseType={selectedReleaseType}
-                onReleaseTypeSelect={setSelectedReleaseType}
-                availableReleaseTypes={releaseTypes}
-                browser={profile.browser}
-                isDownloading={isDownloading}
-                onDownload={() => {
-                  void handleDownload();
-                }}
-                placeholder="Select release type..."
-                downloadedVersions={downloadedVersions}
-              />
-            )}
-          </div>
+          {!releaseTypes.stable || !releaseTypes.nightly ? (
+            <Alert>
+              <AlertDescription>
+                Only {profile.release_type} releases are available for{" "}
+                {getBrowserDisplayName(profile.browser)}.
+              </AlertDescription>
+            </Alert>
+          ) : (
+            <div className="grid gap-2">
+              <Label>New Release Type</Label>
+              {isLoadingReleaseTypes ? (
+                <div className="text-sm text-muted-foreground">
+                  Loading release types...
+                </div>
+              ) : (
+                <ReleaseTypeSelector
+                  selectedReleaseType={selectedReleaseType}
+                  onReleaseTypeSelect={setSelectedReleaseType}
+                  availableReleaseTypes={releaseTypes}
+                  browser={profile.browser}
+                  isDownloading={isDownloading}
+                  onDownload={() => {
+                    void handleDownload();
+                  }}
+                  placeholder="Select release type..."
+                  downloadedVersions={downloadedVersions}
+                />
+              )}
+            </div>
+          )}
 
           {/* Downgrade Warning */}
           {showDowngradeWarning && (
             <Alert className="border-orange-700">
-              <LuTriangleAlert className="h-4 w-4 text-orange-700" />
+              <LuTriangleAlert className="w-4 h-4 text-orange-700" />
               <AlertTitle className="text-orange-700">
                 Stability Warning
               </AlertTitle>
@@ -197,7 +206,7 @@ export function ChangeVersionDialog({
                 You are about to switch from stable to nightly releases. Nightly
                 versions may be less stable and could contain bugs or incomplete
                 features.
-                <div className="flex items-center space-x-2 mt-3">
+                <div className="flex items-center mt-3 space-x-2">
                   <Checkbox
                     id="acknowledge-downgrade"
                     checked={acknowledgeDowngrade}

src/components/create-profile-dialog.tsx

@@ -36,6 +36,7 @@ import type {
 import { invoke } from "@tauri-apps/api/core";
 import { useEffect, useState } from "react";
 import { toast } from "sonner";
+import { Alert, AlertDescription } from "./ui/alert";
 
 type BrowserTypeString =
   | "mullvad-browser"
@@ -369,28 +370,37 @@ export function CreateProfileDialog({
             </Select>
           </div>
 
-          {/* Release Type Selection */}
-          <div className="grid gap-2">
-            <Label>Release Type</Label>
-            {isLoadingReleaseTypes ? (
-              <div className="text-sm text-muted-foreground">
-                Loading release types...
-              </div>
-            ) : (
-              <ReleaseTypeSelector
-                selectedReleaseType={selectedReleaseType}
-                onReleaseTypeSelect={setSelectedReleaseType}
-                availableReleaseTypes={releaseTypes}
-                browser={selectedBrowser ?? ""}
-                isDownloading={isDownloading}
-                onDownload={() => {
-                  void handleDownload();
-                }}
-                placeholder="Select release type..."
-                downloadedVersions={downloadedVersions}
-              />
-            )}
-          </div>
+          {selectedBrowser &&
+          (!releaseTypes.stable || !releaseTypes.nightly) ? (
+            <Alert>
+              <AlertDescription>
+                Only {(releaseTypes.stable && "Stable") ?? "Nightly"} releases
+                are available for {getBrowserDisplayName(selectedBrowser)}.
+              </AlertDescription>
+            </Alert>
+          ) : (
+            <div className="grid gap-2">
+              <Label>Release Type</Label>
+              {isLoadingReleaseTypes ? (
+                <div className="text-sm text-muted-foreground">
+                  Loading release types...
+                </div>
+              ) : (
+                <ReleaseTypeSelector
+                  selectedReleaseType={selectedReleaseType}
+                  onReleaseTypeSelect={setSelectedReleaseType}
+                  availableReleaseTypes={releaseTypes}
+                  browser={selectedBrowser ?? ""}
+                  isDownloading={isDownloading}
+                  onDownload={() => {
+                    void handleDownload();
+                  }}
+                  placeholder="Select release type..."
+                  downloadedVersions={downloadedVersions}
+                />
+              )}
+            </div>
+          )}
 
           {/* Proxy Settings */}
           <div className="grid gap-4 pt-4 border-t">

src/components/profile-data-table.tsx

@@ -379,16 +379,18 @@ export function ProfilesDataTable({
                     }}
                     disabled={!isClient || isBrowserUpdating}
                   >
-                    Configure proxy
-                  </DropdownMenuItem>
-                  <DropdownMenuItem
-                    onClick={() => {
-                      onChangeVersion(profile);
-                    }}
-                    disabled={!isClient || isRunning || isBrowserUpdating}
-                  >
-                    Switch Release
+                    Configure Proxy
                   </DropdownMenuItem>
+                  {!["chromium", "zen"].includes(profile.browser) && (
+                    <DropdownMenuItem
+                      onClick={() => {
+                        onChangeVersion(profile);
+                      }}
+                      disabled={!isClient || isRunning || isBrowserUpdating}
+                    >
+                      Switch Release
+                    </DropdownMenuItem>
+                  )}
                   <DropdownMenuItem
                     onClick={() => {
                       setProfileToRename(profile);

src/components/settings-dialog.tsx

@@ -31,7 +31,6 @@ interface AppSettings {
   set_as_default_browser: boolean;
   show_settings_on_startup: boolean;
   theme: string;
-  auto_updates_enabled: boolean;
   auto_delete_unused_binaries: boolean;
 }
 
@@ -51,14 +50,12 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     set_as_default_browser: false,
     show_settings_on_startup: true,
     theme: "system",
-    auto_updates_enabled: true,
     auto_delete_unused_binaries: true,
   });
   const [originalSettings, setOriginalSettings] = useState<AppSettings>({
     set_as_default_browser: false,
     show_settings_on_startup: true,
     theme: "system",
-    auto_updates_enabled: true,
     auto_delete_unused_binaries: true,
   });
   const [isDefaultBrowser, setIsDefaultBrowser] = useState(false);
@@ -291,7 +288,6 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     settings.show_settings_on_startup !==
       originalSettings.show_settings_on_startup ||
     settings.theme !== originalSettings.theme ||
-    settings.auto_updates_enabled !== originalSettings.auto_updates_enabled ||
     settings.auto_delete_unused_binaries !==
       originalSettings.auto_delete_unused_binaries;
 
@@ -366,19 +362,6 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
           <div className="space-y-4">
             <Label className="text-base font-medium">Auto-Updates</Label>
 
-            <div className="flex items-center space-x-2">
-              <Checkbox
-                id="auto-updates"
-                checked={settings.auto_updates_enabled}
-                onCheckedChange={(checked) => {
-                  updateSetting("auto_updates_enabled", checked as boolean);
-                }}
-              />
-              <Label htmlFor="auto-updates" className="text-sm">
-                Enable automatic browser updates
-              </Label>
-            </div>
-
             <div className="flex items-center space-x-2">
               <Checkbox
                 id="auto-delete-binaries"

src/components/version-update-settings.tsx

@@ -1,127 +0,0 @@
-"use client";
-
-import { LoadingButton } from "@/components/loading-button";
-import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
-import {
-  Card,
-  CardContent,
-  CardDescription,
-  CardHeader,
-  CardTitle,
-} from "@/components/ui/card";
-import { useVersionUpdater } from "@/hooks/use-version-updater";
-import {
-  LuCheckCheck,
-  LuCircleAlert,
-  LuClock,
-  LuRefreshCw,
-} from "react-icons/lu";
-
-export function VersionUpdateSettings() {
-  const {
-    isUpdating,
-    lastUpdateTime,
-    timeUntilNextUpdate,
-    updateProgress,
-    triggerManualUpdate,
-    formatTimeUntilUpdate,
-    formatLastUpdateTime,
-  } = useVersionUpdater();
-
-  return (
-    <Card>
-      <CardHeader>
-        <CardTitle className="flex gap-2 items-center">
-          <LuRefreshCw className="w-5 h-5" />
-          Background Version Updates
-        </CardTitle>
-        <CardDescription>
-          Browser versions are automatically checked every 3 hours in the
-          background. New versions are cached and ready when you need them.
-        </CardDescription>
-      </CardHeader>
-      <CardContent className="space-y-4">
-        {/* Current Status */}
-        <div className="grid gap-4 md:grid-cols-2">
-          <div className="space-y-2">
-            <div className="flex gap-2 items-center text-sm font-medium">
-              <LuClock className="w-4 h-4" />
-              Last Update
-            </div>
-            <div className="text-sm text-muted-foreground">
-              {formatLastUpdateTime(lastUpdateTime)}
-            </div>
-          </div>
-
-          <div className="space-y-2">
-            <div className="flex gap-2 items-center text-sm font-medium">
-              <LuCheckCheck className="w-4 h-4" />
-              Next Update
-            </div>
-            <div className="text-sm text-muted-foreground">
-              {timeUntilNextUpdate <= 0
-                ? "Now"
-                : `In ${formatTimeUntilUpdate(timeUntilNextUpdate)}`}
-            </div>
-          </div>
-        </div>
-
-        {/* Progress indicator */}
-        {isUpdating && updateProgress && (
-          <Alert>
-            <LuRefreshCw className="w-4 h-4 animate-spin" />
-            <AlertTitle>Updating Browser Versions</AlertTitle>
-            <AlertDescription>
-              {updateProgress.current_browser ? (
-                <>
-                  Looking for updates for {updateProgress.current_browser} (
-                  {updateProgress.completed_browsers}/
-                  {updateProgress.total_browsers})
-                </>
-              ) : (
-                "Starting version update..."
-              )}
-            </AlertDescription>
-          </Alert>
-        )}
-
-        {/* Manual update button */}
-        <div className="flex justify-between items-center pt-2 border-t">
-          <div className="space-y-1">
-            <div className="text-sm font-medium">Manual Update</div>
-            <div className="text-xs text-muted-foreground">
-              Check for new browser versions now
-            </div>
-          </div>
-          <LoadingButton
-            isLoading={isUpdating}
-            onClick={() => {
-              void triggerManualUpdate();
-            }}
-            variant="outline"
-            size="sm"
-            disabled={isUpdating}
-          >
-            <LuRefreshCw className="mr-2 w-4 h-4" />
-            {isUpdating ? "Updating..." : "Check Now"}
-          </LoadingButton>
-        </div>
-
-        {/* Information about background updates */}
-        <Alert>
-          <LuCircleAlert className="w-4 h-4" />
-          <AlertTitle>How it works</AlertTitle>
-          <AlertDescription className="text-xs">
-            • Version information is checked automatically every 3 hours
-            <br />• New versions are added to the cache without removing old
-            ones
-            <br />• When creating profiles or changing versions, you&apos;ll see
-            how many new versions were found
-            <br />• This keeps the app responsive while ensuring you have the
-            latest information
-          </AlertDescription>
-        </Alert>
-      </CardContent>
-    </Card>
-  );
-}

src/hooks/use-browser-download.ts

@@ -60,53 +60,29 @@ export function useBrowserDownload() {
 
       const browserName = getBrowserDisplayName(progress.browser);
 
-      // Check if this is an auto-update download to suppress completion toast
-      const checkAutoUpdate = async () => {
-        let isAutoUpdate = false;
-        try {
-          isAutoUpdate = await invoke<boolean>("is_auto_update_download", {
-            browser: progress.browser,
-            version: progress.version,
-          });
-        } catch (error) {
-          console.error("Failed to check auto-update status:", error);
-        }
+      // Show toast with progress
+      if (progress.stage === "downloading") {
+        const speedMBps = (
+          progress.speed_bytes_per_sec /
+          (1024 * 1024)
+        ).toFixed(1);
+        const etaText = progress.eta_seconds
+          ? formatTime(progress.eta_seconds)
+          : "calculating...";
 
-        // Show toast with progress
-        if (progress.stage === "downloading") {
-          const speedMBps = (
-            progress.speed_bytes_per_sec /
-            (1024 * 1024)
-          ).toFixed(1);
-          const etaText = progress.eta_seconds
-            ? formatTime(progress.eta_seconds)
-            : "calculating...";
-
-          showDownloadToast(browserName, progress.version, "downloading", {
-            percentage: progress.percentage,
-            speed: speedMBps,
-            eta: etaText,
-          });
-        } else if (progress.stage === "extracting") {
-          showDownloadToast(browserName, progress.version, "extracting");
-        } else if (progress.stage === "verifying") {
-          showDownloadToast(browserName, progress.version, "verifying");
-        } else if (progress.stage === "completed") {
-          // Suppress completion toast for auto-updates
-          showDownloadToast(
-            browserName,
-            progress.version,
-            "completed",
-            undefined,
-            {
-              suppressCompletionToast: isAutoUpdate,
-            },
-          );
-          setDownloadProgress(null);
-        }
-      };
-
-      void checkAutoUpdate();
+        showDownloadToast(browserName, progress.version, "downloading", {
+          percentage: progress.percentage,
+          speed: speedMBps,
+          eta: etaText,
+        });
+      } else if (progress.stage === "extracting") {
+        showDownloadToast(browserName, progress.version, "extracting");
+      } else if (progress.stage === "verifying") {
+        showDownloadToast(browserName, progress.version, "verifying");
+      } else if (progress.stage === "completed") {
+        showDownloadToast(browserName, progress.version, "completed");
+        setDownloadProgress(null);
+      }
     });
 
     return () => {

src/hooks/use-update-notifications.tsx

@@ -1,7 +1,7 @@
 import { getBrowserDisplayName } from "@/lib/browser-utils";
-import { showAutoUpdateToast, showToast } from "@/lib/toast-utils";
+import { dismissToast, showToast } from "@/lib/toast-utils";
 import { invoke } from "@tauri-apps/api/core";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useRef, useState } from "react";
 
 interface UpdateNotification {
   id: string;
@@ -25,6 +25,11 @@ export function useUpdateNotifications(
     Set<string>
   >(new Set());
 
+  const isUpdating = useCallback(
+    (browser: string) => updatingBrowsers.has(browser),
+    [updatingBrowsers],
+  );
+
   // Add refs to track ongoing operations to prevent duplicates
   const isCheckingForUpdates = useRef(false);
   const activeDownloads = useRef<Set<string>>(new Set()); // Track "browser-version" keys
@@ -83,11 +88,11 @@ export function useUpdateNotifications(
         return;
       }
 
-      // Mark download as active
+      // Mark download as active and disable browser
       activeDownloads.current.add(downloadKey);
+      setUpdatingBrowsers((prev) => new Set(prev).add(browser));
 
       try {
-        setUpdatingBrowsers((prev) => new Set(prev).add(browser));
         const browserDisplayName = getBrowserDisplayName(browser);
 
         // Dismiss the notification in the backend
@@ -95,8 +100,14 @@ export function useUpdateNotifications(
           notificationId,
         });
 
-        // Show auto-update started toast
-        showAutoUpdateToast(browserDisplayName, newVersion);
+        // Show update started notification
+        showToast({
+          id: `auto-update-started-${browser}-${newVersion}`,
+          type: "loading",
+          title: `${browserDisplayName} update started`,
+          description: `Version ${newVersion} download will begin shortly. Browser launch is disabled until update completes.`,
+          duration: 4000,
+        });
 
         try {
           // Check if browser already exists before downloading
@@ -110,14 +121,25 @@ export function useUpdateNotifications(
             console.log(
               `${browserDisplayName} ${newVersion} already exists, skipping download`,
             );
+
+            showToast({
+              id: `auto-update-skip-download-${browser}-${newVersion}`,
+              type: "success",
+              title: `${browserDisplayName} ${newVersion} already available`,
+              description: "Updating profile configurations...",
+              duration: 3000,
+            });
           } else {
-            // Mark download as auto-update in the backend for toast suppression
-            await invoke("mark_auto_update_download", {
-              browser,
-              version: newVersion,
+            // Show download starting notification
+            showToast({
+              id: `auto-update-download-starting-${browser}-${newVersion}`,
+              type: "loading",
+              title: `Starting ${browserDisplayName} ${newVersion} download`,
+              description: "Download progress will be shown below...",
+              duration: 4000,
             });
 
-            // Download the browser (progress will be handled by use-browser-download hook)
+            // Download the browser - this will trigger download progress events automatically
             await invoke("download_browser", {
               browserStr: browser,
               version: newVersion,
@@ -144,61 +166,41 @@ export function useUpdateNotifications(
               id: `auto-update-success-${browser}-${newVersion}`,
               type: "success",
               title: `${browserDisplayName} update completed`,
-              description: `${profileText} to version ${newVersion}. To update running profiles, restart them.`,
-              duration: 5000,
+              description: `${profileText} to version ${newVersion}. You can now launch your browsers with the latest version.`,
+              duration: 6000,
             });
           } else {
             showToast({
               id: `auto-update-success-${browser}-${newVersion}`,
               type: "success",
-              title: `${browserDisplayName} update ready`,
-              description:
-                "All affected profiles are currently running. To update them, restart them.",
-              duration: 5000,
+              title: `${browserDisplayName} update completed`,
+              description: `Version ${newVersion} is now available. Running profiles will use the new version when restarted.`,
+              duration: 6000,
             });
           }
 
-          // Trigger profile refresh to update UI with new versions
           if (onProfilesUpdated) {
-            void onProfilesUpdated();
+            await onProfilesUpdated();
           }
         } catch (downloadError) {
           console.error("Failed to download browser:", downloadError);
 
-          // Clean up auto-update tracking on error
-          try {
-            await invoke("remove_auto_update_download", {
-              browser,
-              version: newVersion,
-            });
-          } catch (e) {
-            console.error("Failed to clean up auto-update tracking:", e);
-          }
+          dismissToast(`download-${browser}-${newVersion}`);
 
           showToast({
             id: `auto-update-error-${browser}-${newVersion}`,
             type: "error",
             title: `Failed to download ${browserDisplayName} ${newVersion}`,
             description: String(downloadError),
-            duration: 6000,
+            duration: 8000,
           });
           throw downloadError;
         }
-
-        // Don't call checkForUpdates() again here as it can cause recursion and duplicates
-        // The periodic checks will handle finding any remaining updates
       } catch (error) {
         console.error("Failed to start auto-update:", error);
-        const browserDisplayName = getBrowserDisplayName(browser);
-        showToast({
-          id: `auto-update-error-${browser}-${newVersion}`,
-          type: "error",
-          title: `Failed to update ${browserDisplayName}`,
-          description: String(error),
-          duration: 6000,
-        });
+        throw error;
       } finally {
-        // Remove from active downloads and updating browsers
+        // Clean up
         activeDownloads.current.delete(downloadKey);
         setUpdatingBrowsers((prev) => {
           const next = new Set(prev);
@@ -210,19 +212,9 @@ export function useUpdateNotifications(
     [onProfilesUpdated],
   );
 
-  // Clean up notifications when they're no longer needed
-  useEffect(() => {
-    // Remove notifications that have been processed
-    setNotifications((prev) =>
-      prev.filter(
-        (notification) => !processedNotifications.has(notification.id),
-      ),
-    );
-  }, [processedNotifications]);
-
   return {
     notifications,
+    isUpdating,
     checkForUpdates,
-    isUpdating: (browser: string) => updatingBrowsers.has(browser),
   };
 }

src/hooks/use-version-updater.ts

@@ -1,9 +1,14 @@
 import { getBrowserDisplayName } from "@/lib/browser-utils";
-import { dismissToast, showUnifiedVersionUpdateToast } from "@/lib/toast-utils";
+import {
+  dismissToast,
+  showAutoUpdateToast,
+  showErrorToast,
+  showSuccessToast,
+  showUnifiedVersionUpdateToast,
+} from "@/lib/toast-utils";
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 import { useCallback, useEffect, useState } from "react";
-import { toast } from "sonner";
 
 interface VersionUpdateProgress {
   current_browser: string;
@@ -28,6 +33,13 @@ interface BrowserVersionsResult {
   total_versions_count: number;
 }
 
+interface AutoUpdateEvent {
+  browser: string;
+  new_version: string;
+  notification_id: string;
+  affected_profiles: string[];
+}
+
 export function useVersionUpdater() {
   const [isUpdating, setIsUpdating] = useState(false);
   const [lastUpdateTime, setLastUpdateTime] = useState<number | null>(null);
@@ -35,6 +47,18 @@ export function useVersionUpdater() {
   const [updateProgress, setUpdateProgress] =
     useState<VersionUpdateProgress | null>(null);
 
+  const loadUpdateStatus = useCallback(async () => {
+    try {
+      const [lastUpdate, timeUntilNext] = await invoke<[number | null, number]>(
+        "get_version_update_status",
+      );
+      setLastUpdateTime(lastUpdate);
+      setTimeUntilNextUpdate(timeUntilNext);
+    } catch (error) {
+      console.error("Failed to load version update status:", error);
+    }
+  }, []);
+
   // Listen for version update progress events
   useEffect(() => {
     const unlisten = listen<VersionUpdateProgress>(
@@ -68,13 +92,13 @@ export function useVersionUpdater() {
           dismissToast("unified-version-update");
 
           if (progress.new_versions_found > 0) {
-            toast.success("Browser versions updated successfully", {
-              duration: 4000,
+            showSuccessToast("Browser versions updated successfully", {
+              duration: 5000,
               description:
-                "Version information has been updated in the background",
+                "Auto-downloads will start shortly for available updates.",
             });
           } else {
-            toast.success("No new browser versions found", {
+            showSuccessToast("No new browser versions found", {
               duration: 3000,
               description: "All browser versions are up to date",
             });
@@ -87,14 +111,113 @@ export function useVersionUpdater() {
           setUpdateProgress(null);
           dismissToast("unified-version-update");
 
-          toast.error("Failed to update browser versions", {
-            duration: 4000,
+          showErrorToast("Failed to update browser versions", {
+            duration: 6000,
             description: "Check your internet connection and try again",
           });
         }
       },
     );
 
+    return () => {
+      void unlisten.then((fn) => {
+        fn();
+      });
+    };
+  }, [loadUpdateStatus]);
+
+  // Listen for browser auto-update events
+  useEffect(() => {
+    const unlisten = listen<AutoUpdateEvent>(
+      "browser-auto-update-available",
+      (event) => {
+        const handleAutoUpdate = async () => {
+          const { browser, new_version, notification_id } = event.payload;
+          console.log("Browser auto-update event received:", event.payload);
+
+          const browserDisplayName = getBrowserDisplayName(browser);
+
+          try {
+            // Show auto-update start notification
+            showAutoUpdateToast(browserDisplayName, new_version, {
+              description: `Downloading ${browserDisplayName} ${new_version} automatically. Progress will be shown below.`,
+            });
+
+            // Dismiss the update notification in the backend
+            await invoke("dismiss_update_notification", {
+              notificationId: notification_id,
+            });
+
+            // Check if browser already exists before downloading
+            const isDownloaded = await invoke<boolean>("check_browser_exists", {
+              browserStr: browser,
+              version: new_version,
+            });
+
+            if (isDownloaded) {
+              // Browser already exists, skip download and go straight to profile update
+              console.log(
+                `${browserDisplayName} ${new_version} already exists, skipping download`,
+              );
+
+              showSuccessToast(
+                `${browserDisplayName} ${new_version} already available`,
+                {
+                  description: "Updating profile configurations...",
+                  duration: 3000,
+                },
+              );
+            } else {
+              // Download the browser - this will trigger download progress events automatically
+              await invoke("download_browser", {
+                browserStr: browser,
+                version: new_version,
+              });
+            }
+
+            // Complete the update with auto-update of profile versions
+            const updatedProfiles = await invoke<string[]>(
+              "complete_browser_update_with_auto_update",
+              {
+                browser,
+                newVersion: new_version,
+              },
+            );
+
+            // Show success message based on whether profiles were updated
+            if (updatedProfiles.length > 0) {
+              const profileText =
+                updatedProfiles.length === 1
+                  ? `Profile "${updatedProfiles[0]}" has been updated`
+                  : `${updatedProfiles.length} profiles have been updated`;
+
+              showSuccessToast(`${browserDisplayName} update completed`, {
+                description: `${profileText} to version ${new_version}. You can now launch your browsers with the latest version.`,
+                duration: 6000,
+              });
+            } else {
+              showSuccessToast(`${browserDisplayName} update completed`, {
+                description: `Version ${new_version} is now available. Running profiles will use the new version when restarted.`,
+                duration: 6000,
+              });
+            }
+          } catch (error) {
+            console.error("Failed to handle browser auto-update:", error);
+            showErrorToast(`Failed to auto-update ${browserDisplayName}`, {
+              description:
+                error instanceof Error
+                  ? error.message
+                  : "Unknown error occurred",
+              duration: 8000,
+            });
+          }
+        };
+
+        // Call the async handler
+        void handleAutoUpdate();
+      },
+    );
+
     return () => {
       void unlisten.then((fn) => {
         fn();
@@ -114,19 +237,7 @@ export function useVersionUpdater() {
     return () => {
       clearInterval(interval);
     };
-  }, []);
-
-  const loadUpdateStatus = useCallback(async () => {
-    try {
-      const [lastUpdate, timeUntilNext] = await invoke<[number | null, number]>(
-        "get_version_update_status",
-      );
-      setLastUpdateTime(lastUpdate);
-      setTimeUntilNextUpdate(timeUntilNext);
-    } catch (error) {
-      console.error("Failed to load version update status:", error);
-    }
-  }, []);
+  }, [loadUpdateStatus]);
 
   const triggerManualUpdate = useCallback(async () => {
     try {
@@ -147,17 +258,17 @@ export function useVersionUpdater() {
       ).length;
 
       if (failedUpdates > 0) {
-        toast.warning("Update completed with some errors", {
+        showErrorToast("Update completed with some errors", {
           description: `${totalNewVersions} new versions found, ${failedUpdates} browsers failed to update`,
           duration: 5000,
         });
       } else if (totalNewVersions > 0) {
-        toast.success("Browser versions updated successfully", {
-          description: `Updated ${successfulUpdates} browsers successfully`,
+        showSuccessToast("Browser versions updated successfully", {
+          description: `Found ${totalNewVersions} new versions across ${successfulUpdates} browsers. Auto-downloads will start shortly.`,
           duration: 4000,
         });
       } else {
-        toast.success("No new browser versions found", {
+        showSuccessToast("No new browser versions found", {
           description: "All browser versions are up to date",
           duration: 3000,
         });
@@ -167,7 +278,7 @@ export function useVersionUpdater() {
       return results;
     } catch (error) {
       console.error("Failed to trigger manual update:", error);
-      toast.error("Failed to update browser versions", {
+      showErrorToast("Failed to update browser versions", {
         description:
           error instanceof Error ? error.message : "Unknown error occurred",
         duration: 4000,
@@ -189,7 +300,7 @@ export function useVersionUpdater() {
         // Show notification about new versions if any were found
         if (result.new_versions_count && result.new_versions_count > 0) {
           const browserName = getBrowserDisplayName(browserStr);
-          toast.success(
+          showSuccessToast(
             `Found ${result.new_versions_count} new ${browserName} versions!`,
             {
               duration: 3000,
@@ -208,18 +319,15 @@ export function useVersionUpdater() {
   );
 
   const formatTimeUntilUpdate = useCallback((seconds: number): string => {
-    if (seconds <= 0) return "Update overdue";
-
-    const hours = Math.floor(seconds / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-
-    if (hours > 0) {
-      return `${hours}h ${minutes}m`;
+    if (seconds < 60) {
+      return `${seconds} seconds`;
     }
-    if (minutes > 0) {
-      return `${minutes}m`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) {
+      return `${minutes} minute${minutes === 1 ? "" : "s"}`;
     }
-    return "< 1m";
+    const hours = Math.floor(minutes / 60);
+    return `${hours} hour${hours === 1 ? "" : "s"}`;
   }, []);
 
   const formatLastUpdateTime = useCallback(