fix(proxy): resolve 404 error and auto-setup proxy targets

Issues fixed: 1. Route prefix mismatch - Live config was set to use /claude, /codex, /gemini prefixes but server only had routes without prefixes 2. Proxy targets not auto-configured - start_with_takeover only modified Live config but didn't set is_proxy_target=true for current providers Changes: - Add prefixed routes (/claude/v1/messages, /codex/v1/*, /gemini/v1beta/*) to server.rs for backward compatibility - Remove URL prefixes from takeover_live_configs() - server can route by API endpoint path alone (/v1/messages=Claude, /v1/chat/completions=Codex) - Add setup_proxy_targets() method that automatically sets current providers as proxy targets when starting proxy with takeover - Unify proxy toggle in SettingsPage to use takeover mode (same as main UI) - Fix error message extraction in useProxyStatus hooks - Fix provider switch logic to check both takeover flag AND proxy running state
2026-07-24 12:44:18 +08:00 · 2025-12-10 19:58:43 +08:00
parent 3cdce2eced
commit 5cc864c6aa
17 changed files with 831 additions and 47 deletions
@@ -15,12 +15,26 @@ pub async fn start_proxy_server(
    state.proxy_service.start().await
 }

+/// 启动代理服务器（带 Live 配置接管）
+#[tauri::command]
+pub async fn start_proxy_with_takeover(
+    state: tauri::State<'_, AppState>,
+) -> Result<ProxyServerInfo, String> {
+    state.proxy_service.start_with_takeover().await
+}
+
 /// 停止代理服务器
 #[tauri::command]
 pub async fn stop_proxy_server(state: tauri::State<'_, AppState>) -> Result<(), String> {
    state.proxy_service.stop().await
 }

