farion1231/cc-switch

This system is a cross-platform desktop application built on Tauri v2 that serves as a unified management hub for multiple AI coding agents and API providers. It enables users to configure, synchronize, and monitor settings for tools like Claude, Codex, and Gemini, while handling complex backend tasks such as OAuth authentication, proxy failover, and usage tracking. The application provides a centralized interface for managing MCP servers, skills, and conversation sessions across various platforms, backed by a local SQLite database and a robust Rust-based backend.

58 changes.

The project migrated from Electron to Tauri 2, replacing the legacy renderer and main process with a Rust backend and a modern React frontend using TanStack Query and Radix UI. This architectural shift introduced a SQLite database for persistent storage, a comprehensive provider management system with OAuth support, and expanded capabilities for MCP servers, skills, and proxy failover.

13 changes.

This period focused on implementing a centralized session manager that consolidates conversation history across nine AI coding agents, featuring a rebuilt virtualized UI for browsing and searching. The work also expanded configuration capabilities with dedicated panels for OpenClaw, Hermes, and workspace files, while introducing project-based profile switching. Supporting infrastructure improvements included adding Flatpak packaging, terminal emulator support, and mirroring release assets to Cloudflare R2.

A new AgentsPanel component has been added to the application, providing a placeholder interface for the upcoming Agents management feature. The panel displays a 'Coming Soon' message with a bot icon, indicating that autonomous agent capabilities are currently under development.

src/components/agents · high confidence

Users can now install CC Switch on Linux via Flatpak. This change introduces the Flatpak manifest and build configuration, bundling necessary dependencies like libayatana-appindicator for system tray support and intltool for building libdbusmenu. The package is configured to run on the GNOME 46 runtime and includes a README with instructions for local builds and permission adjustments.

flatpak · high confidence

The session manager now supports launching sessions in the Otty terminal emulator, using its CLI to open new tabs or windows with the correct working directory. This change also adds explicit support for launching sessions in Warp and Kaku terminals, and ensures that Ghostty sessions are restored with the correct launch path. Users can now select these additional terminal applications when resuming or launching new sessions.

_src-tauri/src/session\manager/terminal · high confidence

A new Workspace Files panel has been added to the workspace interface, providing a grid of clickable cards to view and edit key configuration files (AGENTS.md, SOUL.md, USER.md, IDENTITY.md, TOOLS.md, MEMORY.md, HEARTBEAT.md, BOOTSTRAP.md, and BOOT.md) with existence indicators. The panel also includes a link to open the underlying workspace directory and integrates a Daily Memory feature, allowing users to manage, search, and edit daily markdown memory files directly from the workspace view.

src/components/workspace · high confidence

The application now supports multiple languages, initializing with Chinese (zh) as the default and falling back to English (en) for missing translations. Users can switch between Chinese, Traditional Chinese (zh-TW), English, and Japanese (ja), with the system automatically detecting the preferred language from browser settings or local storage. This change introduces i18next integration to manage translations and language switching.

src/i18n · high confidence

