Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

49.9 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

from __future__ import annotations

import json
import os
import stat
import sys
from pathlib import Path
from urllib.parse import parse_qs, urlparse

_REPO_ROOT = Path(__file__).resolve().parents[2]
if str(_REPO_ROOT) not in sys.path:
    sys.path.insert(0, str(_REPO_ROOT))

import pytest
from typer.testing import CliRunner

import unsloth_cli.commands.start as start

BASE = "http://127.0.0.1:8888"
MODEL = {"id": "unsloth/gemma-4-E2B-it-GGUF", "context_length": 32768}
CLI_KEY = "sk-unsloth-c11c11c11c11"
APP_KEY = "sk-unsloth-a99a99a99a99"


def _parse_toml(text: str) -> dict:
    tomllib = pytest.importorskip("tomllib")
    return tomllib.loads(text)


def _private(path: Path) -> bool:
    return os.name == "nt" or stat.S_IMODE(path.stat().st_mode) == 0o600


@pytest.fixture
def studio(tmp_path, monkeypatch):
    home = tmp_path / "home"
    home.mkdir()
    monkeypatch.setenv("HOME", str(home))
    monkeypatch.setenv("USERPROFILE", str(home))
    monkeypatch.setenv("LOCALAPPDATA", str(home / "AppData" / "Local"))
    monkeypatch.delenv("CODEX_HOME", raising = False)
    monkeypatch.delenv("UNSLOTH_API_KEY", raising = False)
    for name in ("OPENCLAW_CONFIG_PATH", "OPENCLAW_STATE_DIR", "OPENCLAW_HOME", "OPENCLAW_PROFILE"):
        monkeypatch.delenv(name, raising = False)
    server = {"calls": [], "keys": {CLI_KEY, APP_KEY}, "minted": 0}

    def http_json(
        method,
        url,
        token,
        payload = None,
        timeout = 30,
        error = None,
    ):
        server["calls"].append((method, url, payload))
        if url.endswith("/api/inference/loaded-models"):
            if token not in server["keys"] and token != "jwt":
                raise start.urllib.error.HTTPError(url, 401, "Unauthorized", {}, None)
            return {"object": "list", "data": [MODEL]}
        if url.split("?")[0].endswith("/api/inference/status"):
            return {"is_gguf": True, "model_identifier": MODEL["id"]}
        if url.endswith("/api/auth/api-keys") and method == "GET":
            return {"api_keys": [{"key_prefix": CLI_KEY[11:19]}]}
        if url.endswith("/api/auth/api-keys") and method == "POST":
            if payload["name"].startswith("Coding agents"):
                return {"key": CLI_KEY, "api_key": {"id": 1}}
            server["minted"] += 1
            return {"key": APP_KEY, "api_key": {"id": 7}}
        if "/api/auth/api-keys/" in url and method == "DELETE":
            server["keys"].discard(APP_KEY)
            return {"detail": "API key revoked"}
        raise AssertionError(f"unexpected request: {method} {url}")

    monkeypatch.setattr(start, "find_studio_server", lambda: BASE)
    monkeypatch.setattr(start, "verify_studio_identity", lambda base: True)
    monkeypatch.setattr(start, "_hub_gguf_files", lambda repo: None)
    monkeypatch.setattr(start, "_studio_token", lambda: "jwt")
    monkeypatch.setattr(start, "_http_json", http_json)
    monkeypatch.setattr(start, "_key_cache_path", lambda: tmp_path / "agent_api_key.json")
    monkeypatch.setattr(start, "_agents_config_root", lambda: tmp_path / "agents")
    monkeypatch.setattr(start, "_require_agent_for_launch", lambda *args: None)
    monkeypatch.setattr(
        start, "_launch", lambda *args, **kwargs: pytest.fail("--app launched the CLI")
    )
    monkeypatch.setattr(start.shutil, "which", lambda _: None)
    server["opened"] = 0
    monkeypatch.setattr(
        start, "_open_codex_app", lambda: server.__setitem__("opened", 1), raising = False
    )
    monkeypatch.setattr(start, "_studio_healthy", lambda base, timeout = 3.0: True)
    server["while_running"] = lambda: None

    def ctrl_c(_seconds):
        server["while_running"]()
        raise KeyboardInterrupt

    monkeypatch.setattr(start.time, "sleep", ctrl_c)
    server["home"] = home
    return server


USER_CODEX = (
    "# my settings\n"
    'model = "gpt-5.5"\n'
    'approval_policy = "on-request"\n'
    "\n"
    '[projects."/work/repo"]\n'
    'trust_level = "trusted"\n'
)


def _codex_config(studio) -> Path:
    config = studio["home"] / ".codex" / "config.toml"
    config.parent.mkdir(exist_ok = True)
    config.write_text(USER_CODEX)
    return config


def test_codex_app_switches_the_app_while_running_and_back_on_exit(studio):
    config = _codex_config(studio)
    catalog = config.with_name("unsloth-model-catalog.json")
    backup = config.with_name("config.toml.unsloth-backup")
    seen = {}

    def while_running():
        seen["config"] = _parse_toml(config.read_text())
        seen["catalog"] = json.loads(catalog.read_text())["models"]
        seen["private"] = all(_private(p) for p in (config, catalog, backup))
        seen["backup"] = backup.read_text()

    studio["while_running"] = while_running

    result = CliRunner().invoke(start.start_app, ["codex", "--app"])

    assert result.exit_code == 0, result.output
    assert seen["config"]["model_provider"] == "unsloth_api"
    assert seen["config"]["model"] == MODEL["id"]
    assert seen["config"]["model_catalog_json"] == "unsloth-model-catalog.json"
    assert seen["config"]["approval_policy"] == "on-request"
    provider = seen["config"]["model_providers"]["unsloth_api"]
    assert provider["base_url"] == f"{BASE}/v1"
    assert provider["experimental_bearer_token"] == APP_KEY
    [listed] = seen["catalog"]
    assert (listed["slug"], listed["visibility"]) == (MODEL["id"], "list")
    assert seen["private"]
    assert seen["backup"] == USER_CODEX
    assert studio["opened"] == 1
    assert config.read_text() == USER_CODEX
    assert not catalog.exists()
    assert not backup.exists()
    assert ("POST", f"{BASE}/api/auth/api-keys", {"name": "Codex app"}) in studio["calls"]
    assert ("DELETE", f"{BASE}/api/auth/api-keys/7", None) in studio["calls"]
    assert APP_KEY not in result.output
    assert "Switched the Codex app back" in result.output


