mirror of https://github.com/farion1231/cc-switch.git synced 2026-04-28 05:33:10 +08:00

Go to file

YoVinchen b1103c8a59 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.

2025-12-05 11:26:41 +08:00

.github/workflows

chore: standardize release artifact naming with version tags

2025-10-12 23:17:05 +08:00

assets

fix(config): correct MiniMax apiKeyUrl to minimaxi.com

2025-11-30 23:03:09 +08:00

docs

docs: add v3.8.0 release documentation and Japanese README

2025-11-28 21:47:05 +08:00

scripts

Refactor/storage (#286 )

2025-11-25 09:30:55 +08:00

src

Feat/proxy server (#355 )

2025-12-05 11:26:41 +08:00

src-tauri

Feat/proxy server (#355 )

2025-12-05 11:26:41 +08:00

tests

Feat/proxy server (#355 )

2025-12-05 11:26:41 +08:00

.gitattributes

fix: add .gitattributes to resolve line ending inconsistencies

2025-09-06 11:28:58 +08:00

.gitignore

chore: add nul to .gitignore to prevent Windows reserved filename tracking

2025-12-02 10:00:15 +08:00

.node-version

fix: update layout for Claude app type provider display (#87 )

2025-10-05 11:09:03 +08:00

CHANGELOG.md

docs: add v3.8.0 release documentation and Japanese README

2025-11-28 21:47:05 +08:00

components.json

feat: complete stage 1 infrastructure

2025-10-16 10:00:22 +08:00

deplink.html

Refactor/storage (#286 )

2025-11-25 09:30:55 +08:00

LICENSE

feat: add prettier formatter and MIT license

2025-08-29 11:35:17 +08:00

package.json

Feat/proxy server (#355 )

2025-12-05 11:26:41 +08:00

pnpm-lock.yaml

Feat/proxy server (#355 )

2025-12-05 11:26:41 +08:00

pnpm-workspace.yaml

feat: add provider usage query with JavaScript scripting support (#101 )

2025-10-15 09:15:25 +08:00

postcss.config.js

fix(css): downgrade Tailwind CSS from v4 to v3.4 for better browser compatibility

2025-11-27 22:55:14 +08:00

README_JA.md

chore: bump version to 3.8.2

2025-12-01 22:41:43 +08:00

README_ZH.md

chore: bump version to 3.8.2

2025-12-01 22:41:43 +08:00

README.md

chore: bump version to 3.8.2

2025-12-01 22:41:43 +08:00

tailwind.config.js

fix(tailwind): add missing shadcn/ui color mappings for opaque dialog backgrounds

2025-11-29 19:49:55 +08:00

tsconfig.json

fix: resolve TypeScript type errors in test files

2025-10-27 13:29:12 +08:00

tsconfig.node.json

test: add frontend testing infrastructure with vitest

2025-10-25 10:08:06 +08:00

vite.config.mts

fix(css): downgrade Tailwind CSS from v4 to v3.4 for better browser compatibility

2025-11-27 22:55:14 +08:00

vitest.config.ts

test: add frontend testing infrastructure with vitest

2025-10-25 10:08:06 +08:00

README.md

All-in-One Assistant for Claude Code, Codex & Gemini CLI

English | 中文 | 日本語 | Changelog

From Provider Switcher to All-in-One AI CLI Management Platform

Unified management for Claude Code, Codex & Gemini CLI provider configurations, MCP servers, Skills extensions, and system prompts.

This project is sponsored by Z.ai, supporting us with their GLM CODING PLAN.

GLM CODING PLAN is a subscription service designed for AI coding, starting at just $3/month. It provides access to their flagship GLM-4.6 model across 10+ popular AI coding tools (Claude Code, Cline, Roo Code, etc.), offering developers top-tier, fast, and stable coding experiences.

Get 10% OFF the GLM CODING PLAN with this link!

	Thanks to PackyCode for sponsoring this project! PackyCode is a reliable and efficient API relay service provider, offering relay services for Claude Code, Codex, Gemini, and more. PackyCode provides special discounts for our software users: register using this link and enter the "cc-switch" promo code during recharge to get 10% off.
	Thanks to ShanDianShuo for sponsoring this project! ShanDianShuo is a local-first AI voice input: Millisecond latency, data stays on device, 4x faster than typing, AI-powered correction, Privacy-first, completely free. Doubles your coding efficiency with Claude Code! Free download for Mac/Win

Screenshots

Main Interface	Add Provider

Features

Current Version: v3.8.2 | Full Changelog | Release Notes

v3.8.0 Major Update (2025-11-28)

Persistence Architecture Upgrade & Brand New UI

SQLite + JSON Dual-layer Architecture
- Migrated from JSON file storage to SQLite + JSON dual-layer structure
- Syncable data (providers, MCP, Prompts, Skills) stored in SQLite
- Device-level data (window state, local paths) stored in JSON
- Lays the foundation for future cloud sync functionality
- Schema version management for database migrations
Brand New User Interface
- Completely redesigned interface layout
- Unified component styles and smoother animations
- Optimized visual hierarchy
- Tailwind CSS downgraded from v4 to v3.4 for better browser compatibility
Japanese Language Support
- Added Japanese interface support (now supports Chinese/English/Japanese)
Auto Launch on Startup
- One-click enable/disable in settings
- Platform-native APIs (Registry/LaunchAgent/XDG autostart)
Skills Recursive Scanning
- Support for multi-level directory structures
- Allow same-named skills from different repositories
Critical Bug Fixes
- Fixed custom endpoints lost when updating providers
- Fixed Gemini configuration write issues
- Fixed Linux WebKitGTK rendering issues

v3.7.0 Highlights

Six Core Features, 18,000+ Lines of New Code

Gemini CLI Integration
- Third supported AI CLI (Claude Code / Codex / Gemini)
- Dual-file configuration support (.env + settings.json)
- Complete MCP server management
- Presets: Google Official (OAuth) / PackyCode / Custom
Claude Skills Management System
- Auto-scan skills from GitHub repositories (3 pre-configured curated repos)
- One-click install/uninstall to ~/.claude/skills/
- Custom repository support + subdirectory scanning
- Complete lifecycle management (discover/install/update)
Prompts Management System
- Multi-preset system prompt management (unlimited presets, quick switching)
- Cross-app support (Claude: CLAUDE.md / Codex: AGENTS.md / Gemini: GEMINI.md)
- Markdown editor (CodeMirror 6 + real-time preview)
- Smart backfill protection, preserves manual modifications
MCP v3.7.0 Unified Architecture
- Single panel manages MCP servers across three applications
- New SSE (Server-Sent Events) transport type
- Smart JSON parser + Codex TOML format auto-correction
- Unified import/export + bidirectional sync
Deep Link Protocol
- ccswitch:// protocol registration (all platforms)
- One-click import provider configs via shared links
- Security validation + lifecycle integration
Environment Variable Conflict Detection
- Auto-detect cross-app configuration conflicts (Claude/Codex/Gemini/MCP)
- Visual conflict indicators + resolution suggestions
- Override warnings + backup before changes

Core Capabilities

Provider Management: One-click switching between Claude Code, Codex, and Gemini API configurations
Speed Testing: Measure API endpoint latency with visual quality indicators
Import/Export: Backup and restore configs with auto-rotation (keep 10 most recent)
i18n Support: Complete Chinese/English localization (UI, errors, tray)
Claude Plugin Sync: One-click apply/restore Claude plugin configurations

v3.6 Highlights

Provider duplication & drag-and-drop sorting
Multi-endpoint management & custom config directory (cloud sync ready)
Granular model configuration (4-tier: Haiku/Sonnet/Opus/Custom)
WSL environment support with auto-sync on directory change
100% hooks test coverage & complete architecture refactoring

System Features

System tray with quick switching
Single instance daemon
Built-in auto-updater
Atomic writes with rollback protection

Download & Installation

System Requirements

Windows: Windows 10 and above
macOS: macOS 10.15 (Catalina) and above
Linux: Ubuntu 22.04+ / Debian 11+ / Fedora 34+ and other mainstream distributions

Windows Users

Download the latest CC-Switch-v{version}-Windows.msi installer or CC-Switch-v{version}-Windows-Portable.zip portable version from the Releases page.

macOS Users

Method 1: Install via Homebrew (Recommended)

brew tap farion1231/ccswitch
brew install --cask cc-switch

Update:

brew upgrade --cask cc-switch

Method 2: Manual Download

Download CC-Switch-v{version}-macOS.zip from the Releases page and extract to use.

Note

: Since the author doesn't have an Apple Developer account, you may see an "unidentified developer" warning on first launch. Please close it first, then go to "System Settings" → "Privacy & Security" → click "Open Anyway", and you'll be able to open it normally afterwards.

ArchLinux 用户

Install via paru (Recommended)

paru -S cc-switch-bin

Linux Users

Download the latest CC-Switch-v{version}-Linux.deb package or CC-Switch-v{version}-Linux.AppImage from the Releases page.

Quick Start

Basic Usage

Add Provider: Click "Add Provider" → Choose preset or create custom configuration
Switch Provider:
- Main UI: Select provider → Click "Enable"
- System Tray: Click provider name directly (instant effect)
Takes Effect: Restart your terminal or Claude Code / Codex / Gemini clients to apply changes
Back to Official: Select the "Official Login" preset (Claude/Codex) or "Google Official" preset (Gemini), restart the corresponding client, then follow its login/OAuth flow

MCP Management

Location: Click "MCP" button in top-right corner
Add Server:
- Use built-in templates (mcp-fetch, mcp-filesystem, etc.)
- Support stdio / http / sse transport types
- Configure independent MCP servers for different apps
Enable/Disable: Toggle switches to control which servers sync to live config
Sync: Enabled servers auto-sync to each app's live files
Import/Export: Import existing MCP servers from Claude/Codex/Gemini config files

Skills Management (v3.7.0 New)

Location: Click "Skills" button in top-right corner
Discover Skills:
- Auto-scan pre-configured GitHub repositories (Anthropic official, ComposioHQ, community, etc.)
- Add custom repositories (supports subdirectory scanning)
Install Skills: Click "Install" to one-click install to ~/.claude/skills/
Uninstall Skills: Click "Uninstall" to safely remove and clean up state
Manage Repositories: Add/remove custom GitHub repositories

Prompts Management (v3.7.0 New)

Location: Click "Prompts" button in top-right corner
Create Presets:
- Create unlimited system prompt presets
- Use Markdown editor to write prompts (syntax highlighting + real-time preview)
Switch Presets: Select preset → Click "Activate" to apply immediately
Sync Mechanism:
- Claude: ~/.claude/CLAUDE.md
- Codex: ~/.codex/AGENTS.md
- Gemini: ~/.gemini/GEMINI.md
Protection Mechanism: Auto-save current prompt content before switching, preserves manual modifications

Configuration Files

Claude Code

Live config: ~/.claude/settings.json (or claude.json)
API key field: env.ANTHROPIC_AUTH_TOKEN or env.ANTHROPIC_API_KEY
MCP servers: ~/.claude.json → mcpServers

Codex

Live config: ~/.codex/auth.json (required) + config.toml (optional)
API key field: OPENAI_API_KEY in auth.json
MCP servers: ~/.codex/config.toml → [mcp_servers] tables

Gemini

Live config: ~/.gemini/.env (API key) + ~/.gemini/settings.json (auth mode)
API key field: GEMINI_API_KEY or GOOGLE_GEMINI_API_KEY in .env
Environment variables: Support GOOGLE_GEMINI_BASE_URL, GEMINI_MODEL, etc.
MCP servers: ~/.gemini/settings.json → mcpServers
Tray quick switch: Each provider switch rewrites ~/.gemini/.env, no need to restart Gemini CLI

CC Switch Storage (v3.8.0 New Architecture)

Database (SSOT): ~/.cc-switch/cc-switch.db (SQLite, stores providers, MCP, Prompts, Skills)
Local settings: ~/.cc-switch/settings.json (device-level settings)
Backups: ~/.cc-switch/backups/ (auto-rotate, keep 10)

Cloud Sync Setup

Go to Settings → "Custom Configuration Directory"
Choose your cloud sync folder (Dropbox, OneDrive, iCloud, etc.)
Restart app to apply
Repeat on other devices to enable cross-device sync

Note

: First launch auto-imports existing Claude/Codex configs as default provider.

Architecture Overview

Design Principles

┌─────────────────────────────────────────────────────────────┐
│                    Frontend (React + TS)                    │
│  ┌─────────────┐  ┌──────────────┐  ┌──────────────────┐    │
│  │ Components  │  │    Hooks     │  │  TanStack Query  │    │
│  │   (UI)      │──│ (Bus. Logic) │──│   (Cache/Sync)   │    │
│  └─────────────┘  └──────────────┘  └──────────────────┘    │
└────────────────────────┬────────────────────────────────────┘
                         │ Tauri IPC
┌────────────────────────▼────────────────────────────────────┐
│                  Backend (Tauri + Rust)                     │
│  ┌─────────────┐  ┌──────────────┐  ┌──────────────────┐    │
│  │  Commands   │  │   Services   │  │  Models/Config   │    │
│  │ (API Layer) │──│ (Bus. Layer) │──│     (Data)       │    │
│  └─────────────┘  └──────────────┘  └──────────────────┘    │
└─────────────────────────────────────────────────────────────┘

Core Design Patterns

SSOT (Single Source of Truth): All data stored in ~/.cc-switch/cc-switch.db (SQLite)
Dual-layer Storage: SQLite for syncable data, JSON for device-level settings
Dual-way Sync: Write to live files on switch, backfill from live when editing active provider
Atomic Writes: Temp file + rename pattern prevents config corruption
Concurrency Safe: Mutex-protected database connection avoids race conditions
Layered Architecture: Clear separation (Commands → Services → DAO → Database)

Key Components

ProviderService: Provider CRUD, switching, backfill, sorting
McpService: MCP server management, import/export, live file sync
ConfigService: Config import/export, backup rotation
SpeedtestService: API endpoint latency measurement

v3.6 Refactoring

Backend: 5-phase refactoring (error handling → command split → tests → services → concurrency)
Frontend: 4-stage refactoring (test infra → hooks → components → cleanup)
Testing: 100% hooks coverage + integration tests (vitest + MSW)

Development

Environment Requirements

Node.js 18+
pnpm 8+
Rust 1.85+
Tauri CLI 2.8+

Development Commands

# Install dependencies
pnpm install

# Dev mode (hot reload)
pnpm dev

# Type check
pnpm typecheck

# Format code
pnpm format

# Check code format
pnpm format:check

# Run frontend unit tests
pnpm test:unit

# Run tests in watch mode (recommended for development)
pnpm test:unit:watch

# Build application
pnpm build

# Build debug version
pnpm tauri build --debug

Rust Backend Development

cd src-tauri

# Format Rust code
cargo fmt

# Run clippy checks
cargo clippy

# Run backend tests
cargo test

# Run specific tests
cargo test test_name

# Run tests with test-hooks feature
cargo test --features test-hooks

Testing Guide (v3.6 New)

Frontend Testing:

Uses vitest as test framework
Uses MSW (Mock Service Worker) to mock Tauri API calls
Uses @testing-library/react for component testing

Test Coverage:

Hooks unit tests (100% coverage)
- useProviderActions - Provider operations
- useMcpActions - MCP management
- useSettings series - Settings management
- useImportExport - Import/export
Integration tests
- App main application flow
- SettingsDialog complete interaction
- MCP panel functionality

Running Tests:

# Run all tests
pnpm test:unit

# Watch mode (auto re-run)
pnpm test:unit:watch

# With coverage report
pnpm test:unit --coverage

Tech Stack

Frontend: React 18 · TypeScript · Vite · TailwindCSS 4 · TanStack Query v5 · react-i18next · react-hook-form · zod · shadcn/ui · @dnd-kit

Backend: Tauri 2.8 · Rust · serde · tokio · thiserror · tauri-plugin-updater/process/dialog/store/log

Testing: vitest · MSW · @testing-library/react

Project Structure

├── src/                      # Frontend (React + TypeScript)
│   ├── components/           # UI components (providers/settings/mcp/ui)
│   ├── hooks/                # Custom hooks (business logic)
│   ├── lib/
│   │   ├── api/              # Tauri API wrapper (type-safe)
│   │   └── query/            # TanStack Query config
│   ├── i18n/locales/         # Translations (zh/en)
│   ├── config/               # Presets (providers/mcp)
│   └── types/                # TypeScript definitions
├── src-tauri/                # Backend (Rust)
│   └── src/
│       ├── commands/         # Tauri command layer (by domain)
│       ├── services/         # Business logic layer
│       ├── app_config.rs     # Config data models
│       ├── provider.rs       # Provider domain models
│       ├── mcp.rs            # MCP sync & validation
│       └── lib.rs            # App entry & tray menu
├── tests/                    # Frontend tests
│   ├── hooks/                # Unit tests
│   └── components/           # Integration tests
└── assets/                   # Screenshots & partner resources

Changelog

See CHANGELOG.md for version update details.

Legacy Electron Version

Releases retains v2.0.3 legacy Electron version

If you need legacy Electron code, you can pull the electron-legacy branch

Contributing

Issues and suggestions are welcome!

Before submitting PRs, please ensure:

Pass type check: pnpm typecheck
Pass format check: pnpm format:check
Pass unit tests: pnpm test:unit
💡 For new features, please open an issue for discussion before submitting a PR

README.md

All-in-One Assistant for Claude Code, Codex & Gemini CLI

Screenshots

Features

Current Version: v3.8.2 | Full Changelog | Release Notes

Download & Installation

System Requirements

Windows Users

macOS Users

ArchLinux 用户

Linux Users

Quick Start

Basic Usage

MCP Management

Skills Management (v3.7.0 New)

Prompts Management (v3.7.0 New)

Configuration Files

Cloud Sync Setup

Architecture Overview

Design Principles

Development

Environment Requirements

Development Commands

Rust Backend Development

Testing Guide (v3.6 New)

Tech Stack

Project Structure

Changelog

Legacy Electron Version

Contributing

Star History

License

README.md

All-in-One Assistant for Claude Code, Codex & Gemini CLI

❤️Sponsor

Screenshots

Features

Current Version: v3.8.2 | Full Changelog | Release Notes

Download & Installation

System Requirements

Windows Users

macOS Users

ArchLinux 用户

Linux Users

Quick Start

Basic Usage

MCP Management

Skills Management (v3.7.0 New)

Prompts Management (v3.7.0 New)

Configuration Files

Cloud Sync Setup

Architecture Overview

Design Principles

Development

Environment Requirements

Development Commands

Rust Backend Development

Testing Guide (v3.6 New)

Tech Stack

Project Structure

Changelog

Legacy Electron Version

Contributing

Star History

License