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
17.2 KB
Raw Blame
import json
import os
import subprocess
import sys

import httpx
import pytest

from free_claude_code.cli import doctor
from free_claude_code.config import paths
from free_claude_code.config.loader import ManagedConfigStore
from free_claude_code.config.server_urls import local_proxy_root_url
from free_claude_code.config.settings import Settings
from free_claude_code.providers.openai_codex import auth as openai_auth
from free_claude_code.runtime import diagnostics


@pytest.fixture(autouse=True)
def offline_discovery_status(monkeypatch):
    def unavailable(*args, **kwargs):
        raise httpx.ConnectError("private-canary")

    monkeypatch.setattr(httpx, "get", unavailable)


def test_live_discovery_report_projects_only_safe_current_errors(monkeypatch):
    requests = []
    message = "The network proxy rejected or failed the connection. Check your proxy settings."

    def get(url, **kwargs):
        requests.append((url, kwargs))
        return httpx.Response(
            200,
            request=httpx.Request("GET", url),
            json={
                "status": "running",
                "token": "private-canary",
                "startup": {
                    "providers": {
                        "nvidia_nim": "failed",
                        "open_router": "ready",
                        "lmstudio": "unavailable",
                        "llamacpp": "unavailable",
                        "ollama": "unavailable",
                        "private-canary": "failed",
                    },
                    "provider_errors": {
                        "nvidia_nim": message,
                        "open_router": "private-canary",
                        "ollama": "private-canary",
                    },
                },
            },
        )

    monkeypatch.setattr(httpx, "get", get)
    result = diagnostics.model_discovery_report(Settings())
    assert result["status"] == "available"
    assert result["providers"]["nvidia_nim"] == {"state": "failed", "message": message}
    assert result["providers"]["open_router"] == {"state": "ready"}
    for provider_id in ("lmstudio", "llamacpp", "ollama"):
        assert result["providers"][provider_id] == {"state": "unavailable"}
    assert "private-canary" not in json.dumps(result)
    assert requests == [
        (
            "http://127.0.0.1:8082/admin/api/status",
            {
                "timeout": 2.0,
                "trust_env": False,
                "follow_redirects": False,
            },
        )
    ]


@pytest.mark.parametrize(
    "payload",
    [
        None,
        [],
        {},
        {"status": "running"},
        {"status": "running", "startup": {"providers": []}},
    ],
)
def test_missing_or_incompatible_live_status_is_unavailable(monkeypatch, payload):
    monkeypatch.setattr(
        httpx,
        "get",
        lambda url, **kwargs: httpx.Response(
            200, request=httpx.Request("GET", url), json=payload
        ),
    )
    assert diagnostics.model_discovery_report(Settings())["status"] == "unavailable"


@pytest.mark.parametrize(
    "message",
    [
        "private-canary",
        "The model-list request returned HTTP 403. private-canary",
        {},
        None,
    ],
)
def test_doctor_does_not_trust_arbitrary_server_failure_text(monkeypatch, message):
    monkeypatch.setattr(
        httpx,
        "get",
        lambda url, **kwargs: httpx.Response(
            200,
            request=httpx.Request("GET", url),
            json={
                "status": "running",
                "startup": {
                    "providers": {"nvidia_nim": "failed"},
                    "provider_errors": {"nvidia_nim": message},
                },
            },
        ),
    )
    result = diagnostics.model_discovery_report(Settings())
    assert result["providers"]["nvidia_nim"] == {
        "state": "failed",
        "message": "Could not load models. Check the provider's settings and retry.",
    }
    assert "private-canary" not in json.dumps(result)


@pytest.mark.parametrize(
    "status, body",
    [(302, "private-canary"), (500, "private-canary"), (200, "private-canary")],
)
def test_unusable_local_http_response_is_unavailable(monkeypatch, status, body):
    monkeypatch.setattr(
        httpx,
        "get",
        lambda url, **kwargs: httpx.Response(
            status,
            request=httpx.Request("GET", url),
            text=body,
            headers={"Location": "https://private-canary.test"},
        ),
    )
    result = diagnostics.model_discovery_report(Settings())
    assert result["status"] == "unavailable"
    assert "private-canary" not in json.dumps(result)


def test_discovery_status_failure_does_not_expose_exception_or_contact_remote_host(
    monkeypatch,
):
    assert diagnostics.model_discovery_report(Settings())["status"] == "unavailable"

    def forbidden(*args, **kwargs):
        pytest.fail("doctor must only contact the local server")

    monkeypatch.setattr(httpx, "get", forbidden)
    assert (
        diagnostics.model_discovery_report(Settings(HOST="remote.test"))["status"]
        == "unavailable"
    )


