Merge branch 'refactor/simplify-proxy-logs' into feature/global-proxy

Resolve conflict in skill.rs: keep global HTTP client for proxy support

src-tauri/src/codex_config.rs

@@ -9,13 +9,21 @@ use serde_json::Value;
 use std::fs;
 use std::path::Path;
 
+/// 获取用户主目录，带回退和日志
+fn get_home_dir() -> PathBuf {
+    dirs::home_dir().unwrap_or_else(|| {
+        log::warn!("无法获取用户主目录，回退到当前目录");
+        PathBuf::from(".")
+    })
+}
+
 /// 获取 Codex 配置目录路径
 pub fn get_codex_config_dir() -> PathBuf {
     if let Some(custom) = crate::settings::get_codex_override_dir() {
         return custom;
     }
 
-    dirs::home_dir().expect("无法获取用户主目录").join(".codex")
+    get_home_dir().join(".codex")
 }
 
 /// 获取 Codex auth.json 路径

src-tauri/src/commands/misc.rs

@@ -1,6 +1,8 @@
 #![allow(non_snake_case)]
 
 use crate::init_status::{InitErrorPayload, SkillsMigrationPayload};
+use once_cell::sync::Lazy;
+use regex::Regex;
 use tauri::AppHandle;
 use tauri_plugin_opener::OpenerExt;
 
@@ -139,11 +141,14 @@ async fn fetch_npm_latest_version(client: &reqwest::Client, package: &str) -> Op
     }
 }
 
+/// 预编译的版本号正则表达式
+static VERSION_RE: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"\d+\.\d+\.\d+(-[\w.]+)?").expect("Invalid version regex"));
+
 /// 从版本输出中提取纯版本号
 fn extract_version(raw: &str) -> String {
-    // 匹配 semver 格式: x.y.z 或 x.y.z-xxx
-    let re = regex::Regex::new(r"\d+\.\d+\.\d+(-[\w.]+)?").expect("Invalid version regex pattern");
-    re.find(raw)
+    VERSION_RE
+        .find(raw)
         .map(|m| m.as_str().to_string())
         .unwrap_or_else(|| raw.to_string())
 }

src-tauri/src/config.rs

@@ -5,22 +5,26 @@ use std::path::{Path, PathBuf};
 
 use crate::error::AppError;
 