def test_codex_app_switches_back_when_unsloth_stops_answering(studio, monkeypatch):
    config = _codex_config(studio)
    monkeypatch.setattr(start.time, "sleep", lambda _seconds: None)
    monkeypatch.setattr(start, "_studio_healthy", lambda base, timeout = 3.0: False)

    result = CliRunner().invoke(start.start_app, ["codex", "--app"])

    assert result.exit_code == 0, result.output
    assert "stopped answering" in result.output
    assert config.read_text() == USER_CODEX
    assert not config.with_name("unsloth-model-catalog.json").exists()


def test_codex_recovers_a_switch_left_by_a_dead_session(studio, monkeypatch, tmp_path):
    config = _codex_config(studio)
    with monkeypatch.context() as crash:
        crash.setattr(start, "_switch_codex_app_back", lambda *args: [], raising = False)
        assert CliRunner().invoke(start.start_app, ["codex", "--app"]).exit_code == 0
    state_path = tmp_path / "agents" / "app" / "codex.json"
    state = json.loads(state_path.read_text())
    state["owner"] = {"pid": 2**22 + 4321, "started": 1.0}
    state_path.write_text(json.dumps(state))
    assert _parse_toml(config.read_text())["model"] == MODEL["id"]

    result = CliRunner().invoke(start.start_app, ["codex", "--no-launch"])

    assert result.exit_code == 0, result.output
    assert "did not exit cleanly" in result.output
    assert config.read_text() == USER_CODEX
    assert not state_path.exists()


def test_a_second_codex_app_session_does_not_switch_twice(studio):
    config = _codex_config(studio)
    seen = {}

    def while_running():
        before = config.read_text()
        seen["second"] = CliRunner().invoke(start.start_app, ["codex", "--app"])
        seen["unchanged"] = config.read_text() == before

    studio["while_running"] = while_running

    result = CliRunner().invoke(start.start_app, ["codex", "--app"])

    assert result.exit_code == 0, result.output
    assert seen["second"].exit_code == 1
    assert "already on Unsloth" in seen["second"].output
    assert seen["unchanged"]
    assert studio["minted"] == 1
    assert config.read_text() == USER_CODEX


def test_codex_app_leaves_a_model_the_user_picked_while_running(studio):
    config = _codex_config(studio)
    studio["while_running"] = lambda: config.write_text(
        config.read_text().replace(f'model = "{MODEL["id"]}"', 'model = "o3"')
    )

    result = CliRunner().invoke(start.start_app, ["codex", "--app"])

    assert result.exit_code == 0, result.output
    parsed = _parse_toml(config.read_text())
    assert parsed["model"] == "o3"
    assert parsed["approval_policy"] == "on-request"
    assert "model_provider" not in parsed
    assert "model_catalog_json" not in parsed
    assert "unsloth_api" not in parsed.get("model_providers", {})
    assert "Left model" in result.output


def test_codex_app_creates_and_removes_a_missing_config(studio):
    config = studio["home"] / ".codex" / "config.toml"
    seen = {}
    studio["while_running"] = lambda: seen.update(model = _parse_toml(config.read_text())["model"])

    assert CliRunner().invoke(start.start_app, ["codex", "--app"]).exit_code == 0

    assert seen["model"] == MODEL["id"]
    assert not config.exists()
    assert not config.with_name("unsloth-model-catalog.json").exists()


def test_codex_app_keeps_a_created_config_the_app_wrote_to_without_a_toml_parser(
    studio, monkeypatch
):
    config = studio["home"] / ".codex" / "config.toml"
    monkeypatch.setitem(sys.modules, "tomllib", None)
    monkeypatch.setitem(sys.modules, "tomli", None)
    studio["while_running"] = lambda: config.write_text(
        config.read_text() + '\n[projects."/work/repo"]\ntrust_level = "trusted"\n'
    )

    assert CliRunner().invoke(start.start_app, ["codex", "--app"]).exit_code == 0

    assert config.read_text().strip() == '[projects."/work/repo"]\ntrust_level = "trusted"'


@pytest.mark.skipif(os.name == "nt", reason = "creating a symlink needs admin rights on Windows")
def test_codex_app_refuses_a_symlinked_config(studio, tmp_path):
    target = tmp_path / "dotfiles" / "codex.toml"
    target.parent.mkdir()
    target.write_text(USER_CODEX)
    config = studio["home"] / ".codex" / "config.toml"
    config.parent.mkdir()
    config.symlink_to(target)

    result = CliRunner().invoke(start.start_app, ["codex", "--app"])

    assert result.exit_code == 1
    assert "symlink" in result.output
    assert target.read_text() == USER_CODEX
    assert studio["minted"] == 0


def test_app_refuses_a_remote_server_without_an_explicit_key(studio, monkeypatch, tmp_path):
    remote = "http://10.0.0.5:8888"
    monkeypatch.setattr(start, "find_studio_server", lambda: remote)
    cache = tmp_path / "agent_api_key.json"
    cache.write_text(json.dumps({"servers": {remote: {"saved": [CLI_KEY], "minted": []}}}))

    result = CliRunner().invoke(start.start_app, ["codex", "--app"])

    assert result.exit_code == 1
    assert "--api-key" in result.output
    assert not (studio["home"] / ".codex").exists()


def test_codex_app_never_revokes_an_explicit_key(studio, monkeypatch):
    monkeypatch.setattr(start, "find_studio_server", lambda: "http://10.0.0.5:8888")
    config = studio["home"] / ".codex" / "config.toml"
    seen = {}
    studio["while_running"] = lambda: seen.update(config = _parse_toml(config.read_text()))

    result = CliRunner().invoke(start.start_app, ["codex", "--app", "--api-key", CLI_KEY])

    assert result.exit_code == 0, result.output
    assert seen["config"]["model_providers"]["unsloth_api"]["experimental_bearer_token"] == CLI_KEY
    assert studio["minted"] == 0
    assert not any(m == "DELETE" for m, _, _ in studio["calls"])


def test_codex_app_has_no_off_switch():
    result = CliRunner().invoke(start.start_app, ["codex", "--help"])
    assert "--app " in result.output
    assert "--app-off" not in result.output


def test_undo_is_not_an_app_option(studio):
    result = CliRunner().invoke(start.start_app, ["opencode", "--app", "--undo"])
    assert result.exit_code == 1
    assert "takes no agent arguments" in result.output


