cc-switch 0.9.6__py3-none-any.whl

cc_switch/__init__.py

@@ -0,0 +1,50 @@
+"""cc-switch — generate ~/.claude/settings.json from saved provider/model configs.
+
+A standalone CLI (mirroring the credstore pattern) that keeps the
+non-secret *shape* of a Claude Code provider setup in
+``~/.claude/cc-switch.json`` and materialises it into
+``~/.claude/settings.json``.  Secrets never touch settings.json — the
+API key is read from credstore at activate time and injected only into
+the system environment as ``ANTHROPIC_AUTH_TOKEN``.
+
+Modules::
+
+    cc_switch      Package API (get/save/remove/list/activate)
+    cc_switch.cli  Command-line interface (entry point ``cc-switch``)
+"""
+
+from cc_switch._api import (
+    CONFIG_PATH,
+    add_provider,
+    list_providers,
+    remove_provider,
+    load_config,
+    save_config,
+    update_provider,
+)
+from cc_switch._defaults import (
+    DEFAULT_ENV,
+    DEFAULT_OVERRIDE_KEYS,
+    DEFAULT_SETTINGS,
+    MAIN_MODEL_SLOT_KEYS,
+    default_value,
+    list_default_override_keys,
+)
+
+__version__ = "0.9.6"
+
+__all__ = [
+    "CONFIG_PATH",
+    "DEFAULT_ENV",
+    "DEFAULT_OVERRIDE_KEYS",
+    "DEFAULT_SETTINGS",
+    "MAIN_MODEL_SLOT_KEYS",
+    "add_provider",
+    "default_value",
+    "list_default_override_keys",
+    "list_providers",
+    "load_config",
+    "remove_provider",
+    "save_config",
+    "update_provider",
+]

cc_switch/__main__.py

@@ -0,0 +1,6 @@
+"""cc-switch CLI entry point (``python -m cc_switch``)."""
+
+from cc_switch.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cc_switch/_activate.py

