mirror of
https://github.com/farion1231/cc-switch.git
synced 2026-07-24 12:44:18 +08:00
makoMakoGo
1150 lines
38 KiB
Rust
1150 lines
38 KiB
Rust
use serde::{Deserialize, Serialize};
|
||
use std::fs;
|
||
use std::io::Write;
|
||
use std::path::PathBuf;
|
||
use std::sync::{OnceLock, RwLock};
|
||
|
||
use crate::app_config::AppType;
|
||
use crate::error::AppError;
|
||
use crate::services::skill::{SkillStorageLocation, SyncMethod};
|
||
|
||
/// 自定义端点配置（历史兼容，实际存储在 provider.meta.custom_endpoints）
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct CustomEndpoint {
|
||
pub url: String,
|
||
pub added_at: i64,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub last_used: Option<i64>,
|
||
}
|
||
|
||
fn default_true() -> bool {
|
||
true
|
||
}
|
||
|
||
/// 主页面显示的应用配置
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct VisibleApps {
|
||
#[serde(default = "default_true")]
|
||
pub claude: bool,
|
||
#[serde(
|
||
rename = "claude-desktop",
|
||
alias = "claudeDesktop",
|
||
alias = "claude_desktop",
|
||
default = "default_true"
|
||
)]
|
||
pub claude_desktop: bool,
|
||
#[serde(default = "default_true")]
|
||
pub codex: bool,
|
||
#[serde(default = "default_true")]
|
||
pub gemini: bool,
|
||
#[serde(default = "default_true")]
|
||
pub opencode: bool,
|
||
#[serde(default = "default_true")]
|
||
pub openclaw: bool,
|
||
#[serde(default)]
|
||
pub hermes: bool,
|
||
}
|
||
|
||
impl Default for VisibleApps {
|
||
fn default() -> Self {
|
||
Self {
|
||
claude: true,
|
||
claude_desktop: true,
|
||
codex: true,
|
||
gemini: true,
|
||
opencode: true,
|
||
openclaw: true,
|
||
hermes: false, // 默认不显示，需用户手动启用
|
||
}
|
||
}
|
||
}
|
||
|
||
impl VisibleApps {
|
||
/// Check if the specified app is visible
|
||
pub fn is_visible(&self, app: &AppType) -> bool {
|
||
match app {
|
||
AppType::Claude => self.claude,
|
||
AppType::ClaudeDesktop => self.claude_desktop,
|
||
AppType::Codex => self.codex,
|
||
AppType::Gemini => self.gemini,
|
||
AppType::OpenCode => self.opencode,
|
||
AppType::OpenClaw => self.openclaw,
|
||
AppType::Hermes => self.hermes,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// WebDAV 同步状态（持久化同步进度信息）
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct WebDavSyncStatus {
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub last_sync_at: Option<i64>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub last_error: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub last_error_source: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub last_remote_etag: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub last_local_manifest_hash: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub last_remote_manifest_hash: Option<String>,
|
||
}
|
||
|
||
fn default_remote_root() -> String {
|
||
"cc-switch-sync".to_string()
|
||
}
|
||
fn default_profile() -> String {
|
||
"default".to_string()
|
||
}
|
||
|
||
/// WebDAV 同步设置
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct WebDavSyncSettings {
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
#[serde(default)]
|
||
pub auto_sync: bool,
|
||
#[serde(default)]
|
||
pub base_url: String,
|
||
#[serde(default)]
|
||
pub username: String,
|
||
#[serde(default)]
|
||
pub password: String,
|
||
#[serde(default = "default_remote_root")]
|
||
pub remote_root: String,
|
||
#[serde(default = "default_profile")]
|
||
pub profile: String,
|
||
#[serde(default)]
|
||
pub status: WebDavSyncStatus,
|
||
}
|
||
|
||
impl Default for WebDavSyncSettings {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: false,
|
||
auto_sync: false,
|
||
base_url: String::new(),
|
||
username: String::new(),
|
||
password: String::new(),
|
||
remote_root: default_remote_root(),
|
||
profile: default_profile(),
|
||
status: WebDavSyncStatus::default(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl WebDavSyncSettings {
|
||
pub fn validate(&self) -> Result<(), crate::error::AppError> {
|
||
if self.base_url.trim().is_empty() {
|
||
return Err(crate::error::AppError::localized(
|
||
"webdav.base_url.required",
|
||
"WebDAV 地址不能为空",
|
||
"WebDAV URL is required.",
|
||
));
|
||
}
|
||
if self.username.trim().is_empty() {
|
||
return Err(crate::error::AppError::localized(
|
||
"webdav.username.required",
|
||
"WebDAV 用户名不能为空",
|
||
"WebDAV username is required.",
|
||
));
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
pub fn normalize(&mut self) {
|
||
self.base_url = self.base_url.trim().to_string();
|
||
self.username = self.username.trim().to_string();
|
||
self.remote_root = self.remote_root.trim().to_string();
|
||
self.profile = self.profile.trim().to_string();
|
||
if self.remote_root.is_empty() {
|
||
self.remote_root = default_remote_root();
|
||
}
|
||
if self.profile.is_empty() {
|
||
self.profile = default_profile();
|
||
}
|
||
}
|
||
|
||
/// Returns true if all credential fields are blank (no config to persist).
|
||
fn is_empty(&self) -> bool {
|
||
self.base_url.is_empty() && self.username.is_empty() && self.password.is_empty()
|
||
}
|
||
}
|
||
|
||
/// S3 同步设置
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct S3SyncSettings {
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
#[serde(default)]
|
||
pub auto_sync: bool,
|
||
#[serde(default)]
|
||
pub region: String,
|
||
#[serde(default)]
|
||
pub bucket: String,
|
||
#[serde(default)]
|
||
pub access_key_id: String,
|
||
#[serde(default)]
|
||
pub secret_access_key: String,
|
||
#[serde(default)]
|
||
pub endpoint: String,
|
||
#[serde(default = "default_remote_root")]
|
||
pub remote_root: String,
|
||
#[serde(default = "default_profile")]
|
||
pub profile: String,
|
||
#[serde(default)]
|
||
pub status: WebDavSyncStatus,
|
||
}
|
||
|
||
impl Default for S3SyncSettings {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: false,
|
||
auto_sync: false,
|
||
region: String::new(),
|
||
bucket: String::new(),
|
||
access_key_id: String::new(),
|
||
secret_access_key: String::new(),
|
||
endpoint: String::new(),
|
||
remote_root: default_remote_root(),
|
||
profile: default_profile(),
|
||
status: WebDavSyncStatus::default(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl S3SyncSettings {
|
||
pub fn validate(&self) -> Result<(), crate::error::AppError> {
|
||
if self.bucket.trim().is_empty() {
|
||
return Err(crate::error::AppError::localized(
|
||
"s3.bucket.required",
|
||
"S3 存储桶不能为空",
|
||
"S3 bucket is required.",
|
||
));
|
||
}
|
||
if self.region.trim().is_empty() {
|
||
return Err(crate::error::AppError::localized(
|
||
"s3.region.required",
|
||
"S3 区域不能为空",
|
||
"S3 region is required.",
|
||
));
|
||
}
|
||
if self.access_key_id.trim().is_empty() {
|
||
return Err(crate::error::AppError::localized(
|
||
"s3.access_key_id.required",
|
||
"S3 Access Key ID 不能为空",
|
||
"S3 Access Key ID is required.",
|
||
));
|
||
}
|
||
if self.secret_access_key.trim().is_empty() {
|
||
return Err(crate::error::AppError::localized(
|
||
"s3.secret_access_key.required",
|
||
"S3 Secret Access Key 不能为空",
|
||
"S3 Secret Access Key is required.",
|
||
));
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
pub fn normalize(&mut self) {
|
||
self.region = self.region.trim().to_string();
|
||
self.bucket = self.bucket.trim().to_string();
|
||
self.access_key_id = self.access_key_id.trim().to_string();
|
||
self.endpoint = self.endpoint.trim().to_string();
|
||
self.remote_root = self.remote_root.trim().to_string();
|
||
self.profile = self.profile.trim().to_string();
|
||
if self.remote_root.is_empty() {
|
||
self.remote_root = default_remote_root();
|
||
}
|
||
if self.profile.is_empty() {
|
||
self.profile = default_profile();
|
||
}
|
||
}
|
||
|
||
/// Returns true if all credential fields are blank (no config to persist).
|
||
fn is_empty(&self) -> bool {
|
||
self.bucket.is_empty()
|
||
&& self.region.is_empty()
|
||
&& self.access_key_id.is_empty()
|
||
&& self.secret_access_key.is_empty()
|
||
}
|
||
}
|
||
|
||
/// 本机自动迁移状态。
|
||
///
|
||
/// 这里记录的是本机启动时执行过的一次性迁移；标记不随数据库同步。
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct LocalMigrations {
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub codex_third_party_history_provider_bucket_v1:
|
||
Option<CodexThirdPartyHistoryProviderBucketMigration>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub codex_provider_template_v1: Option<CodexProviderTemplateMigration>,
|
||
/// 统一会话开关的官方历史迁移标记。开关关闭时会被清除，
|
||
/// 这样重新开启能把"关闭期间"落入 openai 桶的官方会话补迁进来。
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub codex_official_history_unify_v1: Option<CodexOfficialHistoryUnifyMigration>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct CodexThirdPartyHistoryProviderBucketMigration {
|
||
pub completed_at: String,
|
||
pub target_provider_id: String,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub source_provider_ids: Vec<String>,
|
||
#[serde(default)]
|
||
pub migrated_jsonl_files: usize,
|
||
#[serde(default)]
|
||
pub migrated_state_rows: usize,
|
||
#[serde(default)]
|
||
pub scanned_history_files: bool,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct CodexProviderTemplateMigration {
|
||
pub completed_at: String,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub migrated_provider_ids: Vec<String>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct CodexOfficialHistoryUnifyMigration {
|
||
pub completed_at: String,
|
||
pub target_provider_id: String,
|
||
#[serde(default)]
|
||
pub migrated_jsonl_files: usize,
|
||
#[serde(default)]
|
||
pub migrated_state_rows: usize,
|
||
/// 迁移时的规范化 Codex 目录。标记只对同一目录生效：
|
||
/// 切换 codex_config_dir 后旧标记不会挡住新目录的迁移。
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub codex_config_dir: Option<String>,
|
||
}
|
||
|
||
/// 应用设置结构
|
||
///
|
||
/// 存储设备级别设置，保存在本地 `~/.cc-switch/settings.json`，不随数据库同步。
|
||
/// 这确保了云同步场景下多设备可以独立运作。
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct AppSettings {
|
||
// ===== 设备级 UI 设置 =====
|
||
#[serde(default = "default_show_in_tray")]
|
||
pub show_in_tray: bool,
|
||
#[serde(default = "default_minimize_to_tray_on_close")]
|
||
pub minimize_to_tray_on_close: bool,
|
||
#[serde(default)]
|
||
pub use_app_window_controls: bool,
|
||
/// 是否启用 Claude 插件联动
|
||
#[serde(default)]
|
||
pub enable_claude_plugin_integration: bool,
|
||
/// 是否跳过 Claude Code 初次安装确认
|
||
#[serde(default)]
|
||
pub skip_claude_onboarding: bool,
|
||
/// 是否开机自启
|
||
#[serde(default)]
|
||
pub launch_on_startup: bool,
|
||
/// 静默启动（程序启动时不显示主窗口，仅托盘运行）
|
||
#[serde(default)]
|
||
pub silent_startup: bool,
|
||
/// 是否在主页面启用本地代理功能（默认关闭）
|
||
#[serde(default)]
|
||
pub enable_local_proxy: bool,
|
||
/// User has confirmed the local proxy first-run notice
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub proxy_confirmed: Option<bool>,
|
||
/// User has confirmed the usage query first-run notice
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub usage_confirmed: Option<bool>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub usage_dashboard_refresh_interval_ms: Option<u32>,
|
||
/// User has confirmed the stream check first-run notice
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub stream_check_confirmed: Option<bool>,
|
||
/// Whether to show the failover toggle independently on the main page
|
||
#[serde(default)]
|
||
pub enable_failover_toggle: bool,
|
||
/// Keep Codex ChatGPT login material in auth.json when switching to third-party providers.
|
||
/// Opt-in: defaults to false so third-party switches cleanly overwrite auth.json.
|
||
#[serde(default)]
|
||
pub preserve_codex_official_auth_on_switch: bool,
|
||
/// Run official Codex providers under the shared "custom" model_provider id
|
||
/// so official sessions share one resume-history bucket with third-party
|
||
/// providers. Opt-in: defaults to false.
|
||
#[serde(default)]
|
||
pub unify_codex_session_history: bool,
|
||
/// User opted in (via the enable dialog checkbox) to migrate existing
|
||
/// official sessions ("openai" bucket) into the shared bucket. Persisted so
|
||
/// a failed migration retries at startup; cleared when the toggle turns off.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub unify_codex_migrate_existing: Option<bool>,
|
||
/// User has confirmed the failover toggle first-run notice
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub failover_confirmed: Option<bool>,
|
||
/// User has confirmed the first-run welcome notice
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub first_run_notice_confirmed: Option<bool>,
|
||
/// User has confirmed the common config first-run notice
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub common_config_confirmed: Option<bool>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub language: Option<String>,
|
||
|
||
// ===== 主页面显示的应用 =====
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub visible_apps: Option<VisibleApps>,
|
||
|
||
// ===== 设备级目录覆盖 =====
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub claude_config_dir: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub codex_config_dir: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub gemini_config_dir: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub opencode_config_dir: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub openclaw_config_dir: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub hermes_config_dir: Option<String>,
|
||
|
||
// ===== 当前供应商 ID（设备级）=====
|
||
/// 当前 Claude 供应商 ID（本地存储，优先于数据库 is_current）
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub current_provider_claude: Option<String>,
|
||
/// 当前 Claude Desktop 供应商 ID（本地存储，优先于数据库 is_current）
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub current_provider_claude_desktop: Option<String>,
|
||
/// 当前 Codex 供应商 ID（本地存储，优先于数据库 is_current）
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub current_provider_codex: Option<String>,
|
||
/// 当前 Gemini 供应商 ID（本地存储，优先于数据库 is_current）
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub current_provider_gemini: Option<String>,
|
||
/// 当前 OpenCode 供应商 ID（本地存储，对 OpenCode 可能无意义，但保持结构一致）
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub current_provider_opencode: Option<String>,
|
||
/// 当前 OpenClaw 供应商 ID（本地存储，对 OpenClaw 可能无意义，但保持结构一致）
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub current_provider_openclaw: Option<String>,
|
||
/// 当前 Hermes 供应商 ID（本地存储，保持结构一致）
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub current_provider_hermes: Option<String>,
|
||
|
||
// ===== Skill 同步设置 =====
|
||
/// Skill 同步方式：auto（默认，优先 symlink）、symlink、copy
|
||
#[serde(default)]
|
||
pub skill_sync_method: SyncMethod,
|
||
/// Skill 存储位置：cc_switch（默认）或 unified（~/.agents/skills/）
|
||
#[serde(default)]
|
||
pub skill_storage_location: SkillStorageLocation,
|
||
|
||
// ===== WebDAV 同步设置 =====
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub webdav_sync: Option<WebDavSyncSettings>,
|
||
|
||
// ===== S3 同步设置 =====
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub s3_sync: Option<S3SyncSettings>,
|
||
|
||
// ===== WebDAV 备份设置（旧版，保留向后兼容）=====
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub webdav_backup: Option<serde_json::Value>,
|
||
|
||
// ===== 备份策略设置 =====
|
||
/// Auto-backup interval in hours (default 24, 0 = disabled)
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub backup_interval_hours: Option<u32>,
|
||
/// Maximum number of backup files to retain (default 10)
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub backup_retain_count: Option<u32>,
|
||
|
||
// ===== 终端设置 =====
|
||
/// 首选终端应用（可选，默认使用系统默认终端）
|
||
/// - macOS: "terminal" | "iterm2" | "warp" | "alacritty" | "kitty" | "ghostty" | "wezterm" | "kaku"
|
||
/// - Windows: "cmd" | "powershell" | "wt" (Windows Terminal)
|
||
/// - Linux: "gnome-terminal" | "konsole" | "xfce4-terminal" | "alacritty" | "kitty" | "ghostty"
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub preferred_terminal: Option<String>,
|
||
|
||
// ===== 本机自动迁移状态 =====
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub local_migrations: Option<LocalMigrations>,
|
||
}
|
||
|
||
fn default_show_in_tray() -> bool {
|
||
true
|
||
}
|
||
|
||
fn default_minimize_to_tray_on_close() -> bool {
|
||
true
|
||
}
|
||
|
||
impl Default for AppSettings {
|
||
fn default() -> Self {
|
||
Self {
|
||
show_in_tray: true,
|
||
minimize_to_tray_on_close: true,
|
||
use_app_window_controls: false,
|
||
enable_claude_plugin_integration: false,
|
||
skip_claude_onboarding: false,
|
||
launch_on_startup: false,
|
||
silent_startup: false,
|
||
enable_local_proxy: false,
|
||
proxy_confirmed: None,
|
||
usage_confirmed: None,
|
||
usage_dashboard_refresh_interval_ms: None,
|
||
stream_check_confirmed: None,
|
||
enable_failover_toggle: false,
|
||
preserve_codex_official_auth_on_switch: false,
|
||
unify_codex_session_history: false,
|
||
unify_codex_migrate_existing: None,
|
||
failover_confirmed: None,
|
||
first_run_notice_confirmed: None,
|
||
common_config_confirmed: None,
|
||
language: None,
|
||
visible_apps: None,
|
||
claude_config_dir: None,
|
||
codex_config_dir: None,
|
||
gemini_config_dir: None,
|
||
opencode_config_dir: None,
|
||
openclaw_config_dir: None,
|
||
hermes_config_dir: None,
|
||
current_provider_claude: None,
|
||
current_provider_claude_desktop: None,
|
||
current_provider_codex: None,
|
||
current_provider_gemini: None,
|
||
current_provider_opencode: None,
|
||
current_provider_openclaw: None,
|
||
current_provider_hermes: None,
|
||
skill_sync_method: SyncMethod::default(),
|
||
skill_storage_location: SkillStorageLocation::default(),
|
||
webdav_sync: None,
|
||
s3_sync: None,
|
||
webdav_backup: None,
|
||
backup_interval_hours: None,
|
||
backup_retain_count: None,
|
||
preferred_terminal: None,
|
||
local_migrations: None,
|
||
}
|
||
}
|
||
}
|
||
|
||
impl AppSettings {
|
||
fn settings_path() -> Option<PathBuf> {
|
||
// settings.json 保留用于旧版本迁移和无数据库场景
|
||
Some(
|
||
crate::config::get_home_dir()
|
||
.join(".cc-switch")
|
||
.join("settings.json"),
|
||
)
|
||
}
|
||
|
||
fn normalize_paths(&mut self) {
|
||
self.claude_config_dir = self
|
||
.claude_config_dir
|
||
.as_ref()
|
||
.map(|s| s.trim())
|
||
.filter(|s| !s.is_empty())
|
||
.map(|s| s.to_string());
|
||
|
||
self.codex_config_dir = self
|
||
.codex_config_dir
|
||
.as_ref()
|
||
.map(|s| s.trim())
|
||
.filter(|s| !s.is_empty())
|
||
.map(|s| s.to_string());
|
||
|
||
self.gemini_config_dir = self
|
||
.gemini_config_dir
|
||
.as_ref()
|
||
.map(|s| s.trim())
|
||
.filter(|s| !s.is_empty())
|
||
.map(|s| s.to_string());
|
||
|
||
self.opencode_config_dir = self
|
||
.opencode_config_dir
|
||
.as_ref()
|
||
.map(|s| s.trim())
|
||
.filter(|s| !s.is_empty())
|
||
.map(|s| s.to_string());
|
||
|
||
self.openclaw_config_dir = self
|
||
.openclaw_config_dir
|
||
.as_ref()
|
||
.map(|s| s.trim())
|
||
.filter(|s| !s.is_empty())
|
||
.map(|s| s.to_string());
|
||
|
||
self.hermes_config_dir = self
|
||
.hermes_config_dir
|
||
.as_ref()
|
||
.map(|s| s.trim())
|
||
.filter(|s| !s.is_empty())
|
||
.map(|s| s.to_string());
|
||
|
||
self.language = self
|
||
.language
|
||
.as_ref()
|
||
.map(|s| s.trim())
|
||
.filter(|s| matches!(*s, "en" | "zh" | "zh-TW" | "ja"))
|
||
.map(|s| s.to_string());
|
||
|
||
if let Some(sync) = &mut self.webdav_sync {
|
||
sync.normalize();
|
||
if sync.is_empty() {
|
||
self.webdav_sync = None;
|
||
}
|
||
}
|
||
|
||
if let Some(s3) = &mut self.s3_sync {
|
||
s3.normalize();
|
||
if s3.is_empty() {
|
||
self.s3_sync = None;
|
||
}
|
||
}
|
||
}
|
||
|
||
fn load_from_file() -> Self {
|
||
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) => {
|
||
settings.normalize_paths();
|
||
settings
|
||
}
|
||
Err(err) => {
|
||
log::warn!(
|
||
"解析设置文件失败，将使用默认设置。路径: {}, 错误: {}",
|
||
path.display(),
|
||
err
|
||
);
|
||
Self::default()
|
||
}
|
||
}
|
||
} else {
|
||
Self::default()
|
||
}
|
||
}
|
||
}
|
||
|
||
fn save_settings_file(settings: &AppSettings) -> Result<(), AppError> {
|
||
let mut normalized = settings.clone();
|
||
normalized.normalize_paths();
|
||
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))?;
|
||
}
|
||
|
||
let json = serde_json::to_string_pretty(&normalized)
|
||
.map_err(|e| AppError::JsonSerialize { source: e })?;
|
||
#[cfg(unix)]
|
||
{
|
||
use std::fs::OpenOptions;
|
||
use std::os::unix::fs::OpenOptionsExt;
|
||
|
||
let mut file = OpenOptions::new()
|
||
.create(true)
|
||
.write(true)
|
||
.truncate(true)
|
||
.mode(0o600)
|
||
.open(&path)
|
||
.map_err(|e| AppError::io(&path, e))?;
|
||
file.write_all(json.as_bytes())
|
||
.map_err(|e| AppError::io(&path, e))?;
|
||
}
|
||
|
||
#[cfg(not(unix))]
|
||
{
|
||
fs::write(&path, json).map_err(|e| AppError::io(&path, e))?;
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
static SETTINGS_STORE: OnceLock<RwLock<AppSettings>> = OnceLock::new();
|
||
|
||
fn settings_store() -> &'static RwLock<AppSettings> {
|
||
SETTINGS_STORE.get_or_init(|| RwLock::new(AppSettings::load_from_file()))
|
||
}
|
||
|
||
fn resolve_override_path(raw: &str) -> PathBuf {
|
||
if raw == "~" {
|
||
if let Some(home) = dirs::home_dir() {
|
||
return home;
|
||
}
|
||
} else if let Some(stripped) = raw.strip_prefix("~/") {
|
||
if let Some(home) = dirs::home_dir() {
|
||
return home.join(stripped);
|
||
}
|
||
} else if let Some(stripped) = raw.strip_prefix("~\\") {
|
||
if let Some(home) = dirs::home_dir() {
|
||
return home.join(stripped);
|
||
}
|
||
}
|
||
|
||
PathBuf::from(raw)
|
||
}
|
||
|
||
pub fn get_settings() -> AppSettings {
|
||
settings_store()
|
||
.read()
|
||
.unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
})
|
||
.clone()
|
||
}
|
||
|
||
pub fn get_settings_for_frontend() -> AppSettings {
|
||
let mut settings = get_settings();
|
||
if let Some(sync) = &mut settings.webdav_sync {
|
||
sync.password.clear();
|
||
}
|
||
if let Some(s3) = &mut settings.s3_sync {
|
||
s3.secret_access_key.clear();
|
||
}
|
||
settings.webdav_backup = None;
|
||
settings
|
||
}
|
||
|
||
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().unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
});
|
||
*guard = new_settings;
|
||
Ok(())
|
||
}
|
||
|
||
fn mutate_settings<F>(mutator: F) -> Result<(), AppError>
|
||
where
|
||
F: FnOnce(&mut AppSettings),
|
||
{
|
||
let mut guard = settings_store().write().unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
});
|
||
let mut next = guard.clone();
|
||
mutator(&mut next);
|
||
next.normalize_paths();
|
||
save_settings_file(&next)?;
|
||
*guard = next;
|
||
Ok(())
|
||
}
|
||
|
||
pub fn is_codex_third_party_history_provider_bucket_migrated() -> bool {
|
||
get_settings()
|
||
.local_migrations
|
||
.as_ref()
|
||
.and_then(|migrations| {
|
||
migrations
|
||
.codex_third_party_history_provider_bucket_v1
|
||
.as_ref()
|
||
})
|
||
.is_some_and(|m| m.scanned_history_files)
|
||
}
|
||
|
||
pub fn mark_codex_third_party_history_provider_bucket_migrated(
|
||
migration: CodexThirdPartyHistoryProviderBucketMigration,
|
||
) -> Result<(), AppError> {
|
||
mutate_settings(|settings| {
|
||
let migrations = settings
|
||
.local_migrations
|
||
.get_or_insert_with(Default::default);
|
||
migrations.codex_third_party_history_provider_bucket_v1 = Some(migration);
|
||
})
|
||
}
|
||
|
||
pub fn is_codex_provider_template_migrated() -> bool {
|
||
get_settings()
|
||
.local_migrations
|
||
.as_ref()
|
||
.and_then(|migrations| migrations.codex_provider_template_v1.as_ref())
|
||
.is_some()
|
||
}
|
||
|
||
pub fn mark_codex_provider_template_migrated(
|
||
migration: CodexProviderTemplateMigration,
|
||
) -> Result<(), AppError> {
|
||
mutate_settings(|settings| {
|
||
let migrations = settings
|
||
.local_migrations
|
||
.get_or_insert_with(Default::default);
|
||
migrations.codex_provider_template_v1 = Some(migration);
|
||
})
|
||
}
|
||
|
||
/// 统一会话迁移标记是否覆盖指定目录。标记里没记目录（不应出现的旧格式）
|
||
/// 视为不匹配——重跑迁移是幂等的，宁可重迁也不漏迁。
|
||
pub fn is_codex_official_history_unify_migrated_for_dir(codex_dir: &str) -> bool {
|
||
get_settings()
|
||
.local_migrations
|
||
.as_ref()
|
||
.and_then(|migrations| migrations.codex_official_history_unify_v1.as_ref())
|
||
.is_some_and(|migration| migration.codex_config_dir.as_deref() == Some(codex_dir))
|
||
}
|
||
|
||
/// 条件写入迁移完成标记：仅当此刻开关仍开启且迁移意愿仍在时才写。
|
||
/// 检查与写入在 settings 写锁内原子完成，与关闭开关路径
|
||
/// （`update_settings` / 清标记）串行，消除"迁移线程复查开关后、写标记前
|
||
/// 用户恰好关闭开关"的竞态窗口。返回是否实际写入。
|
||
pub fn mark_codex_official_history_unify_migrated_if_enabled(
|
||
migration: CodexOfficialHistoryUnifyMigration,
|
||
) -> Result<bool, AppError> {
|
||
let mut written = false;
|
||
mutate_settings(|settings| {
|
||
if settings.unify_codex_session_history
|
||
&& settings.unify_codex_migrate_existing.unwrap_or(false)
|
||
{
|
||
settings
|
||
.local_migrations
|
||
.get_or_insert_with(Default::default)
|
||
.codex_official_history_unify_v1 = Some(migration);
|
||
written = true;
|
||
}
|
||
})?;
|
||
Ok(written)
|
||
}
|
||
|
||
pub fn clear_codex_official_history_unify_migration() -> Result<(), AppError> {
|
||
mutate_settings(|settings| {
|
||
if let Some(migrations) = settings.local_migrations.as_mut() {
|
||
migrations.codex_official_history_unify_v1 = None;
|
||
}
|
||
})
|
||
}
|
||
|
||
pub fn unify_codex_migrate_existing_requested() -> bool {
|
||
get_settings().unify_codex_migrate_existing.unwrap_or(false)
|
||
}
|
||
|
||
pub fn clear_codex_unify_migrate_existing() -> Result<(), AppError> {
|
||
mutate_settings(|settings| {
|
||
settings.unify_codex_migrate_existing = None;
|
||
})
|
||
}
|
||
|
||
/// 从文件重新加载设置到内存缓存
|
||
/// 用于导入配置等场景，确保内存缓存与文件同步
|
||
pub fn reload_settings() -> Result<(), AppError> {
|
||
let fresh_settings = AppSettings::load_from_file();
|
||
let mut guard = settings_store().write().unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
});
|
||
*guard = fresh_settings;
|
||
Ok(())
|
||
}
|
||
|
||
pub fn get_claude_override_dir() -> Option<PathBuf> {
|
||
let settings = settings_store().read().ok()?;
|
||
settings
|
||
.claude_config_dir
|
||
.as_ref()
|
||
.map(|p| resolve_override_path(p))
|
||
}
|
||
|
||
pub fn get_codex_override_dir() -> Option<PathBuf> {
|
||
let settings = settings_store().read().ok()?;
|
||
settings
|
||
.codex_config_dir
|
||
.as_ref()
|
||
.map(|p| resolve_override_path(p))
|
||
}
|
||
|
||
pub fn get_gemini_override_dir() -> Option<PathBuf> {
|
||
let settings = settings_store().read().ok()?;
|
||
settings
|
||
.gemini_config_dir
|
||
.as_ref()
|
||
.map(|p| resolve_override_path(p))
|
||
}
|
||
|
||
pub fn get_opencode_override_dir() -> Option<PathBuf> {
|
||
let settings = settings_store().read().ok()?;
|
||
settings
|
||
.opencode_config_dir
|
||
.as_ref()
|
||
.map(|p| resolve_override_path(p))
|
||
}
|
||
|
||
pub fn get_openclaw_override_dir() -> Option<PathBuf> {
|
||
let settings = settings_store().read().ok()?;
|
||
settings
|
||
.openclaw_config_dir
|
||
.as_ref()
|
||
.map(|p| resolve_override_path(p))
|
||
}
|
||
|
||
pub fn get_hermes_override_dir() -> Option<PathBuf> {
|
||
let settings = settings_store().read().ok()?;
|
||
settings
|
||
.hermes_config_dir
|
||
.as_ref()
|
||
.map(|p| resolve_override_path(p))
|
||
}
|
||
|
||
pub fn preserve_codex_official_auth_on_switch() -> bool {
|
||
settings_store()
|
||
.read()
|
||
.unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
})
|
||
.preserve_codex_official_auth_on_switch
|
||
}
|
||
|
||
pub fn unify_codex_session_history() -> bool {
|
||
settings_store()
|
||
.read()
|
||
.unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
})
|
||
.unify_codex_session_history
|
||
}
|
||
|
||
// ===== 当前供应商管理函数 =====
|
||
|
||
/// 获取指定应用类型的当前供应商 ID（从本地 settings 读取）
|
||
///
|
||
/// 这是设备级别的设置，不随数据库同步。
|
||
/// 如果本地没有设置，调用者应该 fallback 到数据库的 `is_current` 字段。
|
||
pub fn get_current_provider(app_type: &AppType) -> Option<String> {
|
||
let settings = settings_store().read().ok()?;
|
||
match app_type {
|
||
AppType::Claude => settings.current_provider_claude.clone(),
|
||
AppType::ClaudeDesktop => settings.current_provider_claude_desktop.clone(),
|
||
AppType::Codex => settings.current_provider_codex.clone(),
|
||
AppType::Gemini => settings.current_provider_gemini.clone(),
|
||
AppType::OpenCode => settings.current_provider_opencode.clone(),
|
||
AppType::OpenClaw => settings.current_provider_openclaw.clone(),
|
||
AppType::Hermes => settings.current_provider_hermes.clone(),
|
||
}
|
||
}
|
||
|
||
/// 设置指定应用类型的当前供应商 ID（保存到本地 settings）
|
||
///
|
||
/// 这是设备级别的设置，不随数据库同步。
|
||
/// 传入 `None` 会清除当前供应商设置。
|
||
pub fn set_current_provider(app_type: &AppType, id: Option<&str>) -> Result<(), AppError> {
|
||
let id_owned = id.map(|s| s.to_string());
|
||
mutate_settings(|settings| match app_type {
|
||
AppType::Claude => settings.current_provider_claude = id_owned.clone(),
|
||
AppType::ClaudeDesktop => settings.current_provider_claude_desktop = id_owned.clone(),
|
||
AppType::Codex => settings.current_provider_codex = id_owned.clone(),
|
||
AppType::Gemini => settings.current_provider_gemini = id_owned.clone(),
|
||
AppType::OpenCode => settings.current_provider_opencode = id_owned.clone(),
|
||
AppType::OpenClaw => settings.current_provider_openclaw = id_owned.clone(),
|
||
AppType::Hermes => settings.current_provider_hermes = id_owned.clone(),
|
||
})
|
||
}
|
||
|
||
/// 获取有效的当前供应商 ID（验证存在性）
|
||
///
|
||
/// 逻辑：
|
||
/// 1. 从本地 settings 读取当前供应商 ID
|
||
/// 2. 验证该 ID 在数据库中存在
|
||
/// 3. 如果不存在则清理本地 settings，fallback 到数据库的 is_current
|
||
///
|
||
/// 这确保了返回的 ID 一定是有效的（在数据库中存在）。
|
||
/// 多设备云同步场景下，配置导入后本地 ID 可能失效，此函数会自动修复。
|
||
pub fn get_effective_current_provider(
|
||
db: &crate::database::Database,
|
||
app_type: &AppType,
|
||
) -> Result<Option<String>, AppError> {
|
||
// 1. 从本地 settings 读取
|
||
if let Some(local_id) = get_current_provider(app_type) {
|
||
// 2. 验证该 ID 在数据库中存在
|
||
let providers = db.get_all_providers(app_type.as_str())?;
|
||
if providers.contains_key(&local_id) {
|
||
// 存在，直接返回
|
||
return Ok(Some(local_id));
|
||
}
|
||
|
||
// 3. 不存在，清理本地 settings
|
||
log::warn!(
|
||
"本地 settings 中的供应商 {} ({}) 在数据库中不存在，将清理并 fallback 到数据库",
|
||
local_id,
|
||
app_type.as_str()
|
||
);
|
||
let _ = set_current_provider(app_type, None);
|
||
}
|
||
|
||
// Fallback 到数据库的 is_current
|
||
db.get_current_provider(app_type.as_str())
|
||
}
|
||
|
||
// ===== Skill 同步方式管理函数 =====
|
||
|
||
/// 获取 Skill 同步方式配置
|
||
pub fn get_skill_sync_method() -> SyncMethod {
|
||
settings_store()
|
||
.read()
|
||
.unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
})
|
||
.skill_sync_method
|
||
}
|
||
|
||
// ===== Skill 存储位置管理函数 =====
|
||
|
||
/// 获取 Skill 存储位置配置
|
||
pub fn get_skill_storage_location() -> SkillStorageLocation {
|
||
settings_store()
|
||
.read()
|
||
.unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
})
|
||
.skill_storage_location
|
||
}
|
||
|
||
/// 设置 Skill 存储位置
|
||
pub fn set_skill_storage_location(location: SkillStorageLocation) -> Result<(), AppError> {
|
||
mutate_settings(|s| {
|
||
s.skill_storage_location = location;
|
||
})
|
||
}
|
||
|
||
// ===== 备份策略管理函数 =====
|
||
|
||
/// Get the effective auto-backup interval in hours (default 24)
|
||
pub fn effective_backup_interval_hours() -> u32 {
|
||
settings_store()
|
||
.read()
|
||
.unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
})
|
||
.backup_interval_hours
|
||
.unwrap_or(24)
|
||
}
|
||
|
||
/// Get the effective backup retain count (default 10, minimum 1)
|
||
pub fn effective_backup_retain_count() -> usize {
|
||
settings_store()
|
||
.read()
|
||
.unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
})
|
||
.backup_retain_count
|
||
.map(|n| (n as usize).max(1))
|
||
.unwrap_or(10)
|
||
}
|
||
|
||
// ===== 终端设置管理函数 =====
|
||
|
||
/// 获取首选终端应用
|
||
pub fn get_preferred_terminal() -> Option<String> {
|
||
settings_store()
|
||
.read()
|
||
.unwrap_or_else(|e| {
|
||
log::warn!("设置锁已毒化，使用恢复值: {e}");
|
||
e.into_inner()
|
||
})
|
||
.preferred_terminal
|
||
.clone()
|
||
}
|
||
|
||
// ===== WebDAV 同步设置管理函数 =====
|
||
|
||
/// 获取 WebDAV 同步设置
|
||
pub fn get_webdav_sync_settings() -> Option<WebDavSyncSettings> {
|
||
settings_store().read().ok()?.webdav_sync.clone()
|
||
}
|
||
|
||
/// 保存 WebDAV 同步设置
|
||
pub fn set_webdav_sync_settings(settings: Option<WebDavSyncSettings>) -> Result<(), AppError> {
|
||
mutate_settings(|current| {
|
||
current.webdav_sync = settings;
|
||
})
|
||
}
|
||
|
||
/// 仅更新 WebDAV 同步状态，避免覆写 credentials/root/profile 等字段
|
||
pub fn update_webdav_sync_status(status: WebDavSyncStatus) -> Result<(), AppError> {
|
||
mutate_settings(|current| {
|
||
if let Some(sync) = current.webdav_sync.as_mut() {
|
||
sync.status = status;
|
||
}
|
||
})
|
||
}
|
||
|
||
// ===== S3 同步设置管理函数 =====
|
||
|
||
pub fn get_s3_sync_settings() -> Option<S3SyncSettings> {
|
||
settings_store().read().ok()?.s3_sync.clone()
|
||
}
|
||
|
||
pub fn set_s3_sync_settings(settings: Option<S3SyncSettings>) -> Result<(), AppError> {
|
||
mutate_settings(|current| {
|
||
current.s3_sync = settings;
|
||
})
|
||
}
|
||
|
||
pub fn update_s3_sync_status(status: WebDavSyncStatus) -> Result<(), AppError> {
|
||
mutate_settings(|current| {
|
||
if let Some(s3) = current.s3_sync.as_mut() {
|
||
s3.status = status;
|
||
}
|
||
})
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use crate::app_config::AppType;
|
||
|
||
#[test]
|
||
fn visible_apps_old_settings_default_claude_desktop_visible() {
|
||
let visible: VisibleApps = serde_json::from_value(serde_json::json!({
|
||
"claude": true,
|
||
"codex": true,
|
||
"gemini": true,
|
||
"opencode": true,
|
||
"openclaw": true,
|
||
"hermes": true
|
||
}))
|
||
.expect("visible apps");
|
||
|
||
assert!(visible.is_visible(&AppType::ClaudeDesktop));
|
||
}
|
||
|
||
#[test]
|
||
fn visible_apps_accepts_claude_desktop_aliases() {
|
||
let visible: VisibleApps = serde_json::from_value(serde_json::json!({
|
||
"claude": true,
|
||
"claudeDesktop": false,
|
||
"codex": true,
|
||
"gemini": true,
|
||
"opencode": true,
|
||
"openclaw": true,
|
||
"hermes": true
|
||
}))
|
||
.expect("visible apps");
|
||
|
||
assert!(!visible.is_visible(&AppType::ClaudeDesktop));
|
||
}
|
||
}
|