def test_opencode_app_adds_unsloth_without_changing_the_default_model(studio, monkeypatch):
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start, "_opencode_command", lambda *_: ("opencode", False))
    config = studio["home"] / ".config" / "opencode" / "opencode.json"
    config.parent.mkdir(parents = True)
    user = {
        "$schema": "https://opencode.ai/config.json",
        "model": "openai/gpt-5.5",
        "enabled_providers": ["anthropic"],
        "permission": {"bash": "allow"},
    }
    original = json.dumps(user, indent = 4) + "\n"
    config.write_text(original)

    result = CliRunner().invoke(start.start_app, ["opencode", "--app"])

    assert result.exit_code == 0, result.output
    data = json.loads(config.read_text())
    assert data["model"] == "openai/gpt-5.5"
    assert data["enabled_providers"] == ["anthropic", "unsloth-studio"]
    provider = data["provider"]["unsloth-studio"]
    assert provider["options"] == {"baseURL": f"{BASE}/v1", "apiKey": APP_KEY}
    assert provider["models"][MODEL["id"]]["limit"]["output"] > 0
    assert data["permission"] == {"bash": "allow"}
    assert "compaction" not in data
    assert _private(config)
    assert config.with_name("opencode.json.unsloth-backup").read_text() == original
    assert ("POST", f"{BASE}/api/auth/api-keys", {"name": "OpenCode app"}) in studio["calls"]
    assert APP_KEY not in result.output

    first = config.read_text()
    again = CliRunner().invoke(start.start_app, ["opencode", "--app"])
    assert again.exit_code == 0, again.output
    assert config.read_text() == first
    assert studio["minted"] == 1


def test_openclaw_app_adds_unsloth_and_joins_an_existing_allowlist(studio):
    config = studio["home"] / ".openclaw" / "openclaw.json"
    config.parent.mkdir()
    user = {
        "agents": {
            "defaults": {
                "model": {"primary": "openai/gpt-5.5", "fallbacks": ["openai/o3"]},
                "modelPolicy": {"allow": ["openai/*"]},
                "workspace": "/work",
            }
        },
        "gateway": {"mode": "local", "auth": {"mode": "token"}},
    }
    config.write_text(json.dumps(user, indent = 2) + "\n")

    result = CliRunner().invoke(start.start_app, ["openclaw", "--app"])

    assert result.exit_code == 0, result.output
    data = json.loads(config.read_text())
    ref = f"unsloth/{MODEL['id']}"
    defaults = data["agents"]["defaults"]
    assert defaults["model"] == user["agents"]["defaults"]["model"]
    assert defaults["modelPolicy"] == {"allow": ["openai/*", ref]}
    assert "models" not in defaults
    assert defaults["workspace"] == "/work"
    assert data["gateway"] == user["gateway"]
    assert data["models"]["providers"]["unsloth"]["apiKey"] == APP_KEY
    assert data["models"]["providers"]["unsloth"]["baseUrl"] == f"{BASE}/v1"


@pytest.mark.parametrize("selector", ["config", "state", "both", "home", "profile"])
def test_openclaw_app_updates_selected_config_only(studio, monkeypatch, tmp_path, selector):
    default = studio["home"] / ".openclaw" / "openclaw.json"
    default.parent.mkdir()
    default.write_text('{"marker": "unrelated default"}\n')
    if selector == "home":
        monkeypatch.setenv("OPENCLAW_HOME", str(tmp_path / "relocated-home"))
        selected = tmp_path / "relocated-home" / ".openclaw" / "openclaw.json"
    elif selector == "profile":
        monkeypatch.setenv("OPENCLAW_PROFILE", "work")
        selected = studio["home"] / ".openclaw-work" / "openclaw.json"
        monkeypatch.setenv("OPENCLAW_STATE_DIR", str(selected.parent))
        monkeypatch.setenv("OPENCLAW_CONFIG_PATH", str(selected))
    else:
        selected = tmp_path / "selected" / "openclaw.json"
        if selector in ("config", "both"):
            monkeypatch.setenv("OPENCLAW_CONFIG_PATH", str(selected))
        if selector in ("state", "both"):
            # An explicit file wins over a different state directory.
            state = selected.parent if selector == "state" else tmp_path / "other-state"
            monkeypatch.setenv("OPENCLAW_STATE_DIR", str(state))
    selected.parent.mkdir(parents = True)
    original = '{"marker": "selected", "agents": {"defaults": {}}}\n'
    selected.write_text(original)

    result = CliRunner().invoke(start.start_app, ["openclaw", "--app"])

    assert result.exit_code == 0, result.output
    data = json.loads(selected.read_text())
    assert data["marker"] == "selected"
    assert data["models"]["providers"]["unsloth"]["apiKey"] == APP_KEY
    assert selected.with_name("openclaw.json.unsloth-backup").read_text() == original
    assert default.read_text() == '{"marker": "unrelated default"}\n'
    state = json.loads(start._app_state_path("openclaw", selected).read_text())
    assert state["path"] == str(selected)


@pytest.mark.parametrize("override", ["~/custom/openclaw.json", "relative/openclaw.json"])
def test_openclaw_app_resolves_user_paths(studio, monkeypatch, tmp_path, override):
    monkeypatch.chdir(tmp_path)
    monkeypatch.setenv("OPENCLAW_CONFIG_PATH", " " + override + " ")
    expected = (
        studio["home"] / "custom/openclaw.json" if override.startswith("~") else tmp_path / override
    )
    assert start._openclaw_app_target().path == expected


def test_openclaw_app_expands_tilde_against_selected_home(studio, monkeypatch, tmp_path):
    monkeypatch.setenv("OPENCLAW_HOME", str(tmp_path / "selected-home"))
    monkeypatch.setenv("OPENCLAW_CONFIG_PATH", "~/custom.json")
    assert start._openclaw_app_target().path == tmp_path / "selected-home" / "custom.json"


@pytest.mark.parametrize(
    "reported, profile, selected",
    [
        ("{home}/.openclaw/openclaw.json", "work", ".openclaw"),
        ("{home}/.openclaw-work/openclaw.json", "work", ".openclaw-work"),
        (None, "work", ".openclaw"),
        ("not a path", "work", ".openclaw"),
        ("{home}/.openclaw-work/openclaw.json", "Default", ".openclaw"),
        ("{home}/.openclaw-work/openclaw.json", "bad/name", ".openclaw"),
    ],
)
def test_openclaw_profile_environment_alone(studio, monkeypatch, reported, profile, selected):
    home = studio["home"]
    asked = []

    def check_output(command, **kwargs):
        asked.append(command[1:])
        if reported is None:
            raise start.subprocess.CalledProcessError(1, command)
        return "[plugins] ready\n" + reported.format(home = home) + "\n"

    monkeypatch.setattr(start, "_which_with_install_dirs", lambda name: "/bin/" + name)
    monkeypatch.setattr(start.subprocess, "check_output", check_output)
    monkeypatch.setenv("OPENCLAW_PROFILE", profile)
    config = home / selected / "openclaw.json"
    config.parent.mkdir()
    config.write_text('{"marker": "active"}\n')

    result = CliRunner().invoke(start.start_app, ["openclaw", "--app"])

    assert result.exit_code == 0, result.output
    data = json.loads(config.read_text())
    assert data["models"]["providers"]["unsloth"]["apiKey"] == APP_KEY
    assert data["marker"] == "active"
    other = ".openclaw-work" if selected == ".openclaw" else ".openclaw"
    assert not (home / other / "openclaw.json").exists()
    assert asked == ([] if profile != "work" else [["config", "file"]])