+/// 停止代理服务器（恢复 Live 配置）
+#[tauri::command]
+pub async fn stop_proxy_with_restore(state: tauri::State<'_, AppState>) -> Result<(), String> {
+    state.proxy_service.stop_with_restore().await
+}
+
 /// 获取代理服务器状态
 #[tauri::command]
 pub async fn get_proxy_status(state: tauri::State<'_, AppState>) -> Result<ProxyStatus, String> {
@@ -48,6 +62,25 @@ pub async fn is_proxy_running(state: tauri::State<'_, AppState>) -> Result<bool,
    Ok(state.proxy_service.is_running().await)
 }

+/// 检查是否处于 Live 接管模式
+#[tauri::command]
+pub async fn is_live_takeover_active(state: tauri::State<'_, AppState>) -> Result<bool, String> {
+    state.proxy_service.is_takeover_active().await
+}
+
+/// 代理模式下切换供应商（热切换）
+#[tauri::command]
+pub async fn switch_proxy_provider(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+    provider_id: String,
+) -> Result<(), String> {
+    state
+        .proxy_service
+        .switch_proxy_target(&app_type, &provider_id)
+        .await
+}
+
 // ==================== 故障转移相关命令 ====================

 /// 获取代理目标列表
@@ -17,7 +17,7 @@ impl Database {
            let conn = lock_conn!(self.conn);
            conn.query_row(
                "SELECT enabled, listen_address, listen_port, max_retries,
-                        request_timeout, enable_logging
+                        request_timeout, enable_logging, live_takeover_active
                 FROM proxy_config WHERE id = 1",
                [],
                |row| {
@@ -28,6 +28,7 @@ impl Database {
                        max_retries: row.get::<_, i32>(3)? as u8,
                        request_timeout: row.get::<_, i32>(4)? as u64,
                        enable_logging: row.get::<_, i32>(5)? != 0,
+                        live_takeover_active: row.get::<_, i32>(6).unwrap_or(0) != 0,
                    })
                },
            )
@@ -51,8 +52,8 @@ impl Database {

        conn.execute(
            "INSERT OR REPLACE INTO proxy_config
-             (id, enabled, listen_address, listen_port, max_retries, request_timeout, enable_logging, target_app, created_at, updated_at)
-             VALUES (1, ?1, ?2, ?3, ?4, ?5, ?6, ?7,
+             (id, enabled, listen_address, listen_port, max_retries, request_timeout, enable_logging, live_takeover_active, target_app, created_at, updated_at)
+             VALUES (1, ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8,
                     COALESCE((SELECT created_at FROM proxy_config WHERE id = 1), datetime('now')),
                     datetime('now'))",
            rusqlite::params![
@@ -62,6 +63,7 @@ impl Database {
                config.max_retries as i32,
                config.request_timeout as i32,
                if config.enable_logging { 1 } else { 0 },
+                if config.live_takeover_active { 1 } else { 0 },
                "claude", // 兼容旧字段，写入默认值
            ],
        )
@@ -70,6 +72,30 @@ impl Database {
        Ok(())
    }

+    /// 设置 Live 接管状态
+    pub async fn set_live_takeover_active(&self, active: bool) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+        conn.execute(
+            "UPDATE proxy_config SET live_takeover_active = ?1, updated_at = datetime('now') WHERE id = 1",
+            rusqlite::params![if active { 1 } else { 0 }],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+        Ok(())
+    }
+
+    /// 检查是否处于 Live 接管模式
+    pub async fn is_live_takeover_active(&self) -> Result<bool, AppError> {
+        let conn = lock_conn!(self.conn);
+        let active: i32 = conn
+            .query_row(
+                "SELECT COALESCE(live_takeover_active, 0) FROM proxy_config WHERE id = 1",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap_or(0);
+        Ok(active != 0)
+    }
+
    // ==================== Provider Health ====================

    /// 获取Provider健康状态
@@ -318,4 +344,74 @@ impl Database {

        Ok(())
    }
+
+    // ==================== Live Backup ====================
+
+    /// 保存 Live 配置备份
+    pub async fn save_live_backup(
+        &self,
+        app_type: &str,
+        config_json: &str,
+    ) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+        let now = chrono::Utc::now().to_rfc3339();
+
+        conn.execute(
+            "INSERT OR REPLACE INTO proxy_live_backup (app_type, original_config, backed_up_at)
+             VALUES (?1, ?2, ?3)",
+            rusqlite::params![app_type, config_json, now],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        log::info!("已备份 {app_type} Live 配置");
+        Ok(())
+    }
+
+    /// 获取 Live 配置备份
+    pub async fn get_live_backup(&self, app_type: &str) -> Result<Option<LiveBackup>, AppError> {
+        let conn = lock_conn!(self.conn);
+
+        let result = conn.query_row(
+            "SELECT app_type, original_config, backed_up_at FROM proxy_live_backup WHERE app_type = ?1",
+            rusqlite::params![app_type],
+            |row| {
+                Ok(LiveBackup {
+                    app_type: row.get(0)?,
+                    original_config: row.get(1)?,
+                    backed_up_at: row.get(2)?,
+                })
+            },
+        );
+
+        match result {
+            Ok(backup) => Ok(Some(backup)),
+            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+            Err(e) => Err(AppError::Database(e.to_string())),
+        }
+    }
+
+    /// 删除 Live 配置备份
+    pub async fn delete_live_backup(&self, app_type: &str) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+
+        conn.execute(
+            "DELETE FROM proxy_live_backup WHERE app_type = ?1",
+            rusqlite::params![app_type],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        log::info!("已删除 {app_type} Live 配置备份");
+        Ok(())
+    }
+
+    /// 删除所有 Live 配置备份
+    pub async fn delete_all_live_backups(&self) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+
+        conn.execute("DELETE FROM proxy_live_backup", [])
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        log::info!("已删除所有 Live 配置备份");
+        Ok(())
+    }
 }
@@ -360,6 +360,23 @@ impl Database {
        )
        .map_err(|e| AppError::Database(e.to_string()))?;

+        // 16. Proxy Live Backup 表 (Live 配置备份)
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS proxy_live_backup (
+                app_type TEXT PRIMARY KEY,
+                original_config TEXT NOT NULL,
+                backed_up_at TEXT NOT NULL
+            )",
+            [],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        // 尝试添加 live_takeover_active 列到 proxy_config 表
+        let _ = conn.execute(
+            "ALTER TABLE proxy_config ADD COLUMN live_takeover_active INTEGER NOT NULL DEFAULT 0",
+            [],
+        );
+
        Ok(())
    }

@@ -648,11 +648,15 @@ pub fn run() {
            commands::get_auto_launch_status,
            // Proxy server management
            commands::start_proxy_server,
+            commands::start_proxy_with_takeover,
            commands::stop_proxy_server,
+            commands::stop_proxy_with_restore,
            commands::get_proxy_status,
            commands::get_proxy_config,
            commands::update_proxy_config,
            commands::is_proxy_running,
+            commands::is_live_takeover_active,
+            commands::switch_proxy_provider,
            // Proxy failover commands
            commands::get_proxy_targets,
            commands::set_proxy_target,
@@ -148,17 +148,24 @@ impl ProxyServer {
            // 健康检查
            .route("/health", get(handlers::health_check))
            .route("/status", get(handlers::get_status))
-            // Claude API
+            // Claude API (支持带前缀和不带前缀两种格式)
            .route("/v1/messages", post(handlers::handle_messages))
-            // OpenAI Chat Completions API (Codex CLI)
+            .route("/claude/v1/messages", post(handlers::handle_messages))
+            // OpenAI Chat Completions API (Codex CLI，支持带前缀和不带前缀)
            .route(
                "/v1/chat/completions",
                post(handlers::handle_chat_completions),
            )
-            // OpenAI Responses API (Codex CLI)
+            .route(
+                "/codex/v1/chat/completions",
+                post(handlers::handle_chat_completions),
+            )
+            // OpenAI Responses API (Codex CLI，支持带前缀和不带前缀)
            .route("/v1/responses", post(handlers::handle_responses))
-            // Gemini API
+            .route("/codex/v1/responses", post(handlers::handle_responses))
+            // Gemini API (支持带前缀和不带前缀)
            .route("/v1beta/*path", post(handlers::handle_gemini))
+            .route("/gemini/v1beta/*path", post(handlers::handle_gemini))
            .layer(cors)
            .with_state(self.state.clone())
    }
@@ -15,6 +15,9 @@ pub struct ProxyConfig {
    pub request_timeout: u64,
    /// 是否启用日志
    pub enable_logging: bool,
+    /// 是否正在接管 Live 配置
+    #[serde(default)]
+    pub live_takeover_active: bool,
 }

 impl Default for ProxyConfig {
@@ -26,6 +29,7 @@ impl Default for ProxyConfig {
            max_retries: 3,
            request_timeout: 300,
            enable_logging: true,
+            live_takeover_active: false,
        }
    }
 }
@@ -117,3 +121,14 @@ pub struct ProxyUsageRecord {
    pub error: Option<String>,
    pub timestamp: String,
 }
+
+/// Live 配置备份记录
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LiveBackup {
+    /// 应用类型 (claude/codex/gemini)
+    pub app_type: String,
+    /// 原始配置 JSON
+    pub original_config: String,
+    /// 备份时间
+    pub backed_up_at: String,
+}
@@ -173,14 +173,70 @@ impl ProviderService {
    ///
    /// Switch flow:
    /// 1. Validate target provider exists
-    /// 2. **Backfill mechanism**: Backfill current live config to current provider, protect user manual modifications
-    /// 3. Update local settings current_provider_xxx (device-level)
-    /// 4. Update database is_current (as default for new devices)
-    /// 5. Write target provider config to live files
-    /// 6. Sync MCP configuration
+    /// 2. Check if proxy takeover mode is active AND proxy server is running
+    /// 3. If takeover mode active: hot-switch proxy target only (no Live config write)
+    /// 4. If normal mode:
+    ///    a. **Backfill mechanism**: Backfill current live config to current provider
+    ///    b. Update local settings current_provider_xxx (device-level)
+    ///    c. Update database is_current (as default for new devices)
+    ///    d. Write target provider config to live files
+    ///    e. Sync MCP configuration
    pub fn switch(state: &AppState, app_type: AppType, id: &str) -> Result<(), AppError> {
        // Check if provider exists
        let providers = state.db.get_all_providers(app_type.as_str())?;
+        let _provider = providers
+            .get(id)
+            .ok_or_else(|| AppError::Message(format!("供应商 {id} 不存在")))?;
+
+        // Check if proxy takeover mode is active AND proxy server is actually running
+        // Both conditions must be true to use hot-switch mode
+        // Use blocking wait since this is a sync function
+        let is_takeover_flag =
+            futures::executor::block_on(state.db.is_live_takeover_active()).unwrap_or(false);
+        let is_proxy_running = futures::executor::block_on(state.proxy_service.is_running());
+
+        // Hot-switch only when BOTH: takeover flag is set AND proxy server is actually running
+        let should_hot_switch = is_takeover_flag && is_proxy_running;
+
+        if should_hot_switch {
+            // Proxy takeover mode: hot-switch only, don't write Live config
+            log::info!(
+                "代理接管模式：热切换 {} 的目标供应商为 {}",
+                app_type.as_str(),
+                id
+            );
+
+            // Update database is_current (proxy server reads this)
+            state.db.set_current_provider(app_type.as_str(), id)?;
+
+            // Update local settings for consistency
+            crate::settings::set_current_provider(&app_type, Some(id))?;
+
+            // Note: No Live config write, no MCP sync
+            // The proxy server will route requests to the new provider
+            return Ok(());
+        }
+
+        // Normal mode: full switch with Live config write
+        // Also clear stale takeover flag if proxy is not running but flag was set
+        if is_takeover_flag && !is_proxy_running {
+            log::warn!(
+                "检测到代理接管标志残留（代理已停止），清除标志并执行正常切换"
+            );
+            // Clear stale takeover flag
+            let _ = futures::executor::block_on(state.db.set_live_takeover_active(false));
+        }
+
+        Self::switch_normal(state, app_type, id, &providers)
+    }
+
+    /// Normal switch flow (non-proxy mode)
+    fn switch_normal(
+        state: &AppState,
+        app_type: AppType,
+        id: &str,
+        providers: &indexmap::IndexMap<String, Provider>,
+    ) -> Result<(), AppError> {
        let provider = providers
            .get(id)
            .ok_or_else(|| AppError::Message(format!("供应商 {id} 不存在")))?;
@@ -2,9 +2,13 @@
 //!
 //! 提供代理服务器的启动、停止和配置管理

+use crate::app_config::AppType;
+use crate::config::{get_claude_settings_path, read_json_file, write_json_file};
 use crate::database::Database;
 use crate::proxy::server::ProxyServer;
 use crate::proxy::types::*;
+use serde_json::{json, Value};
+use std::str::FromStr;
 use std::sync::Arc;
 use tokio::sync::RwLock;

@@ -59,6 +63,66 @@ impl ProxyService {
        Ok(info)
    }

+    /// 启动代理服务器（带 Live 配置接管）
+    pub async fn start_with_takeover(&self) -> Result<ProxyServerInfo, String> {
+        // 1. 自动将各应用当前选中的供应商设置为代理目标
+        self.setup_proxy_targets().await?;
+
+        // 2. 备份各应用的 Live 配置
+        self.backup_live_configs().await?;
+
+        // 3. 接管各应用的 Live 配置（写入代理地址）
+        self.takeover_live_configs().await?;
+
+        // 4. 设置接管状态
+        self.db
+            .set_live_takeover_active(true)
+            .await
+            .map_err(|e| format!("设置接管状态失败: {e}"))?;
+
+        // 5. 启动代理服务器
+        match self.start().await {
+            Ok(info) => Ok(info),
+            Err(e) => {
+                // 启动失败，恢复原始配置
+                log::error!("代理启动失败，尝试恢复原始配置: {e}");
+                let _ = self.restore_live_configs().await;
+                let _ = self.db.set_live_takeover_active(false).await;
+                Err(e)
+            }
+        }
+    }
+
+    /// 自动设置代理目标：将各应用当前选中的供应商设置为代理目标
+    async fn setup_proxy_targets(&self) -> Result<(), String> {
+        let app_types = ["claude", "codex", "gemini"];
+
+        for app_type in app_types {
+            // 获取当前选中的供应商
+            if let Ok(Some(provider_id)) = self.db.get_current_provider(app_type) {
+                // 设置为代理目标
+                if let Err(e) = self.db.set_proxy_target(&provider_id, app_type, true).await {
+                    log::warn!(
+                        "设置 {} 的代理目标 {} 失败: {}",
+                        app_type,
+                        provider_id,
+                        e
+                    );
+                } else {
+                    log::info!(
+                        "已将 {} 的当前供应商 {} 设置为代理目标",
+                        app_type,
+                        provider_id
+                    );
+                }
+            } else {
+                log::debug!("{} 没有当前供应商，跳过代理目标设置", app_type);
+            }
+        }
+
+        Ok(())
+    }
+
    /// 停止代理服务器
    pub async fn stop(&self) -> Result<(), String> {
        if let Some(server) = self.server.write().await.take() {
@@ -73,6 +137,259 @@ impl ProxyService {
        }
    }

+    /// 停止代理服务器（恢复 Live 配置）
+    pub async fn stop_with_restore(&self) -> Result<(), String> {
+        // 1. 停止代理服务器
+        self.stop().await?;
+
+        // 2. 恢复原始 Live 配置
+        self.restore_live_configs().await?;
+
+        // 3. 清除接管状态
+        self.db
+            .set_live_takeover_active(false)
+            .await
+            .map_err(|e| format!("清除接管状态失败: {e}"))?;
+
+        // 4. 删除备份
+        self.db
+            .delete_all_live_backups()
+            .await
+            .map_err(|e| format!("删除备份失败: {e}"))?;
+
+        log::info!("代理已停止，Live 配置已恢复");
+        Ok(())
+    }
+
+    /// 备份各应用的 Live 配置
+    async fn backup_live_configs(&self) -> Result<(), String> {
+        // Claude
+        if let Ok(config) = self.read_claude_live() {
+            let json_str = serde_json::to_string(&config)
+                .map_err(|e| format!("序列化 Claude 配置失败: {e}"))?;
+            self.db
+                .save_live_backup("claude", &json_str)
+                .await
+                .map_err(|e| format!("备份 Claude 配置失败: {e}"))?;
+        }
+
+        // Codex
+        if let Ok(config) = self.read_codex_live() {
+            let json_str = serde_json::to_string(&config)
+                .map_err(|e| format!("序列化 Codex 配置失败: {e}"))?;
+            self.db
+                .save_live_backup("codex", &json_str)
+                .await
+                .map_err(|e| format!("备份 Codex 配置失败: {e}"))?;
+        }
+
+        // Gemini
+        if let Ok(config) = self.read_gemini_live() {
+            let json_str = serde_json::to_string(&config)
+                .map_err(|e| format!("序列化 Gemini 配置失败: {e}"))?;
+            self.db
+                .save_live_backup("gemini", &json_str)
+                .await
+                .map_err(|e| format!("备份 Gemini 配置失败: {e}"))?;
+        }
+
+        log::info!("已备份所有应用的 Live 配置");
+        Ok(())
+    }
+
+    /// 接管各应用的 Live 配置（写入代理地址）
+    ///
+    /// 代理服务器的路由已经根据 API 端点自动区分应用类型：
+    /// - `/v1/messages` → Claude
+    /// - `/v1/chat/completions`, `/v1/responses` → Codex
+    /// - `/v1beta/*` → Gemini
+    ///
+    /// 因此不需要在 URL 中添加应用前缀。
+    async fn takeover_live_configs(&self) -> Result<(), String> {
+        let config = self
+            .db
+            .get_proxy_config()
+            .await
+            .map_err(|e| format!("获取代理配置失败: {e}"))?;
+
+        let proxy_url = format!("http://{}:{}", config.listen_address, config.listen_port);
+
+        // Claude: 修改 ANTHROPIC_BASE_URL
+        if let Ok(mut live_config) = self.read_claude_live() {
+            if let Some(env) = live_config.get_mut("env").and_then(|v| v.as_object_mut()) {
+                env.insert("ANTHROPIC_BASE_URL".to_string(), json!(&proxy_url));
+            } else {
+                live_config["env"] = json!({
+                    "ANTHROPIC_BASE_URL": &proxy_url
+                });
+            }
+            self.write_claude_live(&live_config)?;
+            log::info!("Claude Live 配置已接管，代理地址: {}", proxy_url);
+        }
+
+        // Codex: 修改 OPENAI_BASE_URL
+        if let Ok(mut live_config) = self.read_codex_live() {
+            if let Some(auth) = live_config.get_mut("auth").and_then(|v| v.as_object_mut()) {
+                auth.insert("OPENAI_BASE_URL".to_string(), json!(&proxy_url));
+            }
+            self.write_codex_live(&live_config)?;
+            log::info!("Codex Live 配置已接管，代理地址: {}", proxy_url);
+        }
+
+        // Gemini: 修改 GEMINI_API_BASE
+        if let Ok(mut live_config) = self.read_gemini_live() {
+            if let Some(env) = live_config.get_mut("env").and_then(|v| v.as_object_mut()) {
+                env.insert("GEMINI_API_BASE".to_string(), json!(&proxy_url));
+            } else {
+                live_config["env"] = json!({
+                    "GEMINI_API_BASE": &proxy_url
+                });
+            }
+            self.write_gemini_live(&live_config)?;
+            log::info!("Gemini Live 配置已接管，代理地址: {}", proxy_url);
+        }
+
+        Ok(())
+    }
+
+    /// 恢复原始 Live 配置
+    async fn restore_live_configs(&self) -> Result<(), String> {
+        // Claude
+        if let Ok(Some(backup)) = self.db.get_live_backup("claude").await {
+            let config: Value = serde_json::from_str(&backup.original_config)
+                .map_err(|e| format!("解析 Claude 备份失败: {e}"))?;
+            self.write_claude_live(&config)?;
+            log::info!("Claude Live 配置已恢复");
+        }
+
+        // Codex
+        if let Ok(Some(backup)) = self.db.get_live_backup("codex").await {
+            let config: Value = serde_json::from_str(&backup.original_config)
+                .map_err(|e| format!("解析 Codex 备份失败: {e}"))?;
+            self.write_codex_live(&config)?;
+            log::info!("Codex Live 配置已恢复");
+        }
+
+        // Gemini
+        if let Ok(Some(backup)) = self.db.get_live_backup("gemini").await {
+            let config: Value = serde_json::from_str(&backup.original_config)
+                .map_err(|e| format!("解析 Gemini 备份失败: {e}"))?;
+            self.write_gemini_live(&config)?;
+            log::info!("Gemini Live 配置已恢复");
+        }
+
+        Ok(())
+    }
+
+    /// 检查是否处于 Live 接管模式
+    pub async fn is_takeover_active(&self) -> Result<bool, String> {
+        self.db
+            .is_live_takeover_active()
+            .await
+            .map_err(|e| format!("检查接管状态失败: {e}"))
+    }
+
+    /// 代理模式下切换供应商（热切换，不写 Live）
+    pub async fn switch_proxy_target(
+        &self,
+        app_type: &str,
+        provider_id: &str,
+    ) -> Result<(), String> {
+        // 更新数据库中的 is_current 标记
+        let app_type_enum = AppType::from_str(app_type)
+            .map_err(|_| format!("无效的应用类型: {app_type}"))?;
+
+        self.db
+            .set_current_provider(app_type_enum.as_str(), provider_id)
+            .map_err(|e| format!("更新当前供应商失败: {e}"))?;
+
+        log::info!(
+            "代理模式：已切换 {} 的目标供应商为 {}",
+            app_type,
+            provider_id
+        );
+        Ok(())
+    }
+
+    // ==================== Live 配置读写辅助方法 ====================
+
+    fn read_claude_live(&self) -> Result<Value, String> {
+        let path = get_claude_settings_path();
+        if !path.exists() {
+            return Err("Claude 配置文件不存在".to_string());
+        }
+        read_json_file(&path).map_err(|e| format!("读取 Claude 配置失败: {e}"))
+    }
+
+    fn write_claude_live(&self, config: &Value) -> Result<(), String> {
+        let path = get_claude_settings_path();
+        write_json_file(&path, config).map_err(|e| format!("写入 Claude 配置失败: {e}"))
+    }
+
+    fn read_codex_live(&self) -> Result<Value, String> {
+        use crate::codex_config::{get_codex_auth_path, get_codex_config_path};
+
+        let auth_path = get_codex_auth_path();
+        if !auth_path.exists() {
+            return Err("Codex auth.json 不存在".to_string());
+        }
+
+        let auth: Value =
+            read_json_file(&auth_path).map_err(|e| format!("读取 Codex auth 失败: {e}"))?;
+
+        let config_path = get_codex_config_path();
+        let config_str = if config_path.exists() {
+            std::fs::read_to_string(&config_path)
+                .map_err(|e| format!("读取 Codex config 失败: {e}"))?
+        } else {
+            String::new()
+        };
+
+        Ok(json!({
+            "auth": auth,
+            "config": config_str
+        }))
+    }
+
+    fn write_codex_live(&self, config: &Value) -> Result<(), String> {
+        use crate::codex_config::{get_codex_auth_path, get_codex_config_path};
+
+        if let Some(auth) = config.get("auth") {
+            let auth_path = get_codex_auth_path();
+            write_json_file(&auth_path, auth).map_err(|e| format!("写入 Codex auth 失败: {e}"))?;
+        }
+
+        if let Some(config_str) = config.get("config").and_then(|v| v.as_str()) {
+            let config_path = get_codex_config_path();
+            std::fs::write(&config_path, config_str)
+                .map_err(|e| format!("写入 Codex config 失败: {e}"))?;
+        }
+
+        Ok(())
+    }
+
+    fn read_gemini_live(&self) -> Result<Value, String> {
+        use crate::gemini_config::{env_to_json, get_gemini_env_path, read_gemini_env};
+
+        let env_path = get_gemini_env_path();
+        if !env_path.exists() {
+            return Err("Gemini .env 文件不存在".to_string());
+        }
+
+        let env_map = read_gemini_env().map_err(|e| format!("读取 Gemini env 失败: {e}"))?;
+        Ok(env_to_json(&env_map))
+    }
+
+    fn write_gemini_live(&self, config: &Value) -> Result<(), String> {
+        use crate::gemini_config::{json_to_env, write_gemini_env_atomic};
+
+        let env_map = json_to_env(config).map_err(|e| format!("转换 Gemini 配置失败: {e}"))?;
+        write_gemini_env_atomic(&env_map).map_err(|e| format!("写入 Gemini env 失败: {e}"))?;
+        Ok(())
+    }
+
+    // ==================== 原有方法 ====================
+
    /// 获取服务器状态
    pub async fn get_status(&self) -> Result<ProxyStatus, String> {
        if let Some(server) = self.server.read().await.as_ref() {
@@ -103,9 +420,10 @@ impl ProxyService {
            .await
            .map_err(|e| format!("获取代理配置失败: {e}"))?;

-        // 保存到数据库（保持 enabled 状态不变）
+        // 保存到数据库（保持 enabled 和 live_takeover_active 状态不变）
        let mut new_config = config.clone();
        new_config.enabled = previous.enabled;
+        new_config.live_takeover_active = previous.live_takeover_active;

        self.db
            .update_proxy_config(new_config.clone())
@@ -525,7 +525,10 @@ fn validate_request_url(request_url: &str, base_url: &str) -> Result<(), AppErro

    // 检查端口是否匹配（考虑默认端口）
    // 使用 port_or_known_default() 会自动处理默认端口（http->80, https->443）
-    match (parsed_request.port_or_known_default(), parsed_base.port_or_known_default()) {
+    match (
+        parsed_request.port_or_known_default(),
+        parsed_base.port_or_known_default(),
+    ) {
        (Some(request_port), Some(base_port)) if request_port == base_port => {
            // 端口匹配，继续执行
        }
@@ -534,13 +537,11 @@ fn validate_request_url(request_url: &str, base_url: &str) -> Result<(), AppErro
                "usage_script.request_port_mismatch",
                format!(
                    "请求端口 {} 必须与 base_url 端口 {} 匹配",
-                    request_port,
-                    base_port
+                    request_port, base_port
                ),
                format!(
                    "Request port {} must match base_url port {}",
-                    request_port,
-                    base_port
+                    request_port, base_port
                ),
            ));
        }
@@ -774,22 +775,25 @@ mod tests {
    fn test_https_bypass_prevention() {
        // 非本地域名的 HTTP 应该被拒绝
        let result = validate_base_url("http://127.0.0.1.evil.com/api");
-        assert!(result.is_err(), "Should reject HTTP for non-localhost domains");
+        assert!(
+            result.is_err(),
+            "Should reject HTTP for non-localhost domains"
+        );
    }

    #[test]
    fn test_edge_cases() {
        // 边界情况测试
-        assert!(is_private_ip("172.16.0.0"));   // RFC1918起始
+        assert!(is_private_ip("172.16.0.0")); // RFC1918起始
        assert!(is_private_ip("172.31.255.255")); // RFC1918结束
-        assert!(is_private_ip("10.0.0.0"));      // 10.0.0.0/8起始
+        assert!(is_private_ip("10.0.0.0")); // 10.0.0.0/8起始
        assert!(is_private_ip("10.255.255.255")); // 10.0.0.0/8结束
-        assert!(is_private_ip("192.168.0.0"));   // 192.168.0.0/16起始
+        assert!(is_private_ip("192.168.0.0")); // 192.168.0.0/16起始
        assert!(is_private_ip("192.168.255.255")); // 192.168.0.0/16结束

        // 紧邻RFC1918的公网地址 - 应该返回false
        assert!(!is_private_ip("172.15.255.255")); // 172.16.0.0的前一个
-        assert!(!is_private_ip("172.32.0.0"));    // 172.31.255.255的后一个
+        assert!(!is_private_ip("172.32.0.0")); // 172.31.255.255的后一个
    }

    #[test]
@@ -815,27 +819,57 @@ mod tests {
        // 测试用例：(base_url, request_url, should_match)
        let test_cases = vec![
            // HTTPS默认端口测试
-            ("https://api.example.com", "https://api.example.com/v1/test", true),
-            ("https://api.example.com", "https://api.example.com:443/v1/test", true),
-            ("https://api.example.com:443", "https://api.example.com/v1/test", true),
-            ("https://api.example.com:443", "https://api.example.com:443/v1/test", true),
-
+            (
+                "https://api.example.com",
+                "https://api.example.com/v1/test",
+                true,
+            ),
+            (
+                "https://api.example.com",
+                "https://api.example.com:443/v1/test",
+                true,
+            ),
+            (
+                "https://api.example.com:443",
+                "https://api.example.com/v1/test",
+                true,
+            ),
+            (
+                "https://api.example.com:443",
+                "https://api.example.com:443/v1/test",
+                true,
+            ),
            // 端口不匹配测试
-            ("https://api.example.com", "https://api.example.com:8443/v1/test", false),
-            ("https://api.example.com:443", "https://api.example.com:8443/v1/test", false),
+            (
+                "https://api.example.com",
+                "https://api.example.com:8443/v1/test",
+                false,
+            ),
+            (
+                "https://api.example.com:443",
+                "https://api.example.com:8443/v1/test",
+                false,
+            ),
        ];

        for (base_url, request_url, should_match) in test_cases {
            let result = validate_request_url(request_url, base_url);

            if should_match {
-                assert!(result.is_ok(),
+                assert!(
+                    result.is_ok(),
                    "应该匹配的URL被拒绝: base_url={}, request_url={}, error={}",
-                    base_url, request_url, result.unwrap_err());
+                    base_url,
+                    request_url,
+                    result.unwrap_err()
+                );
            } else {
-                assert!(result.is_err(),
+                assert!(
+                    result.is_err(),
                    "应该不匹配的URL被允许: base_url={}, request_url={}",
-                    base_url, request_url);
+                    base_url,
+                    request_url
+                );
            }
        }
    }
@@ -33,6 +33,7 @@ import { ConfirmDialog } from "@/components/ConfirmDialog";
 import { SettingsPage } from "@/components/settings/SettingsPage";
 import { UpdateBadge } from "@/components/UpdateBadge";
 import { EnvWarningBanner } from "@/components/env/EnvWarningBanner";
+import { ProxyToggle } from "@/components/proxy/ProxyToggle";
 import UsageScriptModal from "@/components/UsageScriptModal";
 import UnifiedMcpPanel from "@/components/mcp/UnifiedMcpPanel";
 import PromptPanel from "@/components/prompts/PromptPanel";
@@ -63,7 +64,7 @@ function App() {
    "bg-orange-500 hover:bg-orange-600 dark:bg-orange-500 dark:hover:bg-orange-600 text-white shadow-lg shadow-orange-500/30 dark:shadow-orange-500/40 rounded-full w-8 h-8";

  // 获取代理服务状态
-  const { isRunning: isProxyRunning } = useProxyStatus();
+  const { isRunning: isProxyRunning, isTakeoverActive } = useProxyStatus();

  // 获取供应商列表，当代理服务运行时自动刷新
  const { data, isLoading, refetch } = useProvidersQuery(activeApp, {
@@ -321,6 +322,7 @@ function App() {
                  appId={activeApp}
                  isLoading={isLoading}
                  isProxyRunning={isProxyRunning}
+                  isProxyTakeover={isProxyRunning && isTakeoverActive}
                  onSwitch={switchProvider}
                  onEdit={setEditingProvider}
                  onDelete={setConfirmDelete}
@@ -482,6 +484,8 @@ function App() {
            )}
            {currentView === "providers" && (
              <>
+                <ProxyToggle />
+
                <AppSwitcher activeApp={activeApp} onSwitch={setActiveApp} />

                <div className="bg-muted p-1 rounded-xl flex items-center gap-1">
@@ -40,6 +40,7 @@ interface ProviderCardProps {
  onTest?: (provider: Provider) => void;
  isTesting?: boolean;
  isProxyRunning: boolean;
+  isProxyTakeover?: boolean; // 代理接管模式（Live配置已被接管，切换为热切换）
  proxyPriority?: number; // 代理目标的实际优先级 (1, 2, 3...)
  allProviders?: Provider[]; // 所有供应商列表，用于计算开启后的优先级
  dragHandleProps?: DragHandleProps;
@@ -93,6 +94,7 @@ export function ProviderCard({
  onTest,
  isTesting,
  isProxyRunning,
+  isProxyTakeover = false,
  proxyPriority,
  allProviders,
  dragHandleProps,
@@ -231,7 +233,12 @@ export function ProviderCard({
      className={cn(
        "relative overflow-hidden rounded-xl border border-border p-4 transition-all duration-300",
        "bg-card text-card-foreground group hover:border-border-active",
-        isCurrent ? "border-primary/50 shadow-sm" : "hover:shadow-sm",
+        // 代理接管模式下当前供应商使用绿色边框
+        isProxyTakeover && isCurrent
+          ? "border-emerald-500/60 shadow-sm shadow-emerald-500/10"
+          : isCurrent
+            ? "border-primary/50 shadow-sm"
+            : "hover:shadow-sm",
        dragHandleProps?.isDragging &&
          "cursor-grabbing border-primary shadow-lg scale-105 z-10",
      )}
@@ -27,6 +27,7 @@ interface ProviderListProps {
  onCreate?: () => void;
  isLoading?: boolean;
  isProxyRunning?: boolean; // 代理服务运行状态
+  isProxyTakeover?: boolean; // 代理接管模式（Live配置已被接管）
 }

 export function ProviderList({
@@ -42,6 +43,7 @@ export function ProviderList({
  onCreate,
  isLoading = false,
  isProxyRunning = false, // 默认值为 false
+  isProxyTakeover = false, // 默认值为 false
 }: ProviderListProps) {
  const { sortedProviders, sensors, handleDragEnd } = useDragSort(
    providers,
@@ -122,6 +124,7 @@ export function ProviderList({
              onTest={handleTest}
              isTesting={isTesting(provider.id)}
              isProxyRunning={isProxyRunning}
+              isProxyTakeover={isProxyTakeover}
              proxyPriority={proxyPriorityMap.get(provider.id)}
              allProviders={sortedProviders}
            />
@@ -145,6 +148,7 @@ interface SortableProviderCardProps {
  onTest: (provider: Provider) => void;
  isTesting: boolean;
  isProxyRunning: boolean;
+  isProxyTakeover: boolean;
  proxyPriority?: number; // 代理目标的实际优先级 (1, 2, 3...)
  allProviders?: Provider[]; // 所有供应商列表
 }
@@ -162,6 +166,7 @@ function SortableProviderCard({
  onTest,
  isTesting,
  isProxyRunning,
+  isProxyTakeover,
  proxyPriority,
  allProviders,
 }: SortableProviderCardProps) {
@@ -196,6 +201,7 @@ function SortableProviderCard({
        onTest={onTest}
        isTesting={isTesting}
        isProxyRunning={isProxyRunning}
+        isProxyTakeover={isProxyTakeover}
        proxyPriority={proxyPriority}
        allProviders={allProviders}
        dragHandleProps={{
@@ -18,8 +18,11 @@ export interface AutoFailoverConfigPanelProps {

 export function AutoFailoverConfigPanel({
  enabled,
-  onEnabledChange,
+  onEnabledChange: _onEnabledChange,
 }: AutoFailoverConfigPanelProps) {
+  // Note: onEnabledChange is currently unused but kept in the interface
+  // for potential future use by parent components
+  void _onEnabledChange;
  const { t } = useTranslation();
  const { data: config, isLoading, error } = useCircuitBreakerConfig();
  const updateConfig = useUpdateCircuitBreakerConfig();
@@ -262,7 +265,7 @@ export function AutoFailoverConfigPanel({
          </Button>
          <Button
            onClick={handleSave}
-            disabled={updateConfig.isPending || !formData.enabled}
+            disabled={updateConfig.isPending || !enabled}
          >
            {updateConfig.isPending ? (
              <>
@@ -0,0 +1,82 @@
+/**
+ * 代理模式切换开关组件
+ *
+ * 放置在主界面头部，用于一键启用/关闭代理模式
+ * 启用时自动接管 Live 配置，关闭时恢复原始配置
+ */
+
+import { Radio, Loader2 } from "lucide-react";
+import { Switch } from "@/components/ui/switch";
+import { useProxyStatus } from "@/hooks/useProxyStatus";
+import { cn } from "@/lib/utils";
+
+interface ProxyToggleProps {
+  className?: string;
+}
+
+export function ProxyToggle({ className }: ProxyToggleProps) {
+  const {
+    isRunning,
+    isTakeoverActive,
+    startWithTakeover,
+    stopWithRestore,
+    isPending,
+    status,
+  } = useProxyStatus();
+
+  const handleToggle = async (checked: boolean) => {
+    if (checked) {
+      await startWithTakeover();
+    } else {
+      await stopWithRestore();
+    }
+  };
+
+  const isActive = isRunning && isTakeoverActive;
+
+  const tooltipText = isActive
+    ? `代理模式运行中 - ${status?.address}:${status?.port}\n切换供应商为热切换`
+    : "开启代理模式\n启用后自动接管 Live 配置";
+
+  return (
+    <div
+      className={cn(
+        "flex items-center gap-2 px-3 py-1.5 rounded-lg transition-all cursor-default",
+        isActive
+          ? "bg-emerald-500/10 border border-emerald-500/30"
+          : "bg-muted/50 hover:bg-muted",
+        className,
+      )}
+      title={tooltipText}
+    >
+      {isPending ? (
+        <Loader2 className="h-4 w-4 animate-spin text-muted-foreground" />
+      ) : (
+        <Radio
+          className={cn(
+            "h-4 w-4 transition-colors",
+            isActive
+              ? "text-emerald-500 animate-pulse"
+              : "text-muted-foreground",
+          )}
+        />
+      )}
+      <span
+        className={cn(
+          "text-sm font-medium transition-colors select-none",
+          isActive
+            ? "text-emerald-600 dark:text-emerald-400"
+            : "text-muted-foreground",
+        )}
+      >
+        Proxy
+      </span>
+      <Switch
+        checked={isActive}
+        onCheckedChange={handleToggle}
+        disabled={isPending}
+        className="ml-1"
+      />
+    </div>
+  );
+}
@@ -174,8 +174,8 @@ export function SettingsPage({

  const {
    isRunning,
-    start: startProxy,
-    stop: stopProxy,
+    startWithTakeover: startProxy,
+    stopWithRestore: stopProxy,
    isPending: isProxyPending,
  } = useProxyStatus();
  const [failoverEnabled, setFailoverEnabled] = useState(true);
@@ -5,13 +5,16 @@
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { invoke } from "@tauri-apps/api/core";
 import { toast } from "sonner";
+import { useTranslation } from "react-i18next";
 import type { ProxyStatus, ProxyServerInfo } from "@/types/proxy";
+import { extractErrorMessage } from "@/utils/errorUtils";

 /**
 * 代理服务状态管理
 */
 export function useProxyStatus() {
  const queryClient = useQueryClient();
+  const { t } = useTranslation();

  // 查询状态（自动轮询）
  const { data: status, isLoading } = useQuery({
@@ -23,7 +26,13 @@ export function useProxyStatus() {
    placeholderData: (previousData) => previousData,
  });

-  // 启动服务器
+  // 查询接管状态
+  const { data: isTakeoverActive } = useQuery({
+    queryKey: ["proxyTakeoverActive"],
+    queryFn: () => invoke<boolean>("is_live_takeover_active"),
+  });
+
+  // 启动服务器（普通模式）
  const startMutation = useMutation({
    mutationFn: () => invoke<ProxyServerInfo>("start_proxy_server"),
    onSuccess: (info) => {
@@ -31,11 +40,34 @@ export function useProxyStatus() {
      queryClient.invalidateQueries({ queryKey: ["proxyStatus"] });
    },
    onError: (error: Error) => {
-      toast.error(`启动失败: ${error.message}`);
+      const detail = extractErrorMessage(error) || "未知错误";
+      toast.error(`启动失败: ${detail}`);
    },
  });

-  // 停止服务器
+  // 启动服务器（带 Live 配置接管）
+  const startWithTakeoverMutation = useMutation({
+    mutationFn: () => invoke<ProxyServerInfo>("start_proxy_with_takeover"),
+    onSuccess: (info) => {
+      toast.success(
+        t("proxy.startedWithTakeover", {
+          defaultValue: `代理模式已启用 - ${info.address}:${info.port}`,
+        }),
+      );
+      queryClient.invalidateQueries({ queryKey: ["proxyStatus"] });
+      queryClient.invalidateQueries({ queryKey: ["proxyTakeoverActive"] });
+    },
+    onError: (error: Error) => {
+      const detail = extractErrorMessage(error) || "未知错误";
+      toast.error(
+        t("proxy.startWithTakeoverFailed", {
+          defaultValue: `启动失败: ${detail}`,
+        }),
+      );
+    },
+  });
+
+  // 停止服务器（普通模式）
  const stopMutation = useMutation({
    mutationFn: () => invoke("stop_proxy_server"),
    onSuccess: () => {
@@ -43,7 +75,48 @@ export function useProxyStatus() {
      queryClient.invalidateQueries({ queryKey: ["proxyStatus"] });
    },
    onError: (error: Error) => {
-      toast.error(`停止失败: ${error.message}`);
+      const detail = extractErrorMessage(error) || "未知错误";
+      toast.error(`停止失败: ${detail}`);
+    },
+  });
+
+  // 停止服务器（恢复 Live 配置）
+  const stopWithRestoreMutation = useMutation({
+    mutationFn: () => invoke("stop_proxy_with_restore"),
+    onSuccess: () => {
+      toast.success(
+        t("proxy.stoppedWithRestore", {
+          defaultValue: "代理模式已关闭，配置已恢复",
+        }),
+      );
+      queryClient.invalidateQueries({ queryKey: ["proxyStatus"] });
+      queryClient.invalidateQueries({ queryKey: ["proxyTakeoverActive"] });
+    },
+    onError: (error: Error) => {
+      const detail = extractErrorMessage(error) || "未知错误";
+      toast.error(
+        t("proxy.stopWithRestoreFailed", {
+          defaultValue: `停止失败: ${detail}`,
+        }),
+      );
+    },
+  });
+
+  // 代理模式切换供应商（热切换）
+  const switchProxyProviderMutation = useMutation({
+    mutationFn: ({
+      appType,
+      providerId,
+    }: {
+      appType: string;
+      providerId: string;
+    }) => invoke("switch_proxy_provider", { appType, providerId }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["proxyStatus"] });
+    },
+    onError: (error: Error) => {
+      const detail = extractErrorMessage(error) || "未知错误";
+      toast.error(`切换失败: ${detail}`);
    },
  });

@@ -56,15 +129,43 @@ export function useProxyStatus() {
    }
  };

+  // 检查接管状态
+  const checkTakeoverActive = async () => {
+    try {
+      return await invoke<boolean>("is_live_takeover_active");
+    } catch {
+      return false;
+    }
+  };
+
  return {
    status,
    isLoading,
    isRunning: status?.running || false,
+    isTakeoverActive: isTakeoverActive || false,
+
+    // 普通模式
    start: startMutation.mutateAsync,
    stop: stopMutation.mutateAsync,
+
+    // 接管模式（推荐使用）
+    startWithTakeover: startWithTakeoverMutation.mutateAsync,
+    stopWithRestore: stopWithRestoreMutation.mutateAsync,
+
+    // 代理模式下切换供应商
+    switchProxyProvider: switchProxyProviderMutation.mutateAsync,
+
+    // 状态检查
    checkRunning,
-    isStarting: startMutation.isPending,
-    isStopping: stopMutation.isPending,
-    isPending: startMutation.isPending || stopMutation.isPending,
+    checkTakeoverActive,
+
+    // 加载状态
+    isStarting: startMutation.isPending || startWithTakeoverMutation.isPending,
+    isStopping: stopMutation.isPending || stopWithRestoreMutation.isPending,
+    isPending:
+      startMutation.isPending ||
+      stopMutation.isPending ||
+      startWithTakeoverMutation.isPending ||
+      stopWithRestoreMutation.isPending,
  };
 }
@@ -5,6 +5,7 @@ export interface ProxyConfig {
  max_retries: number;
  request_timeout: number;
  enable_logging: boolean;
+  live_takeover_active?: boolean;
 }

 export interface ProxyStatus {