refactor: make ui reactive for proxy changes

src-tauri/src/api_server.rs

@@ -537,11 +537,11 @@ async fn get_group(
 }
 
 async fn create_group(
-  State(_state): State<ApiServerState>,
+  State(state): State<ApiServerState>,
   Json(request): Json<CreateGroupRequest>,
 ) -> Result<Json<ApiGroupResponse>, StatusCode> {
   match GROUP_MANAGER.lock() {
-    Ok(manager) => match manager.create_group(request.name) {
+    Ok(manager) => match manager.create_group(&state.app_handle, request.name) {
       Ok(group) => Ok(Json(ApiGroupResponse {
         id: group.id,
         name: group.name,
@@ -555,11 +555,11 @@ async fn create_group(
 
 async fn update_group(
   Path(id): Path<String>,
-  State(_state): State<ApiServerState>,
+  State(state): State<ApiServerState>,
   Json(request): Json<UpdateGroupRequest>,
 ) -> Result<Json<ApiGroupResponse>, StatusCode> {
   match GROUP_MANAGER.lock() {
-    Ok(manager) => match manager.update_group(id.clone(), request.name) {
+    Ok(manager) => match manager.update_group(&state.app_handle, id.clone(), request.name) {
       Ok(group) => Ok(Json(ApiGroupResponse {
         id: group.id,
         name: group.name,
@@ -573,10 +573,10 @@ async fn update_group(
 
 async fn delete_group(
   Path(id): Path<String>,
-  State(_state): State<ApiServerState>,
+  State(state): State<ApiServerState>,
 ) -> Result<StatusCode, StatusCode> {
   match GROUP_MANAGER.lock() {
-    Ok(manager) => match manager.delete_group(id.clone()) {
+    Ok(manager) => match manager.delete_group(&state.app_handle, id.clone()) {
       Ok(_) => Ok(StatusCode::NO_CONTENT),
       Err(_) => Err(StatusCode::BAD_REQUEST),
     },
@@ -629,13 +629,13 @@ async fn get_proxy(
 }
 
 async fn create_proxy(
-  State(_state): State<ApiServerState>,
+  State(state): State<ApiServerState>,
   Json(request): Json<CreateProxyRequest>,
 ) -> Result<Json<ApiProxyResponse>, StatusCode> {
   // Convert JSON value to ProxySettings
   match serde_json::from_value(request.proxy_settings.clone()) {
     Ok(proxy_settings) => {
-      match PROXY_MANAGER.create_stored_proxy(request.name.clone(), proxy_settings) {
+      match PROXY_MANAGER.create_stored_proxy(&state.app_handle, request.name.clone(), proxy_settings) {
         Ok(_) => {
           // Find the created proxy to return it
           let proxies = PROXY_MANAGER.get_stored_proxies();
@@ -658,7 +658,7 @@ async fn create_proxy(
 
 async fn update_proxy(
   Path(id): Path<String>,
-  State(_state): State<ApiServerState>,
+  State(state): State<ApiServerState>,
   Json(request): Json<UpdateProxyRequest>,
 ) -> Result<Json<ApiProxyResponse>, StatusCode> {
   let proxies = PROXY_MANAGER.get_stored_proxies();
@@ -674,6 +674,7 @@ async fn update_proxy(
     };
 
     match PROXY_MANAGER.update_stored_proxy(
+      &state.app_handle,
       &id,
       Some(new_name.clone()),
       Some(new_proxy_settings.clone()),
@@ -692,9 +693,9 @@ async fn update_proxy(
 
 async fn delete_proxy(
   Path(id): Path<String>,
-  State(_state): State<ApiServerState>,
+  State(state): State<ApiServerState>,
 ) -> Result<StatusCode, StatusCode> {
-  match PROXY_MANAGER.delete_stored_proxy(&id) {
+  match PROXY_MANAGER.delete_stored_proxy(&state.app_handle, &id) {
     Ok(_) => Ok(StatusCode::NO_CONTENT),
     Err(_) => Err(StatusCode::BAD_REQUEST),
   }

src-tauri/src/lib.rs

@@ -174,11 +174,12 @@ async fn handle_url_open(app: tauri::AppHandle, url: String) -> Result<(), Strin
 
 #[tauri::command]
 async fn create_stored_proxy(
+  app_handle: tauri::AppHandle,
   name: String,
   proxy_settings: crate::browser::ProxySettings,
 ) -> Result<crate::proxy_manager::StoredProxy, String> {
   crate::proxy_manager::PROXY_MANAGER
-    .create_stored_proxy(name, proxy_settings)
+    .create_stored_proxy(&app_handle, name, proxy_settings)
     .map_err(|e| format!("Failed to create stored proxy: {e}"))
 }
 
@@ -189,19 +190,20 @@ async fn get_stored_proxies() -> Result<Vec<crate::proxy_manager::StoredProxy>,
 
 #[tauri::command]
 async fn update_stored_proxy(
+  app_handle: tauri::AppHandle,
   proxy_id: String,
   name: Option<String>,
   proxy_settings: Option<crate::browser::ProxySettings>,
 ) -> Result<crate::proxy_manager::StoredProxy, String> {
   crate::proxy_manager::PROXY_MANAGER
-    .update_stored_proxy(&proxy_id, name, proxy_settings)
+    .update_stored_proxy(&app_handle, &proxy_id, name, proxy_settings)
     .map_err(|e| format!("Failed to update stored proxy: {e}"))
 }
 
 #[tauri::command]
-async fn delete_stored_proxy(proxy_id: String) -> Result<(), String> {
+async fn delete_stored_proxy(app_handle: tauri::AppHandle, proxy_id: String) -> Result<(), String> {
   crate::proxy_manager::PROXY_MANAGER
-    .delete_stored_proxy(&proxy_id)
+    .delete_stored_proxy(&app_handle, &proxy_id)
     .map_err(|e| format!("Failed to delete stored proxy: {e}"))
 }
 

src-tauri/src/proxy_manager.rs

@@ -6,6 +6,7 @@ use std::fs;
 use std::path::PathBuf;
 use std::sync::Mutex;
 use tauri_plugin_shell::ShellExt;
+use tauri::Emitter;
 
 use crate::browser::ProxySettings;
 
@@ -146,6 +147,7 @@ impl ProxyManager {
   // Create a new stored proxy
   pub fn create_stored_proxy(
     &self,
+    app_handle: &tauri::AppHandle,
     name: String,
     proxy_settings: ProxySettings,
   ) -> Result<StoredProxy, String> {
@@ -168,6 +170,11 @@ impl ProxyManager {
       eprintln!("Warning: Failed to save proxy: {e}");
     }
 
+    // Emit event for reactive UI updates
+    if let Err(e) = app_handle.emit("proxies-changed", ()) {
+      eprintln!("Failed to emit proxies-changed event: {e}");
+    }
+
     Ok(stored_proxy)
   }
 
@@ -182,6 +189,7 @@ impl ProxyManager {
   // Update a stored proxy
   pub fn update_stored_proxy(
     &self,
+    app_handle: &tauri::AppHandle,
     proxy_id: &str,
     name: Option<String>,
     proxy_settings: Option<ProxySettings>,
@@ -226,11 +234,16 @@ impl ProxyManager {
       eprintln!("Warning: Failed to save proxy: {e}");
     }
 
+    // Emit event for reactive UI updates
+    if let Err(e) = app_handle.emit("proxies-changed", ()) {
+      eprintln!("Failed to emit proxies-changed event: {e}");
+    }
+
     Ok(updated_proxy)
   }
 
   // Delete a stored proxy
-  pub fn delete_stored_proxy(&self, proxy_id: &str) -> Result<(), String> {
+  pub fn delete_stored_proxy(&self, app_handle: &tauri::AppHandle, proxy_id: &str) -> Result<(), String> {
     {
       let mut stored_proxies = self.stored_proxies.lock().unwrap();
       if stored_proxies.remove(proxy_id).is_none() {
@@ -242,6 +255,11 @@ impl ProxyManager {
       eprintln!("Warning: Failed to delete proxy file: {e}");
     }
 
+    // Emit event for reactive UI updates
+    if let Err(e) = app_handle.emit("proxies-changed", ()) {
+      eprintln!("Failed to emit proxies-changed event: {e}");
+    }
+
     Ok(())
   }
 
@@ -514,6 +532,11 @@ impl ProxyManager {
       }
     }
 
+    // Emit event for reactive UI updates
+    if let Err(e) = app_handle.emit("proxies-changed", ()) {
+      eprintln!("Failed to emit proxies-changed event: {e}");
+    }
+
     Ok(())
   }
 
@@ -554,6 +577,11 @@ impl ProxyManager {
       let _ = self.stop_proxy(app_handle.clone(), *dead_pid).await;
     }
 
+    // Emit event for reactive UI updates
+    if let Err(e) = app_handle.emit("proxies-changed", ()) {
+      eprintln!("Failed to emit proxies-changed event: {e}");
+    }
+
     Ok(dead_pids)
   }
 }