@pytest.mark.parametrize("sentinel", ["null", " undefined "])
def test_openclaw_home_sentinel_is_unset(studio, monkeypatch, sentinel):
    monkeypatch.setenv("OPENCLAW_HOME", sentinel)
    assert start._openclaw_app_target().path == studio["home"] / ".openclaw" / "openclaw.json"


def test_openclaw_app_creates_no_allowlist(studio):
    config = studio["home"] / ".openclaw" / "openclaw.json"
    config.parent.mkdir()
    config.write_text('{"agents": {"defaults": {"model": "openai/gpt-5.5"}}}\n')

    assert CliRunner().invoke(start.start_app, ["openclaw", "--app"]).exit_code == 0

    defaults = json.loads(config.read_text())["agents"]["defaults"]
    assert defaults == {"model": "openai/gpt-5.5"}


@pytest.mark.parametrize(
    "defaults",
    [{"modelPolicy": {"allow": []}}, {"models": {}}],
    ids = ["empty-allow", "empty-legacy-map"],
)
def test_openclaw_app_keeps_an_empty_allowlist_open(studio, defaults):
    config = studio["home"] / ".openclaw" / "openclaw.json"
    config.parent.mkdir()
    config.write_text(json.dumps({"agents": {"defaults": defaults}}) + "\n")

    assert CliRunner().invoke(start.start_app, ["openclaw", "--app"]).exit_code == 0

    assert json.loads(config.read_text())["agents"]["defaults"] == defaults


@pytest.mark.parametrize("vision", [True, False])
def test_app_config_declares_image_input_only_for_a_vision_model(studio, monkeypatch, vision):
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start, "_opencode_command", lambda *_: ("opencode", False))
    http_json = start._http_json

    def with_vision(method, url, *args, **kwargs):
        answer = http_json(method, url, *args, **kwargs)
        if url.split("?")[0].endswith("/api/inference/status"):
            answer["is_vision"] = vision
        return answer

    monkeypatch.setattr(start, "_http_json", with_vision)
    for agent in ("opencode", "openclaw"):
        result = CliRunner().invoke(start.start_app, [agent, "--app"])
        assert result.exit_code == 0, result.output
    opencode = json.loads((studio["home"] / ".config" / "opencode" / "opencode.json").read_text())
    model = opencode["provider"]["unsloth-studio"]["models"][MODEL["id"]]
    assert model.get("attachment", False) is vision
    assert ("image" in model.get("modalities", {}).get("input", ())) is vision
    openclaw = json.loads((studio["home"] / ".openclaw" / "openclaw.json").read_text())
    model = openclaw["models"]["providers"]["unsloth"]["models"][0]
    assert ("image" in model.get("input", ())) is vision


def test_opencode_app_reads_a_commented_jsonc(studio, monkeypatch):
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start, "_opencode_command", lambda *_: ("opencode", False))
    config = studio["home"] / ".config" / "opencode" / "opencode.jsonc"
    config.parent.mkdir(parents = True)
    config.write_text('{\n  // mine\n  "model": "openai/gpt-5.5", /* x */\n  "theme": "a//b",\n}\n')

    result = CliRunner().invoke(start.start_app, ["opencode", "--app"])

    assert result.exit_code == 0, result.output
    text = config.read_text()
    assert "// mine" in text and "/* x */" in text
    data = start._load_app_config(config, text)
    assert (data["model"], data["theme"]) == ("openai/gpt-5.5", "a//b")
    assert "unsloth-studio" in data["provider"]

    assert CliRunner().invoke(start.start_app, ["opencode", "--app"]).exit_code == 0
    assert config.read_text() == text


@pytest.mark.parametrize(
    "text",
    [
        "{}",
        "{\n  // only a comment\n}\n",
        '{\n  "provider": {\n    // keep\n    "openai": {"x": 1},\n  },\n}\n',
        '{"provider": {"unsloth-studio": {"old": true}}, /* tail */ "model": "m"}',
    ],
)
def test_set_app_values_keeps_jsonc_comments(tmp_path, text):
    path = tmp_path / "opencode.jsonc"
    updates = [(("provider", "unsloth-studio"), {"npm": "x", "models": {"a": {}}})]
    out = start._set_app_values(text, path, updates)
    expected = start._load_app_config(path, text)
    expected.setdefault("provider", {})["unsloth-studio"] = updates[0][1]
    assert start._load_app_config(path, out) == expected
    for comment in ("// only a comment", "// keep", "/* tail */"):
        assert (comment in out) is (comment in text)
    assert start._set_app_values(out, path, updates) == out


def test_opencode_app_reenables_a_disabled_unsloth(studio, monkeypatch):
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start, "_opencode_command", lambda *_: ("opencode", False))
    config = studio["home"] / ".config" / "opencode" / "opencode.json"
    config.parent.mkdir(parents = True)
    config.write_text(json.dumps({"disabled_providers": ["openai", "unsloth-studio"]}) + "\n")

    assert CliRunner().invoke(start.start_app, ["opencode", "--app"]).exit_code == 0

    data = json.loads(config.read_text())
    assert data["disabled_providers"] == ["openai"]
    assert "unsloth-studio" in data["provider"]


