Files
headroom/tests/test_mcp_registry_opencode.py
9202948c1e fix(mcp): accept the JSONC opencode config that wrap and install already accept (#4297)
## 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>
2026-10-24 08:44:36 -07:00

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