@pytest.mark.parametrize(
    "host", ["http://127.0.0.1", "[::1", "[::1]:8082", "local\nhost"]
)
def test_malformed_host_still_produces_a_doctor_report(monkeypatch, host):
    ManagedConfigStore().initialize({})
    monkeypatch.setenv("HOST", host)

    # Exercise real URL validation without connecting to a user-owned server.
    def validate_url(url, **kwargs):
        httpx.Request("GET", url)
        raise httpx.ConnectError("unavailable")

    monkeypatch.setattr(httpx, "get", validate_url)
    monkeypatch.setattr(diagnostics, "harness_report", lambda: {})
    monkeypatch.setattr(diagnostics, "integration_report", lambda settings: {})
    report = diagnostics.collect_report()
    assert report["configuration"]["status"] == "available"
    assert report["runtime"]["host"] == host
    assert report["model_discovery"]["status"] == "unavailable"
    assert json.dumps(report)


def test_missing_configuration_still_produces_report(monkeypatch):
    monkeypatch.setattr(diagnostics, "harness_report", lambda: {})
    report = diagnostics.collect_report()
    assert next(iter(report)) == "version"
    assert report["configuration"]["status"] == "missing"
    assert report["runtime"] is None
    assert report["providers"] is None
    assert report["system"]["python_version"]


def test_settings_projection_excludes_secrets_and_url_credentials():
    settings = Settings(
        OPENAI_API_KEY="secret-api-key",
        ANTHROPIC_API_KEY="secret-anthropic-key",
        ANTHROPIC_WORKSPACE_ID="secret-workspace",
        ANTHROPIC_AUTH_TOKEN="secret-proxy-token",
        TELEGRAM_BOT_TOKEN="secret-bot-token",
        ALLOWED_TELEGRAM_USER_ID="secret-user-id",
        LM_STUDIO_BASE_URL="http://user:secret-password@localhost:1234/private?key=secret-query",
        MODEL="openai_api/gpt-example",
    )
    result = diagnostics.settings_report(settings, {})
    encoded = json.dumps(result)
    assert "secret-" not in encoded
    assert "/private" not in encoded
    assert result["providers"]["openai_api"]["configured"] is True
    assert result["providers"]["openai_api"]["referenced"] is True
    assert (
        result["providers"]["lmstudio"]["base_url"]["origin"] == "http://localhost:1234"
    )
    assert result["model_routing"]["model"] == "openai_api/gpt-example"


def test_all_settings_have_an_explicit_reporting_policy():
    assert diagnostics.classified_settings() == set(Settings.model_fields)


def test_collection_does_not_initialize_or_expose_validation_input(monkeypatch):
    store = ManagedConfigStore()
    store.path.parent.mkdir(parents=True)
    store.path.write_text("FCC_CONFIG_SCHEMA=invalid\nOPENAI_API_KEY=secret-value\n")

    def forbidden(*args, **kwargs):
        pytest.fail("doctor must not initialize configuration")

    monkeypatch.setattr(ManagedConfigStore, "initialize", forbidden)
    monkeypatch.setattr(diagnostics, "harness_report", lambda: {})
    report = diagnostics.collect_report()
    assert report["configuration"]["status"] == "invalid"
    assert "secret-value" not in json.dumps(report)


