Claude Code & Codex Provider Switcher
Featuredby
Manages and switches provider configurations and MCP servers for Claude Code and Codex on Windows, macOS, and Linux, supporting custom endpoints, cloud‑synced directories, and rapid configuration import/export.
Claude Code & Codex Provider Switcher Overview
What is Claude Code & Codex Provider Switcher about?
Manages multiple AI coding providers and their MCP servers, allowing one‑click switching of Claude Code or Codex configurations across platforms. It centralises all provider data, offers backup & restore, and provides speed‑testing and internationalisation out of the box.
How to use Claude Code & Codex Provider Switcher?
- Install – download the MSI/PKG/AppImage from the Releases page or install via Homebrew on macOS (
brew tap farion1231/ccswitch && brew install --cask cc-switch). - Add a Provider – open the app, click Add Provider, fill the required fields (API key, endpoint, model selections) and save.
- Switch – select a provider in the main window or from the system‑tray menu and click Switch. The live config files (
settings.jsonfor Claude,auth.json/config.tomlfor Codex) are updated instantly. - MCP Management – use the MCP panel to add, enable, or disable MCP servers (stdio or http). Built‑in templates such as mcp-fetch are available.
- Import/Export – backup all providers to a JSON file or restore from a previously exported file; the app automatically validates and rotates backups.
- Advanced Settings – configure a custom configuration directory (e.g., a Dropbox or OneDrive folder) to sync settings across machines, enable WSL support, or adjust usage‑query intervals.
Key Features
- Complete MCP server configuration (stdio & http) with real‑time enable/disable
- Provider duplication, drag‑and‑drop manual sorting, and custom endpoint aggregation
- Config import/export with automatic validation and backup rotation (keep latest 10)
- Endpoint latency testing with visual quality indicators
- Full i18next internationalisation (English & Chinese) and language switching
- Claude plugin synchronisation button for instant application
- Custom configuration directory support for cloud sync (Dropbox, OneDrive, iCloud, etc.)
- Usage query auto‑refresh, script validation, and template system
- Single‑instance enforcement, system‑tray minimisation, and auto‑updater
- Atomic file writes + rollback to prevent corrupted configs
- WSL environment support – auto‑sync when switching config directories
Use Cases
- Multi‑provider development – developers who test code generation across Anthropic, OpenAI, DeepSeek, Qwen, MiniMax, Kimi, etc., can switch providers without manually editing JSON/TOML files.
- MCP server testing – teams experimenting with custom MCP back‑ends can manage, enable, and test them directly from the UI.
- Cross‑device consistency – by pointing the config folder to a cloud‑synced directory, the same provider list is available on desktop, laptop, and remote WSL environments.
- Performance optimisation – quickly identify the fastest endpoint for a given provider using the built‑in speed test.
- Backup & recovery – export configurations before major changes; the app keeps a rotation of backups for safe rollback.
FAQ
Q: Where are the live configuration files stored?
- Claude:
~/.claude/settings.json(fallbackclaude.json). - Codex:
~/.codex/auth.jsonand~/.codex/config.toml.
Q: Do I need to migrate old configurations?
- The app performs a one‑time migration for versions prior to v3.2.0. After migration, all data resides in
~/.cc-switch/config.json.
Q: How does the app handle WSL?
- When you change the config directory to a WSL mount point, the current provider is automatically synced to the new location, avoiding file‑conflict issues.
Q: Can I run the app without admin rights?
- Yes. All operations are performed within the user’s home directory; elevated privileges are not required.
Q: How are backups managed?
- Backups are stored under
~/.cc-switch/backups/with timestamps; the latest 10 are retained automatically.
Q: What if a provider’s API key changes?
- Edit the provider entry via the UI; the change is saved and immediately reflected in the live config.
Q: Is the app open‑source?
- The source code is publicly available under the MIT license at https://github.com/farion1231/cc-switch.
Claude Code & Codex Provider Switcher's README
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.
❤️Sponsor
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!
Screenshots
| Main Interface | Add Provider |
|---|---|
 |
 |
Features
Current Version: v3.8.0 | 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
- Claude:
- Protection Mechanism: Auto-save current prompt content before switching, preserves manual modifications
Configuration Files
Claude Code
- Live config:
~/.claude/settings.json(orclaude.json) - API key field:
env.ANTHROPIC_AUTH_TOKENorenv.ANTHROPIC_API_KEY - MCP servers:
~/.claude.json→mcpServers
Codex
- Live config:
~/.codex/auth.json(required) +config.toml(optional) - API key field:
OPENAI_API_KEYinauth.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_KEYorGOOGLE_GEMINI_API_KEYin.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 operationsuseMcpActions- MCP managementuseSettingsseries - Settings managementuseImportExport- 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
Star History
License
MIT © Jason Young
Claude Code & Codex Provider Switcher Reviews
Login Required
Please log in to share your review and rating for this MCP.
Similar MCP Servers like Claude Code & Codex Provider Switcher
Explore related MCPs that share similar capabilities and solve comparable challenges
Git
Officialby modelcontextprotocol
A Model Context Protocol server for Git repository interaction and automation.
Zed
OfficialClientby zed-industries
A high‑performance, multiplayer code editor designed for speed and collaboration.
Everything
Officialby modelcontextprotocol
Model Context Protocol Servers
Time
Officialby modelcontextprotocol
A Model Context Protocol server that provides time and timezone conversion capabilities.
Cline
OfficialClientby cline
An autonomous coding assistant that can create and edit files, execute terminal commands, and interact with a browser directly from your IDE, operating step‑by‑step with explicit user permission.
Context7 MCP
Officialby upstash
Provides up-to-date, version‑specific library documentation and code examples directly inside LLM prompts, eliminating outdated information and hallucinated APIs.
Daytona
by daytonaio
Provides a secure, elastic infrastructure that creates isolated sandboxes for running AI‑generated code with sub‑90 ms startup, unlimited persistence, and OCI/Docker compatibility.
Continue
OfficialClientby continuedev
Enables faster shipping of code by integrating continuous AI agents across IDEs, terminals, and CI pipelines, offering chat, edit, autocomplete, and customizable agent workflows.
GitHub MCP Server
by github
Connects AI tools directly to GitHub, enabling natural‑language interactions for repository browsing, issue and pull‑request management, CI/CD monitoring, code‑security analysis, and team collaboration.