@pytest.mark.parametrize(
    "original",
    [
        "{ agents: { defaults: { workspace: '~/work' } }, marker: 'keep me' }",
        "{ 'agents': { 'defaults': { 'workspace': '~/work' } }, 'marker': 'keep me' }",
        "{ agents: { defaults: { workspace: '~/work' } }, marker: 'https://example.test/a//b' }",
        "{ /* mine */ agents: { defaults: { workspace: '~/work', }, }, marker: '/* literal */', }",
    ],
)
def test_openclaw_app_preserves_json5_values_and_original_backup(studio, original):
    import json5

    config = studio["home"] / ".openclaw" / "openclaw.json"
    config.parent.mkdir()
    config.write_text(original)
    expected = json5.loads(original)

    result = CliRunner().invoke(start.start_app, ["openclaw", "--app"])

    assert result.exit_code == 0, result.output
    data = json5.loads(config.read_text())
    assert data["agents"] == expected["agents"]
    assert data["marker"] == expected["marker"]
    assert data["models"]["providers"]["unsloth"]["apiKey"] == APP_KEY
    assert config.with_name("openclaw.json.unsloth-backup").read_text() == original
    updated = config.read_text()
    assert CliRunner().invoke(start.start_app, ["openclaw", "--app"]).exit_code == 0
    assert config.read_text() == updated


def test_openclaw_app_writes_an_escaped_surrogate_pair(studio):
    config = studio["home"] / ".openclaw" / "openclaw.json"
    config.parent.mkdir()
    config.write_text("{ agents: { defaults: { workspace: '~/\\ud83d\\ude80' } } }")

    result = CliRunner().invoke(start.start_app, ["openclaw", "--app"])

    assert result.exit_code == 0, result.output
    data = json.loads(config.read_text(encoding = "utf-8"))
    assert data["agents"]["defaults"]["workspace"] == "~/\U0001f680"


@pytest.mark.parametrize("name", ["custom.settings", "custom.yaml", "custom.toml"])
def test_openclaw_json5_format_is_selected_by_agent(studio, tmp_path, name):
    import json5

    config = tmp_path / name
    config.write_text("{ marker: 'keep', agents: { defaults: {} } }")
    target = start._AppTarget("openclaw", "OpenClaw app", config, start._openclaw_app_updates)
    start._add_app_provider(target, BASE, APP_KEY, MODEL)
    data = json5.loads(config.read_text())
    assert data["marker"] == "keep"
    assert "unsloth" in data["models"]["providers"]


def test_opencode_app_does_not_accept_json5_as_jsonc(studio, monkeypatch):
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start, "_opencode_command", lambda *_: ("opencode", False))
    config = studio["home"] / ".config/opencode/opencode.json"
    config.parent.mkdir(parents = True)
    original = "{ theme: 'dark' }"
    config.write_text(original)
    result = CliRunner().invoke(start.start_app, ["opencode", "--app"])
    assert result.exit_code == 1
    assert "Couldn't parse" in result.output
    assert config.read_text() == original


def test_openclaw_app_reads_a_commented_config(studio):
    config = studio["home"] / ".openclaw" / "openclaw.json"
    config.parent.mkdir()
    config.write_text('{\n  // mine\n  "agents": {"defaults": {"model": "openai/gpt-5.5",}},\n}\n')

    result = CliRunner().invoke(start.start_app, ["openclaw", "--app"])

    assert result.exit_code == 0, result.output
    data = start._load_app_config(config, config.read_text())
    assert data["agents"]["defaults"] == {"model": "openai/gpt-5.5"}
    assert data["models"]["providers"]["unsloth"]["apiKey"] == APP_KEY


def test_opencode_app_keeps_each_config_dirs_backup_and_key(studio, monkeypatch, tmp_path):
    monkeypatch.setattr(start, "_opencode_command", lambda *_: ("opencode", False))
    originals = {}
    for name in ("a", "b"):
        config = tmp_path / name / "opencode" / "opencode.json"
        config.parent.mkdir(parents = True)
        originals[name] = json.dumps({"model": f"openai/{name}"}) + "\n"
        config.write_text(originals[name])

    for name in ("a", "b", "a"):
        monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / name))
        assert CliRunner().invoke(start.start_app, ["opencode", "--app"]).exit_code == 0

    for name in ("a", "b"):
        backup = tmp_path / name / "opencode" / "opencode.json.unsloth-backup"
        assert backup.read_text() == originals[name]
    assert studio["minted"] == 2


def test_codex_app_owner_without_psutil(monkeypatch):
    monkeypatch.setitem(sys.modules, "psutil", None)
    owner = start._codex_app_owner()
    assert owner == {"pid": os.getpid(), "started": None}
    assert start._codex_app_owner_alive(owner) is True


def test_hermes_app_replaces_the_provider_an_earlier_run_named_unsloth(studio):
    yaml = pytest.importorskip("yaml")
    config = start._hermes_app_target().path
    config.parent.mkdir(parents = True, exist_ok = True)
    legacy = {"base_url": f"{BASE}/v1", "api_mode": "openai", "api_key": "sk-unsloth-old"}
    mine = {"base_url": "http://elsewhere.test/v1", "api_key": "k"}
    config.write_text(
        yaml.safe_dump(
            {
                "model": {"provider": "custom:unsloth", "default": "m"},
                "providers": {"unsloth": legacy, "other": mine},
            }
        )
    )

    result = CliRunner().invoke(start.start_app, ["hermes", "--app"])

    assert result.exit_code == 0, result.output
    data = yaml.safe_load(config.read_text())
    assert set(data["providers"]) == {"unsloth-studio", "other"}
    assert data["model"] == {"provider": "custom:unsloth-studio", "default": "m"}

    providers = {"unsloth": {**mine, "base_url": f"{BASE}/v1", "headers": {"x": "1"}}}
    config.write_text(yaml.safe_dump({"providers": providers}))
    result = CliRunner().invoke(start.start_app, ["hermes", "--app"])
    assert result.exit_code == 0, result.output
    assert "unsloth" in yaml.safe_load(config.read_text())["providers"]


def test_hermes_app_adds_unsloth_to_the_active_profile(studio):
    yaml = pytest.importorskip("yaml")
    root = start._hermes_app_target().path.parent
    (root / "profiles" / "work").mkdir(parents = True)
    (root / "active_profile").write_text("work\n")
    config = root / "profiles" / "work" / "config.yaml"
    original = (
        "# my hermes\nmodel:\n  default: openrouter/kimi-k3  # mine\n  provider: openrouter\n"
        "toolsets:\n- web\n"
    )
    config.write_text(original)

    result = CliRunner().invoke(start.start_app, ["hermes", "--app"])

    assert result.exit_code == 0, result.output
    data = yaml.safe_load(config.read_text())
    assert data["model"] == {"default": "openrouter/kimi-k3", "provider": "openrouter"}
    assert "compression" not in data
    provider = data["providers"]["unsloth-studio"]
    assert provider["api_key"] == APP_KEY
    assert provider["base_url"] == f"{BASE}/v1"
    assert "key_env" not in provider
    assert provider["models"] == {MODEL["id"]: {"context_length": start._HERMES_MIN_CONTEXT}}
    assert data["toolsets"] == ["web"]
    assert config.read_text().startswith(original)
    assert not (root / "config.yaml").exists()
    assert ("POST", f"{BASE}/api/auth/api-keys", {"name": "Hermes app"}) in studio["calls"]
    assert "--max-seq-length 65536" in result.output