@@ -0,0 +1,142 @@
+"""Activation — materialise a provider/model into ``~/.claude/settings.json``.
+
+Plain ``activate`` fills every model slot with the stock Claude Code
+defaults from :mod:`cc_switch._defaults`; ``--custom`` lets the user
+override each env key interactively before writing.
+
+The secret is read from credstore (by the *api_key_name* referenced in
+the provider config) and injected into the **system environment** as
+``ANTHROPIC_AUTH_TOKEN`` — mirroring ``credstore inject`` (registry on
+Windows, shell profile on Unix).  The generated settings.json never
+contains a credential line, and the env injection survives the transient
+cc-switch process so a new Claude Code session picks it up.
+
+If the secret is missing from credstore, activation fails loudly instead
+of writing an unusable settings.json.
+
+Memory safety: the keyring value is fetched, used, then ``del``-ed
+immediately.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from cc_switch import _defaults
+
+# Output path — overridable for tests via monkeypatch.
+SETTINGS_PATH = os.path.expanduser("~/.claude/settings.json")
+
+
+class SecretNotFoundError(RuntimeError):
+    """Raised when a provider's api_key_name is not stored in credstore."""
+
+
+def resolve_secret(api_key_name: str) -> str | None:
+    """Read *api_key_name* from credstore (system keyring).
+
+    Returns the secret, or None when the key is not stored or credstore
+    is unavailable.  The caller must ``del`` the returned value after
+    use.  This is the only place cc-switch touches secret material.
+    """
+    try:
+        from credstore import get_credential
+    except Exception:
+        return None
+    return get_credential(api_key_name)
+
+
+def build_env(provider: dict, model_name: str, overrides: dict | None = None) -> dict:
+    """Build the env block for settings.json.
+
+    *overrides* maps env key → value and is used by ``--custom``; a
+    missing key falls back to ``default_value`` — the main-model slots
+    inherit *model_name* (never empty), the rest keep their static
+    default.  Always + ``ANTHROPIC_BASE_URL`` + model — never a secret.
+    """
+    env: dict[str, str] = {}
+    # 1. Every override slot (with the override value where provided)
+    for key in _defaults.DEFAULT_OVERRIDE_KEYS:
+        if overrides and key in overrides:
+            env[key] = str(overrides[key])
+        else:
+            env[key] = _defaults.default_value(key, model_name)
+    # 2. Provider-specific env overrides (applied after the slots)
+    env.update(provider.get("extra_env") or {})
+    # 3. Provider base URL + chosen model
+    env["ANTHROPIC_BASE_URL"] = provider["base_url"]
+    env["ANTHROPIC_MODEL"] = model_name
+    return env
+
+
+def build_settings(provider: dict, model_name: str, overrides: dict | None = None) -> dict:
+    """Return the full settings.json dict (no secret material)."""
+    settings = dict(_defaults.DEFAULT_SETTINGS)
+    settings["env"] = build_env(provider, model_name, overrides)
+    return settings
+
+
+def write_settings(settings: dict) -> None:
+    """Write the settings dict to ``~/.claude/settings.json`` (overrides path)."""
+    import json
+
+    target = SETTINGS_PATH
+    parent = os.path.dirname(target)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+    with open(target, "w", encoding="utf-8") as fh:
+        json.dump(settings, fh, ensure_ascii=False, indent=2)
+        fh.write("\n")
+
+
+def inject_token(secret: str, shell: str = "auto", output=None) -> None:
+    """Persist *secret* as ``ANTHROPIC_AUTH_TOKEN`` in the system environment.
+
+    Mirrors ``credstore inject``: writes the value to the system env via
+    ``persist_key`` (registry on Windows, shell profile on Unix) so a
+    freshly launched Claude Code session inherits it.  When *output* is
+    a TTY it prints an activation hint (no secret); otherwise it prints
+    the export line for the current shell.
+    """
+    from credstore._shell import format_export, persist_key
+
+    persist_key("ANTHROPIC_AUTH_TOKEN", secret, shell)
+
+    out = output if output is not None else sys.stdout
+    if out.isatty():
+        print(
+            "Injected ANTHROPIC_AUTH_TOKEN into the system environment.",
+            file=out,
+        )
+        print(
+            "Restart your shell (or start a new terminal) for it to take effect.",
+            file=out,
+        )
+    else:
+        print(format_export("ANTHROPIC_AUTH_TOKEN", secret, shell), file=out)
+
+
+def activate(provider: dict, model_name: str, overrides: dict | None = None,
+             shell: str = "auto", output=None) -> dict:
+    """Generate, write settings.json, and inject the secret into the system env.
+
+    Writes settings.json first (so the config shape is in place even if
+    the token lookup then fails), then resolves the API key from
+    credstore.  A missing key raises :class:`SecretNotFoundError` —
+    never a silent skip.  Returns the settings dict that was written.
+    """
+    settings = build_settings(provider, model_name, overrides)
+    write_settings(settings)
+
+    secret = resolve_secret(provider["api_key_name"])
+    if secret is None:
+        raise SecretNotFoundError(
+            f"'{provider['api_key_name']}' is not in credstore.\n"
+            f"Store it first: credstore set {provider['api_key_name']}"
+        )
+    try:
+        inject_token(secret, shell=shell, output=output)
+    finally:
+        del secret
+    return settings

cc_switch/_api.py

