Feat/auto failover (#367)

* feat(db): add circuit breaker config table and provider proxy target APIs

Add database support for auto-failover feature:

- Add circuit_breaker_config table for storing failover thresholds
- Add get/update_circuit_breaker_config methods in proxy DAO
- Add reset_provider_health method for manual recovery
- Add set_proxy_target and get_proxy_targets methods in providers DAO
  for managing multi-provider failover configuration

* feat(proxy): implement circuit breaker and provider router for auto-failover

Add core failover logic:

- CircuitBreaker: Tracks provider health with three states:
  - Closed: Normal operation, requests pass through
  - Open: Circuit broken after consecutive failures, skip provider
  - HalfOpen: Testing recovery with limited requests
- ProviderRouter: Routes requests across multiple providers with:
  - Health tracking and automatic failover
  - Configurable failure/success thresholds
  - Auto-disable proxy target after reaching failure threshold
  - Support for manual circuit breaker reset
- Export new types in proxy module

* feat(proxy): add failover Tauri commands and integrate with forwarder

Expose failover functionality to frontend:

- Add Tauri commands: get_proxy_targets, set_proxy_target,
  get_provider_health, reset_circuit_breaker,
  get/update_circuit_breaker_config, get_circuit_breaker_stats
- Register all new commands in lib.rs invoke handler
- Update forwarder with improved error handling and logging
- Integrate ProviderRouter with proxy server startup
- Add provider health tracking in request handlers

* feat(frontend): add failover API layer and TanStack Query hooks

Add frontend data layer for failover management:

- Add failover.ts API: Tauri invoke wrappers for all failover commands
- Add failover.ts query hooks: TanStack Query mutations and queries
  - useProxyTargets, useProviderHealth queries
  - useSetProxyTarget, useResetCircuitBreaker mutations
  - useCircuitBreakerConfig query and mutation
- Update queries.ts with provider health query key
- Update mutations.ts to invalidate health on provider changes
- Add CircuitBreakerConfig and ProviderHealth types

* feat(ui): add auto-failover configuration UI and provider health display

Add comprehensive UI for failover management:

Components:
- ProviderHealthBadge: Display provider health status with color coding
- CircuitBreakerConfigPanel: Configure failure/success thresholds,
  timeout duration, and error rate limits
- AutoFailoverConfigPanel: Manage proxy targets with drag-and-drop
  priority ordering and individual enable/disable controls
- ProxyPanel: Integrate failover tabs for unified proxy management

Provider enhancements:
- ProviderCard: Show health badge and proxy target indicator
- ProviderActions: Add "Set as Proxy Target" action
- EditProviderDialog: Add is_proxy_target toggle
- ProviderList: Support proxy target filtering mode

Other:
- Update App.tsx routing for settings integration
- Update useProviderActions hook with proxy target mutation
- Fix ProviderList tests for updated component API

* fix(usage): stabilize date range to prevent infinite re-renders

* feat(backend): add tool version check command

Add get_tool_versions command to check local and latest versions of
Claude, Codex, and Gemini CLI tools:

- Detect local installed versions via command line execution
- Fetch latest versions from npm registry (Claude, Gemini)
  and GitHub releases API (Codex)
- Return comprehensive version info including error details
  for uninstalled tools
- Register command in Tauri invoke handler

* style(ui): format accordion component code style

Apply consistent code formatting to accordion component:
- Convert double quotes to semicolons at line endings
- Adjust indentation to 2-space standard
- Align with project code style conventions

* refactor(providers): update provider card styling to use theme tokens

Replace hardcoded color classes with semantic design tokens:
- Use bg-card, border-border, text-card-foreground instead of glass-card
- Replace gray/white color literals with muted/foreground tokens
- Change proxy target indicator color from purple to green
- Improve hover states with border-border-active
- Ensure consistent dark mode support via CSS variables

* refactor(proxy): simplify auto-failover config panel structure

Restructure AutoFailoverConfigPanel for better integration:
- Remove internal Card wrapper and expansion toggle (now handled by parent)
- Extract enabled state to props for external control
- Simplify loading state display
- Clean up redundant CardHeader/CardContent wrappers
- ProxyPanel: reduce complexity by delegating to parent components

* feat(settings): enhance settings page with accordion layout and tool versions

Major settings page improvements:

AboutSection:
- Add local tool version detection (Claude, Codex, Gemini)
- Display installed vs latest version comparison with visual indicators
- Show update availability badges and environment check cards

SettingsPage:
- Reorganize advanced settings into collapsible accordion sections
- Add proxy control panel with inline status toggle
- Integrate auto-failover configuration with accordion UI
- Add database and cost calculation config sections

DirectorySettings & WindowSettings:
- Minor styling adjustments for consistency

settings.ts API:
- Add getToolVersions() wrapper for new backend command

* refactor(usage): restructure usage dashboard components

Comprehensive usage statistics panel refactoring:

UsageDashboard:
- Reorganize layout with improved section headers
- Add better loading states and empty state handling

ModelStatsTable & ProviderStatsTable:
- Minor styling updates for consistency

ModelTestConfigPanel & PricingConfigPanel:
- Simplify component structure
- Remove redundant Card wrappers
- Improve form field organization

RequestLogTable:
- Enhance table layout with better column sizing
- Improve pagination controls

UsageSummaryCards:
- Update card styling with semantic tokens
- Better responsive grid layout

UsageTrendChart:
- Refine chart container styling
- Improve legend and tooltip display

* chore(deps): add accordion and animation dependencies

Package updates:
- Add @radix-ui/react-accordion for collapsible sections
- Add cmdk for command palette support
- Add framer-motion for enhanced animations

Tailwind config:
- Add accordion-up/accordion-down animations
- Update darkMode config to support both selector and class
- Reorganize color and keyframe definitions for clarity

* style(app): update header and app switcher styling

App.tsx:
- Replace glass-header with explicit bg-background/80 backdrop-blur
- Update navigation button container to use bg-muted

AppSwitcher:
- Replace hardcoded gray colors with semantic muted/foreground tokens
- Ensure consistent dark mode support via CSS variables
- Add group class for better hover state transitions

src-tauri/src/commands/skill.rs

@@ -1,4 +1,3 @@
-use crate::app_config::AppType;
 use crate::error::format_skill_error;
 use crate::services::skill::SkillState;
 use crate::services::{Skill, SkillRepo, SkillService};
@@ -9,46 +8,15 @@ use tauri::State;
 
 pub struct SkillServiceState(pub Arc<SkillService>);
 
-/// 解析 app 参数为 AppType
-fn parse_app_type(app: &str) -> Result<AppType, String> {
-    match app.to_lowercase().as_str() {
-        "claude" => Ok(AppType::Claude),
-        "codex" => Ok(AppType::Codex),
-        "gemini" => Ok(AppType::Gemini),
-        _ => Err(format!("不支持的 app 类型: {app}")),
-    }
-}
-
-/// 根据 app_type 生成带前缀的 skill key
-fn get_skill_key(app_type: &AppType, directory: &str) -> String {
-    let prefix = match app_type {
-        AppType::Claude => "claude",
-        AppType::Codex => "codex",
-        AppType::Gemini => "gemini",
-    };
-    format!("{prefix}:{directory}")
-}
-
 #[tauri::command]
 pub async fn get_skills(
     service: State<'_, SkillServiceState>,
     app_state: State<'_, AppState>,
 ) -> Result<Vec<Skill>, String> {
-    get_skills_for_app("claude".to_string(), service, app_state).await
-}
-
-#[tauri::command]
-pub async fn get_skills_for_app(
-    app: String,
-    _service: State<'_, SkillServiceState>,
-    app_state: State<'_, AppState>,
-) -> Result<Vec<Skill>, String> {
-    let app_type = parse_app_type(&app)?;
-    let service = SkillService::new_for_app(app_type.clone()).map_err(|e| e.to_string())?;
-
     let repos = app_state.db.get_skill_repos().map_err(|e| e.to_string())?;
 
     let skills = service
+        .0
         .list_skills(repos)
         .await
         .map_err(|e| e.to_string())?;
@@ -58,19 +26,16 @@ pub async fn get_skills_for_app(
     let existing_states = app_state.db.get_skills().unwrap_or_default();
 
     for skill in &skills {
-        if skill.installed {
-            let key = get_skill_key(&app_type, &skill.directory);
-            if !existing_states.contains_key(&key) {
-                // 本地有该 skill，但数据库中没有记录，自动添加
-                if let Err(e) = app_state.db.update_skill_state(
-                    &key,
-                    &SkillState {
-                        installed: true,
-                        installed_at: Utc::now(),
-                    },
-                ) {
-                    log::warn!("同步本地 skill {key} 状态到数据库失败: {e}");
-                }
+        if skill.installed && !existing_states.contains_key(&skill.directory) {
+            // 本地有该 skill，但数据库中没有记录，自动添加
+            if let Err(e) = app_state.db.update_skill_state(
+                &skill.directory,
+                &SkillState {
+                    installed: true,
+                    installed_at: Utc::now(),
+                },
+            ) {
+                log::warn!("同步本地 skill {} 状态到数据库失败: {}", skill.directory, e);
             }
         }
     }
@@ -84,23 +49,11 @@ pub async fn install_skill(
     service: State<'_, SkillServiceState>,
     app_state: State<'_, AppState>,
 ) -> Result<bool, String> {
-    install_skill_for_app("claude".to_string(), directory, service, app_state).await
-}
-
-#[tauri::command]
-pub async fn install_skill_for_app(
-    app: String,
-    directory: String,
-    _service: State<'_, SkillServiceState>,
-    app_state: State<'_, AppState>,
-) -> Result<bool, String> {
-    let app_type = parse_app_type(&app)?;
-    let service = SkillService::new_for_app(app_type.clone()).map_err(|e| e.to_string())?;
-
     // 先在不持有写锁的情况下收集仓库与技能信息
     let repos = app_state.db.get_skill_repos().map_err(|e| e.to_string())?;
 
     let skills = service
+        .0
         .list_skills(repos)
         .await
         .map_err(|e| e.to_string())?;
@@ -140,16 +93,16 @@ pub async fn install_skill_for_app(
         };
 
         service
+            .0
             .install_skill(directory.clone(), repo)
             .await
             .map_err(|e| e.to_string())?;
     }
 
-    let key = get_skill_key(&app_type, &directory);
     app_state
         .db
         .update_skill_state(
-            &key,
+            &directory,
             &SkillState {
                 installed: true,
                 installed_at: Utc::now(),
@@ -166,29 +119,16 @@ pub fn uninstall_skill(
     service: State<'_, SkillServiceState>,
     app_state: State<'_, AppState>,
 ) -> Result<bool, String> {
-    uninstall_skill_for_app("claude".to_string(), directory, service, app_state)
-}
-
-#[tauri::command]
-pub fn uninstall_skill_for_app(
-    app: String,
-    directory: String,
-    _service: State<'_, SkillServiceState>,
-    app_state: State<'_, AppState>,
-) -> Result<bool, String> {
-    let app_type = parse_app_type(&app)?;
-    let service = SkillService::new_for_app(app_type.clone()).map_err(|e| e.to_string())?;
-
     service
+        .0
         .uninstall_skill(directory.clone())
         .map_err(|e| e.to_string())?;
 
     // Remove from database by setting installed = false
-    let key = get_skill_key(&app_type, &directory);
     app_state
         .db
         .update_skill_state(
-            &key,
+            &directory,
             &SkillState {
                 installed: false,
                 installed_at: Utc::now(),