The deep link system (ccswitch://) has been expanded to allow importing not just provider configurations, but also MCP server definitions, prompt templates, and skill repositories. Users can now use deep links to batch-import MCP servers (with support for merging apps on existing servers), import prompts (optionally enabling them immediately), and add skill repositories from GitHub. The module also introduces usage script fields for provider deep links, allowing users to configure usage query scripts and credentials via the link, and adds validation to prevent path traversal attacks when importing skill repositories.

src-tauri/src/deeplink · high confidence

The MCP module now provides first-class synchronization and import capabilities for seven additional AI applications alongside existing support. New modules handle bidirectional configuration mapping for Claude (JSON), Codex (TOML), Gemini (JSON), Grok Build (TOML), Hermes (YAML), OpenCode (JSON), and MiniMax Code (JSON). Each module implements format conversion logic to translate between the app's native configuration structure and the unified internal MCP format, ensuring that server specs, authentication headers, and environment variables are correctly preserved during sync. The implementation includes robust validation to skip invalid entries without aborting the entire sync process, and respects user preferences by skipping writes when the target application's configuration directory does not exist.

src-tauri/src/mcp · high confidence

Added a new set of components in src/components/universal that provide a user interface for managing universal API providers. The UniversalProviderPanel lists providers and handles loading, saving, deleting, and syncing configurations to connected apps (Claude, Codex, Gemini). The UniversalProviderCard displays provider details, enabled apps, and action buttons for editing, duplicating, and syncing. The UniversalProviderFormModal allows users to create or edit provider configurations, including selecting presets, setting base URLs and API keys, and configuring model settings for different apps, with support for dark mode and JSON configuration previews.

src/components/universal · high confidence

Users can now manage Pi-specific prompts directly within the application via a new dedicated panel. This update adds a tabbed interface supporting global prompts, system prompt files (SYSTEM.md and APPEND\_SYSTEM.md) with inline editing and save/delete capabilities, and prompt templates. The implementation includes a new PromptFormPanel for creating and editing prompts, a PromptLibrary for browsing and toggling them, and specific handling for Pi's native prompt resources, allowing users to configure Pi's behavior through these new UI components.

src/components/prompts · high confidence

The session management interface has been rebuilt with a new SessionManagerPage component that supports browsing sessions in both flat and grouped views (organized by provider and directory). Long session messages are now virtualized and collapsed by default to improve performance, while search functionality highlights matching keywords in titles and content. The UI includes a table of contents sidebar/dialog for navigation, batch selection for bulk operations, and provider-specific icons and labels.

src/components/sessions · high confidence

Users can now manage and switch between project profiles that apply snapshot-based configurations to specific application groups (Claude, Claude Desktop, and Codex). The new ProfileSwitcher component allows selecting a profile, which automatically saves the current configuration as a snapshot for that scope, while the ProfileManageDialog enables renaming or deleting these shared project entities. Profiles are scoped so that switching in one group (e.g., Claude) does not affect another (e.g., Codex), and the switcher is only visible for supported app tabs to prevent confusion.

src/components/profiles · high confidence

The application now provides a centralized session manager that supports browsing, loading, and deleting conversation history for eight supported providers: Claude, Codex, OpenCode, OpenClaw, Gemini CLI, Grok Build, Hermes, and Pi. Session scanning is optimized to run in parallel across all providers, and the system handles both file-based and SQLite-backed storage (specifically for OpenCode and Hermes). Users can now view a consolidated list of sessions sorted by activity, load message history, and delete individual sessions with provider-specific cleanup, while MCode sessions remain managed externally by the host application.

_src-tauri/src/session\manager · high confidence

The proxy layer now uses a \ProviderAdapter\ trait to standardize how upstream providers are handled, replacing ad-hoc logic with a structured interface for URL building, authentication, and request/response transformation. This change introduces dedicated modules for authentication strategies (\AuthStrategy\), including support for Codex OAuth (ChatGPT Plus/Pro) and GitHub Copilot (including Enterprise Server) device-code flows, as well as specialized adapters for Claude (with OpenAI/Responses/Gemini format conversion) and Codex (with Responses-to-Chat bridging and history restoration). It also adds shared utilities for reasoning content extraction and SSE envelope construction, enabling consistent protocol bridging and improved cache stability across different provider types.

src-tauri/src/proxy/providers · high confidence

The proxy now includes a dedicated usage module that accurately tracks API token consumption and calculates costs by distinguishing between fresh input, cache-read, and cache-creation tokens. This ensures that billing reflects the actual pricing semantics of different providers (e.g., treating Claude's input tokens as fresh vs. OpenAI's as inclusive of cache). The system also deduplicates usage logs to prevent inflated request counts and provides detailed cost breakdowns for transparency.

src-tauri/src/proxy/usage · high confidence

The settings interface has been significantly restructured and expanded with a suite of new components. The About section now serves as a comprehensive tool management panel, displaying version checks for tools like Claude Code, Codex, Gemini, and Grok Build, and providing one-click install commands. A new App Visibility Settings panel allows users to toggle the visibility of specific apps and the profile switcher. Configuration is centralized in a new Directory Settings component that supports overriding config directories for multiple tools. Proxy management is now a dedicated tab featuring global proxy settings with scanning and testing, auto-failover configuration, and rectifier controls. Additional new panels include an Auth Center for managing OAuth accounts (GitHub Copilot, ChatGPT/Codex, xAI/Grok), a Backup Manager for configuring and restoring local backups, an Import/Export section for settings, and a Log Config panel for adjusting verbosity. The Language Settings panel has also been updated to include Japanese and Traditional Chinese options.

src/components/settings · high confidence

The application introduces a new AppSwitcher component that dynamically adjusts its layout based on available width, supporting both expanded and compact modes with visual indicators for active applications. Several new quota display components have been added: CodexOauthAccountQuota and CodexOauthQuotaFooter for displaying subscription usage for Codex OAuth accounts, CopilotQuotaFooter for GitHub Copilot usage, and a generalized SubscriptionQuotaFooter for other providers. Additionally, a DeepLinkImportDialog has been implemented to handle the import of configurations via deep links, including support for providers, prompts, MCPs, and skills, with risk assessment and confirmation steps. A FirstRunNoticeDialog is now shown on the first launch to guide new users, and a DatabaseUpgrade component provides an in-app recovery screen when the database version is too new for the current application version.

src/components · high confidence

A new 'Memory' panel has been added to the Hermes settings interface, replacing the previous Prompts entry. This panel allows users to manage agent and user memory configurations via a tabbed interface, featuring toggles to enable or disable memory for each type, a Markdown editor for editing memory content, and usage limits with validation. The component integrates with existing hooks for fetching memory data, saving changes, and toggling memory states, providing a dedicated UI for memory management within the application.

src/components/hermes · high confidence

Users can now manage OpenClaw configuration directly through dedicated UI panels. The Agents panel allows setting a primary model and fallbacks via dropdowns, along with workspace, timeout, context tokens, and concurrency limits. The Tools panel provides a dropdown to select tool profiles (minimal, coding, messaging, full) and manage allow/deny lists. The Environment panel offers a JSON editor for direct manipulation of the env configuration. A health banner displays warnings for issues like unsupported profiles or deprecated fields, and a new hook fetches available model options from configured providers.

src/components/openclaw · high confidence

The \src/hooks\ directory has been expanded with a suite of new hooks that replace ad-hoc state management with TanStack Query for data fetching and mutations. \useBackupManager\ now handles database backup lifecycle operations (create, restore, rename, delete) with automatic cache invalidation. \useGlobalProxy\ and \useProxyStatus\ centralize global proxy configuration, status polling, and takeover controls. \useProviderActions\ extracts complex provider logic (add, update, delete, switch) into a reusable hook, while \useDirectorySettings\ manages per-app configuration directory paths. Additional hooks like \useDarkMode\, \useDragSort\, \useMcp\, \useOpenClaw\, \useHermes\, \usePromptActions\, and \useSessionSearch\ provide specialized functionality for theme detection, UI sorting, MCP server management, app-specific configurations, and search, all grounded in the new query-based architecture.

src/hooks · high confidence

The \src-tauri/src/commands\ directory has been expanded with new command modules to support managed OAuth authentication, proxy failover, and usage tracking. \auth.rs\ introduces a unified device-code flow for GitHub Copilot, Codex OAuth, and xAI OAuth, enabling multi-account management and quota display. \failover.rs\ adds commands to manage the proxy failover queue and auto-failover switches. \global\_proxy.rs\ provides commands to configure and test the global outbound proxy. \balance.rs\, \coding\_plan.rs\, and \codex\_oauth.rs\ expose usage and quota queries for various providers. Additionally, \hermes.rs\ adds commands for the Hermes Web UI and memory management, while \import\_export.rs\ handles SQL backups and deep link imports.

src-tauri/src/commands · high confidence

This change introduces a comprehensive set of TypeScript interfaces in src/types to support new and existing product capabilities. The proxy module now includes types for per-app takeover mode, independent failover queue management, circuit breaker health status, and provider health tracking. Usage tracking is expanded with types for session sync results, models.dev pricing synchronization, live end-time date ranges, and dashboard-wide scope filters that fold claude-desktop into claude for display. The OMO subsystem adds definitions for built-in agents and categories with recommended models, as well as disableable agents and MCPs. Additional types cover environment variable conflict detection, icon metadata, and subscription quota tiers with credential status.

src/types · high confidence

The usage section has been replaced with a comprehensive new dashboard featuring real-time request logs, provider and model statistics, and a dedicated pricing management panel. Users can now configure per-app cost multipliers and pricing sources, import model pricing directly from models.dev via a new picker dialog, and manage automatic pricing synchronization. The dashboard includes a date range picker with presets, app/provider/model filtering, and configurable auto-refresh intervals, while a new connectivity check panel allows tuning of stream health monitoring parameters.

src/components/usage · high confidence

The application introduces several new backend service modules in \src-tauri/src/services\ to expand usage tracking and configuration management. The \balance\ service adds account balance queries for DeepSeek, StepFun, SiliconFlow, OpenRouter, and Novita AI, returning data in the existing \UsageResult\ format. The \coding\_plan\ service implements quota tracking for Kimi For Coding, Zhipu GLM, MiniMax, ZenMux, Volcengine, and OpenCode Go, supporting various time-window reset logic. A new \codex\_oauth\_models\ service fetches the model catalog directly from the ChatGPT backend for Codex OAuth users. Additionally, \env\_checker\ and \env\manager\ provide cross-platform (Windows/Unix) detection and resolution of environment variable conflicts (e.g., \ANTHROPIC\\\, \OPENAI\\*\) with automatic backup and restore capabilities, while \config\ adds backup management and live configuration synchronization for supported apps.

src-tauri/src/services · high confidence

A new EnvWarningBanner component has been added to display warnings when environment variable conflicts are detected. Users can now view details of conflicting variables, expand the banner to see a list of specific conflicts, select individual or all conflicts, and delete the conflicting environment variables directly from the interface with confirmation and backup information.

src/components/env · high confidence

This change introduces a suite of new modules in src/lib to support core application capabilities. It adds a structured frontend logger with comprehensive redaction of sensitive data (keys, tokens, credentials) before disk persistence, and a platform detection utility that disables UI drag regions on Linux to prevent window freezes. The update also includes a Tauri updater wrapper for checking and applying updates, a local proxy request override system with strict header validation, and a models.dev pricing sync engine for automatic cost data. Additional utilities cover clipboard operations, usage range resolution with live end-time support, version comparison logic, and prompt template management.

src/lib · high confidence

The icon library in \src/icons/extracted\ has been expanded with new SVG assets for several AI provider partners and cloud platforms, including AICodeMirror, Alibaba, AmuxAPI, Anthropic, AWS, Azure, Baidu, Bailian, ByteDance, CatCoder, and AiHubMix. These additions ensure that users can visually identify these specific services within the application's provider selection interface.

src/icons · high confidence

This change introduces a comprehensive set of new React components for the provider management interface, including AddProviderDialog, EditProviderDialog, ProviderCard, ProviderList, and ProviderActions. These components implement features such as universal provider support, failover priority badges, health status indicators, and additive mode management for specific applications like OpenCode and OpenClaw. The UI also includes improved empty states, search functionality, and drag-and-drop sorting capabilities.

src/components/providers · high confidence

The application now ships with dedicated configuration files for provider presets across multiple apps. For Claude and Claude Desktop, presets define API formats (Anthropic, OpenAI Chat/Responses, Gemini Native), model routing, and partner branding. Codex presets include templates for auth.json and config.toml, supporting native Responses API, OAuth flows (GitHub Copilot, Codex OAuth, xAI OAuth), and detailed model catalogs with reasoning levels and input modalities. Gemini and Grok Build also receive their own preset structures. Additionally, a coding plan provider detection system automatically identifies supported providers (Kimi, Zhipu, MiniMax, Volcengine, OpenCode Go) and injects usage scripts for quota tracking.

src/config · high confidence

The proxy settings area now includes a comprehensive configuration panel (ProxyPanel) that allows users to manage the local proxy listen address and port, with validation for IPv4, IPv6, and localhost formats. A new FailoverToggle component in the header enables per-app automatic failover, which requires app takeover to be active. The FailoverQueueManager component lets users configure the failover queue by adding or removing providers and adjusting circuit breaker thresholds (failure/success thresholds, error rate, timeouts). An AutoFailoverConfigPanel provides detailed per-app settings for retries and timeouts. Additionally, a ClaudeDesktopRouteToggle manages a specific route for Claude Desktop, and a RoutingActivationBrand adds a visual confirmation animation when routing is activated.

src/components/proxy · high confidence

The session manager now includes dedicated provider implementations for nine AI coding tools, enabling users to browse, load, and delete their local conversation history directly within the application. The new files in \src-tauri/src/session\_manager/providers\ implement session scanning, message loading, and deletion logic for Claude (JSONL), Codex (JSONL + SQLite), Gemini (JSON), Grok Build (JSONL + summary.json), Hermes (SQLite + JSONL), MCode (SQLite), OpenClaw (JSONL), OpenCode (JSON + SQLite), and Pi (JSONL). Each provider handles the specific file formats, storage locations, and metadata structures of its respective tool, allowing seamless access to past sessions across these integrated agents.

_src-tauri/src/session\manager/providers · high confidence

Added a set of reusable components in src/components/common to support the new app management and panel features: AppCountBar provides a scrollable bar showing per-app counts with optional bulk-enable/disable toggle buttons; AppToggleGroup renders a compact row of icon buttons for toggling individual apps with tooltips; FullScreenPanel is a portal-based full-screen overlay with header, footer, body scroll lock, platform-specific drag regions, and configurable fade or slide-from-right exit/entry animations (including ESC-key support); ListItemRow offers a consistent list-item row with hover and border styling; ManagementListSearch supplies a local search input with clear button and keyboard handling. These components standardize the UI for the searchable lists, bulk toggles, and full-screen panel interactions introduced in this change set.

src/components/common · high confidence

This change introduces a new set of shared UI components in \src/components/providers/forms/shared\ to standardize provider configuration forms. \ApiKeySection\ handles API key input with optional partner promotion messages and links to official key pages. \EndpointField\ provides an endpoint input with a toggle for 'full URL' mode and a management button. \ModelInputWithFetch\ and \ModelDropdown\ enable fetching models from a provider's \/v1/models\ endpoint, displaying them in a searchable, vendor-grouped dropdown with fuzzy search support. These components replace or supplement previous ad-hoc implementations, offering a consistent experience for configuring provider credentials, endpoints, and model selections.

src/components/providers/forms/shared · high confidence

The skills management UI has been replaced with a new architecture. Users can now discover and install skills from public repositories or the skills.sh registry via a dedicated SkillsPage, manage custom Git repositories through a RepoManagerPanel, and handle installed skills using a UnifiedSkillsPanel that supports app-specific toggling, backup/restore, and batch updates.

src/components/skills · high confidence

The application introduces a comprehensive TypeScript API layer in src/lib/api that bridges the frontend to the Tauri backend. This new module exposes typed functions and interfaces for managing providers, sessions, skills, MCP servers, and usage data, while also adding dedicated modules for OAuth authentication (GitHub Copilot, Codex, xAI), global proxy configuration, failover queue management, and deep-link imports. Users benefit from a consistent, type-safe interface for all backend interactions, enabling features like multi-account management, unified configuration snippets, and robust health checks.

src/lib/api · high confidence

This change introduces a suite of new utility modules in src/utils to support enhanced security, configuration management, and data integrity. The deeplinkRisk module adds risk classification helpers that flag private endpoints, environment variable hijacks, and shell command injections in deep-link imports, while also masking sensitive configuration values in previews. Provider configuration utilities now include robust TOML parsing and manipulation for Codex and Grok Build providers, featuring prototype-pollution guards to prevent security vulnerabilities during config merging. A new deepClone utility replaces previous JSON deep-copy methods, using structuredClone with a safe fallback that explicitly handles \_\proto\\_ keys. Additional helpers include formatters for JSON and MCP configurations, error translation for MCP and Pi provider mutations, and post-change sync logic for live provider updates.

src/utils · high confidence

The files in src/main (index.ts, preload.ts, services.ts) have been completely deleted. This removes the Electron main process entry point, the preload script exposing IPC handlers, and the backend services responsible for provider status checking, configuration switching, and local storage management via electron-store.

src/main · high confidence

The custom AddProviderModal and ProviderList components, along with their associated CSS stylesheets, have been removed from the renderer. This eliminates the previous implementation for adding new AI providers via a modal form and managing them through a list with radio-button switching and status indicators.

src/renderer/components · high confidence

Deleted the original React application entry files (main.tsx, App.tsx) and their associated global stylesheets (App.css, index.css) from the renderer directory. This removes the previous implementation that managed provider lists, status checks, and configuration paths via Electron IPC, clearing the way for the new Tauri API-based architecture.

src/renderer · high confidence

The application now uses a dedicated DAO (Data Access Object) module to manage database interactions for proxy configurations, provider failover queues, MCP servers, skills, and project profiles. This change introduces structured persistence for proxy settings (including cost multipliers and pricing sources), failover queue management for providers, and unified CRUD operations for skills and MCP servers across multiple app types (Claude, Codex, Gemini, GrokBuild, OpenCode, Hermes). It also adds support for project-based configuration profiles and official provider seeding, replacing previous ad-hoc database handling with a consistent, modular architecture.

src-tauri/src/database/dao · high confidence

A change to existing behaviour in src-tauri/icons — 8 commits, 18 files.

src-tauri/icons · medium confidence · unverified

The application now uses a dedicated \UpdateContext\ to manage update checks and state. This context automatically checks for updates one second after the app starts and provides methods to manually check, dismiss, or reset the dismissal of update notifications. A key behavioral change is the persistence of the dismissed state in \localStorage\, ensuring that once a user dismisses an update notification, it will not reappear for that specific version across sessions. The implementation also includes a migration path to handle legacy storage keys for backward compatibility.

src/contexts · high confidence

The application has migrated its core data storage from JSON files to a local SQLite database. This change introduces a new database module that handles schema creation, versioned migrations (up to schema v19), and data migration from the legacy MultiAppConfig JSON format. It also adds robust backup and restore capabilities, including SQL export/import with strict security authorizers to prevent cross-file injection, binary snapshot backups, and automatic pre-migration backups. The database layer now manages providers, MCP servers, prompts, skills, and settings, with support for sync-preserving imports and automatic cleanup routines.

src-tauri/src/database · high confidence

The frontend application has been restructured and restyled. The main entry point (App.tsx) and global styles (index.css) have been rewritten to implement a new glassmorphism design system with explicit dark mode support, replacing previous CSS variable approaches. The application root has been moved from src/renderer to src, and the HTML entry point now includes inline script to persist theme preferences. The app now utilizes TanStack Query for data fetching, integrates i18n for internationalization, and introduces a new provider categorization system (official, cloud\_provider, aggregator, etc.) in the type definitions.

src · high confidence

The application now correctly decodes URL-safe Base64 strings in deep link import confirmations, ensuring that payloads containing special characters (like '+' or '/') are displayed accurately rather than as opaque strings or empty lists. This aligns the frontend decoding logic with the backend's handling of URL-safe alphabets (RFC 4648 §5) and missing padding. Additionally, a new utility for running sequential bulk actions has been introduced to prevent race conditions when multiple app adapters update configuration files simultaneously, ensuring writes occur in order and failures are tracked individually.

src/lib/utils · high confidence

The application has been migrated to the Tauri v2 framework, introducing a new window configuration with an overlay title bar on macOS and a visible system title bar on Windows to prevent startup display issues. This change includes a restrictive Content Security Policy (CSP) for improved security, support for deep-linking via the 'ccswitch' URL scheme, and an integrated auto-updater pointing to GitHub and a custom endpoint. Additionally, Windows-specific build scripts have been added to embed Common Controls v6 manifests, ensuring test binaries run correctly without entry-point errors.

src-tauri · high confidence

Added new helper modules in the forms helpers directory to standardize configuration handling for OpenCode providers and request headers. The new \opencodeFormUtils.ts\ file provides default configuration templates for various providers (Claude, Codex, Gemini, OpenClaw) and utility functions to parse, normalize, and validate OpenCode-specific settings, including model keys and extra options. The \requestHeaders.ts\ module introduces a dedicated prefix for draft headers to prevent collisions with legitimate custom headers and provides functions to normalize and search request headers, ensuring consistent header management across the provider forms.

src/components/providers/forms/helpers · high confidence

The application now uses dedicated Rust modules to manage core configuration and platform-specific behaviors. \app\_config.rs\ defines structured data types for MCP server and Skill enablement states across supported applications (Claude, Codex, Gemini, etc.), replacing ad-hoc handling. \app\_store.rs\ implements a Tauri Store-backed mechanism for persisting and caching the \app\_config\_dir\ override, ensuring independent management of the configuration directory. \auto\_launch.rs\ standardizes cross-platform auto-start logic using \AutoLaunchBuilder\, fixing macOS bundle path resolution. Additionally, \claude\_mcp.rs\ and \claude\_plugin.rs\ provide robust, atomic read/write operations for Claude Desktop and Claude Code configuration files, including MCP server management and onboarding state control.

src-tauri/src · high confidence

The \src/lib/query\ directory has been restructured to use TanStack Query (\@tanstack/react-query\) for all data fetching and state management. This introduces dedicated hooks for Copilot quota, failover queue and circuit breaker management, proxy server status and configuration, usage summaries and logs, subscription quotas (including Codex and xAI OAuth), and provider/profile mutations. The migration standardizes caching, automatic refetching, and error handling across the application, replacing previous ad-hoc query patterns with a consistent, cache-normalized approach.

src/lib/query · high confidence

The provider service has been refactored from a monolithic file into a modular structure under src-tauri/src/services/provider, introducing dedicated modules for endpoints, Gemini authentication, live configuration, Pi provider management, and usage scripts. Users can now manage custom API endpoints per provider (add, remove, list, and track last-used timestamps), while Gemini providers automatically detect authentication types (PackyCode, Google Official OAuth, or Generic) and ensure correct OAuth security flags are written to local settings. Live configuration handling is now isolated, supporting context-window defaults for Codex OAuth (gpt-5.6) and Kimi For Coding, and sanitizing internal fields from Claude settings. Usage scripts are executed with credential resolution that prioritizes script-specific values over provider defaults, with transient transport failures properly triggering retries while preserving last-good values.

src-tauri/src/services/provider · high confidence

This change introduces dedicated confirmation components (McpConfirmation, PromptConfirmation, SkillConfirmation) for the deeplink import flow. For MCP imports, the UI now surfaces command arguments, environment variables, and URLs, applying risk classification to flag potentially dangerous values with warnings. A critical behavioral fix ensures the MCP enabled-warning is always displayed, regardless of the request's enabled flag, preventing attackers from hiding this warning by omitting the field. Prompt and Skill imports also receive structured confirmation views with appropriate warnings or hints.

src/components/deeplink · high confidence

The application now includes a comprehensive set of UI components (such as Dialog, Select, Command, and Toast) built on Radix UI primitives, providing a consistent visual design system. A key behavioral improvement is the addition of an IME-safe input component and disabled auto-capitalization on standard inputs, which prevents text corruption and layout jitter for users typing with CJK input methods on macOS.

src/components/ui · high confidence

A new validation schema for provider configurations has been introduced, enforcing that the settings configuration field contains valid JSON. The schema includes specific error handling to parse and display JSON syntax errors with location details (line/column or position) for better user feedback during configuration.

src/lib/schemas · high confidence

The provider configuration forms now use a modular hook-based architecture to manage state, replacing previous inline or monolithic logic. This change introduces dedicated hooks for specific concerns: \useApiKeyState\ and \useBaseUrlState\ handle credential and endpoint synchronization for JSON-based providers (Claude, Gemini), while \useCodexConfigState\ and \useCodexTomlValidation\ manage TOML-based Codex configurations, including real-time syntax validation and model catalog mapping. Common configuration snippets for Claude, Codex, and Gemini are now managed by \useCommonConfigSnippet\, \useCodexCommonConfig\, and \useGeminiCommonConfig\, which handle persistence, migration from legacy storage, and safe merging. Additionally, \useManagedAuth\ centralizes OAuth flows for Codex, Copilot, and xAI, while \useApiKeyLink\ and \useProviderCategory\ standardize UI elements like API key links and category-based visibility across all provider forms.

src/components/providers/forms/hooks · high confidence

The provider configuration forms have been restructured into a set of focused, reusable components to improve maintainability and support complex provider-specific workflows. This change introduces dedicated sections for authentication (including Codex OAuth, GitHub Copilot, and xAI OAuth), base configuration fields (name, icon, notes), and API key inputs. It also adds specialized editors for common configuration snippets (JSON/TOML) with features like dark mode support, extraction from current providers, and real-time validation. Provider-specific forms (such as Claude Desktop and Codex) now leverage these modular pieces to handle advanced options like model routing, API format selection, and endpoint speed testing, resulting in a more consistent and extensible form architecture.

src/components/providers/forms · high confidence

The MCP configuration interface has been rebuilt with a new UnifiedMcpPanel that provides searchable lists and bulk toggling for enabling MCP servers across apps (Claude, Codex, Gemini, GrokBuild, OpenCode, etc.). Adding or editing a server now uses a new McpFormModal that supports both JSON and TOML formats, includes a collapsible metadata section, and validates input using the extracted useMcpValidation hook. A new McpWizardModal helps users quickly generate configurations for stdio, HTTP, or SSE transports with live preview and validation. The form also pre-fills from existing configurations and handles duplicate ID detection.

src/components/mcp · high confidence

The release pipeline now mirrors in-app updater and website download assets to Cloudflare R2. A new script generates a website download manifest (manifest.json) that includes SHA-256 checksums and the real release publish date for each platform and architecture, while another script rewrites the Tauri updater manifest (latest.json) to point download URLs at the R2 mirror instead of GitHub Releases. This ensures faster, more reliable downloads for users and keeps the updater signature verification intact.

scripts · high confidence

The shared type definitions for Provider, ProviderStatus, and AppConfig, along with the global declaration of the electronAPI interface, have been removed from the codebase. This change eliminates the centralized TypeScript contracts and the client-side API surface used to interact with the Electron backend for provider management and status checking, indicating a shift in how these data structures and IPC methods are handled or defined elsewhere.

src/shared · high confidence

Skill installation and management errors are now parsed into structured objects and translated into user-friendly messages in the user's preferred language. The new \skillErrorParser\ module maps specific error codes (such as missing repositories, download failures, or archive issues) to localized keys, providing clear titles and descriptions along with actionable suggestions (e.g., checking network or proxy settings) to help users resolve issues more easily.

src/lib/errors · high confidence

The Windows MSI installer has been updated to support per-user installations, targeting the user's LocalAppData folder instead of the system-wide Program Files directory. This change allows users to install the application without administrative privileges, with registry keys and shortcuts stored under HKCU (HKEY\_CURRENT\_USER) rather than HKLM, and includes logic to detect and migrate from previous installation directories.

src-tauri/wix · high confidence

A new .gitattributes file is added to enforce consistent LF line endings for source and configuration files (Rust, TOML, JSON, Markdown, YAML, TypeScript, JavaScript, HTML, CSS, Shell scripts) while marking binary assets (images, fonts, executables) as binary. This prevents Windows-style CRLF line endings from being committed, resolving potential issues with script execution, diff readability, and cross-platform consistency.

(repo-wide) · high confidence

The proxy now includes a circuit breaker to prevent requests to unhealthy providers, automatic failover switching with UI synchronization, and a body filter that strips private parameters (fields starting with \\_\) to prevent internal information leakage. It also supports decompressing stacked HTTP content encodings (such as gzip, zstd, and deflate) with output size limits to defend against decompression bombs, and introduces a Copilot optimizer to reduce premium interaction consumption by correctly classifying agent vs. user requests.

src-tauri/src/proxy · high confidence

Added MSW-based test infrastructure for Tauri API mocking; Added comprehensive test coverage for provider presets and configuration; Added frontend testing infrastructure with vitest and MSW; Added integration tests for App and SettingsDialog components; Added test coverage for configuration and utility functions; Added tests for frontend error logging, usage resilience, and model pricing sync; Added unit tests for application hooks; Expanded integration test coverage for configuration, provider, and profile management; Expanded test coverage for provider configuration and management components.

The application has moved from an Electron-based architecture to Tauri 2, replacing the \electron\ and \electron-builder\ packages with \@tauri-apps/cli\ and integrating Tauri plugins for the updater, process, dialog, and window state. The frontend dependency list has been significantly expanded to support this new stack and UI enhancements, adding Radix UI primitives, CodeMirror 6 for code editing, DnD Kit for drag-and-drop sorting, React Hook Form, and i18next for internationalization. Additionally, the build tooling has been updated to use pnpm, Vite 7, and Vitest for testing.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 42 → 54 (+12.4)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 65 → 60 (-4.6)
• Architecture 95 (new)
• Maturity 78 → 74 (-4.8)
• Readiness 25 → 55 (+29.3)
• Security 49 → 61 (+12.8)
• Accessibility 47 (new)

• Boundary-crossing change coupling: RequestLogTable.tsx ↔ usage.ts (src/components/usage/RequestLogTable.tsx)
• Boundary-crossing change coupling: UnifiedSkillsPanel.tsx ↔ useSkills.ts (src/components/skills/UnifiedSkillsPanel.tsx)
• Boundary-crossing change coupling: codexProviderPresets.ts ↔ index.ts (src/config/codexProviderPresets.ts)
• Boundary-crossing change coupling: codexProviderPresets.ts ↔ metadata.ts (src/config/codexProviderPresets.ts)
• Boundary-crossing change coupling: openclawProviderPresets.ts ↔ metadata.ts (src/config/openclawProviderPresets.ts)
• Boundary-crossing change coupling: opencodeProviderPresets.ts ↔ index.ts (src/config/opencodeProviderPresets.ts)
• Boundary-crossing change coupling: opencodeProviderPresets.ts ↔ metadata.ts (src/config/opencodeProviderPresets.ts)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Dimension evaluation failed
• High CVE: [GHSA redacted] (src-tauri/Cargo.lock)
• High CVE: [GHSA redacted] (src-tauri/Cargo.lock)
• High CVE: [GHSA redacted] (src-tauri/Cargo.lock)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (src-tauri/Cargo.lock)
• High CVE: [GHSA redacted] (src-tauri/Cargo.lock)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (src-tauri/Cargo.lock)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (src-tauri/Cargo.lock)
• …and 62 more

• AboutSection.AboutSection (cognitive 174) (src/components/settings/AboutSection.tsx)
• AboutSection.AboutSection (cyclomatic 137) (src/components/settings/AboutSection.tsx)
• AddProviderDialog.AddProviderDialog (cognitive 125) (src/components/providers/AddProviderDialog.tsx)
• AddProviderDialog.AddProviderDialog (cyclomatic 84) (src/components/providers/AddProviderDialog.tsx)
• AgentsDefaultsPanel.AgentsDefaultsPanel (cognitive 40) (src/components/openclaw/AgentsDefaultsPanel.tsx)
• AgentsDefaultsPanel.AgentsDefaultsPanel (cyclomatic 39) (src/components/openclaw/AgentsDefaultsPanel.tsx)
• Ambiguous/Overlapping data retrieval methods. get_failover_queue and get_failover_providers have nearly identical names and likely return the same data (the list of providers in the failover queue). get_available_providers_for_failover might be distinct (providers eligible for failover vs those in the queue), but the naming is confusing. If get_failover_providers returns the queue contents, it duplicates get_failover_queue.
• AnthropicToResponsesState::close_block (cognitive 23) (src-tauri/src/proxy/providers/streaming_codex_anthropic.rs)
• App.App (cognitive 187) (src/App.tsx)
• App.App (cyclomatic 229) (src/App.tsx)
• AppCountBar.AppCountBar (cyclomatic 16) (src/components/common/AppCountBar.tsx)
• AppSwitcher.AppSwitcher (cyclomatic 16) (src/components/AppSwitcher.tsx)
• BackupListSection.BackupListSection (cognitive 38) (src/components/settings/BackupListSection.tsx)
• BackupListSection.BackupListSection (cyclomatic 32) (src/components/settings/BackupListSection.tsx)
• Boundary-crossing change coupling: ProviderCard.tsx ↔ subscription.ts (src/components/providers/ProviderCard.tsx)
• BufferedCitationTextState::finish_unkeyed_text (cognitive 28) (src-tauri/src/proxy/providers/streaming_responses.rs)
• BufferedCitationTextState::finish_unkeyed_text (cyclomatic 18) (src-tauri/src/proxy/providers/streaming_responses.rs)
• BufferedCitationTextState::merge_part_indices (cognitive 30) (src-tauri/src/proxy/providers/streaming_responses.rs)
• BufferedCitationTextState::merge_part_indices (cyclomatic 24) (src-tauri/src/proxy/providers/streaming_responses.rs)
• BufferedCitationTextState::render_message_part (cognitive 42) (src-tauri/src/proxy/providers/streaming_responses.rs)
• …and 1428 more

• 246 commits — 96 feature/other, 150 fixes

• src-tauri/src — 112 commits
• src/config — 41 commits
• src/components — 27 commits
• src/i18n — 22 commits
• (root) — 15 commits
• docs/user-manual — 7 commits
• tests/config — 6 commits
• docs/release-notes — 5 commits
• .github/workflows — 3 commits
• src/App.tsx — 2 commits
• .github/labeler.yml — 1 commit
• docs/guides — 1 commit
• src-tauri/capabilities — 1 commit
• src-tauri/tests — 1 commit
• src-tauri/wix — 1 commit
• src/icons — 1 commit

• fix: ci: fix i18n labeler glob to match actual locales path
• fix: fix(a11y): add accessible names to GUI controls (#7049)
• fix: fix(backup): preserve SQL fidelity and recovery safety (#6146)
• fix: fix(capabilities): grant process:allow-exit so exit buttons can quit the app
• fix: fix(ci): clear clippy dead_code and question_mark
• fix: fix(ci): run WSL2 contract tests via prebuilt binaries (#6472)
• fix: fix(ci): stabilize frontend tests and verify renderer build
• fix: fix(claude): align advanced options with Codex (#6200)
• fix: fix(claude): align quick model selection with form order
• fix: fix(claude): exclude workflow journal.jsonl from session list
• fix: fix(claude): expose Opus 5 and Sonnet 5 in takeover mode (#5882)
• fix: fix(claude): hide session URL attribution (#7053)
• fix: fix(claude-desktop): align provider form frame (#6205)
• fix: fix(claude-desktop): clarify model configuration modes (#6208)
• fix: fix(claude-desktop): expose the 1M context variant for DeepSeek V4 routes
• fix: fix(codex): add vision-capable glm-5.3-flash to Zhipu GLM presets (#7689)
• fix: fix(codex): address xAI native Responses review findings
• fix: fix(codex): align OAuth client identity for GPT-6 (#7132)
• fix: fix(codex): allow multiple follow-login providers (#6535)
• fix: fix(codex): backfill names for all custom tables, never for Bedrock ones
• …and 226 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

farion1231/cc-switch was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.