Files
headroom/tests/test_cli/test_wrap_openclaw.py
Tejas ChopraandClaude Opus 5.5 73f59a32cc refactor(cli): remove test-only and dead helpers from wrap, proxy and mcp (#4118)
## Description

Removes private CLI helpers that no product code calls any more. Each
one lost its last caller in an earlier rewrite, so only its own unit
tests still called it. The tests that pinned the dead code go with it.

Refs #4136
## Type of Change

- [ ] 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
- [x] Code refactoring (no functional changes)

## Changes Made

- `headroom/cli/wrap.py`: removed six dead helpers and constants.
- `_wrap_marker_proxy_is_dead`: the self-heal path now calls
`_wrap_proxy_alive` inline.
- `_agent_savings_config_mismatches` and `_AGENT_SAVINGS_TARGET_AGENTS`:
the live restart check only compares `savings_profile`.
- The `_normalize_openclaw_gateway_provider_ids` forwarder and its
import alias.
- A dead copy of `_opencode_home_dir`; the real one lives in
`providers/opencode/config.py`.
- The unused `_CONTEXT_1M_SUFFIX` and `_OPENCLAUDE_INSTRUCTIONS_FILE`
constants.
- `headroom/cli/proxy.py`: removed `_get_env_float_optional`, which had
no callers.
- `headroom/cli/mcp.py`: removed `get_headroom_command`,
`load_mcp_config`, `save_mcp_config`, `find_headroom_registration` and
the `CLAUDE_CONFIG_DIR` / `MCP_CONFIG_PATH` / `CLAUDE_JSON_PATH`
constants.
- `mcp install`, `mcp status` and `mcp uninstall` all go through
`headroom.mcp_registry` registrars now.
- `load_mcp_config` returned `{}` on corrupt JSON, and `save_mcp_config`
would then overwrite the file. That data-loss path goes away with them.
- Tests removed, because they only exercised the deleted code:
- `tests/test_cli/test_mcp_status.py`, all of which tested
`find_headroom_registration`;
- `TestMCPConfigFunctions` and its path fixtures in
`tests/test_cli/test_mcp.py`;
  - 3 `_wrap_marker_proxy_is_dead` tests;
  - 5 `_agent_savings_config_mismatches` tests;
  - 1 forwarder test.
- The remaining `mcp uninstall` / `mcp status` tests already patch the
registrars. They no longer take the path fixture.

Evidence: `rg -n -w '<name>' headroom crates plugins sdk examples
benchmarks scripts e2e docs wiki .github pyproject.toml tests <consumer
repos>` for each name finds only the definition and the removed tests.
Live behaviour stays covered:
- `test_wrap_dead_marker_selfheal.py`: `test_dead_port_*`,
`test_live_port_is_never_cleared` and the `_wrap_proxy_alive` tests;
- `tests/test_provider_openclaw_wrap.py`;
- `test_mcp.py::TestMCPStatusCommand` / `TestMCPUninstallCommand`.

## Testing

- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [x] Type checking passes (`mypy headroom`)
- [ ] New tests added for new functionality
- [ ] Manual testing performed

### Test Output

```text
$ pytest -q -p no:cacheprovider tests/test_cli/test_wrap_dead_marker_selfheal.py tests/test_agent_savings.py tests/test_cli/test_wrap_openclaw.py tests/test_cli/test_wrap_opencode.py tests/test_cli/test_mcp.py tests/test_cli/test_wrap_helpers.py tests/test_provider_openclaw_wrap.py tests/test_cli/test_main_help_version.py
253 passed in 33.08s
$ uvx ruff@0.16.8 check headroom/cli tests/test_cli tests/test_agent_savings.py
All checks passed!
$ mypy headroom/cli/wrap.py headroom/cli/mcp.py headroom/cli/proxy.py --ignore-missing-imports
Success: no issues found in 3 source files
```

## Real Behavior Proof

- Environment: macOS, Python 3.12, repo `.venv`, branch cut from
`origin/main` at a9815bbb.
- Exact command / steps: ran the pytest files above, which cover `wrap`,
`unwrap`, `mcp status` and `mcp uninstall` via CliRunner, plus `headroom
--help` / `--version`.
- Observed result: all 253 passed; ruff and mypy are clean.
- Smoke harness (real proxy started from this checkout against a local
fake upstream; temp HOME and workspace, offline):

```text
branch: cleanup/cli-integrations-dead-cli-helpers @ 5f450556
health: 200
POST /v1/messages        -> HTTP200 smoke-ok
POST /v1/chat/completions -> HTTP200 smoke-ok
stats: requests=2 failed=0 tokens_saved=13574 savings_percent=99.82
proxy.log WARNING/ERROR lines (<tmp>/ws/logs/proxy-63492.log):
   2 headroom.proxy - WARNING - event=proxy_offline_mode air-gap active — every connection Headroom initiates is refused (telemetry, update check, license reporter, model/tokenizer/binary/dataset downloads, remote Kompress, OTLP/Langfuse export, Copilot auth, subscription polling, OpenAI embedders, Headroom Cloud compression). Still allowed on purpose: forwarding your requests to the upstream you configured, operator-configured local endpoints, loopback health probes.
   4 headroom.transforms.kompress_compressor - WARNING - Kompress: artifact prefetch found no usable file for chopratejas/kompress-v2-base
   4 headroom.transforms.kompress_compressor - WARNING - Kompress: artifact prefetch refused for chopratejas/kompress-v2-base (HEADROOM_OFFLINE is set): HEADROOM_OFFLINE is set: refusing outbound network access for HuggingFace download of chopratejas/kompress-v2-base/onnx/kompress-int8-wo.onnx to huggingface.co. Unset HEADROOM_OFFLINE, or turn off the feature that needs this connection.
(smoke dir: <tmp>)
```
- Direct runtime command on this PR's own path (temp HOME,
HEADROOM_WORKSPACE_DIR and CODEX_HOME):

