Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python
82.9 KB
Raw Blame
import json
import mimetypes
import os
from dataclasses import replace
from pathlib import Path
from unittest.mock import AsyncMock, patch

import httpx
import pytest
from fastapi.testclient import TestClient

from free_claude_code.application.connected_accounts import (
    ConnectedAccountLoginMode,
    ConnectedAccountState,
    ConnectedAccountStatus,
)
from free_claude_code.application.model_metadata import (
    ProviderModelInfo,
    ProviderModelRefreshResult,
)
from free_claude_code.config.admin.values import MASKED_SECRET
from free_claude_code.config.api_keys import normalize_api_keys
from free_claude_code.config.env_files import (
    dotenv_values_from_file,
    dotenv_values_from_text,
)
from free_claude_code.config.model_refs import ModelFallback, decode_model_fallbacks
from free_claude_code.config.provider_catalog import PROVIDER_CATALOG
from free_claude_code.config.server_urls import local_admin_url
from free_claude_code.config.settings import Settings
from free_claude_code.core.version import package_version
from tests.api.support import (
    create_test_app,
    post_config,
    provider_manager_for_app,
    runtime_for_app,
)


def _local_client(app):
    return TestClient(
        app,
        base_url="http://127.0.0.1",
        client=("127.0.0.1", 50000),
    )


@pytest.mark.parametrize(
    "path",
    (
        "/admin/chat",
        "/admin/chat/old-session",
        "/admin/api/chat/sessions",
        "/admin/api/chat/events",
        "/admin/api/chat/settings",
        f"/admin/assets/{package_version()}/chat_sessions.js",
        f"/admin/assets/{package_version()}/chat_sessions.css",
    ),
)
def test_retired_chat_urls_are_not_served(path):
    client = _local_client(create_test_app())
    assert client.get(path).status_code == 404


def test_admin_retains_code_without_chat_markup():
    client = _local_client(create_test_app())
    response = client.get("/admin")
    assert response.status_code == 200
    assert 'id="view-code"' in response.text
    assert 'id="view-chat"' not in response.text
    assert "chat_sessions" not in response.text
    assert client.get("/admin/code").status_code == 200


def test_admin_retirement_preview_apply_and_runtime_agree(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "FCC_CONFIG_SCHEMA=1\nMODEL=groq/default\nMODEL_OPUS=groq/managed\n"
        "GITHUB_MODELS_TOKEN=preserve-secret\nGITHUB_MODELS_PROXY=http://user:[email protected]\nPRIVATE=hidden\n",
        encoding="utf-8",
    )
    monkeypatch.setenv("MODEL_OPUS", "github_models/retired-process")
    app = create_test_app()
    client = _local_client(app)
    body = post_config(
        client,
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL_SONNET": "github_models/stale",
                "MODEL_OPUS": "deepseek/cannot-unlock",
                "MODEL_FALLBACKS": "groq/a,github_models/old,deepseek/b",
            }
        },
    ).json()
    assert body["applied"]
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=groq/default" in text
    assert "MODEL_SONNET" not in text
    assert "MODEL_OPUS=groq/managed" in text
    assert decode_model_fallbacks(
        dotenv_values_from_file(env_file)["MODEL_FALLBACKS"]
    ) == (ModelFallback(model="groq/a"), ModelFallback(model="deepseek/b"))
    assert "preserve-secret" in text and "http://user:[email protected]" in text
    assert "preserve-secret" not in body["env_preview"]
    assert "http://user:[email protected]" not in body["env_preview"]
    assert "PRIVATE=********" in body["env_preview"]
    effective = provider_manager_for_app(app).current_settings()
    assert effective.model == "groq/default"
    assert effective.model_opus is None and effective.model_sonnet is None
    assert effective.model_fallbacks == (
        ModelFallback(model="groq/a"),
        ModelFallback(model="deepseek/b"),
    )


def test_admin_super_migration_preview_apply_and_runtime_agree(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    old = "nvidia_nim/nvidia/nemotron-3-super-120b-a12b"
    new = "nvidia_nim/nvidia/nemotron-3-ultra-550b-a55b"
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "FCC_CONFIG_SCHEMA=2\nMODEL=groq/default\nMODEL_OPUS=groq/managed\nPRIVATE=hidden\n",
        encoding="utf-8",
    )
    monkeypatch.setenv("MODEL_OPUS", old)
    app = create_test_app()
    client = _local_client(app)
    submission = {
        "values": {
            "MODEL": old,
            "MODEL_SONNET": old,
            "MODEL_OPUS": "deepseek/cannot-unlock",
            "MODEL_FALLBACKS": f"{old},{new},groq/backup",
            "REASONING_SONNET": "off",
        }
    }
    response = post_config(client, "/admin/api/config/apply", json=submission)
    assert response.status_code == 200
    body = response.json()
    assert body["applied"]
    assert old not in body["env_preview"]
    assert "PRIVATE=********" in body["env_preview"]
    values = dotenv_values_from_file(env_file)
    assert values["MODEL"] == values["MODEL_SONNET"] == new
    assert values["MODEL_OPUS"] == "groq/managed"
    assert values["REASONING_SONNET"] == "off"
    assert values["PRIVATE"] == "hidden"
    effective = provider_manager_for_app(app).current_settings()
    assert effective.model == effective.model_sonnet == effective.model_opus == new
    assert effective.model_fallbacks == (
        ModelFallback(model=new),
        ModelFallback(model="groq/backup"),
    )
    assert os.environ["MODEL_OPUS"] == old


@pytest.fixture(autouse=True)
def _offline_credential_checks(monkeypatch):
    """These tests exercise config persistence; probe HTTP has its own suite."""
    monkeypatch.setattr(
        "free_claude_code.runtime.application.check_credentials",
        AsyncMock(return_value=()),
    )


def _set_home(monkeypatch, tmp_path: Path) -> None:
    monkeypatch.setenv("HOME", str(tmp_path))
    monkeypatch.setenv("USERPROFILE", str(tmp_path))
    monkeypatch.chdir(tmp_path)


def _clear_process_config(monkeypatch) -> None:
    for key in (
        "MODEL",
        "MODEL_FALLBACKS",
        "NVIDIA_NIM_API_KEY",
        "HUGGINGFACE_API_KEY",
        "OPENROUTER_API_KEY",
        "AWS_BEARER_TOKEN_BEDROCK",
        "BEDROCK_BASE_URL",
        "BEDROCK_PROXY",
        "OLLAMA_API_KEY",
        "ANTHROPIC_AUTH_TOKEN",
        "PROXY_AUTH_ENABLED",
        "TELEGRAM_PROXY_URL",
        "FCC_ENV_FILE",
        "CLOUDFLARE_API_TOKEN",
        "CLOUDFLARE_ACCOUNT_ID",
        "GITHUB_MODELS_TOKEN",
        "SAMBANOVA_API_KEY",
        "HOST",
        "PORT",
        "FCC_OPEN_BROWSER",
        "VOICE_NOTE_ENABLED",
        "WHISPER_DEVICE",
        "LOG_FILE",
        "ZAI_BASE_URL",
        "CLAUDE_WORKSPACE",
        "CLAUDE_CLI_BIN",
    ):
        monkeypatch.delenv(key, raising=False)
    for descriptor in PROVIDER_CATALOG.values():
        if descriptor.proxy_attr is None:
            continue
        alias = Settings.model_fields[descriptor.proxy_attr].validation_alias
        if alias is not None:
            monkeypatch.delenv(str(alias), raising=False)


def _catalog_proxy_env_keys() -> tuple[str, ...]:
    keys: list[str] = []
    for descriptor in PROVIDER_CATALOG.values():
        if descriptor.proxy_attr is None:
            continue
        alias = Settings.model_fields[descriptor.proxy_attr].validation_alias
        if alias is not None:
            keys.append(str(alias))
    return tuple(keys)


@pytest.mark.parametrize(
    "path", ["/admin", "/admin/model_config", "/admin/messaging", "/admin/integrations"]
)
def test_admin_page_is_loopback_only(monkeypatch, tmp_path, path):
    _set_home(monkeypatch, tmp_path)
    app = create_test_app()

    assert _local_client(app).get(path).status_code == 200
    remote_client = TestClient(app, client=("203.0.113.10", 50000))
    assert remote_client.get(path).status_code == 403