def test_complete_report_reads_real_files_without_mutation(
    monkeypatch, tmp_path, capsys
):
    store = ManagedConfigStore()
    store.initialize({})
    store.commit(
        dict(store.read({}).managed)
        | {"MODEL": "openai_api/saved", "ANTHROPIC_AUTH_TOKEN": "managed-secret"}
    )
    monkeypatch.setenv("MODEL", "openai_api/process")
    monkeypatch.setenv("ANTHROPIC_AUTH_TOKEN", "ignored-secret")
    settings = store.read().settings
    assert settings.proxy_auth_token == "managed-secret"
    claude = diagnostics.claude_integration
    claude.configure(
        claude.settings_path(),
        local_proxy_root_url(settings),
        settings.proxy_auth_token,
        connected=True,
    )
    copilot_path = paths.github_copilot_auth_path()
    copilot_path.parent.mkdir(parents=True)
    copilot_path.write_text(
        json.dumps(
            {
                "schema_version": 1,
                "enabled": True,
                "revision": 1,
                "identity": {"host": "github.com", "login": "private-account"},
            }
        )
    )
    before = {p: p.read_bytes() for p in tmp_path.rglob("*") if p.is_file()}

    def forbidden(*args, **kwargs):
        pytest.fail("diagnostics must not initialize config or construct HTTP clients")

    monkeypatch.setattr(ManagedConfigStore, "initialize", forbidden)
    monkeypatch.setattr(openai_auth.httpx, "AsyncClient", forbidden)
    monkeypatch.setattr(diagnostics.shutil, "which", lambda binary: None)
    copied = []
    monkeypatch.setattr(doctor, "copy_text", copied.append)
    doctor.main([])
    stdout = capsys.readouterr().out
    report = json.loads(stdout)
    assert copied == [stdout]
    assert report["model_routing"]["model"] == "openai_api/process"
    assert report["integrations"]["claude-vscode"]["connected"] is True
    assert report["providers"]["github_copilot"]["saved_connection"] == "connected"
    assert report["errors"] == []
    assert report["model_discovery"]["status"] == "unavailable"
    assert all(not item["installed"] for item in report["harnesses"].values())
    for private in (
        "managed-secret",
        "ignored-secret",
        "private-account",
        str(tmp_path),
    ):
        assert private not in stdout
    assert before == {p: p.read_bytes() for p in tmp_path.rglob("*") if p.is_file()}


def test_every_credential_and_private_identifier_is_excluded():
    values = dict.fromkeys(diagnostics.EXCLUDED_FIELDS, "private-canary")
    encoded = json.dumps(
        diagnostics.settings_report(Settings.model_validate(values), {})
    )
    assert "private-canary" not in encoded


def test_one_unreadable_integration_does_not_hide_other_sections(monkeypatch):
    store = ManagedConfigStore()
    store.initialize({})
    codex_path = diagnostics.codex_integration.config_path()
    codex_path.parent.mkdir(parents=True)
    codex_path.write_text("not valid toml private-content")
    monkeypatch.setattr(diagnostics.shutil, "which", lambda binary: None)
    report = diagnostics.collect_report()
    assert report["runtime"] is not None
    assert report["integrations"]["codex"]["connected"] is None
    assert report["integrations"]["claude-vscode"]["status"] == "available"
    assert "private-content" not in json.dumps(report)


@pytest.mark.parametrize(
    "banner, redirect", [("", ""), ("echo private-banner\n", ""), ("", " >&2")]
)
def test_native_version_probe_works_with_platform_command_shim(
    monkeypatch, tmp_path, banner, redirect
):
    suffix = ".cmd" if sys.platform == "win32" else ""
    binary = tmp_path / ("doctor-test-harness" + suffix)
    binary.write_text(
        ("@echo off\n" if suffix else "#!/bin/sh\n")
        + banner
        + f"echo 1.2.3{redirect}\n"
    )
    binary.chmod(0o755)
    monkeypatch.setenv("PATH", str(tmp_path) + os.pathsep + os.environ["PATH"])
    assert diagnostics.probe_harness("doctor-test-harness", ("--version",)) == {
        "installed": True,
        "version": "1.2.3",
        "status": "available",
    }


def test_command_prints_and_copies_identical_json(monkeypatch, capsys):
    copied = []
    monkeypatch.setattr(
        doctor, "collect_report", lambda: {"version": "1.2.3", "errors": []}
    )
    monkeypatch.setattr(doctor, "copy_text", copied.append)
    doctor.main([])
    captured = capsys.readouterr()
    assert copied == [captured.out]
    assert captured.out.startswith('{\n  "version": "1.2.3"')
    assert json.loads(captured.out)["errors"] == []


def test_clipboard_failure_leaves_valid_stdout(monkeypatch, capsys):
    monkeypatch.setattr(doctor, "collect_report", lambda: {"version": "1.2.3"})

    def unavailable(text):
        raise doctor.ClipboardUnavailable

    monkeypatch.setattr(doctor, "copy_text", unavailable)
    doctor.main([])
    captured = capsys.readouterr()
    assert json.loads(captured.out) == {"version": "1.2.3"}
    assert "manually" in captured.err


