feat: add proxy configuration support

  - Add proxy settings UI component with enable/disable toggle
  - Support HTTP, HTTPS, NO_PROXY, and ALL_PROXY environment variables
  - Store proxy settings in app database for persistence
  - Apply proxy settings on app startup and when saved
  - Pass proxy environment variables to Claude command execution
  - Integrate proxy settings into main Settings page with unified save
  - Add proxy support for both system binary and sidecar execution

  This allows users to configure proxy settings for Claude API requests,
  which is essential for users behind corporate firewalls or in regions
  requiring proxy access.

  Fixes network connectivity issues in restricted environments.

Author: CatherineXiaoXiao

src-tauri/src/claude_binary.rs

@@ -509,6 +509,8 @@ fn compare_versions(a: &str, b: &str) -> Ordering {
 /// This ensures commands like Claude can find Node.js and other dependencies
 pub fn create_command_with_env(program: &str) -> Command {
     let mut cmd = Command::new(program);
+    
+    info!("Creating command for: {}", program);
 
     // Inherit essential environment variables from parent process
     for (key, value) in std::env::vars() {
@@ -525,11 +527,25 @@ pub fn create_command_with_env(program: &str) -> Command {
             || key == "NVM_BIN"
             || key == "HOMEBREW_PREFIX"
             || key == "HOMEBREW_CELLAR"
+            // Add proxy environment variables (only uppercase)
+            || key == "HTTP_PROXY"
+            || key == "HTTPS_PROXY"
+            || key == "NO_PROXY"
+            || key == "ALL_PROXY"
         {
             debug!("Inheriting env var: {}={}", key, value);
             cmd.env(&key, &value);
         }
     }
+    
+    // Log proxy-related environment variables for debugging
+    info!("Command will use proxy settings:");
+    if let Ok(http_proxy) = std::env::var("HTTP_PROXY") {
+        info!("  HTTP_PROXY={}", http_proxy);
+    }
+    if let Ok(https_proxy) = std::env::var("HTTPS_PROXY") {
+        info!("  HTTPS_PROXY={}", https_proxy);
+    }
 
     // Add NVM support if the program is in an NVM directory
     if program.contains("/.nvm/versions/node/") {

src-tauri/src/commands/agents.rs

@@ -796,6 +796,18 @@ fn create_agent_sidecar_command(
     // Set working directory
     sidecar_cmd = sidecar_cmd.current_dir(project_path);
 
+    // Pass through proxy environment variables if they exist (only uppercase)
+    for (key, value) in std::env::vars() {
+        if key == "HTTP_PROXY"
+            || key == "HTTPS_PROXY"
+            || key == "NO_PROXY"
+            || key == "ALL_PROXY"
+        {
+            debug!("Setting proxy env var for agent sidecar: {}={}", key, value);
+            sidecar_cmd = sidecar_cmd.env(&key, &value);
+        }
+    }
+    
     Ok(sidecar_cmd)
 }
 

src-tauri/src/commands/claude.rs

@@ -288,6 +288,18 @@ fn create_sidecar_command(
     // Set working directory
     sidecar_cmd = sidecar_cmd.current_dir(project_path);
 
+    // Pass through proxy environment variables if they exist (only uppercase)
+    for (key, value) in std::env::vars() {
+        if key == "HTTP_PROXY"
+            || key == "HTTPS_PROXY"
+            || key == "NO_PROXY"
+            || key == "ALL_PROXY"
+        {
+            log::debug!("Setting proxy env var for sidecar: {}={}", key, value);
+            sidecar_cmd = sidecar_cmd.env(&key, &value);
+        }
+    }
+    
     Ok(sidecar_cmd)
 }
 

src-tauri/src/commands/mod.rs

@@ -4,3 +4,4 @@ pub mod mcp;
 pub mod usage;
 pub mod storage;
 pub mod slash_commands;
+pub mod proxy;

src-tauri/src/commands/proxy.rs

@@ -0,0 +1,155 @@
+use serde::{Deserialize, Serialize};
+use tauri::State;
+use rusqlite::params;
+
+use crate::commands::agents::AgentDb;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct ProxySettings {
+    pub http_proxy: Option<String>,
+    pub https_proxy: Option<String>,
+    pub no_proxy: Option<String>,
+    pub all_proxy: Option<String>,
+    pub enabled: bool,
+}
+
+impl Default for ProxySettings {
+    fn default() -> Self {
+        Self {
+            http_proxy: None,
+            https_proxy: None,
+            no_proxy: None,
+            all_proxy: None,
+            enabled: false,
+        }
+    }
+}
+
+/// Get proxy settings from the database
+#[tauri::command]
+pub async fn get_proxy_settings(db: State<'_, AgentDb>) -> Result<ProxySettings, String> {
+    let conn = db.0.lock().map_err(|e| e.to_string())?;
+    
+    let mut settings = ProxySettings::default();
+    
+    // Query each proxy setting
+    let keys = vec![
+        ("proxy_enabled", "enabled"),
+        ("proxy_http", "http_proxy"),
+        ("proxy_https", "https_proxy"),
+        ("proxy_no", "no_proxy"),
+        ("proxy_all", "all_proxy"),
+    ];
+    
+    for (db_key, field) in keys {
+        if let Ok(value) = conn.query_row(
+            "SELECT value FROM app_settings WHERE key = ?1",
+            params![db_key],
+            |row| row.get::<_, String>(0),
+        ) {
+            match field {
+                "enabled" => settings.enabled = value == "true",
+                "http_proxy" => settings.http_proxy = Some(value).filter(|s| !s.is_empty()),
+                "https_proxy" => settings.https_proxy = Some(value).filter(|s| !s.is_empty()),
+                "no_proxy" => settings.no_proxy = Some(value).filter(|s| !s.is_empty()),
+                "all_proxy" => settings.all_proxy = Some(value).filter(|s| !s.is_empty()),
+                _ => {}
+            }
+        }
+    }
+    
+    Ok(settings)
+}
+
+/// Save proxy settings to the database
+#[tauri::command]
+pub async fn save_proxy_settings(
+    db: State<'_, AgentDb>,
+    settings: ProxySettings,
+) -> Result<(), String> {
+    let conn = db.0.lock().map_err(|e| e.to_string())?;
+    
+    // Save each setting
+    let values = vec![
+        ("proxy_enabled", settings.enabled.to_string()),
+        ("proxy_http", settings.http_proxy.clone().unwrap_or_default()),
+        ("proxy_https", settings.https_proxy.clone().unwrap_or_default()),
+        ("proxy_no", settings.no_proxy.clone().unwrap_or_default()),
+        ("proxy_all", settings.all_proxy.clone().unwrap_or_default()),
+    ];
+    
+    for (key, value) in values {
+        conn.execute(
+            "INSERT OR REPLACE INTO app_settings (key, value) VALUES (?1, ?2)",
+            params![key, value],
+        ).map_err(|e| format!("Failed to save {}: {}", key, e))?;
+    }
+    
+    // Apply the proxy settings immediately to the current process
+    apply_proxy_settings(&settings);
+    
+    Ok(())
+}
+
+/// Apply proxy settings as environment variables
+pub fn apply_proxy_settings(settings: &ProxySettings) {
+    log::info!("Applying proxy settings: enabled={}", settings.enabled);
+    
+    if !settings.enabled {
+        // Clear proxy environment variables if disabled
+        log::info!("Clearing proxy environment variables");
+        std::env::remove_var("HTTP_PROXY");
+        std::env::remove_var("HTTPS_PROXY");
+        std::env::remove_var("NO_PROXY");
+        std::env::remove_var("ALL_PROXY");
+        // Also clear lowercase versions
+        std::env::remove_var("http_proxy");
+        std::env::remove_var("https_proxy");
+        std::env::remove_var("no_proxy");
+        std::env::remove_var("all_proxy");
+        return;
+    }
+    
+    // Ensure NO_PROXY includes localhost by default
+    let mut no_proxy_list = vec!["localhost", "127.0.0.1", "::1", "0.0.0.0"];
+    if let Some(user_no_proxy) = &settings.no_proxy {
+        if !user_no_proxy.is_empty() {
+            no_proxy_list.push(user_no_proxy.as_str());
+        }
+    }
+    let no_proxy_value = no_proxy_list.join(",");
+    
+    // Set proxy environment variables (uppercase is standard)
+    if let Some(http_proxy) = &settings.http_proxy {
+        if !http_proxy.is_empty() {
+            log::info!("Setting HTTP_PROXY={}", http_proxy);
+            std::env::set_var("HTTP_PROXY", http_proxy);
+        }
+    }
+    
+    if let Some(https_proxy) = &settings.https_proxy {
+        if !https_proxy.is_empty() {
+            log::info!("Setting HTTPS_PROXY={}", https_proxy);
+            std::env::set_var("HTTPS_PROXY", https_proxy);
+        }
+    }
+    
+    // Always set NO_PROXY to include localhost
+    log::info!("Setting NO_PROXY={}", no_proxy_value);
+    std::env::set_var("NO_PROXY", &no_proxy_value);
+    
+    if let Some(all_proxy) = &settings.all_proxy {
+        if !all_proxy.is_empty() {
+            log::info!("Setting ALL_PROXY={}", all_proxy);
+            std::env::set_var("ALL_PROXY", all_proxy);
+        }
+    }
+    
+    // Log current proxy environment variables for debugging
+    log::info!("Current proxy environment variables:");
+    for (key, value) in std::env::vars() {
+        if key.contains("PROXY") || key.contains("proxy") {
+            log::info!("  {}={}", key, value);
+        }
+    }
+}

src-tauri/src/main.rs

@@ -42,6 +42,7 @@ use commands::storage::{
     storage_list_tables, storage_read_table, storage_update_row, storage_delete_row,
     storage_insert_row, storage_execute_sql, storage_reset_database,
 };
+use commands::proxy::{get_proxy_settings, save_proxy_settings, apply_proxy_settings};
 use process::ProcessRegistryState;
 use std::sync::Mutex;
 use tauri::Manager;
@@ -57,6 +58,55 @@ fn main() {
         .setup(|app| {
             // Initialize agents database
             let conn = init_database(&app.handle()).expect("Failed to initialize agents database");
+            
+            // Load and apply proxy settings from the database
+            {
+                let db = AgentDb(Mutex::new(conn));
+                let proxy_settings = match db.0.lock() {
+                    Ok(conn) => {
+                        // Directly query proxy settings from the database
+                        let mut settings = commands::proxy::ProxySettings::default();
+                        
+                        let keys = vec![
+                            ("proxy_enabled", "enabled"),
+                            ("proxy_http", "http_proxy"),
+                            ("proxy_https", "https_proxy"),
+                            ("proxy_no", "no_proxy"),
+                            ("proxy_all", "all_proxy"),
+                        ];
+                        
+                        for (db_key, field) in keys {
+                            if let Ok(value) = conn.query_row(
+                                "SELECT value FROM app_settings WHERE key = ?1",
+                                rusqlite::params![db_key],
+                                |row| row.get::<_, String>(0),
+                            ) {
+                                match field {
+                                    "enabled" => settings.enabled = value == "true",
+                                    "http_proxy" => settings.http_proxy = Some(value).filter(|s| !s.is_empty()),
+                                    "https_proxy" => settings.https_proxy = Some(value).filter(|s| !s.is_empty()),
+                                    "no_proxy" => settings.no_proxy = Some(value).filter(|s| !s.is_empty()),
+                                    "all_proxy" => settings.all_proxy = Some(value).filter(|s| !s.is_empty()),
+                                    _ => {}
+                                }
+                            }
+                        }
+                        
+                        log::info!("Loaded proxy settings: enabled={}", settings.enabled);
+                        settings
+                    }
+                    Err(e) => {
+                        log::warn!("Failed to lock database for proxy settings: {}", e);
+                        commands::proxy::ProxySettings::default()
+                    }
+                };
+                
+                // Apply the proxy settings
+                apply_proxy_settings(&proxy_settings);
+            }
+            
+            // Re-open the connection for the app to manage
+            let conn = init_database(&app.handle()).expect("Failed to initialize agents database");
             app.manage(AgentDb(Mutex::new(conn)));
 
             // Initialize checkpoint state
@@ -195,6 +245,10 @@ fn main() {
             commands::slash_commands::slash_command_get,
             commands::slash_commands::slash_command_save,
             commands::slash_commands::slash_command_delete,
+            
+            // Proxy Settings
+            get_proxy_settings,
+            save_proxy_settings,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");