mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 13:29:19 +08:00
## Description `headroom mcp install` registers the Headroom MCP server in OpenCode's `opencode.json` / `opencode.jsonc`. Its registrar (`headroom/mcp_registry/opencode.py`) has its own JSONC fallback, which strips only two comment shapes: ```python cleaned = re.sub(r"^\s*//[^\n]*\n", "", text, flags=re.MULTILINE) # whole-line // comments return re.sub(r",\s*//[^\n]*", ",", cleaned) # comments right after a comma ``` Any other JSONC that OpenCode itself accepts fails to parse, and since #1661 the registrar (correctly) refuses to overwrite a file it can't parse. So with - a trailing `// comment` on the **last** key (no comma before it), - a `/* block */` comment, - a trailing comma, `headroom mcp install` stops with `opencode.jsonc exists but is not valid JSON (not valid JSON/JSONC); refusing to overwrite. Fix or remove the file`, and the MCP server isn't installed. That's a normal hand-edited `opencode.jsonc`. Meanwhile `headroom/providers/opencode/config.py` (used by `headroom wrap opencode` and `install`) already parses these files with a string-aware stripper, so one command accepts the user's config and the other rejects it. Closes: N/A (no matching issue found) ## Type of Change - [x] Bug fix (non-breaking change that fixes an issue) - [ ] New feature (non-breaking change that adds functionality) - [ ] Breaking change (fix or feature that would cause existing functionality to change) - [ ] Documentation update - [ ] Performance improvement - [ ] Code refactoring (no functional changes) ## Changes Made - `headroom/mcp_registry/opencode.py`: `_parse_json_loose()` keeps its contract: standard JSON first, `None` for anything that still isn't a JSON object, so `_read_json_for_write` still refuses to clobber a malformed file. The fallback now runs the provider module's `_strip_jsonc_comments` + `_strip_jsonc_trailing_commas`, which handle `//` and `/* */` comments and trailing commas without touching string contents such as `https://` URLs. The import is inside the function because `headroom.providers.opencode` imports `headroom.mcp_registry` at package load, and a module-level import is circular. The now-unused `_strip_json_line_comments` and `import re` are removed. Because that stripper treats an unterminated `/*` as running to end of file, the registrar first checks for one and returns `None`, so such a file is still refused instead of being rewritten without its tail (added after review). - `tests/test_mcp_registry_opencode.py`: `test_register_server_accepts_other_jsonc_syntax`, parametrized over a trailing line comment, a block comment and a trailing comma, checks `register_server()` returns `REGISTERED`, merges the `mcp` block, and keeps `theme`/`model`. `test_register_server_preserves_malformed_config` gains an unterminated-`/*` case; it and the existing cases (`not json`, `{`, `{"theme": }`, `[]`) fail closed and leave the file byte-identical. ## Testing - [x] Unit tests pass (`pytest`): `tests/test_mcp_registry_opencode.py`, `tests/test_mcp_registry/`, `tests/test_providers_opencode_config.py`, `tests/test_cli/test_wrap_opencode.py`, not the full suite - [x] Linting passes (`ruff check .`): on the changed files - [ ] Type checking passes (`mypy headroom`): not run - [x] New tests added for new functionality - [x] Manual testing performed ### Test Output New test on `main` (fix reverted, test kept): ```text $ python -m pytest tests/test_mcp_registry_opencode.py -q E AssertionError: .../opencode.jsonc exists but is not valid JSON (not valid JSON/JSONC); refusing to overwrite. Fix or remove the file, then re-run. E assert <RegisterStat...LED: 'failed'> == <RegisterStat... 'registered'> FAILED tests/test_mcp_registry_opencode.py::test_register_server_accepts_other_jsonc_syntax[trailing-line-comment] FAILED tests/test_mcp_registry_opencode.py::test_register_server_accepts_other_jsonc_syntax[block-comment] FAILED tests/test_mcp_registry_opencode.py::test_register_server_accepts_other_jsonc_syntax[trailing-comma] ========================= 3 failed, 42 passed in 1.77s ========================= ``` With the fix: ```text $ python -m pytest tests/test_mcp_registry_opencode.py tests/test_mcp_registry tests/test_providers_opencode_config.py tests/test_cli/test_wrap_opencode.py -q ============================= 399 passed in 5.90s ============================== $ ruff check headroom/mcp_registry/opencode.py tests/test_mcp_registry_opencode.py All checks passed! $ ruff format --check headroom/mcp_registry/opencode.py tests/test_mcp_registry_opencode.py 2 files already formatted ``` ## Real Behavior Proof - Environment: macOS 27.0.1 (arm64), Python 3.12.11, source tree on this branch (native `headroom._core` from the 0.41.0 wheel), `HOME` pointed at a fresh temp dir, `HEADROOM_OFFLINE=1` - Exact command / steps: wrote `~/.config/opencode/opencode.jsonc` as ```jsonc { "$schema": "https://opencode.ai/config.json", "theme": "dracula", // keep my theme "model": "anthropic/claude-sonnet-4-5" // default model } ``` then ran `python -m headroom.cli mcp install --agent opencode` and printed the file afterwards, on `main` and on this branch. - Observed result: on `main` the install fails and the file is unchanged. On this branch the `mcp.headroom` entry is merged in, and `$schema`, `theme` and `model` are kept. As before, a rewrite drops the comments; the docstring already says so. ```text == main Installing Headroom MCP server... opencode: install failed (failed): .../.config/opencode/opencode.jsonc exists but is not valid JSON (not valid JSON/JSONC); refusing to overwrite. Fix or remove the file, then re-run. == this branch Next steps: 1. Start the Headroom proxy (if not running): headroom proxy -- opencode.jsonc after: { "$schema": "https://opencode.ai/config.json", "theme": "dracula", "model": "anthropic/claude-sonnet-4-5", "mcp": { "headroom": { "type": "local", "command": ["<python>", "-m", "headroom.cli", "mcp", "serve"], "enabled": true } } } ``` (`command` shortened here; it is the absolute interpreter path of the run.) - Not tested: a real OpenCode binary reading the rewritten file; Windows paths. Preserving comments on rewrite is out of scope; that limitation is unchanged. ## Runtime Rollout Safety - Rollout-managed feature(s): none - Minimum rollout channel: N/A - Stable/default behavior changed: `headroom mcp install` / `uninstall` for OpenCode now accept the JSONC that `headroom wrap opencode` already accepts. Malformed files are still refused, and the existing fail-closed tests pass unchanged. - Kill switch / disable path: N/A - Unsafe override required: no - Qualification impact: none - Rollback path: revert this commit ## Review Readiness - [x] I have performed a self-review - [x] This PR is ready for human review ## Checklist - [x] My code follows the project's style guidelines - [x] I have performed a self-review of my code - [x] I have commented my code, particularly in hard-to-understand areas - [ ] I have made corresponding changes to the documentation - [x] My changes generate no new warnings - [x] I have added tests that prove my fix is effective or that my feature works - [x] New and existing unit tests pass locally with my changes - [x] I did **not** edit `CHANGELOG.md` — it is generated by release-please from my Conventional Commit PR title (a CI guard enforces this) ## Additional Notes This removes the second, weaker JSONC parser in favour of the one the OpenCode provider already ships, so the MCP and wrap/install paths can't disagree about what a valid `opencode.jsonc` is. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
628 lines
22 KiB
Python
628 lines
22 KiB
Python
"""Tests for :class:`headroom.mcp_registry.opencode.OpencodeRegistrar`."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import pytest
|
|
|
|
from headroom.mcp_registry.base import RegisterStatus, ServerSpec
|
|
from headroom.mcp_registry.opencode import (
|
|
OpencodeRegistrar,
|
|
_diff_specs,
|
|
_entry_to_spec,
|
|
_spec_to_entry,
|
|
_specs_equivalent,
|
|
)
|
|
|
|
|
|
def _write_json(path: Path, data: dict[str, Any]) -> None:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(json.dumps(data, indent=2) + "\n")
|
|
|
|
|
|
def _registrar(tmp_path: Path) -> OpencodeRegistrar:
|
|
return OpencodeRegistrar(config_path=tmp_path / "opencode.json")
|
|
|
|
|
|
def test_default_config_path_prefers_existing_jsonc(
|
|
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
"""Regression test for #1869: MCP registration must land in opencode.jsonc
|
|
|
|
when that's the file OpenCode actually reads, matching the provider-block
|
|
resolution in headroom.providers.opencode.config.
|
|
"""
|
|
monkeypatch.delenv("OPENCODE_CONFIG", raising=False)
|
|
monkeypatch.setenv("OPENCODE_HOME", str(tmp_path))
|
|
(tmp_path / "opencode.jsonc").write_text("{}", encoding="utf-8")
|
|
|
|
registrar = OpencodeRegistrar()
|
|
|
|
assert registrar._config_path == tmp_path / "opencode.jsonc"
|
|
|
|
|
|
def test_register_server_merges_into_commented_jsonc(
|
|
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
"""Regression test for #1869 review feedback: real-world opencode.jsonc files
|
|
|
|
commonly contain ``//`` comments. register_server() must parse past them
|
|
and merge the mcp block in without dropping the user's existing settings,
|
|
instead of failing with "not valid JSON".
|
|
"""
|
|
monkeypatch.delenv("OPENCODE_CONFIG", raising=False)
|
|
monkeypatch.setenv("OPENCODE_HOME", str(tmp_path))
|
|
config_path = tmp_path / "opencode.jsonc"
|
|
config_path.write_text(
|
|
"""{
|
|
// user's theme preference
|
|
"theme": "dracula",
|
|
"model": "anthropic/claude-sonnet-4",
|
|
"provider": {
|
|
"anthropic": {"options": {"baseURL": "https://api.example.com"}}
|
|
}
|
|
}
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
registrar = OpencodeRegistrar()
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp",), env={})
|
|
result = registrar.register_server(spec)
|
|
|
|
assert result.status == RegisterStatus.REGISTERED
|
|
data = json.loads(config_path.read_text(encoding="utf-8"))
|
|
assert data["theme"] == "dracula"
|
|
assert data["model"] == "anthropic/claude-sonnet-4"
|
|
assert data["provider"]["anthropic"]["options"]["baseURL"] == "https://api.example.com"
|
|
assert data["mcp"]["headroom"]["command"] == ["headroom", "mcp"]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"contents",
|
|
[
|
|
# trailing comment on the last key (no comma before the //)
|
|
'{\n "theme": "dracula",\n "model": "anthropic/claude-sonnet-4" // default model\n}\n',
|
|
# block comment
|
|
'{\n /* user settings */\n "theme": "dracula",\n "model": "anthropic/claude-sonnet-4"\n}\n',
|
|
# trailing comma, which JSONC allows
|
|
'{\n "theme": "dracula",\n "model": "anthropic/claude-sonnet-4",\n}\n',
|
|
],
|
|
ids=["trailing-line-comment", "block-comment", "trailing-comma"],
|
|
)
|
|
def test_register_server_accepts_other_jsonc_syntax(tmp_path: Path, contents: str) -> None:
|
|
"""Every JSONC form OpenCode itself reads must merge, not fail as "not valid JSON"."""
|
|
config_path = tmp_path / "opencode.jsonc"
|
|
config_path.write_text(contents, encoding="utf-8")
|
|
registrar = OpencodeRegistrar(config_path=config_path)
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp",), env={})
|
|
result = registrar.register_server(spec)
|
|
|
|
assert result.status == RegisterStatus.REGISTERED, result.detail
|
|
data = json.loads(config_path.read_text(encoding="utf-8"))
|
|
assert data["theme"] == "dracula"
|
|
assert data["model"] == "anthropic/claude-sonnet-4"
|
|
assert data["mcp"]["headroom"]["command"] == ["headroom", "mcp"]
|
|
assert registrar.get_server("headroom") is not None
|
|
|
|
|
|
def test_detect_when_binary_present(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
|
"""Detection succeeds when the opencode binary is in PATH."""
|
|
monkeypatch.setenv("PATH", str(tmp_path))
|
|
(tmp_path / "opencode").write_text("#!/bin/sh\necho ok")
|
|
(tmp_path / "opencode").chmod(0o755)
|
|
registrar = _registrar(tmp_path)
|
|
assert registrar.detect() is True
|
|
|
|
|
|
def test_detect_when_config_dir_present(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
|
"""Detection succeeds when the config directory exists."""
|
|
monkeypatch.setenv("PATH", "/nonexistent")
|
|
config_dir = tmp_path / "opencode"
|
|
config_dir.mkdir()
|
|
registrar = OpencodeRegistrar(config_path=config_dir / "opencode.json")
|
|
assert registrar.detect() is True
|
|
|
|
|
|
def test_detect_when_nothing_present(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
|
"""Detection fails when neither binary nor config dir exists."""
|
|
monkeypatch.setenv("PATH", "/nonexistent")
|
|
registrar = OpencodeRegistrar(config_path=tmp_path / "nonexistent" / "opencode.json")
|
|
assert registrar.detect() is False
|
|
|
|
|
|
def test_get_server_returns_none_when_absent(tmp_path: Path) -> None:
|
|
"""get_server returns None when the server is not configured."""
|
|
registrar = _registrar(tmp_path)
|
|
assert registrar.get_server("headroom") is None
|
|
|
|
|
|
def test_get_server_returns_spec_when_present(tmp_path: Path) -> None:
|
|
"""get_server parses the existing MCP entry correctly."""
|
|
config = {
|
|
"mcp": {
|
|
"headroom": {
|
|
"type": "local",
|
|
"command": ["headroom", "mcp", "serve"],
|
|
"enabled": True,
|
|
}
|
|
}
|
|
}
|
|
_write_json(tmp_path / "opencode.json", config)
|
|
registrar = _registrar(tmp_path)
|
|
spec = registrar.get_server("headroom")
|
|
assert spec is not None
|
|
assert spec.name == "headroom"
|
|
assert spec.command == "headroom"
|
|
assert spec.args == ("mcp", "serve")
|
|
|
|
|
|
def test_register_server_creates_config_when_missing(tmp_path: Path) -> None:
|
|
"""register_server creates the config file when it doesn't exist."""
|
|
registrar = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
result = registrar.register_server(spec)
|
|
assert result.status == RegisterStatus.REGISTERED
|
|
config_path = tmp_path / "opencode.json"
|
|
assert config_path.exists()
|
|
data = json.loads(config_path.read_text())
|
|
assert data["mcp"]["headroom"] == {
|
|
"type": "local",
|
|
"command": ["headroom", "mcp", "serve"],
|
|
"enabled": True,
|
|
}
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"contents",
|
|
[
|
|
"not json",
|
|
"{",
|
|
'{"theme": }',
|
|
"[]",
|
|
# An unterminated block comment must not be read as "comment to EOF".
|
|
'{"theme": "dark"}\n/* unfinished notes\n"keep": "me"\n',
|
|
],
|
|
)
|
|
def test_register_server_preserves_malformed_config(tmp_path: Path, contents: str) -> None:
|
|
"""Registering must NOT clobber an existing but unparseable opencode.json.
|
|
|
|
The file holds theme/model/provider and other MCP servers; before the fix a
|
|
malformed file was read as {} and rewritten with only {"mcp": ...}."""
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
config_path = tmp_path / "opencode.json"
|
|
config_path.write_text(contents, encoding="utf-8")
|
|
registrar = _registrar(tmp_path)
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
result = registrar.register_server(spec)
|
|
|
|
assert result.status == RegisterStatus.FAILED
|
|
assert "not valid JSON" in result.detail
|
|
assert config_path.read_text(encoding="utf-8") == contents
|
|
|
|
|
|
def test_non_utf8_config_fails_cleanly_and_is_left_untouched(tmp_path: Path) -> None:
|
|
"""An opencode.json saved in a non-UTF-8 locale encoding (GBK here) must not
|
|
crash with a raw UnicodeDecodeError; it is treated as malformed and never
|
|
rewritten."""
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
config_path = tmp_path / "opencode.json"
|
|
original = '{"theme": "主题"}'.encode("gbk")
|
|
config_path.write_bytes(original)
|
|
registrar = _registrar(tmp_path)
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
result = registrar.register_server(spec)
|
|
|
|
assert result.status == RegisterStatus.FAILED
|
|
assert "not valid JSON" in result.detail
|
|
assert registrar.unregister_server("headroom") is False
|
|
assert config_path.read_bytes() == original
|
|
|
|
|
|
def test_register_server_preserves_other_keys(tmp_path: Path) -> None:
|
|
"""The happy path merges: theme/model and an existing MCP server survive."""
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
config_path = tmp_path / "opencode.json"
|
|
_write_json(
|
|
config_path,
|
|
{"theme": "dark", "model": "anthropic/claude", "mcp": {"other": {"type": "local"}}},
|
|
)
|
|
registrar = _registrar(tmp_path)
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
result = registrar.register_server(spec)
|
|
|
|
assert result.status == RegisterStatus.REGISTERED
|
|
data = json.loads(config_path.read_text(encoding="utf-8"))
|
|
assert data["theme"] == "dark"
|
|
assert data["model"] == "anthropic/claude"
|
|
assert data["mcp"]["other"] == {"type": "local"}
|
|
assert "headroom" in data["mcp"]
|
|
|
|
|
|
def test_register_server_idempotent(tmp_path: Path) -> None:
|
|
"""register_server is a no-op when the same spec is already present."""
|
|
registrar = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
registrar.register_server(spec)
|
|
result = registrar.register_server(spec)
|
|
assert result.status == RegisterStatus.ALREADY
|
|
|
|
|
|
def test_unregister_server_removes_entry(tmp_path: Path) -> None:
|
|
"""unregister_server removes the server entry."""
|
|
registrar = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
registrar.register_server(spec)
|
|
assert registrar.unregister_server("headroom") is True
|
|
assert registrar.get_server("headroom") is None
|
|
|
|
|
|
def test_unregister_server_returns_false_when_absent(tmp_path: Path) -> None:
|
|
"""unregister_server returns False when the server was not registered."""
|
|
registrar = _registrar(tmp_path)
|
|
assert registrar.unregister_server("headroom") is False
|
|
|
|
|
|
def test_specs_equivalent_true() -> None:
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
a = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
b = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
assert _specs_equivalent(a, b) is True
|
|
|
|
|
|
def test_specs_equivalent_false() -> None:
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
a = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
b = ServerSpec(name="headroom", command="other", args=("mcp", "serve"))
|
|
assert _specs_equivalent(a, b) is False
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Edge cases
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_register_server_force_overwrites_mismatch(tmp_path: Path) -> None:
|
|
"""register_server with force=True overwrites a mismatched existing server."""
|
|
registrar = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec_a = ServerSpec(name="headroom", command="old", args=("serve",))
|
|
spec_b = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
|
|
registrar.register_server(spec_a)
|
|
assert registrar.register_server(spec_b).status == RegisterStatus.MISMATCH
|
|
assert registrar.register_server(spec_b, force=True).status == RegisterStatus.REGISTERED
|
|
updated = registrar.get_server("headroom")
|
|
assert updated is not None
|
|
assert updated.command == "headroom"
|
|
|
|
|
|
def test_unregister_removes_mcp_key_when_empty(tmp_path: Path) -> None:
|
|
"""unregister_server removes the top-level 'mcp' key when it becomes empty."""
|
|
registrar = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
registrar.register_server(spec)
|
|
assert registrar.unregister_server("headroom") is True
|
|
assert registrar.get_server("headroom") is None
|
|
# mcp key should be removed entirely
|
|
import json
|
|
|
|
data = json.loads((tmp_path / "opencode.json").read_text())
|
|
assert "mcp" not in data
|
|
|
|
|
|
def test_register_server_leaves_other_mcp_servers(tmp_path: Path) -> None:
|
|
"""register_server preserves other MCP servers in the config."""
|
|
registrar = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
# Pre-populate with a user-managed MCP server
|
|
_write_json(
|
|
tmp_path / "opencode.json",
|
|
{
|
|
"mcp": {
|
|
"existing-server": {
|
|
"type": "remote",
|
|
"url": "https://example.com",
|
|
"enabled": True,
|
|
},
|
|
}
|
|
},
|
|
)
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
registrar.register_server(spec)
|
|
|
|
data = json.loads((tmp_path / "opencode.json").read_text())
|
|
assert "headroom" in data["mcp"]
|
|
assert "existing-server" in data["mcp"]
|
|
|
|
|
|
def test_unregister_preserves_other_mcp_servers(tmp_path: Path) -> None:
|
|
"""unregister_server leaves other MCP servers intact."""
|
|
registrar = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
_write_json(
|
|
tmp_path / "opencode.json",
|
|
{
|
|
"mcp": {
|
|
"existing-server": {"type": "remote", "url": "https://example.com"},
|
|
}
|
|
},
|
|
)
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
registrar.register_server(spec)
|
|
registrar.unregister_server("headroom")
|
|
|
|
data = json.loads((tmp_path / "opencode.json").read_text())
|
|
assert "headroom" not in data["mcp"]
|
|
assert "existing-server" in data["mcp"]
|
|
|
|
|
|
def test_get_server_returns_none_for_non_dict_mcp(tmp_path: Path) -> None:
|
|
"""get_server returns None when 'mcp' is not a dict."""
|
|
registrar = _registrar(tmp_path)
|
|
_write_json(tmp_path / "opencode.json", {"mcp": "not-a-dict"})
|
|
assert registrar.get_server("headroom") is None
|
|
|
|
|
|
def test_get_server_handles_missing_config_file(tmp_path: Path) -> None:
|
|
"""get_server returns None when the config file doesn't exist."""
|
|
registrar = _registrar(tmp_path)
|
|
assert registrar.get_server("headroom") is None
|
|
|
|
|
|
def test_register_server_handles_config_with_no_mcp_key(tmp_path: Path) -> None:
|
|
"""register_server adds 'mcp' key when it doesn't exist."""
|
|
registrar = _registrar(tmp_path)
|
|
_write_json(tmp_path / "opencode.json", {"model": "gpt-4o"})
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
registrar.register_server(spec)
|
|
|
|
data = json.loads((tmp_path / "opencode.json").read_text())
|
|
assert data["model"] == "gpt-4o" # preserved
|
|
assert "headroom" in data["mcp"]
|
|
|
|
|
|
def test_register_server_with_env_vars(tmp_path: Path) -> None:
|
|
"""register_server handles ServerSpec with environment variables."""
|
|
registrar = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec = ServerSpec(
|
|
name="headroom",
|
|
command="headroom",
|
|
args=("mcp", "serve"),
|
|
env={"HEADROOM_PROXY_URL": "http://127.0.0.1:9090"},
|
|
)
|
|
registrar.register_server(spec)
|
|
|
|
data = json.loads((tmp_path / "opencode.json").read_text())
|
|
assert data["mcp"]["headroom"]["environment"] == {"HEADROOM_PROXY_URL": "http://127.0.0.1:9090"}
|
|
|
|
|
|
def test_register_then_re_register_with_different_env_returns_mismatch(tmp_path: Path) -> None:
|
|
"""Re-registering with different env returns MISMATCH without force."""
|
|
registrar = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec_a = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
spec_b = ServerSpec(
|
|
name="headroom",
|
|
command="headroom",
|
|
args=("mcp", "serve"),
|
|
env={"NEW_VAR": "value"},
|
|
)
|
|
registrar.register_server(spec_a)
|
|
result = registrar.register_server(spec_b)
|
|
assert result.status == RegisterStatus.MISMATCH
|
|
|
|
|
|
def test_register_server_on_malformed_config_file(tmp_path: Path) -> None:
|
|
"""register_server refuses to overwrite a malformed config, preserving it.
|
|
|
|
Updated for the clobber guard: opencode.json holds theme/model/provider and
|
|
other MCP servers, so a present-but-unparseable file is left untouched and
|
|
registration fails rather than silently wiping the user's config.
|
|
"""
|
|
registrar = _registrar(tmp_path)
|
|
(tmp_path / "opencode.json").write_text("not valid json at all")
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
result = registrar.register_server(spec)
|
|
assert result.status == RegisterStatus.FAILED
|
|
|
|
# The malformed file is left byte-for-byte untouched rather than clobbered.
|
|
assert (tmp_path / "opencode.json").read_text() == "not valid json at all"
|
|
|
|
|
|
def test_entry_to_spec_command_as_string() -> None:
|
|
"""_entry_to_spec handles a string command (not a list)."""
|
|
entry = {
|
|
"type": "remote",
|
|
"command": "some-command",
|
|
"enabled": True,
|
|
}
|
|
spec = _entry_to_spec("test", entry)
|
|
assert spec.name == "test"
|
|
assert spec.command == "some-command"
|
|
assert spec.args == ()
|
|
|
|
|
|
def test_entry_to_spec_reads_opencode_environment() -> None:
|
|
"""_entry_to_spec reads OpenCode's environment map."""
|
|
entry = {
|
|
"type": "local",
|
|
"command": ["headroom", "mcp", "serve"],
|
|
"enabled": True,
|
|
"environment": {"HEADROOM_PROXY_URL": "http://127.0.0.1:9090"},
|
|
}
|
|
spec = _entry_to_spec("headroom", entry)
|
|
assert spec.env == {"HEADROOM_PROXY_URL": "http://127.0.0.1:9090"}
|
|
|
|
|
|
def test_entry_to_spec_reads_legacy_env() -> None:
|
|
"""_entry_to_spec keeps compatibility with previously written env maps."""
|
|
entry = {
|
|
"type": "local",
|
|
"command": ["headroom", "mcp", "serve"],
|
|
"enabled": True,
|
|
"env": {"HEADROOM_PROXY_URL": "http://127.0.0.1:9090"},
|
|
}
|
|
spec = _entry_to_spec("headroom", entry)
|
|
assert spec.env == {"HEADROOM_PROXY_URL": "http://127.0.0.1:9090"}
|
|
|
|
|
|
def test_entry_to_spec_no_command() -> None:
|
|
"""_entry_to_spec handles an entry without a 'command' key."""
|
|
entry: dict[str, Any] = {
|
|
"type": "remote",
|
|
"url": "http://example.com",
|
|
"enabled": True,
|
|
}
|
|
spec = _entry_to_spec("test", entry)
|
|
assert spec.name == "test"
|
|
assert spec.command == ""
|
|
|
|
|
|
def test_spec_to_entry_roundtrip() -> None:
|
|
"""_spec_to_entry and _entry_to_spec are inverses for local commands."""
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
original = ServerSpec(
|
|
name="test",
|
|
command="python",
|
|
args=("-m", "server"),
|
|
env={"KEY": "VAL"},
|
|
)
|
|
entry = _spec_to_entry(original)
|
|
assert entry["type"] == "local"
|
|
assert entry["command"] == ["python", "-m", "server"]
|
|
assert entry["environment"] == {"KEY": "VAL"}
|
|
|
|
restored = _entry_to_spec("test", entry)
|
|
assert restored.name == original.name
|
|
assert restored.command == original.command
|
|
assert restored.args == original.args
|
|
assert restored.env == original.env
|
|
|
|
|
|
def test_spec_to_entry_no_env_has_no_environment_key() -> None:
|
|
"""_spec_to_entry omits 'environment' key when spec has no env vars."""
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec = ServerSpec(name="headroom", command="headroom", args=("mcp", "serve"))
|
|
entry = _spec_to_entry(spec)
|
|
assert entry["type"] == "local"
|
|
assert "url" not in entry
|
|
assert "environment" not in entry
|
|
assert "env" not in entry
|
|
|
|
|
|
def test_entry_to_spec_reads_environment_field() -> None:
|
|
"""_entry_to_spec reads the 'environment' field (not legacy 'env')."""
|
|
entry = {
|
|
"type": "local",
|
|
"command": ["headroom", "mcp", "serve"],
|
|
"environment": {"HEADROOM_PROXY_URL": "http://127.0.0.1:8787"},
|
|
"enabled": True,
|
|
}
|
|
spec = _entry_to_spec("headroom", entry)
|
|
assert spec.env == {"HEADROOM_PROXY_URL": "http://127.0.0.1:8787"}
|
|
|
|
|
|
def test_entry_to_spec_falls_back_to_legacy_env_field() -> None:
|
|
"""_entry_to_spec falls back to 'env' when 'environment' is absent."""
|
|
entry = {
|
|
"type": "local",
|
|
"command": ["headroom", "mcp", "serve"],
|
|
"env": {"LEGACY_KEY": "value"},
|
|
"enabled": True,
|
|
}
|
|
spec = _entry_to_spec("headroom", entry)
|
|
assert spec.env == {"LEGACY_KEY": "value"}
|
|
|
|
|
|
def test_diff_specs_all_fields() -> None:
|
|
"""_diff_specs reports differences in all fields."""
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
a = ServerSpec(name="s", command="cmd_a", args=("a1",), env={"K": "A"})
|
|
b = ServerSpec(name="s", command="cmd_b", args=("b1",), env={"K": "B"})
|
|
diff = _diff_specs(a, b)
|
|
assert "cmd_a" in diff
|
|
assert "cmd_b" in diff
|
|
assert "a1" in diff
|
|
assert "b1" in diff
|
|
|
|
|
|
def test_diff_specs_no_difference_returns_generic_message() -> None:
|
|
"""_diff_specs returns a generic message when no identifiable field differs."""
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
a = ServerSpec(name="s", command="x")
|
|
b = ServerSpec(name="s", command="x")
|
|
diff = _diff_specs(a, b)
|
|
assert "unidentified field" in diff
|
|
|
|
|
|
def test_register_server_returns_already_status(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
r = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec = ServerSpec(name="already", command="cmd")
|
|
r.register_server(spec)
|
|
result = r.register_server(spec)
|
|
assert result.status == RegisterStatus.ALREADY
|
|
|
|
|
|
def test_unregister_server_handles_oserror(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
|
r = _registrar(tmp_path)
|
|
from headroom.mcp_registry.base import ServerSpec
|
|
|
|
spec = ServerSpec(name="bad-unregister", command="cmd")
|
|
r.register_server(spec)
|
|
|
|
def _fail_write(*args: Any, **kwargs: Any) -> None:
|
|
msg = "permission denied"
|
|
raise OSError(msg)
|
|
|
|
monkeypatch.setattr("headroom.mcp_registry.opencode._write_json", _fail_write)
|
|
ok = r.unregister_server("bad-unregister")
|
|
assert ok is False
|
|
|
|
|
|
def test_get_all_registrars_includes_opencode() -> None:
|
|
from headroom.mcp_registry.install import get_all_registrars
|
|
|
|
registrars = get_all_registrars()
|
|
names = [r.name for r in registrars]
|
|
assert "opencode" in names
|