43 Commits

  • feat(codex): add unified session history toggle for official providers
    Codex buckets resume history by the model_provider id recorded in each
    session: official runs (no key, built-in "openai") and cc-switch
    third-party runs (shared "custom") are mutually invisible in the resume
    picker. Add an opt-in setting that runs official providers under the
    shared "custom" id so future official sessions land in the same history
    bucket as third-party ones. Forward-only by design: existing sessions
    are not migrated.
    
    When enabled, official live config.toml gets model_provider = "custom"
    plus a [model_providers.custom] entry that mirrors the built-in openai
    provider (requires_openai_auth routes auth to the ChatGPT login in
    auth.json, name "OpenAI" keeps is_openai() feature gates, explicit
    supports_websockets/wire_api restore built-in defaults). auth.json is
    untouched.
    
    Key invariants:
    - Injection lives only in the live config: switch-away backfill strips
      the exact injected shape, so stored provider configs stay clean and
      turning the toggle off fully reverts on the next write.
    - Toggle changes apply immediately via a takeover-aware reapply: when
      the proxy owns the live config (backup/placeholder present), only the
      live backup is updated, mirroring the provider-switch path.
    - The takeover backup path runs the same injection so a takeover
      release restores a config that still carries the unified routing.
    - Injection refuses to activate a foreign [model_providers.custom]
      table (e.g. stale entry with a third-party base_url) to avoid routing
      ChatGPT OAuth traffic to an unknown backend.
    
    The toggle lives under Settings → Codex App Enhancements; the
    description warns that resuming old sessions across providers may fail
    because encrypted_content reasoning only decrypts on the backend that
    created it (upstream treats cross-provider resume as unsupported).
  • fix: usage script provider credential resolution (#1479)
    The JS-script usage path resolved {{apiKey}}/{{baseUrl}} with env-only
    field guessing, so apps that store credentials elsewhere (Codex:
    auth.OPENAI_API_KEY + config.toml base_url) always got empty values and
    custom-template queries failed despite a fully configured provider.
    
    - query_usage / test_usage_script now delegate to
      Provider::resolve_usage_credentials, the same per-app resolver used by
      the native balance/coding-plan path and mirrored by the frontend
      getProviderCredentials; explicit non-empty script values still win
    - test_usage_script loads the provider and applies the same fallback,
      so testing matches what a saved script does
    - the custom-template variable preview shows the effective values
      (script overrides first, then provider config) instead of always
      showing provider credentials
    - extract_codex_base_url documents and test-locks the frontend-mirror
      invariant: non-active [model_providers.*] sections are never read
    
    Reworked from the original patch to reuse the existing resolver instead
    of duplicating per-app extraction.
    
    Co-authored-by: Jason <farion1231@gmail.com>
  • feat(proxy): add GET /v1/models endpoint for Codex CLI reachability check (#3818)
    * feat(proxy): add GET /v1/models endpoint for Codex CLI reachability check
    
    Codex CLI probes GET /v1/models at startup. Without this endpoint the proxy
    returns 404, causing Codex to fail before any request reaches the upstream
    LLM.
    
    Return an OpenAI-compatible model list derived from the cc-switch–managed
    model catalog file.
    
    Fixes #3812
    
    * fix(proxy): return Codex catalog schema from /v1/models
    
    Codex deserializes the response as a catalog with a top-level `models`
    field, not the OpenAI `{"object":"list","data":[...]}` envelope.
    Return the catalog file content directly so the format matches what
    Codex expects.
    
    Co-authored-by: Codex review bot
    
    * fix(proxy): guard /v1/models against serving stale catalog
    
    Only return the model catalog when config.toml still references it via
    `model_catalog_json`.  After switching to a provider without a custom
    catalog, the old file lingers on disk — serving it unconditionally
    would advertise the previous provider's models to Codex.
    
    Co-authored-by: Codex review bot
    
    * fix(proxy): match relative model_catalog_json in stale-guard
    
    cc-switch writes `model_catalog_json = "cc-switch-model-catalog.json"`
    (relative) via set_codex_model_catalog_json_field.  Match on the
    filename constant rather than the absolute path so the guard works
    with both relative and absolute paths.
    
    Co-authored-by: Codex review bot
    
    * fix(proxy): parse model_catalog_json field instead of substring match
    
    Replace raw config_text.contains() with proper TOML field parsing so
    commented-out lines and stray mentions of the filename in other fields
    don't defeat the stale guard.  Also switch from contains() to exact
    filename match (Path::new(val).file_name() == Some(...)) to stay
    consistent with resolve_cc_switch_catalog_path in codex_config.rs.
    
    Add log::debug! when the guard blocks serving so the operator can
    distinguish "no models configured" from "guard blocked stale catalog".
    
    * refactor(proxy): reuse resolve_cc_switch_catalog_path in handle_models
    
    Replace the inline config.toml parsing and filename match in
    handle_models with the existing resolve_cc_switch_catalog_path helper
    (now pub(crate)). This removes the duplicated stale-guard logic, keeps
    a single source of truth for catalog-path ownership, and makes the
    handler honor absolute model_catalog_json paths the same way Codex
    live-setting import does.
    
    ---------
    
    Co-authored-by: Jason <farion1231@gmail.com>
  • fix(codex): use relative filename for model_catalog_json (#3614)
    * fix(codex): use relative filename for model_catalog_json
    
    Instead of writing an absolute path (which breaks on WSL/symlink setups),
    write only the filename "cc-switch-model-catalog.json" to config.toml.
    Codex CLI resolves relative paths from the config directory, and both
    files always reside in the same directory (~/.codex/).
    
    This eliminates the need for UNC-to-Linux path translation and makes
    the config portable across Windows, WSL, and symlinked directories.
    
    Also simplifies ownership checks in resolve_cc_switch_catalog_path()
    and set_codex_model_catalog_json_field() by removing dead string-equality
    comparisons that never matched on WSL.
    
    Closes farion1231/cc-switch#3573
    Related: farion1231/cc-switch#3569
    
    * style(codex): fix rustfmt violations in model_catalog tests
    
    Wrap a >100-col UNC-path line and remove a trailing blank line that broke 'cargo fmt --check' in Backend CI. Style-only, no logic change.
    
    ---------
    
    Co-authored-by: steponeerror <huxaio0207@qq.com>
    Co-authored-by: Jason <farion1231@gmail.com>
  • Fix Codex model catalog lost on proxy takeover-off restore
    Turning proxy takeover off restores Live from a stored backup via
    write_codex_live_verbatim. That path mishandled the Codex model catalog
    for two backup shapes that need opposite treatment:
    
    - Snapshot backup (read_codex_live_settings -> {auth, config}): no inline
      modelCatalog, but the config.toml text already carries the live
      model_catalog_json pointer. The old code ran catalog projection, which
      saw no specs and stripped the pointer.
    - Provider-rebuilt backup (update_live_backup_from_provider): inline
      modelCatalog (DB SSOT) with a pointer-less config text. A pure verbatim
      write ignored the inline catalog and never regenerated the pointer.
    
    The projection decision is orthogonal to auth: a provider-rebuilt backup
    can pair an inline modelCatalog with empty auth.json ({}) when the API key
    lives in the config's experimental_bearer_token. The empty-auth branch
    raw-wrote config and skipped projection entirely, so that shape lost its
    mapping too.
    
    Decide the config.toml text once, before splitting on auth, via the new
    prepare_codex_live_config_text_with_optional_catalog helper: project only
    when an inline modelCatalog is present, else keep the text raw (preserving
    any existing pointer). Every config-writing branch (write-auth,
    delete-auth, no-auth) now applies it consistently. Add regression tests
    covering all three shapes.
  • fix(usage): resolve per-app credentials for native balance/coding-plan queries (#3355)
    * fix(usage): resolve per-app credentials for native balance/coding-plan queries
    
    The native usage-query paths (balance + coding_plan) in
    `query_provider_usage_inner` read credentials only from `env.ANTHROPIC_*`.
    That matches Claude providers, but Codex stores its key in
    `auth.OPENAI_API_KEY` with the base URL inside a TOML `config` string,
    Hermes/OpenClaw flatten them at the top level, and OpenCode nests them under
    `options`. So the card "refresh usage" / auto-query returned empty
    credentials and failed ("查询失败") for those apps, even though the
    config-page "Test" button worked (the frontend extracts per-app correctly).
    
    Introduce a single per-app resolver `Provider::resolve_usage_credentials`
    that mirrors the frontend `getProviderCredentials`, and route both native
    branches through it. Add `extract_codex_base_url` to `codex_config` as the
    canonical Codex TOML base-URL parser and make the proxy adapter delegate to
    it (removing a duplicate copy). Align the frontend `getProviderCredentials`
    to cover OpenCode and Claude Desktop and to use the same OpenRouter/Google
    key fallbacks as the backend.
    
    Fixes #3158
    Fixes #3100
    Fixes #2625
    
    * refactor(usage): explicit AppType arms + frontend trailing-slash trim
    
    Address two review nits on the per-app credential resolver:
    
    - provider.rs: replace the catch-all `_` arm in resolve_usage_credentials with an explicit `AppType::Claude | AppType::ClaudeDesktop` arm, so a new AppType variant fails to compile here instead of silently defaulting to the Anthropic env shape.
    - UsageScriptModal.tsx: normalize getProviderCredentials baseUrl through a single trailing-slash trim so the frontend 'Test' path matches the backend resolver (trim_end_matches), keeping front/back truly in lockstep.
    
    No behavior change for well-formed configs; tests/typecheck/fmt/clippy clean.
    
    * fix(usage): skip empty primary credential fields in fallback chain
    
    `obj.get(key)` returns `Some` for a present-but-empty field, so the
    `.or_else()` fallback chains for the Claude/ClaudeDesktop and Gemini api-key
    lookups only skipped *absent* keys, not empty ones. Presets seed fields like
    `ANTHROPIC_AUTH_TOKEN` as present-but-empty placeholders, so a provider whose
    real key lives in a fallback field (`ANTHROPIC_API_KEY` / `OPENROUTER_API_KEY`
    / `GOOGLE_API_KEY`, or `GOOGLE_API_KEY` for Gemini) resolved to an empty key on
    the native balance/coding-plan path — while the frontend `a || b` (which skips
    empty strings) still found it, reproducing the same Test-works / refresh-fails
    divergence this PR removes.
    
    Add a `first_non_empty` helper that skips present-but-empty values, matching
    the frontend `||` semantics, and use it for both fallback chains. Tests cover
    empty primary + populated fallback for Claude and Gemini.
  • fix(codex): add multi-platform CLI discovery and static gpt-5.5 template fallback (#3382)
    * fix(codex): add multi-platform CLI discovery and static gpt-5.5 template fallback for model catalog generation
    
    When cc-switch generates a Codex model catalog for third-party providers,
    it needs the gpt-5.5 model definition as a template. Previously it relied
    on either ~/.codex/models_cache.json (only exists when Codex has connected
    to OpenAI) or running 'codex debug models --bundled' (fails when codex
    is not on the Tauri app's PATH, common in macOS GUI environments).
    
    This commit adds a three-tier fallback:
    1. Try 'codex' from PATH, then platform-specific common paths
       (/opt/homebrew/bin/codex, /usr/local/bin/codex, etc.)
    2. If all CLI attempts fail, use a compile-time embedded gpt-5.5
       template (extracted from codex 0.135.0 bundled models)
    
    Also adds tests for the static template validity and CLI candidates.
    
    * fix(codex): discover user node codex installs
    
    ---------
    
    Co-authored-by: Jason <farion1231@gmail.com>
  • Fix Codex OAuth auth being cleared during preserve-mode takeover
    When "preserve official auth on switch" is enabled, proxy takeover routes
    the PROXY_MANAGED placeholder into config.toml's experimental_bearer_token
    and leaves auth.json (the ChatGPT OAuth login) untouched. Takeover detection
    only inspected auth.json's OPENAI_API_KEY, so it never recognized this state
    and returned a false negative, which led downstream paths to clobber the
    preserved OAuth login.
    
    - Detection: is_codex_live_taken_over now also matches a config.toml
      experimental_bearer_token equal to the placeholder, fixing detect/cleanup/
      restore/startup-recovery in one place.
    - Cleanup: remove the config.toml bearer token only when it equals the
      placeholder (new remove_codex_experimental_bearer_token_if predicate), so a
      real third-party key is never stripped.
    - Write: under preservation, the None-provider takeover path writes only
      config.toml and keeps auth.json intact, matching the provider path.
    - Settings: rename the section to "Codex App Enhancements" and reword the
      description across all four locales.
    - Add tests covering OAuth preservation on takeover and placeholder-only
      cleanup.
  • Refactor Codex live-write routing and cover default auth overwrite
    Collapse the two duplicated write_codex_live_atomic branches in
    write_codex_live_for_provider into a single should_write_auth guard.
    This is behavior-preserving: `if A {X} else if B {X} else {Y}` becomes
    `if A || B {X} else {Y}`.
    
    Adapt the Codex switch tests to the new opt-in default for
    preserve_codex_official_auth_on_switch (flipped off in 3f59ab37):
    add an enable_codex_official_auth_preservation() test helper for the
    cases that assert the auth-preserving path, and tag the official login
    provider with category="official" so it routes through the official
    branch rather than relying on the global preservation flag.
    
    Add a regression test locking the default (preservation off) behavior:
    switching to a third-party provider rewrites auth.json with the new
    API key and discards the existing ChatGPT OAuth login. This is the
    dual of the existing preserve-and-backfill test, which only covered
    the opt-in path.
  • refactor(codex): unify custom model_provider routing key to "custom"
    - Always emit `model_provider = "custom"` from deep link, UniversalProvider, and the universal form modal so future writes share one stable routing key.
    - Add `codex_provider_template_v1` local migration that rewrites legacy keys (aihubmix/ccswitch/...) under `[model_providers.custom]`, updates profile refs, and backs up the original settings_config under `~/.cc-switch/backups/<timestamp>/providers/`.
    - Tighten history migration source detection to a whitelist plus `[model_providers.<id>]` existence check so user-authored keys are never rewritten in jsonl/state DB.
    - Encode deep link name/model/endpoint through `toml_edit::Value` so display names containing quotes or backslashes no longer break the generated config.toml.
    - Stabilize provider settings backup filename hash with Sha256 (was process-random SipHash).
  • refactor(codex): stop force-rewriting user's model_provider field in live config
    The one-time history migration already consolidates legacy provider IDs
    into a single bucket; there is no need to normalize on every write.
    This preserves user-chosen provider identities through the full
    write/backup/restore cycle.
  • chore: satisfy clippy::nonminimal_bool and prettier to unblock CI
    - codex_config: rewrite `!(A && !B)` as `!A || B` (De Morgan-
      equivalent) — also reads more directly as "no OAuth, or
      already has provider API key".
    - UsageScriptModal: reflow conditional onto one line per prettier.
  • feat(codex): preserve OAuth login state during third-party provider switching
    Codex provider switches now only write config.toml for third-party providers,
    injecting the API key as experimental_bearer_token. The user's auth.json
    (ChatGPT OAuth tokens) is preserved. Official providers with login material
    still write auth.json normally. Backfill restores bearer tokens into stored
    provider auth.OPENAI_API_KEY to maintain canonical shape.
  • fix: preserve Codex model catalog on live read of active provider
    Editing the currently active Codex provider triggered `read_live_settings`,
    which returned only { auth, config }, omitting `modelCatalog`. The form's
    mapping table then initialized to empty, and a subsequent save wiped the
    DB's `modelCatalog` field — silently destroying user-configured model
    mappings after every CC Switch restart.
    
    The mappings already live on disk as a projection in
    `~/.codex/cc-switch-model-catalog.json` (pointed at by `config.toml`'s
    `model_catalog_json`). Reverse-parse that file so live reads return the
    same shape the save path writes.
    
    - Add `read_codex_model_catalog_simplified_from_live` to recover
      `{ model, displayName?, contextWindow? }` entries from the catalog file.
    - Skip user-managed external catalogs (filename != cc-switch-model-catalog.json)
      so we don't downgrade their richer structure to the simplified table.
    - Squash display_name == slug and context_window == default (config's
      `model_context_window`, or 128_000 fallback) so blank inputs round-trip
      back to blank instead of materializing fallback values in the UI.
    - Collapse all failure modes (missing file, parse error, no matching
      field) to Ok(None) so the editor stays openable when the projection
      file is absent or corrupt.
    - Wire the new function into `read_live_settings`'s Codex branch.
    - Cover the new pure helpers with 7 unit tests in codex_config::tests.
  • feat: unify Codex third-party providers into stable "custom" history bucket
    Codex filters resume history by `model_provider`, so switching between
    provider-specific ids like `rightcode` and `aihubmix` made past sessions
    appear to vanish. Collapse all third-party providers into a single
    stable bucket so cross-switch history stays visible.
    
    - Normalize live `model_provider` to "custom" on every Codex write
      (reserved built-in ids like openai/ollama are preserved).
    - Add device-level one-shot migration that rewrites historical JSONL
      session files and the `state_5.sqlite` threads table from legacy
      provider ids into the "custom" bucket. Backs up originals under
      `~/.cc-switch/backups/codex-history-provider-migration-v1/` and uses
      the SQLite Backup API for the state DB.
    - Record completion in `settings.json` under `localMigrations` so the
      migration is strictly idempotent across launches.
    - Update Codex provider preset templates to emit `model_provider = "custom"`
      out of the box.
  • fix: Codex model catalog WYSIWYG and config consolidation
    - Remove mergeCodexDefaultCatalogModelForSave implicit injection (P1)
      The model mapping table is now the single source of truth; no hidden
      entries are prepended on save.
    
    - Sync first catalog row model into config.toml on save
      Ensures Codex default request model matches the table's first entry
      instead of retaining a stale template value.
    
    - Remove API Format selector from CodexFormFields (P3)
      wire_api is always 'responses'; the selector confused users into
      thinking they were changing the upstream protocol. Only the 'Needs
      Local Routing' toggle remains.
    
    - Add restart hint to model mapping i18n text (P2)
      model_catalog_json is loaded at Codex startup; users are now informed
      that a restart is needed after changes.
    
    - Unify write_codex_live_with_catalog helper (P4)
      Replaces three scattered prepare+write call sites in config.rs,
      provider/live.rs, and proxy.rs with a single entry point.
    
    - Clean up useCodexConfigState dead state (P3 follow-up)
      Remove codexModelName, codexContextWindow, codexAutoCompactLimit and
      their handlers/effects since no component consumes them after the UI
      consolidation.
  • Add Chat Completions routing for Codex providers
    - Add a Codex API format selector and routing badge for Chat Completions providers.
    - Convert Codex Responses requests to upstream Chat Completions when routing is required.
    - Convert Chat Completions JSON and SSE responses back to Responses format.
    - Keep generated Codex wire_api values on Responses for Codex compatibility.
    - Add i18n labels, provider metadata handling, and focused conversion tests.
  • 修复 Codex 切换供应商后历史记录变化 (#2349)
    * Keep Codex history stable across provider switches
    
    * Restore template Codex provider id when backfilling live config
    
    Backfill writes the current Codex live config back to the previous
    provider's stored template after a switch. Because the live file now
    carries a normalized stable model_provider id, the previous provider's
    template would lose its own provider-specific id (and any matching
    [profiles.*] references) on every subsequent switch.
    
    Reverse the normalization at backfill time by rewriting model_provider,
    the active model_providers section, and matching profile references back
    to the template's original id.
    
    ---------
    
    Co-authored-by: Jason <farion1231@gmail.com>
  • refactor(proxy): transparent header forwarding via hyper client (#1714)
    * style(frontend): reformat provider forms, constants and hooks
    
    Apply prettier formatting across 5 frontend files. No logic changes.
    
    Changed files:
    - AddProviderDialog.tsx: reformat generic type annotation and callback
    - ClaudeFormFields.tsx: consolidate multi-line useState and Collapsible props
    - CodexConfigSections.tsx: expand single-line React imports to multi-line,
      collapse removeCodexTopLevelField() call
    - constants.ts: merge TemplateType into single line
    - useSkills.ts: expand single-line TanStack Query imports to multi-line,
      reformat uninstallSkill mutationFn chain
    
    * deps(proxy): add hyper ecosystem crates and manual decompression libs
    
    reqwest internally normalizes all header names to lowercase and does not
    preserve insertion order, causing proxied requests to differ from the
    original client requests. To achieve transparent header forwarding with
    original casing and order, introduce lower-level hyper HTTP client libs.
    
    New dependencies:
    - hyper-util 0.1: TokioExecutor + legacy Client with
      preserve_header_case support for HTTP/1.1
    - hyper-rustls 0.27: rustls-based TLS connector for hyper
    - http 1 / http-body 1 / http-body-util 0.1: HTTP type crates for
      hyper 1.x request/response construction
    - flate2 1: manual gzip/deflate decompression (replaces reqwest auto)
    - brotli 7: manual brotli decompression
    
    Changed dependencies:
    - serde_json: enable preserve_order feature to keep JSON field order
    - reqwest: drop gzip feature to prevent reqwest from overriding the
      client's original accept-encoding header
    
    * refactor(proxy): use hyper client for header-case preserving forwarding
    
    Previously the proxy used reqwest for all upstream requests. reqwest
    normalizes header names to lowercase and reorders them internally,
    making proxied requests distinguishable from direct CLI requests.
    Some upstream providers are sensitive to these differences.
    
    This commit replaces reqwest with a hyper-based HTTP client on the
    default (non-proxy) path, achieving wire-level header fidelity:
    
    Server layer (server.rs):
    - Replace axum::serve with a manual hyper HTTP/1.1 accept loop
    - Enable preserve_header_case(true) so incoming header casing is
      captured in a HeaderCaseMap extension on each request
    - Bridge hyper requests to axum Router via tower::Service
    
    New hyper client module (hyper_client.rs):
    - Lazy-initialized hyper-util Client with preserve_header_case
    - ProxyResponse enum wrapping both hyper::Response and reqwest::Response
      behind a unified interface (status, headers, bytes, bytes_stream)
    - send_request() builds requests with ordered HeaderMap + case map
    
    Request handlers (handlers.rs):
    - Switch from (HeaderMap, Json<Value>) extractors to raw
      axum::extract::Request to preserve Extensions (containing the
      HeaderCaseMap from the accept loop)
    - Pass extensions through the forwarding chain
    
    Forwarder (forwarder.rs):
    - Remove HEADER_BLACKLIST array; replace with ordered header iteration
      that preserves original header sequence and casing
    - Build ordered_headers by iterating client headers, skipping only
      auth/host/content-length, and inserting auth headers at the original
      authorization position to maintain order
    - Handle anthropic-beta (ensure claude-code-20250219 tag) and
      anthropic-version (passthrough or default) inline during iteration
    - Remove should_force_identity_encoding() — accept-encoding is now
      transparently forwarded to upstream
    - Use hyper client by default; fall back to reqwest only when an
      HTTP/SOCKS5 proxy tunnel is configured
    
    Provider adapters (adapter.rs, claude.rs, codex.rs, gemini.rs):
    - Replace add_auth_headers(RequestBuilder) -> RequestBuilder with
      get_auth_headers(AuthInfo) -> Vec<(HeaderName, HeaderValue)>
    - Adapters now return header pairs instead of mutating a reqwest builder
    - Claude adapter: merge Anthropic/ClaudeAuth/Bearer into single branch;
      move Copilot fingerprint headers into get_auth_headers
    
    Response processing (response_processor.rs):
    - Add manual decompression (gzip/deflate/brotli via flate2 + brotli)
      for non-streaming responses, since reqwest auto-decompression is now
      disabled to allow accept-encoding passthrough
    - Add compressed-SSE warning log for streaming responses
    - Accept ProxyResponse instead of reqwest::Response
    
    HTTP client (http_client.rs):
    - Disable reqwest auto-decompression (.no_gzip/.no_brotli/.no_deflate)
      on both global and per-provider clients
    
    Streaming adapters (streaming.rs, streaming_responses.rs):
    - Generalize stream error type from reqwest::Error to generic E: Error
    
    Misc:
    - log_codes.rs: add SRV-005 (ACCEPT_ERR) and SRV-006 (CONN_ERR)
    - stream_check.rs: reformat copilot header lines
    - transform.rs: fix trailing whitespace alignment
    
    * fix(lint): resolve 35 clippy warnings across Rust codebase
    
    Fix all clippy warnings reported by `cargo clippy --lib`:
    
    - codex_config.rs: fix doc_overindented_list_items (3 spaces -> 2)
    - commands/copilot.rs: inline format args in 2 log::error! calls
    - commands/provider.rs: inline format args in 3 map_err closures
    - proxy/hyper_client.rs: inline format arg in log::debug! call
    - proxy/providers/copilot_auth.rs: inline format args in 16 locations
      (log macros, format! in headers, error constructors)
    - proxy/thinking_optimizer.rs: inline format args in 2 log::info! calls
    - services/skill.rs: inline format args in log::debug! call
    - services/webdav_sync.rs: inline format args in 6 format! calls
      (version compat messages, download limit messages)
    - services/webdav_sync/archive.rs: inline format args in 2 format! calls
    - session_manager/providers/opencode.rs: inline format args in
      source_path format!
    
    All fixes use the clippy::uninlined_format_args suggestion pattern:
      format!("msg: {}", var)  ->  format!("msg: {var}")
    
    * deps(proxy): add raw HTTP write and native TLS cert dependencies
    
    Add crates required for the raw TCP/TLS write path that bypasses
    hyper's header encoder to preserve original header name casing:
    
    - httparse: parse raw TCP peek bytes to capture header casings
    - tokio-rustls + rustls: direct TLS connections for raw write path
    - webpki-roots: Mozilla CA bundle baseline
    - rustls-native-certs: load system keychain CAs (trusts proxy MITM
      certificates from Clash, mitmproxy, etc.)
    
    * fix(proxy): address code review feedback on response handling
    
    Fixes from PR #1714 code review:
    
    - Extract `read_decoded_body()` and `strip_entity_headers_for_rebuilt_body()`
      in response_processor to properly clean content-encoding/content-length
      headers after decompression
    - Reuse `read_decoded_body()` in handlers.rs for Claude transform path,
      ensuring compressed responses are decoded before format conversion
    - Make `build_proxy_url_from_config()` public so forwarder can pass proxy
      URL to the hyper raw write path
    - Add `has_system_proxy_env()` utility with test coverage
    - Add 50ms backoff after accept() failures in server.rs to prevent
      tight-loop CPU spin on transient socket errors
    
    * feat(proxy): implement raw TCP/TLS write with HTTP CONNECT tunnel
    
    Rewrite hyper_client with a two-tier strategy for header case preservation:
    
    Primary path (raw write):
    - Peek raw TCP bytes in server.rs to capture OriginalHeaderCases before
      hyper lowercases them
    - Build raw HTTP/1.1 request bytes with exact original header name casing
    - Write directly to TLS stream, then use WriteFilter to let hyper parse
      the response while discarding its duplicate request writes
    - Support HTTP CONNECT tunneling through upstream proxies, so header case
      is preserved even when a proxy (Clash, V2Ray) is configured
    
    Fallback path (hyper-util Client):
    - Used when OriginalHeaderCases is empty or raw write fails
    - Configured with title_case_headers(true) for best-effort casing
    
    TLS improvements:
    - Load native system certificates alongside webpki roots so proxy MITM
      CAs (installed in system keychain) are trusted through CONNECT tunnels
    
    Key types added:
    - OriginalHeaderCases: maps lowercase name → original wire-casing bytes
    - WriteFilter<S>: AsyncRead+AsyncWrite wrapper that discards writes
    - connect_via_proxy(): HTTP CONNECT tunnel establishment
    - ExtensionDebugMarker: diagnostic marker for extension chain debugging
    
    * refactor(proxy): route requests through hyper with proxy-aware forwarding
    
    Rework forwarder request dispatch to always prefer the hyper raw write
    path (header case preservation) over reqwest:
    
    Request routing:
    - HTTP/HTTPS proxy: hyper raw write through CONNECT tunnel (case preserved)
    - SOCKS5 proxy: reqwest fallback (CONNECT not supported for SOCKS5)
    - No proxy: hyper raw write direct connection
    
    Header handling improvements:
    - Replace host header in-place at original position instead of
      skip-and-append, preserving client's header ordering
    - Preserve client's original accept-encoding for transparent passthrough;
      only force identity encoding when transform path needs decompression
    - Add should_force_identity_encoding() to centralize the decision
    - Remove hardcoded 'br, gzip, deflate' override that masked client values
    
    Proxy URL resolution (priority order):
    1. Provider-specific proxy config (if enabled)
    2. Global proxy URL configured in CC Switch
    3. Direct connection (no proxy)
    
    * chore(proxy): remove dead code, redundant tests and debug scaffolding
    
    - Inline should_force_identity_encoding() (was just `needs_transform`)
      and delete its 5 test cases
    - Remove ExtensionDebugMarker diagnostic type
    - Remove unused has_system_proxy_env() and its test
    - Remove strip_entity_headers test
    - Simplify hyper path: remove redundant is_socks_proxy ternary
    - Update hyper_client module doc to reflect CONNECT tunnel support
    
    * fix(proxy): block direct-connect fallback and complete CONNECT tunnel support
    
    * feat(hooks): improve proxy requirement warnings with specific reasons
    
    - Remove redundant OpenAI format hint toast messages
    - Add detailed reason detection for proxy requirements (OpenAI Chat, OpenAI Responses, full URL mode)
    - Update i18n files with new reason-specific keys
    
    * style(*): format code with prettier
    
    - Remove extra whitespace in http_client.rs
    - Fix formatting issues in useProviderActions.ts
    
    * fix(proxy): post-merge fixes for forward return type and clippy warnings
    
    - Restore forward() return type to (ProxyResponse, Option<String>)
      to pass claude_api_format through to callers
    - Inline format args in log::warn! macro (clippy::uninlined_format_args)
    - Suppress too_many_arguments for check_claude_stream
    
    * refactor(proxy): preserve original header wire order and add non-streaming body timeout
    
    - Rewrite build_raw_request to emit headers in original
      client-sent sequence instead of hash-map order
    - Remove unused OriginalHeaderCases::get_all method
    - Add body_timeout to read_decoded_body to prevent
      requests hanging when upstream stalls after headers
  • fix: make Codex TOML base_url editing section-aware
    Rewrite setCodexBaseUrl/extractCodexBaseUrl to understand TOML section
    boundaries, ensuring base_url is written into the correct
    [model_providers.<name>] section instead of being appended to file end.
    
    - Add section-aware TOML helpers in providerConfigUtils.ts
    - Extract shared update_codex_toml_field/remove_codex_toml_base_url_if
      in codex_config.rs, deduplicate proxy.rs TOML editing logic
    - Replace scattered inline base_url regexes with extractCodexBaseUrl()
    - Add comprehensive tests for both Rust and TypeScript implementations
  • refactor(config): consolidate get_home_dir into single public function
    Follow-up to #644: Extract duplicate get_home_dir() implementations
    into a single pub fn in config.rs, reducing code duplication across
    codex_config.rs, gemini_config.rs, and settings.rs.
    
    Also adds documentation comments to build.rs explaining the Windows
    manifest workaround for test binaries.
  • fix(windows): stabilize test environment (#644)
    * fix(windows): embed common-controls manifest
    
    * fix(windows): prefer HOME for config paths
    
    * test(windows): fix export_sql invalid path
    
    * fix(windows): remove unused env import in config.rs
  • Refactor/simplify proxy logs (#585)
    * refactor(proxy): simplify logging for better readability
    
    - Delete 17 verbose debug logs from handlers, streaming, and response_processor
    - Convert excessive INFO logs to DEBUG level for internal processing details
    - Add 2 critical INFO logs in forwarder.rs for failover scenarios:
      - Log when switching to next provider after failure
      - Log when all providers have been exhausted
    - Fix clippy uninlined_format_args warning
    
    This reduces log noise while maintaining visibility into key user-facing decisions.
    
    * fix: replace unsafe unwrap() calls with proper error handling
    
    - database/dao/mcp.rs: Use map_err for serde_json serialization
    - database/dao/providers.rs: Use map_err for settings_config and meta serialization
    - commands/misc.rs: Use expect() for compile-time regex pattern
    - services/prompt.rs: Use unwrap_or_default() for SystemTime
    - deeplink/provider.rs: Replace unwrap() with is_none_or pattern for Option checks
    
    Reduces potential panic points from 26 to 1 (static regex init, safe).
    
    * refactor(proxy): simplify verbose logging output
    
    - Remove response JSON full output logging in response_processor
    - Remove per-request INFO logs in provider_router (failover status, provider selection)
    - Change model mapping log from INFO to DEBUG
    - Change usage logging failure from INFO to WARN
    - Remove redundant debug logs for circuit breaker operations
    
    Reduces log noise significantly while preserving important warnings and errors.
    
    * feat(proxy): add structured log codes for i18n support
    
    Add error code system to proxy module logs for multi-language support:
    
    - CB-001~006: Circuit breaker state transitions and triggers
    - SRV-001~004: Proxy server lifecycle events
    - FWD-001~002: Request forwarding and failover
    - FO-001~005: Failover switch operations
    - USG-001~002: Usage logging errors
    
    Log format: [CODE] Chinese message
    Frontend/log tools can map codes to any language.
    
    New file: src/proxy/log_codes.rs - centralized code definitions
    
    * chore: bump version to 3.9.1
    
    * style: format code with prettier and rustfmt
    
    * fix(ui): allow number inputs to be fully cleared before saving
    
    - Convert numeric state to string type for controlled inputs
    - Use isNaN() check instead of || fallback to allow 0 values
    - Apply fix to ProxyPanel, CircuitBreakerConfigPanel,
      AutoFailoverConfigPanel, and ModelTestConfigPanel
    
    * feat(pricing): support @ separator in model name matching
    
    - Refactor model name cleaning into chained method calls
    - Add @ to - replacement (e.g., gpt-5.2-codex@low → gpt-5.2-codex-low)
    - Add test case for @ separator matching
    
    * fix(proxy): improve validation and error handling in proxy config panels
    
    - Add StopTimeout/StopFailed error types for proper stop() error reporting
    - Replace silent clamp with validation-and-block in config panels
    - Add listenAddress format validation in ProxyPanel
    - Use log_codes constants instead of hardcoded strings
    - Use once_cell::Lazy for regex precompilation
    
    * fix(proxy): harden error handling and input validation
    
    - Handle RwLock poisoning in settings.rs with unwrap_or_else
    - Add fallback for dirs::home_dir() in config modules
    - Normalize localhost to 127.0.0.1 in ProxyPanel
    - Format IPv6 addresses with brackets for valid URLs
    - Strict port validation with pure digit regex
    - Treat NaN as validation failure in config panels
    - Log warning on cost_multiplier parse failure
    - Align timeoutSeconds range to [0, 300] across all panels
  • Refactor/storage (#277)
    * feat(components): add reusable full-screen panel components
    
    Add new full-screen panel components to support the UI refactoring:
    
    - FullScreenPanel: Reusable full-screen layout component with header,
      content area, and optional footer. Provides consistent layout for
      settings, prompts, and other full-screen views.
    
    - PromptFormPanel: Dedicated panel for creating and editing prompts
      with markdown preview support. Features real-time validation and
      integrated save/cancel actions.
    
    - AgentsPanel: Panel component for managing agent configurations.
      Provides a consistent interface for agent CRUD operations.
    
    - RepoManagerPanel: Full-featured repository manager panel for Skills.
      Supports repository listing, addition, deletion, and configuration
      management with integrated validation.
    
    These components establish the foundation for the upcoming settings
    page migration from dialog-based to full-screen layout.
    
    * refactor(settings): migrate from dialog to full-screen page layout
    
    Complete migration of settings from modal dialog to dedicated full-screen
    page, improving UX and providing more space for configuration options.
    
    Changes:
    - Remove SettingsDialog component (legacy modal-based interface)
    - Add SettingsPage component with full-screen layout using FullScreenPanel
    - Refactor App.tsx routing to support dedicated settings page
      * Add settings route handler
      * Update navigation logic from dialog-based to page-based
      * Integrate with existing app switcher and provider management
    - Update ImportExportSection to work with new page layout
      * Improve spacing and layout for better readability
      * Enhanced error handling and user feedback
      * Better integration with page-level actions
    - Enhance useSettings hook to support page-based workflow
      * Add navigation state management
      * Improve settings persistence logic
      * Better error boundary handling
    
    Benefits:
    - More intuitive navigation with dedicated settings page
    - Better use of screen space for complex configurations
    - Improved accessibility with clearer visual hierarchy
    - Consistent with modern desktop application patterns
    - Easier to extend with new settings sections
    
    This change is part of the larger UI refactoring initiative to modernize
    the application interface and improve user experience.
    
    * refactor(forms): simplify and modernize form components
    
    Comprehensive refactoring of form components to reduce complexity,
    improve maintainability, and enhance user experience.
    
    Provider Forms:
    - CodexCommonConfigModal & CodexConfigSections
      * Simplified state management with reduced boilerplate
      * Improved field validation and error handling
      * Better layout with consistent spacing
      * Enhanced model selection with visual indicators
    - GeminiCommonConfigModal & GeminiConfigSections
      * Streamlined authentication flow (OAuth vs API Key)
      * Cleaner form layout with better grouping
      * Improved validation feedback
      * Better integration with parent components
    - CommonConfigEditor
      * Reduced from 178 to 68 lines (-62% complexity)
      * Extracted reusable form patterns
      * Improved JSON editing with syntax validation
      * Better error messages and recovery options
    - EndpointSpeedTest
      * Complete rewrite for better UX
      * Real-time testing progress indicators
      * Enhanced error handling with retry logic
      * Visual feedback for test results (color-coded latency)
    
    MCP & Prompts:
    - McpFormModal
      * Simplified from 581 to ~360 lines
      * Better stdio/http server type handling
      * Improved form validation
      * Enhanced multi-app selection (Claude/Codex/Gemini)
    - PromptPanel
      * Cleaner integration with PromptFormPanel
      * Improved list/grid view switching
      * Better state management for editing workflows
      * Enhanced delete confirmation with safety checks
    
    Code Quality Improvements:
    - Reduced total lines by ~251 lines (-24% code reduction)
    - Eliminated duplicate validation logic
    - Improved TypeScript type safety
    - Better component composition and separation of concerns
    - Enhanced accessibility with proper ARIA labels
    
    These changes make forms more intuitive, responsive, and easier to
    maintain while reducing bundle size and improving runtime performance.
    
    * style(ui): modernize component layouts and visual design
    
    Update UI components with improved layouts, visual hierarchy, and
    modern design patterns for better user experience.
    
    Navigation & Brand Components:
    - AppSwitcher
      * Enhanced visual design with better spacing
      * Improved active state indicators
      * Smoother transitions and hover effects
      * Better mobile responsiveness
    - BrandIcons
      * Optimized icon rendering performance
      * Added support for more provider icons
      * Improved SVG handling and fallbacks
      * Better scaling across different screen sizes
    
    Editor Components:
    - JsonEditor
      * Enhanced syntax highlighting
      * Better error visualization
      * Improved code formatting options
      * Added line numbers and code folding support
    - UsageScriptModal
      * Complete layout overhaul (1239 lines refactored)
      * Better script editor integration
      * Improved template selection UI
      * Enhanced preview and testing panels
      * Better error feedback and validation
    
    Provider Components:
    - ProviderCard
      * Redesigned card layout with modern aesthetics
      * Better information density and readability
      * Improved action buttons placement
      * Enhanced status indicators (active/inactive)
    - ProviderList
      * Better grid/list view layouts
      * Improved drag-and-drop visual feedback
      * Enhanced sorting indicators
    - ProviderActions
      * Streamlined action menu
      * Better icon consistency
      * Improved tooltips and accessibility
    
    Usage & Footer:
    - UsageFooter
      * Redesigned footer layout
      * Better quota visualization
      * Improved refresh controls
      * Enhanced error states
    
    Design System Updates:
    - dialog.tsx (shadcn/ui component)
      * Updated to latest design tokens
      * Better overlay animations
      * Improved focus management
    - index.css
      * Added 65 lines of global utility classes
      * New animation keyframes
      * Enhanced color variables for dark mode
      * Improved typography scale
    - tailwind.config.js
      * Extended theme with new design tokens
      * Added custom animations and transitions
      * New spacing and sizing utilities
      * Enhanced color palette
    
    Visual Improvements:
    - Consistent border radius across components
    - Unified shadow system for depth perception
    - Better color contrast for accessibility (WCAG AA)
    - Smoother animations and transitions
    - Improved dark mode support
    
    These changes create a more polished, modern interface while
    maintaining consistency with the application's design language.
    
    * chore: update dialogs, i18n and improve component integration
    
    Various functional updates and improvements across provider dialogs,
    MCP panel, skills page, and internationalization.
    
    Provider Dialogs:
    - AddProviderDialog
      * Simplified form state management
      * Improved preset selection workflow
      * Better validation error messages
      * Enhanced template variable handling
    - EditProviderDialog
      * Streamlined edit flow with better state synchronization
      * Improved handling of live config backfilling
      * Better error recovery for failed updates
      * Enhanced integration with parent components
    
    MCP & Skills:
    - UnifiedMcpPanel
      * Reduced complexity from 140+ to ~95 lines
      * Improved multi-app server management
      * Better server type detection (stdio/http)
      * Enhanced server status indicators
      * Cleaner integration with MCP form modal
    - SkillsPage
      * Simplified navigation and state management
      * Better integration with RepoManagerPanel
      * Improved error handling for repository operations
      * Enhanced loading states
    - SkillCard
      * Minor layout adjustments
      * Better action button placement
    
    Environment & Configuration:
    - EnvWarningBanner
      * Improved conflict detection messages
      * Better visual hierarchy for warnings
      * Enhanced dismissal behavior
    - tauri.conf.json
      * Updated build configuration
      * Added new window management options
    
    Internationalization:
    - en.json & zh.json
      * Added 17 new translation keys for new features
      * Updated existing keys for better clarity
      * Added translations for new settings page
      * Improved consistency across UI text
    
    Code Cleanup:
    - mutations.ts
      * Removed 14 lines of unused mutation definitions
      * Cleaned up deprecated query invalidation logic
      * Better type safety for mutation parameters
    
    Overall Impact:
    - Reduced total lines by 51 (-10% in affected files)
    - Improved component integration and data flow
    - Better error handling and user feedback
    - Enhanced i18n coverage for new features
    
    These changes improve the overall polish and integration of various
    components while removing technical debt and unused code.
    
    * feat(backend): add auto-launch functionality
    
    Implement system auto-launch feature to allow CC-Switch to start
    automatically on system boot, improving user convenience.
    
    Backend Implementation:
    - auto_launch.rs: New module for auto-launch management
      * Cross-platform support using auto-launch crate
      * Enable/disable auto-launch with system integration
      * Proper error handling for permission issues
      * Platform-specific implementations (macOS/Windows/Linux)
    
    Command Layer:
    - Add get_auto_launch command to check current status
    - Add set_auto_launch command to toggle auto-start
    - Integrate commands with settings API
    
    Settings Integration:
    - Extend Settings struct with auto_launch field
    - Persist auto-launch preference in settings store
    - Automatic state synchronization on app startup
    
    Dependencies:
    - Add auto-launch ^0.5.0 to Cargo.toml
    - Update Cargo.lock with new dependency tree
    
    Technical Details:
    - Uses platform-specific auto-launch mechanisms:
      * macOS: Login Items via LaunchServices
      * Windows: Registry Run key
      * Linux: XDG autostart desktop files
    - Handles edge cases like permission denials gracefully
    - Maintains settings consistency across app restarts
    
    This feature enables users to have CC-Switch readily available
    after system boot without manual intervention, particularly useful
    for users who frequently switch between API providers.
    
    * refactor(settings): enhance settings page with auto-launch integration
    
    Complete refactoring of settings page architecture to integrate auto-launch
    feature and improve overall settings management workflow.
    
    SettingsPage Component:
    - Integrate auto-launch toggle with WindowSettings section
    - Improve layout and spacing for better visual hierarchy
    - Enhanced error handling for settings operations
    - Better loading states during settings updates
    - Improved accessibility with proper ARIA labels
    
    WindowSettings Component:
    - Add auto-launch switch with real-time status
    - Integrate with backend auto-launch commands
    - Proper error feedback for permission issues
    - Visual indicators for current auto-launch state
    - Tooltip guidance for auto-launch functionality
    
    useSettings Hook (Major Refactoring):
    - Complete rewrite reducing complexity by ~30%
    - Better separation of concerns with dedicated handlers
    - Improved state management using React Query
    - Enhanced auto-launch state synchronization
      * Fetch auto-launch status on mount
      * Real-time updates on toggle
      * Proper error recovery
    - Optimized re-renders with better memoization
    - Cleaner API for component integration
    - Better TypeScript type safety
    
    Settings API:
    - Add getAutoLaunch() method
    - Add setAutoLaunch(enabled: boolean) method
    - Type-safe Tauri command invocations
    - Proper error propagation to UI layer
    
    Architecture Improvements:
    - Reduced hook complexity from 197 to ~140 effective lines
    - Eliminated redundant state management logic
    - Better error boundaries and fallback handling
    - Improved testability with clearer separation
    
    User Experience Enhancements:
    - Instant visual feedback on auto-launch toggle
    - Clear error messages for permission issues
    - Loading indicators during async operations
    - Consistent behavior across all platforms
    
    This refactoring provides a solid foundation for future settings
    additions while maintaining code quality and user experience.
    
    * refactor(ui): optimize FullScreenPanel, Dialog and App routing
    
    Comprehensive refactoring of core UI components to improve code quality,
    maintainability, and user experience.
    
    FullScreenPanel Component:
    - Enhanced props interface with better TypeScript types
    - Improved layout flexibility with customizable padding
    - Better header/footer composition patterns
    - Enhanced scroll behavior for long content
    - Added support for custom actions in header
    - Improved responsive design for different screen sizes
    - Better integration with parent components
    - Cleaner prop drilling with context where appropriate
    
    Dialog Component (shadcn/ui):
    - Updated to latest component patterns
    - Improved animation timing and easing
    - Better focus trap management
    - Enhanced overlay styling with backdrop blur
    - Improved accessibility (ARIA labels, keyboard navigation)
    - Better close button positioning and styling
    - Enhanced mobile responsiveness
    - Cleaner composition with DialogHeader/Footer
    
    App Component Routing:
    - Refactored routing logic for better clarity
    - Improved state management for navigation
    - Better integration with settings page
    - Enhanced error boundary handling
    - Cleaner separation of layout concerns
    - Improved provider context propagation
    - Better handling of deep links
    - Optimized re-renders with React.memo where appropriate
    
    Code Quality Improvements:
    - Reduced prop drilling with better component composition
    - Improved TypeScript type safety
    - Better separation of concerns
    - Enhanced code readability with clearer naming
    - Eliminated redundant logic
    
    Performance Optimizations:
    - Reduced unnecessary re-renders
    - Better memoization of callbacks
    - Optimized component tree structure
    - Improved event handler efficiency
    
    User Experience:
    - Smoother transitions and animations
    - Better visual feedback for interactions
    - Improved loading states
    - More consistent behavior across features
    
    These changes create a more maintainable and performant foundation
    for the application's UI layer while improving the overall user
    experience with smoother interactions and better visual polish.
    
    * refactor(features): modernize Skills, Prompts and Agents components
    
    Major refactoring of feature components to improve code quality,
    user experience, and maintainability.
    
    SkillsPage Component (299 lines refactored):
    - Complete rewrite of layout and state management
    - Better integration with RepoManagerPanel
    - Improved navigation between list and detail views
    - Enhanced error handling with user-friendly messages
    - Better loading states with skeleton screens
    - Optimized re-renders with proper memoization
    - Cleaner separation between list and form views
    - Improved skill card interactions
    - Better responsive design for different screen sizes
    
    RepoManagerPanel Component (370 lines refactored):
    - Streamlined repository management workflow
    - Enhanced form validation with real-time feedback
    - Improved repository list with better visual hierarchy
    - Better handling of git operations (clone, pull, delete)
    - Enhanced error recovery for network issues
    - Cleaner state management reducing complexity
    - Improved TypeScript type safety
    - Better integration with Skills backend API
    - Enhanced loading indicators for async operations
    
    PromptPanel Component (249 lines refactored):
    - Modernized layout with FullScreenPanel integration
    - Better separation between list and edit modes
    - Improved prompt card design with better readability
    - Enhanced search and filter functionality
    - Cleaner state management for editing workflow
    - Better integration with PromptFormPanel
    - Improved delete confirmation with safety checks
    - Enhanced keyboard navigation support
    
    PromptFormPanel Component (238 lines refactored):
    - Streamlined form layout and validation
    - Better markdown editor integration
    - Real-time preview with syntax highlighting
    - Improved validation error display
    - Enhanced save/cancel workflow
    - Better handling of large prompt content
    - Cleaner form state management
    - Improved accessibility features
    
    AgentsPanel Component (33 lines modified):
    - Minor layout adjustments for consistency
    - Better integration with FullScreenPanel
    - Improved placeholder states
    - Enhanced error boundaries
    
    Type Definitions (types.ts):
    - Added 10 new type definitions
    - Better type safety for Skills/Prompts/Agents
    - Enhanced interfaces for repository management
    - Improved typing for form validations
    
    Architecture Improvements:
    - Reduced component coupling
    - Better prop interfaces with explicit types
    - Improved error boundaries
    - Enhanced code reusability
    - Better testing surface
    
    User Experience Enhancements:
    - Smoother transitions between views
    - Better visual feedback for actions
    - Improved error messages
    - Enhanced loading states
    - More intuitive navigation flows
    - Better responsive layouts
    
    Code Quality:
    - Net reduction of 29 lines while adding features
    - Improved code organization
    - Better naming conventions
    - Enhanced documentation
    - Cleaner control flow
    
    These changes significantly improve the maintainability and user
    experience of core feature components while establishing consistent
    patterns for future development.
    
    * style(ui): refine component layouts and improve visual consistency
    
    Comprehensive UI polish across multiple components to enhance visual
    design, improve user experience, and maintain consistency.
    
    UsageScriptModal Component (1302 lines refactored):
    - Complete layout overhaul for better usability
    - Improved script editor with syntax highlighting
    - Better template selection interface
    - Enhanced test/preview panels with clearer separation
    - Improved error feedback and validation messages
    - Better modal sizing and responsiveness
    - Cleaner tab navigation between sections
    - Enhanced code formatting and readability
    - Improved loading states for async operations
    - Better integration with parent components
    
    MCP Components:
    - McpFormModal (42 lines):
      * Streamlined form layout
      * Better server type selection (stdio/http)
      * Improved field grouping and labels
      * Enhanced validation feedback
    - UnifiedMcpPanel (14 lines):
      * Minor layout adjustments
      * Better list item spacing
      * Improved server status indicators
      * Enhanced action button placement
    
    Provider Components:
    - ProviderCard (11 lines):
      * Refined card layout and spacing
      * Better visual hierarchy
      * Improved badge placement
      * Enhanced hover effects
    - ProviderList (5 lines):
      * Minor grid layout adjustments
      * Better drag-and-drop visual feedback
    - GeminiConfigSections (4 lines):
      * Field label alignment
      * Improved spacing consistency
    
    Editor & Footer Components:
    - JsonEditor (13 lines):
      * Better editor height management
      * Improved error display
      * Enhanced syntax highlighting
    - UsageFooter (10 lines):
      * Refined footer layout
      * Better quota display
      * Improved refresh button placement
    
    Settings & Environment:
    - ImportExportSection (24 lines):
      * Better button layout
      * Improved action grouping
      * Enhanced visual feedback
    - EnvWarningBanner (4 lines):
      * Refined alert styling
      * Better dismiss button placement
    
    Global Styles (index.css):
    - Added 11 lines of utility classes
    - Improved transition timing
    - Better focus indicators
    - Enhanced scrollbar styling
    - Refined spacing utilities
    
    Design Improvements:
    - Consistent spacing using design tokens
    - Unified color palette application
    - Better typography hierarchy
    - Improved shadow system for depth
    - Enhanced interactive states (hover, active, focus)
    - Better border radius consistency
    - Refined animation timings
    
    Accessibility:
    - Improved focus indicators
    - Better keyboard navigation
    - Enhanced screen reader support
    - Improved color contrast ratios
    
    Code Quality:
    - Net increase of 68 lines due to UsageScriptModal improvements
    - Better component organization
    - Cleaner style application
    - Reduced style duplication
    
    These visual refinements create a more polished and professional
    interface while maintaining excellent usability and accessibility
    standards across all components.
    
    * chore(i18n): add auto-launch translation keys
    
    Add translation keys for new auto-launch feature to support
    multi-language interface.
    
    Translation Keys Added:
    - autoLaunch: Label for auto-launch toggle
    - autoLaunchDescription: Explanation of auto-launch functionality
    - autoLaunchEnabled: Status message when enabled
    
    Languages Updated:
    - Chinese (zh.json): 简体中文翻译
    - English (en.json): English translations
    
    The translations maintain consistency with existing terminology
    and provide clear, user-friendly descriptions of the auto-launch
    feature across both supported languages.
    
    * test: update test suites to match component refactoring
    
    Comprehensive test updates to align with recent component refactoring
    and new auto-launch functionality.
    
    Component Tests:
    - AddProviderDialog.test.tsx (10 lines):
      * Updated test cases for new dialog behavior
      * Enhanced mock data for preset selection
      * Improved assertions for validation
    
    - ImportExportSection.test.tsx (16 lines):
      * Updated for new settings page integration
      * Enhanced test coverage for error scenarios
      * Better mock state management
    
    - McpFormModal.test.tsx (60 lines):
      * Extensive updates for form refactoring
      * New test cases for multi-app selection
      * Enhanced validation testing
      * Better coverage of stdio/http server types
    
    - ProviderList.test.tsx (11 lines):
      * Updated for new card layout
      * Enhanced drag-and-drop testing
    
    - SettingsDialog.test.tsx (96 lines):
      * Major updates for SettingsPage migration
      * New test cases for auto-launch functionality
      * Enhanced integration test coverage
      * Better async operation testing
    
    Hook Tests:
    - useDirectorySettings.test.tsx (32 lines):
      * Updated for refactored hook logic
      * Enhanced test coverage for edge cases
    
    - useDragSort.test.tsx (36 lines):
      * Simplified test cases
      * Better mock implementation
      * Improved assertions
    
    - useImportExport tests (16 lines total):
      * Updated for new error handling
      * Enhanced test coverage
    
    - useMcpValidation.test.tsx (23 lines):
      * Updated validation test cases
      * Better coverage of error scenarios
    
    - useProviderActions.test.tsx (48 lines):
      * Extensive updates for hook refactoring
      * New test cases for provider operations
      * Enhanced mock data
    
    - useSettings.test.tsx (12 lines):
      * New test cases for auto-launch
      * Enhanced settings state testing
      * Better async operation coverage
    
    Integration Tests:
    - App.test.tsx (41 lines):
      * Updated for new routing logic
      * Enhanced navigation testing
      * Better component integration coverage
    
    - SettingsDialog.test.tsx (88 lines):
      * Complete rewrite for SettingsPage
      * New integration test scenarios
      * Enhanced user workflow testing
    
    Mock Infrastructure:
    - handlers.ts (117 lines):
      * Major updates for MSW handlers
      * New handlers for auto-launch commands
      * Enhanced error simulation
      * Better request/response mocking
    
    - state.ts (37 lines):
      * Updated mock state structure
      * New state for auto-launch
      * Enhanced state reset functionality
    
    - tauriMocks.ts (10 lines):
      * Updated mock implementations
      * Better type safety
    
    - server.ts & testQueryClient.ts:
      * Minor cleanup (2 lines removed)
    
    Test Infrastructure Improvements:
    - Better test isolation
    - Enhanced mock data consistency
    - Improved async operation testing
    - Better error scenario coverage
    - Enhanced integration test patterns
    
    Coverage Improvements:
    - Net increase of 195 lines of test code
    - Better coverage of edge cases
    - Enhanced error path testing
    - Improved integration test scenarios
    - Better mock infrastructure
    
    All tests now pass with the refactored components while maintaining
    comprehensive coverage of functionality and edge cases.
    
    * style(ui): improve window dragging and provider card styles
    
    * fix(skills): resolve third-party skills installation failure
    
    - Add skills_path field to Skill struct
    - Use skills_path to construct correct source path during installation
    - Fix installation for repos with custom skill subdirectories
    
    * feat(icon): add icon type system and intelligent inference logic
    
    Introduce a new icon system for provider customization:
    
    - Add IconMetadata and IconPreset interfaces in src/types/icon.ts
      - Define structure for icon name, display name, category, keywords
      - Support default color configuration per icon
    
    - Implement smart icon inference in src/config/iconInference.ts
      - Create iconMappings for 25+ AI providers and cloud platforms
      - Include Claude, DeepSeek, Qwen, Kimi, Google, AWS, Azure, etc.
      - inferIconForPreset(): match provider name to icon config
      - addIconsToPresets(): batch apply icons to preset arrays
      - Support fuzzy matching for flexible name recognition
    
    This foundation enables automatic icon assignment when users add
    providers, improving visual identification in the provider list.
    
    * feat(ui): add icon picker, color picker and provider icon components
    
    Implement comprehensive icon selection system for provider customization:
    
    ## New Components
    
    ### ProviderIcon (src/components/ProviderIcon.tsx)
    - Render SVG icons by name with automatic fallback
    - Display provider initials when icon not found
    - Support custom sizing via size prop
    - Use dangerouslySetInnerHTML for inline SVG rendering
    
    ### IconPicker (src/components/IconPicker.tsx)
    - Grid-based icon selection with visual preview
    - Real-time search filtering by name and keywords
    - Integration with icon metadata for display names
    - Responsive grid layout (6-10 columns based on screen)
    
    ### ColorPicker (src/components/ColorPicker.tsx)
    - 12 preset colors for quick selection
    - Native color input for custom color picking
    - Hex input field for precise color entry
    - Visual feedback for selected color state
    
    ## Icon Assets (src/icons/extracted/)
    - 38 high-quality SVG icons for AI providers and platforms
    - Includes: OpenAI, Claude, DeepSeek, Qwen, Kimi, Gemini, etc.
    - Cloud platforms: AWS, Azure, Google Cloud, Cloudflare
    - Auto-generated index.ts with getIcon/hasIcon helpers
    - Metadata system with searchable keywords per icon
    
    ## Build Scripts
    - scripts/extract-icons.js: Extract icons from simple-icons
    - scripts/generate-icon-index.js: Generate TypeScript index file
    
    * feat(provider): integrate icon system into provider UI components
    
    Add icon customization support to provider management interface:
    
    ## Type System Updates
    
    ### Provider Interface (src/types.ts)
    - Add optional `icon` field for icon name (e.g., "openai", "anthropic")
    - Add optional `iconColor` field for hex color (e.g., "#00A67E")
    
    ### Form Schema (src/lib/schemas/provider.ts)
    - Extend providerSchema with icon and iconColor optional fields
    - Maintain backward compatibility with existing providers
    
    ## UI Components
    
    ### ProviderCard (src/components/providers/ProviderCard.tsx)
    - Display ProviderIcon alongside provider name
    - Add icon container with hover animation effect
    - Adjust layout spacing for icon placement
    - Update translate offsets for action buttons
    
    ### BasicFormFields (src/components/providers/forms/BasicFormFields.tsx)
    - Add icon preview section showing current selection
    - Implement fullscreen icon picker dialog
    - Auto-apply default color from icon metadata on selection
    - Display provider name and icon status in preview
    
    ### AddProviderDialog & EditProviderDialog
    - Pass icon fields through form submission
    - Preserve icon data during provider updates
    
    This enables users to visually distinguish providers in the list
    with custom icons, improving UX for multi-provider setups.
    
    * feat(backend): add icon fields to Provider model and default mappings
    
    Extend Rust backend to support provider icon customization:
    
    ## Provider Model (src-tauri/src/provider.rs)
    - Add `icon: Option<String>` field for icon name
    - Add `icon_color: Option<String>` field for hex color
    - Use serde rename `iconColor` for frontend compatibility
    - Apply skip_serializing_if for clean JSON output
    - Update Provider::new() to initialize icon fields as None
    
    ## Provider Defaults (src-tauri/src/provider_defaults.rs) [NEW]
    - Define ProviderIcon struct with name and color fields
    - Create DEFAULT_PROVIDER_ICONS static HashMap with 23 providers:
      - AI providers: OpenAI, Anthropic, Claude, Google, Gemini,
        DeepSeek, Kimi, Moonshot, Zhipu, MiniMax, Baidu, Alibaba,
        Tencent, Meta, Microsoft, Cohere, Perplexity, Mistral, HuggingFace
      - Cloud platforms: AWS, Azure, Huawei, Cloudflare
    - Implement infer_provider_icon() with exact and fuzzy matching
    - Add unit tests for matching logic (exact, fuzzy, case-insensitive)
    
    ## Deep Link Support (src-tauri/src/deeplink.rs)
    - Initialize icon fields when creating Provider from deep link import
    
    ## Module Registration (src-tauri/src/lib.rs)
    - Register provider_defaults module
    
    ## Dependencies (Cargo.toml)
    - Add once_cell for lazy static initialization
    
    This backend support enables icon persistence and future features
    like auto-icon inference during provider creation.
    
    * chore(i18n): add translations for icon picker and provider icon
    
    Add Chinese and English translations for icon customization feature:
    
    ## Icon Picker (iconPicker)
    - search: "Search Icons" / "搜索图标"
    - searchPlaceholder: "Enter icon name..." / "输入图标名称..."
    - noResults: "No matching icons found" / "未找到匹配的图标"
    - category.aiProvider: "AI Providers" / "AI 服务商"
    - category.cloud: "Cloud Platforms" / "云平台"
    - category.tool: "Dev Tools" / "开发工具"
    - category.other: "Other" / "其他"
    
    ## Provider Icon (providerIcon)
    - label: "Icon" / "图标"
    - colorLabel: "Icon Color" / "图标颜色"
    - selectIcon: "Select Icon" / "选择图标"
    - preview: "Preview" / "预览"
    
    These translations support the new icon picker UI components
    and provider form icon selection interface.
    
    * style(ui): refine header layout and AppSwitcher color scheme
    
    Improve application header and component styling:
    
    ## App.tsx Header Layout
    - Wrap title and settings button in flex container with gap
    - Add vertical divider between title and settings icon
    - Apply responsive padding (pl-1 sm:pl-2)
    - Reformat JSX for better readability (prettier)
    - Fix string template formatting in className
    
    ## AppSwitcher Color Update
    - Change Claude tab gradient from orange/amber to teal/emerald/green
    - Update shadow color to match new teal theme
    - Change hover color from orange-500 to teal-500
    - Align visual style with emerald/teal brand colors
    
    ## Dialog Component Cleanup
    - Remove default close button (X icon) from DialogContent
    - Allow parent components to control close button placement
    - Remove unused lucide-react X import
    
    ## index.css Header Border
    - Add top border (2px solid) to glass-header
    - Apply to both light and dark mode variants
    - Improve visual separation of header area
    
    These changes enhance visual consistency and modernize the UI
    appearance with a cohesive teal color scheme.
    
    * chore(deps): add icon library and update preset configurations
    
    Add dependencies and utility scripts for icon system:
    
    ## Dependencies (package.json)
    - Add @lobehub/icons-static-svg@1.73.0
      - High-quality SVG icon library for AI providers
      - Source for extracted icons in src/icons/extracted/
    - Update pnpm-lock.yaml accordingly
    
    ## Provider Preset Updates (src/config/claudeProviderPresets.ts)
    - Add optional `icon` and `iconColor` fields to ProviderPreset interface
    - Apply to Anthropic Official preset as example:
      - icon: "anthropic"
      - iconColor: "#D4915D"
    - Future presets can include default icon configurations
    
    ## Utility Script (scripts/filter-icons.js) [NEW]
    - Helper script for filtering and managing icon assets
    - Supports icon discovery and validation workflow
    - Complements extract-icons.js and generate-icon-index.js
    
    This completes the icon system infrastructure, providing all
    necessary tools and dependencies for icon customization.
    
    * refactor(ui): simplify AppSwitcher styles and migrate to local SVG icons
    
    - Replace complex gradient animations with clean, minimal tab design
    - Migrate from @lobehub/icons CDN to local SVG assets for better reliability
    - Fix clippy warning in error.rs (use inline format args)
    - Improve code formatting in skill service and commands
    - Reduce CSS complexity in AppSwitcher component (removed blur effects and gradients)
    - Update BrandIcons to use imported local SVG files instead of dynamic image loading
    
    This improves performance, reduces external dependencies, and provides a cleaner UI experience.
    
    * style(ui): hide scrollbars across all browsers and optimize form layout
    
    - Hide scrollbars globally with cross-browser support:
      * WebKit browsers (Chrome, Safari, Edge): ::-webkit-scrollbar { display: none }
      * Firefox: scrollbar-width: none
      * IE 10+: -ms-overflow-style: none
    - Remove custom scrollbar styling (width, colors, hover states)
    - Reorganize BasicFormFields layout:
      * Move icon picker to top center as a clickable preview (80x80)
      * Change name and notes fields to horizontal grid layout (md:grid-cols-2)
      * Remove icon preview section from bottom
      * Improve visual hierarchy and space efficiency
    
    This provides a cleaner, more modern UI with hidden scrollbars while maintaining full scroll functionality.
    
    * refactor(layout): standardize max-width to 60rem and optimize padding structure
    
    - Unify container max-width across components:
      * Replace max-w-4xl with max-w-[60rem] in App.tsx provider list
      * Replace max-w-5xl with max-w-[60rem] in PromptPanel
      * Move padding from header element to inner container for consistent spacing
    - Optimize padding hierarchy:
      * Remove px-6 from header element, add to inner header container
      * Remove px-6 from main element, keep it only in provider list container
      * Consolidate PromptPanel padding: move px-6 from nested divs to outer container
      * Remove redundant pl-1 sm:pl-2 from logo/title area
    - Benefits:
      * Consistent 60rem max-width provides better readability on wide screens
      * Simplified padding structure reduces CSS complexity
      * Cleaner responsive behavior with unified spacing rules
    
    This creates a more maintainable and visually consistent layout system.
    
    * refactor(ui): unify layout system with 60rem max-width and consistent spacing
    
    - Standardize container max-width across all panels:
      * Replace max-w-4xl and max-w-5xl with unified max-w-[60rem]
      * Apply to SettingsPage, UnifiedMcpPanel, SkillsPage, and FullScreenPanel
      * Ensures consistent reading width and visual balance on wide screens
    
    - Optimize padding hierarchy and structure:
      * Move px-6 from parent elements to content containers
      * FullScreenPanel: Add max-w-[60rem] wrapper to header, content, and footer
      * Add border separators (border-t/border-b) to header and footer sections
      * Consolidate nested padding in MCP, Skills, and Prompts panels
      * Remove redundant padding layers for cleaner CSS
    
    - Simplify component styling:
      * MCP list items: Replace card-based layout with modern group-based design
      * Remove unnecessary wrapper divs and flatten DOM structure
      * Update card hover effects with smooth transitions
      * Simplify icon selection dialog (remove description text in BasicFormFields)
    
    - Benefits:
      * Consistent 60rem max-width provides optimal readability
      * Unified spacing rules reduce maintenance complexity
      * Cleaner component hierarchy improves performance
      * Better responsive behavior across different screen sizes
      * More cohesive visual design language throughout the app
    
    This creates a maintainable, scalable design system foundation.
    
    * feat(deeplink): add Claude model fields support and enhance import dialog
    
    - Add Claude-specific model field support in deeplink import:
      * Support model (ANTHROPIC_MODEL) - general default model
      * Support haikuModel (ANTHROPIC_DEFAULT_HAIKU_MODEL)
      * Support sonnetModel (ANTHROPIC_DEFAULT_SONNET_MODEL)
      * Support opusModel (ANTHROPIC_DEFAULT_OPUS_MODEL)
      * Backend: Update DeepLinkImportRequest struct to include optional model fields
      * Frontend: Add TypeScript type definitions for new model parameters
    
    - Enhance deeplink demo page (deplink.html):
      * Add 5 new Claude configuration examples showcasing different model setups
      * Add parameter documentation with required/optional tags
      * Include basic config (no models), single model, complete 4-model, partial models, and third-party provider examples
      * Improve visual design with param-list component and color-coded badges
      * Add detailed descriptions for each configuration scenario
    
    - Redesign DeepLinkImportDialog layout:
      * Switch from 3-column to compact 2-column grid layout
      * Reduce dialog width from 500px to 650px for better content display
      * Add dedicated section for Claude model configurations with blue highlight box
      * Use uppercase labels and smaller text for more information density
      * Add truncation and tooltips for long URLs
      * Improve visual hierarchy with spacing and grouping
      * Increase z-index to 9999 to ensure dialog appears on top
    
    - Minor UI refinements:
      * Update App.tsx layout adjustments
      * Optimize McpFormModal styling
      * Refine ProviderCard and BasicFormFields components
    
    This enables users to import Claude providers with precise model configurations via deeplink.
    
    * feat(deeplink): add config file support for deeplink import
    
    Support importing provider configuration from embedded or remote config files.
    - Add base64 dependency for config content encoding
    - Support config, configFormat, and configUrl parameters
    - Make homepage/endpoint/apiKey optional when config is provided
    - Add config parsing and merging logic
    
    * feat(deeplink): enhance dialog with config file preview
    
    Add config file parsing and preview in deep link import dialog.
    - Support Base64 encoded config display
    - Add config file source indicator (embedded/remote)
    - Parse and display config fields by app type (Claude/Codex/Gemini)
    - Mask sensitive values in config preview
    - Improve dialog layout and content organization
    
    * refactor(ui): unify dialog styles and improve layout consistency
    
    Standardize dialog and panel components across the application.
    - Update dialog background to use semantic color tokens
    - Adjust FullScreenPanel max-width to 56rem for better alignment
    - Add drag region and prevent body scroll in full-screen panels
    - Optimize button sizes and spacing in panel headers
    - Apply consistent styling to all dialog-based components
    
    * i18n: add deeplink config preview translations
    
    Add missing translation keys for config file preview feature.
    - Add configSource, configEmbedded, configRemote labels
    - Add configDetails and configUrl display strings
    - Support both Chinese and English versions
    
    * feat(deeplink): enhance test page with v3.8 config file examples
    
    Improve deeplink test page with comprehensive config file import examples.
    - Add version badge for v3.8 features
    - Add copy-to-clipboard functionality for all deep links
    - Add Claude config file import examples (embedded/remote)
    - Add Codex config file import examples (auth.json + config.toml)
    - Add Gemini config file import examples (.env format)
    - Add config generator tool for easy testing
    - Update UI with better styling and layout
    
    * feat(settings): add autoSaveSettings for lightweight auto-save
    
    Add optimized auto-save function for General tab settings.
    - Add autoSaveSettings method for non-destructive auto-save
    - Only trigger system APIs when values actually change
    - Avoid unnecessary auto-launch and plugin config updates
    - Update tests to cover new functionality
    
    * refactor(settings): simplify settings page layout and auto-save
    
    Reorganize settings page structure and integrate autoSaveSettings.
    - Move save button inline within Advanced tab content
    - Remove sticky footer for cleaner layout
    - Use autoSaveSettings for General tab settings
    - Simplify dialog close behavior
    - Refactor ImportExportSection layout
    
    * style(providers): optimize card layout and action button sizes
    
    Improve provider card visual density and action buttons.
    - Reduce icon button sizes for compact layout
    - Adjust drag handle and icon sizes
    - Tighten spacing between action buttons
    - Update hover translate values for better alignment
    
    * refactor(mcp): improve form modal layout with adaptive height editor
    
    Restructure MCP form modal for better space utilization.
    - Split form into upper form fields and lower JSON editor sections
    - Add full-height mode support for JsonEditor component
    - Use flex layout for editor to fill available space
    - Update PromptFormPanel to use full-height editor
    - Fix locale text formatting
    
    * style: unify list item styles with semantic colors
    
    Apply consistent styling to list items across components.
    - Replace hardcoded colors with semantic tokens in MCP and Prompt list items
    - Add glass effect container to EndpointSpeedTest panel
    - Format code for better readability
    
    * style: format template literals for better readability
    
    Improve code formatting for conditional className expressions.
    - Break long template literals across multiple lines
    - Maintain consistent formatting in MCP form and endpoint test components
    
    * feat(deeplink): add config merge command for preview
    
    Expose config merging functionality to frontend for preview.
    - Add merge_deeplink_config Tauri command
    - Make parse_and_merge_config public for reuse
    - Enable frontend to display complete config before import
    
    * feat(deeplink): merge and display config in import dialog
    
    Enhance import dialog to fetch and display complete config.
    - Call mergeDeeplinkConfig API when config is present
    - Add UTF-8 base64 decoding support for config content
    - Add scrollable content area with custom scrollbar styling
    - Show complete configuration before user confirms import
    
    * i18n: add config merge error message
    
    Add translation for config file merge error handling.
    
    * style(deeplink): format test page HTML for better readability
    
    Improve HTML formatting in deeplink test page.
    - Format multiline attributes for better readability
    - Add consistent indentation to nested elements
    - Break long lines in buttons and links
    
    * refactor(usage): improve footer layout with two-row design
    
    Reorganize usage footer for better readability and space efficiency.
    - Split into two rows: update time + refresh button (row 1), usage stats (row 2)
    - Move refresh button to top row next to update time
    - Remove card background for cleaner look
    - Add fallback text when never updated
    - Improve spacing and alignment
    - Format template literals for consistency
    
    * feat(database): add SQLite database infrastructure
    
    - Add rusqlite dependency (v0.32.1) and r2d2 connection pooling
    - Implement Database module with CRUD operations for providers, MCP servers, prompts, and skills
    - Add schema initialization with proper indexes
    - Include data migration utilities from JSON config to SQLite
    - Support timestamp tracking (created_at, updated_at)
    
    * refactor(core): integrate SQLite database into application core
    
    - Initialize database on app startup with migration from JSON config
    - Update AppState to include Database instance alongside MultiAppConfig
    - Simplify store module by removing unused session management code
    - Add database initialization to app setup flow
    - Support both database and legacy config during transition
    
    * refactor(services): migrate service layer to use SQLite database
    
    - Refactor ProviderService to use database queries instead of in-memory config
    - Update McpService to fetch and store MCP servers in database
    - Migrate PromptService to database-backed storage
    - Simplify ConfigService by removing complex transaction logic
    - Remove 648 lines of redundant code through database abstraction
    
    * refactor(commands): update command layer to use database API
    
    - Update config commands to query database for providers and settings
    - Modify provider commands to pass database handle to services
    - Update MCP commands to use database-backed operations
    - Refactor prompt and skill commands to leverage database storage
    - Simplify import/export commands with database integration
    
    * refactor(backend): update supporting modules for database compatibility
    
    - Add DatabaseError variant to AppError enum
    - Update provider module to support database-backed operations
    - Modify codex_config to work with new database structure
    - Ensure error handling covers database operations
    
    * refactor(frontend): update UI components for database migration
    
    - Update UsageFooter component to handle new data structure
    - Modify SkillsPage to work with database-backed skills management
    - Ensure frontend compatibility with refactored backend
    
    * feat(skills): add search functionality to Skills page
    
    - Add search input with Search icon in SkillsPage component
    - Implement useMemo-based filtering by skill name, description, and directory
    - Display search results count when filtering is active
    - Show "no results" message when no skills match the search query
    - Add i18n translations for search UI (zh/en)
    - Maintain responsive layout and consistent styling with existing UI
    
    * refactor(backend): replace unsafe unwrap calls with proper error handling
    
    - Add to_json_string helper for safe JSON serialization
    - Add lock_conn macro for safe Mutex locking
    - Replace 41 unwrap() calls with proper error handling:
      - database.rs: JSON serialization and Mutex operations (31 fixes)
      - lib.rs: macOS NSWindow and tray icon handling (3 fixes)
      - services/provider.rs: Claude model normalization (1 fix)
      - services/prompt.rs: timestamp generation (3 fixes)
      - services/skill.rs: directory name extraction (2 fixes)
      - mcp.rs: HashMap initialization and type conversions (5 fixes)
      - app_config.rs: timestamp fallback (1 fix)
    
    This improves application stability and prevents potential panics.
    
    * feat(init): implement automatic data import on first launch
    
    Add comprehensive first-launch data import system:
    
    Database layer:
    - Add is_empty_for_first_import() to detect empty database
    - Add init_default_skill_repos() to initialize 3 default skill repositories
    
    Services layer:
    - Implement McpService::import_from_claude/codex/gemini()
      to import MCP servers from existing config files
    - Implement PromptService::import_from_file_on_first_launch()
      to import prompt files (CLAUDE.md, AGENTS.md, GEMINI.md)
    
    Startup flow (lib.rs):
    - Check if database is empty on startup
    - Import existing configurations if detected:
      1. Initialize default skill repositories
      2. Import provider configurations from live settings
      3. Import MCP servers from config files
      4. Import prompt files
    - All imports are fault-tolerant and logged
    
    This ensures seamless migration from file-based configs to database.
    
    * fix(skills): auto-sync locally installed skills to database
    
    Add automatic synchronization in get_skills command:
    - Detect locally installed skills in ~/.claude/skills/
    - Auto-add to database if not already tracked
    - Ensures existing skills are recognized on first launch
    
    This fixes the issue where user's existing skills were not
    imported into the database on initial application run.
    
    * docs(frontend): add code comments and improve formatting
    
    - Add explanatory comment in EditProviderDialog about config assembly
    - Improve import formatting in SkillsPage for better readability
    
    * feat(deeplink): display all four Claude model fields in import dialog
    
    - Show haiku/sonnet/opus/multiModel fields conditionally for Claude
    - Maintain single model field display for Codex and Gemini
    - Add i18n translations for new model field labels (zh/en)
    
    * feat(backend): add database SQL export/import with backup
    
    - Enable rusqlite backup feature for SQL dump support
    - Implement export_sql to generate SQLite-compatible SQL dumps
    - Implement import_sql with automatic backup before import
    - Add snapshot_to_memory to avoid long-held database locks
    - Add backup rotation to retain latest 10 backups
    - Support atomic import with rollback on failure
    
    * refactor(backend): migrate import/export to use SQL backup
    
    - Reimplement export_config_to_file to use database.export_sql
    - Reimplement import_config_from_file to use database.import_sql
    - Add sync_current_from_db to sync live configs after import
    - Add settings database binding on app initialization
    - Remove deprecated JSON-based config import logic
    
    * refactor(backend): migrate settings storage to database
    
    - Add bind_db function to initialize database-backed settings
    - Implement load_initial_settings with database fallback
    - Replace direct file save with settings store management
    - Add SETTINGS_DB static for database binding
    - Maintain backward compatibility with file-based settings
    - Keep settings.json for legacy migration support
    
    * feat(frontend): update import/export UI for SQL backup
    
    - Change default export filename from .json to .sql
    - Update file format to timestamp format (YYYYMMDD_HHMMSS)
    - Update error messages to reference SQL files
    - Align with backend SQL export/import implementation
    
    * feat(i18n): update translations for SQL backup feature
    
    - Update Chinese translations for SQL import/export
    - Update English translations for SQL import/export
    - Change terminology from 'config file' to 'SQL backup'
    - Update error messages and UI hints
    
    * fix(backend): remove unnecessary dereference in backup operation
    
    - Simplify Backup::new call by removing redundant dereference
    - MutexGuard already implements DerefMut
  • feat(gemini): add Gemini provider integration (#202)
    * feat(gemini): add Gemini provider integration
    
    - Add gemini_config.rs module for .env file parsing
    - Extend AppType enum to support Gemini
    - Implement GeminiConfigEditor and GeminiFormFields components
    - Add GeminiIcon with standardized 1024x1024 viewBox
    - Add Gemini provider presets configuration
    - Update i18n translations for Gemini support
    - Extend ProviderService and McpService for Gemini
    
    * fix(gemini): resolve TypeScript errors, add i18n support, and fix MCP logic
    
    **Critical Fixes:**
    - Fix TS2741 errors in tests/msw/state.ts by adding missing Gemini type definitions
    - Fix ProviderCard.extractApiUrl to support GOOGLE_GEMINI_BASE_URL display
    - Add missing apps.gemini i18n keys (zh/en) for proper app name display
    - Fix MCP service Gemini cross-app duplication logic to prevent self-copy
    
    **Technical Details:**
    - tests/msw/state.ts: Add gemini default providers, current ID, and MCP config
    - ProviderCard.tsx: Check both ANTHROPIC_BASE_URL and GOOGLE_GEMINI_BASE_URL
    - services/mcp.rs: Skip Gemini in sync_other_side logic with unreachable!() guards
    - Run pnpm format to auto-fix code style issues
    
    **Verification:**
    -  pnpm typecheck passes
    -  pnpm format completed
    
    * feat(gemini): enhance authentication and config parsing
    
    - Add strict and lenient .env parsing modes
    - Implement PackyCode partner authentication detection
    - Support Google OAuth official authentication
    - Auto-configure security.auth.selectedType for PackyCode
    - Add comprehensive test coverage for all auth types
    - Update i18n for OAuth hints and Gemini config
    
    ---------
    
    Co-authored-by: Jason <farion1231@gmail.com>
  • refactor(cleanup): remove dead code and optimize Option checks
    - Remove 5 unused functions that were left over from migration refactoring:
      - get_archive_root, ensure_unique_path, archive_file (config.rs)
      - read_config_text_from_path, read_and_validate_config_from_path (codex_config.rs)
    - Simplify is_v1 check using is_some_and instead of map_or for better readability
    - Remove outdated comments about removed functions
    
    This eliminates all dead_code warnings and improves code maintainability.
  • refactor(backend): phase 4 - add test hooks and extend service layer
    - Extract internal functions in commands/mcp.rs and commands/provider.rs
      to enable unit testing without Tauri context
    - Add test hooks: set_mcp_enabled_test_hook, import_mcp_from_claude_test_hook,
      import_mcp_from_codex_test_hook, import_default_config_test_hook
    - Migrate error types from String to AppError for precise error matching in tests
    - Extend ProviderService with delete() method to unify Codex/Claude cleanup logic
    - Add comprehensive test coverage:
      - tests/mcp_commands.rs: command-level tests for MCP operations
      - tests/provider_service.rs: service-level tests for switch/delete operations
    - Run cargo fmt to fix formatting issues (EOF newlines)
    - Update BACKEND_REFACTOR_PLAN.md to mark phase 3 complete
  • refactor(backend): phase 1 - unified error handling with thiserror
    Introduce AppError enum to replace Result<T, String> pattern across
    the codebase, improving error context preservation and type safety.
    
    ## Changes
    
    ### Core Infrastructure
    - Add src/error.rs with AppError enum using thiserror
    - Add thiserror dependency to Cargo.toml
    - Implement helper functions: io(), json(), toml() for ergonomic error creation
    - Implement From<PoisonError> for automatic lock error conversion
    - Implement From<AppError> for String to maintain Tauri command compatibility
    
    ### Module Migrations (60% complete)
    - config.rs: Full migration to AppError
      - read_json_file, write_json_file, atomic_write
      - archive_file, copy_file, delete_file
    - claude_mcp.rs: Full migration to AppError
      - get_mcp_status, read_mcp_json, upsert_mcp_server
      - delete_mcp_server, validate_command_in_path
      - set_mcp_servers_map
    - codex_config.rs: Full migration to AppError
      - write_codex_live_atomic with rollback support
      - read_and_validate_codex_config_text
      - validate_config_toml
    - app_config.rs: Partial migration
      - MultiAppConfig::load, MultiAppConfig::save
    - store.rs: Partial migration
      - AppState::save now returns Result<(), AppError>
    - commands.rs: Minimal changes
      - Use .map_err(Into::into) for compatibility
    - mcp.rs: Minimal changes
      - sync_enabled_to_claude uses Into::into conversion
    
    ### Documentation
    - Add docs/BACKEND_REFACTOR_PLAN.md with detailed refactoring roadmap
    
    ## Benefits
    - Type-safe error handling with preserved error chains
    - Better error messages with file paths and context
    - Reduced boilerplate code (118 Result<T, String> instances to migrate)
    - Automatic error conversion for seamless integration
    
    ## Testing
    - All existing tests pass (4/4)
    - Compilation successful with no warnings
    - Build time: 0.61s (no performance regression)
    
    ## Remaining Work
    - claude_plugin.rs (7 functions)
    - migration.rs, import_export.rs
    - Add unit tests for error.rs
    - Complete commands.rs migration after dependent modules
    
    Co-authored-by: Claude <claude@anthropic.com>
  • refactor: improve code quality and fix linting issues
    - Derive Default trait instead of manual implementation for McpRoot and ProviderManager
    - Remove redundant closures in codex_config.rs and config.rs
    - Simplify match statements to if let patterns in migration.rs and lib.rs
    - Remove unnecessary type conversions and borrows in lib.rs
    - Fix i18n key inconsistency: sequentialThinking → sequential-thinking
    - Format TypeScript files to match Prettier style
    
    All clippy warnings resolved, code passes all quality checks.
  • feat(mcp): add automatic key normalization for server entries
    - Add normalize_server_keys() to ensure MCP server map keys match internal id fields
    - Auto-normalize on all read/write operations (get, upsert, delete, import, sync)
    - Handle edge cases: empty/whitespace ids, key renaming, conflict resolution
    - Auto-save config when normalization detects changes
    - Apply cargo fmt for code formatting consistency
    
    This enhancement improves data integrity by automatically fixing inconsistencies
    between server entry keys and their id fields, especially after manual config edits.
  • refactor: improve error handling and code formatting
    - Enhanced error messages in Rust backend to include file paths
    - Improved provider switching error handling with detailed messages
    - Added MCP button placeholder in UI (functionality TODO)
    - Applied code formatting across frontend components
    - Extended error notification duration to 6s for better readability
  • feat: add config directory override support for WSL
    - Add persistent app settings with custom Claude Code and Codex config directories
    - Add config directory override UI in settings modal with manual input, browse, and reset options
    - Integrate tauri-plugin-dialog for native directory picker
    - Support WSL and other special environments where config paths need manual specification
    
    Changes:
    - settings.rs: Implement settings load/save and directory override logic
    - SettingsModal: Add config directory override UI components
    - API: Add get_config_dir and pick_directory commands
  • feat: add common config snippet management system
    - Add settings module for managing common configuration snippets
    - Implement UI for creating, editing, and deleting snippets
    - Add tauri-plugin-fs for file operations
    - Replace co-authored setting with flexible snippet system
    - Enable users to define custom config snippets for frequently used settings
  • refactor(types): introduce Settings and apply in API
    - style(prettier): format src files
    - style(rustfmt): format Rust sources
    - refactor(tauri-api): type-safe getSettings/saveSettings
    - refactor(d.ts): declare window.api with Settings
    
    [skip ci]
  • refactor(codex): unify TOML handling with robust error recovery
    - Extract common TOML read/validation logic into dedicated helper functions
    - Add graceful degradation for corrupted config files during migration
    - Centralize Codex config.toml processing to ensure consistency across operations
    - Improve error handling: log warnings for invalid files but continue processing
    - Eliminate code duplication between migration, import, and runtime operations
    
    This makes the system more resilient to user configuration issues while maintaining data integrity through unified validation logic.
  • refactor(concurrency): optimize error handling and reduce lock contention
    - Fix operation order: write live files first, then save config.json for consistency
    - Implement short-lock pattern: read state quickly, release lock before I/O operations
    - Add atomic Codex dual-file writes with rollback on failure
    - Simplify add_provider and update_provider logic with consistent structure
    - Remove unnecessary duplicate code and improve error handling reliability
    
    This ensures data consistency when operations fail and significantly improves concurrency by minimizing lock holding time during file I/O.
  • - feat(codex): 引入 Codex 应用与供应商切换(管理 auth.json/config.toml,支持备份与恢复)
    - feat(core): 多应用配置 v2(claude/codex)与 ProviderManager;支持 v1→v2 自动迁移
    - feat(ui): 新增 Codex 页签与双编辑器表单;统一 window.api 支持 app 参数
    - feat(tauri): 新增 get_config_status/open_config_folder/open_external 命令并适配 Codex
    - fix(codex): 主配置缺失时不执行默认导入(对齐 Claude 行为)
    - chore: 配置目录展示与重启提示等细节优化