refactor: handle missing mmdb

src-tauri/src/browser_runner.rs

@@ -1044,6 +1044,27 @@ impl BrowserRunner {
     Ok(missing_binaries)
   }
 
+  /// Check if GeoIP database is missing for Camoufox profiles
+  pub fn check_missing_geoip_database(
+    &self,
+  ) -> Result<bool, Box<dyn std::error::Error + Send + Sync>> {
+    // Get all profiles
+    let profiles = self
+      .list_profiles()
+      .map_err(|e| format!("Failed to list profiles: {e}"))?;
+
+    // Check if there are any Camoufox profiles
+    let has_camoufox_profiles = profiles.iter().any(|profile| profile.browser == "camoufox");
+
+    if has_camoufox_profiles {
+      // Check if GeoIP database is available
+      use crate::geoip_downloader::GeoIPDownloader;
+      return Ok(!GeoIPDownloader::is_geoip_database_available());
+    }
+
+    Ok(false)
+  }
+
   /// Automatically download missing binaries for all profiles
   pub async fn ensure_all_binaries_exist(
     &self,
@@ -1082,6 +1103,25 @@ impl BrowserRunner {
       }
     }
 
+    // Check if GeoIP database is missing for Camoufox profiles
+    if self.check_missing_geoip_database()? {
+      println!("GeoIP database is missing for Camoufox profiles, downloading...");
+
+      use crate::geoip_downloader::GeoIPDownloader;
+      let geoip_downloader = GeoIPDownloader::instance();
+
+      match geoip_downloader.download_geoip_database(app_handle).await {
+        Ok(_) => {
+          downloaded.push("GeoIP database for Camoufox".to_string());
+          println!("GeoIP database downloaded successfully");
+        }
+        Err(e) => {
+          eprintln!("Failed to download GeoIP database: {e}");
+          // Don't fail the entire operation if GeoIP download fails
+        }
+      }
+    }
+
     Ok(downloaded)
   }
 
@@ -1794,6 +1834,14 @@ pub async fn check_missing_binaries() -> Result<Vec<(String, String, String)>, S
     .map_err(|e| format!("Failed to check missing binaries: {e}"))
 }
 
+#[tauri::command]
+pub async fn check_missing_geoip_database() -> Result<bool, String> {
+  let browser_runner = BrowserRunner::instance();
+  browser_runner
+    .check_missing_geoip_database()
+    .map_err(|e| format!("Failed to check missing GeoIP database: {e}"))
+}
+
 #[tauri::command]
 pub async fn ensure_all_binaries_exist(
   app_handle: tauri::AppHandle,

src-tauri/src/lib.rs

@@ -31,13 +31,13 @@ mod version_updater;
 extern crate lazy_static;
 
 use browser_runner::{
-  check_browser_exists, check_browser_status, check_missing_binaries, create_browser_profile_new,
-  delete_profile, download_browser, ensure_all_binaries_exist, fetch_browser_versions_cached_first,
-  fetch_browser_versions_with_count, 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_camoufox_config, update_profile_proxy,
-  update_profile_version,
+  check_browser_exists, check_browser_status, check_missing_binaries, check_missing_geoip_database,
+  create_browser_profile_new, delete_profile, download_browser, ensure_all_binaries_exist,
+  fetch_browser_versions_cached_first, fetch_browser_versions_with_count,
+  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_camoufox_config, update_profile_proxy, update_profile_version,
 };
 
 use settings_manager::{
@@ -69,6 +69,8 @@ use group_manager::{
   get_groups_with_profile_counts, get_profile_groups, update_profile_group,
 };
 
+use geoip_downloader::GeoIPDownloader;
+
 // Trait to extend WebviewWindow with transparent titlebar functionality
 pub trait WindowExt {
   #[cfg(target_os = "macos")]
@@ -173,6 +175,20 @@ async fn delete_stored_proxy(proxy_id: String) -> Result<(), String> {
     .map_err(|e| format!("Failed to delete stored proxy: {e}"))
 }
 
+#[tauri::command]
+async fn is_geoip_database_available() -> Result<bool, String> {
+  Ok(GeoIPDownloader::is_geoip_database_available())
+}
+
+#[tauri::command]
+async fn download_geoip_database(app_handle: tauri::AppHandle) -> Result<(), String> {
+  let downloader = GeoIPDownloader::instance();
+  downloader
+    .download_geoip_database(&app_handle)
+    .await
+    .map_err(|e| format!("Failed to download GeoIP database: {e}"))
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
   let args: Vec<String> = env::args().collect();
@@ -386,6 +402,35 @@ pub fn run() {
         }
       });
 
+      // Check and download GeoIP database at startup if needed
+      let app_handle_geoip = app.handle().clone();
+      tauri::async_runtime::spawn(async move {
+        // Wait a bit for the app to fully initialize
+        tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
+
+        let browser_runner = crate::browser_runner::BrowserRunner::instance();
+        match browser_runner.check_missing_geoip_database() {
+          Ok(true) => {
+            println!("GeoIP database is missing for Camoufox profiles, downloading at startup...");
+            let geoip_downloader = GeoIPDownloader::instance();
+            if let Err(e) = geoip_downloader
+              .download_geoip_database(&app_handle_geoip)
+              .await
+            {
+              eprintln!("Failed to download GeoIP database at startup: {e}");
+            } else {
+              println!("GeoIP database downloaded successfully at startup");
+            }
+          }
+          Ok(false) => {
+            // No Camoufox profiles or GeoIP database already available
+          }
+          Err(e) => {
+            eprintln!("Failed to check GeoIP database status at startup: {e}");
+          }
+        }
+      });
+
       // Start proxy cleanup task for dead browser processes
       let app_handle_proxy_cleanup = app.handle().clone();
       tauri::async_runtime::spawn(async move {
@@ -487,6 +532,7 @@ pub fn run() {
       detect_existing_profiles,
       import_browser_profile,
       check_missing_binaries,
+      check_missing_geoip_database,
       ensure_all_binaries_exist,
       create_stored_proxy,
       get_stored_proxies,
@@ -500,6 +546,8 @@ pub fn run() {
       delete_profile_group,
       assign_profiles_to_group,
       delete_selected_profiles,
+      is_geoip_database_available,
+      download_geoip_database,
     ])
     .run(tauri::generate_context!())
     .expect("error while running tauri application");