@pytest.mark.parametrize(
    "failure, status",
    [
        (subprocess.TimeoutExpired("stub", 5), "timeout"),
        (OSError("secret-path"), "unavailable"),
    ],
)
def test_version_probe_failure_is_bounded_and_sanitized(monkeypatch, failure, status):
    monkeypatch.setattr(diagnostics.shutil, "which", lambda binary: "stub")

    def run(args, **kwargs):
        assert kwargs["timeout"] == 5
        assert kwargs["stdin"] == subprocess.DEVNULL
        raise failure

    monkeypatch.setattr(diagnostics.subprocess, "run", run)
    result = diagnostics.probe_harness("claude", ("--version",))
    assert result == {"installed": True, "version": None, "status": status}


@pytest.mark.parametrize(
    "name, output, stderr, expected",
    [
        ("claude", "2.1.7 (Claude Code)", "secret-error", "2.1.7"),
        ("dsh", "0.1.0-rc.8", "secret-error", "0.1.0-rc.8"),
        ("dsh", "0.1.0-rc.8+build.1", "secret-error", "0.1.0-rc.8+build.1"),
        (
            "grok",
            '{"currentVersion":"1.0.5","path":"secret-path"}',
            "secret-warning 9.8.7",
            "1.0.5",
        ),
        ("grok", '{"path":"secret-path"}', "secret-warning 9.8.7", None),
        ("claude", "unknown secret-output", "secret-error", None),
    ],
)
def test_probe_returns_only_version(monkeypatch, name, output, stderr, expected):
    monkeypatch.setattr(diagnostics.shutil, "which", lambda binary: "stub")
    monkeypatch.setattr(
        diagnostics.subprocess,
        "run",
        lambda args, **kwargs: subprocess.CompletedProcess(args, 0, output, stderr),
    )
    result = diagnostics.probe_harness(name, ("--version",))
    assert result["version"] == expected
    assert "secret-" not in json.dumps(result)


def test_clipboard_adapter_maps_backend_failure(monkeypatch):
    from free_claude_code.cli import clipboard

    def unavailable(text):
        raise clipboard.pyperclip.PyperclipException("no desktop")

    monkeypatch.setattr(clipboard.pyperclip, "copy", unavailable)
    with pytest.raises(clipboard.ClipboardUnavailable):
        clipboard.copy_text("diagnostic text")


def test_doctor_version_does_not_collect_or_copy(monkeypatch, capsys):
    from free_claude_code.cli import entrypoints

    def forbidden():
        pytest.fail("version must not collect or copy a report")

    monkeypatch.setattr(doctor, "collect_report", forbidden)
    monkeypatch.setattr(entrypoints, "package_version", lambda: "1.2.3")
    entrypoints.doctor(["--version"])
    assert capsys.readouterr().out == "free-claude-code 1.2.3\n"


def test_fallback_model_efforts_are_json_serializable_in_doctor_report():
    entries = [
        {"model": "groq/one", "reasoning": "low"},
        {"model": "open_router/vendor/two", "reasoning": "client"},
    ]
    settings = Settings(MODEL_FALLBACKS=entries)
    report = json.loads(json.dumps(diagnostics.settings_report(settings, {})))
    assert report["model_routing"]["model_fallbacks"] == [
        entry | {"api_key_number": 1} for entry in entries
    ]
    assert report["providers"]["groq"]["referenced"] is True
    assert report["providers"]["open_router"]["referenced"] is True


def test_disconnect_mode_does_not_collect_or_copy_diagnostics(monkeypatch, capsys):
    from free_claude_code.harnesses import integration_cleanup

    calls = []
    monkeypatch.setattr(
        integration_cleanup,
        "disconnect_integrations",
        lambda: calls.append("disconnect"),
    )

    def forbidden(*args):
        pytest.fail("cleanup must not collect diagnostics or use the clipboard")

    monkeypatch.setattr(doctor, "collect_report", forbidden)
    monkeypatch.setattr(doctor, "copy_text", forbidden)
    doctor.main(["--disconnect-integrations"])
    assert calls == ["disconnect"]
    assert capsys.readouterr() == (
        "Disconnected recognized FCC editor/app integrations.\n",
        "",
    )


def test_disconnect_mode_reports_failure_and_nonzero_exit(monkeypatch, capsys):
    from free_claude_code.harnesses import integration_cleanup

    def fail():
        raise integration_cleanup.IntegrationCleanupError("Could not disconnect Codex.")

    monkeypatch.setattr(integration_cleanup, "disconnect_integrations", fail)
    with pytest.raises(SystemExit) as error:
        doctor.main(["--disconnect-integrations"])
    assert error.value.code == 1
    assert capsys.readouterr() == ("", "Could not disconnect Codex.\n")