def test_app_refuses_a_config_it_cannot_parse(studio):
    config = studio["home"] / ".openclaw" / "openclaw.json"
    config.parent.mkdir()
    original = "{ // json5 comment\n  agents: { broken } }\n"
    config.write_text(original)

    result = CliRunner().invoke(start.start_app, ["openclaw", "--app"])

    assert result.exit_code == 1
    assert "Couldn't parse" in result.output
    assert config.read_text() == original
    assert studio["minted"] == 0


def test_app_revokes_the_key_it_minted_when_setup_fails(studio):
    config = studio["home"] / ".openclaw" / "openclaw.json"
    config.parent.mkdir()
    config.write_text('{"models": []}\n')

    result = CliRunner().invoke(start.start_app, ["openclaw", "--app"])

    assert result.exit_code == 1
    assert "isn't a table" in result.output
    assert config.read_text() == '{"models": []}\n'
    assert studio["minted"] == 1
    assert ("DELETE", f"{BASE}/api/auth/api-keys/7", None) in studio["calls"]


def test_app_revokes_the_key_it_minted_when_saving_fails(studio, monkeypatch):
    config = studio["home"] / ".openclaw" / "openclaw.json"
    config.parent.mkdir()
    config.write_text("{}\n")

    def read_only(path, text):
        raise PermissionError(path)

    monkeypatch.setattr(start, "_write_app_file", read_only)

    result = CliRunner().invoke(start.start_app, ["openclaw", "--app"])

    assert result.exit_code == 1
    assert ("DELETE", f"{BASE}/api/auth/api-keys/7", None) in studio["calls"]


def test_codex_app_switches_back_a_config_rewritten_with_crlf(studio):
    config = _codex_config(studio)
    studio["while_running"] = lambda: config.write_bytes(
        config.read_bytes().replace(b"\r\n", b"\n").replace(b"\n", b"\r\n")
    )

    assert CliRunner().invoke(start.start_app, ["codex", "--app"]).exit_code == 0

    parsed = _parse_toml(config.read_text())
    assert "model_providers" not in parsed
    assert parsed["model"] == "gpt-5.5"


@pytest.mark.parametrize(
    "agent, flags",
    [("openclaw", ["--temperature", "0.3"]), ("codex", ["--reasoning-effort", "high"])],
)
def test_app_leaves_request_flags_to_the_server(studio, monkeypatch, agent, flags):
    seen = {}
    real_connect = start._connect

    def connect(*args, **kwargs):
        seen["options"] = kwargs["server_options"]
        return real_connect(*args, **kwargs)

    monkeypatch.setattr(start, "_connect", connect)
    monkeypatch.setattr(start, "_agent_version_at_least", lambda *args: True)

    result = CliRunner().invoke(start.start_app, [agent, "--app", *flags])

    assert result.exit_code == 0, result.output
    assert seen["options"].sent_by_agent() == frozenset()


def test_hermes_app_uses_the_windows_hermes_home(studio, monkeypatch, tmp_path):
    local = tmp_path / "LocalAppData"
    monkeypatch.setattr(start.sys, "platform", "win32")
    monkeypatch.setenv("LOCALAPPDATA", str(local))

    target = start._hermes_app_target()

    assert target.path == local / "hermes" / "config.yaml"


def _vscode_config(studio, monkeypatch) -> Path:
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start.sys, "platform", "linux")
    config = studio["home"] / ".config" / "Code" / "User" / "chatLanguageModels.json"
    config.parent.mkdir(parents = True)
    return config


def test_vscode_adds_unsloth_and_keeps_the_users_groups(studio, monkeypatch):
    config = _vscode_config(studio, monkeypatch)
    original = (
        "[\n  // mine\n  {\n"
        '    "name": "Azure", "vendor": "azure",\n'
        '    "models": [{"id": "gpt-5.5", "url": "https://x.openai.azure.com"}],\n'
        "  },\n]\n"
    )
    config.write_text(original)

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    data = json.loads(config.read_text())
    assert data[0] == {
        "name": "Azure",
        "vendor": "azure",
        "models": [{"id": "gpt-5.5", "url": "https://x.openai.azure.com"}],
    }
    group = data[1]
    assert (group["name"], group["vendor"]) == ("Unsloth", "customendpoint")
    assert "apiKey" not in group
    (model,) = group["models"]
    assert model["id"] == MODEL["id"]
    assert model["url"] == f"{BASE}/v1/chat/completions"
    assert model["requestHeaders"] == {"Authorization": f"Bearer {APP_KEY}"}
    assert model["toolCalling"] is True
    assert model["contextWindow"] == MODEL["context_length"]
    assert model["maxInputTokens"] + model["maxOutputTokens"] == MODEL["context_length"]
    assert _private(config)
    assert config.with_name("chatLanguageModels.json.unsloth-backup").read_text() == original
    assert ("POST", f"{BASE}/api/auth/api-keys", {"name": "VS Code"}) in studio["calls"]
    assert APP_KEY not in result.output

    first = config.read_text()
    again = CliRunner().invoke(start.start_app, ["vscode"])
    assert again.exit_code == 0, again.output
    assert config.read_text() == first
    assert studio["minted"] == 1


def test_vscode_replaces_its_own_group_for_another_model(studio, monkeypatch):
    config = _vscode_config(studio, monkeypatch)
    assert CliRunner().invoke(start.start_app, ["vscode"]).exit_code == 0
    other = {"id": "unsloth/Qwen3.5-4B-GGUF", "context_length": 65536}
    monkeypatch.setitem(MODEL, "id", other["id"])
    monkeypatch.setitem(MODEL, "context_length", other["context_length"])

    assert CliRunner().invoke(start.start_app, ["vscode"]).exit_code == 0

    data = json.loads(config.read_text())
    assert [g["name"] for g in data] == ["Unsloth"]
    assert [m["id"] for m in data[0]["models"]] == [other["id"]]
    assert studio["minted"] == 1


def test_vscode_creates_a_missing_file(studio, monkeypatch):
    config = _vscode_config(studio, monkeypatch)

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    assert [g["name"] for g in json.loads(config.read_text())] == ["Unsloth"]
    assert not config.with_name("chatLanguageModels.json.unsloth-backup").exists()


