refactor: update ui on profile events

src-tauri/src/api_server.rs

@@ -49,7 +49,7 @@ pub struct ApiProfileResponse {
 pub struct CreateProfileRequest {
   pub name: String,
   pub browser: String,
-  pub version: Option<String>,
+  pub version: String,
   pub proxy_id: Option<String>,
   pub release_type: Option<String>,
   pub camoufox_config: Option<serde_json::Value>,
@@ -350,8 +350,8 @@ async fn create_profile(
       &state.app_handle,
       &request.name,
       &request.browser,
-      request.version.as_deref().unwrap_or("stable"),
-      request.release_type.as_deref().unwrap_or("release"),
+      &request.version,
+      request.release_type.as_deref().unwrap_or("stable"),
       request.proxy_id.clone(),
       camoufox_config,
       request.group_id.clone(),
@@ -362,7 +362,7 @@ async fn create_profile(
       // Apply tags if provided
       if let Some(tags) = &request.tags {
         if profile_manager
-          .update_profile_tags(&profile.name, tags.clone())
+          .update_profile_tags(&state.app_handle, &profile.name, tags.clone())
           .is_err()
         {
           return Err(StatusCode::INTERNAL_SERVER_ERROR);
@@ -410,14 +410,14 @@ async fn update_profile(
 
   // Update profile fields
   if let Some(new_name) = request.name {
-    if profile_manager.rename_profile(&name, &new_name).is_err() {
+    if profile_manager.rename_profile(&state.app_handle, &name, &new_name).is_err() {
       return Err(StatusCode::BAD_REQUEST);
     }
   }
 
   if let Some(version) = request.version {
     if profile_manager
-      .update_profile_version(&name, &version)
+      .update_profile_version(&state.app_handle, &name, &version)
       .is_err()
     {
       return Err(StatusCode::BAD_REQUEST);
@@ -453,7 +453,7 @@ async fn update_profile(
 
   if let Some(group_id) = request.group_id {
     if profile_manager
-      .assign_profiles_to_group(vec![name.clone()], Some(group_id))
+      .assign_profiles_to_group(&state.app_handle, vec![name.clone()], Some(group_id))
       .is_err()
     {
       return Err(StatusCode::BAD_REQUEST);
@@ -461,7 +461,7 @@ async fn update_profile(
   }
 
   if let Some(tags) = request.tags {
-    if profile_manager.update_profile_tags(&name, tags).is_err() {
+    if profile_manager.update_profile_tags(&state.app_handle, &name, tags).is_err() {
       return Err(StatusCode::BAD_REQUEST);
     }
 
@@ -479,10 +479,10 @@ async fn update_profile(
 
 async fn delete_profile(
   Path(id): Path<String>,
-  State(_state): State<ApiServerState>,
+  State(state): State<ApiServerState>,
 ) -> Result<StatusCode, StatusCode> {
   let profile_manager = ProfileManager::instance();
-  match profile_manager.delete_profile(&id) {
+  match profile_manager.delete_profile(&state.app_handle, &id) {
     Ok(_) => Ok(StatusCode::NO_CONTENT),
     Err(_) => Err(StatusCode::BAD_REQUEST),
   }

src-tauri/src/auto_updater.rs

@@ -148,11 +148,11 @@ impl AutoUpdater {
             );
 
             // Clone app_handle for the async task
-            let app_handle_clone = app_handle.clone();
             let browser = notification.browser.clone();
             let new_version = notification.new_version.clone();
             let notification_id = notification.id.clone();
             let affected_profiles = notification.affected_profiles.clone();
+            let app_handle_clone = app_handle.clone();
 
             // Spawn async task to handle the download and auto-update
             tokio::spawn(async move {
@@ -166,6 +166,7 @@ impl AutoUpdater {
 
                   // Browser already exists, go straight to profile update
                   match crate::auto_updater::complete_browser_update_with_auto_update(
+                    app_handle_clone,
                     browser.clone(),
                     new_version.clone(),
                   )
@@ -293,6 +294,7 @@ impl AutoUpdater {
   /// Automatically update all affected profile versions after browser download
   pub async fn auto_update_profile_versions(
     &self,
+    app_handle: &tauri::AppHandle,
     browser: &str,
     new_version: &str,
   ) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
@@ -314,7 +316,7 @@ impl AutoUpdater {
         // Check if this is an update (newer version)
         if self.is_version_newer(new_version, &profile.version) {
           // Update the profile version
-          match profile_manager.update_profile_version(&profile.name, new_version) {
+          match profile_manager.update_profile_version(app_handle, &profile.name, new_version) {
             Ok(_) => {
               updated_profiles.push(profile.name);
             }
@@ -332,12 +334,13 @@ impl AutoUpdater {
   /// Complete browser update process with auto-update of profile versions
   pub async fn complete_browser_update_with_auto_update(
     &self,
+    app_handle: &tauri::AppHandle,
     browser: &str,
     new_version: &str,
   ) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
     // Auto-update profile versions first
     let updated_profiles = self
-      .auto_update_profile_versions(browser, new_version)
+      .auto_update_profile_versions(app_handle, browser, new_version)
       .await?;
 
     // Remove browser from disabled list and clean up auto-update tracking
@@ -480,12 +483,13 @@ pub async fn dismiss_update_notification(notification_id: String) -> Result<(),
 
 #[tauri::command]
 pub async fn complete_browser_update_with_auto_update(
+  app_handle: tauri::AppHandle,
   browser: String,
   new_version: String,
 ) -> Result<Vec<String>, String> {
   let updater = AutoUpdater::instance();
   updater
-    .complete_browser_update_with_auto_update(&browser, &new_version)
+    .complete_browser_update_with_auto_update(&app_handle, &browser, &new_version)
     .await
     .map_err(|e| format!("Failed to complete browser update: {e}"))
 }
@@ -876,7 +880,7 @@ mod tests {
     use tempfile::TempDir;
 
     // Create a temporary directory for testing
-    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+    let temp_dir = TempDir::new().unwrap();
 
     // Create a mock settings manager that uses the temp directory
     struct TestSettingsManager {

src-tauri/src/browser_runner.rs

@@ -909,9 +909,9 @@ impl BrowserRunner {
     })
   }
 
-  pub fn delete_profile(&self, profile_id: &str) -> Result<(), Box<dyn std::error::Error>> {
+  pub fn delete_profile(&self, app_handle: tauri::AppHandle, profile_id: &str) -> Result<(), Box<dyn std::error::Error>> {
     let profile_manager = ProfileManager::instance();
-    profile_manager.delete_profile(profile_id)?;
+    profile_manager.delete_profile(&app_handle, profile_id)?;
 
     // Always perform cleanup after profile deletion to remove unused binaries
     if let Err(e) = self.cleanup_unused_binaries_internal() {
@@ -1055,7 +1055,7 @@ impl BrowserRunner {
       let system = System::new_all();
       if let Some(process) = system.process(sysinfo::Pid::from(pid as usize)) {
         let cmd = process.cmd();
-        let exe_name = process.name().to_string_lossy().to_lowercase();
+        let exe_name = process.name().to_string_lossy();
 
         // Verify this process is actually our browser
         let is_correct_browser = match profile.browser.as_str() {
@@ -1974,12 +1974,13 @@ pub async fn update_profile_proxy(
 
 #[tauri::command]
 pub fn update_profile_tags(
+  app_handle: tauri::AppHandle,
   profile_name: String,
   tags: Vec<String>,
 ) -> Result<BrowserProfile, String> {
   let profile_manager = ProfileManager::instance();
   profile_manager
-    .update_profile_tags(&profile_name, tags)
+    .update_profile_tags(&app_handle, &profile_name, tags)
     .map_err(|e| format!("Failed to update profile tags: {e}"))
 }
 
@@ -1997,21 +1998,21 @@ pub async fn check_browser_status(
 
 #[tauri::command]
 pub fn rename_profile(
-  _app_handle: tauri::AppHandle,
+  app_handle: tauri::AppHandle,
   old_name: &str,
   new_name: &str,
 ) -> Result<BrowserProfile, String> {
   let profile_manager = ProfileManager::instance();
   profile_manager
-    .rename_profile(old_name, new_name)
+    .rename_profile(&app_handle, old_name, new_name)
     .map_err(|e| format!("Failed to rename profile: {e}"))
 }
 
 #[tauri::command]
-pub fn delete_profile(_app_handle: tauri::AppHandle, profile_id: String) -> Result<(), String> {
+pub async fn delete_profile(app_handle: tauri::AppHandle, profile_id: String) -> Result<(), String> {
   let browser_runner = BrowserRunner::instance();
   browser_runner
-    .delete_profile(profile_id.as_str())
+    .delete_profile(app_handle, &profile_id)
     .map_err(|e| format!("Failed to delete profile: {e}"))
 }
 

src-tauri/src/group_manager.rs

@@ -519,19 +519,23 @@ pub async fn delete_profile_group(group_id: String) -> Result<(), String> {
 
 #[tauri::command]
 pub async fn assign_profiles_to_group(
+  app_handle: tauri::AppHandle,
   profile_names: Vec<String>,
   group_id: Option<String>,
 ) -> Result<(), String> {
   let profile_manager = crate::profile::ProfileManager::instance();
   profile_manager
-    .assign_profiles_to_group(profile_names, group_id)
+    .assign_profiles_to_group(&app_handle, profile_names, group_id)
     .map_err(|e| format!("Failed to assign profiles to group: {e}"))
 }
 
 #[tauri::command]
-pub async fn delete_selected_profiles(profile_names: Vec<String>) -> Result<(), String> {
+pub async fn delete_selected_profiles(
+  app_handle: tauri::AppHandle,
+  profile_names: Vec<String>,
+) -> Result<(), String> {
   let profile_manager = crate::profile::ProfileManager::instance();
   profile_manager
-    .delete_multiple_profiles(profile_names)
+    .delete_multiple_profiles(&app_handle, profile_names)
     .map_err(|e| format!("Failed to delete profiles: {e}"))
 }

src-tauri/src/profile/manager.rs

@@ -218,6 +218,11 @@ impl ProfileManager {
       self.disable_proxy_settings_in_profile(&profile_data_dir)?;
     }
 
+    // Emit profile creation event
+    if let Err(e) = app_handle.emit("profiles-changed", ()) {
+      println!("Warning: Failed to emit profiles-changed event: {e}");
+    }
+
     Ok(profile)
   }
 
@@ -262,6 +267,7 @@ impl ProfileManager {
 
   pub fn rename_profile(
     &self,
+    app_handle: &tauri::AppHandle,
     old_name: &str,
     new_name: &str,
   ) -> Result<BrowserProfile, Box<dyn std::error::Error>> {
@@ -291,10 +297,19 @@ impl ProfileManager {
       let _ = tm.rebuild_from_profiles(&self.list_profiles().unwrap_or_default());
     });
 
+    // Emit profile rename event
+    if let Err(e) = app_handle.emit("profiles-changed", ()) {
+      println!("Warning: Failed to emit profiles-changed event: {e}");
+    }
+
     Ok(profile)
   }
 
-  pub fn delete_profile(&self, profile_name: &str) -> Result<(), Box<dyn std::error::Error>> {
+  pub fn delete_profile(
+    &self,
+    app_handle: &tauri::AppHandle,
+    profile_name: &str,
+  ) -> Result<(), Box<dyn std::error::Error>> {
     println!("Attempting to delete profile: {profile_name}");
 
     // Find the profile by name
@@ -333,11 +348,17 @@ impl ProfileManager {
       let _ = tm.rebuild_from_profiles(&self.list_profiles().unwrap_or_default());
     });
 
+    // Emit profile deletion event
+    if let Err(e) = app_handle.emit("profiles-changed", ()) {
+      println!("Warning: Failed to emit profiles-changed event: {e}");
+    }
+
     Ok(())
   }
 
   pub fn update_profile_version(
     &self,
+    app_handle: &tauri::AppHandle,
     profile_name: &str,
     version: &str,
   ) -> Result<BrowserProfile, Box<dyn std::error::Error>> {
@@ -379,11 +400,17 @@ impl ProfileManager {
     // Save the updated profile
     self.save_profile(&profile)?;
 
+    // Emit profile update event
+    if let Err(e) = app_handle.emit("profiles-changed", ()) {
+      println!("Warning: Failed to emit profiles-changed event: {e}");
+    }
+
     Ok(profile)
   }
 
   pub fn assign_profiles_to_group(
     &self,
+    app_handle: &tauri::AppHandle,
     profile_names: Vec<String>,
     group_id: Option<String>,
   ) -> Result<(), Box<dyn std::error::Error>> {
@@ -412,11 +439,17 @@ impl ProfileManager {
       let _ = tm.rebuild_from_profiles(&self.list_profiles().unwrap_or_default());
     });
 
+    // Emit profile group assignment event
+    if let Err(e) = app_handle.emit("profiles-changed", ()) {
+      println!("Warning: Failed to emit profiles-changed event: {e}");
+    }
+
     Ok(())
   }
 
   pub fn update_profile_tags(
     &self,
+    app_handle: &tauri::AppHandle,
     profile_name: &str,
     tags: Vec<String>,
   ) -> Result<BrowserProfile, Box<dyn std::error::Error>> {
@@ -444,11 +477,17 @@ impl ProfileManager {
       let _ = tm.rebuild_from_profiles(&self.list_profiles().unwrap_or_default());
     });
 
+    // Emit profile tags update event
+    if let Err(e) = app_handle.emit("profiles-changed", ()) {
+      println!("Warning: Failed to emit profiles-changed event: {e}");
+    }
+
     Ok(profile)
   }
 
   pub fn delete_multiple_profiles(
     &self,
+    app_handle: &tauri::AppHandle,
     profile_names: Vec<String>,
   ) -> Result<(), Box<dyn std::error::Error>> {
     let profiles = self.list_profiles()?;
@@ -478,6 +517,11 @@ impl ProfileManager {
       }
     }
 
+    // Emit profile deletion event
+    if let Err(e) = app_handle.emit("profiles-changed", ()) {
+      println!("Warning: Failed to emit profiles-changed event: {e}");
+    }
+
     Ok(())
   }
 
@@ -502,7 +546,7 @@ impl ProfileManager {
       })?;
 
     // Check if the browser is currently running using the comprehensive status check
-    let is_running = self.check_browser_status(app_handle, &profile).await?;
+    let is_running = self.check_browser_status(app_handle.clone(), &profile).await?;
 
     if is_running {
       return Err(
@@ -522,6 +566,11 @@ impl ProfileManager {
 
     println!("Camoufox configuration updated for profile '{profile_name}'.");
 
+    // Emit profile config update event
+    if let Err(e) = app_handle.emit("profiles-changed", ()) {
+      println!("Warning: Failed to emit profiles-changed event: {e}");
+    }
+
     Ok(())
   }
 
@@ -592,6 +641,11 @@ impl ProfileManager {
       println!("Warning: Failed to emit profile update event: {e}");
     }
 
+    // Emit general profiles changed event for profile list updates
+    if let Err(e) = app_handle.emit("profiles-changed", ()) {
+      println!("Warning: Failed to emit profiles-changed event: {e}");
+    }
+
     Ok(profile)
   }