admin/CC-Switch
1
0
Fork 0
mirror of https://github.com/farion1231/cc-switch.git synced 2026-07-24 12:44:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

Feat/provider individual config (#663)

Browse Source 
* refactor(ui): simplify UpdateBadge to minimal dot indicator

* feat(provider): add individual test and proxy config for providers

Add support for provider-specific model test and proxy configurations:

- Add ProviderTestConfig and ProviderProxyConfig types in Rust and TypeScript
- Create ProviderAdvancedConfig component with collapsible panels
- Update stream_check service to merge provider config with global config
- Proxy config UI follows global proxy style (single URL input)

Provider-level configs stored in meta field, no database schema changes needed.

* feat(ui): add failover toggle and improve proxy controls

- Add FailoverToggle component with slide animation
- Simplify ProxyToggle style to match FailoverToggle
- Add usage statistics button when proxy is active
- Fix i18n parameter passing for failover messages
- Add missing failover translation keys (inQueue, addQueue, priority)
- Replace AboutSection icon with app logo

* fix(proxy): support system proxy fallback and provider-level proxy config

- Remove no_proxy() calls in http_client.rs to allow system proxy fallback
- Add get_for_provider() to build HTTP client with provider-specific proxy
- Update forwarder.rs and stream_check.rs to use provider proxy config
- Fix EditProviderDialog.tsx to include provider.meta in useMemo deps
- Add useEffect in ProviderAdvancedConfig.tsx to sync expand state

Fixes #636
Fixes #583

* fix(ui): sync toast theme with app setting

* feat(settings): add log config management

Fixes #612
Fixes #514

* fix(proxy): increase request body size limit to 200MB

Fixes #666

* docs(proxy): update timeout config descriptions and defaults

Fixes #612

* fix(proxy): filter x-goog-api-key header to prevent duplication

* fix(proxy): prevent proxy recursion when system proxy points to localhost

Detect if HTTP_PROXY, HTTPS_PROXY, or ALL_PROXY environment variables
point to loopback addresses (localhost, 127.0.0.1), and bypass system
proxy in such cases to avoid infinite request loops.

* fix(i18n): add providerAdvanced i18n keys and fix failover toast parameter

- Add providerAdvanced.* i18n keys to en.json, zh.json, and ja.json
- Fix failover toggleFailed toast to pass detail parameter
- Remove Chinese fallback text from UI for English/Japanese users

* fix(tray): restore tray-provider events and enable Auto failover properly

- Emit provider-switched event on tray provider click (backward compatibility)
- Auto button now: starts proxy, takes over live config, enables failover

* fix(log): enable dynamic log level and single file mode

- Initialize log at Trace level for dynamic adjustment
- Change rotation strategy to KeepSome(1) for single file
- Set max file size to 1GB
- Delete old log file on startup for clean start

* fix(tray): fix clippy uninlined format args warning

Use inline format arguments: {app_type_str} instead of {}

* fix(provider): allow typing :// in endpoint URL inputs

Change input type from "url" to "text" to prevent browser
URL validation from blocking :// input.

Closes #681

* fix(stream-check): use Gemini native streaming API format

- Change endpoint from OpenAI-compatible to native streamGenerateContent
- Add alt=sse parameter for SSE format response
- Use x-goog-api-key header instead of Bearer token
- Convert request body to Gemini contents/parts format

* feat(proxy): add request logging for debugging

Add debug logs for outgoing requests including URL and body content
with byte size, matching the existing response logging format.

* fix(log): prevent usize underflow in KeepSome rotation strategy

KeepSome(n) internally computes n-2, so n=1 causes underflow.
Use KeepSome(2) as the minimum safe value.
This commit is contained in:
Dex Miller
2026-01-20 21:02:44 +08:00
committed by GitHub
parent 7bb458eecb
commit e7badb1a24
46 changed files with 2008 additions and 331 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src-tauri/src/commands/failover.rs
+11 -1
View File
@@ -75,6 +75,7 @@ pub async fn get_auto_failover_enabled(
/// 注意：关闭故障转移时不会清除队列，队列内容会保留供下次开启时使用
#[tauri::command]
pub async fn set_auto_failover_enabled(
app: tauri::AppHandle,
state: tauri::State<'_, AppState>,
app_type: String,
enabled: bool,
@@ -98,5 +99,14 @@ pub async fn set_auto_failover_enabled(
.db
.update_proxy_config_for_app(config)
.await
.map_err(|e| e.to_string())
.map_err(|e| e.to_string())?;
// 刷新托盘菜单，确保状态同步
if let Ok(new_menu) = crate::tray::create_tray_menu(&app, &state) {
if let Some(tray) = app.tray_by_id("main") {
let _ = tray.set_menu(Some(new_menu));
}
}
Ok(())
}
src-tauri/src/commands/settings.rs
+27
View File
@@ -80,3 +80,30 @@ pub async fn set_rectifier_config(
.map_err(|e| e.to_string())?;
Ok(true)
}
/// 获取日志配置
#[tauri::command]
pub async fn get_log_config(
state: tauri::State<'_, crate::AppState>,
) -> Result<crate::proxy::types::LogConfig, String> {
state.db.get_log_config().map_err(|e| e.to_string())
}
/// 设置日志配置
#[tauri::command]
pub async fn set_log_config(
state: tauri::State<'_, crate::AppState>,
config: crate::proxy::types::LogConfig,
) -> Result<bool, String> {
state
.db
.set_log_config(&config)
.map_err(|e| e.to_string())?;
log::set_max_level(config.to_level_filter());
log::info!(
"日志配置已更新: enabled={}, level={}",
config.enabled,
config.level
);
Ok(true)
}
src-tauri/src/database/dao/proxy.rs
+47
View File
@@ -614,4 +614,51 @@ impl Database {
log::info!("已删除所有 Live 配置备份");
Ok(())
}
// ==================== Sync Methods for Tray Menu ====================
/// 同步获取应用的 proxy 启用状态和自动故障转移状态
///
/// 用于托盘菜单构建等同步场景
/// 返回 (enabled, auto_failover_enabled)
pub fn get_proxy_flags_sync(&self, app_type: &str) -> (bool, bool) {
let conn = match self.conn.lock() {
Ok(c) => c,
Err(_) => return (false, false),
};
conn.query_row(
"SELECT enabled, auto_failover_enabled FROM proxy_config WHERE app_type = ?1",
[app_type],
|row| Ok((row.get::<_, i32>(0)? != 0, row.get::<_, i32>(1)? != 0)),
)
.unwrap_or((false, false))
}
/// 同步设置应用的 proxy 启用状态和自动故障转移状态
///
/// 用于托盘菜单点击等同步场景
pub fn set_proxy_flags_sync(
&self,
app_type: &str,
enabled: bool,
auto_failover_enabled: bool,
) -> Result<(), AppError> {
let conn = self
.conn
.lock()
.map_err(|e| AppError::Database(format!("Mutex lock failed: {e}")))?;
conn.execute(
"UPDATE proxy_config SET enabled = ?2, auto_failover_enabled = ?3, updated_at = datetime('now') WHERE app_type = ?1",
rusqlite::params![
app_type,
if enabled { 1 } else { 0 },
if auto_failover_enabled { 1 } else { 0 },
],
)
.map_err(|e| AppError::Database(e.to_string()))?;
Ok(())
}
}
src-tauri/src/database/dao/settings.rs
+18
View File
@@ -186,4 +186,22 @@ impl Database {
.map_err(|e| AppError::Database(format!("序列化整流器配置失败: {e}")))?;
self.set_setting("rectifier_config", &json)
}
// --- 日志配置 ---
/// 获取日志配置
pub fn get_log_config(&self) -> Result<crate::proxy::types::LogConfig, AppError> {
match self.get_setting("log_config")? {
Some(json) => serde_json::from_str(&json)
.map_err(|e| AppError::Database(format!("解析日志配置失败: {e}"))),
None => Ok(crate::proxy::types::LogConfig::default()),
}
}
/// 更新日志配置
pub fn set_log_config(&self, config: &crate::proxy::types::LogConfig) -> Result<(), AppError> {
let json = serde_json::to_string(config)
.map_err(|e| AppError::Database(format!("序列化日志配置失败: {e}")))?;
self.set_setting("log_config", &json)
}
}
src-tauri/src/lib.rs
+33 -10
View File
@@ -266,33 +266,41 @@ pub fn run() {
log::warn!("初始化 Updater 插件失败，已跳过：{e}");
}
}
// 初始化日志（Debug 和 Release 模式都启用 Info 级别）
// 日志同时输出到控制台和文件（<app_config_dir>/logs/；若设置了覆盖则使用覆盖目录）
// 初始化日志（单文件输出到 <app_config_dir>/logs/cc-switch.log）
{
use tauri_plugin_log::{RotationStrategy, Target, TargetKind, TimezoneStrategy};
let log_dir = panic_hook::get_log_dir();
// 确保日志目录存在
if let Err(e) = std::fs::create_dir_all(&log_dir) {
eprintln!("创建日志目录失败: {e}");
}
// 启动时删除旧日志文件，实现单文件覆盖效果
let log_file_path = log_dir.join("cc-switch.log");
let _ = std::fs::remove_file(&log_file_path);
app.handle().plugin(
tauri_plugin_log::Builder::default()
.level(log::LevelFilter::Info)
// 初始化为 Trace，允许后续通过 log::set_max_level() 动态调整级别
.level(log::LevelFilter::Trace)
.targets([
// 输出到控制台
Target::new(TargetKind::Stdout),
// 输出到日志文件
Target::new(TargetKind::Folder {
path: log_dir,
file_name: Some("cc-switch".into()),
}),
])
.rotation_strategy(RotationStrategy::KeepAll)
.max_file_size(5_000_000) // 5MB 单文件上限
// 单文件模式：启动时删除旧文件，达到大小时轮转
// 注意：KeepSome(n) 内部会做 n-2 运算，n=1 会导致 usize 下溢
// KeepSome(2) 是最小安全值，表示不保留轮转文件
.rotation_strategy(RotationStrategy::KeepSome(2))
// 单文件大小限制 1GB
.max_file_size(1024 * 1024 * 1024)
.timezone_strategy(TimezoneStrategy::UseLocal)
.build(),
)?;
// 清理旧日志文件，只保留最近 2 个
panic_hook::cleanup_old_logs();
}
// 初始化数据库
@@ -660,6 +668,19 @@ pub fn run() {
// 将同一个实例注入到全局状态，避免重复创建导致的不一致
app.manage(app_state);
// 从数据库加载日志配置并应用
{
let db = &app.state::<AppState>().db;
if let Ok(log_config) = db.get_log_config() {
log::set_max_level(log_config.to_level_filter());
log::info!(
"已加载日志配置: enabled={}, level={}",
log_config.enabled,
log_config.level
);
}
}
// 初始化 SkillService
let skill_service = SkillService::new();
app.manage(commands::skill::SkillServiceState(Arc::new(skill_service)));
@@ -757,6 +778,8 @@ pub fn run() {
commands::save_settings,
commands::get_rectifier_config,
commands::set_rectifier_config,
commands::get_log_config,
commands::set_log_config,
commands::restart_app,
commands::check_for_updates,
commands::is_portable_mode,
src-tauri/src/mcp/opencode.rs
+8 -12
View File
@@ -96,10 +96,7 @@ pub fn convert_to_opencode_format(spec: &Value) -> Result<Value, AppError> {
result.insert("enabled".into(), json!(true));
}
_ => {
return Err(AppError::McpValidation(format!(
"Unknown MCP type: {}",
typ
)));
return Err(AppError::McpValidation(format!("Unknown MCP type: {typ}")));
}
}
@@ -171,8 +168,7 @@ pub fn convert_from_opencode_format(spec: &Value) -> Result<Value, AppError> {
}
_ => {
return Err(AppError::McpValidation(format!(
"Unknown OpenCode MCP type: {}",
typ
"Unknown OpenCode MCP type: {typ}"
)));
}
}
@@ -230,16 +226,16 @@ pub fn import_from_opencode(config: &mut MultiAppConfig) -> Result<usize, AppErr
let unified_spec = match convert_from_opencode_format(&spec) {
Ok(s) => s,
Err(e) => {
log::warn!("Skip invalid OpenCode MCP server '{}': {}", id, e);
errors.push(format!("{}: {}", id, e));
log::warn!("Skip invalid OpenCode MCP server '{id}': {e}");
errors.push(format!("{id}: {e}"));
continue;
}
};
// Validate the converted spec
if let Err(e) = validate_server_spec(&unified_spec) {
log::warn!("Skip invalid MCP server '{}' after conversion: {}", id, e);
errors.push(format!("{}: {}", id, e));
log::warn!("Skip invalid MCP server '{id}' after conversion: {e}");
errors.push(format!("{id}: {e}"));
continue;
}
@@ -248,7 +244,7 @@ pub fn import_from_opencode(config: &mut MultiAppConfig) -> Result<usize, AppErr
if !existing.apps.opencode {
existing.apps.opencode = true;
changed += 1;
log::info!("MCP server '{}' enabled for OpenCode", id);
log::info!("MCP server '{id}' enabled for OpenCode");
}
} else {
// New server: default to only OpenCode enabled
@@ -271,7 +267,7 @@ pub fn import_from_opencode(config: &mut MultiAppConfig) -> Result<usize, AppErr
},
);
changed += 1;
log::info!("Imported new MCP server '{}' from OpenCode", id);
log::info!("Imported new MCP server '{id}' from OpenCode");
}
}
src-tauri/src/opencode_config.rs
+2 -3
View File
@@ -103,7 +103,7 @@ pub fn write_opencode_config(config: &Value) -> Result<(), AppError> {
// 复用统一的原子写入逻辑（兼容 Windows 上目标文件已存在的情况）
write_json_file(&path, config)?;
log::debug!("OpenCode config written to {:?}", path);
log::debug!("OpenCode config written to {path:?}");
Ok(())
}
@@ -165,7 +165,7 @@ pub fn get_typed_providers() -> Result<IndexMap<String, OpenCodeProviderConfig>,
result.insert(id, config);
}
Err(e) => {
log::warn!("Failed to parse provider '{}': {}", id, e);
log::warn!("Failed to parse provider '{id}': {e}");
// Skip invalid providers but continue
}
}
@@ -219,4 +219,3 @@ pub fn remove_mcp_server(id: &str) -> Result<(), AppError> {
write_opencode_config(&config)
}
src-tauri/src/panic_hook.rs
-45
View File
@@ -12,9 +12,6 @@ use std::sync::OnceLock;
/// 应用版本号（从 Cargo.toml 读取）
const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
/// 日志文件保留数量
const LOG_FILES_TO_KEEP: usize = 2;
static APP_CONFIG_DIR: OnceLock<PathBuf> = OnceLock::new();
pub fn init_app_config_dir(dir: PathBuf) {
@@ -46,48 +43,6 @@ pub fn get_log_dir() -> PathBuf {
get_app_config_dir().join("logs")
}
/// 清理旧日志文件，只保留最近 N 个
///
/// 在应用启动时调用，确保日志文件不会无限增长。
pub fn cleanup_old_logs() {
let log_dir = get_log_dir();
if !log_dir.exists() {
return;
}
// 读取目录中的所有 .log 文件
let mut log_files: Vec<_> = match std::fs::read_dir(&log_dir) {
Ok(entries) => entries
.filter_map(|e| e.ok())
.map(|e| e.path())
.filter(|p| p.extension().map(|ext| ext == "log").unwrap_or(false))
.collect(),
Err(_) => return,
};
// 如果文件数量不超过保留数量，无需清理
if log_files.len() <= LOG_FILES_TO_KEEP {
return;
}
// 按修改时间排序（最新的在前）
log_files.sort_by(|a, b| {
let time_a = a.metadata().and_then(|m| m.modified()).ok();
let time_b = b.metadata().and_then(|m| m.modified()).ok();
time_b.cmp(&time_a) // 降序
});
// 删除多余的旧文件
for old_file in log_files.into_iter().skip(LOG_FILES_TO_KEEP) {
if let Err(e) = std::fs::remove_file(&old_file) {
log::warn!("清理旧日志文件失败 {}: {e}", old_file.display());
} else {
log::info!("已清理旧日志文件: {}", old_file.display());
}
}
}
/// 安全获取环境信息（不会 panic）
fn get_system_info() -> String {
let os = std::env::consts::OS;
src-tauri/src/provider.rs
+55
View File
@@ -142,6 +142,55 @@ pub struct UsageResult {
pub error: Option<String>,
}
/// 供应商单独的模型测试配置
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ProviderTestConfig {
/// 是否启用单独配置（false 时使用全局配置）
#[serde(default)]
pub enabled: bool,
/// 测试用的模型名称（覆盖全局配置）
#[serde(rename = "testModel", skip_serializing_if = "Option::is_none")]
pub test_model: Option<String>,
/// 超时时间（秒）
#[serde(rename = "timeoutSecs", skip_serializing_if = "Option::is_none")]
pub timeout_secs: Option<u64>,
/// 测试提示词
#[serde(rename = "testPrompt", skip_serializing_if = "Option::is_none")]
pub test_prompt: Option<String>,
/// 降级阈值（毫秒）
#[serde(
rename = "degradedThresholdMs",
skip_serializing_if = "Option::is_none"
)]
pub degraded_threshold_ms: Option<u64>,
/// 最大重试次数
#[serde(rename = "maxRetries", skip_serializing_if = "Option::is_none")]
pub max_retries: Option<u32>,
}
/// 供应商单独的代理配置
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ProviderProxyConfig {
/// 是否启用单独配置（false 时使用全局/系统代理）
#[serde(default)]
pub enabled: bool,
/// 代理类型：http, https, socks5
#[serde(rename = "proxyType", skip_serializing_if = "Option::is_none")]
pub proxy_type: Option<String>,
/// 代理主机
#[serde(rename = "proxyHost", skip_serializing_if = "Option::is_none")]
pub proxy_host: Option<String>,
/// 代理端口
#[serde(rename = "proxyPort", skip_serializing_if = "Option::is_none")]
pub proxy_port: Option<u16>,
/// 代理用户名（可选）
#[serde(rename = "proxyUsername", skip_serializing_if = "Option::is_none")]
pub proxy_username: Option<String>,
/// 代理密码（可选）
#[serde(rename = "proxyPassword", skip_serializing_if = "Option::is_none")]
pub proxy_password: Option<String>,
}
/// 供应商元数据
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ProviderMeta {
@@ -172,6 +221,12 @@ pub struct ProviderMeta {
/// 每月消费限额（USD）
#[serde(rename = "limitMonthlyUsd", skip_serializing_if = "Option::is_none")]
pub limit_monthly_usd: Option<String>,
/// 供应商单独的模型测试配置
#[serde(rename = "testConfig", skip_serializing_if = "Option::is_none")]
pub test_config: Option<ProviderTestConfig>,
/// 供应商单独的代理配置
#[serde(rename = "proxyConfig", skip_serializing_if = "Option::is_none")]
pub proxy_config: Option<ProviderProxyConfig>,
}
impl ProviderManager {
src-tauri/src/proxy/forwarder.rs
+15 -2
View File
@@ -28,6 +28,7 @@ const HEADER_BLACKLIST: &[&str] = &[
// 认证类（会被覆盖）
"authorization",
"x-api-key",
"x-goog-api-key",
// 连接类（由 HTTP 客户端管理）
"host",
"content-length",
@@ -585,8 +586,9 @@ impl RequestForwarder {
// 默认使用空白名单，过滤所有 _ 前缀字段
let filtered_body = filter_private_params_with_whitelist(request_body, &[]);
// 每次请求时获取最新的全局 HTTP 客户端（支持热更新代理配置）
let client = super::http_client::get();
// 获取 HTTP 客户端：优先使用供应商单独代理配置，否则使用全局客户端
let proxy_config = provider.meta.as_ref().and_then(|m| m.proxy_config.as_ref());
let client = super::http_client::get_for_provider(proxy_config);
let mut request = client.post(&url);
// 只有当 timeout > 0 时才设置请求超时
@@ -662,6 +664,17 @@ impl RequestForwarder {
request = request.header("anthropic-version", version_str);
}
// 输出请求信息日志
let tag = adapter.name();
log::debug!("[{tag}] >>> 请求 URL: {url}");
if let Ok(body_str) = serde_json::to_string(&filtered_body) {
log::debug!(
"[{tag}] >>> 请求体内容 ({}字节): {}",
body_str.len(),
body_str
);
}
// 发送请求
let response = request.json(&filtered_body).send().await.map_err(|e| {
if e.is_timeout() {
src-tauri/src/proxy/http_client.rs
+196 -13
View File
@@ -3,8 +3,11 @@
//! 提供支持全局代理配置的 HTTP 客户端。
//! 所有需要发送 HTTP 请求的模块都应使用此模块提供的客户端。
use crate::provider::ProviderProxyConfig;
use once_cell::sync::OnceCell;
use reqwest::Client;
use std::env;
use std::net::IpAddr;
use std::sync::RwLock;
use std::time::Duration;
@@ -155,23 +158,15 @@ pub fn update_proxy(proxy_url: Option<&str>) -> Result<(), String> {
/// 获取全局 HTTP 客户端
///
/// 返回配置了代理的客户端（如果已配置代理），否则返回直连客户端。
/// 返回配置了代理的客户端（如果已配置代理），否则返回跟随系统代理的客户端。
pub fn get() -> Client {
GLOBAL_CLIENT
.get()
.and_then(|lock| lock.read().ok())
.map(|c| c.clone())
.unwrap_or_else(|| {
// 如果还没初始化，创建一个默认客户端（配置与 build_client 一致）
log::warn!("[GlobalProxy] [GP-004] Client not initialized, using fallback");
Client::builder()
.timeout(Duration::from_secs(600))
.connect_timeout(Duration::from_secs(30))
.pool_max_idle_per_host(10)
.tcp_keepalive(Duration::from_secs(60))
.no_proxy()
.build()
.unwrap_or_default()
build_client(None).unwrap_or_default()
})
}
@@ -199,7 +194,7 @@ fn build_client(proxy_url: Option<&str>) -> Result<Client, String> {
.pool_max_idle_per_host(10)
.tcp_keepalive(Duration::from_secs(60));
// 有代理地址则使用代理，否则直连
// 有代理地址则使用代理，否则跟随系统代理
if let Some(url) = proxy_url {
// 先验证 URL 格式和 scheme
let parsed = url::Url::parse(url)
@@ -219,8 +214,16 @@ fn build_client(proxy_url: Option<&str>) -> Result<Client, String> {
builder = builder.proxy(proxy);
log::debug!("[GlobalProxy] Proxy configured: {}", mask_url(url));
} else {
builder = builder.no_proxy();
log::debug!("[GlobalProxy] Direct connection (no proxy)");
// 未设置全局代理时，让 reqwest 自动检测系统代理（环境变量）
// 若系统代理指向本机，禁用系统代理避免自环
if system_proxy_points_to_loopback() {
builder = builder.no_proxy();
log::warn!(
"[GlobalProxy] System proxy points to localhost, bypassing to avoid recursion"
);
} else {
log::debug!("[GlobalProxy] Following system proxy (no explicit proxy configured)");
}
}
builder
@@ -228,6 +231,50 @@ fn build_client(proxy_url: Option<&str>) -> Result<Client, String> {
.map_err(|e| format!("Failed to build HTTP client: {e}"))
}
fn system_proxy_points_to_loopback() -> bool {
const KEYS: [&str; 6] = [
"HTTP_PROXY",
"http_proxy",
"HTTPS_PROXY",
"https_proxy",
"ALL_PROXY",
"all_proxy",
];
KEYS.iter()
.filter_map(|key| env::var(key).ok())
.map(|value| value.trim().to_string())
.filter(|value| !value.is_empty())
.any(|value| proxy_points_to_loopback(&value))
}
fn proxy_points_to_loopback(value: &str) -> bool {
fn host_is_loopback(host: &str) -> bool {
if host.eq_ignore_ascii_case("localhost") {
return true;
}
host.parse::<IpAddr>()
.map(|ip| ip.is_loopback())
.unwrap_or(false)
}
if let Ok(parsed) = url::Url::parse(value) {
if let Some(host) = parsed.host_str() {
return host_is_loopback(host);
}
return false;
}
let with_scheme = format!("http://{value}");
if let Ok(parsed) = url::Url::parse(&with_scheme) {
if let Some(host) = parsed.host_str() {
return host_is_loopback(host);
}
}
false
}
/// 隐藏 URL 中的敏感信息（用于日志）
pub fn mask_url(url: &str) -> String {
if let Ok(parsed) = url::Url::parse(url) {
@@ -247,9 +294,109 @@ pub fn mask_url(url: &str) -> String {
}
}
/// 根据供应商单独代理配置构建代理 URL
///
/// 将 ProviderProxyConfig 转换为代理 URL 字符串
fn build_proxy_url_from_config(config: &ProviderProxyConfig) -> Option<String> {
let proxy_type = config.proxy_type.as_deref().unwrap_or("http");
let host = config.proxy_host.as_deref()?;
let port = config.proxy_port?;
// 构建带认证的代理 URL
if let (Some(username), Some(password)) = (&config.proxy_username, &config.proxy_password) {
if !username.is_empty() && !password.is_empty() {
return Some(format!(
"{proxy_type}://{username}:{password}@{host}:{port}"
));
}
}
Some(format!("{proxy_type}://{host}:{port}"))
}
/// 根据供应商单独代理配置构建 HTTP 客户端
///
/// 如果供应商配置了单独代理（enabled = true），则使用该代理构建客户端；
/// 否则返回 None，调用方应使用全局客户端。
///
/// # Arguments
/// * `proxy_config` - 供应商的代理配置
///
/// # Returns
/// 如果配置有效则返回 Some(Client)，否则返回 None
pub fn build_client_for_provider(proxy_config: Option<&ProviderProxyConfig>) -> Option<Client> {
let config = proxy_config.filter(|c| c.enabled)?;
let proxy_url = build_proxy_url_from_config(config)?;
log::debug!(
"[ProviderProxy] Building client with proxy: {}",
mask_url(&proxy_url)
);
// 构建带代理的客户端
let proxy = match reqwest::Proxy::all(&proxy_url) {
Ok(p) => p,
Err(e) => {
log::error!(
"[ProviderProxy] Failed to create proxy from '{}': {}",
mask_url(&proxy_url),
e
);
return None;
}
};
match Client::builder()
.timeout(Duration::from_secs(600))
.connect_timeout(Duration::from_secs(30))
.pool_max_idle_per_host(10)
.tcp_keepalive(Duration::from_secs(60))
.proxy(proxy)
.build()
{
Ok(client) => {
log::info!(
"[ProviderProxy] Client built with proxy: {}",
mask_url(&proxy_url)
);
Some(client)
}
Err(e) => {
log::error!("[ProviderProxy] Failed to build client: {e}");
None
}
}
}
/// 获取供应商专用的 HTTP 客户端
///
/// 优先使用供应商单独代理配置，如果未启用则返回全局客户端。
///
/// # Arguments
/// * `proxy_config` - 供应商的代理配置
///
/// # Returns
/// 返回适合该供应商的 HTTP 客户端
pub fn get_for_provider(proxy_config: Option<&ProviderProxyConfig>) -> Client {
// 优先使用供应商单独代理
if let Some(client) = build_client_for_provider(proxy_config) {
return client;
}
// 回退到全局客户端
get()
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::{Mutex, OnceLock};
fn env_lock() -> &'static Mutex<()> {
static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
LOCK.get_or_init(|| Mutex::new(()))
}
#[test]
fn test_mask_url() {
@@ -298,4 +445,40 @@ mod tests {
let result = build_client(Some("invalid-scheme://127.0.0.1:7890"));
assert!(result.is_err(), "Should reject invalid proxy scheme");
}
#[test]
fn test_proxy_points_to_loopback() {
assert!(proxy_points_to_loopback("http://127.0.0.1:7890"));
assert!(proxy_points_to_loopback("socks5://localhost:1080"));
assert!(proxy_points_to_loopback("127.0.0.1:7890"));
assert!(!proxy_points_to_loopback("http://192.168.1.10:7890"));
}
#[test]
fn test_system_proxy_points_to_loopback() {
let _guard = env_lock().lock().unwrap();
let keys = [
"HTTP_PROXY",
"http_proxy",
"HTTPS_PROXY",
"https_proxy",
"ALL_PROXY",
"all_proxy",
];
for key in &keys {
std::env::remove_var(key);
}
std::env::set_var("HTTP_PROXY", "http://127.0.0.1:7890");
assert!(system_proxy_points_to_loopback());
std::env::set_var("HTTP_PROXY", "http://10.0.0.2:7890");
assert!(!system_proxy_points_to_loopback());
for key in &keys {
std::env::remove_var(key);
}
}
}
src-tauri/src/proxy/providers/streaming.rs
-1
View File
@@ -104,7 +104,6 @@ pub fn create_anthropic_sse_stream(
}
if let Ok(chunk) = serde_json::from_str::<OpenAIStreamChunk>(data) {
// 仅在 DEBUG 级别简短记录 SSE 事件
log::debug!("[Claude/OpenRouter] <<< SSE chunk received");
if message_id.is_none() {
src-tauri/src/proxy/response_processor.rs
+39 -6
View File
@@ -12,6 +12,7 @@ use super::{
use axum::response::{IntoResponse, Response};
use bytes::Bytes;
use futures::stream::{Stream, StreamExt};
use reqwest::header::HeaderMap;
use rust_decimal::Decimal;
use serde_json::Value;
use std::{
@@ -47,6 +48,12 @@ pub async fn handle_streaming(
parser_config: &UsageParserConfig,
) -> Response {
let status = response.status();
log::debug!(
"[{}] 已接收上游流式响应: status={}, headers={}",
ctx.tag,
status.as_u16(),
format_headers(response.headers())
);
let mut builder = axum::response::Response::builder().status(status);
// 复制响应头
@@ -94,6 +101,19 @@ pub async fn handle_non_streaming(
log::error!("[{}] 读取响应失败: {e}", ctx.tag);
ProxyError::ForwardFailed(format!("Failed to read response body: {e}"))
})?;
log::debug!(
"[{}] 已接收上游响应体: status={}, bytes={}, headers={}",
ctx.tag,
status.as_u16(),
body_bytes.len(),
format_headers(&response_headers)
);
log::debug!(
"[{}] 上游响应体内容: {}",
ctx.tag,
String::from_utf8_lossy(&body_bytes)
);
// 解析并记录使用量
if let Ok(json_value) = serde_json::from_slice::<Value>(&body_bytes) {
@@ -470,6 +490,12 @@ pub fn create_logged_passthrough_stream(
match chunk_result {
Some(Ok(bytes)) => {
if is_first_chunk {
log::debug!(
"[{tag}] 已接收上游流式首包: bytes={}",
bytes.len()
);
}
is_first_chunk = false;
let text = String::from_utf8_lossy(&bytes);
buffer.push_str(&text);
@@ -488,13 +514,9 @@ pub fn create_logged_passthrough_stream(
if let Some(c) = &collector {
c.push(json_value.clone()).await;
}
log::debug!(
"[{}] <<< SSE 事件: {}",
tag,
data.chars().take(100).collect::<String>()
);
log::debug!("[{tag}] <<< SSE 事件: {data}");
} else {
log::debug!("[{tag}] <<< SSE 数据: {}", data.chars().take(100).collect::<String>());
log::debug!("[{tag}] <<< SSE 数据: {data}");
}
} else {
log::debug!("[{tag}] <<< SSE: [DONE]");
@@ -523,3 +545,14 @@ pub fn create_logged_passthrough_stream(
}
}
}
fn format_headers(headers: &HeaderMap) -> String {
headers
.iter()
.map(|(key, value)| {
let value_str = value.to_str().unwrap_or("<non-utf8>");
format!("{key}={value_str}")
})
.collect::<Vec<_>>()
.join(", ")
}
src-tauri/src/proxy/server.rs
+3
View File
@@ -8,6 +8,7 @@ use super::{
};
use crate::database::Database;
use axum::{
extract::DefaultBodyLimit,
routing::{get, post},
Router,
};
@@ -224,6 +225,8 @@ impl ProxyServer {
// Gemini API (支持带前缀和不带前缀)
.route("/v1beta/*path", post(handlers::handle_gemini))
.route("/gemini/v1beta/*path", post(handlers::handle_gemini))
// 提高默认请求体大小限制（避免 413 Payload Too Large）
.layer(DefaultBodyLimit::max(200 * 1024 * 1024))
.layer(cors)
.with_state(self.state.clone())
}
src-tauri/src/proxy/types.rs
+103 -3
View File
@@ -16,13 +16,13 @@ pub struct ProxyConfig {
/// 是否正在接管 Live 配置
#[serde(default)]
pub live_takeover_active: bool,
/// 流式首字超时（秒）- 等待首个数据块的最大时间
/// 流式首字超时（秒）- 等待首个数据块的最大时间，范围 1-120 秒，默认 60 秒
#[serde(default = "default_streaming_first_byte_timeout")]
pub streaming_first_byte_timeout: u64,
/// 流式静默超时（秒）- 两个数据块之间的最大间隔
/// 流式静默超时（秒）- 两个数据块之间的最大间隔，范围 60-600 秒，填 0 禁用（防止中途卡住）
#[serde(default = "default_streaming_idle_timeout")]
pub streaming_idle_timeout: u64,
/// 非流式总超时（秒）- 非流式请求的总超时时间
/// 非流式总超时（秒）- 非流式请求的总超时时间，范围 60-1200 秒，默认 600 秒（10 分钟）
#[serde(default = "default_non_streaming_timeout")]
pub non_streaming_timeout: u64,
}
@@ -221,6 +221,50 @@ fn default_true() -> bool {
true
}
fn default_log_level() -> String {
"info".to_string()
}
/// 日志配置
///
/// 存储在 settings 表的 log_config 字段中（JSON 格式）
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LogConfig {
/// 总开关：是否启用日志
#[serde(default = "default_true")]
pub enabled: bool,
/// 日志级别: error, warn, info, debug, trace
#[serde(default = "default_log_level")]
pub level: String,
}
impl Default for LogConfig {
fn default() -> Self {
Self {
enabled: true,
level: "info".to_string(),
}
}
}
impl LogConfig {
/// 将配置转换为 log::LevelFilter
pub fn to_level_filter(&self) -> log::LevelFilter {
if !self.enabled {
return log::LevelFilter::Off;
}
match self.level.to_lowercase().as_str() {
"error" => log::LevelFilter::Error,
"warn" => log::LevelFilter::Warn,
"info" => log::LevelFilter::Info,
"debug" => log::LevelFilter::Debug,
"trace" => log::LevelFilter::Trace,
_ => log::LevelFilter::Info,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -254,4 +298,60 @@ mod tests {
assert!(!config.enabled);
assert!(!config.request_thinking_signature);
}
#[test]
fn test_log_config_default() {
let config = LogConfig::default();
assert!(config.enabled);
assert_eq!(config.level, "info");
}
#[test]
fn test_log_config_serde_default() {
let json = "{}";
let config: LogConfig = serde_json::from_str(json).unwrap();
assert!(config.enabled);
assert_eq!(config.level, "info");
}
#[test]
fn test_log_config_to_level_filter() {
let mut config = LogConfig::default();
config.level = "error".to_string();
assert_eq!(config.to_level_filter(), log::LevelFilter::Error);
config.level = "warn".to_string();
assert_eq!(config.to_level_filter(), log::LevelFilter::Warn);
config.level = "info".to_string();
assert_eq!(config.to_level_filter(), log::LevelFilter::Info);
config.level = "debug".to_string();
assert_eq!(config.to_level_filter(), log::LevelFilter::Debug);
config.level = "trace".to_string();
assert_eq!(config.to_level_filter(), log::LevelFilter::Trace);
// 无效级别回退到 info
config.level = "invalid".to_string();
assert_eq!(config.to_level_filter(), log::LevelFilter::Info);
// 禁用时返回 Off
config.enabled = false;
config.level = "debug".to_string();
assert_eq!(config.to_level_filter(), log::LevelFilter::Off);
}
#[test]
fn test_log_config_serde_roundtrip() {
let config = LogConfig {
enabled: true,
level: "debug".to_string(),
};
let json = serde_json::to_string(&config).unwrap();
let parsed: LogConfig = serde_json::from_str(&json).unwrap();
assert!(parsed.enabled);
assert_eq!(parsed.level, "debug");
}
}
src-tauri/src/services/provider/live.rs
+6 -15
View File
@@ -500,18 +500,12 @@ pub(crate) fn remove_opencode_provider_from_live(provider_id: &str) -> Result<()
// Check if OpenCode config directory exists
if !opencode_config::get_opencode_dir().exists() {
log::debug!(
"OpenCode config directory doesn't exist, skipping removal of '{}'",
provider_id
);
log::debug!("OpenCode config directory doesn't exist, skipping removal of '{provider_id}'");
return Ok(());
}
opencode_config::remove_provider(provider_id)?;
log::info!(
"OpenCode provider '{}' removed from live config",
provider_id
);
log::info!("OpenCode provider '{provider_id}' removed from live config");
Ok(())
}
@@ -535,10 +529,7 @@ pub fn import_opencode_providers_from_live(state: &AppState) -> Result<usize, Ap
for (id, config) in providers {
// Skip if already exists in database
if existing.contains_key(&id) {
log::debug!(
"OpenCode provider '{}' already exists in database, skipping",
id
);
log::debug!("OpenCode provider '{id}' already exists in database, skipping");
continue;
}
@@ -546,7 +537,7 @@ pub fn import_opencode_providers_from_live(state: &AppState) -> Result<usize, Ap
let settings_config = match serde_json::to_value(&config) {
Ok(v) => v,
Err(e) => {
log::warn!("Failed to serialize OpenCode provider '{}': {}", id, e);
log::warn!("Failed to serialize OpenCode provider '{id}': {e}");
continue;
}
};
@@ -561,12 +552,12 @@ pub fn import_opencode_providers_from_live(state: &AppState) -> Result<usize, Ap
// Save to database
if let Err(e) = state.db.save_provider("opencode", &provider) {
log::warn!("Failed to import OpenCode provider '{}': {}", id, e);
log::warn!("Failed to import OpenCode provider '{id}': {e}");
continue;
}
imported += 1;
log::info!("Imported OpenCode provider '{}' from live config", id);
log::info!("Imported OpenCode provider '{id}' from live config");
}
Ok(imported)
src-tauri/src/services/skill.rs
+24 -4
View File
@@ -323,7 +323,12 @@ impl SkillService {
.ok_or_else(|| anyhow!("Skill not found: {id}"))?;
// 从所有应用目录删除
for app in [AppType::Claude, AppType::Codex, AppType::Gemini, AppType::OpenCode] {
for app in [
AppType::Claude,
AppType::Codex,
AppType::Gemini,
AppType::OpenCode,
] {
let _ = Self::remove_from_app(&skill.directory, &app);
}
@@ -382,7 +387,12 @@ impl SkillService {
let mut unmanaged: HashMap<String, UnmanagedSkill> = HashMap::new();
for app in [AppType::Claude, AppType::Codex, AppType::Gemini, AppType::OpenCode] {
for app in [
AppType::Claude,
AppType::Codex,
AppType::Gemini,
AppType::OpenCode,
] {
let app_dir = match Self::get_app_skills_dir(&app) {
Ok(d) => d,
Err(_) => continue,
@@ -464,7 +474,12 @@ impl SkillService {
let mut source_path: Option<PathBuf> = None;
let mut found_in: Vec<String> = Vec::new();
for app in [AppType::Claude, AppType::Codex, AppType::Gemini, AppType::OpenCode] {
for app in [
AppType::Claude,
AppType::Codex,
AppType::Gemini,
AppType::OpenCode,
] {
if let Ok(app_dir) = Self::get_app_skills_dir(&app) {
let skill_path = app_dir.join(&dir_name);
if skill_path.exists() {
@@ -985,7 +1000,12 @@ pub fn migrate_skills_to_ssot(db: &Arc<Database>) -> Result<usize> {
let mut discovered: HashMap<String, SkillApps> = HashMap::new();
// 扫描各应用目录
for app in [AppType::Claude, AppType::Codex, AppType::Gemini, AppType::OpenCode] {
for app in [
AppType::Claude,
AppType::Codex,
AppType::Gemini,
AppType::OpenCode,
] {
let app_dir = match SkillService::get_app_skills_dir(&app) {
Ok(d) => d,
Err(_) => continue,
src-tauri/src/services/stream_check.rs
+71 -14
View File
@@ -78,15 +78,19 @@ pub struct StreamCheckService;
impl StreamCheckService {
/// 执行流式健康检查（带重试）
///
/// 如果 Provider 配置了单独的测试配置（meta.testConfig），则使用该配置覆盖全局配置
pub async fn check_with_retry(
app_type: &AppType,
provider: &Provider,
config: &StreamCheckConfig,
) -> Result<StreamCheckResult, AppError> {
// 合并供应商单独配置和全局配置
let effective_config = Self::merge_provider_config(provider, config);
let mut last_result = None;
for attempt in 0..=config.max_retries {
let result = Self::check_once(app_type, provider, config).await;
for attempt in 0..=effective_config.max_retries {
let result = Self::check_once(app_type, provider, &effective_config).await;
match &result {
Ok(r) if r.success => {
@@ -97,7 +101,7 @@ impl StreamCheckService {
}
Ok(r) => {
// 失败但非异常，判断是否重试
if Self::should_retry(&r.message) && attempt < config.max_retries {
if Self::should_retry(&r.message) && attempt < effective_config.max_retries {
last_result = Some(r.clone());
continue;
}
@@ -107,7 +111,8 @@ impl StreamCheckService {
});
}
Err(e) => {
if Self::should_retry(&e.to_string()) && attempt < config.max_retries {
if Self::should_retry(&e.to_string()) && attempt < effective_config.max_retries
{
continue;
}
return Err(AppError::Message(e.to_string()));
@@ -123,10 +128,51 @@ impl StreamCheckService {
http_status: None,
model_used: String::new(),
tested_at: chrono::Utc::now().timestamp(),
retry_count: config.max_retries,
retry_count: effective_config.max_retries,
}))
}
/// 合并供应商单独配置和全局配置
///
/// 如果供应商配置了 meta.testConfig 且 enabled 为 true，则使用供应商配置覆盖全局配置
fn merge_provider_config(
provider: &Provider,
global_config: &StreamCheckConfig,
) -> StreamCheckConfig {
let test_config = provider
.meta
.as_ref()
.and_then(|m| m.test_config.as_ref())
.filter(|tc| tc.enabled);
match test_config {
Some(tc) => StreamCheckConfig {
timeout_secs: tc.timeout_secs.unwrap_or(global_config.timeout_secs),
max_retries: tc.max_retries.unwrap_or(global_config.max_retries),
degraded_threshold_ms: tc
.degraded_threshold_ms
.unwrap_or(global_config.degraded_threshold_ms),
claude_model: tc
.test_model
.clone()
.unwrap_or_else(|| global_config.claude_model.clone()),
codex_model: tc
.test_model
.clone()
.unwrap_or_else(|| global_config.codex_model.clone()),
gemini_model: tc
.test_model
.clone()
.unwrap_or_else(|| global_config.gemini_model.clone()),
test_prompt: tc
.test_prompt
.clone()
.unwrap_or_else(|| global_config.test_prompt.clone()),
},
None => global_config.clone(),
}
}
/// 单次流式检查
async fn check_once(
app_type: &AppType,
@@ -144,8 +190,9 @@ impl StreamCheckService {
.extract_auth(provider)
.ok_or_else(|| AppError::Message("API Key not found".to_string()))?;
// 使用全局 HTTP 客户端（已包含代理配置）
let client = crate::proxy::http_client::get();
// 获取 HTTP 客户端：优先使用供应商单独代理配置，否则使用全局客户端
let proxy_config = provider.meta.as_ref().and_then(|m| m.proxy_config.as_ref());
let client = crate::proxy::http_client::get_for_provider(proxy_config);
let request_timeout = std::time::Duration::from_secs(config.timeout_secs);
let model_to_test = Self::resolve_test_model(app_type, provider, config);
@@ -389,6 +436,8 @@ impl StreamCheckService {
}
/// Gemini 流式检查
///
/// 使用 Gemini 原生 API 格式 (streamGenerateContent)
async fn check_gemini_stream(
client: &Client,
base_url: &str,
@@ -398,20 +447,28 @@ impl StreamCheckService {
timeout: std::time::Duration,
) -> Result<(u16, String), AppError> {
let base = base_url.trim_end_matches('/');
let url = format!("{base}/v1/chat/completions");
// Gemini 原生 API: /v1beta/models/{model}:streamGenerateContent?alt=sse
// 智能处理 /v1beta 路径：如果 base_url 不包含版本路径，则添加 /v1beta
// alt=sse 参数使 API 返回 SSE 格式（text/event-stream）而非 JSON 数组
let url = if base.contains("/v1beta") || base.contains("/v1/") {
format!("{base}/models/{model}:streamGenerateContent?alt=sse")
} else {
format!("{base}/v1beta/models/{model}:streamGenerateContent?alt=sse")
};
// Gemini 原生请求体格式
let body = json!({
"model": model,
"messages": [{ "role": "user", "content": test_prompt }],
"max_tokens": 1,
"temperature": 0,
"stream": true
"contents": [{
"role": "user",
"parts": [{ "text": test_prompt }]
}]
});
let response = client
.post(&url)
.header("Authorization", format!("Bearer {}", auth.api_key))
.header("x-goog-api-key", &auth.api_key)
.header("Content-Type", "application/json")
.header("Accept", "text/event-stream")
.timeout(timeout)
.json(&body)
.send()
src-tauri/src/tray.rs
+157 -42
View File
@@ -15,6 +15,7 @@ pub struct TrayTexts {
pub show_main: &'static str,
pub no_provider_hint: &'static str,
pub quit: &'static str,
pub auto_label: &'static str,
}
impl TrayTexts {
@@ -24,17 +25,20 @@ impl TrayTexts {
show_main: "Open main window",
no_provider_hint: " (No providers yet, please add them from the main window)",
quit: "Quit",
auto_label: "Auto (Failover)",
},
"ja" => Self {
show_main: "メインウィンドウを開く",
no_provider_hint:
" (プロバイダーがまだありません。メイン画面から追加してください)",
quit: "終了",
auto_label: "自動 (フェイルオーバー)",
},
_ => Self {
show_main: "打开主界面",
no_provider_hint: " (无供应商，请在主界面添加)",
quit: "退出",
auto_label: "自动 (故障转移)",
},
}
}
@@ -50,6 +54,9 @@ pub struct TrayAppSection {
pub log_name: &'static str,
}
/// Auto 菜单项后缀
pub const AUTO_SUFFIX: &str = "auto";
pub const TRAY_SECTIONS: [TrayAppSection; 3] = [
TrayAppSection {
app_type: AppType::Claude,
@@ -84,6 +91,7 @@ fn append_provider_section<'a>(
manager: Option<&crate::provider::ProviderManager>,
section: &TrayAppSection,
tray_texts: &TrayTexts,
app_state: &AppState,
) -> Result<MenuBuilder<'a, tauri::Wry, tauri::AppHandle<tauri::Wry>>, AppError> {
let Some(manager) = manager else {
return Ok(menu_builder);
@@ -111,6 +119,23 @@ fn append_provider_section<'a>(
return Ok(menu_builder.item(&empty_hint));
}
// 获取 proxy 状态，决定 Auto 是否选中
let (proxy_enabled, auto_failover) =
app_state.db.get_proxy_flags_sync(section.app_type.as_str());
let auto_mode = proxy_enabled && auto_failover;
// 添加 Auto 菜单项（始终显示在供应商列表前）
let auto_item = CheckMenuItem::with_id(
app,
format!("{}{}", section.prefix, AUTO_SUFFIX),
tray_texts.auto_label,
true,
auto_mode,
None::<&str>,
)
.map_err(|e| AppError::Message(format!("创建{}Auto菜单项失败: {e}", section.log_name)))?;
menu_builder = menu_builder.item(&auto_item);
let mut sorted_providers: Vec<_> = manager.providers.iter().collect();
sorted_providers.sort_by(|(_, a), (_, b)| {
match (a.sort_index, b.sort_index) {
@@ -131,7 +156,8 @@ fn append_provider_section<'a>(
});
for (id, provider) in sorted_providers {
let is_current = manager.current == *id;
// Auto 模式下所有供应商都不选中
let is_current = !auto_mode && manager.current == *id;
let item = CheckMenuItem::with_id(
app,
format!("{}{}", section.prefix, id),
@@ -150,13 +176,27 @@ fn append_provider_section<'a>(
/// 处理供应商托盘事件
pub fn handle_provider_tray_event(app: &tauri::AppHandle, event_id: &str) -> bool {
for section in TRAY_SECTIONS.iter() {
if let Some(provider_id) = event_id.strip_prefix(section.prefix) {
log::info!("切换到{}供应商: {provider_id}", section.log_name);
if let Some(suffix) = event_id.strip_prefix(section.prefix) {
// 处理 Auto 点击
if suffix == AUTO_SUFFIX {
log::info!("切换到{} Auto模式", section.log_name);
let app_handle = app.clone();
let app_type = section.app_type.clone();
tauri::async_runtime::spawn_blocking(move || {
if let Err(e) = handle_auto_click(&app_handle, &app_type) {
log::error!("切换{}Auto模式失败: {e}", section.log_name);
}
});
return true;
}
// 处理供应商点击
log::info!("切换到{}供应商: {suffix}", section.log_name);
let app_handle = app.clone();
let provider_id = provider_id.to_string();
let provider_id = suffix.to_string();
let app_type = section.app_type.clone();
tauri::async_runtime::spawn_blocking(move || {
if let Err(e) = switch_provider_internal(&app_handle, app_type, provider_id) {
if let Err(e) = handle_provider_click(&app_handle, &app_type, &provider_id) {
log::error!("切换{}供应商失败: {e}", section.log_name);
}
});
@@ -166,6 +206,110 @@ pub fn handle_provider_tray_event(app: &tauri::AppHandle, event_id: &str) -> boo
false
}
/// 处理 Auto 点击：启用 proxy 和 auto_failover
fn handle_auto_click(app: &tauri::AppHandle, app_type: &AppType) -> Result<(), AppError> {
if let Some(app_state) = app.try_state::<AppState>() {
let app_type_str = app_type.as_str();
// 真正启用 failover：启动代理服务 + 执行接管 + 开启 auto_failover
let proxy_service = &app_state.proxy_service;
// 1) 确保代理服务运行（会自动设置 proxy_enabled = true）
let is_running = futures::executor::block_on(proxy_service.is_running());
if !is_running {
log::info!("[Tray] Auto 模式：启动代理服务");
if let Err(e) = futures::executor::block_on(proxy_service.start()) {
log::error!("[Tray] 启动代理服务失败: {e}");
return Err(AppError::Message(format!("启动代理服务失败: {e}")));
}
}
// 2) 执行 Live 配置接管（确保该 app 被代理接管）
log::info!("[Tray] Auto 模式：对 {app_type_str} 执行接管");
if let Err(e) =
futures::executor::block_on(proxy_service.set_takeover_for_app(app_type_str, true))
{
log::error!("[Tray] 执行接管失败: {e}");
return Err(AppError::Message(format!("执行接管失败: {e}")));
}
// 3) 设置 auto_failover_enabled = true
app_state
.db
.set_proxy_flags_sync(app_type_str, true, true)?;
// 4) 更新托盘菜单
if let Ok(new_menu) = create_tray_menu(app, app_state.inner()) {
if let Some(tray) = app.tray_by_id("main") {
let _ = tray.set_menu(Some(new_menu));
}
}
// 5) 发射事件到前端
let event_data = serde_json::json!({
"appType": app_type_str,
"proxyEnabled": true,
"autoFailoverEnabled": true
});
if let Err(e) = app.emit("proxy-flags-changed", event_data.clone()) {
log::error!("发射 proxy-flags-changed 事件失败: {e}");
}
// 发射 provider-switched 事件（保持向后兼容，Auto 切换也算一种切换）
if let Err(e) = app.emit("provider-switched", event_data) {
log::error!("发射 provider-switched 事件失败: {e}");
}
}
Ok(())
}
/// 处理供应商点击：关闭 auto_failover + 切换供应商
fn handle_provider_click(
app: &tauri::AppHandle,
app_type: &AppType,
provider_id: &str,
) -> Result<(), AppError> {
if let Some(app_state) = app.try_state::<AppState>() {
let app_type_str = app_type.as_str();
// 获取当前 proxy 状态，保持 enabled 不变，只关闭 auto_failover
let (proxy_enabled, _) = app_state.db.get_proxy_flags_sync(app_type_str);
app_state
.db
.set_proxy_flags_sync(app_type_str, proxy_enabled, false)?;
// 切换供应商
crate::commands::switch_provider(
app_state.clone(),
app_type_str.to_string(),
provider_id.to_string(),
)
.map_err(AppError::Message)?;
// 更新托盘菜单
if let Ok(new_menu) = create_tray_menu(app, app_state.inner()) {
if let Some(tray) = app.tray_by_id("main") {
let _ = tray.set_menu(Some(new_menu));
}
}
// 发射事件到前端
let event_data = serde_json::json!({
"appType": app_type_str,
"proxyEnabled": proxy_enabled,
"autoFailoverEnabled": false,
"providerId": provider_id
});
if let Err(e) = app.emit("proxy-flags-changed", event_data.clone()) {
log::error!("发射 proxy-flags-changed 事件失败: {e}");
}
// 发射 provider-switched 事件（保持向后兼容）
if let Err(e) = app.emit("provider-switched", event_data) {
log::error!("发射 provider-switched 事件失败: {e}");
}
}
Ok(())
}
/// 创建动态托盘菜单
pub fn create_tray_menu(
app: &tauri::AppHandle,
@@ -197,8 +341,14 @@ pub fn create_tray_menu(
current: current_id,
};
menu_builder =
append_provider_section(app, menu_builder, Some(&manager), section, &tray_texts)?;
menu_builder = append_provider_section(
app,
menu_builder,
Some(&manager),
section,
&tray_texts,
app_state,
)?;
}
// 分隔符和退出菜单
@@ -263,38 +413,3 @@ pub fn handle_tray_menu_event(app: &tauri::AppHandle, event_id: &str) {
}
}
}
/// 内部切换供应商函数
pub fn switch_provider_internal(
app: &tauri::AppHandle,
app_type: AppType,
provider_id: String,
) -> Result<(), AppError> {
if let Some(app_state) = app.try_state::<AppState>() {
// 在使用前先保存需要的值
let app_type_str = app_type.as_str().to_string();
let provider_id_clone = provider_id.clone();
crate::commands::switch_provider(app_state.clone(), app_type_str.clone(), provider_id)
.map_err(AppError::Message)?;
// 切换成功后重新创建托盘菜单
if let Ok(new_menu) = create_tray_menu(app, app_state.inner()) {
if let Some(tray) = app.tray_by_id("main") {
if let Err(e) = tray.set_menu(Some(new_menu)) {
log::error!("更新托盘菜单失败: {e}");
}
}
}
// 发射事件到前端，通知供应商已切换
let event_data = serde_json::json!({
"appType": app_type_str,
"providerId": provider_id_clone
});
if let Err(e) = app.emit("provider-switched", event_data) {
log::error!("发射供应商切换事件失败: {e}");
}
}
Ok(())
}