@@ -0,0 +1,105 @@
+"""Persistent provider/model configuration storage.
+
+The non-secret *shape* of a Claude Code provider setup lives in
+``~/.claude/cc-switch.json`` (path overridable via ``CC_SWITCH_FILE``).
+Only provider metadata is stored here — never API keys.  The secret is
+referenced by *name* (the ``api_key_name`` field) and resolved through
+credstore at activate time.
+
+File format::
+
+    {
+      "providers": {
+        "deepseek": {
+          "base_url": "https://api.deepseek.com/anthropic",
+          "api_key_name": "DEEPSEEK_API_KEY",
+          "models": ["deepseek-chat", "deepseek-reasoner"],
+          "extra_env": {}
+        }
+      }
+    }
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+CONFIG_PATH = Path(os.environ.get("CC_SWITCH_FILE", str(Path.home() / ".claude" / "cc-switch.json")))
+
+
+def load_config() -> dict:
+    """Load provider configs from ``~/.claude/cc-switch.json``.
+
+    Returns a dict with a ``"providers"`` key (possibly empty).  A
+    missing or unparseable file yields ``{"providers": {}}``.
+    """
+    import json
+
+    try:
+        raw = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {"providers": {}}
+    if not isinstance(raw, dict) or not isinstance(raw.get("providers"), dict):
+        return {"providers": {}}
+    return raw
+
+
+def save_config(data: dict) -> None:
+    """Persist the whole config dict to ``~/.claude/cc-switch.json``."""
+    import json
+
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(
+        json.dumps(data, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _get_providers() -> dict:
+    return load_config().get("providers", {})
+
+
+def add_provider(name: str, base_url: str, api_key_name: str, models: list[str], extra_env: dict | None = None) -> None:
+    """Add a new provider, or replace an existing one with the same name."""
+    data = load_config()
+    data.setdefault("providers", {})[name] = {
+        "base_url": base_url,
+        "api_key_name": api_key_name,
+        "models": list(models),
+        "extra_env": dict(extra_env or {}),
+    }
+    save_config(data)
+
+
+def update_provider(name: str, base_url: str | None = None, api_key_name: str | None = None,
+                    models: list[str] | None = None, extra_env: dict | None = None) -> None:
+    """Merge changes into an existing provider.  Raises KeyError if unknown."""
+    providers = _get_providers()
+    if name not in providers:
+        raise KeyError(name)
+    provider = providers[name]
+    if base_url is not None:
+        provider["base_url"] = base_url
+    if api_key_name is not None:
+        provider["api_key_name"] = api_key_name
+    if models is not None:
+        provider["models"] = list(models)
+    if extra_env is not None:
+        provider["extra_env"] = dict(extra_env)
+    save_config({"providers": providers})
+
+
+def remove_provider(name: str) -> bool:
+    """Delete a provider.  Returns True if it existed."""
+    providers = _get_providers()
+    if name not in providers:
+        return False
+    del providers[name]
+    save_config({"providers": providers})
+    return True
+
+
+def list_providers() -> list[str]:
+    """Return provider names, sorted."""
+    return sorted(_get_providers().keys())

cc_switch/_defaults.py

@@ -0,0 +1,55 @@
+"""Default settings template for the generated ``~/.claude/settings.json``.
+
+The Claude Code convention: the other model slots
+(``ANTHROPIC_DEFAULT_HAIKU_MODEL`` / ``_SONNET_`` / ``_OPUS_`` /
+``CLAUDE_CODE_SUBAGENT_MODEL``) default to the **main model** picked on
+the command line (``ANTHROPIC_MODEL``), and are never left empty.
+``activate --custom`` starts each of those slots at the main model so the
+user can change them individually.
+
+Only the non-model slots have a static default
+(``ANTHROPIC_CLAUDE_CODE_EFFORT_LEVEL: medium``).
+"""
+
+from __future__ import annotations
+
+# The model slots that default to the main model (ANTHROPIC_MODEL).
+# ANTHROPIC_MODEL itself is NOT here — it is chosen on the command line.
+MAIN_MODEL_SLOT_KEYS = [
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_CLAUDE_CODE_SUBAGENT_MODEL",
+]
+
+# Env keys that ``activate --custom`` prompts for, in order.
+DEFAULT_OVERRIDE_KEYS = list(MAIN_MODEL_SLOT_KEYS) + [
+    "ANTHROPIC_CLAUDE_CODE_EFFORT_LEVEL",
+]
+
+# Static default for the non-model slots.
+DEFAULT_ENV: dict[str, str] = {
+    "ANTHROPIC_CLAUDE_CODE_EFFORT_LEVEL": "medium",
+}
+
+# Frozen template for the settings.json body — never a credential here.
+DEFAULT_SETTINGS = {
+    "env": {},
+    "autoUpdatesChannel": "latest",
+}
+
+
+def default_value(key: str, main_model: str) -> str:
+    """Return the default for an env key given the main model.
+
+    Model slots inherit the main model; non-model slots use their static
+    default.
+    """
+    if key in MAIN_MODEL_SLOT_KEYS:
+        return main_model
+    return DEFAULT_ENV[key]
+
+
+def list_default_override_keys() -> list[str]:
+    """Return the env keys that ``activate --custom`` prompts for, in order."""
+    return list(DEFAULT_OVERRIDE_KEYS)

cc_switch/cli.py

@@ -0,0 +1,288 @@
+"""cc-switch CLI — terminal commands for Claude Code settings generation.
+
+Commands::
+
+    cc-switch set <provider> [--name NAME] [--models M1,M2]
+        Create or edit a provider config (base URL + API key name,
+        plus optional models / display name).  Secrets are never stored.
+    cc-switch remove <provider>
+        Delete a provider config.
+    cc-switch activate <provider>[/<model>]
+        Write ~/.claude/settings.json from defaults, inject the API key
+        from credstore into ANTHROPIC_AUTH_TOKEN (env only).
+    cc-switch activate <provider>[/<model>] --custom
+        Interactive override of every model slot, then write.
+    cc-switch list
+        List providers and their models as provider/model.
+    cc-switch list-providers
+        Show all providers and their models (list is for provider/model rows).
+
+Non-secret interactive values use plain ``input()``.  The API key name
+is stored in the config; the key value is read from credstore only at
+activate time and never written to any file.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from cc_switch import _activate, _api, _defaults
+
+
+def _err(msg: str) -> None:
+    print(f"Error: {msg}", file=sys.stderr)
+
+
+def _parse_provider_model(spec: str) -> tuple[str, str | None]:
+    """Split 'provider/model' into (provider, model-or-None)."""
+    if "/" in spec:
+        provider, model = spec.split("/", 1)
+        return provider.strip(), model.strip() or None
+    return spec.strip(), None
+
+
+def _prompt_required(prompt: str, current: str = "") -> str:
+    """Prompt for a required value.
+
+    When *current* is non-empty (editing), Enter keeps it — blank never
+    re-prompts.  When adding (no current), blank re-prompts.
+    """
+    hint = f" [{current}]" if current else ""
+    while True:
+        value = input(f"{prompt}{hint}: ").strip()
+        if value or current:
+            return value or current
+        print("(required — cannot be empty)", file=sys.stderr)
+
+
+def _prompt_optional(prompt: str, current: str = "") -> str:
+    """Prompt for an optional value; blank keeps the current / empty."""
+    hint = f" [{current}]" if current else " [blank = empty]"
+    value = input(f"{prompt}{hint}: ").strip()
+    return value or current or ""
+
+
+def _parse_models(text: str) -> list[str]:
+    """Split a model list on commas, whitespace, and/or semicolons."""
+    for sep in (",", ";"):
+        text = text.replace(sep, " ")
+    return [m.strip() for m in text.split() if m.strip()]
+
+
+# ── set ──────────────────────────────────────────────────────────────
+
+
+def _cmd_set(args) -> int:
+    """Create or edit a provider.  Exists → edit, missing → add."""
+    name = args.provider
+    providers = _api.load_config().get("providers", {})
+    current = providers.get(name)
+    is_edit = current is not None
+
+    if is_edit:
+        print(f"Editing provider '{name}' (press Enter to keep current value).")
+    else:
+        print(f"Adding provider '{name}'.")
+
+    base_url = _prompt_required("Base URL", current["base_url"] if current else "")
+    api_key_name = _prompt_required("API key name (credstore key)", current["api_key_name"] if current else "")
+    models_text = _prompt_optional(
+        "Supported models (comma, space, or semicolon separated)",
+        ", ".join(current["models"]) if current else "",
+    )
+    models = _parse_models(models_text)
+    extra_env = current.get("extra_env") if current else None
+    _api.add_provider(name, base_url, api_key_name, models, extra_env=extra_env)
+    print(f"Provider '{name}' saved.")
+    if models:
+        print(f"  models: {', '.join(models)}")
+    print(f"  Activate with: cc-switch activate {name}/<model>")
+    return 0
+
+
+# ── remove ───────────────────────────────────────────────────────────
+
+
+def _cmd_remove(args) -> int:
+    if _api.remove_provider(args.provider):
+        print(f"Provider '{args.provider}' removed.")
+        return 0
+    _err(f"provider '{args.provider}' not found.")
+    return 1
+
+
+# ── activate ─────────────────────────────────────────────────────────
+
+
+def _collect_overrides(main_model: str) -> dict:
+    """Interactive override pass for ``activate --custom``.
+
+    Main-model slots default to *main_model* (the CLI-chosen model);
+    the effort level defaults to its static value.  A blank response
+    keeps the default; a value of ``-`` clears the field to an empty
+    string.
+    """
+    overrides: dict[str, str] = {}
+    print("Custom activation — enter a new value, or Enter to keep the default.")
+    for key in _defaults.DEFAULT_OVERRIDE_KEYS:
+        current = _defaults.default_value(key, main_model)
+        hint = ""
+        if key == "ANTHROPIC_CLAUDE_CODE_EFFORT_LEVEL":
+            hint = " (low|medium|high|xhigh|max)"
+        value = input(f"{key} [{current}]{hint}: ").strip()
+        if value:
+            # '-' clears the field to an empty string; anything else overrides.
+            overrides[key] = "" if value == "-" else value
+    return overrides
+
+
+def _cmd_activate(args) -> int:
+    provider_name, model_name = _parse_provider_model(args.provider_model)
+    providers = _api.load_config().get("providers", {})
+    provider = providers.get(provider_name)
+    if provider is None:
+        _err(f"provider '{provider_name}' not found. Add it first: cc-switch set {provider_name}")
+        return 1
+
+    if model_name is None:
+        models = provider.get("models") or []
+        if len(models) == 1:
+            model_name = models[0]
+        elif not models:
+            model_name = _prompt_required("Model name")
+        else:
+            print("Available models:")
+            for i, m in enumerate(models, 1):
+                print(f"  {i}. {m}")
+            try:
+                choice = int(input("Select a model by number: ").strip())
+                model_name = models[choice - 1]
+            except (ValueError, IndexError):
+                _err("invalid selection.")
+                return 1
+    elif model_name not in (provider.get("models") or []):
+        print(f"Note: model '{model_name}' is not in the provider's model list.", file=sys.stderr)
+
+    overrides = _collect_overrides(model_name) if args.custom else None
+
+    # --custom never touches the stored config; the overrides are one-shot.
+    try:
+        settings = _activate.activate(
+            provider, model_name, overrides=overrides,
+            shell=args.shell,
+        )
+    except _activate.SecretNotFoundError as exc:
+        _err(str(exc))
+        _err("settings.json was not updated — store the key, then re-run activate.")
+        return 1
+
+    print(f"Activated {provider_name}/{model_name}.")
+    print(f"  Wrote: {_activate.SETTINGS_PATH}")
+    print(f"  Injected ANTHROPIC_AUTH_TOKEN from credstore '{provider['api_key_name']}'.")
+    return 0
+
+
+# ── list ─────────────────────────────────────────────────────────────
+
+
+def _cmd_list(args) -> int:
+    """List providers and their models as provider/model rows."""
+    providers = _api.load_config().get("providers", {})
+    if not providers:
+        print("No providers configured.")
+        print("Add one with: cc-switch set <provider-name>")
+        return 0
+    for name in sorted(providers):
+        provider = providers[name]
+        models = provider.get("models") or []
+        if not models:
+            print(f"{name}/<no models — run 'cc-switch set {name}' to add>")
+            continue
+        for model in models:
+            print(f"{name}/{model}")
+    return 0
+
+
+def _cmd_list_providers(args) -> int:
+    """Show providers with their metadata (base URL, API key name)."""
+    providers = _api.load_config().get("providers", {})
+    if not providers:
+        print("No providers configured.")
+        return 0
+    for name in sorted(providers):
+        provider = providers[name]
+        models = provider.get("models") or []
+        print(f"{name}:")
+        print(f"  base_url:      {provider.get('base_url', '')}")
+        print(f"  api_key_name:  {provider.get('api_key_name', '')}")
+        print(f"  models:        {', '.join(models) if models else '(none)'}")
+        extra = provider.get("extra_env") or {}
+        if extra:
+            print(f"  extra_env:     {json.dumps(extra)}")
+    return 0
+
+
+# ── dispatch ─────────────────────────────────────────────────────────
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="cc-switch",
+        description="Generate ~/.claude/settings.json from saved provider/model configs.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    set_p = sub.add_parser("set", help="Create or edit a provider config")
+    set_p.add_argument("provider", help="Provider name, e.g. deepseek")
+
+    rem_p = sub.add_parser("remove", help="Delete a provider config")
+    rem_p.add_argument("provider", help="Provider name")
+
+    act_p = sub.add_parser("activate", help="Write ~/.claude/settings.json and inject the API key into the env")
+    act_p.add_argument("provider_model", help="Provider/model, e.g. deepseek/deepseek-chat")
+    act_p.add_argument("--custom", action="store_true",
+                       help="Interactively override every model slot before writing")
+    act_p.add_argument("--shell", choices=["auto", "bash", "powershell", "cmd"],
+                       default="auto",
+                       help="Shell format for the exported env var (default: auto-detect)")
+
+    sub.add_parser("list", help="List providers and models as provider/model")
+    sub.add_parser("list-providers", help="Show providers with their base URL and API key name")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI entry point. Returns exit code."""
+    if argv is None:
+        argv = sys.argv[1:]
+
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        if args.command == "set":
+            return _cmd_set(args)
+        elif args.command == "remove":
+            return _cmd_remove(args)
+        elif args.command == "activate":
+            return _cmd_activate(args)
+        elif args.command == "list":
+            return _cmd_list(args)
+        elif args.command == "list-providers":
+            return _cmd_list_providers(args)
+        else:
+            parser.print_help()
+            return 1
+    except KeyboardInterrupt:
+        print("\nCancelled.")
+        return 130
+    except Exception as exc:
+        _err(str(exc))
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cc_switch-0.9.6.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.3
+Name: cc-switch
+Version: 0.9.6
+Summary: Generate ~/.claude/settings.json from saved provider/model configs
+Project-URL: Homepage, https://github.com/juzcn/slife
+Project-URL: Repository, https://github.com/juzcn/slife
+Author-email: juzcn <zhangjun@cueb.edu.cn>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Terminals
+Requires-Python: >=3.13
+Requires-Dist: credstore
+Description-Content-Type: text/markdown
+
+# cc-switch
+
+Generate `~/.claude/settings.json` from saved provider/model configs —
+a small CLI that mirrors the [credstore](../credstore/README.md) pattern.
+
+Non-secret provider *shape* lives in `~/.claude/cc-switch.json`.  API
+keys are **never** stored there — the config keeps the key's *name*,
+and the value is read from credstore at activate time and injected into
+the current process environment as `ANTHROPIC_AUTH_TOKEN`.  The
+generated `settings.json` contains no credential line.
+
+## Install
+
+cc-switch is a standalone PyPI package — installed independently of
+slife (installing slife does **not** bring cc-switch, and vice versa).
+Both depend on [credstore](../credstore/README.md), which is pulled in
+automatically.
+
+```bash
+uv tool install cc-switch
+# or, in this repo:
+uv sync
+```
+
+## Commands
+
+### `cc-switch set <provider-name>`
+
+Create or edit a provider.  Prompts for:
+
+- **Base URL** (required)
+- **API key name** — the credstore key holding the secret (required)
+- **Supported models** (optional; comma, space, or semicolon separated)
+
+If the provider already exists this *edits* it; otherwise it *adds* it.
+
+```bash
+cc-switch set deepseek
+# Base URL [..]: https://api.deepseek.com/anthropic
+# API key name (credstore key): DEEPSEEK_API_KEY
+# Supported models (comma separated): deepseek-chat,deepseek-reasoner
+```
+
+No secret value is ever asked for or written — store it first with:
+
+```bash
+credstore set DEEPSEEK_API_KEY
+```
+
+### `cc-switch activate <provider-name/model-name>`
+
+Writes `~/.claude/settings.json` with stock Claude Code defaults, and
+injects the API key from credstore into the system environment as
+`ANTHROPIC_AUTH_TOKEN` (mirroring `credstore inject` — registry on
+Windows, shell profile on Unix), so a freshly launched Claude Code
+session inherits it.  The settings file contains **no** credential.
+
+If the provider's API key is not in credstore, `activate` fails loudly
+with a `credstore set <key>` hint instead of writing an unusable setup.
+
+```bash
+cc-switch activate deepseek/deepseek-chat
+```
+
+If the model is omitted and the provider has exactly one model, it is
+used; if several, you are prompted to pick one.
+
+### `cc-switch activate <provider-name/model-name> --custom`
+
+Like `activate`, but lets you override every model slot first —
+`ANTHROPIC_DEFAULT_HAIKU_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`,
+`ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_CLAUDE_CODE_SUBAGENT_MODEL`,
+`ANTHROPIC_MODEL`, `ANTHROPIC_CLAUDE_CODE_EFFORT_LEVEL` — one at a time.
+Enter a value to override, or Enter to keep the default.  Overrides are
+one-shot: they never touch the stored provider config.
+
+### `cc-switch list`
+
+Lists every configured provider/model pair, one per line:
+
+```
+deepseek/deepseek-chat
+deepseek/deepseek-reasoner
+scnet/scnet-1m
+```
+
+### `cc-switch list-providers`
+
+Shows provider metadata (base URL, API key name, models) without the
+model-per-line layout of `list`.
+
+### `cc-switch remove <provider-name>`
+
+Deletes a provider config.  Does not touch credstore or settings.json.
+
+## Files
+
+| Path | Purpose |
+|------|---------|
+| `~/.claude/cc-switch.json` | Provider/model shapes (no secrets) |
+| `~/.claude/settings.json` | Generated by `activate` |
+| credstore (`DEEPSEEK_API_KEY`, …) | The actual API key values |
+
+`CC_SWITCH_FILE` overrides the config path; the settings path can be
+overridden for tests.
+
+## Security notes
+
+- The config file holds only metadata — the API key is referenced by name.
+- `activate` reads the secret from credstore and injects it into the
+  system environment as `ANTHROPIC_AUTH_TOKEN` (registry on Windows /
+  shell profile on Unix), mirroring `credstore inject`; it is never
+  written to settings.json.
+- On a TTY, `activate` prints an activation hint without echoing the
+  secret; when stdout is piped it emits the shell export line for `eval`.
+- Restart your shell (or start a new terminal) after activating for the
+  env change to take effect in the current session.
+- Secrets are immutable Python `str` — cc-switch follows credstore's
+  practice of `del`-ing the reference immediately after use.

cc_switch-0.9.6.dist-info/RECORD

@@ -0,0 +1,10 @@
+cc_switch/__init__.py,sha256=Tj25Bi3ts1Y6z1u1oqOoygTTIzpXfI4pX9MQK4Tn5QY,1283
+cc_switch/__main__.py,sha256=zIgq2dbe9u_cRGENPSYTeMDs1Pw1hZHBVMtwhrMk_hY,148
+cc_switch/_activate.py,sha256=6a0nMSyjtljBQPax1tMJ9_m68Dcz8Uk5PgCXFjiLzNU,5386
+cc_switch/_api.py,sha256=gMHz-DyiOt1VHRgHYl5KduAEPlewp_a3Hhh4aau74Hc,3288
+cc_switch/_defaults.py,sha256=ptaIhRO8WQTWB2SIJS-_9py6oS1TGJFIgIDseAev7L4,1812
+cc_switch/cli.py,sha256=1fZBoYtR7bD--CtyvzmZNjrLGvBV4oFZgmmmjyEuOpA,11092
+cc_switch-0.9.6.dist-info/METADATA,sha256=2xpiZnUF5zmYavhNHwiBAqekY-WLctc-YxzfCCAwRs8,4792
+cc_switch-0.9.6.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+cc_switch-0.9.6.dist-info/entry_points.txt,sha256=g2UCHtGA9vuEbJrB6HK7KY2DfElVzkWh6wZMQ5bmTzI,49
+cc_switch-0.9.6.dist-info/RECORD,,

cc_switch-0.9.6.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.26.3
+Root-Is-Purelib: true
+Tag: py3-none-any

cc_switch-0.9.6.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cc-switch = cc_switch.cli:main