refactor: partially migrate from launching camoufox directly to launching via playwright

src-tauri/src/browser_runner.rs

@@ -13,7 +13,7 @@ use crate::browser::{create_browser, BrowserType, ProxySettings};
 use crate::browser_version_service::{
   BrowserVersionInfo, BrowserVersionService, BrowserVersionsResult,
 };
-use crate::camoufox_direct::CamoufoxConfig;
+use crate::camoufox::CamoufoxConfig;
 use crate::download::{DownloadProgress, Downloader};
 use crate::downloaded_browsers::DownloadedBrowsersRegistry;
 use crate::extraction::Extractor;
@@ -1884,7 +1884,7 @@ impl BrowserRunner {
     url: Option<String>,
     local_proxy_settings: Option<&ProxySettings>,
   ) -> Result<BrowserProfile, Box<dyn std::error::Error + Send + Sync>> {
-    // Handle camoufox profiles specially using only the direct launcher
+    // Handle camoufox profiles using nodecar launcher
     if profile.browser == "camoufox" {
       if let Some(mut camoufox_config) = profile.camoufox_config.clone() {
         // Handle proxy settings for camoufox
@@ -1951,8 +1951,7 @@ impl BrowserRunner {
         } else {
           // No meaningful config provided, use test config to ensure anti-fingerprinting works
           println!("No Camoufox configuration provided, using test configuration");
-          let mut test_config =
-            crate::camoufox_direct::CamoufoxDirectLauncher::create_test_config();
+          let mut test_config = crate::camoufox::CamoufoxNodecarLauncher::create_test_config();
           // Preserve any proxy settings from the original config
           test_config.proxy = camoufox_config.proxy.clone();
           test_config.headless = camoufox_config.headless;
@@ -1960,8 +1959,8 @@ impl BrowserRunner {
           test_config
         };
 
-        // Use the direct camoufox launcher
-        let camoufox_result = crate::camoufox_direct::launch_camoufox_profile_direct(
+        // Use the nodecar camoufox launcher
+        let camoufox_result = crate::camoufox::launch_camoufox_profile_nodecar(
           app_handle.clone(),
           profile.clone(),
           final_config,
@@ -1969,21 +1968,16 @@ impl BrowserRunner {
         )
         .await
         .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> {
-          format!("Failed to launch camoufox: {e}").into()
+          format!("Failed to launch camoufox via nodecar: {e}").into()
         })?;
 
-        // Update proxy with actual PID if proxy was started
-        if let Some(pid) = camoufox_result.pid {
-          if profile.proxy_id.is_some() {
-            if let Err(e) = PROXY_MANAGER.update_proxy_pid(0, pid) {
-              println!("Warning: Failed to update proxy PID: {e}");
-            }
-          }
-        }
+        // For server-based Camoufox, we don't have a PID but we have a port
+        // We'll use the port as a unique identifier for the running instance
+        let process_id = camoufox_result.port;
 
         // Update profile with the process info from camoufox result
         let mut updated_profile = profile.clone();
-        updated_profile.process_id = camoufox_result.pid;
+        updated_profile.process_id = process_id;
         updated_profile.last_launch = Some(SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs());
 
         // Save the updated profile
@@ -2166,10 +2160,9 @@ impl BrowserRunner {
     url: &str,
     _internal_proxy_settings: Option<&ProxySettings>,
   ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    // Handle camoufox profiles specially using only the direct launcher
+    // Handle camoufox profiles using nodecar launcher
     if profile.browser == "camoufox" {
-      let camoufox_launcher =
-        crate::camoufox_direct::CamoufoxDirectLauncher::new(app_handle.clone());
+      let camoufox_launcher = crate::camoufox::CamoufoxNodecarLauncher::new(app_handle.clone());
 
       // Get the profile path based on the UUID
       let profiles_dir = self.get_profiles_dir();
@@ -2588,12 +2581,15 @@ impl BrowserRunner {
         let profile_path_match = cmd.iter().any(|s| {
           let arg = s.to_str().unwrap_or("");
           // For Firefox-based browsers (including camoufox), check for exact profile path match
-          if profile.browser == "tor-browser"
+          if profile.browser == "camoufox" {
+            // Camoufox uses user_data_dir like Chromium browsers
+            arg.contains(&format!("--user-data-dir={profile_data_path_str}"))
+              || arg == profile_data_path_str
+          } else if profile.browser == "tor-browser"
             || profile.browser == "firefox"
             || profile.browser == "firefox-developer"
             || profile.browser == "mullvad-browser"
             || profile.browser == "zen"
-            || profile.browser == "camoufox"
           {
             arg == profile_data_path_str
               || arg == format!("-profile={profile_data_path_str}")
@@ -2665,7 +2661,11 @@ impl BrowserRunner {
           let profile_path_match = cmd.iter().any(|s| {
             let arg = s.to_str().unwrap_or("");
             // For Firefox-based browsers, check for exact profile path match
-            if profile.browser == "tor-browser"
+            if profile.browser == "camoufox" {
+              // Camoufox uses user_data_dir like Chromium browsers
+              arg.contains(&format!("--user-data-dir={profile_data_path_str}"))
+                || arg == profile_data_path_str
+            } else if profile.browser == "tor-browser"
               || profile.browser == "firefox"
               || profile.browser == "firefox-developer"
               || profile.browser == "mullvad-browser"
@@ -2726,7 +2726,7 @@ impl BrowserRunner {
   pub fn update_camoufox_config(
     &self,
     profile_name: &str,
-    config: crate::camoufox_direct::CamoufoxConfig,
+    config: crate::camoufox::CamoufoxConfig,
   ) -> Result<(), Box<dyn std::error::Error>> {
     // Find the profile by name
     let profiles = self.list_profiles()?;
@@ -2758,15 +2758,14 @@ impl BrowserRunner {
     app_handle: tauri::AppHandle,
     profile: &BrowserProfile,
   ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    // Handle camoufox profiles specially using only the direct launcher
+    // Handle camoufox profiles using nodecar launcher
     if profile.browser == "camoufox" {
-      let camoufox_launcher =
-        crate::camoufox_direct::CamoufoxDirectLauncher::new(app_handle.clone());
+      let camoufox_launcher = crate::camoufox::CamoufoxNodecarLauncher::new(app_handle.clone());
 
       // Try to stop by PID first (faster)
       if let Some(stored_pid) = profile.process_id {
         match camoufox_launcher
-          .stop_camoufox(&stored_pid.to_string())
+          .stop_camoufox(&app_handle, &stored_pid.to_string())
           .await
         {
           Ok(stopped) => {
@@ -2791,7 +2790,10 @@ impl BrowserRunner {
           .await
         {
           Ok(Some(camoufox_process)) => {
-            match camoufox_launcher.stop_camoufox(&camoufox_process.id).await {
+            match camoufox_launcher
+              .stop_camoufox(&app_handle, &camoufox_process.id)
+              .await
+            {
               Ok(stopped) => {
                 if stopped {
                   println!(
@@ -2889,7 +2891,11 @@ impl BrowserRunner {
           let profile_path_match = cmd.iter().any(|s| {
             let arg = s.to_str().unwrap_or("");
             // For Firefox-based browsers, check for exact profile path match
-            if profile.browser == "tor-browser"
+            if profile.browser == "camoufox" {
+              // Camoufox uses user_data_dir like Chromium browsers
+              arg.contains(&format!("--user-data-dir={profile_data_path_str}"))
+                || arg == profile_data_path_str
+            } else if profile.browser == "tor-browser"
               || profile.browser == "firefox"
               || profile.browser == "firefox-developer"
               || profile.browser == "mullvad-browser"

src-tauri/src/camoufox.rs

@@ -0,0 +1,671 @@
+use crate::browser_runner::BrowserProfile;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use tauri::AppHandle;
+use tauri_plugin_shell::ShellExt;
+use tokio::sync::Mutex as AsyncMutex;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CamoufoxConfig {
+  pub os: Option<Vec<String>>,
+  pub block_images: Option<bool>,
+  pub block_webrtc: Option<bool>,
+  pub block_webgl: Option<bool>,
+  pub disable_coop: Option<bool>,
+  pub geoip: Option<serde_json::Value>, // Can be String or bool
+  pub country: Option<String>,
+  pub timezone: Option<String>,
+  pub latitude: Option<f64>,
+  pub longitude: Option<f64>,
+  pub humanize: Option<bool>,
+  pub humanize_duration: Option<f64>,
+  pub headless: Option<bool>,
+  pub locale: Option<Vec<String>>,
+  pub addons: Option<Vec<String>>,
+  pub fonts: Option<Vec<String>>,
+  pub custom_fonts_only: Option<bool>,
+  pub exclude_addons: Option<Vec<String>>,
+  pub screen_min_width: Option<u32>,
+  pub screen_max_width: Option<u32>,
+  pub screen_min_height: Option<u32>,
+  pub screen_max_height: Option<u32>,
+  pub window_width: Option<u32>,
+  pub window_height: Option<u32>,
+  pub ff_version: Option<u32>,
+  pub main_world_eval: Option<bool>,
+  pub webgl_vendor: Option<String>,
+  pub webgl_renderer: Option<String>,
+  pub proxy: Option<String>,
+  pub enable_cache: Option<bool>,
+  pub virtual_display: Option<String>,
+  pub debug: Option<bool>,
+  pub additional_args: Option<Vec<String>>,
+  pub env_vars: Option<HashMap<String, String>>,
+  pub firefox_prefs: Option<HashMap<String, serde_json::Value>>,
+  pub disable_theming: Option<bool>,
+  pub showcursor: Option<bool>,
+}
+
+impl Default for CamoufoxConfig {
+  fn default() -> Self {
+    Self {
+      os: None,
+      block_images: None,
+      block_webrtc: None,
+      block_webgl: None,
+      disable_coop: None,
+      geoip: None,
+      country: None,
+      timezone: None,
+      latitude: None,
+      longitude: None,
+      humanize: None,
+      humanize_duration: None,
+      headless: None,
+      locale: None,
+      addons: None,
+      fonts: None,
+      custom_fonts_only: None,
+      exclude_addons: None,
+      screen_min_width: None,
+      screen_max_width: None,
+      screen_min_height: None,
+      screen_max_height: None,
+      window_width: None,
+      window_height: None,
+      ff_version: None,
+      main_world_eval: None,
+      webgl_vendor: None,
+      webgl_renderer: None,
+      proxy: None,
+      enable_cache: Some(true), // Cache enabled by default
+      virtual_display: None,
+      debug: None,
+      additional_args: None,
+      env_vars: None,
+      firefox_prefs: None,
+      disable_theming: Some(true), // Required for anti-detect
+      showcursor: Some(false),     // Required for anti-detect
+    }
+  }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[allow(non_snake_case)]
+pub struct CamoufoxLaunchResult {
+  pub id: String,
+  pub port: Option<u32>,
+  #[serde(alias = "ws_endpoint")]
+  pub wsEndpoint: Option<String>,
+  #[serde(alias = "profile_path")]
+  pub profilePath: Option<String>,
+  pub url: Option<String>,
+}
+
+#[derive(Debug)]
+struct CamoufoxInstance {
+  #[allow(dead_code)]
+  id: String,
+  port: Option<u32>,
+  ws_endpoint: Option<String>,
+  profile_path: Option<String>,
+  url: Option<String>,
+}
+
+struct CamoufoxNodecarLauncherInner {
+  instances: HashMap<String, CamoufoxInstance>,
+}
+
+pub struct CamoufoxNodecarLauncher {
+  inner: Arc<AsyncMutex<CamoufoxNodecarLauncherInner>>,
+}
+
+// Global singleton instance
+lazy_static::lazy_static! {
+  static ref GLOBAL_NODECAR_LAUNCHER: CamoufoxNodecarLauncher = CamoufoxNodecarLauncher::new_singleton();
+}
+
+impl CamoufoxNodecarLauncher {
+  pub fn new(_app_handle: AppHandle) -> Self {
+    // Return a reference to the global singleton
+    GLOBAL_NODECAR_LAUNCHER.clone()
+  }
+
+  pub fn new_singleton() -> Self {
+    Self {
+      inner: Arc::new(AsyncMutex::new(CamoufoxNodecarLauncherInner {
+        instances: HashMap::new(),
+      })),
+    }
+  }
+
+  fn clone(&self) -> Self {
+    Self {
+      inner: Arc::clone(&self.inner),
+    }
+  }
+
+  /// Create a test configuration to verify anti-fingerprinting is working
+  pub fn create_test_config() -> CamoufoxConfig {
+    CamoufoxConfig {
+      // Core anti-fingerprinting settings
+      timezone: Some("Europe/London".to_string()),
+      screen_min_width: Some(1440),
+      screen_min_height: Some(900),
+      window_width: Some(1200),
+      window_height: Some(800),
+
+      // Locale settings
+      locale: Some(vec!["en-GB".to_string(), "en-US".to_string()]),
+
+      // WebGL spoofing
+      webgl_vendor: Some("Intel Inc.".to_string()),
+      webgl_renderer: Some("Intel Iris Pro OpenGL Engine".to_string()),
+
+      // Geolocation spoofing (London coordinates)
+      latitude: Some(51.5074),
+      longitude: Some(-0.1278),
+
+      // Font settings
+      fonts: Some(vec![
+        "Arial".to_string(),
+        "Times New Roman".to_string(),
+        "Helvetica".to_string(),
+        "Georgia".to_string(),
+      ]),
+      custom_fonts_only: Some(true),
+
+      // Humanization
+      humanize: Some(true),
+      humanize_duration: Some(2.0),
+
+      // Blocking features
+      block_images: Some(false), // Don't block images for testing
+      block_webrtc: Some(true),
+      block_webgl: Some(false), // Don't block WebGL so we can test spoofing
+
+      // Other settings
+      debug: Some(true),
+      enable_cache: Some(true),
+      headless: Some(false), // Not headless for testing
+
+      ..Default::default()
+    }
+  }
+
+  /// Get the nodecar sidecar command
+  fn get_nodecar_sidecar(
+    &self,
+    app_handle: &AppHandle,
+  ) -> Result<tauri_plugin_shell::process::Command, Box<dyn std::error::Error + Send + Sync>> {
+    let shell = app_handle.shell();
+    let sidecar_command = shell
+      .sidecar("nodecar")
+      .map_err(|e| format!("Failed to create nodecar sidecar: {e}"))?;
+    Ok(sidecar_command)
+  }
+
+  /// Launch Camoufox browser using nodecar sidecar
+  pub async fn launch_camoufox(
+    &self,
+    app_handle: &AppHandle,
+    profile_path: &str,
+    config: &CamoufoxConfig,
+    url: Option<&str>,
+  ) -> Result<CamoufoxLaunchResult, Box<dyn std::error::Error + Send + Sync>> {
+    // Build nodecar command arguments
+    let mut args = vec!["camoufox".to_string(), "start".to_string()];
+
+    // Add profile path
+    args.extend(["--profile-path".to_string(), profile_path.to_string()]);
+
+    // Add URL if provided
+    if let Some(url) = url {
+      args.extend(["--url".to_string(), url.to_string()]);
+    }
+
+    // Add configuration options
+    if let Some(os_list) = &config.os {
+      let os_str = os_list.join(",");
+      args.extend(["--os".to_string(), os_str]);
+    }
+
+    if let Some(block_images) = config.block_images {
+      if block_images {
+        args.push("--block-images".to_string());
+      }
+    }
+
+    if let Some(block_webrtc) = config.block_webrtc {
+      if block_webrtc {
+        args.push("--block-webrtc".to_string());
+      }
+    }
+
+    if let Some(block_webgl) = config.block_webgl {
+      if block_webgl {
+        args.push("--block-webgl".to_string());
+      }
+    }
+
+    if let Some(disable_coop) = config.disable_coop {
+      if disable_coop {
+        args.push("--disable-coop".to_string());
+      }
+    }
+
+    if let Some(geoip) = &config.geoip {
+      match geoip {
+        serde_json::Value::Bool(true) => {
+          args.extend(["--geoip".to_string(), "auto".to_string()]);
+        }
+        serde_json::Value::String(ip) => {
+          args.extend(["--geoip".to_string(), ip.clone()]);
+        }
+        _ => {}
+      }
+    }
+
+    if let Some(country) = &config.country {
+      args.extend(["--country".to_string(), country.clone()]);
+    }
+
+    if let Some(timezone) = &config.timezone {
+      args.extend(["--timezone".to_string(), timezone.clone()]);
+    }
+
+    if let Some(latitude) = config.latitude {
+      args.extend(["--latitude".to_string(), latitude.to_string()]);
+    }
+
+    if let Some(longitude) = config.longitude {
+      args.extend(["--longitude".to_string(), longitude.to_string()]);
+    }
+
+    if let Some(humanize) = config.humanize {
+      if humanize {
+        if let Some(duration) = config.humanize_duration {
+          args.extend(["--humanize".to_string(), duration.to_string()]);
+        } else {
+          args.push("--humanize".to_string());
+        }
+      }
+    }
+
+    if let Some(headless) = config.headless {
+      if headless {
+        args.push("--headless".to_string());
+      }
+    }
+
+    if let Some(locale_list) = &config.locale {
+      let locale_str = locale_list.join(",");
+      args.extend(["--locale".to_string(), locale_str]);
+    }
+
+    if let Some(addons) = &config.addons {
+      let addons_str = addons.join(",");
+      args.extend(["--addons".to_string(), addons_str]);
+    }
+
+    if let Some(fonts) = &config.fonts {
+      let fonts_str = fonts.join(",");
+      args.extend(["--fonts".to_string(), fonts_str]);
+    }
+
+    if let Some(custom_fonts_only) = config.custom_fonts_only {
+      if custom_fonts_only {
+        args.push("--custom-fonts-only".to_string());
+      }
+    }
+
+    if let Some(exclude_addons) = &config.exclude_addons {
+      let exclude_str = exclude_addons.join(",");
+      args.extend(["--exclude-addons".to_string(), exclude_str]);
+    }
+
+    if let Some(screen_min_width) = config.screen_min_width {
+      args.extend([
+        "--screen-min-width".to_string(),
+        screen_min_width.to_string(),
+      ]);
+    }
+
+    if let Some(screen_max_width) = config.screen_max_width {
+      args.extend([
+        "--screen-max-width".to_string(),
+        screen_max_width.to_string(),
+      ]);
+    }
+
+    if let Some(screen_min_height) = config.screen_min_height {
+      args.extend([
+        "--screen-min-height".to_string(),
+        screen_min_height.to_string(),
+      ]);
+    }
+
+    if let Some(screen_max_height) = config.screen_max_height {
+      args.extend([
+        "--screen-max-height".to_string(),
+        screen_max_height.to_string(),
+      ]);
+    }
+
+    if let Some(window_width) = config.window_width {
+      args.extend(["--window-width".to_string(), window_width.to_string()]);
+    }
+
+    if let Some(window_height) = config.window_height {
+      args.extend(["--window-height".to_string(), window_height.to_string()]);
+    }
+
+    if let Some(ff_version) = config.ff_version {
+      args.extend(["--ff-version".to_string(), ff_version.to_string()]);
+    }
+
+    if let Some(main_world_eval) = config.main_world_eval {
+      if main_world_eval {
+        args.push("--main-world-eval".to_string());
+      }
+    }
+
+    if let Some(webgl_vendor) = &config.webgl_vendor {
+      args.extend(["--webgl-vendor".to_string(), webgl_vendor.clone()]);
+    }
+
+    if let Some(webgl_renderer) = &config.webgl_renderer {
+      args.extend(["--webgl-renderer".to_string(), webgl_renderer.clone()]);
+    }
+
+    if let Some(proxy) = &config.proxy {
+      args.extend(["--proxy".to_string(), proxy.clone()]);
+    }
+
+    if let Some(enable_cache) = config.enable_cache {
+      if !enable_cache {
+        args.push("--disable-cache".to_string());
+      }
+    }
+
+    if let Some(virtual_display) = &config.virtual_display {
+      args.extend(["--virtual-display".to_string(), virtual_display.clone()]);
+    }
+
+    if let Some(debug) = config.debug {
+      if debug {
+        args.push("--debug".to_string());
+      }
+    }
+
+    if let Some(additional_args) = &config.additional_args {
+      let args_str = additional_args.join(",");
+      args.extend(["--args".to_string(), args_str]);
+    }
+
+    if let Some(env_vars) = &config.env_vars {
+      let env_json = serde_json::to_string(env_vars)?;
+      args.extend(["--env".to_string(), env_json]);
+    }
+
+    if let Some(firefox_prefs) = &config.firefox_prefs {
+      let prefs_json = serde_json::to_string(firefox_prefs)?;
+      args.extend(["--firefox-prefs".to_string(), prefs_json]);
+    }
+
+    // Required anti-detect options
+    if let Some(disable_theming) = config.disable_theming {
+      if disable_theming {
+        args.push("--disable-theming".to_string());
+      }
+    }
+
+    if let Some(showcursor) = config.showcursor {
+      if !showcursor {
+        args.push("--no-showcursor".to_string());
+      }
+    }
+
+    // Get the nodecar sidecar command
+    let mut sidecar_command = self.get_nodecar_sidecar(app_handle)?;
+
+    // Add all arguments to the sidecar command
+    for arg in &args {
+      sidecar_command = sidecar_command.arg(arg);
+    }
+
+    // Execute nodecar sidecar command
+    let output = sidecar_command.output().await?;
+
+    if !output.status.success() {
+      let stderr = String::from_utf8_lossy(&output.stderr);
+      return Err(format!("nodecar camoufox failed: {stderr}").into());
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Parse the JSON output
+    let launch_result: CamoufoxLaunchResult = serde_json::from_str(&stdout)
+      .map_err(|e| format!("Failed to parse nodecar output as JSON: {e}"))?;
+
+    // Store the instance
+    let instance = CamoufoxInstance {
+      id: launch_result.id.clone(),
+      port: launch_result.port,
+      ws_endpoint: launch_result.wsEndpoint.clone(),
+      profile_path: launch_result.profilePath.clone(),
+      url: launch_result.url.clone(),
+    };
+
+    {
+      let mut inner = self.inner.lock().await;
+      inner.instances.insert(launch_result.id.clone(), instance);
+    }
+
+    Ok(launch_result)
+  }
+
+  /// Stop a Camoufox process by ID
+  pub async fn stop_camoufox(
+    &self,
+    app_handle: &AppHandle,
+    id: &str,
+  ) -> Result<bool, Box<dyn std::error::Error + Send + Sync>> {
+    // Get the nodecar sidecar command
+    let sidecar_command = self
+      .get_nodecar_sidecar(app_handle)?
+      .arg("camoufox")
+      .arg("stop")
+      .arg("--id")
+      .arg(id);
+
+    // Execute nodecar stop command
+    let output = sidecar_command.output().await?;
+
+    if !output.status.success() {
+      let _stderr = String::from_utf8_lossy(&output.stderr);
+      return Ok(false);
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let result: serde_json::Value = serde_json::from_str(&stdout)
+      .map_err(|e| format!("Failed to parse nodecar stop output: {e}"))?;
+
+    let success = result
+      .get("success")
+      .and_then(|v| v.as_bool())
+      .unwrap_or(false);
+
+    if success {
+      // Remove from our tracking
+      let mut inner = self.inner.lock().await;
+      inner.instances.remove(id);
+    }
+
+    Ok(success)
+  }
+
+  /// Find Camoufox server by profile path (for integration with browser_runner)
+  pub async fn find_camoufox_by_profile(
+    &self,
+    profile_path: &str,
+  ) -> Result<Option<CamoufoxLaunchResult>, Box<dyn std::error::Error + Send + Sync>> {
+    // First clean up any dead instances
+    self.cleanup_dead_instances().await?;
+
+    let inner = self.inner.lock().await;
+
+    // Convert paths to canonical form for comparison
+    let target_path = std::path::Path::new(profile_path)
+      .canonicalize()
+      .unwrap_or_else(|_| std::path::Path::new(profile_path).to_path_buf());
+
+    for (id, instance) in inner.instances.iter() {
+      if let Some(instance_profile_path) = &instance.profile_path {
+        let instance_path = std::path::Path::new(instance_profile_path)
+          .canonicalize()
+          .unwrap_or_else(|_| std::path::Path::new(instance_profile_path).to_path_buf());
+
+        if instance_path == target_path {
+          // Verify the server is actually running by checking the port
+          if let Some(port) = instance.port {
+            if self.is_server_running(port).await {
+              return Ok(Some(CamoufoxLaunchResult {
+                id: id.clone(),
+                port: instance.port,
+                wsEndpoint: instance.ws_endpoint.clone(),
+                profilePath: instance.profile_path.clone(),
+                url: instance.url.clone(),
+              }));
+            }
+          }
+        }
+      }
+    }
+
+    Ok(None)
+  }
+
+  /// Check if servers are still alive and clean up dead instances
+  pub async fn cleanup_dead_instances(
+    &self,
+  ) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
+    let mut dead_instances = Vec::new();
+    let mut instances_to_remove = Vec::new();
+
+    {
+      let inner = self.inner.lock().await;
+
+      for (id, instance) in inner.instances.iter() {
+        if let Some(port) = instance.port {
+          // Check if the server is still alive
+          if !self.is_server_running(port).await {
+            // Server is dead
+            dead_instances.push(id.clone());
+            instances_to_remove.push(id.clone());
+          }
+        } else {
+          // No port means it's likely a dead instance
+          dead_instances.push(id.clone());
+          instances_to_remove.push(id.clone());
+        }
+      }
+    }
+
+    // Remove dead instances
+    if !instances_to_remove.is_empty() {
+      let mut inner = self.inner.lock().await;
+      for id in &instances_to_remove {
+        inner.instances.remove(id);
+      }
+    }
+
+    Ok(dead_instances)
+  }
+
+  /// Check if a Camoufox server is running on the given port
+  async fn is_server_running(&self, port: u32) -> bool {
+    let client = reqwest::Client::new();
+    let url = format!("http://localhost:{port}/json/version");
+
+    match client
+      .get(&url)
+      .timeout(std::time::Duration::from_secs(1))
+      .send()
+      .await
+    {
+      Ok(response) => response.status().is_success(),
+      Err(_) => false,
+    }
+  }
+}
+
+pub async fn launch_camoufox_profile_nodecar(
+  app_handle: AppHandle,
+  profile: BrowserProfile,
+  config: CamoufoxConfig,
+  url: Option<String>,
+) -> Result<CamoufoxLaunchResult, String> {
+  let launcher = CamoufoxNodecarLauncher::new(app_handle.clone());
+
+  // Get profile path
+  let browser_runner = crate::browser_runner::BrowserRunner::new();
+  let profiles_dir = browser_runner.get_profiles_dir();
+  let profile_path = profile.get_profile_data_path(&profiles_dir);
+  let profile_path_str = profile_path.to_string_lossy();
+
+  // Check if there's already a running instance for this profile
+  if let Ok(Some(existing)) = launcher.find_camoufox_by_profile(&profile_path_str).await {
+    // If there's an existing instance, stop it first to avoid conflicts
+    let _ = launcher.stop_camoufox(&app_handle, &existing.id).await;
+  }
+
+  // Clean up any dead instances before launching
+  let _ = launcher.cleanup_dead_instances().await;
+
+  launcher
+    .launch_camoufox(&app_handle, &profile_path_str, &config, url.as_deref())
+    .await
+    .map_err(|e| format!("Failed to launch Camoufox via nodecar: {e}"))
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn test_camoufox_config_creation() {
+    let test_config = CamoufoxNodecarLauncher::create_test_config();
+
+    // Verify test config has expected values
+    assert_eq!(test_config.timezone, Some("Europe/London".to_string()));
+    assert_eq!(test_config.screen_min_width, Some(1440));
+    assert_eq!(test_config.screen_min_height, Some(900));
+    assert_eq!(test_config.window_width, Some(1200));
+    assert_eq!(test_config.window_height, Some(800));
+    assert_eq!(test_config.webgl_vendor, Some("Intel Inc.".to_string()));
+    assert_eq!(
+      test_config.webgl_renderer,
+      Some("Intel Iris Pro OpenGL Engine".to_string())
+    );
+    assert_eq!(test_config.latitude, Some(51.5074));
+    assert_eq!(test_config.longitude, Some(-0.1278));
+    assert_eq!(test_config.humanize, Some(true));
+    assert_eq!(test_config.debug, Some(true));
+    assert_eq!(test_config.enable_cache, Some(true));
+    assert_eq!(test_config.headless, Some(false));
+  }
+
+  #[test]
+  fn test_default_config() {
+    let default_config = CamoufoxConfig::default();
+
+    // Verify defaults
+    assert_eq!(default_config.enable_cache, Some(true));
+    assert_eq!(default_config.timezone, None);
+    assert_eq!(default_config.debug, None);
+    assert_eq!(default_config.headless, None);
+  }
+}

src-tauri/src/default_browser.rs

@@ -545,112 +545,3 @@ pub async fn open_url_with_profile(
   println!("Successfully opened URL '{url}' with profile '{profile_name}'");
   Ok(())
 }
-
-#[tauri::command]
-pub async fn smart_open_url(
-  app_handle: tauri::AppHandle,
-  url: String,
-  _is_startup: Option<bool>,
-) -> Result<String, String> {
-  use crate::browser_runner::BrowserRunner;
-
-  let runner = BrowserRunner::new();
-
-  // Get all profiles
-  let profiles = runner
-    .list_profiles()
-    .map_err(|e| format!("Failed to list profiles: {e}"))?;
-
-  if profiles.is_empty() {
-    return Err("no_profiles".to_string());
-  }
-
-  println!(
-    "URL opening - Total profiles: {}, checking for running profiles",
-    profiles.len()
-  );
-
-  // Check for running profiles and find the first one that can handle URLs
-  for profile in &profiles {
-    // Check if this profile is running
-    let is_running = runner
-      .check_browser_status(app_handle.clone(), profile)
-      .await
-      .unwrap_or(false);
-
-    if is_running {
-      println!(
-        "Found running profile '{}', attempting to open URL",
-        profile.name
-      );
-
-      // For TOR browser: Check if any other TOR browser is running
-      if profile.browser == "tor-browser" {
-        let mut other_tor_running = false;
-        for p in &profiles {
-          if p.browser == "tor-browser"
-            && p.name != profile.name
-            && runner
-              .check_browser_status(app_handle.clone(), p)
-              .await
-              .unwrap_or(false)
-          {
-            other_tor_running = true;
-            break;
-          }
-        }
-
-        if other_tor_running {
-          continue; // Skip this one, can't have multiple TOR instances
-        }
-      }
-
-      // For Mullvad browser: Check if any other Mullvad browser is running
-      if profile.browser == "mullvad-browser" {
-        let mut other_mullvad_running = false;
-        for p in &profiles {
-          if p.browser == "mullvad-browser"
-            && p.name != profile.name
-            && runner
-              .check_browser_status(app_handle.clone(), p)
-              .await
-              .unwrap_or(false)
-          {
-            other_mullvad_running = true;
-            break;
-          }
-        }
-
-        if other_mullvad_running {
-          continue; // Skip this one, can't have multiple Mullvad instances
-        }
-      }
-
-      // Try to open the URL with this running profile
-      match runner
-        .launch_or_open_url(app_handle.clone(), profile, Some(url.clone()), None)
-        .await
-      {
-        Ok(_) => {
-          println!(
-            "Successfully opened URL '{}' with running profile '{}'",
-            url, profile.name
-          );
-          return Ok(format!("opened_with_profile:{}", profile.name));
-        }
-        Err(e) => {
-          println!(
-            "Failed to open URL with running profile '{}': {}",
-            profile.name, e
-          );
-          // Continue to try other profiles or show selector
-        }
-      }
-    }
-  }
-
-  println!("No suitable running profiles found, showing profile selector");
-
-  // No suitable running profile found, show the profile selector
-  Err("show_selector".to_string())
-}

src-tauri/src/lib.rs

@@ -13,7 +13,7 @@ mod auto_updater;
 mod browser;
 mod browser_runner;
 mod browser_version_service;
-mod camoufox_direct;
+mod camoufox;
 mod default_browser;
 mod download;
 mod downloaded_browsers;
@@ -44,9 +44,7 @@ use settings_manager::{
   save_app_settings, save_table_sorting_settings, should_show_settings_on_startup,
 };
 
-use default_browser::{
-  is_default_browser, open_url_with_profile, set_as_default_browser, smart_open_url,
-};
+use default_browser::{is_default_browser, open_url_with_profile, set_as_default_browser};
 
 use version_updater::{
   get_version_update_status, get_version_updater, trigger_manual_version_update,
@@ -179,7 +177,7 @@ async fn delete_stored_proxy(proxy_id: String) -> Result<(), String> {
 #[tauri::command]
 async fn update_camoufox_config(
   profile_name: String,
-  config: crate::camoufox_direct::CamoufoxConfig,
+  config: crate::camoufox::CamoufoxConfig,
 ) -> Result<(), String> {
   let browser_runner = browser_runner::BrowserRunner::new();
   browser_runner
@@ -337,6 +335,27 @@ pub fn run() {
         auto_updater::check_for_updates_with_progress(app_handle_auto_updater).await;
       });
 
+      // Handle any pending URLs that were received before the window was ready
+      let handle_pending = handle.clone();
+      tauri::async_runtime::spawn(async move {
+        // Wait a bit for the window to be fully ready
+        tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+        let pending_urls = {
+          let mut pending = PENDING_URLS.lock().unwrap();
+          let urls = pending.clone();
+          pending.clear();
+          urls
+        };
+
+        for url in pending_urls {
+          println!("Processing pending URL: {url}");
+          if let Err(e) = handle_url_open(handle_pending.clone(), url).await {
+            eprintln!("Failed to handle pending URL: {e}");
+          }
+        }
+      });
+
       // Start periodic cleanup task for unused binaries
       tauri::async_runtime::spawn(async move {
         let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(300)); // Every 5 minutes
@@ -382,7 +401,7 @@ pub fn run() {
       // Start Camoufox cleanup task
       let app_handle_cleanup = app.handle().clone();
       tauri::async_runtime::spawn(async move {
-        let launcher = crate::camoufox_direct::CamoufoxDirectLauncher::new(app_handle_cleanup);
+        let launcher = crate::camoufox::CamoufoxNodecarLauncher::new(app_handle_cleanup);
         let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(5));
 
         loop {
@@ -469,7 +488,6 @@ pub fn run() {
       is_default_browser,
       open_url_with_profile,
       set_as_default_browser,
-      smart_open_url,
       trigger_manual_version_update,
       get_version_update_status,
       check_for_browser_updates,