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.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# 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