def test_vscode_refuses_a_file_it_cannot_parse(studio, monkeypatch):
    config = _vscode_config(studio, monkeypatch)
    config.write_text('{"name": "not a list"}\n')

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 1
    assert "Couldn't parse" in result.output
    assert config.read_text() == '{"name": "not a list"}\n'
    assert studio["minted"] == 0


@pytest.mark.parametrize(
    "platform, parts",
    [
        ("linux", (".config", "Code", "User")),
        ("darwin", ("Library", "Application Support", "Code", "User")),
        ("win32", ("Roaming", "Code", "User")),
    ],
)
def test_vscode_settings_path_per_platform(monkeypatch, tmp_path, platform, parts):
    monkeypatch.setattr(start.sys, "platform", platform)
    monkeypatch.setattr(start.Path, "home", lambda: tmp_path)
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setenv("APPDATA", str(tmp_path / "Roaming"))

    assert start._vscode_models_path() == tmp_path.joinpath(*parts, "chatLanguageModels.json")


def test_vscode_uses_insiders_only_without_stable(monkeypatch, tmp_path):
    monkeypatch.setattr(start.sys, "platform", "linux")
    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
    (tmp_path / "Code - Insiders" / "User").mkdir(parents = True)
    insiders = tmp_path / "Code - Insiders" / "User" / "chatLanguageModels.json"
    assert start._vscode_models_path() == insiders

    # A leftover stable dir without a user dir does not count as stable VS Code.
    (tmp_path / "Code").mkdir()
    assert start._vscode_models_path() == insiders

    (tmp_path / "Code" / "User").mkdir()
    assert start._vscode_models_path() == tmp_path / "Code" / "User" / "chatLanguageModels.json"


@pytest.mark.parametrize(
    "status, tools, vision, thinking",
    [
        ({"model_identifier": MODEL["id"], "supports_tools": False}, False, False, False),
        (
            {
                "model_identifier": MODEL["id"],
                "supports_tools": True,
                "is_vision": True,
                "supports_reasoning": True,
            },
            True,
            True,
            True,
        ),
        (
            {
                "model_identifier": "unsloth/other-GGUF",
                "is_vision": True,
                "supports_reasoning": True,
            },
            True,
            False,
            False,
        ),
        ({}, True, False, False),
    ],
)
def test_vscode_reads_model_capabilities_from_the_served_model(
    studio, monkeypatch, status, tools, vision, thinking
):
    config = _vscode_config(studio, monkeypatch)
    real_http_json = start._http_json

    def http_json(method, url, token, *args, **kwargs):
        if "/api/inference/status?" in url:
            assert parse_qs(urlparse(url).query) == {"model": [MODEL["id"]]}
            return status
        return real_http_json(method, url, token, *args, **kwargs)

    monkeypatch.setattr(start, "_http_json", http_json)

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    (model,) = json.loads(config.read_text())[0]["models"]
    assert (model["toolCalling"], model["vision"], model["thinking"]) == (tools, vision, thinking)
    assert ("Ask mode" in result.output) is not tools


def test_vscode_keeps_what_the_user_put_in_an_unsloth_group(studio, monkeypatch):
    config = _vscode_config(studio, monkeypatch)
    mine = {"id": "my/finetune", "name": "Mine", "url": "http://127.0.0.1:8888/v1"}
    config.write_text(
        json.dumps(
            [
                {
                    "name": "Unsloth",
                    "vendor": "customendpoint",
                    "apiType": "responses",
                    "models": [mine],
                }
            ]
        )
    )
    assert CliRunner().invoke(start.start_app, ["vscode"]).exit_code == 0
    first = MODEL["id"]
    monkeypatch.setitem(MODEL, "id", "unsloth/Qwen3.5-4B-GGUF")

    assert CliRunner().invoke(start.start_app, ["vscode"]).exit_code == 0

    (group,) = json.loads(config.read_text())
    assert group["apiType"] == "responses"
    ids = [m["id"] for m in group["models"]]
    assert ids == ["my/finetune", "unsloth/Qwen3.5-4B-GGUF"] and first not in ids
    assert group["models"][0] == mine
    assert group["models"][1]["apiType"] == "chat-completions"


def test_vscode_mints_its_own_key_when_the_explicit_one_was_rejected(studio, monkeypatch):
    config = _vscode_config(studio, monkeypatch)
    # _connect swapped an exported key meant for another server for one this server accepts.
    monkeypatch.setattr(start, "_connect", lambda *args, **kwargs: (BASE, CLI_KEY, dict(MODEL)))
    monkeypatch.setenv("UNSLOTH_API_KEY", "sk-unsloth-elsewhere")

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    (model,) = json.loads(config.read_text())[0]["models"]
    assert model["requestHeaders"] == {"Authorization": f"Bearer {APP_KEY}"}


def test_vscode_under_wsl_writes_the_windows_vscode_config(monkeypatch, tmp_path):
    monkeypatch.setattr(start.sys, "platform", "linux")
    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "linux"))
    code = "/mnt/c/Users/me/AppData/Local/Programs/Microsoft VS Code/bin/code"
    monkeypatch.setattr(start, "_wsl_windows_executable", lambda cmd: code)
    monkeypatch.setattr(start, "_wsl_windows_user_profile", lambda exe, app: tmp_path / "win")
    windows = tmp_path / "win" / "AppData" / "Roaming" / "Code" / "User" / "chatLanguageModels.json"
    assert start._vscode_models_path() == windows

    (tmp_path / "linux" / "Code" / "User").mkdir(parents = True)
    linux = tmp_path / "linux" / "Code" / "User" / "chatLanguageModels.json"
    assert start._vscode_models_path() == linux


def test_vscode_over_ssh_prints_the_group_instead_of_writing_a_dead_file(studio, monkeypatch):
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start.sys, "platform", "linux")
    monkeypatch.setenv("SSH_CONNECTION", "10.0.0.2 51234 10.0.0.9 22")
    user_dir = studio["home"] / ".config" / "Code" / "User"
    assert start._vscode_over_ssh(user_dir / "chatLanguageModels.json")

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    assert not user_dir.exists()
    assert "nothing was written" in result.output and "ssh -L 8888:127.0.0.1:8888" in result.output
    group = json.loads(result.output[result.output.index("{") : result.output.rindex("}") + 1])
    assert group["models"][0]["requestHeaders"] == {"Authorization": f"Bearer {APP_KEY}"}

    assert CliRunner().invoke(start.start_app, ["vscode"]).exit_code == 0
    assert studio["minted"] == 1

    user_dir.mkdir(parents = True)
    assert CliRunner().invoke(start.start_app, ["vscode"]).exit_code == 0
    assert (user_dir / "chatLanguageModels.json").exists()