```text
$ HOME=<tmp>/home HEADROOM_WORKSPACE_DIR=<tmp>/ws CODEX_HOME=<tmp>/codex headroom mcp install --agent claude
exit=0
--- stdout
Installing Headroom MCP server...
  claude: registered (restart the agent if it was already running)

Next steps:
  1. Start the Headroom proxy (if not running): headroom proxy
  2. Start your agent (e.g.) ANTHROPIC_BASE_URL=http://127.0.0.1:8787 claude
  3. Restart any agent that was already running so it picks up the new MCP server.
--- stderr
$ HOME=<tmp>/home HEADROOM_WORKSPACE_DIR=<tmp>/ws CODEX_HOME=<tmp>/codex headroom mcp status
exit=0
--- stdout
Headroom MCP Status
========================================
MCP SDK:        ✓ Installed
Agent Config:
  Antigravity IDE: ✗ Not detected
  Claude Code: ✓ Configured
$ HOME=<tmp>/home HEADROOM_WORKSPACE_DIR=<tmp>/ws CODEX_HOME=<tmp>/codex headroom mcp uninstall
exit=0
--- stdout
✓ Claude Code: removed headroom MCP server(s)
--- stderr
```
- Not tested: a live `headroom wrap` session against a real agent
binary. Only unreferenced private code was deleted, so no runtime path
changes.

## Runtime Rollout Safety

- Rollout-managed feature(s): None.
- Minimum rollout channel: N/A, no rollout-managed behaviour.
- Stable/default behavior changed: No. Only code with no callers is
removed.
- 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
- [ ] 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
- [ ] 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)

## Screenshots (if applicable)

N/A

## Additional Notes

- Part of maintainer-requested cleanup #4136 (dead code, duplication,
debuggability), split into small PRs for review.
- No new tests or docs are needed, because this is a pure removal and
none of the removed names were documented.
- `_DEFAULT_1M_MODEL` stays, because
`tests/test_cli/test_wrap_helpers.py` pins it.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

<!-- devin-review-badge-begin -->

---

<a href="https://app.devin.ai/review/headroomlabs-ai/headroom/pull/4118"
target="_blank"><picture><source media="(prefers-color-scheme: dark)"
srcset="https://static.devin.ai/assets/gh-devin-review-dark.svg?v=4"><img
src="https://static.devin.ai/assets/gh-devin-review-light.svg?v=4"
alt="Devin Review"></picture></a>
<!-- devin-review-badge-end -->

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 09:01:00 -07:00

861 lines
31 KiB
Python

