mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 13:29:19 +08:00
## 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` ata9815bbb. - 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 @5f450556health: 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>
861 lines
31 KiB
Python
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
|