def test_admin_page_uses_installed_version(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    monkeypatch.setattr(
        "free_claude_code.api.admin_routes.package_version",
        lambda: "9.8.7",
    )

    response = _local_client(create_test_app()).get("/admin")

    assert response.status_code == 200
    assert "<p>Server Control · v9.8.7</p>" in response.text
    assert 'href="https://github.com/Alishahryar1/free-claude-code"' in response.text
    assert 'target="_blank"' in response.text
    assert 'rel="noopener noreferrer"' in response.text
    assert 'aria-label="Open Free Claude Code on GitHub"' in response.text
    assert 'src="/admin/assets/9.8.7/app-icon.svg"' in response.text
    assert 'href="/admin/assets/9.8.7/admin.css"' in response.text
    assert 'href="/admin/assets/9.8.7/code_sessions.css"' in response.text
    assert 'src="/admin/assets/9.8.7/model_combobox.js"' in response.text
    assert 'src="/admin/assets/9.8.7/form_controls.js"' in response.text
    assert 'src="/admin/assets/9.8.7/code_sessions.js"' in response.text
    assert 'src="/admin/assets/9.8.7/admin.js"' in response.text
    assert 'href="/admin/assets/admin.css"' not in response.text
    assert 'href="/admin/assets/code_sessions.css"' not in response.text
    assert 'src="/admin/assets/code_sessions.js"' not in response.text
    assert 'src="/admin/assets/admin.js"' not in response.text


@pytest.mark.parametrize(
    ("filename", "media_type"),
    (
        ("admin.css", "text/css"),
        ("admin.js", "text/javascript"),
        ("form_controls.js", "text/javascript"),
        ("code_sessions.css", "text/css"),
        ("code_sessions.js", "text/javascript"),
        ("session_ui.js", "text/javascript"),
        ("model_combobox.js", "text/javascript"),
        ("providers/openrouter.svg", "image/svg+xml"),
        ("providers/lightning.png", "image/png"),
    ),
)
def test_admin_versioned_assets_serve_packaged_files(
    monkeypatch,
    tmp_path,
    filename,
    media_type,
):
    mimetypes.init()
    monkeypatch.setitem(mimetypes.types_map, Path(filename).suffix, "text/plain")
    asset_path = (
        Path(__file__).resolve().parents[2]
        / "src"
        / "free_claude_code"
        / "api"
        / "admin_static"
        / filename
    )
    _set_home(monkeypatch, tmp_path)
    response = _local_client(create_test_app()).get(
        f"/admin/assets/{package_version()}/{filename}"
    )

    assert response.status_code == 200
    assert response.headers["content-type"].startswith(media_type)
    assert response.content == asset_path.read_bytes()


def test_admin_versioned_logo_reuses_packaged_app_icon(monkeypatch, tmp_path):
    asset_path = (
        Path(__file__).resolve().parents[2]
        / "src"
        / "free_claude_code"
        / "assets"
        / "app-icon.svg"
    )
    _set_home(monkeypatch, tmp_path)
    response = _local_client(create_test_app()).get(
        f"/admin/assets/{package_version()}/app-icon.svg"
    )

    assert response.status_code == 200
    assert response.headers["content-type"].startswith("image/svg+xml")
    assert response.content == asset_path.read_bytes()


@pytest.mark.parametrize(
    "path",
    (
        "/admin",
        f"/admin/assets/{package_version()}/app-icon.svg",
        f"/admin/assets/{package_version()}/admin.css",
        f"/admin/assets/{package_version()}/admin.js",
        f"/admin/assets/{package_version()}/code_sessions.css",
        f"/admin/assets/{package_version()}/code_sessions.js",
        f"/admin/assets/{package_version()}/model_combobox.js",
        "/admin/api/config",
    ),
)
def test_admin_responses_are_never_cached(monkeypatch, tmp_path, path):
    _set_home(monkeypatch, tmp_path)
    response = _local_client(create_test_app()).get(path)

    assert response.status_code == 200
    assert response.headers["cache-control"] == "no-store"


@pytest.mark.parametrize(
    ("path", "client_host", "expected_status"),
    (
        ("/admin", "203.0.113.10", 403),
        ("/admin/assets/admin.js", "127.0.0.1", 404),
        (
            f"/admin/assets/{package_version()}.stale/admin.js",
            "127.0.0.1",
            404,
        ),
        (
            f"/admin/assets/{package_version()}/missing.js",
            "127.0.0.1",
            404,
        ),
        (
            f"/admin/assets/{package_version()}/admin.js",
            "203.0.113.10",
            403,
        ),
    ),
)
def test_admin_http_errors_are_never_cached(
    monkeypatch,
    tmp_path,
    path,
    client_host,
    expected_status,
):
    _set_home(monkeypatch, tmp_path)
    client = TestClient(
        create_test_app(),
        base_url="http://127.0.0.1",
        client=(client_host, 50000),
    )

    response = client.get(path)

    assert response.status_code == expected_status
    assert response.headers["cache-control"] == "no-store"


def test_admin_apply_payload_validation_errors_are_never_cached(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)

    response = _local_client(create_test_app()).post(
        "/admin/api/config/apply",
        content="{",
        headers={"Content-Type": "application/json"},
    )

    assert response.status_code == 422
    assert response.headers["cache-control"] == "no-store"


def test_admin_unexpected_errors_are_never_cached(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    client = TestClient(
        create_test_app(),
        base_url="http://127.0.0.1",
        client=("127.0.0.1", 50000),
        raise_server_exceptions=False,
    )

    with patch(
        "free_claude_code.runtime.configuration.ConfigurationService.admin_config",
        side_effect=RuntimeError("test error"),
    ):
        response = client.get("/admin/api/config")

    assert response.status_code == 500
    assert response.headers["cache-control"] == "no-store"


def test_admin_cache_policy_does_not_match_similar_public_paths(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)

    response = _local_client(create_test_app()).get("/administrator")

    assert response.status_code == 404
    assert "cache-control" not in response.headers


def test_admin_api_fetches_bypass_browser_cache():
    script = Path("src/free_claude_code/api/admin_static/admin.js").read_text(
        encoding="utf-8"
    )

    assert 'cache: "no-store"' in script


class _FakeConnectedAccount:
    def __init__(self, provider_id: str = "openai") -> None:
        self.provider_id = provider_id
        self.connected = False
        self.revision = 0
        self.cancelled = False
        self.started_modes: list[ConnectedAccountLoginMode] = []

    def is_connected(self) -> bool:
        return self.connected

    def status(self) -> ConnectedAccountStatus:
        status = ConnectedAccountStatus(
            provider_id=self.provider_id,
            state=(
                ConnectedAccountState.CONNECTED
                if self.connected
                else ConnectedAccountState.DISCONNECTED
            ),
            connected=self.connected,
            revision=self.revision,
        )
        if self.provider_id == "github_copilot":
            return replace(
                status,
                display_identity="octocat" if self.connected else None,
                supported_login_modes=(ConnectedAccountLoginMode.DEVICE,),
                default_login_mode=ConnectedAccountLoginMode.DEVICE,
            )
        return replace(status, email="[email protected]" if self.connected else None)

    async def start_login(
        self, mode: ConnectedAccountLoginMode
    ) -> ConnectedAccountStatus:
        self.started_modes.append(mode)
        return replace(
            self.status(),
            state=ConnectedAccountState.CONNECTING,
            connected=False,
            attempt_id="login_safe",
            mode=mode,
            authorization_url=(
                "https://auth.openai.com/safe"
                if mode == ConnectedAccountLoginMode.BROWSER
                else None
            ),
            verification_url=(
                "https://github.com/login/device"
                if mode == ConnectedAccountLoginMode.DEVICE
                else None
            ),
            user_code="ABCD-1234" if mode == ConnectedAccountLoginMode.DEVICE else None,
        )

    async def cancel_login(self) -> ConnectedAccountStatus:
        self.cancelled = True
        return self.status()

    async def disconnect(self) -> ConnectedAccountStatus:
        self.connected = False
        self.revision += 1
        return self.status()

    async def close(self) -> None:
        return None


def test_admin_connected_account_routes_are_safe_loopback_only_and_uncached(
    monkeypatch, tmp_path
):
    _set_home(monkeypatch, tmp_path)
    account = _FakeConnectedAccount()
    app = create_test_app(connected_accounts={"openai": account})
    client = _local_client(app)

    status_response = client.get("/admin/api/providers/openai/auth")
    login_response = client.post(
        "/admin/api/providers/openai/auth/login",
        json={"mode": "browser"},
    )
    cancel_response = client.post("/admin/api/providers/openai/auth/cancel")

    assert status_response.status_code == 200
    assert status_response.headers["cache-control"] == "no-store"
    assert status_response.json()["state"] == "disconnected"
    assert login_response.status_code == 200
    assert login_response.json() == {
        "provider_id": "openai",
        "state": "connecting",
        "connected": False,
        "revision": 0,
        "attempt_id": "login_safe",
        "mode": "browser",
        "authorization_url": "https://auth.openai.com/safe",
        "supported_login_modes": ["browser", "device"],
        "default_login_mode": "browser",
    }
    assert "token" not in login_response.text.lower()
    assert cancel_response.status_code == 200
    assert account.cancelled is True
    remote = TestClient(app, client=("203.0.113.10", 50000))
    assert remote.get("/admin/api/providers/openai/auth").status_code == 403


@pytest.mark.parametrize(
    ("provider_id", "default_mode"),
    [("openai", "browser"), ("github_copilot", "device")],
)
@pytest.mark.parametrize("payload", [{}, {"mode": None}])
def test_admin_login_uses_the_provider_default(
    monkeypatch,
    tmp_path,
    provider_id,
    default_mode,
    payload,
):
    _set_home(monkeypatch, tmp_path)
    account = _FakeConnectedAccount(provider_id)
    client = _local_client(
        create_test_app(providers={}, connected_accounts={provider_id: account})
    )

    response = client.post(
        f"/admin/api/providers/{provider_id}/auth/login", json=payload
    )

    assert response.status_code == 200
    assert response.headers["cache-control"] == "no-store"
    assert response.json()["mode"] == default_mode
    assert account.started_modes == [ConnectedAccountLoginMode(default_mode)]
    if default_mode == "device":
        assert response.json()["user_code"] == "ABCD-1234"
        assert response.json()["verification_url"] == "https://github.com/login/device"
        assert "authorization_url" not in response.json()


@pytest.mark.parametrize("mode", ["browser", "unrecognized"])
def test_admin_rejects_unsupported_login_modes_before_starting(
    monkeypatch, tmp_path, mode
):
    _set_home(monkeypatch, tmp_path)
    account = _FakeConnectedAccount("github_copilot")
    client = _local_client(
        create_test_app(providers={}, connected_accounts={"github_copilot": account})
    )

    response = client.post(
        "/admin/api/providers/github_copilot/auth/login", json={"mode": mode}
    )

    assert response.status_code == 422
    assert response.headers["cache-control"] == "no-store"
    assert account.started_modes == []


def test_admin_connected_account_identity_modes_and_disconnect_are_independent(
    monkeypatch, tmp_path
):
    _set_home(monkeypatch, tmp_path)
    openai = _FakeConnectedAccount()
    copilot = _FakeConnectedAccount("github_copilot")
    openai.connected = copilot.connected = True
    client = _local_client(
        create_test_app(
            providers={},
            connected_accounts={"openai": openai, "github_copilot": copilot},
        )
    )

    openai_status = client.get("/admin/api/providers/openai/auth").json()
    copilot_status = client.get("/admin/api/providers/github_copilot/auth").json()
    assert openai_status["email"] == "[email protected]"
    assert openai_status["supported_login_modes"] == ["browser", "device"]
    assert copilot_status["display_identity"] == "octocat"
    assert "email" not in copilot_status
    assert copilot_status["supported_login_modes"] == ["device"]
    assert copilot_status["default_login_mode"] == "device"
    assert "token" not in str(copilot_status).lower()

    cancelled = client.post("/admin/api/providers/github_copilot/auth/cancel")
    assert cancelled.status_code == 200
    assert copilot.cancelled is True
    assert openai.cancelled is False
    disconnected = client.delete("/admin/api/providers/github_copilot/auth")
    assert disconnected.status_code == 200
    assert disconnected.json()["connected"] is False
    assert disconnected.json()["supported_login_modes"] == ["device"]
    assert client.get("/admin/api/providers/openai/auth").json()["connected"] is True


def test_admin_openai_keeps_explicit_device_login(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    account = _FakeConnectedAccount()
    client = _local_client(create_test_app(connected_accounts={"openai": account}))

    response = client.post(
        "/admin/api/providers/openai/auth/login", json={"mode": "device"}
    )

    assert response.status_code == 200
    assert account.started_modes == [ConnectedAccountLoginMode.DEVICE]


def test_admin_rejects_auth_routes_for_non_connected_provider(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)

    response = _local_client(create_test_app()).get(
        "/admin/api/providers/nvidia_nim/auth"
    )

    assert response.status_code == 404


def test_admin_page_no_longer_renders_generated_env_panel(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    app = create_test_app()

    response = _local_client(app).get("/admin")

    assert response.status_code == 200
    assert "Generated Env" not in response.text
    assert "envPreview" not in response.text


def test_admin_page_no_longer_renders_global_status_header(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    app = create_test_app()

    response = _local_client(app).get("/admin")

    assert response.status_code == 200
    assert "Local Admin" not in response.text
    assert "serverStatus" not in response.text
    assert "modelBadge" not in response.text


def test_admin_static_no_longer_fetches_global_status_header():
    script = Path("src/free_claude_code/api/admin_static/admin.js").read_text(
        encoding="utf-8"
    )

    assert 'api("/admin/api/status")' not in script
    assert "updateHeader" not in script
    assert '"Running"' not in script
    assert "serverStatus" not in script
    assert "modelBadge" not in script


def test_admin_static_hides_managed_source_label():
    script = Path("src/free_claude_code/api/admin_static/admin.js").read_text(
        encoding="utf-8"
    )

    assert 'managed_env: "",' in script
    assert "hasOwnProperty.call(labels, source)" in script
    assert 'parts.push("locked")' in script
    assert "sourceEl.textContent = source" in script


def test_admin_static_places_reasoning_fields_in_model_config():
    script = Path("src/free_claude_code/api/admin_static/admin.js").read_text(
        encoding="utf-8"
    )

    assert 'sections: ["models", "web_tools"]' in script
    assert 'sections: ["models", "thinking", "web_tools"]' not in script


def test_admin_static_model_combobox_owns_dropdown_and_search_behavior():
    script = Path("src/free_claude_code/api/admin_static/admin.js").read_text(
        encoding="utf-8"
    )
    combobox_script = Path(
        "src/free_claude_code/api/admin_static/model_combobox.js"
    ).read_text(encoding="utf-8")
    styles = Path("src/free_claude_code/api/admin_static/admin.css").read_text(
        encoding="utf-8"
    )

    assert 'api("/admin/api/models" + (refresh ? "/refresh" : "")' in script
    assert 'field.type === "model" || field.type === "optional_model"' in script
    assert "new window.FccModelCombobox" in script
    assert 'input.setAttribute("role", "combobox")' in combobox_script
    assert 'this.listbox.setAttribute("role", "listbox")' in combobox_script
    assert 'this.toggle.className = "model-combobox-toggle"' in combobox_script
    assert "class FccModelCombobox" in combobox_script
    assert 'input.addEventListener("click", () => this.open())' in combobox_script
    assert 'event.key === "ArrowDown" || event.key === "ArrowUp"' in combobox_script
    assert "this.setActive(this.visibleOptions.length - 1)" in combobox_script
    assert 'event.key === "Enter"' in combobox_script
    assert 'event.key === "Escape"' in combobox_script
    assert 'document.createElement("datalist")' not in combobox_script
    assert ".model-combobox-list" in styles
    assert ".model-combobox-option.active" in styles
    assert styles.count("background-image: var(--dropdown-chevron)") == 2


def test_admin_static_model_combobox_preserves_custom_slugs_and_none_semantics():
    script = Path("src/free_claude_code/api/admin_static/admin.js").read_text(
        encoding="utf-8"
    )

    assert '? ["None", ...state.modelOptions]' in script
    assert "You can still enter a custom slug." in script
    assert 'input.dataset.fieldType === "optional_model"' in script
    assert "return null;" in script
    assert "await hydrateModelOptions();" in script
    assert "Model fields remain editable" in script
    assert "result.failed_providers || []" in script
    assert '"warn"' in script


def test_admin_config_masks_secrets_and_exposes_manifest(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = _local_client(app).get("/admin/api/config")

    assert response.status_code == 200
    body = response.json()
    keys = {field["key"] for field in body["fields"]}
    assert "MODEL_FABLE" in keys
    assert "REASONING_FABLE" in keys
    assert "ANTHROPIC_AUTH_TOKEN" in keys
    assert "PROXY_AUTH_ENABLED" in keys
    assert "LOG_LEVEL" in keys
    assert "OPENROUTER_API_KEY" in keys
    assert "AWS_BEARER_TOKEN_BEDROCK" in keys
    assert "BEDROCK_BASE_URL" in keys
    assert "FIREWORKS_API_KEY" in keys
    assert "CLOUDFLARE_API_TOKEN" in keys
    assert "CLOUDFLARE_ACCOUNT_ID" in keys
    assert "GITHUB_MODELS_TOKEN" not in keys
    assert "GEMINI_API_KEY" in keys
    assert "GROQ_API_KEY" in keys
    assert "SAMBANOVA_API_KEY" in keys
    assert "TELEGRAM_PROXY_URL" in keys
    assert "CEREBRAS_API_KEY" in keys
    assert "OLLAMA_API_KEY" in keys
    assert "FCC_OPEN_BROWSER" in keys
    assert "ZAI_BASE_URL" not in keys
    assert "CLAUDE_WORKSPACE" not in keys
    assert "CLAUDE_CLI_BIN" not in keys
    assert "LOG_FILE" not in keys
    auth_field = next(
        field for field in body["fields"] if field["key"] == "ANTHROPIC_AUTH_TOKEN"
    )
    assert auth_field["secret"] is True
    assert auth_field["value"] == MASKED_SECRET
    assert auth_field["source"] == "default"
    assert auth_field["nullable"] is False
    telegram_proxy_field = next(
        field for field in body["fields"] if field["key"] == "TELEGRAM_PROXY_URL"
    )
    assert telegram_proxy_field["secret"] is True
    assert telegram_proxy_field["value"] is None
    assert telegram_proxy_field["configured"] is False
    assert telegram_proxy_field["nullable"] is True
    assert body["paths"] == {"managed": str(tmp_path / ".fcc" / ".env")}
    catalog_smoke_keys = {
        f"FCC_SMOKE_MODEL_{provider_id.upper()}" for provider_id in PROVIDER_CATALOG
    }
    actual_smoke_keys = {
        field["key"]
        for field in body["fields"]
        if field["key"].startswith("FCC_SMOKE_MODEL_")
    }
    assert actual_smoke_keys == catalog_smoke_keys | {
        "FCC_SMOKE_MODEL_MISTRAL_REASONING"
    }
    open_browser_field = next(
        field for field in body["fields"] if field["key"] == "FCC_OPEN_BROWSER"
    )
    assert open_browser_field["type"] == "boolean"
    assert open_browser_field["value"] == "true"
    assert open_browser_field["restart_required"] is False
    progress_timeout_field = next(
        field for field in body["fields"] if field["key"] == "PROVIDER_PROGRESS_TIMEOUT"
    )
    assert progress_timeout_field["label"] == "Provider Progress Timeout"
    assert progress_timeout_field["section"] == "runtime"
    assert progress_timeout_field["type"] == "number"
    assert progress_timeout_field["value"] == "600.0"
    assert progress_timeout_field["advanced"] is True
    assert progress_timeout_field["restart_required"] is False
    assert "non-empty protocol event" in progress_timeout_field["description"]
    assert "Independent of HTTP Read Timeout" in progress_timeout_field["description"]
    model_field_types = {
        field["key"]: field["type"]
        for field in body["fields"]
        if field["key"]
        in {
            "MODEL",
            "MODEL_FABLE",
            "MODEL_OPUS",
            "MODEL_SONNET",
            "MODEL_HAIKU",
            "MODEL_FALLBACKS",
        }
    }
    assert model_field_types == {
        "MODEL": "model",
        "MODEL_FABLE": "optional_model",
        "MODEL_OPUS": "optional_model",
        "MODEL_SONNET": "optional_model",
        "MODEL_HAIKU": "optional_model",
        "MODEL_FALLBACKS": "model_list",
    }
    fallback_field = next(
        field for field in body["fields"] if field["key"] == "MODEL_FALLBACKS"
    )
    assert fallback_field["label"] == "Fallback Models"
    assert fallback_field["value"] is None
    assert fallback_field["nullable"] is True
    assert fallback_field["restart_required"] is False
    assert "fails before output" in fallback_field["description"]
    assert "every client" in fallback_field["description"]
    assert "multiple providers" in fallback_field["description"]
    reasoning_policy = next(
        field for field in body["fields"] if field["key"] == "REASONING_POLICY"
    )
    assert reasoning_policy["section"] == "models"
    assert reasoning_policy["type"] == "select"
    assert reasoning_policy["value"] == "client"
    assert reasoning_policy["options"] == [
        {"value": "off", "label": "Off"},
        {"value": "client", "label": "From client"},
        {"value": "low", "label": "Low"},
        {"value": "medium", "label": "Medium"},
        {"value": "high", "label": "High"},
        {"value": "xhigh", "label": "X-High"},
        {"value": "max", "label": "Max"},
    ]
    route_reasoning = next(
        field for field in body["fields"] if field["key"] == "REASONING_FABLE"
    )
    assert route_reasoning["options"] == [
        {"value": "inherit", "label": "Inherit"},
        *reasoning_policy["options"],
    ]
    assert all(
        field["section"] == "models"
        for field in body["fields"]
        if field["key"].startswith("REASONING_")
    )
    assert "reasoning" not in {section["id"] for section in body["sections"]}
    restart_required = {
        field["key"] for field in body["fields"] if field["restart_required"] is True
    }
    assert {
        "ANTHROPIC_AUTH_TOKEN",
        "DEBUG_PLATFORM_EDITS",
        "DEBUG_SUBAGENT_STACK",
        "LOG_RAW_API_PAYLOADS",
        "LOG_API_ERROR_TRACEBACKS",
        "LOG_RAW_MESSAGING_CONTENT",
        "LOG_RAW_CLI_DIAGNOSTICS",
        "LOG_MESSAGING_ERROR_DETAILS",
    } <= restart_required


def test_admin_models_include_configured_and_cached_canonical_slugs():
    settings = Settings()
    settings.model = "nvidia_nim/configured-model"
    settings.model_opus = "open_router/anthropic/configured-opus"
    settings.open_router_api_keys = normalize_api_keys("open-router-key")
    app = create_test_app(settings)
    provider_manager_for_app(app).cache_model_infos(
        "open_router",
        {
            ProviderModelInfo("anthropic/configured-opus"),
            ProviderModelInfo("meta/llama-3.3"),
        },
    )

    response = _local_client(app).get("/admin/api/models")

    assert response.status_code == 200
    assert {
        key: value for key, value in response.json().items() if key != "model_labels"
    } == {
        "models": [
            "nvidia_nim/configured-model",
            "open_router/anthropic/configured-opus",
            "open_router/meta/llama-3.3",
        ],
        "failed_providers": [],
    }


def test_admin_model_refresh_returns_the_updated_canonical_catalog():
    settings = Settings()
    settings.model = "deepseek/deepseek-chat"
    settings.deepseek_api_keys = normalize_api_keys("deepseek-key")
    app = create_test_app(settings)
    runtime = app.state.services.admin

    async def refresh_models() -> ProviderModelRefreshResult:
        provider_manager_for_app(app).cache_model_infos(
            "deepseek",
            {ProviderModelInfo("deepseek-reasoner")},
        )
        return ProviderModelRefreshResult(refreshed_provider_ids=("deepseek",))

    runtime.refresh_models = AsyncMock(side_effect=refresh_models)

    response = _local_client(app).post("/admin/api/models/refresh")

    assert response.status_code == 200
    assert {
        key: value for key, value in response.json().items() if key != "model_labels"
    } == {
        "models": ["deepseek/deepseek-chat", "deepseek/deepseek-reasoner"],
        "failed_providers": [],
    }
    runtime.refresh_models.assert_awaited_once_with()


def test_admin_model_refresh_reports_partial_provider_failures():
    settings = Settings()
    settings.model = "deepseek/deepseek-chat"
    app = create_test_app(settings)
    runtime = app.state.services.admin
    runtime.refresh_models = AsyncMock(
        return_value=ProviderModelRefreshResult(
            refreshed_provider_ids=("deepseek",),
            failed_provider_ids=("open_router",),
        )
    )

    response = _local_client(app).post("/admin/api/models/refresh")

    assert response.status_code == 200
    assert {
        key: value for key, value in response.json().items() if key != "model_labels"
    } == {
        "models": ["deepseek/deepseek-chat"],
        "failed_providers": ["open_router"],
    }


def test_admin_config_preserves_managed_env_source_contract(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text("MODEL=open_router/managed-model\n", encoding="utf-8")
    app = create_test_app()

    response = _local_client(app).get("/admin/api/config")

    assert response.status_code == 200
    body = response.json()
    model_field = next(field for field in body["fields"] if field["key"] == "MODEL")
    assert model_field["source"] == "managed_env"
    assert model_field["locked"] is False


def test_admin_apply_persists_open_browser_for_next_launch(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"FCC_OPEN_BROWSER": False}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert body["pending_fields"] == []
    assert body["restart"] == {
        "required": False,
        "automatic": False,
        "admin_url": None,
        "fields": [],
    }
    managed_env = tmp_path / ".fcc" / ".env"
    assert "FCC_OPEN_BROWSER=false" in managed_env.read_text(encoding="utf-8")


def test_admin_apply_hot_publishes_provider_progress_timeout(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"PROVIDER_PROGRESS_TIMEOUT": 900}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert body["pending_fields"] == []
    assert body["restart"]["required"] is False
    assert (
        provider_manager_for_app(app).current_settings().provider_progress_timeout
        == 900.0
    )
    managed_env = tmp_path / ".fcc" / ".env"
    assert "PROVIDER_PROGRESS_TIMEOUT=900" in managed_env.read_text(encoding="utf-8")


def test_admin_apply_hot_publishes_ordered_model_fallbacks(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()
    value = "open_router/vendor/model-a,groq/vendor/model-b"

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MODEL_FALLBACKS": value}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert body["restart"]["required"] is False
    assert provider_manager_for_app(app).current_settings().model_fallbacks == (
        ModelFallback(model="open_router/vendor/model-a"),
        ModelFallback(model="groq/vendor/model-b"),
    )
    managed_env = tmp_path / ".fcc" / ".env"
    assert (
        decode_model_fallbacks(dotenv_values_from_file(managed_env)["MODEL_FALLBACKS"])
        == provider_manager_for_app(app).current_settings().model_fallbacks
    )

    loaded = _local_client(app).get("/admin/api/config").json()
    field = next(item for item in loaded["fields"] if item["key"] == "MODEL_FALLBACKS")
    assert (
        decode_model_fallbacks(field["value"])
        == provider_manager_for_app(app).current_settings().model_fallbacks
    )
    assert field["source"] == "managed_env"


def test_admin_apply_null_removes_model_fallbacks(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "FCC_CONFIG_SCHEMA=1\nMODEL_FALLBACKS=open_router/vendor/model-a\n",
        encoding="utf-8",
    )
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MODEL_FALLBACKS": None}},
    )

    assert response.status_code == 200
    assert response.json()["applied"] is True
    assert provider_manager_for_app(app).current_settings().model_fallbacks is None
    assert "MODEL_FALLBACKS=" not in env_file.read_text(encoding="utf-8")


def test_admin_rejects_invalid_provider_progress_timeout_without_writing(
    monkeypatch,
    tmp_path,
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"PROVIDER_PROGRESS_TIMEOUT": 0}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is False
    assert body["valid"] is False
    assert any("PROVIDER_PROGRESS_TIMEOUT" in error for error in body["errors"])
    managed_env = tmp_path / ".fcc" / ".env"
    assert "PROVIDER_PROGRESS_TIMEOUT=" not in managed_env.read_text(encoding="utf-8")


def test_admin_apply_masks_telegram_proxy_credentials(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()
    proxy_url = "https://user:[email protected]:8443"

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"TELEGRAM_PROXY_URL": proxy_url}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "TELEGRAM_PROXY_URL=********" in body["env_preview"]
    assert proxy_url not in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert f"TELEGRAM_PROXY_URL={proxy_url}" in text


def test_admin_apply_null_removes_optional_secret(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "FCC_CONFIG_SCHEMA=1\nTELEGRAM_PROXY_URL=https://secret.invalid\n",
        encoding="utf-8",
    )
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"TELEGRAM_PROXY_URL": None}},
    )

    assert response.status_code == 200
    assert response.json()["applied"] is True
    assert "TELEGRAM_PROXY_URL=" not in env_file.read_text(encoding="utf-8")


@pytest.mark.parametrize("submitted", [MASKED_SECRET, "", "   "])
def test_admin_apply_masked_or_blank_secret_is_unchanged(
    monkeypatch,
    tmp_path,
    submitted,
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "FCC_CONFIG_SCHEMA=1\nOPENROUTER_API_KEY=original-secret\n",
        encoding="utf-8",
    )
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"OPENROUTER_API_KEY": submitted}},
    )

    assert response.status_code == 200
    assert response.json()["applied"] is True
    assert json.loads(
        dotenv_values_from_text(env_file.read_text(encoding="utf-8"))[
            "OPENROUTER_API_KEY"
        ]
    ) == ["original-secret"]


def test_admin_apply_rejects_bad_model_shape(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MODEL": "missing-provider-prefix"}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is False
    assert body["valid"] is False
    assert any("provider type" in error for error in body["errors"])


def test_admin_apply_rejects_duplicate_model_fallbacks(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()
    duplicate = "groq/vendor/model,groq/vendor/model"

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MODEL_FALLBACKS": duplicate}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is False
    assert body["valid"] is False
    assert any("duplicate" in error.lower() for error in body["errors"])


@pytest.mark.parametrize("proxy_key", _catalog_proxy_env_keys())
def test_admin_apply_rejects_invalid_catalog_provider_proxy(
    monkeypatch,
    tmp_path,
    proxy_key,
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    invalid_proxy = "not-a-proxy://user:[email protected]:8080"

    response = post_config(
        _local_client(create_test_app()),
        "/admin/api/config/apply",
        json={"values": {proxy_key: invalid_proxy}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is False
    assert body["valid"] is False
    assert body["errors"] == [
        (
            f"{proxy_key}: must be a proxy URL with a supported scheme and host "
            "(for example http://127.0.0.1:8080 or socks5://127.0.0.1:1080)"
        )
    ]
    assert invalid_proxy not in response.text
    assert "leaked-secret" not in response.text


@pytest.mark.parametrize(
    "proxy",
    (
        "http://user:[email protected]:8080",
        "https://proxy.example:8443",
        "socks5://127.0.0.1:1080",
        "socks5h://proxy.example:1080",
        "  http://127.0.0.1:8080  ",
    ),
)
def test_admin_apply_accepts_httpx_provider_proxy(monkeypatch, tmp_path, proxy):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)

    response = post_config(
        _local_client(create_test_app()),
        "/admin/api/config/apply",
        json={"values": {"OPENAI_PROXY": proxy}},
    )

    assert response.status_code == 200
    assert response.json()["applied"] is True
    assert response.json()["valid"] is True


@pytest.mark.parametrize(
    "proxy",
    (
        "copied Admin page text",
        "socks://127.0.0.1:1080",
        "http://",
        "http:///path",
        "http://proxy.example:notaport",
    ),
)
def test_admin_apply_rejects_unusable_provider_proxy(monkeypatch, tmp_path, proxy):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)

    response = post_config(
        _local_client(create_test_app()),
        "/admin/api/config/apply",
        json={"values": {"OPENAI_PROXY": proxy}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is False
    assert body["valid"] is False
    assert len(body["errors"]) == 1
    assert body["errors"][0].startswith("OPENAI_PROXY: must be a proxy URL")
    assert "OPENAI_PROXY=********" in body["env_preview"]


def test_admin_apply_rejects_invalid_provider_proxy_without_side_effects(
    monkeypatch,
    tmp_path,
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text("MODEL=open_router/test-model\n", encoding="utf-8")
    callbacks: list[str] = []

    def restart_callback() -> None:
        callbacks.append("restart")

    app = create_test_app(restart_callback=restart_callback)
    _local_client(app).get("/admin/api/config")
    baseline = env_file.read_bytes()
    invalid_proxy = "invalid://user:[email protected]:8080"

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"OPENAI_PROXY": invalid_proxy}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["valid"] is False
    assert body["applied"] is False
    assert body["pending_fields"] == []
    assert env_file.read_bytes() == baseline
    assert callbacks == []
    assert invalid_proxy not in response.text
    assert "leaked-secret" not in response.text


def test_admin_apply_validates_retained_proxy_and_allows_removal(
    monkeypatch,
    tmp_path,
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    invalid_proxy = "invalid://proxy.example:8080"
    original = f"GROQ_PROXY={invalid_proxy}\n"
    env_file.write_text(original, encoding="utf-8")
    app = create_test_app()
    _local_client(app).get("/admin/api/config")
    baseline = env_file.read_bytes()

    rejected = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MODEL": "open_router/test-model"}},
    )

    assert rejected.status_code == 200
    assert rejected.json()["applied"] is False
    assert env_file.read_bytes() == baseline

    removed = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"GROQ_PROXY": None}},
    )

    assert removed.status_code == 200
    assert removed.json()["applied"] is True
    assert "GROQ_PROXY=" not in env_file.read_text(encoding="utf-8")


@pytest.mark.parametrize("submitted", (MASKED_SECRET, "", "   "))
def test_admin_apply_preserves_valid_stored_proxy_secret(
    monkeypatch,
    tmp_path,
    submitted,
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "OPENAI_PROXY=http://user:[email protected]:8080\n",
        encoding="utf-8",
    )

    response = post_config(
        _local_client(create_test_app()),
        "/admin/api/config/apply",
        json={"values": {"OPENAI_PROXY": submitted}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert body["valid"] is True
    assert "OPENAI_PROXY=********" in body["env_preview"]
    assert "password" not in response.text


def test_admin_apply_writes_complete_managed_env_and_masks_preview(
    monkeypatch, tmp_path
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "open_router/test-model",
                "OPENROUTER_API_KEY": "router-secret",
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "OPENROUTER_API_KEY=********" in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text("utf-8")
    assert "MODEL=open_router/test-model" in text
    assert json.loads(dotenv_values_from_text(text)["OPENROUTER_API_KEY"]) == [
        "router-secret"
    ]
    assert "ANTHROPIC_AUTH_TOKEN=" not in text
    assert "PROXY_AUTH_ENABLED=" not in text
    assert "HOST=" not in text
    assert "PORT=" not in text
    assert body["restart"] == {
        "required": False,
        "automatic": False,
        "admin_url": None,
        "fields": [],
    }


def test_admin_apply_writes_fireworks_key_and_masks_preview(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "fireworks/test-model",
                "FIREWORKS_API_KEY": "fw-secret",
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "FIREWORKS_API_KEY=********" in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=fireworks/test-model" in text
    assert json.loads(dotenv_values_from_text(text)["FIREWORKS_API_KEY"]) == [
        "fw-secret"
    ]


def test_admin_apply_writes_gemini_key_and_masks_preview(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "gemini/models/gemini-3.1-flash-lite",
                "GEMINI_API_KEY": "gm-secret",
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "GEMINI_API_KEY=********" in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=gemini/models/gemini-3.1-flash-lite" in text
    assert json.loads(dotenv_values_from_text(text)["GEMINI_API_KEY"]) == ["gm-secret"]


def test_admin_apply_writes_groq_key_and_masks_preview(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "groq/llama-3.3-70b-versatile",
                "GROQ_API_KEY": "gq-secret",
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "GROQ_API_KEY=********" in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=groq/llama-3.3-70b-versatile" in text
    assert json.loads(dotenv_values_from_text(text)["GROQ_API_KEY"]) == ["gq-secret"]


def test_admin_apply_writes_sambanova_key_and_masks_preview(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "sambanova/Meta-Llama-3.3-70B-Instruct",
                "SAMBANOVA_API_KEY": "sn-secret",
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "SAMBANOVA_API_KEY=********" in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=sambanova/Meta-Llama-3.3-70B-Instruct" in text
    assert json.loads(dotenv_values_from_text(text)["SAMBANOVA_API_KEY"]) == [
        "sn-secret"
    ]


def test_admin_apply_writes_cerebras_key_and_masks_preview(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "cerebras/llama3.1-8b",
                "CEREBRAS_API_KEY": "cb-secret",
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "CEREBRAS_API_KEY=********" in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=cerebras/llama3.1-8b" in text
    assert json.loads(dotenv_values_from_text(text)["CEREBRAS_API_KEY"]) == [
        "cb-secret"
    ]


def test_admin_apply_writes_bedrock_region_config_and_masks_key(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "bedrock/openai.gpt-oss-120b",
                "AWS_BEARER_TOKEN_BEDROCK": "bedrock-secret",
                "BEDROCK_BASE_URL": ("https://bedrock-mantle.us-west-2.api.aws/v1"),
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "AWS_BEARER_TOKEN_BEDROCK=********" in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=bedrock/openai.gpt-oss-120b" in text
    assert json.loads(dotenv_values_from_text(text)["AWS_BEARER_TOKEN_BEDROCK"]) == [
        "bedrock-secret"
    ]
    assert "BEDROCK_BASE_URL=https://bedrock-mantle.us-west-2.api.aws/v1" in text


def test_admin_apply_writes_cloudflare_fields_and_masks_preview(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "cloudflare/@cf/moonshotai/kimi-k2.6",
                "CLOUDFLARE_API_TOKEN": "cf-secret",
                "CLOUDFLARE_ACCOUNT_ID": "cf-account",
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "CLOUDFLARE_API_TOKEN=********" in body["env_preview"]
    assert "CLOUDFLARE_ACCOUNT_ID=cf-account" in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=cloudflare/@cf/moonshotai/kimi-k2.6" in text
    assert json.loads(dotenv_values_from_text(text)["CLOUDFLARE_API_TOKEN"]) == [
        "cf-secret"
    ]
    assert "CLOUDFLARE_ACCOUNT_ID=cf-account" in text


def test_admin_apply_writes_huggingface_key_and_masks_preview(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "huggingface/openai/gpt-oss-120b:fastest",
                "HUGGINGFACE_API_KEY": "hf-secret",
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert body["pending_fields"] == ["HUGGINGFACE_API_KEY"]
    assert "HUGGINGFACE_API_KEY=********" in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=huggingface/openai/gpt-oss-120b:fastest" in text
    assert json.loads(dotenv_values_from_text(text)["HUGGINGFACE_API_KEY"]) == [
        "hf-secret"
    ]


@pytest.mark.parametrize(
    ("device", "credential_key"),
    [
        ("nvidia_nim", "NVIDIA_NIM_API_KEY"),
        ("cpu", "HUGGINGFACE_API_KEY"),
    ],
)
def test_admin_key_change_requires_restart_for_active_voice_backend(
    monkeypatch,
    tmp_path,
    device,
    credential_key,
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "\n".join(
            [
                "VOICE_NOTE_ENABLED=true",
                f"WHISPER_DEVICE={device}",
                f"{credential_key}=old-key",
                "",
            ]
        ),
        encoding="utf-8",
    )
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {credential_key: "new-key"}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert body["pending_fields"] == [credential_key]
    assert body["restart"] == {
        "required": True,
        "automatic": False,
        "admin_url": None,
        "fields": [credential_key],
    }


@pytest.mark.parametrize(
    ("key", "initial", "updated"),
    [
        ("ANTHROPIC_AUTH_TOKEN", "old-token", "new-token"),
        ("DEBUG_PLATFORM_EDITS", "true", "false"),
        ("DEBUG_SUBAGENT_STACK", "true", "false"),
        ("LOG_RAW_API_PAYLOADS", "true", "false"),
        ("LOG_API_ERROR_TRACEBACKS", "true", "false"),
        ("LOG_RAW_MESSAGING_CONTENT", "true", "false"),
        ("LOG_RAW_CLI_DIAGNOSTICS", "true", "false"),
        ("LOG_MESSAGING_ERROR_DETAILS", "true", "false"),
    ],
)
def test_admin_constructor_captured_setting_requires_restart(
    monkeypatch,
    tmp_path,
    key,
    initial,
    updated,
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(f"{key}={initial}\n", encoding="utf-8")
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {key: updated}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert body["pending_fields"] == [key]
    assert body["restart"] == {
        "required": True,
        "automatic": False,
        "admin_url": None,
        "fields": [key],
    }


def test_admin_apply_writes_cohere_key_and_masks_preview(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "cohere/command-a-plus-05-2026",
                "COHERE_API_KEY": "cohere-secret",
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "COHERE_API_KEY=********" in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=cohere/command-a-plus-05-2026" in text
    assert json.loads(dotenv_values_from_text(text)["COHERE_API_KEY"]) == [
        "cohere-secret"
    ]


def test_admin_apply_replaces_retired_model_and_ignores_retired_credential(
    monkeypatch, tmp_path
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "MODEL": "github_models/openai/gpt-4.1",
                "GITHUB_MODELS_TOKEN": "github-secret",
            }
        },
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert "GITHUB_MODELS_TOKEN" not in body["env_preview"]
    env_file = tmp_path / ".fcc" / ".env"
    text = env_file.read_text(encoding="utf-8")
    assert "MODEL=" not in text
    assert "GITHUB_MODELS_TOKEN" not in text


def test_admin_apply_preserves_hidden_diagnostics_and_smoke_values(
    monkeypatch, tmp_path
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "\n".join(
            [
                "MODEL=nvidia_nim/old-model",
                "LOG_RAW_API_PAYLOADS=true",
                "FCC_SMOKE_MODEL_ZAI=zai/smoke-model",
                "",
            ]
        ),
        encoding="utf-8",
    )
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MODEL": "open_router/test-model"}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    text = env_file.read_text("utf-8")
    assert "MODEL=open_router/test-model" in text
    assert "LOG_RAW_API_PAYLOADS=true" in text
    assert "FCC_SMOKE_MODEL_ZAI=zai/smoke-model" in text


def test_admin_apply_preserves_unrecognized_managed_zai_base_url(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "\n".join(
            [
                "MODEL=zai/glm-5.2",
                "ZAI_API_KEY=zai-secret",
                "ZAI_BASE_URL=https://custom.zai.invalid/v1",
                "",
            ]
        ),
        encoding="utf-8",
    )
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MODEL": "zai/glm-5.2"}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    text = env_file.read_text("utf-8")
    assert json.loads(dotenv_values_from_text(text)["ZAI_API_KEY"]) == ["zai-secret"]
    assert "ZAI_BASE_URL=https://custom.zai.invalid/v1" in text


def test_admin_apply_preserves_unrecognized_managed_assignments(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "\n".join(
            [
                "MODEL=open_router/test-model",
                "CLAUDE_WORKSPACE=C:/custom/workspace",
                "CLAUDE_CLI_BIN=claude-custom",
                "",
            ]
        ),
        encoding="utf-8",
    )
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MODEL": "open_router/test-model"}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    text = env_file.read_text("utf-8")
    assert "MODEL=open_router/test-model" in text
    assert "CLAUDE_WORKSPACE=C:/custom/workspace" in text
    assert "CLAUDE_CLI_BIN=claude-custom" in text


@pytest.mark.parametrize("already_saved", [True, False])
def test_admin_ignores_retired_request_settings_and_preserves_saved_values(
    monkeypatch, tmp_path, already_saved
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    retired = {
        "FAST_PREFIX_DETECTION": "true",
        "ENABLE_NETWORK_PROBE_MOCK": "false",
        "ENABLE_TITLE_GENERATION_SKIP": "obsolete-invalid-boolean",
        "ENABLE_SUGGESTION_MODE_SKIP": "true",
        "ENABLE_FILEPATH_EXTRACTION_MOCK": "false",
    }
    saved = {"UNRELATED_CUSTOM_SETTING": "keep-me"}
    if already_saved:
        saved.update(retired)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "\n".join(f"{key}={value}" for key, value in saved.items()) + "\n",
        encoding="utf-8",
    )
    with _local_client(create_test_app()) as client:
        response = client.get("/admin/api/config")
        assert response.status_code == 200
        fields = {field["key"] for field in response.json()["fields"]}
        assert not fields.intersection(retired)

        response = post_config(
            client,
            "/admin/api/config/apply",
            json={"values": {**dict.fromkeys(retired, "false"), "LOG_LEVEL": "DEBUG"}},
        )

    assert response.status_code == 200
    assert response.json()["applied"] is True
    values = dotenv_values_from_text(env_file.read_text(encoding="utf-8"))
    assert values["LOG_LEVEL"] == "DEBUG"
    if not already_saved:
        assert not values.keys() & retired.keys()
    for key, value in saved.items():
        assert values[key] == value
        assert f"{key}=********" in response.json()["env_preview"]


def test_admin_apply_restart_required_reports_automatic_restart(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    callbacks: list[str] = []

    def restart_callback() -> None:
        callbacks.append("restart")

    app = create_test_app(restart_callback=restart_callback)
    instance_id = _local_client(app).get("/admin/api/status").json()["instance_id"]

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"PORT": "9090"}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert body["pending_fields"] == ["PORT"]
    assert body["restart"] == {
        "required": True,
        "automatic": True,
        "admin_url": "http://127.0.0.1:9090/admin",
        "fields": ["PORT"],
        "instance_id": instance_id,
    }
    assert callbacks == ["restart"]


@pytest.mark.parametrize("origin", ["http://127.0.0.1:8082", "http://localhost:9090"])
def test_admin_restart_status_can_be_read_from_another_local_address(origin):
    app = create_test_app()
    response = _local_client(app).get("/admin/api/status", headers={"Origin": origin})
    assert response.status_code == 200
    assert response.headers["Access-Control-Allow-Origin"] == origin
    assert response.headers["Vary"] == "Origin"
    initial = response.json()
    assert initial["status"] == "running"
    assert isinstance(initial["instance_id"], str) and initial["instance_id"]
    runtime_for_app(app).begin_shutdown()
    stopping = _local_client(app).get("/admin/api/status").json()
    assert stopping["status"] == "stopping"
    assert stopping["instance_id"] == initial["instance_id"]


def test_admin_restart_status_does_not_allow_a_remote_web_origin():
    response = _local_client(create_test_app()).get(
        "/admin/api/status", headers={"Origin": "https://example.com"}
    )
    assert response.status_code == 403
    assert "Access-Control-Allow-Origin" not in response.headers


def test_admin_apply_restart_required_reports_manual_fallback(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"PORT": "9091"}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert body["pending_fields"] == ["PORT"]
    assert body["restart"] == {
        "required": True,
        "automatic": False,
        "admin_url": None,
        "fields": ["PORT"],
    }


def test_restart_signal_failure_reports_saved_config_and_manual_restart(
    monkeypatch, tmp_path, caplog
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)

    def restart_callback() -> None:
        raise RuntimeError("private restart failure detail")

    app = create_test_app(restart_callback=restart_callback)
    client = _local_client(app)
    original_port = client.get("/admin/api/status").json()["port"]
    response = post_config(
        client, "/admin/api/config/apply", json={"values": {"PORT": "9090"}}
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is True
    assert body["restart"] == {
        "required": True,
        "automatic": False,
        "admin_url": None,
        "fields": ["PORT"],
    }
    assert "PORT=9090" in (tmp_path / ".fcc" / ".env").read_text()
    status = client.get("/admin/api/status").json()
    assert status["port"] == original_port
    assert status["pending_fields"] == ["PORT"]
    assert "private restart failure detail" not in response.text + caplog.text


@pytest.mark.parametrize(
    "followup",
    [{"PORT": "9090"}, {"MODEL": "nvidia_nim/new"}, {"LOG_LEVEL": "WARNING"}],
)
@pytest.mark.parametrize("signal_recovers", [False, True])
def test_pending_restart_survives_later_apply(
    monkeypatch, tmp_path, followup, signal_recovers
):
    from unittest.mock import MagicMock

    from free_claude_code.config.loader import ManagedConfigStore

    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    store = ManagedConfigStore()
    store.initialize()
    settings = store.read().settings
    callback = MagicMock(
        side_effect=[
            RuntimeError("first signal failed"),
            None if signal_recovers else RuntimeError("still unavailable"),
        ]
    )
    app = create_test_app(settings, restart_callback=callback)
    client = _local_client(app)
    assert post_config(
        client, "/admin/api/config/apply", json={"values": {"PORT": "9090"}}
    ).json()["restart"]["required"]
    result = post_config(
        client, "/admin/api/config/apply", json={"values": followup}
    ).json()
    fields = ["PORT", "LOG_LEVEL"] if "LOG_LEVEL" in followup else ["PORT"]
    assert result["applied"] is True
    assert result["restart"]["required"] is True
    assert result["restart"]["automatic"] is signal_recovers
    assert result["restart"]["fields"] == fields
    assert callback.call_count == 2
    status = client.get("/admin/api/status").json()
    assert status["port"] == settings.port
    assert status["pending_fields"] == ([] if signal_recovers else fields)
    assert provider_manager_for_app(app).current_generation_id == 1


def test_reverting_pending_restart_restores_hot_apply(monkeypatch, tmp_path):
    from unittest.mock import MagicMock

    from free_claude_code.config.loader import ManagedConfigStore

    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    store = ManagedConfigStore()
    store.initialize()
    settings = store.read().settings
    callback = MagicMock(side_effect=RuntimeError("restart failed"))
    app = create_test_app(settings, restart_callback=callback)
    client = _local_client(app)
    post_config(client, "/admin/api/config/apply", json={"values": {"PORT": "9090"}})
    with patch.object(provider_manager_for_app(app), "_start_pass", MagicMock()):
        result = post_config(
            client,
            "/admin/api/config/apply",
            json={"values": {"PORT": str(settings.port), "MODEL": "nvidia_nim/new"}},
        ).json()
    assert result["applied"] is True
    assert result["restart"]["required"] is False
    assert callback.call_count == 1
    status = client.get("/admin/api/status").json()
    assert status["pending_fields"] == []
    assert status["port"] == settings.port
    assert status["model"] == "nvidia_nim/new"


def test_admin_process_env_values_are_locked_and_not_written(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    monkeypatch.setenv("MODEL", "open_router/process-model")
    app = create_test_app()

    config = _local_client(app).get("/admin/api/config").json()
    model_field = next(field for field in config["fields"] if field["key"] == "MODEL")
    assert model_field["locked"] is True
    assert model_field["source"] == "process"

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MODEL": "deepseek/managed-model"}},
    )

    assert response.status_code == 200
    env_file = tmp_path / ".fcc" / ".env"
    assert "deepseek/managed-model" not in env_file.read_text("utf-8")


def test_admin_process_model_fallbacks_are_locked_and_not_written(
    monkeypatch, tmp_path
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    monkeypatch.setenv("MODEL_FALLBACKS", "open_router/process-model")
    app = create_test_app()

    config = _local_client(app).get("/admin/api/config").json()
    field = next(item for item in config["fields"] if item["key"] == "MODEL_FALLBACKS")
    assert field["locked"] is True
    assert field["source"] == "process"

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MODEL_FALLBACKS": "groq/managed-model"}},
    )

    assert response.status_code == 200
    env_file = tmp_path / ".fcc" / ".env"
    assert "MODEL_FALLBACKS=" not in env_file.read_text("utf-8")


def test_admin_never_reads_arbitrary_current_directory_env(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    monkeypatch.chdir(tmp_path)
    (tmp_path / ".env").write_text(
        "MODEL=deepseek/deepseek-chat\nDEEPSEEK_API_KEY=deepseek-secret\n",
        encoding="utf-8",
    )
    app = create_test_app()

    config = _local_client(app).get("/admin/api/config").json()
    model_field = next(field for field in config["fields"] if field["key"] == "MODEL")
    assert model_field["value"] == "nvidia_nim/nvidia/nemotron-3-ultra-550b-a55b"
    assert model_field["source"] == "default"

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {}},
    )

    assert response.status_code == 200
    managed_text = (tmp_path / ".fcc" / ".env").read_text("utf-8")
    assert "MODEL=deepseek/deepseek-chat" not in managed_text
    assert "DEEPSEEK_API_KEY=deepseek-secret" not in managed_text


def test_admin_migration_removes_blank_required_managed_values(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "MESSAGING_PLATFORM=\nWHISPER_DEVICE=\n",
        encoding="utf-8",
    )
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"NVIDIA_NIM_API_KEY": "nim-secret"}},
    )

    assert response.status_code == 200
    assert response.json()["applied"] is True
    managed_text = (tmp_path / ".fcc" / ".env").read_text("utf-8")
    assert json.loads(dotenv_values_from_text(managed_text)["NVIDIA_NIM_API_KEY"]) == [
        "nim-secret"
    ]
    assert "MESSAGING_PLATFORM=" not in managed_text
    assert "WHISPER_DEVICE=" not in managed_text


def test_admin_migrates_empty_auth_token_to_explicit_disabled_state(
    monkeypatch, tmp_path
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    env_file.write_text(
        "ANTHROPIC_AUTH_TOKEN=\nPROVIDER_RATE_LIMIT=1\n",
        encoding="utf-8",
    )
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"PROVIDER_RATE_LIMIT": "2"}},
    )

    assert response.status_code == 200
    assert response.json()["applied"] is True
    managed_lines = env_file.read_text("utf-8").splitlines()
    assert not any(line.startswith("ANTHROPIC_AUTH_TOKEN=") for line in managed_lines)
    assert "PROXY_AUTH_ENABLED=false" in managed_lines
    assert "PROVIDER_RATE_LIMIT=2" in managed_lines


@pytest.mark.parametrize(
    ("submitted", "message"),
    [
        (None, "this setting cannot be removed"),
        ("", "this setting cannot be blank"),
        ("   ", "this setting cannot be blank"),
    ],
)
def test_admin_apply_rejects_missing_required_value_without_writing(
    monkeypatch,
    tmp_path,
    submitted,
    message,
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    env_file = tmp_path / ".fcc" / ".env"
    env_file.parent.mkdir(parents=True)
    original = "ANTHROPIC_AUTH_TOKEN=\nMESSAGING_PLATFORM=none\n"
    env_file.write_text(original, encoding="utf-8")
    app = create_test_app()
    _local_client(app).get("/admin/api/config")
    baseline = env_file.read_bytes()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={"values": {"MESSAGING_PLATFORM": submitted}},
    )

    assert response.status_code == 200
    body = response.json()
    assert body["applied"] is False
    assert body["valid"] is False
    assert f"MESSAGING_PLATFORM: {message}" in body["errors"]
    assert env_file.read_bytes() == baseline


def test_admin_apply_preserves_false_and_numeric_zero(monkeypatch, tmp_path):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    response = post_config(
        _local_client(app),
        "/admin/api/config/apply",
        json={
            "values": {
                "FCC_OPEN_BROWSER": False,
                "HTTP_WRITE_TIMEOUT": 0,
            }
        },
    )

    assert response.status_code == 200
    assert response.json()["applied"] is True
    managed = (tmp_path / ".fcc" / ".env").read_text(encoding="utf-8")
    assert "FCC_OPEN_BROWSER=false" in managed
    assert "HTTP_WRITE_TIMEOUT=0" in managed


@pytest.mark.parametrize("provider_id", ["lmstudio", "llamacpp", "ollama"])
def test_admin_local_provider_status_reports_reachable(
    monkeypatch, tmp_path, provider_id
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    class FakeAsyncClient:
        def __init__(self, *args, **kwargs):
            pass

        async def __aenter__(self):
            return self

        async def __aexit__(self, *args):
            return None

        async def get(self, url: str):
            return httpx.Response(200, json={"data": []})

    with patch("free_claude_code.api.admin_routes.httpx.AsyncClient", FakeAsyncClient):
        response = _local_client(app).get(
            f"/admin/api/providers/{provider_id}/local-status"
        )

    assert response.status_code == 200
    assert response.json()["provider_id"] == provider_id
    assert response.json()["status"] == "reachable"


def test_admin_local_provider_status_checks_only_requested_provider(
    monkeypatch, tmp_path
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()
    calls = 0

    class CountingAsyncClient:
        def __init__(self, *args, **kwargs):
            pass

        async def __aenter__(self):
            return self

        async def __aexit__(self, *args):
            return None

        async def get(self, url: str):
            nonlocal calls
            calls += 1
            return httpx.Response(200, json={"data": []})

    with patch(
        "free_claude_code.api.admin_routes.httpx.AsyncClient", CountingAsyncClient
    ):
        response = _local_client(app).get("/admin/api/providers/lmstudio/local-status")

    assert response.status_code == 200
    assert calls == 1


def test_admin_config_exposes_structured_provider_configuration_targets(
    monkeypatch, tmp_path
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)

    response = _local_client(create_test_app()).get("/admin/api/config")

    assert response.status_code == 200
    providers = {
        provider["provider_id"]: provider
        for provider in response.json()["provider_status"]
    }
    assert providers["nvidia_nim"]["configuration_keys"] == ["NVIDIA_NIM_API_KEY"]
    assert providers["nvidia_nim"]["missing_configuration_keys"] == [
        "NVIDIA_NIM_API_KEY"
    ]
    assert "configuration" not in providers["nvidia_nim"]
    assert providers["lmstudio"]["status"] == "configured"
    assert providers["lmstudio"]["configuration_keys"] == ["LM_STUDIO_BASE_URL"]


def test_admin_local_provider_failure_does_not_return_exception_text(
    monkeypatch, tmp_path
):
    _set_home(monkeypatch, tmp_path)
    _clear_process_config(monkeypatch)
    app = create_test_app()

    class FailingAsyncClient:
        async def __aenter__(self):
            return self

        async def __aexit__(self, *args):
            return None

        async def get(self, url: str):
            raise RuntimeError(
                "Provider rejected credential CREDENTIAL[unrecognized-format-987654321]"
            )

    with patch(
        "free_claude_code.api.admin_routes.httpx.AsyncClient",
        return_value=FailingAsyncClient(),
    ):
        response = _local_client(app).get("/admin/api/providers/lmstudio/local-status")

    assert response.status_code == 200
    provider = response.json()
    assert provider["status"] == "offline"
    assert provider["message"] == (
        "Could not connect. Verify the URL and that the local provider is running."
    )
    assert "CREDENTIAL[unrecognized-format-987654321]" not in provider["message"]
    assert "RuntimeError" not in provider["message"]
    assert provider["error_type"] == "unexpected_error"
    assert "CREDENTIAL[unrecognized-format-987654321]" not in response.text
    assert "RuntimeError" not in response.text


@pytest.mark.parametrize(
    "result",
    (
        {"provider_id": "nvidia_nim", "ok": True, "models": ["model-a"]},
        {
            "provider_id": "nvidia_nim",
            "ok": False,
            "message": "NVIDIA_NIM_API_KEY is not set.",
        },
    ),
)
def test_admin_provider_test_route_preserves_runtime_result(
    monkeypatch, tmp_path, result
):
    _set_home(monkeypatch, tmp_path)
    app = create_test_app()
    runtime = runtime_for_app(app)

    with patch.object(runtime, "test_provider", new=AsyncMock(return_value=result)):
        response = _local_client(app).post(
            "/admin/api/providers/nvidia_nim/test",
            json={},
        )

    assert response.status_code == 200
    assert response.json() == result


def test_admin_provider_test_exposes_completed_attempt_failure():
    app = create_test_app()
    manager = provider_manager_for_app(app)
    message = "The model-list request returned HTTP 403."
    result = ProviderModelRefreshResult(
        failed_provider_ids=("nvidia_nim",),
        failure_messages={"nvidia_nim": message},
    )
    with patch.object(manager, "refresh_provider", new=AsyncMock(return_value=result)):
        response = _local_client(app).post(
            "/admin/api/providers/nvidia_nim/test", json={}
        )
    assert response.status_code == 200
    assert response.json() == {
        "provider_id": "nvidia_nim",
        "ok": False,
        "message": message,
    }


def test_admin_launch_url_uses_loopback_for_wildcard_host():
    settings = Settings.model_construct(host="0.0.0.0", port=8082)

    assert local_admin_url(settings) == "http://127.0.0.1:8082/admin"