+/// 获取用户主目录，带回退和日志
+fn get_home_dir() -> PathBuf {
+    dirs::home_dir().unwrap_or_else(|| {
+        log::warn!("无法获取用户主目录，回退到当前目录");
+        PathBuf::from(".")
+    })
+}
+
 /// 获取 Claude Code 配置目录路径
 pub fn get_claude_config_dir() -> PathBuf {
     if let Some(custom) = crate::settings::get_claude_override_dir() {
         return custom;
     }
 
-    dirs::home_dir()
-        .expect("无法获取用户主目录")
-        .join(".claude")
+    get_home_dir().join(".claude")
 }
 
 /// 默认 Claude MCP 配置文件路径 (~/.claude.json)
 pub fn get_default_claude_mcp_path() -> PathBuf {
-    dirs::home_dir()
-        .expect("无法获取用户主目录")
-        .join(".claude.json")
+    get_home_dir().join(".claude.json")
 }
 
 fn derive_mcp_path_from_override(dir: &Path) -> Option<PathBuf> {

src-tauri/src/gemini_config.rs

@@ -5,15 +5,21 @@ use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;
 
+/// 获取用户主目录，带回退和日志
+fn get_home_dir() -> PathBuf {
+    dirs::home_dir().unwrap_or_else(|| {
+        log::warn!("无法获取用户主目录，回退到当前目录");
+        PathBuf::from(".")
+    })
+}
+
 /// 获取 Gemini 配置目录路径（支持设置覆盖）
 pub fn get_gemini_dir() -> PathBuf {
     if let Some(custom) = crate::settings::get_gemini_override_dir() {
         return custom;
     }
 
-    dirs::home_dir()
-        .expect("无法获取用户主目录")
-        .join(".gemini")
+    get_home_dir().join(".gemini")
 }
 
 /// 获取 Gemini .env 文件路径

src-tauri/src/gemini_mcp.rs

@@ -134,6 +134,33 @@ pub fn set_mcp_servers_map(
         obj.remove("homepage");
         obj.remove("docs");
 
+        // Timeout 转换：Claude/Codex 使用 startup_timeout_sec/tool_timeout_sec
+        // Gemini CLI 只支持 timeout（单位 ms）
+        // 默认值：startup=10s, tool=60s
+        const DEFAULT_STARTUP_MS: u64 = 10_000;
+        const DEFAULT_TOOL_MS: u64 = 60_000;
+
+        let extract_timeout =
+            |obj: &mut Map<String, Value>, key: &str, multiplier: u64| -> Option<u64> {
+                obj.remove(key).and_then(|val| {
+                    val.as_u64()
+                        .map(|n| n * multiplier)
+                        .or_else(|| val.as_f64().map(|f| (f * multiplier as f64) as u64))
+                })
+            };
+
+        // 分别收集 startup 和 tool timeout，未设置时使用默认值
+        let startup_ms = extract_timeout(&mut obj, "startup_timeout_sec", 1000)
+            .or_else(|| extract_timeout(&mut obj, "startup_timeout_ms", 1))
+            .unwrap_or(DEFAULT_STARTUP_MS);
+        let tool_ms = extract_timeout(&mut obj, "tool_timeout_sec", 1000)
+            .or_else(|| extract_timeout(&mut obj, "tool_timeout_ms", 1))
+            .unwrap_or(DEFAULT_TOOL_MS);
+
+        // 取最大值作为 Gemini timeout
+        let final_timeout = startup_ms.max(tool_ms);
+        obj.insert("timeout".to_string(), Value::Number(final_timeout.into()));
+
         out.insert(id.clone(), Value::Object(obj));
     }
 

src-tauri/src/proxy/circuit_breaker.rs

@@ -2,6 +2,7 @@
 //!
 //! 实现熔断器模式，用于防止向不健康的供应商发送请求
 
+use super::log_codes::cb as log_cb;
 use serde::{Deserialize, Serialize};
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::Arc;
@@ -126,7 +127,10 @@ impl CircuitBreaker {
                 if let Some(opened_at) = *self.last_opened_at.read().await {
                     if opened_at.elapsed().as_secs() >= config.timeout_seconds {
                         drop(config); // 释放读锁再转换状态
-                        log::info!("[CB-001] 熔断器 Open → HalfOpen (超时恢复)");
+                        log::info!(
+                            "[{}] 熔断器 Open → HalfOpen (超时恢复)",
+                            log_cb::OPEN_TO_HALF_OPEN
+                        );
                         self.transition_to_half_open().await;
                         return true;
                     }
@@ -151,7 +155,10 @@ impl CircuitBreaker {
                 if let Some(opened_at) = *self.last_opened_at.read().await {
                     if opened_at.elapsed().as_secs() >= config.timeout_seconds {
                         drop(config); // 释放读锁再转换状态
-                        log::info!("熔断器 Open → HalfOpen (超时恢复)");
+                        log::info!(
+                            "[{}] 熔断器 Open → HalfOpen (超时恢复)",
+                            log_cb::OPEN_TO_HALF_OPEN
+                        );
                         self.transition_to_half_open().await;
 
                         // 转换后按当前状态决定是否需要获取 HalfOpen 探测名额
@@ -197,7 +204,10 @@ impl CircuitBreaker {
 
             if successes >= config.success_threshold {
                 drop(config); // 释放读锁再转换状态
-                log::info!("[CB-002] 熔断器 HalfOpen → Closed (恢复正常)");
+                log::info!(
+                    "[{}] 熔断器 HalfOpen → Closed (恢复正常)",
+                    log_cb::HALF_OPEN_TO_CLOSED
+                );
                 self.transition_to_closed().await;
             }
         }
@@ -224,14 +234,20 @@ impl CircuitBreaker {
         match state {
             CircuitState::HalfOpen => {
                 // HalfOpen 状态下失败，立即转为 Open
-                log::warn!("[CB-003] 熔断器 HalfOpen 探测失败 → Open");
+                log::warn!(
+                    "[{}] 熔断器 HalfOpen 探测失败 → Open",
+                    log_cb::HALF_OPEN_PROBE_FAILED
+                );
                 drop(config);
                 self.transition_to_open().await;
             }
             CircuitState::Closed => {
                 // 检查连续失败次数
                 if failures >= config.failure_threshold {
-                    log::warn!("[CB-004] 熔断器触发: 连续失败 {failures} 次 → Open");
+                    log::warn!(
+                        "[{}] 熔断器触发: 连续失败 {failures} 次 → Open",
+                        log_cb::TRIGGERED_FAILURES
+                    );
                     drop(config); // 释放读锁再转换状态
                     self.transition_to_open().await;
                 } else {
@@ -244,7 +260,8 @@ impl CircuitBreaker {
 
                         if error_rate >= config.error_rate_threshold {
                             log::warn!(
-                                "[CB-005] 熔断器触发: 错误率 {:.1}% → Open",
+                                "[{}] 熔断器触发: 错误率 {:.1}% → Open",
+                                log_cb::TRIGGERED_ERROR_RATE,
                                 error_rate * 100.0
                             );
                             drop(config); // 释放读锁再转换状态
@@ -278,7 +295,7 @@ impl CircuitBreaker {
     /// 重置熔断器（手动恢复）
     #[allow(dead_code)]
     pub async fn reset(&self) {
-        log::info!("[CB-006] 熔断器手动重置 → Closed");
+        log::info!("[{}] 熔断器手动重置 → Closed", log_cb::MANUAL_RESET);
         self.transition_to_closed().await;
     }
 

src-tauri/src/proxy/error.rs

@@ -17,6 +17,12 @@ pub enum ProxyError {
     #[error("地址绑定失败: {0}")]
     BindFailed(String),
 
+    #[error("停止超时")]
+    StopTimeout,
+
+    #[error("停止失败: {0}")]
+    StopFailed(String),
+
     #[error("请求转发失败: {0}")]
     ForwardFailed(String),
 
@@ -113,6 +119,12 @@ impl IntoResponse for ProxyError {
                     ProxyError::BindFailed(_) => {
                         (StatusCode::INTERNAL_SERVER_ERROR, self.to_string())
                     }
+                    ProxyError::StopTimeout => {
+                        (StatusCode::INTERNAL_SERVER_ERROR, self.to_string())
+                    }
+                    ProxyError::StopFailed(_) => {
+                        (StatusCode::INTERNAL_SERVER_ERROR, self.to_string())
+                    }
                     ProxyError::ForwardFailed(_) => (StatusCode::BAD_GATEWAY, self.to_string()),
                     ProxyError::NoAvailableProvider => {
                         (StatusCode::SERVICE_UNAVAILABLE, self.to_string())

src-tauri/src/proxy/handlers.rs

@@ -456,7 +456,12 @@ async fn log_usage(
         Ok(Some(p)) => {
             if let Some(meta) = p.meta {
                 if let Some(cm) = meta.cost_multiplier {
-                    Decimal::from_str(&cm).unwrap_or(Decimal::from(1))
+                    Decimal::from_str(&cm).unwrap_or_else(|e| {
+                        log::warn!(
+                            "cost_multiplier 解析失败 (provider_id={provider_id}): {cm} - {e}"
+                        );
+                        Decimal::from(1)
+                    })
                 } else {
                     Decimal::from(1)
                 }

src-tauri/src/proxy/providers/claude.rs

@@ -62,7 +62,8 @@ impl ClaudeAdapter {
                 let normalized = value.trim().to_lowercase();
                 normalized == "true" || normalized == "1"
             }
-            _ => true,
+            // OpenRouter now supports Claude Code compatible API, default to passthrough
+            _ => false,
         }
     }
 
@@ -465,12 +466,22 @@ mod tests {
         }));
         assert!(!adapter.needs_transform(&anthropic_provider));
 
+        // OpenRouter provider without explicit setting now defaults to passthrough (no transform)
         let openrouter_provider = create_provider(json!({
             "env": {
                 "ANTHROPIC_BASE_URL": "https://openrouter.ai/api"
             }
         }));
-        assert!(adapter.needs_transform(&openrouter_provider));
+        assert!(!adapter.needs_transform(&openrouter_provider));
+
+        // OpenRouter provider with explicit compat mode enabled should transform
+        let openrouter_enabled = create_provider(json!({
+            "env": {
+                "ANTHROPIC_BASE_URL": "https://openrouter.ai/api"
+            },
+            "openrouter_compat_mode": true
+        }));
+        assert!(adapter.needs_transform(&openrouter_enabled));
 
         let openrouter_disabled = create_provider(json!({
             "env": {

src-tauri/src/proxy/response_processor.rs

@@ -372,7 +372,12 @@ async fn log_usage_internal(
         Ok(Some(p)) => {
             if let Some(meta) = p.meta {
                 if let Some(cm) = meta.cost_multiplier {
-                    Decimal::from_str(&cm).unwrap_or(Decimal::from(1))
+                    Decimal::from_str(&cm).unwrap_or_else(|e| {
+                        log::warn!(
+                            "cost_multiplier 解析失败 (provider_id={provider_id}): {cm} - {e}"
+                        );
+                        Decimal::from(1)
+                    })
                 } else {
                     Decimal::from(1)
                 }

src-tauri/src/proxy/server.rs

@@ -3,8 +3,8 @@
 //! 基于Axum的HTTP服务器，处理代理请求
 
 use super::{
-    failover_switch::FailoverSwitchManager, handlers, provider_router::ProviderRouter, types::*,
-    ProxyError,
+    failover_switch::FailoverSwitchManager, handlers, log_codes::srv as log_srv,
+    provider_router::ProviderRouter, types::*, ProxyError,
 };
 use crate::database::Database;
 use axum::{
@@ -95,7 +95,7 @@ impl ProxyServer {
             .await
             .map_err(|e| ProxyError::BindFailed(e.to_string()))?;
 
-        log::info!("[SRV-001] 代理服务器启动于 {addr}");
+        log::info!("[{}] 代理服务器启动于 {addr}", log_srv::STARTED);
 
         // 保存关闭句柄
         *self.shutdown_tx.write().await = Some(shutdown_tx);
@@ -146,13 +146,25 @@ impl ProxyServer {
         // 2. 等待服务器任务结束（带 5 秒超时保护）
         if let Some(handle) = self.server_handle.write().await.take() {
             match tokio::time::timeout(std::time::Duration::from_secs(5), handle).await {
-                Ok(Ok(())) => log::info!("[SRV-002] 代理服务器已完全停止"),
-                Ok(Err(e)) => log::warn!("[SRV-003] 代理服务器任务异常终止: {e}"),
-                Err(_) => log::warn!("[SRV-004] 代理服务器停止超时（5秒），强制继续"),
+                Ok(Ok(())) => {
+                    log::info!("[{}] 代理服务器已完全停止", log_srv::STOPPED);
+                    Ok(())
+                }
+                Ok(Err(e)) => {
+                    log::warn!("[{}] 代理服务器任务异常终止: {e}", log_srv::TASK_ERROR);
+                    Err(ProxyError::StopFailed(e.to_string()))
+                }
+                Err(_) => {
+                    log::warn!(
+                        "[{}] 代理服务器停止超时（5秒），强制继续",
+                        log_srv::STOP_TIMEOUT
+                    );
+                    Err(ProxyError::StopTimeout)
+                }
             }
+        } else {
+            Ok(())
         }
-
-        Ok(())
     }
 
     pub async fn get_status(&self) -> ProxyStatus {

src-tauri/src/services/provider/live.rs

@@ -148,6 +148,15 @@ pub fn sync_current_to_live(state: &AppState) -> Result<(), AppError> {
 
     // MCP sync
     McpService::sync_all_enabled(state)?;
+
+    // Skill sync
+    for app_type in [AppType::Claude, AppType::Codex, AppType::Gemini] {
+        if let Err(e) = crate::services::skill::SkillService::sync_to_app(&state.db, &app_type) {
+            log::warn!("同步 Skill 到 {:?} 失败: {}", app_type, e);
+            // Continue syncing other apps, don't abort
+        }
+    }
+
     Ok(())
 }
 

src-tauri/src/settings.rs

@@ -92,12 +92,9 @@ impl Default for AppSettings {
 }
 
 impl AppSettings {
-    fn settings_path() -> PathBuf {
+    fn settings_path() -> Option<PathBuf> {
         // settings.json 保留用于旧版本迁移和无数据库场景
-        dirs::home_dir()
-            .expect("无法获取用户主目录")
-            .join(".cc-switch")
-            .join("settings.json")
+        dirs::home_dir().map(|h| h.join(".cc-switch").join("settings.json"))
     }
 
     fn normalize_paths(&mut self) {
@@ -131,7 +128,9 @@ impl AppSettings {
     }
 
     fn load_from_file() -> Self {
-        let path = Self::settings_path();
+        let Some(path) = Self::settings_path() else {
+            return Self::default();
+        };
         if let Ok(content) = fs::read_to_string(&path) {
             match serde_json::from_str::<AppSettings>(&content) {
                 Ok(mut settings) => {
@@ -156,7 +155,9 @@ impl AppSettings {
 fn save_settings_file(settings: &AppSettings) -> Result<(), AppError> {
     let mut normalized = settings.clone();
     normalized.normalize_paths();
-    let path = AppSettings::settings_path();
+    let Some(path) = AppSettings::settings_path() else {
+        return Err(AppError::Config("无法获取用户主目录".to_string()));
+    };
 
     if let Some(parent) = path.parent() {
         fs::create_dir_all(parent).map_err(|e| AppError::io(parent, e))?;
@@ -193,14 +194,23 @@ fn resolve_override_path(raw: &str) -> PathBuf {
 }
 
 pub fn get_settings() -> AppSettings {
-    settings_store().read().expect("读取设置锁失败").clone()
+    settings_store()
+        .read()
+        .unwrap_or_else(|e| {
+            log::warn!("设置锁已毒化，使用恢复值: {e}");
+            e.into_inner()
+        })
+        .clone()
 }
 
 pub fn update_settings(mut new_settings: AppSettings) -> Result<(), AppError> {
     new_settings.normalize_paths();
     save_settings_file(&new_settings)?;
 
-    let mut guard = settings_store().write().expect("写入设置锁失败");
+    let mut guard = settings_store().write().unwrap_or_else(|e| {
+        log::warn!("设置锁已毒化，使用恢复值: {e}");
+        e.into_inner()
+    });
     *guard = new_settings;
     Ok(())
 }
@@ -209,7 +219,10 @@ pub fn update_settings(mut new_settings: AppSettings) -> Result<(), AppError> {
 /// 用于导入配置等场景，确保内存缓存与文件同步
 pub fn reload_settings() -> Result<(), AppError> {
     let fresh_settings = AppSettings::load_from_file();
-    let mut guard = settings_store().write().expect("写入设置锁失败");
+    let mut guard = settings_store().write().unwrap_or_else(|e| {
+        log::warn!("设置锁已毒化，使用恢复值: {e}");
+        e.into_inner()
+    });
     *guard = fresh_settings;
     Ok(())
 }