def test_vscode_reuses_the_remembered_key_for_a_remote_server(studio, monkeypatch):
    config = _vscode_config(studio, monkeypatch)
    remote = "http://gpu-box.lan:8888"
    # _connect recovered a key saved for this server on an earlier run; none was passed now.
    monkeypatch.setattr(start, "_connect", lambda *args, **kwargs: (remote, CLI_KEY, dict(MODEL)))

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    (model,) = json.loads(config.read_text())[0]["models"]
    assert model["url"] == f"{remote}/v1/chat/completions"
    assert model["requestHeaders"] == {"Authorization": f"Bearer {CLI_KEY}"}


@pytest.mark.parametrize("name", ["REMOTE_CONTAINERS", "CODESPACES"])
def test_vscode_in_a_dev_container_prints_the_group(studio, monkeypatch, name):
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start.sys, "platform", "linux")
    for var in ("SSH_CONNECTION", "SSH_CLIENT", "SSH_TTY", "REMOTE_CONTAINERS", "CODESPACES"):
        monkeypatch.delenv(var, raising = False)
    monkeypatch.setenv(name, "true")

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    assert "nothing was written" in result.output
    assert not (studio["home"] / ".config" / "Code").exists()


@pytest.mark.parametrize(
    "marker, engine", [("/.dockerenv", "docker"), ("/run/.containerenv", "podman")]
)
def test_vscode_in_a_plain_container_prints_the_group(studio, monkeypatch, marker, engine):
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start.sys, "platform", "linux")
    for var in ("SSH_CONNECTION", "SSH_CLIENT", "SSH_TTY", "REMOTE_CONTAINERS", "CODESPACES"):
        monkeypatch.delenv(var, raising = False)
    real_exists = os.path.exists
    monkeypatch.setattr(
        start.os.path,
        "exists",
        lambda p: p == marker
        or (p not in ("/.dockerenv", "/run/.containerenv") and real_exists(p)),
    )
    user_dir = studio["home"] / ".config" / "Code" / "User"

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    assert "nothing was written" in result.output
    assert f"{engine} run -p 8888:8888" in result.output and "ssh -L" not in result.output
    assert not user_dir.exists()

    # A dead file an earlier release wrote here is left alone and the group is still printed.
    user_dir.mkdir(parents = True)
    (user_dir / "chatLanguageModels.json").write_text("[]\n")
    (user_dir / "chatLanguageModels.json.unsloth-backup").write_text("[]\n")
    result = CliRunner().invoke(start.start_app, ["vscode"])
    assert result.exit_code == 0, result.output
    assert "nothing was written" in result.output
    assert (user_dir / "chatLanguageModels.json").read_text() == "[]\n"

    # VS Code itself running in the container keeps the write.
    (user_dir / "globalStorage").mkdir()
    assert CliRunner().invoke(start.start_app, ["vscode"]).exit_code == 0
    assert "Unsloth" in (user_dir / "chatLanguageModels.json").read_text()


def test_vscode_in_a_container_writes_a_user_dir_it_never_targeted(studio, monkeypatch):
    # A bind-mounted or fresh VS Code user dir holding only this file is VS Code's, not residue.
    config = _vscode_config(studio, monkeypatch)
    config.write_text("[]\n")
    monkeypatch.setattr(start, "_container_engine", lambda: "docker")
    for var in start._VSCODE_REMOTE_ENV:
        monkeypatch.delenv(var, raising = False)

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    assert "nothing was written" not in result.output
    assert [g["name"] for g in json.loads(config.read_text())] == ["Unsloth"]

    # Its own earlier write there does not make the dir look stale.
    monkeypatch.setitem(MODEL, "id", "unsloth/Qwen3.5-4B-GGUF")
    result = CliRunner().invoke(start.start_app, ["vscode"])
    assert result.exit_code == 0, result.output
    assert "nothing was written" not in result.output
    assert [m["id"] for m in json.loads(config.read_text())[0]["models"]] == [MODEL["id"]]


@pytest.mark.parametrize("name", ["REMOTE_CONTAINERS", "CODESPACES"])
def test_vscode_in_a_docker_backed_dev_container_keeps_the_forwarding_hint(
    studio, monkeypatch, name
):
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start.sys, "platform", "linux")
    for var in start._VSCODE_REMOTE_ENV:
        monkeypatch.delenv(var, raising = False)
    monkeypatch.setenv(name, "true")
    monkeypatch.setattr(start, "_container_engine", lambda: "docker")

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    assert "ssh -L 8888:127.0.0.1:8888" in result.output and "docker run" not in result.output


@pytest.mark.skipif(os.name == "nt", reason = "WSL paths are POSIX paths")
def test_vscode_under_wsl_says_to_use_a_local_window(studio, monkeypatch, tmp_path):
    monkeypatch.setattr(start.sys, "platform", "linux")
    monkeypatch.setenv("WSL_DISTRO_NAME", "Ubuntu")
    windows = Path("/mnt/c/Users/me/AppData/Roaming/Code/User/chatLanguageModels.json")
    monkeypatch.setattr(start, "_vscode_models_path", lambda: windows)
    monkeypatch.setattr(start, "_read_app_file", lambda path: None)
    monkeypatch.setattr(start, "_save_app_config", lambda *args: None)

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    assert "local VS Code window" in result.output


def test_vscode_over_ssh_skips_the_tunnel_hint_for_a_reachable_server(studio, monkeypatch):
    monkeypatch.delenv("XDG_CONFIG_HOME", raising = False)
    monkeypatch.setattr(start.sys, "platform", "linux")
    monkeypatch.setenv("SSH_CONNECTION", "10.0.0.2 51234 10.0.0.9 22")
    remote = "http://gpu-box.lan:8888"
    monkeypatch.setattr(start, "_connect", lambda *args, **kwargs: (remote, CLI_KEY, dict(MODEL)))

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    assert "ssh -L" not in result.output and f"can reach {remote}" in result.output


@pytest.mark.parametrize("window, warned", [(8192, True), (32768, False)])
def test_vscode_warns_when_the_context_is_too_small_for_agent_mode(
    studio, monkeypatch, window, warned
):
    _vscode_config(studio, monkeypatch)
    monkeypatch.setitem(MODEL, "context_length", window)

    result = CliRunner().invoke(start.start_app, ["vscode"])

    assert result.exit_code == 0, result.output
    assert ("--context-length 32768" in result.output) is warned