"""Tests for `headroom wrap openclaw` command."""
from __future__ import annotations
import json
from pathlib import Path
from unittest.mock import MagicMock, patch
import pytest
from click.testing import CliRunner
from headroom.cli import wrap as wrap_cli
from headroom.cli.main import main
@pytest.fixture
def runner() -> CliRunner:
return CliRunner()
@pytest.fixture
def plugin_dir(tmp_path: Path) -> Path:
"""Create a minimal OpenClaw plugin directory fixture."""
plugin = tmp_path / "plugins" / "openclaw"
plugin.mkdir(parents=True)
(plugin / "package.json").write_text('{"name":"headroom-openclaw"}\n')
(plugin / "openclaw.plugin.json").write_text('{"id":"headroom"}\n')
hook_shim = plugin / "hook-shim"
hook_shim.mkdir()
(hook_shim / "index.js").write_text("export default {};\n")
return plugin
def _make_successful_run(calls: list[dict]) -> object:
def run(cmd, **kwargs): # noqa: ANN001
calls.append({"cmd": list(cmd), **kwargs})
return MagicMock(returncode=0, stdout="", stderr="")
return run
@pytest.mark.parametrize("source", ["npm", "link", "copy"])
def test_wrap_openclaw_retries_deprecated_install_flag(
runner: CliRunner, plugin_dir: Path, source: str
) -> None:
"""New OpenClaw requires source confirmation instead of its deprecated flag."""
calls: list[dict] = []
def run(cmd, **kwargs): # noqa: ANN001
calls.append({"cmd": list(cmd), **kwargs})
if cmd[:3] == ["openclaw", "plugins", "install"]:
if "--force" not in cmd:
return MagicMock(
returncode=1,
stdout="",
stderr=(
"Install cancelled; rerun with --force after reviewing the source.\n"
"--dangerously-force-unsafe-install is deprecated and no longer "
"affects plugin installs"
),
)
if "--accept-capabilities" not in cmd:
return MagicMock(
returncode=1,
stdout="",
stderr='Plugin "headroom" requires capability consent. Use --accept-capabilities.',
)
return MagicMock(returncode=0, stdout="", stderr="")
args = ["wrap", "openclaw", "--no-restart"]
if source != "npm":
args.extend(["--plugin-path", str(plugin_dir), "--skip-build"])
if source == "copy":
args.append("--copy")
with (
patch("headroom.cli.wrap.shutil.which", side_effect=lambda name: name),
patch("headroom.cli.wrap.subprocess.run", side_effect=run),
):
result = runner.invoke(main, args)
assert result.exit_code == 0, result.output
installs = [c for c in calls if c["cmd"][:3] == ["openclaw", "plugins", "install"]]
assert len(installs) == 2
assert installs[1]["cmd"] == (
installs[0]["cmd"][:3] + ["--force", "--accept-capabilities"] + installs[0]["cmd"][4:]
)
assert installs[1].get("cwd") == installs[0].get("cwd")
@pytest.mark.parametrize("after_migration", [False, True])
def test_wrap_openclaw_does_not_override_install_policy(
runner: CliRunner, after_migration: bool
) -> None:
"""A policy block is terminal even if OpenClaw also prints a deprecation notice."""
calls: list[dict] = []
def run(cmd, **kwargs): # noqa: ANN001
calls.append({"cmd": list(cmd), **kwargs})
if cmd[:3] == ["openclaw", "plugins", "install"]:
if after_migration and "--force" not in cmd:
return MagicMock(
returncode=1,
stdout="Install cancelled; rerun with --force after reviewing the source.",
stderr="--dangerously-force-unsafe-install is deprecated",
)
return MagicMock(
returncode=1,
stdout="",
stderr=(
"Blocked by security.installPolicy\n"
"--dangerously-force-unsafe-install is deprecated"
),
)
return MagicMock(returncode=0, stdout="", stderr="")
with (
patch("headroom.cli.wrap.shutil.which", side_effect=lambda name: name),
patch("headroom.cli.wrap.subprocess.run", side_effect=run),
):
result = runner.invoke(main, ["wrap", "openclaw"])
assert result.exit_code != 0
assert "Blocked by security.installPolicy" in result.output
installs = [c for c in calls if c["cmd"][:3] == ["openclaw", "plugins", "install"]]
assert len(installs) == (2 if after_migration else 1)
assert not any(c["cmd"][:3] == ["openclaw", "config", "set"] for c in calls)
def test_wrap_openclaw_default_installs_from_npm_and_restarts(runner: CliRunner) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
mapping = {
"openclaw": "openclaw",
"npm": "npm",
}
return mapping.get(name)
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=_make_successful_run(calls)):
result = runner.invoke(main, ["wrap", "openclaw"])
assert result.exit_code == 0, result.output
cmds = [c["cmd"] for c in calls]
assert [
"openclaw",
"plugins",
"install",
"--dangerously-force-unsafe-install",
"headroom-openclaw",
] in cmds
assert ["openclaw", "config", "validate"] in cmds
assert ["openclaw", "gateway", "restart"] in cmds
assert ["openclaw", "plugins", "inspect", "headroom"] in cmds
config_set_index = next(
i
for i, cmd in enumerate(cmds)
if cmd[:4] == ["openclaw", "config", "set", "plugins.entries.headroom"]
)
install_index = next(
i
for i, cmd in enumerate(cmds)
if cmd[:4] == ["openclaw", "plugins", "install", "--dangerously-force-unsafe-install"]
)
# Config must be written only after a successful install so a failed
# install leaves no stale plugins.entries.headroom entry (issue #1969).
assert install_index < config_set_index
# Verify plugin install in npm mode does not set cwd
install_call = next(
c
for c in calls
if c["cmd"][:4] == ["openclaw", "plugins", "install", "--dangerously-force-unsafe-install"]
)
assert install_call["cwd"] is None
# No local build in npm mode
assert ["npm", "install"] not in cmds
assert ["npm", "run", "build"] not in cmds
# Verify config payload includes enabled + expected defaults
set_entry = next(
c
for c in calls
if c["cmd"][:4] == ["openclaw", "config", "set", "plugins.entries.headroom"]
)
payload = json.loads(set_entry["cmd"][4])
assert payload["enabled"] is True
assert payload["config"]["proxyPort"] == 8787
assert payload["config"]["autoStart"] is True
assert payload["config"]["startupTimeoutMs"] == 20000
assert payload["config"]["gatewayProviderIds"] == ["openai-codex"]
assert payload["config"]["pythonPath"] == wrap_cli.sys.executable
def test_wrap_openclaw_skip_build_and_no_restart(runner: CliRunner, plugin_dir: Path) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
mapping = {
"openclaw": "openclaw",
"npm": "npm",
}
return mapping.get(name)
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=_make_successful_run(calls)):
result = runner.invoke(
main,
[
"wrap",
"openclaw",
"--plugin-path",
str(plugin_dir),
"--skip-build",
"--no-restart",
],
)
assert result.exit_code == 0, result.output
cmds = [c["cmd"] for c in calls]
assert ["npm", "install"] not in cmds
assert ["npm", "run", "build"] not in cmds
assert ["openclaw", "gateway", "restart"] not in cmds
def test_wrap_openclaw_local_source_mode_builds_and_links(
runner: CliRunner, plugin_dir: Path
) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
mapping = {
"openclaw": "openclaw",
"npm": "npm",
}
return mapping.get(name)
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=_make_successful_run(calls)):
result = runner.invoke(
main,
["wrap", "openclaw", "--plugin-path", str(plugin_dir)],
)
assert result.exit_code == 0, result.output
cmds = [c["cmd"] for c in calls]
assert ["npm", "install"] in cmds
assert ["npm", "run", "build"] in cmds
assert [
"openclaw",
"plugins",
"install",
"--dangerously-force-unsafe-install",
"--link",
".",
] in cmds
def test_wrap_openclaw_fails_when_openclaw_missing(runner: CliRunner, plugin_dir: Path) -> None:
def which(name: str) -> str | None:
return None if name == "openclaw" else "npm"
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
result = runner.invoke(main, ["wrap", "openclaw", "--plugin-path", str(plugin_dir)])
assert result.exit_code != 0
assert "'openclaw' not found in PATH" in result.output
def test_wrap_openclaw_fails_when_plugin_path_invalid(runner: CliRunner, tmp_path: Path) -> None:
invalid = tmp_path / "missing-plugin"
with patch("headroom.cli.wrap.shutil.which", return_value="openclaw"):
result = runner.invoke(main, ["wrap", "openclaw", "--plugin-path", str(invalid)])
assert result.exit_code != 0
assert "Plugin path not found" in result.output
def test_wrap_openclaw_uses_extension_fallback_on_linked_install_bug(
runner: CliRunner, plugin_dir: Path
) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
mapping = {
"openclaw": "openclaw",
"npm": "npm",
}
return mapping.get(name)
def run(cmd, **kwargs): # noqa: ANN001
calls.append({"cmd": list(cmd), **kwargs})
if cmd[:3] == ["openclaw", "plugins", "install"]:
return MagicMock(
returncode=1,
stdout="Also not a valid hook pack",
stderr='Plugin installation blocked despite "--dangerously-force-unsafe-install"',
)
return MagicMock(returncode=0, stdout="", stderr="")
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=run):
with patch(
"headroom.cli.wrap._copy_openclaw_plugin_into_extensions",
return_value=Path("C:/Users/test/.openclaw/extensions/headroom"),
) as copy_fallback:
result = runner.invoke(main, ["wrap", "openclaw", "--plugin-path", str(plugin_dir)])
assert result.exit_code == 0, result.output
copy_fallback.assert_called_once()
def test_wrap_openclaw_continues_when_plugin_already_exists(
runner: CliRunner,
) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
mapping = {
"openclaw": "openclaw",
"npm": "npm",
}
return mapping.get(name)
def run(cmd, **kwargs): # noqa: ANN001
calls.append({"cmd": list(cmd), **kwargs})
if cmd[:3] == ["openclaw", "plugins", "install"]:
return MagicMock(
returncode=1,
stdout="plugin already exists: C:\\Users\\test\\.openclaw\\extensions\\headroom",
stderr="",
)
return MagicMock(returncode=0, stdout="", stderr="")
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=run):
result = runner.invoke(main, ["wrap", "openclaw", "--no-restart"])
assert result.exit_code == 0, result.output
cmds = [c["cmd"] for c in calls]
assert ["openclaw", "config", "validate"] in cmds
assert ["openclaw", "plugins", "inspect", "headroom"] in cmds
def test_wrap_openclaw_verbose_prints_install_restart_and_inspect_output(
runner: CliRunner,
) -> None:
def which(name: str) -> str | None:
mapping = {
"openclaw": "openclaw",
"npm": "npm",
}
return mapping.get(name)
def run(cmd, **kwargs): # noqa: ANN001
if cmd[:3] == ["openclaw", "plugins", "install"]:
return MagicMock(returncode=0, stdout="install-ok", stderr="")
if cmd[:3] == ["openclaw", "gateway", "restart"]:
return MagicMock(returncode=0, stdout="restart-ok", stderr="")
if cmd[:3] == ["openclaw", "plugins", "inspect"]:
return MagicMock(returncode=0, stdout="inspect-ok", stderr="")
return MagicMock(returncode=0, stdout="", stderr="")
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=run):
result = runner.invoke(main, ["wrap", "openclaw", "--verbose"])
assert result.exit_code == 0, result.output
assert "install-ok" in result.output
assert "restart-ok" in result.output
assert "inspect-ok" in result.output
def test_wrap_openclaw_starts_gateway_when_restart_fails(runner: CliRunner) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
return {"openclaw": "openclaw", "npm": "npm"}.get(name)
def run(cmd, **kwargs): # noqa: ANN001
calls.append({"cmd": list(cmd), **kwargs})
if cmd[:3] == ["openclaw", "gateway", "restart"]:
return MagicMock(returncode=1, stdout="", stderr="gateway not running")
if cmd[:3] == ["openclaw", "gateway", "start"]:
return MagicMock(returncode=0, stdout="started-ok", stderr="")
return MagicMock(returncode=0, stdout="", stderr="")
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=run):
result = runner.invoke(main, ["wrap", "openclaw", "--verbose"])
assert result.exit_code == 0, result.output
cmds = [c["cmd"] for c in calls]
assert ["openclaw", "gateway", "restart"] in cmds
assert ["openclaw", "gateway", "start"] in cmds
assert "Gateway started." in result.output
assert "started-ok" in result.output
def test_wrap_openclaw_accepts_repeatable_gateway_provider_ids(runner: CliRunner) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
return {"openclaw": "openclaw", "npm": "npm"}.get(name)
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=_make_successful_run(calls)):
result = runner.invoke(
main,
[
"wrap",
"openclaw",
"--gateway-provider-id",
"openai-codex",
"--gateway-provider-id",
"anthropic",
"--no-restart",
],
)
assert result.exit_code == 0, result.output
set_entry = next(
c
for c in calls
if c["cmd"][:4] == ["openclaw", "config", "set", "plugins.entries.headroom"]
)
payload = json.loads(set_entry["cmd"][4])
assert payload["config"]["gatewayProviderIds"] == ["openai-codex", "anthropic"]
def test_read_openclaw_config_value_handles_missing_and_raw_strings() -> None:
missing = MagicMock(returncode=1, stdout="", stderr="missing")
raw_string = MagicMock(returncode=0, stdout="plain-text-value\n", stderr="")
with patch("headroom.cli.wrap.subprocess.run", side_effect=[missing, raw_string]):
assert wrap_cli._read_openclaw_config_value("openclaw", "plugins.entries.headroom") is None
assert (
wrap_cli._read_openclaw_config_value(
"openclaw", "plugins.entries.headroom.config.pythonPath"
)
== "plain-text-value"
)
def test_build_openclaw_plugin_entry_sets_and_clears_python_path() -> None:
with_python = wrap_cli._build_openclaw_plugin_entry(
existing_entry={"config": {"customFlag": True}},
proxy_port=8787,
startup_timeout_ms=20000,
python_path="C:\\Python312\\python.exe",
no_auto_start=False,
gateway_provider_ids=("openai-codex",),
enabled=True,
)
assert with_python["config"]["pythonPath"] == "C:\\Python312\\python.exe"
without_python = wrap_cli._build_openclaw_plugin_entry(
existing_entry={"config": {"pythonPath": "C:\\Old\\python.exe", "customFlag": True}},
proxy_port=8787,
startup_timeout_ms=20000,
python_path=None,
no_auto_start=False,
gateway_provider_ids=("openai-codex",),
enabled=True,
)
assert "pythonPath" not in without_python["config"]
assert without_python["config"]["customFlag"] is True
def test_build_openclaw_unwrap_entry_preserves_top_level_metadata() -> None:
entry = wrap_cli._build_openclaw_unwrap_entry(
{
"source": "headroom-ai/openclaw",
"enabled": True,
"config": {
"pythonPath": "C:\\Python312\\python.exe",
"proxyPort": 8787,
"customFlag": True,
},
}
)
assert entry["source"] == "headroom-ai/openclaw"
assert entry["enabled"] is False
assert entry["config"] == {"customFlag": True}
def test_unwrap_openclaw_stops_proxy_by_default(runner: CliRunner) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
return "openclaw" if name == "openclaw" else None
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=_make_successful_run(calls)):
with patch(
"headroom.cli.wrap._stop_local_proxy_for_unwrap",
return_value="stopped",
) as stop_proxy:
result = runner.invoke(
main,
["unwrap", "openclaw", "--proxy-port", "9999", "--no-restart"],
)
assert result.exit_code == 0, result.output
stop_proxy.assert_called_once_with(9999)
assert "Stopped local Headroom proxy on port 9999" in result.output
def test_wrap_openclaw_no_auto_start_does_not_default_python_path(
runner: CliRunner, plugin_dir: Path
) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
return {"openclaw": "openclaw", "npm": "npm"}.get(name)
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=_make_successful_run(calls)):
result = runner.invoke(
main,
[
"wrap",
"openclaw",
"--plugin-path",
str(plugin_dir),
"--skip-build",
"--no-auto-start",
"--no-restart",
],
)
assert result.exit_code == 0, result.output
set_entry = next(
c
for c in calls
if c["cmd"][:4] == ["openclaw", "config", "set", "plugins.entries.headroom"]
)
payload = json.loads(set_entry["cmd"][4])
assert payload["config"]["autoStart"] is False
assert "pythonPath" not in payload["config"]
def test_wrap_openclaw_fails_for_npm_mode_hook_pack_bug_without_local_fallback(
runner: CliRunner,
) -> None:
def which(name: str) -> str | None:
mapping = {
"openclaw": "openclaw",
"npm": "npm",
}
return mapping.get(name)
def run(cmd, **kwargs): # noqa: ANN001
if cmd[:3] == ["openclaw", "plugins", "install"]:
return MagicMock(
returncode=1,
stdout="Also not a valid hook pack",
stderr='Blocked despite "--dangerously-force-unsafe-install"',
)
return MagicMock(returncode=0, stdout="", stderr="")
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=run):
result = runner.invoke(main, ["wrap", "openclaw"])
assert result.exit_code != 0
assert "openclaw plugins install failed" in result.output
def test_wrap_openclaw_default_plugin_spec_matches_published_package() -> None:
"""The --plugin-spec default must be the real published npm package name."""
from headroom.providers.openclaw import OPENCLAW_NPM_PACKAGE
assert OPENCLAW_NPM_PACKAGE == "headroom-openclaw"
command = wrap_cli.wrap.commands["openclaw"]
plugin_spec_option = next(p for p in command.params if p.name == "plugin_spec")
assert plugin_spec_option.default == "headroom-openclaw"
def test_wrap_openclaw_failed_install_writes_no_config_entry(runner: CliRunner) -> None:
"""A hard `plugins install` failure must not leave a stale config entry."""
calls: list[dict] = []
def which(name: str) -> str | None:
return {"openclaw": "openclaw", "npm": "npm"}.get(name)
def run(cmd, **kwargs): # noqa: ANN001
calls.append({"cmd": list(cmd), **kwargs})
if cmd[:3] == ["openclaw", "plugins", "install"]:
return MagicMock(returncode=1, stdout="", stderr="npm 404 not found")
return MagicMock(returncode=0, stdout="", stderr="")
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=run):
result = runner.invoke(main, ["wrap", "openclaw"])
assert result.exit_code != 0
assert "openclaw plugins install failed" in result.output
cmds = [c["cmd"] for c in calls]
# No plugin config entry should be written when the install hard-fails.
assert not any(
cmd[:4] == ["openclaw", "config", "set", "plugins.entries.headroom"] for cmd in cmds
)
def test_wrap_openclaw_copy_mode_uses_path_install(runner: CliRunner, plugin_dir: Path) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
mapping = {
"openclaw": "openclaw",
"npm": "npm",
}
return mapping.get(name)
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=_make_successful_run(calls)):
result = runner.invoke(
main,
[
"wrap",
"openclaw",
"--plugin-path",
str(plugin_dir),
"--copy",
"--skip-build",
"--no-restart",
],
)
assert result.exit_code == 0, result.output
cmds = [c["cmd"] for c in calls]
assert [
"openclaw",
"plugins",
"install",
"--dangerously-force-unsafe-install",
str(plugin_dir),
] in cmds
def test_wrap_openclaw_fails_when_npm_missing_for_local_build(
runner: CliRunner, plugin_dir: Path
) -> None:
def which(name: str) -> str | None:
mapping = {
"openclaw": "openclaw",
"npm": None,
}
return mapping.get(name)
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
result = runner.invoke(main, ["wrap", "openclaw", "--plugin-path", str(plugin_dir)])
assert result.exit_code != 0
assert "'npm' not found in PATH" in result.output
def test_wrap_openclaw_fails_when_local_path_missing_manifest_files(
runner: CliRunner, tmp_path: Path
) -> None:
plugin = tmp_path / "plugins" / "openclaw"
plugin.mkdir(parents=True)
with patch("headroom.cli.wrap.shutil.which", return_value="openclaw"):
result = runner.invoke(main, ["wrap", "openclaw", "--plugin-path", str(plugin)])
assert result.exit_code != 0
assert "missing package.json" in result.output
(plugin / "package.json").write_text("{}\n")
with patch("headroom.cli.wrap.shutil.which", return_value="openclaw"):
result = runner.invoke(main, ["wrap", "openclaw", "--plugin-path", str(plugin)])
assert result.exit_code != 0
assert "missing openclaw.plugin.json" in result.output
def test_run_checked_raises_click_exception_on_command_errors() -> None:
with patch("headroom.cli.wrap.subprocess.run", side_effect=FileNotFoundError()):
with pytest.raises(Exception, match="command not found"):
wrap_cli._run_checked(["missing"], action="demo")
cpe_stderr = wrap_cli.subprocess.CalledProcessError(
returncode=2,
cmd=["x"],
stderr="bad-stderr",
)
with patch("headroom.cli.wrap.subprocess.run", side_effect=cpe_stderr):
with pytest.raises(Exception, match="bad-stderr"):
wrap_cli._run_checked(["x"], action="demo")
cpe_stdout = wrap_cli.subprocess.CalledProcessError(
returncode=3,
cmd=["x"],
output="bad-stdout",
stderr="",
)
with patch("headroom.cli.wrap.subprocess.run", side_effect=cpe_stdout):
with pytest.raises(Exception, match="bad-stdout"):
wrap_cli._run_checked(["x"], action="demo")
def test_resolve_openclaw_extensions_dir_empty_output_raises() -> None:
with patch(
"headroom.cli.wrap._run_checked",
return_value=MagicMock(stdout=" \n", stderr="", returncode=0),
):
with pytest.raises(Exception, match="Unable to resolve OpenClaw config path"):
wrap_cli._resolve_openclaw_extensions_dir("openclaw")
def test_copy_openclaw_plugin_into_extensions_handles_missing_and_existing_dist(
tmp_path: Path,
) -> None:
plugin = tmp_path / "plugin"
plugin.mkdir()
with pytest.raises(Exception, match="Plugin dist folder missing"):
wrap_cli._copy_openclaw_plugin_into_extensions(plugin_dir=plugin, openclaw_bin="openclaw")
dist = plugin / "dist"
dist.mkdir()
(dist / "index.js").write_text("x\n")
(plugin / "package.json").write_text("{}\n")
(plugin / "openclaw.plugin.json").write_text("{}\n")
with patch("headroom.cli.wrap._resolve_openclaw_extensions_dir", return_value=tmp_path):
with pytest.raises(Exception, match="Plugin hook-shim folder missing"):
wrap_cli._copy_openclaw_plugin_into_extensions(
plugin_dir=plugin, openclaw_bin="openclaw"
)
hook_shim = plugin / "hook-shim"
hook_shim.mkdir()
(hook_shim / "index.js").write_text("shim\n")
ext_root = tmp_path / ".openclaw" / "extensions"
target_headroom = ext_root / "headroom"
target_dist = target_headroom / "dist"
target_hook_shim = target_headroom / "hook-shim"
target_dist.mkdir(parents=True)
(target_dist / "old.js").write_text("old\n")
target_hook_shim.mkdir(parents=True)
(target_hook_shim / "old.js").write_text("old-shim\n")
with patch("headroom.cli.wrap._resolve_openclaw_extensions_dir", return_value=ext_root):
out = wrap_cli._copy_openclaw_plugin_into_extensions(
plugin_dir=plugin, openclaw_bin="openclaw"
)
assert out == target_headroom
assert (target_dist / "index.js").exists()
assert not (target_dist / "old.js").exists()
assert (target_hook_shim / "index.js").exists()
assert not (target_hook_shim / "old.js").exists()
def test_unwrap_openclaw_disables_plugin_and_restores_legacy_slot(runner: CliRunner) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
return {"openclaw": "openclaw"}.get(name)
def run(cmd, **kwargs): # noqa: ANN001
calls.append({"cmd": list(cmd), **kwargs})
if cmd[:4] == ["openclaw", "config", "get", "plugins.entries.headroom"]:
return MagicMock(
returncode=0,
stdout=json.dumps(
{
"enabled": True,
"config": {
"proxyPort": 8787,
"gatewayProviderIds": ["openai-codex"],
"customFlag": True,
},
}
),
stderr="",
)
return MagicMock(returncode=0, stdout="", stderr="")
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=run):
result = runner.invoke(main, ["unwrap", "openclaw"])
assert result.exit_code == 0, result.output
set_entry = next(
c
for c in calls
if c["cmd"][:4] == ["openclaw", "config", "set", "plugins.entries.headroom"]
)
payload = json.loads(set_entry["cmd"][4])
assert payload == {"enabled": False, "config": {"customFlag": True}}
set_slot = next(
c
for c in calls
if c["cmd"][:4] == ["openclaw", "config", "set", "plugins.slots.contextEngine"]
)
assert json.loads(set_slot["cmd"][4]) == "legacy"
assert ["openclaw", "gateway", "restart"] in [c["cmd"] for c in calls]
def test_unwrap_openclaw_no_restart_skips_gateway_restart(runner: CliRunner) -> None:
calls: list[dict] = []
def which(name: str) -> str | None:
return {"openclaw": "openclaw"}.get(name)
def run(cmd, **kwargs): # noqa: ANN001
calls.append({"cmd": list(cmd), **kwargs})
return MagicMock(returncode=0, stdout="", stderr="")
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=run):
result = runner.invoke(main, ["unwrap", "openclaw", "--no-restart"])
assert result.exit_code == 0, result.output
assert ["openclaw", "gateway", "restart"] not in [c["cmd"] for c in calls]
def test_unwrap_openclaw_fails_when_openclaw_missing(runner: CliRunner) -> None:
with patch("headroom.cli.wrap.shutil.which", return_value=None):
result = runner.invoke(main, ["unwrap", "openclaw"])
assert result.exit_code != 0
assert "'openclaw' not found in PATH" in result.output
def test_unwrap_openclaw_verbose_prints_gateway_and_inspect_output(runner: CliRunner) -> None:
def which(name: str) -> str | None:
return {"openclaw": "openclaw"}.get(name)
def run(cmd, **kwargs): # noqa: ANN001
if cmd[:4] == ["openclaw", "config", "get", "plugins.entries.headroom"]:
return MagicMock(
returncode=0,
stdout=json.dumps({"enabled": True, "config": {"proxyPort": 8787}}),
stderr="",
)
if cmd[:3] == ["openclaw", "gateway", "restart"]:
return MagicMock(returncode=0, stdout="gateway-restarted", stderr="")
if cmd[:3] == ["openclaw", "plugins", "inspect"]:
return MagicMock(returncode=0, stdout="inspect-disabled", stderr="")
return MagicMock(returncode=0, stdout="", stderr="")
with patch("headroom.cli.wrap.shutil.which", side_effect=which):
with patch("headroom.cli.wrap.subprocess.run", side_effect=run):
result = runner.invoke(main, ["unwrap", "openclaw", "--verbose"])
assert result.exit_code == 0, result.output
assert "gateway-restarted" in result.output
assert "inspect-disabled" in result.output