feat: linux support preview

src-tauri/src/lib.rs

@@ -1,6 +1,5 @@
 // Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
 use std::sync::Mutex;
-use std::time::{SystemTime, UNIX_EPOCH};
 use tauri::{Emitter, Manager, Runtime, WebviewUrl, WebviewWindow, WebviewWindowBuilder};
 use tauri_plugin_deep_link::DeepLinkExt;
 
@@ -19,22 +18,22 @@ mod downloaded_browsers;
 mod extraction;
 mod proxy_manager;
 mod settings_manager;
+mod theme_detector;
 mod version_updater;
 
 extern crate lazy_static;
 
 use browser_runner::{
-  check_browser_exists, check_browser_status, create_browser_profile, create_browser_profile_new,
-  delete_profile, download_browser, fetch_browser_versions, fetch_browser_versions_cached_first,
-  fetch_browser_versions_detailed, fetch_browser_versions_with_count,
-  fetch_browser_versions_with_count_cached_first, get_cached_browser_versions_detailed,
-  get_downloaded_browser_versions, get_saved_mullvad_releases, get_supported_browsers,
-  is_browser_downloaded, kill_browser_profile, launch_browser_profile, list_browser_profiles,
-  rename_profile, should_update_browser_cache, update_profile_proxy, update_profile_version,
+  check_browser_exists, check_browser_status, cleanup_unused_binaries, 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,
 };
 
 use settings_manager::{
-  disable_default_browser_prompt, get_app_settings, get_table_sorting_settings, save_app_settings,
+  clear_all_version_cache, get_app_settings, get_table_sorting_settings, save_app_settings,
   save_table_sorting_settings, should_show_settings_on_startup,
 };
 
@@ -43,21 +42,21 @@ use default_browser::{
 };
 
 use version_updater::{
-  check_version_update_needed, force_version_update_check, get_version_update_status,
-  get_version_updater, trigger_manual_version_update,
+  get_version_update_status, get_version_updater, trigger_manual_version_update,
 };
 
 use auto_updater::{
-  check_for_browser_updates, complete_browser_update, 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, start_browser_update,
+  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,
 };
 
 use app_auto_updater::{
   check_for_app_updates, check_for_app_updates_manual, download_and_install_app_update,
-  get_app_version_info,
 };
 
+use theme_detector::get_system_theme;
+
 // Trait to extend WebviewWindow with transparent titlebar functionality
 pub trait WindowExt {
   #[cfg(target_os = "macos")]
@@ -103,13 +102,6 @@ impl<R: Runtime> WindowExt for WebviewWindow<R> {
   }
 }
 
-#[tauri::command]
-fn greet() -> String {
-  let now = SystemTime::now();
-  let epoch_ms = now.duration_since(UNIX_EPOCH).unwrap().as_millis();
-  format!("Hello world from Rust! Current epoch: {epoch_ms}")
-}
-
 #[tauri::command]
 async fn handle_url_open(app: tauri::AppHandle, url: String) -> Result<(), String> {
   println!("handle_url_open called with URL: {url}");
@@ -169,61 +161,6 @@ async fn check_and_handle_startup_url(app_handle: tauri::AppHandle) -> Result<bo
   Ok(false)
 }
 
-#[tauri::command]
-async fn set_window_background_color(
-  app_handle: tauri::AppHandle,
-  is_dark_mode: bool,
-) -> Result<(), String> {
-  #[cfg(target_os = "macos")]
-  {
-    if let Some(window) = app_handle.get_webview_window("main") {
-      use objc2::rc::Retained;
-      use objc2_app_kit::{NSColor, NSWindow};
-
-      let ns_window: Retained<NSWindow> =
-        unsafe { Retained::retain(window.ns_window().unwrap().cast()).unwrap() };
-
-      let bg_color = if is_dark_mode {
-        // Dark mode - pure black background
-        unsafe { NSColor::colorWithRed_green_blue_alpha(0.0, 0.0, 0.0, 1.0) }
-      } else {
-        // Light mode - pure white background
-        unsafe { NSColor::colorWithRed_green_blue_alpha(1.0, 1.0, 1.0, 1.0) }
-      };
-
-      // Ensure this runs on the main thread for immediate visual update
-      unsafe {
-        // Set the window background color
-        ns_window.setBackgroundColor(Some(&bg_color));
-
-        // Force immediate visual updates using multiple refresh methods
-        ns_window.invalidateShadow();
-        ns_window.display();
-
-        // Ensure the window content is redrawn
-        if let Some(content_view) = ns_window.contentView() {
-          content_view.setNeedsDisplay(true);
-          content_view.displayIfNeeded();
-        }
-
-        // Trigger a window update
-        ns_window.update();
-      }
-
-      // Also emit an event to the frontend to ensure synchronization
-      let _ = app_handle.emit("window-background-updated", is_dark_mode);
-    }
-  }
-
-  #[cfg(not(target_os = "macos"))]
-  {
-    // For non-macOS platforms, we can't change the native window background
-    let _ = (app_handle, is_dark_mode); // Suppress unused variable warnings
-  }
-
-  Ok(())
-}
-
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
   tauri::Builder::default()
