10 Commits

• feat(skills): unified management architecture with SSOT and React Query

  - Introduce SSOT (Single Source of Truth) at ~/.cc-switch/skills/
  - Add three-app toggle support (Claude/Codex/Gemini) for each skill
  - Refactor frontend to use TanStack Query hooks instead of manual state
  - Add UnifiedSkillsPanel for managing installed skills with app toggles
  - Add useSkills.ts with declarative data fetching hooks
  - Extend skills.ts API with unified install/uninstall/toggle methods
  - Support importing unmanaged skills from app directories
  - Add v2→v3 database migration for new skills table structure

  Jason · 2026-01-02 22:04:02 +08:00
  ff03ca1e63
• Feat/provider icon color (#385)

  * feat(ui): add color prop support to ProviderIcon component
  
  * feat(health): add stream check core functionality
  
  Add new stream-based health check module to replace model_test:
  - Add stream_check command layer with single and batch provider checks
  - Add stream_check DAO layer for config and log persistence
  - Add stream_check service layer with retry mechanism and health status evaluation
  - Add frontend HealthStatusIndicator component
  - Add frontend useStreamCheck hook
  
  This provides more comprehensive health checking capabilities.
  
  * refactor(health): replace model_test with stream_check
  
  Replace model_test module with stream_check across the codebase:
  - Remove model_test command and service modules
  - Update command registry in lib.rs to use stream_check commands
  - Update module exports in commands/mod.rs and services/mod.rs
  - Remove frontend useModelTest hook
  - Update stream_check command implementation
  
  This refactoring provides clearer naming and better separation of concerns.
  
  * refactor(db): clean up unused database tables and optimize schema
  
  Remove deprecated and unused database tables:
  - Remove proxy_usage table (replaced by proxy_request_logs)
  - Remove usage_daily_stats table (aggregation done on-the-fly)
  - Rename model_test_logs to stream_check_logs with updated schema
  - Remove related DAO methods for proxy_usage
  - Update usage_stats service to use proxy_request_logs only
  - Refactor usage_script to work with new schema
  
  This simplifies the database schema and removes redundant data storage.
  
  * refactor(ui): update frontend components for stream check
  
  Update frontend components to use stream check API:
  - Refactor ModelTestConfigPanel to use stream check config
  - Update API layer to use stream_check commands
  - Add HealthStatus type and StreamCheckResult interface
  - Update ProviderList to use new health check integration
  - Update AutoFailoverConfigPanel with stream check references
  - Improve UI layout and configuration options
  
  This completes the frontend migration from model_test to stream_check.
  
  * feat(health): add configurable test models and reasoning effort support
  
  Enhance stream check service with configurable test models:
  - Add claude_model, codex_model, gemini_model to StreamCheckConfig
  - Support reasoning effort syntax (model@level or model#level)
  - Parse and apply reasoning_effort for OpenAI-compatible models
  - Remove hardcoded model names from check functions
  - Add unit tests for model parsing logic
  - Remove obsolete model_test source files
  
  This allows users to customize which models are used for health checks.

  YoVinchen · 2025-12-11 17:20:44 +08:00
  395783e22a
• Feat/proxy server (#355)

  * feat(proxy): implement local HTTP proxy server with multi-provider failover
  
  Add a complete HTTP proxy server implementation built on Axum framework,
  enabling local API request forwarding with automatic provider failover
  and load balancing capabilities.
  
  Backend Implementation (Rust):
  - Add proxy server module with 7 core components:
    * server.rs: Axum HTTP server lifecycle management (start/stop/status)
    * router.rs: API routing configuration for Claude/OpenAI/Gemini endpoints
    * handlers.rs: Request/response handling and transformation
    * forwarder.rs: Upstream forwarding logic with retry mechanism (652 lines)
    * error.rs: Comprehensive error handling and HTTP status mapping
    * types.rs: Shared types (ProxyConfig, ProxyStatus, ProxyServerInfo)
    * health.rs: Provider health check infrastructure
  
  Service Layer:
  - Add ProxyService (services/proxy.rs, 157 lines):
    * Manage proxy server lifecycle
    * Handle configuration updates
    * Track runtime status and metrics
  
  Database Layer:
  - Add proxy configuration DAO (dao/proxy.rs, 242 lines):
    * Persist proxy settings (listen address, port, timeout)
    * Store provider priority and availability flags
  - Update schema with proxy_config table (schema.rs):
    * Support runtime configuration persistence
  
  Tauri Commands:
  - Add 6 command endpoints (commands/proxy.rs):
    * start_proxy_server: Launch proxy server
    * stop_proxy_server: Gracefully shutdown server
    * get_proxy_status: Query runtime status
    * get_proxy_config: Retrieve current configuration
    * update_proxy_config: Modify settings without restart
    * is_proxy_running: Check server state
  
  Frontend Implementation (React + TypeScript):
  - Add ProxyPanel component (222 lines):
    * Real-time server status display
    * Start/stop controls
    * Provider availability monitoring
  - Add ProxySettingsDialog component (420 lines):
    * Configuration editor (address, port, timeout)
    * Provider priority management
    * Settings validation
  - Add React hooks:
    * useProxyConfig: Manage proxy configuration state
    * useProxyStatus: Poll and display server status
  - Add TypeScript types (types/proxy.ts):
    * Define ProxyConfig, ProxyStatus interfaces
  
  Provider Integration:
  - Extend Provider model with availability field (providers.rs):
    * Track provider health for failover logic
  - Update ProviderCard UI to display proxy status
  - Integrate proxy controls in Settings page
  
  Dependencies:
  - Add Axum 0.7 (async web framework)
  - Add Tower 0.4 (middleware and service abstractions)
  - Add Tower-HTTP (CORS layer)
  - Add Tokio sync primitives (oneshot, RwLock)
  
  Technical Details:
  - Graceful shutdown via oneshot channel
  - Shared state with Arc<RwLock<T>> for thread-safe config updates
  - CORS enabled for cross-origin frontend access
  - Request/response streaming support
  - Automatic retry with exponential backoff (forwarder)
  - API key extraction from multiple config formats (Claude/Codex/Gemini)
  
  File Statistics:
  - 41 files changed
  - 3491 insertions(+), 41 deletions(-)
  - Core modules: 1393 lines (server + forwarder + handlers)
  - Frontend UI: 642 lines (ProxyPanel + ProxySettingsDialog)
  - Database/DAO: 326 lines
  
  This implementation provides the foundation for advanced features like:
  - Multi-provider load balancing
  - Automatic failover on provider errors
  - Request logging and analytics
  - Usage tracking and cost monitoring
  
  * fix(proxy): resolve UI/UX issues and database constraint error
  
  Simplify proxy control interface and fix database persistence issues:
  
  Backend Fixes:
  - Fix NOT NULL constraint error in proxy_config.created_at field
    * Use COALESCE to preserve created_at on updates
    * Ensure proper INSERT OR REPLACE behavior
  - Remove redundant enabled field validation on startup
    * Auto-enable when user clicks start button
    * Persist enabled state after successful start
  - Preserve enabled state during config updates
    * Prevent accidental service shutdown on config save
  
  Frontend Improvements:
  - Remove duplicate proxy enable switch from settings dialog
    * Keep only runtime toggle in ProxyPanel
    * Simplify user experience with single control point
  - Hide proxy target button when proxy service is stopped
    * Add isProxyRunning prop to ProviderCard
    * Conditionally render proxy controls based on service status
  - Update form schema to omit enabled field
    * Managed automatically by backend
  
  Files: 5 changed, 81 insertions(+), 94 deletions(-)
  
  * fix(proxy): improve URL building and Gemini request handling
  
  - Refactor URL construction with version path deduplication (/v1, /v1beta)
  - Preserve query parameters for Gemini API requests
  - Support GOOGLE_GEMINI_API_KEY field name (with fallback)
  - Change default proxy port from 5000 to 15721
  - Fix test: use Option type for is_proxy_target field
  
  * refactor(proxy): remove unused request handlers and routes
  
  - Remove unused GET/DELETE request forwarding methods
  - Remove count_tokens, get/delete response handlers
  - Simplify router by removing unused endpoints
  - Keep only essential routes: /v1/messages, /v1/responses, /v1beta/*
  
  * Merge branch 'main' into feat/proxy-server
  
  * fix(proxy): resolve clippy warnings for dead code and uninlined format args
  
  - Add #[allow(dead_code)] to unused ProviderUnhealthy variant
  - Inline format string arguments in handlers.rs and codex.rs log macros
  - Refactor error response handling to properly pass through upstream errors
  - Add URL deduplication logic for /v1/v1 paths in CodexAdapter
  
  * feat(proxy): implement provider adapter pattern with OpenRouter support
  
  This major refactoring introduces a modular provider adapter architecture
  to support format transformation between different AI API formats.
  
  New features:
  - Add ProviderAdapter trait for unified provider abstraction
  - Implement Claude, Codex, and Gemini adapters with specific logic
  - Add Anthropic ↔ OpenAI format transformation for OpenRouter compatibility
  - Support model mapping from provider configuration (ANTHROPIC_MODEL, etc.)
  - Add OpenRouter preset to Claude provider presets
  
  Refactoring:
  - Extract authentication logic into auth.rs with AuthInfo and AuthStrategy
  - Move URL building and request transformation to individual adapters
  - Simplify ProviderRouter to only use proxy target providers
  - Refactor RequestForwarder to use adapter-based request/response handling
  - Use whitelist mode for header forwarding (only pass necessary headers)
  
  Architecture:
  - providers/adapter.rs: ProviderAdapter trait definition
  - providers/auth.rs: AuthInfo, AuthStrategy types
  - providers/claude.rs: Claude adapter with OpenRouter detection
  - providers/codex.rs: Codex (OpenAI) adapter
  - providers/gemini.rs: Gemini (Google) adapter
  - providers/models/: Anthropic and OpenAI API data models
  - providers/transform.rs: Bidirectional format transformation
  
  * feat(proxy): add streaming SSE transform and thinking parameter support
  
  New features:
  - Add OpenAI → Anthropic SSE streaming response transformation
  - Support thinking parameter detection for reasoning model selection
  - Add ANTHROPIC_REASONING_MODEL config option for extended thinking
  
  Changes:
  - streaming.rs: Implement SSE event parsing and Anthropic format conversion
  - transform.rs: Add thinking detection logic and reasoning model mapping
  - handlers.rs: Integrate streaming transform for OpenRouter compatibility
  - Cargo.toml: Add async-stream and bytes dependencies
  
  * feat(db): add usage tracking schema and types
  
  Add database tables for proxy request logs and model pricing.
  Extend Provider and error types to support usage statistics.
  
  * feat(proxy): implement usage tracking subsystem
  
  Add request logger with automatic cost calculation.
  Implement token parser for Claude/OpenAI/Gemini responses.
  Add cost calculator based on model pricing configuration.
  
  * feat(proxy): integrate usage logging into request handlers
  
  Add usage logging to forwarder and streaming handlers.
  Track token usage and costs for each proxy request.
  
  * feat(commands): add usage statistics Tauri commands
  
  Register usage commands for summary, trends, logs, and pricing.
  Expose usage stats service through Tauri command layer.
  
  * feat(api): add frontend usage API and query hooks
  
  Add TypeScript types for usage statistics.
  Implement usage API with Tauri invoke calls.
  Add TanStack Query hooks for usage data fetching.
  
  * feat(ui): add usage dashboard components
  
  Add UsageDashboard with summary cards, trend chart, and data tables.
  Implement model pricing configuration panel.
  Add request log viewer with filtering and detail panel.
  
  * fix(ui): integrate usage dashboard and fix type errors
  
  Add usage dashboard tab to settings page.
  Fix UsageScriptModal TypeScript type annotations.
  
  * deps: add recharts for charts and rust_decimal/uuid for usage tracking
  
  - recharts: Chart visualization for usage trends
  - rust_decimal: Precise cost calculations
  - uuid: Request ID generation
  
  * feat(proxy): add ProviderType enum for fine-grained provider detection
  
  Introduce ProviderType enum to distinguish between different provider
  implementations (Claude, ClaudeAuth, Codex, Gemini, GeminiCli, OpenRouter).
  This enables proper authentication handling and request transformation
  based on the actual provider type rather than just AppType.
  
  - Add ProviderType enum with detection logic from config
  - Enhance Claude adapter with OpenRouter detection
  - Enhance Gemini adapter with CLI mode detection
  - Add helper methods for provider type inference
  
  * feat(database): extend schema with streaming and timing fields
  
  Add new columns to proxy_request_logs table for enhanced usage tracking:
  - first_token_ms and duration_ms for performance metrics
  - provider_type and is_streaming for request classification
  - cost_multiplier for flexible pricing
  
  Update model pricing with accurate rates for Claude/GPT/Gemini models.
  Add ensure_model_pricing_seeded() call on database initialization.
  Add test for model pricing auto-seeding verification.
  
  * feat(proxy/usage): enhance token parser and logger for multi-format support
  
  Parser enhancements:
  - Add OpenAI Chat Completions format parsing (prompt_tokens/completion_tokens)
  - Add model field to TokenUsage for actual model name extraction
  - Add from_codex_response_adjusted() for proper cache token handling
  - Add debug logging for better stream event tracing
  
  Logger enhancements:
  - Add first_token_ms, provider_type, is_streaming, cost_multiplier fields
  - Extend RequestLog struct with full metadata tracking
  - Update log_with_calculation() signature for new fields
  
  Calculator: Update tests with model field in TokenUsage.
  
  * feat(proxy): enhance proxy server with session tracking and OpenAI route
  
  Error handling:
  - Add StreamIdleTimeout and AuthError variants for better error classification
  
  Module exports:
  - Export ResponseType, StreamHandler, NonStreamHandler from response_handler
  - Export ProxySession, ClientFormat from session module
  
  Server routing:
  - Add /v1/chat/completions route for OpenAI Chat Completions API
  
  Handlers:
  - Add log_usage_with_session() for enhanced usage tracking with session context
  - Add first_token_ms timing measurement for streaming responses
  - Use SseUsageCollector with start_time for accurate latency calculation
  - Track is_streaming flag in usage logs
  
  * feat(services): add pagination and enhanced filtering for request logs
  
  Usage stats service:
  - Change get_request_logs() from limit/offset to page/page_size pagination
  - Return PaginatedLogs with total count, page, and page_size
  - Add appType and providerName filters with LIKE search
  - Add is_streaming, first_token_ms, duration_ms to RequestLogDetail
  - Join with providers table for provider name lookup
  
  Commands:
  - Update get_request_logs command signature for pagination params
  
  Module exports:
  - Export PaginatedLogs struct
  
  * feat(frontend): update usage types and API for pagination support
  
  Types (usage.ts):
  - Add isStreaming, firstTokenMs, durationMs to RequestLog
  - Add PaginatedLogs interface with data, total, page, pageSize
  - Change LogFilters: providerId -> appType + providerName
  
  API (usage.ts):
  - Change getRequestLogs params from limit/offset to page/pageSize
  - Return PaginatedLogs instead of RequestLog[]
  - Pass filters object directly to backend
  
  Query (usage.ts):
  - Update usageKeys.logs key generation for pagination
  - Update useRequestLogs hook signature
  
  * refactor(ui): enhance RequestLogTable with filtering and pagination
  
  UI improvements:
  - Add filter bar with app type, provider name, model, status selectors
  - Add date range picker (startDate/endDate)
  - Add search/reset/refresh buttons
  
  Pagination:
  - Implement proper page-based pagination with page info display
  - Show total count and current page range
  - Add prev/next navigation buttons
  
  Features:
  - Default to last 24 hours filter
  - Streamlined table columns layout
  - Query invalidation on refresh
  
  * style(config): format mcpPresets code style
  
  Apply consistent formatting to createNpxCommand function and
  sequential-thinking server configuration.
  
  * fix(ui): update SettingsPage tab styles for improved appearance (#342)
  
  * feat(model-test): add provider model availability testing
  
  Implement standalone model testing feature to verify provider API connectivity:
  - Add ModelTestService for Claude/Codex/Gemini endpoint testing
  - Create model_test_logs table for test result persistence
  - Add test button to ProviderCard with loading state
  - Include ModelTestConfigPanel for customizing test parameters
  
  * fix(proxy): resolve token parsing for OpenRouter streaming responses
  
  Problem:
  - OpenRouter and similar third-party services return streaming responses
    where input_tokens appear in message_delta instead of message_start
  - The previous implementation only extracted input_tokens from message_start,
    causing input_tokens to be recorded as 0 for these providers
  
  Changes:
  - streaming.rs: Add prompt_tokens field to Usage struct and include
    input_tokens in the transformed message_delta event when converting
    OpenAI format to Anthropic format
  - parser.rs: Update from_claude_stream_events() to handle input_tokens
    from both message_start (native Claude API) and message_delta (OpenRouter)
    - Use if-let pattern instead of direct unwrap for safer parsing
    - Only update input_tokens from message_delta if not already set
  - logger.rs: Adjust test parameters to match updated function signature
  
  Tests:
  - Add test_openrouter_stream_parsing() for OpenRouter format validation
  - Add test_native_claude_stream_parsing() for native Claude API validation
  
  * fix(pricing): standardize model ID format for pricing lookup
  
  Normalize model IDs by removing vendor prefixes and converting dots to hyphens to ensure consistent pricing lookups across different API response formats.
  
  Changes:
  - Update seed data to use hyphen format (e.g., gpt-5-1, gemini-2-5-pro)
  - Add normalize_model_id() function to strip vendor prefixes (anthropic/, openai/)
  - Convert dots to hyphens in model IDs (claude-haiku-4.5 → claude-haiku-4-5)
  - Try both original and normalized IDs for exact matching
  - Use normalized ID for suffix-based fallback matching
  - Add comprehensive test cases for prefix and dot handling
  - Add warning log when no pricing found
  
  This ensures pricing lookups work correctly for:
  - Models with vendor prefixes: anthropic/claude-haiku-4.5
  - Models with dots in version: claude-sonnet-4.5
  - Models with date suffixes: claude-haiku-4-5-20240229
  
  * style(rust): apply clippy formatting suggestions
  
  Apply automatic clippy fixes for uninlined_format_args warnings across Rust codebase. Replace format string placeholders with inline variable syntax for improved readability.
  
  Changes:
  - Convert format!("{}", var) to format!("{var}")
  - Apply to model_test.rs, parser.rs, and usage_stats.rs
  - Fix line length issues by breaking long function calls
  - Improve code formatting consistency
  
  All changes are automatic formatting with no functional impact.
  
  * fix(ui): restore card borders in usage statistics panels
  
  Restore proper card styling for ModelTestConfigPanel and PricingConfigPanel by adding back border and rounded-lg classes. The transparent background styling was causing visual inconsistency.
  
  Changes:
  - Replace border-none bg-transparent shadow-none with border rounded-lg
  - Apply to both loading and error states for consistency
  - Format TypeScript code for better readability
  - Break long function signatures across multiple lines
  
  This ensures the usage statistics panels have consistent visual appearance with proper borders and rounded corners.
  
  * feat(pricing): add GPT-5 Codex model pricing presets
  
  Add pricing configuration for GPT-5 Codex variants to support cost tracking for Codex-specific models.
  
  Changes:
  - Add gpt-5-codex model with standard GPT-5 pricing
  - Add gpt-5-1-codex model with standard GPT-5.1 pricing
  - Input: $1.25/M tokens, Output: $10/M tokens
  - Cache read: $0.125/M tokens, Cache creation: $0
  
  This ensures accurate cost calculation for Codex API requests using GPT-5 Codex models.

  YoVinchen · 2025-12-05 11:26:41 +08:00
  b1103c8a59
• 添加Claude和Codex环境变量检查 (#242)

  * feat(env): add environment variable conflict detection and management
  
  实现了系统环境变量冲突检测与管理功能:
  
  核心功能:
  - 自动检测会影响 Claude/Codex 的系统环境变量
  - 支持 Windows 注册表和 Unix shell 配置文件检测
  - 提供可视化的环境变量冲突警告横幅
  - 支持批量选择和删除环境变量
  - 删除前自动备份,支持后续恢复
  
  技术实现:
  - Rust 后端: 跨平台环境变量检测与管理
  - React 前端: EnvWarningBanner 组件交互界面
  - 国际化支持: 中英文界面
  - 类型安全: 完整的 TypeScript 类型定义
  
  * refactor(env): remove unused imports and function
  
  Remove unused HashMap and PathBuf imports, and delete the unused get_source_description function to clean up the code.

  冰子 · 2025-11-18 23:44:44 +08:00
  b9412ece0b
• Feat/claude skills management (#237)

  * feat(skills): add Claude Skills management feature
  
  Implement complete Skills management system with repository discovery,
  installation, and lifecycle management capabilities.
  
  Backend:
  - Add SkillService with GitHub integration and installation logic
  - Implement skill commands (list, install, uninstall, check updates)
  - Support multiple skill repositories with caching
  
  Frontend:
  - Add Skills management page with repository browser
  - Create SkillCard and RepoManager components
  - Add badge, card, table UI components
  - Integrate Skills API with Tauri commands
  
  Files: 10 files changed, 1488 insertions(+)
  
  * feat(skills): integrate Skills feature into application
  
  Integrate Skills management feature with complete dependency updates,
  configuration structure extensions, and internationalization support.
  
  Dependencies:
  - Add @radix-ui/react-visually-hidden for accessibility
  - Add anyhow, zip, serde_yaml, tempfile for Skills backend
  - Enable chrono serde feature for timestamp serialization
  
  Backend Integration:
  - Extend MultiAppConfig with SkillStore field
  - Implement skills.json migration from legacy location
  - Register SkillService and skill commands in main app
  - Export skill module in commands and services
  
  Frontend Integration:
  - Add Skills page route and dialog in App
  - Integrate Skills UI with main navigation
  
  Internationalization:
  - Add complete Chinese translations for Skills UI
  - Add complete English translations for Skills UI
  
  Code Quality:
  - Remove redundant blank lines in gemini_mcp.rs
  - Format log statements in mcp.rs
  
  Tests:
  - Update import_export_sync tests for SkillStore
  - Update mcp_commands tests for new structure
  
  Files: 16 files changed, 540 insertions(+), 39 deletions(-)
  
  * style(skills): improve SkillsPage typography and spacing
  
  Optimize visual hierarchy and readability of Skills page:
  - Reduce title size from 2xl to lg with tighter tracking
  - Improve description spacing and color contrast
  - Enhance empty state with better text hierarchy
  - Use explicit gray colors for better dark mode support
  
  * feat(skills): support custom subdirectory path for skill scanning
  
  Add optional skillsPath field to SkillRepo to enable scanning skills
  from subdirectories (e.g., "skills/") instead of repository root.
  
  Changes:
  - Backend: Add skillsPath field with subdirectory scanning logic
  - Frontend: Add skillsPath input field and display in repo list
  - Presets: Add cexll/myclaude repo with skills/ subdirectory
  - Code quality: Fix clippy warnings (dedup logic, string formatting)
  
  Backward compatible: skillsPath is optional, defaults to root scanning.
  
  * refactor(skills): improve repo manager dialog layout
  
  Optimize dialog structure with fixed header and scrollable content:
  - Add flexbox layout with fixed header and scrollable body
  - Remove outer border wrapper for cleaner appearance
  - Match SkillsPage design pattern for consistency
  - Improve UX with better content hierarchy

  YoVinchen · 2025-11-18 22:05:54 +08:00
  ec303544ca
• feat(prompts+i18n): add prompt management and improve prompt editor i18n (#193)

  * feat(prompts): add prompt management across Tauri service and React UI
  
  - backend: add commands/prompt.rs, services/prompt.rs, register in commands/mod.rs and lib.rs, refine app_config.rs
  - frontend: add PromptPanel, PromptFormModal, PromptListItem, MarkdownEditor, usePromptActions, integrate in App.tsx
  - api: add src/lib/api/prompts.ts
  - i18n: update src/i18n/locales/{en,zh}.json
  - build: update package.json and pnpm-lock.yaml
  
  * feat(i18n): improve i18n for prompts and Markdown editor
  
  - update src/i18n/locales/{en,zh}.json keys and strings
  - apply i18n in PromptFormModal, PromptPanel, and MarkdownEditor
  - align prompt text with src-tauri/src/services/prompt.rs
  
  * feat(prompts): add enable/disable toggle and simplify panel UI
  
  - Add PromptToggle component and integrate in prompt list items
  - Implement toggleEnabled with optimistic update; enable via API, disable via upsert with enabled=false;
    reload after success
  - Simplify PromptPanel: remove file import and current-file preview to keep CRUD flow focused
  - Tweak header controls style (use mcp variant) and minor copy: rename “Prompt Management” to “Prompts”
  - i18n: add disableSuccess/disableFailed messages
  - Backend (Tauri): prevent duplicate backups when importing original prompt content
  
  * style: unify code formatting with trailing commas
  
  * feat(prompts): add Gemini filename support to PromptFormModal
  
  Update filename mapping to use Record<AppId, string> pattern, supporting
  GEMINI.md alongside CLAUDE.md and AGENTS.md.
  
  * fix(prompts): sync enabled prompt to file when updating
  
  When updating a prompt that is currently enabled, automatically sync
  the updated content to the corresponding live file (CLAUDE.md/AGENTS.md/GEMINI.md).
  
  This ensures the active prompt file always reflects the latest content
  when editing enabled prompts.

  YoVinchen · 2025-11-12 16:41:41 +08:00
  155532ea8c
• refactor(backend): implement transaction mechanism and i18n errors for provider service

  This commit completes phase 4 service layer extraction by introducing:
  
  1. **Transaction mechanism with 2PC (Two-Phase Commit)**:
     - Introduced `run_transaction()` wrapper with snapshot-based rollback
     - Implemented `LiveSnapshot` enum to capture and restore live config files
     - Added `PostCommitAction` to separate config.json persistence from live file writes
     - Applied to critical operations: add, update, switch providers
     - Ensures atomicity: memory + config.json + live files stay consistent
  
  2. **Internationalized error handling**:
     - Added `AppError::Localized` variant with key + zh + en messages
     - Implemented `AppError::localized()` helper function
     - Migrated 24 error sites to use i18n-ready errors
     - Enables frontend to display errors in user's preferred language
  
  3. **Concurrency optimization**:
     - Fixed `get_custom_endpoints()` to use read lock instead of write lock
     - Ensured async IO operations (usage query) execute outside lock scope
     - Added defensive RAII lock management with explicit scope blocks
  
  4. **Code organization improvements**:
     - Reduced commands/provider.rs from ~800 to ~320 lines (-60%)
     - Expanded services/provider.rs with transaction infrastructure
     - Added unit tests for validation and credential extraction
     - Documented legacy file cleanup logic with inline comments
  
  5. **Backfill mechanism refinement**:
     - Ensured live config is synced back to memory before switching
     - Maintains SSOT (Single Source of Truth) architecture principle
     - Handles Codex dual-file (auth.json + config.toml) atomically
  
  Breaking changes: None (internal refactoring only)
  Performance: Improved read concurrency, no measurable overhead from snapshots
  Test coverage: Added validation tests, updated service layer tests

  Jason · 2025-10-28 17:47:15 +08:00
  5c3aca18eb
• refactor(backend): extract config and speedtest services (phase 4)

  This commit continues the backend refactoring initiative by extracting
  configuration management and API speedtest logic into dedicated service
  layers, completing phase 4 of the architectural improvement plan.
  
  ## Changes
  
  ### New Service Layers
  - **ConfigService** (`services/config.rs`): Consolidates all config
    import/export, backup management, and live sync operations
    - `create_backup()`: Creates timestamped backups with auto-cleanup
    - `export_config_to_path()`: Exports config to specified path
    - `load_config_for_import()`: Loads and validates imported config
    - `import_config_from_path()`: Full import with state update
    - `sync_current_providers_to_live()`: Syncs current providers to live files
    - Private helpers for Claude/Codex-specific sync logic
  
  - **SpeedtestService** (`services/speedtest.rs`): Encapsulates endpoint
    latency testing with proper validation and error handling
    - `test_endpoints()`: Tests multiple URLs concurrently
    - URL validation now unified in service layer
    - Includes 3 unit tests for edge cases (empty list, invalid URLs, timeout clamping)
  
  ### Command Layer Refactoring
  - Move all import/export commands to `commands/import_export.rs`
  - Commands become thin wrappers: parse params → call service → return JSON
  - Maintain `spawn_blocking` for I/O operations (phase 5 optimization)
  - Lock acquisition happens after I/O completes (minimize contention)
  
  ### File Organization
  - Delete: `import_export.rs`, `speedtest.rs` (root-level modules)
  - Create: `commands/import_export.rs`, `services/config.rs`, `services/speedtest.rs`
  - Update: Module declarations in `lib.rs`, `commands/mod.rs`, `services/mod.rs`
  
  ### Test Updates
  - Update 20 integration tests in `import_export_sync.rs` to use `ConfigService` APIs
  - All existing test cases pass without modification to test logic
  - Add 3 new unit tests for `SpeedtestService`:
    - `sanitize_timeout_clamps_values`: Boundary value testing
    - `test_endpoints_handles_empty_list`: Empty input handling
    - `test_endpoints_reports_invalid_url`: Invalid URL error reporting
  
  ## Benefits
  
  1. **Improved Testability**: Service methods are `pub fn`, easily callable
     from tests without Tauri runtime
  2. **Better Separation of Concerns**: Business logic isolated from
     command/transport layer
  3. **Enhanced Maintainability**: Related operations grouped in cohesive
     service structs
  4. **Consistent Error Handling**: Services return `Result<T, AppError>`,
     commands convert to `Result<T, String>`
  5. **Performance**: I/O operations run in `spawn_blocking`, locks released
     before file operations
  
  ## Testing
  
  - ✅ All 43 tests passing (7 unit + 36 integration)
  - ✅ `cargo fmt --check` passes
  - ✅ `cargo clippy -- -D warnings` passes (zero warnings)
  
  ## Documentation
  
  Updated `BACKEND_REFACTOR_PLAN.md` to reflect completion of config and
  speedtest service extraction, marking phase 4 substantially complete.
  
  Co-authored-by: Claude Code <code@anthropic.com>

  Jason · 2025-10-28 15:58:04 +08:00
  88a952023f
• refactor(backend): extract MCP service layer with snapshot isolation

  Extract all MCP business logic from command layer into `services/mcp.rs`,
  implementing snapshot isolation pattern to optimize lock granularity after
  RwLock migration in Phase 5.
  
  ## Key Changes
  
  ### Service Layer (`services/mcp.rs`)
  - Add `McpService` with 7 methods: `get_servers`, `upsert_server`,
    `delete_server`, `set_enabled`, `sync_enabled`, `import_from_claude`,
    `import_from_codex`
  - Implement snapshot isolation: acquire write lock only for in-memory
    modifications, clone config snapshot, release lock, then perform file I/O
    with snapshot
  - Use conditional cloning: only clone config when sync is actually needed
    (e.g., when `enabled` flag is true or `sync_other_side` is requested)
  
  ### Command Layer (`commands/mcp.rs`)
  - Reduce to thin wrappers: parse parameters and delegate to `McpService`
  - Remove all `*_internal` and `*_test_hook` functions (-94 lines)
  - Each command now 5-10 lines (parameter parsing + service call + error mapping)
  
  ### Core Logic Refactoring (`mcp.rs`)
  - Rename `set_enabled_and_sync_for` → `set_enabled_flag_for`
  - Remove file sync logic from low-level function, move sync responsibility
    to service layer for better separation of concerns
  
  ### Test Adaptation (`tests/mcp_commands.rs`)
  - Replace test hooks with direct `McpService` calls
  - All 5 MCP integration tests pass
  
  ### Additional Fixes
  - Add `Default` impl for `AppState` (clippy suggestion)
  - Remove unnecessary auto-deref in `commands/provider.rs` and `lib.rs`
  - Update Phase 4/5 progress in `BACKEND_REFACTOR_PLAN.md`
  
  ## Performance Impact
  
  **Before**: Write lock held during file I/O (~10ms), blocking all readers
  **After**: Write lock held only for memory ops (~100μs), file I/O lock-free
  
  Estimated throughput improvement: ~2x in high-concurrency read scenarios
  
  ## Testing
  
  - ✅ All tests pass: 5 MCP commands + 7 provider service tests
  - ✅ Zero clippy warnings with `-D warnings`
  - ✅ No behavioral changes, maintains original save semantics
  
  Part of Phase 4 (Service Layer Abstraction) of backend refactoring roadmap.

  Jason · 2025-10-28 14:59:28 +08:00
  9e72e786e3
• refactor(backend): phase 4 - extract provider service layer

  Architecture improvements:
  - Extract ProviderService with switch/backfill/write methods
  - Reduce command layer from 160 to 13 lines via delegation
  - Separate business logic (services) from state management (commands)
  - Introduce precise error handling with structured validation
  
  Refactoring details:
  - Split Codex/Claude switching into symmetric private methods
  - Add multi-layer validation for Codex auth field (existence + type)
  - Extract import_config_from_path for command and test reuse
  - Expose export_config_to_file and ProviderService in public API
  
  Test coverage:
  - Add 10+ integration tests for Claude/Codex switching flows
  - Cover import/export success and failure scenarios (JSON parse, missing file)
  - Verify state consistency on error paths (current remains unchanged)
  - Test snapshot backfill for both old and new providers after switching

  Jason · 2025-10-28 10:47:48 +08:00
  c2e8855a0f