@@ -233,12 +170,14 @@ pub fn run() {
     .plugin(tauri_plugin_deep_link::init())
     .setup(|app| {
       // Create the main window programmatically
+      #[allow(unused_variables)]
       let win_builder = WebviewWindowBuilder::new(app, "main", WebviewUrl::default())
         .title("Donut Browser")
         .inner_size(900.0, 600.0)
         .resizable(false)
         .fullscreen(false);
 
+      #[allow(unused_variables)]
       let window = win_builder.build().unwrap();
 
       // Set transparent titlebar for macOS
@@ -328,25 +267,19 @@ pub fn run() {
       Ok(())
     })
     .invoke_handler(tauri::generate_handler![
-      greet,
       get_supported_browsers,
+      is_browser_supported_on_platform,
       download_browser,
       delete_profile,
-      is_browser_downloaded,
       check_browser_exists,
+      cleanup_unused_binaries,
       create_browser_profile_new,
-      create_browser_profile,
       list_browser_profiles,
       launch_browser_profile,
-      fetch_browser_versions,
-      fetch_browser_versions_detailed,
       fetch_browser_versions_with_count,
       fetch_browser_versions_cached_first,
       fetch_browser_versions_with_count_cached_first,
-      get_cached_browser_versions_detailed,
-      should_update_browser_cache,
       get_downloaded_browser_versions,
-      get_saved_mullvad_releases,
       update_profile_proxy,
       update_profile_version,
       check_browser_status,
@@ -355,22 +288,17 @@ pub fn run() {
       get_app_settings,
       save_app_settings,
       should_show_settings_on_startup,
-      disable_default_browser_prompt,
       get_table_sorting_settings,
       save_table_sorting_settings,
+      clear_all_version_cache,
       is_default_browser,
       open_url_with_profile,
       set_as_default_browser,
       smart_open_url,
-      handle_url_open,
       check_and_handle_startup_url,
       trigger_manual_version_update,
       get_version_update_status,
-      check_version_update_needed,
-      force_version_update_check,
       check_for_browser_updates,
-      start_browser_update,
-      complete_browser_update,
       is_browser_disabled_for_update,
       dismiss_update_notification,
       complete_browser_update_with_auto_update,
@@ -380,9 +308,169 @@ pub fn run() {
       check_for_app_updates,
       check_for_app_updates_manual,
       download_and_install_app_update,
-      get_app_version_info,
-      set_window_background_color,
+      get_system_theme,
     ])
     .run(tauri::generate_context!())
     .expect("error while running tauri application");
 }
+
+#[cfg(test)]
+mod tests {
+  use std::fs;
+
+  #[test]
+  fn test_no_unused_tauri_commands() {
+    check_unused_commands(false); // Run in strict mode for CI
+  }
+
+  #[test]
+  fn test_unused_tauri_commands_detailed() {
+    check_unused_commands(true); // Run in verbose mode for development
+  }
+
+  fn check_unused_commands(verbose: bool) {
+    // Extract command names from the generate_handler! macro in this file
+    let lib_rs_content = fs::read_to_string("src/lib.rs").expect("Failed to read lib.rs");
+    let commands = extract_tauri_commands(&lib_rs_content);
+
+    // Get all frontend files
+    let frontend_files = get_frontend_files("../src");
+
+    // Check which commands are actually used
+    let mut unused_commands = Vec::new();
+    let mut used_commands = Vec::new();
+
+    for command in &commands {
+      let mut is_used = false;
+
+      for file_content in &frontend_files {
+        // More comprehensive search for command usage
+        if is_command_used(file_content, command) {
+          is_used = true;
+          break;
+        }
+      }
+
+      if is_used {
+        used_commands.push(command.clone());
+        if verbose {
+          println!("✅ {command}");
+        }
+      } else {
+        unused_commands.push(command.clone());
+        if verbose {
+          println!("❌ {command} (UNUSED)");
+        }
+      }
+    }
+
+    if verbose {
+      println!("\n📊 Summary:");
+      println!("  ✅ Used commands: {}", used_commands.len());
+      println!("  ❌ Unused commands: {}", unused_commands.len());
+    }
+
+    if !unused_commands.is_empty() {
+      let message = format!(
+        "Found {} unused Tauri commands: {}\n\nThese commands are exported in generate_handler! but not used in the frontend.\nConsider removing them or add them to the allowlist if they're used elsewhere.\n\nRun `pnpm check-unused-commands` for detailed analysis.",
+        unused_commands.len(),
+        unused_commands.join(", ")
+      );
+
+      if verbose {
+        println!("\n🚨 {message}");
+      } else {
+        panic!("{}", message);
+      }
+    } else if verbose {
+      println!("\n🎉 All exported commands are being used!");
+    } else {
+      println!(
+        "✅ All {} exported Tauri commands are being used in the frontend",
+        commands.len()
+      );
+    }
+  }
+
+  fn is_command_used(content: &str, command: &str) -> bool {
+    // Check various patterns for invoke usage
+    let patterns = vec![
+      format!("invoke<{}>(\"{}\"", "", command), // invoke<Type>("command"
+      format!("invoke(\"{}\"", command),         // invoke("command"
+      format!("invoke<{}>(\"{}\",", "", command), // invoke<Type>("command",
+      format!("invoke(\"{}\",", command),        // invoke("command",
+      format!("\"{}\"", command),                // Just the command name in quotes
+    ];
+
+    for pattern in patterns {
+      if content.contains(&pattern) {
+        return true;
+      }
+    }
+
+    // Also check for the command name appearing after "invoke" within a reasonable distance
+    if let Some(invoke_pos) = content.find("invoke") {
+      let after_invoke = &content[invoke_pos..];
+      if let Some(cmd_pos) = after_invoke.find(&format!("\"{command}\"")) {
+        // If the command appears within 100 characters of "invoke", consider it used
+        if cmd_pos < 100 {
+          return true;
+        }
+      }
+    }
+
+    false
+  }
+
+  fn extract_tauri_commands(content: &str) -> Vec<String> {
+    let mut commands = Vec::new();
+
+    // Find the generate_handler! macro
+    if let Some(start) = content.find("tauri::generate_handler![") {
+      if let Some(end) = content[start..].find("])") {
+        let handler_content = &content[start + 25..start + end]; // Skip "tauri::generate_handler!["
+
+        // Extract command names
+        for line in handler_content.lines() {
+          let line = line.trim();
+          if !line.is_empty() && !line.starts_with("//") {
+            // Remove trailing comma and whitespace
+            let command = line.trim_end_matches(',').trim();
+            if !command.is_empty() {
+              commands.push(command.to_string());
+            }
+          }
+        }
+      }
+    }
+
+    commands
+  }
+
+  fn get_frontend_files(src_dir: &str) -> Vec<String> {
+    let mut files_content = Vec::new();
+
+    if let Ok(entries) = fs::read_dir(src_dir) {
+      for entry in entries.flatten() {
+        let path = entry.path();
+
+        if path.is_dir() {
+          // Recursively read subdirectories
+          let subdir_files = get_frontend_files(&path.to_string_lossy());
+          files_content.extend(subdir_files);
+        } else if let Some(extension) = path.extension() {
+          if matches!(
+            extension.to_str(),
+            Some("ts") | Some("tsx") | Some("js") | Some("jsx")
+          ) {
+            if let Ok(content) = fs::read_to_string(&path) {
+              files_content.push(content);
+            }
+          }
+        }
+      }
+    }
+
+    files_content
+  }
+}