mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 15:10:00 +08:00
## Description `headroom install status` could report `Status: stopped` next to `Healthy: yes`, while `headroom doctor` reported the same proxy as running (#3072, bug 2). The commands used independent process views: `install status` trusted PID/container bookkeeping for `Status`, while both commands used the live HTTP health endpoints to establish health. This change treats a successful `/readyz` probe as authoritative evidence that the deployment is running. If the proxy is not ready, `runtime_status` still distinguishes a running-but-unhealthy process from a stopped process. The PR also adds a focused macOS pytest lane for CLI and install code, closing the Darwin test-coverage gap described in #3065 without duplicating the full four-shard Linux suite. Bug 1 from #3072 (`HEADROOM_PORT` being ignored by `install apply` and `deploy`) was already fixed on `main` by #3085 and is not reimplemented here. Closes #3072 Closes #3065 ## 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 - Updated `headroom/cli/install.py` so `install_status` performs one readiness probe and reports `Status: running` whenever `/readyz` is healthy. - Kept `runtime_status` as the fallback when the proxy is not ready, preserving the distinction between running-but-unhealthy and stopped. - Added regression coverage for the formerly contradictory `Status: stopped` plus `Healthy: yes` output. - Added regression coverage for the not-ready case where process status must still come from `runtime_status`. - Added a `test-macos` CI job that runs the CLI/install pytest subset on `macos-latest`. ## Testing - [x] Unit tests pass (`pytest`) - [x] Linting passes (`ruff check .`) - [x] Type checking passes (`mypy headroom`) - [x] New tests added for new functionality - [ ] Manual testing performed ### Test Output ```text $ uv run --frozen --extra dev pytest tests/test_cli/test_install_cli.py -q ============================= test session starts ============================== platform darwin -- Python 3.11.15, pytest-9.0.3, pluggy-1.6.0 collected 42 items tests/test_cli/test_install_cli.py ..................................... [ 88%] ..... [100%] ============================== 42 passed in 1.79s ============================== $ uv run --frozen ruff check headroom/cli/install.py tests/test_cli/test_install_cli.py All checks passed! $ uv run --frozen ruff format --check headroom/cli/install.py tests/test_cli/test_install_cli.py 2 files already formatted $ uv run --frozen mypy headroom/cli/install.py --ignore-missing-imports Success: no issues found in 1 source file ``` ## Real Behavior Proof - Environment: macOS (Apple Silicon), CPython 3.11.15 via `uv`, pytest 9.0.3. - Exact command / steps: ran `uv run --frozen --extra dev pytest tests/test_cli/test_install_cli.py -q`. The new regression test invokes `headroom install status` through Click's `CliRunner` with `/readyz` returning healthy while PID/runtime bookkeeping returns `stopped`. - Observed result: the command exits successfully and prints `Status: running` with `Healthy: yes`; `Status: stopped` is absent. A second test verifies that when readiness is false, a live runtime still prints `Status: running` with `Healthy: no`. - Not tested: an end-to-end persistent-service installation with a real OS supervisor or Docker daemon. The new macOS CI job itself will be exercised by GitHub Actions rather than locally. ## Runtime Rollout Safety - Rollout-managed feature(s): none; this changes diagnostic display logic and CI coverage only. - Minimum rollout channel: stable/default patch release. - Stable/default behavior changed: yes; `install status` now reports a ready deployment as running even if PID/container bookkeeping says stopped. Unready deployments retain the existing runtime-status behavior. - Kill switch / disable path: no runtime flag; revert this PR if the readiness precedence causes an unforeseen regression. - Unsafe override required: none. - Qualification impact: `tests/test_cli/test_install_cli.py` and the new `test-macos` CI job must remain green. - Rollback path: revert commit `f3ae269b`; no persisted state, schema, manifest, or configuration migration is involved. ## 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) ## Screenshots (if applicable) Not applicable; this is terminal status output and CI configuration. ## Additional Notes - Documentation was not changed because no command, option, configuration contract, or documented workflow changed; this corrects contradictory diagnostic output. - #2787 was also reviewed as an urgent author-reported issue, but it already has active implementation PR #2992. This PR deliberately avoids duplicating or conflicting with that work. <!-- devin-review-badge-begin --> --- <a href="https://app.devin.ai/review/headroomlabs-ai/headroom/pull/3141" 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 --> ### Maintainer current-main requalification Exact head `f550bf1d05873b20b773d935aa7cb93025b63262`, upstream main `2d3ee51846435ef5b320eea4806af14e602b0d8c`. Re-reviewed latest integration head3c11d4a96and current discussion; clean integration with upstream/main2d3ee51846. Install status still treats a ready reachable proxy as running, preserving runtime-status fallback when unhealthy. All 160 install-status/release/version/MCP tests pass; no PR-specific production-code blocker found in scope. Downloaded the latest failing native macOS job 126368233730 from run 41765101507: four persistent-wrap recovery tests still failed because _Manifest/TaskManifest lacked runtime_kind. Repaired test doubles with the Python runtime declaration and explicitly mocked the readiness boundary those tests control through health probes; real ownership classification remains exercised. Parametrized the four affected recovery cases across Darwin/Linux/Windows by replacing only runtime module's sys reference, without global platform emulation. All 83 persistent-wrap tests pass, preserving matching deployment recovery, bound-socket recovery, healthy reuse, and task warning coverage. No production recovery logic changed. Changed-file Ruff check/format and whitespace pass. These local platform variants are not native macOS validation; exact-head hosted macOS lane must qualify before approval. Existing native extension supports Python startup, not a fresh native build. Maintainers handle CI; nothing merged. Exact-head hosted checks are being handled by maintainers. No new finding in the reviewed scope; formal approval awaits exact-head hosted qualification; nothing merged. --------- Co-authored-by: vishal veerareddy <vishalveera.reddy@servicenow.com> Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com> Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
2172 lines
80 KiB
Python
2172 lines
80 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from pathlib import Path
|
|
from threading import Thread
|
|
from types import SimpleNamespace
|
|
|
|
import click
|
|
import pytest
|
|
from click.testing import CliRunner
|
|
|
|
from headroom.cli import install as inst
|
|
from headroom.cli.main import main
|
|
from headroom.install.models import DeploymentManifest, ManagedMutation
|
|
from headroom.install.planner import build_tool_envs
|
|
from headroom.install.state import load_manifest as load_state_manifest
|
|
from headroom.install.state import save_manifest_strict
|
|
|
|
|
|
def test_require_manifest_resolves_single_profile_when_default_missing(monkeypatch):
|
|
"""On an init'd machine (one profile, e.g. init-user), a bare lifecycle
|
|
command whose --profile defaults to 'default' resolves to the single
|
|
installed deployment instead of dead-ending (#2811)."""
|
|
only = SimpleNamespace(profile="init-user")
|
|
monkeypatch.delenv("HEADROOM_DEPLOYMENT_PROFILE", raising=False)
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: None)
|
|
monkeypatch.setattr(inst, "list_manifests", lambda: [only])
|
|
|
|
assert inst._require_manifest("default") is only
|
|
|
|
|
|
def test_require_manifest_honors_env_profile(monkeypatch):
|
|
"""An explicit HEADROOM_DEPLOYMENT_PROFILE (exported by the runtime) selects
|
|
the target even when the requested profile is not installed."""
|
|
target = SimpleNamespace(profile="init-user")
|
|
monkeypatch.setenv("HEADROOM_DEPLOYMENT_PROFILE", "init-user")
|
|
monkeypatch.setattr(
|
|
inst, "load_manifest", lambda profile: target if profile == "init-user" else None
|
|
)
|
|
monkeypatch.setattr(inst, "list_manifests", lambda: [target])
|
|
|
|
assert inst._require_manifest("default") is target
|
|
|
|
|
|
def test_require_manifest_lists_installed_profiles_when_ambiguous(monkeypatch):
|
|
"""With several installed profiles and no signal, the error names them and
|
|
points at --profile instead of dead-ending on 'default'."""
|
|
monkeypatch.delenv("HEADROOM_DEPLOYMENT_PROFILE", raising=False)
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: None)
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"list_manifests",
|
|
lambda: [SimpleNamespace(profile="init-user"), SimpleNamespace(profile="ci")],
|
|
)
|
|
|
|
with pytest.raises(click.ClickException) as exc:
|
|
inst._require_manifest("default")
|
|
msg = str(exc.value)
|
|
assert "ci" in msg and "init-user" in msg and "--profile" in msg
|
|
|
|
|
|
def _status_manifest(profile: str) -> SimpleNamespace:
|
|
return SimpleNamespace(
|
|
profile=profile,
|
|
preset="persistent-task",
|
|
runtime_kind="python",
|
|
supervisor_kind="none",
|
|
scope="user",
|
|
port=8787,
|
|
health_url="http://127.0.0.1:8787/readyz",
|
|
backend="anthropic",
|
|
)
|
|
|
|
|
|
def test_install_status_explicit_missing_profile_is_not_redirected_to_env(monkeypatch):
|
|
"""An explicit --profile must be honored or rejected verbatim, never
|
|
redirected to HEADROOM_DEPLOYMENT_PROFILE or a lone installed deployment: a
|
|
typo must fail even when the env profile exists (#2832 review). Only a
|
|
CliRunner invocation exercises the default-vs-explicit distinction."""
|
|
init_user = _status_manifest("init-user")
|
|
monkeypatch.setenv("HEADROOM_DEPLOYMENT_PROFILE", "init-user")
|
|
monkeypatch.setattr(inst, "load_manifest", lambda p: init_user if p == "init-user" else None)
|
|
monkeypatch.setattr(inst, "list_manifests", lambda: [init_user])
|
|
|
|
res = CliRunner().invoke(main, ["install", "status", "--profile", "typo"])
|
|
|
|
assert res.exit_code != 0
|
|
assert "typo" in res.output
|
|
# The error names the installed profile, but the command never operated on it.
|
|
assert "Preset:" not in res.output
|
|
assert "Status:" not in res.output
|
|
|
|
|
|
def test_install_status_stale_env_profile_is_not_redirected_to_lone_manifest(monkeypatch):
|
|
"""A non-empty HEADROOM_DEPLOYMENT_PROFILE is an explicit selection: if it
|
|
names a missing/stale profile the command must fail naming that profile, never
|
|
silently redirect to a different lone installed deployment (#2832 review)."""
|
|
init_user = _status_manifest("init-user")
|
|
monkeypatch.setenv("HEADROOM_DEPLOYMENT_PROFILE", "missing")
|
|
monkeypatch.setattr(inst, "load_manifest", lambda p: init_user if p == "init-user" else None)
|
|
monkeypatch.setattr(inst, "list_manifests", lambda: [init_user])
|
|
|
|
res = CliRunner().invoke(main, ["install", "status"])
|
|
|
|
assert res.exit_code != 0
|
|
assert "missing" in res.output
|
|
# Never operated on the lone init-user deployment.
|
|
assert "Preset:" not in res.output
|
|
assert "Status:" not in res.output
|
|
|
|
|
|
def test_install_status_omitted_profile_resolves_env_deployment(monkeypatch):
|
|
"""With --profile omitted (Click default), HEADROOM_DEPLOYMENT_PROFILE selects
|
|
the target so the documented bare command works on an init'd machine."""
|
|
init_user = _status_manifest("init-user")
|
|
monkeypatch.setenv("HEADROOM_DEPLOYMENT_PROFILE", "init-user")
|
|
monkeypatch.setattr(inst, "load_manifest", lambda p: init_user if p == "init-user" else None)
|
|
monkeypatch.setattr(inst, "list_manifests", lambda: [init_user])
|
|
monkeypatch.setattr(inst, "probe_json", lambda url: None)
|
|
monkeypatch.setattr(inst, "runtime_status", lambda m: "running")
|
|
monkeypatch.setattr(inst, "probe_ready", lambda url: True)
|
|
|
|
res = CliRunner().invoke(main, ["install", "status"])
|
|
|
|
assert res.exit_code == 0, res.output
|
|
assert "Profile: init-user" in res.output
|
|
|
|
|
|
def test_install_apply_starts_service_supervisor(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = [object()]
|
|
mutations = [object()]
|
|
mutations = []
|
|
targets = ["claude", "codex"]
|
|
artifacts = []
|
|
|
|
manifest = Manifest()
|
|
|
|
monkeypatch.setattr("headroom.cli.install.build_manifest", lambda **_: manifest)
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: None)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.apply_mutations",
|
|
lambda deployment: calls.append("apply") or [],
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.install_supervisor", lambda deployment, **kwargs: [])
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.save_manifest", lambda deployment: calls.append("save")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_supervisor", lambda deployment: calls.append("start_service")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_detached_agent", lambda profile: calls.append("start_agent")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_persistent_docker",
|
|
lambda deployment: calls.append("start_docker"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda deployment, timeout_seconds=45, **kwargs: True
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "stopped")
|
|
|
|
result = runner.invoke(main, ["install", "apply"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "Installed persistent deployment 'default'" in result.output
|
|
assert "Targets: claude, codex" in result.output
|
|
assert calls == ["save", "save", "start_service", "apply", "save"]
|
|
|
|
|
|
def test_install_apply_announces_windows_service_fallback(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-task"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "task"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations: list[object] = []
|
|
targets: list[str] = []
|
|
artifacts: list[object] = []
|
|
|
|
monkeypatch.setattr("headroom.cli.install._is_windows", lambda: True)
|
|
monkeypatch.setattr("headroom.cli.install.build_manifest", lambda **_: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: None)
|
|
monkeypatch.setattr("headroom.cli.install.install_supervisor", lambda deployment, **kwargs: [])
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.apply_mutations", lambda deployment: [])
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "stopped")
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_detached_agent", lambda profile: calls.append("start_agent")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda deployment, timeout_seconds=45, **kwargs: True
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "apply", "--preset", "persistent-service"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "Falling back to persistent-task with Task Scheduler" in result.output
|
|
assert "sc.exe" not in result.output
|
|
assert calls == ["start_agent"]
|
|
|
|
|
|
def test_install_apply_forwards_no_http2_to_build_manifest(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
captured: dict[str, object] = {}
|
|
|
|
class Manifest:
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = [object()]
|
|
mutations = [object()]
|
|
targets = ["claude"]
|
|
mutations = []
|
|
artifacts = []
|
|
|
|
manifest = Manifest()
|
|
|
|
def fake_build_manifest(**kwargs):
|
|
captured.update(kwargs)
|
|
return manifest
|
|
|
|
monkeypatch.setattr("headroom.cli.install.build_manifest", fake_build_manifest)
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: None)
|
|
monkeypatch.setattr("headroom.cli.install.apply_mutations", lambda deployment: [])
|
|
monkeypatch.setattr("headroom.cli.install.install_supervisor", lambda deployment, **kwargs: [])
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.start_supervisor", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.start_detached_agent", lambda profile: None)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda deployment, timeout_seconds=45, **kwargs: True
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "apply", "--no-http2"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert captured["no_http2"] is True
|
|
|
|
|
|
def _patch_apply_pipeline(monkeypatch, captured: dict[str, object]):
|
|
"""Stub out the apply side effects and capture ``build_manifest`` kwargs."""
|
|
|
|
class Manifest:
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
targets = ["claude"]
|
|
mutations: list = []
|
|
artifacts: list = []
|
|
|
|
def fake_build_manifest(**kwargs):
|
|
captured.update(kwargs)
|
|
return Manifest()
|
|
|
|
monkeypatch.setattr("headroom.cli.install.build_manifest", fake_build_manifest)
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: None)
|
|
monkeypatch.setattr("headroom.cli.install.apply_mutations", lambda deployment: [])
|
|
monkeypatch.setattr("headroom.cli.install.install_supervisor", lambda deployment, **kwargs: [])
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.start_supervisor", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.start_detached_agent", lambda profile: None)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda deployment, timeout_seconds=45, **kwargs: True
|
|
)
|
|
|
|
|
|
def test_install_apply_honors_headroom_port_env(monkeypatch) -> None:
|
|
"""An explicit HEADROOM_PORT must reach build_manifest, like `proxy --port` honors it.
|
|
|
|
Regression for #3072 bug 1: `install apply` ignored HEADROOM_PORT and always
|
|
configured 8787 because the --port option had no envvar binding.
|
|
"""
|
|
captured: dict[str, object] = {}
|
|
_patch_apply_pipeline(monkeypatch, captured)
|
|
monkeypatch.setenv("HEADROOM_PORT", "8788")
|
|
|
|
result = CliRunner().invoke(main, ["install", "apply"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert captured["port"] == 8788
|
|
|
|
|
|
def test_install_apply_explicit_port_overrides_env(monkeypatch) -> None:
|
|
"""An explicit --port still wins over HEADROOM_PORT (Click precedence)."""
|
|
captured: dict[str, object] = {}
|
|
_patch_apply_pipeline(monkeypatch, captured)
|
|
monkeypatch.setenv("HEADROOM_PORT", "8788")
|
|
|
|
result = CliRunner().invoke(main, ["install", "apply", "--port", "9999"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert captured["port"] == 9999
|
|
|
|
|
|
def test_deploy_honors_headroom_port_env(monkeypatch) -> None:
|
|
"""`headroom deploy` must honor HEADROOM_PORT the same way (#3072 bug 1)."""
|
|
captured: dict[str, object] = {}
|
|
|
|
plan = SimpleNamespace(
|
|
preset="persistent-service",
|
|
runtime="python",
|
|
reason="test",
|
|
supervisor_kind="service",
|
|
base_env={},
|
|
)
|
|
manifest = SimpleNamespace(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="service",
|
|
scope="user",
|
|
port=0,
|
|
health_url="http://127.0.0.1:8788/readyz",
|
|
targets=["claude"],
|
|
)
|
|
|
|
def fake_build(**kwargs):
|
|
captured.update(kwargs)
|
|
return manifest
|
|
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install._select_turnkey_plan", lambda prefer_docker=True: plan
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install._build_deployment_manifest", fake_build)
|
|
monkeypatch.setattr("headroom.cli.install._apply_manifest", lambda m: None)
|
|
monkeypatch.setattr("headroom.cli.install._echo_installed", lambda m, prefix="": None)
|
|
monkeypatch.setenv("HEADROOM_PORT", "8788")
|
|
|
|
result = CliRunner().invoke(main, ["deploy"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert captured["port"] == 8788
|
|
|
|
|
|
def test_install_apply_help_lists_no_http2() -> None:
|
|
runner = CliRunner()
|
|
|
|
result = runner.invoke(main, ["install", "apply", "--help"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "--no-http2" in result.output
|
|
|
|
|
|
def test_capture_passthrough_env_skips_empty_and_unrelated() -> None:
|
|
from headroom.cli.install import _capture_passthrough_env
|
|
|
|
captured = _capture_passthrough_env(
|
|
{
|
|
"ANTHROPIC_TARGET_API_URL": "https://gw.example/v1",
|
|
"OPENAI_TARGET_API_URL": "", # unset-equivalent, must be skipped
|
|
"SOME_UNRELATED_VAR": "x",
|
|
}
|
|
)
|
|
|
|
assert captured == {"ANTHROPIC_TARGET_API_URL": "https://gw.example/v1"}
|
|
|
|
|
|
def _apply_capturing_build_manifest(monkeypatch) -> dict[str, object]:
|
|
"""Stub install-apply side effects and return the captured build_manifest kwargs."""
|
|
captured: dict[str, object] = {}
|
|
|
|
class Manifest:
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
targets = ["claude"]
|
|
mutations: list[object] = []
|
|
artifacts: list[object] = []
|
|
|
|
def fake_build_manifest(**kwargs):
|
|
captured.update(kwargs)
|
|
return Manifest()
|
|
|
|
monkeypatch.setattr("headroom.cli.install.build_manifest", fake_build_manifest)
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: None)
|
|
monkeypatch.setattr("headroom.cli.install.apply_mutations", lambda deployment: [])
|
|
monkeypatch.setattr("headroom.cli.install.install_supervisor", lambda deployment, **kwargs: [])
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.start_supervisor", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.start_detached_agent", lambda profile: None)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda deployment, timeout_seconds=45, **kwargs: True
|
|
)
|
|
return captured
|
|
|
|
|
|
def test_install_apply_captures_target_api_url_from_env(monkeypatch) -> None:
|
|
monkeypatch.setenv("ANTHROPIC_TARGET_API_URL", "https://gateway.internal/v1")
|
|
captured = _apply_capturing_build_manifest(monkeypatch)
|
|
|
|
result = CliRunner().invoke(main, ["install", "apply"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
# The exported gateway URL rode into the manifest env so the supervised
|
|
# proxy forwards there instead of the public Anthropic endpoint (#2240).
|
|
assert captured["extra_env"]["ANTHROPIC_TARGET_API_URL"] == "https://gateway.internal/v1"
|
|
|
|
|
|
def test_install_apply_explicit_env_overrides_captured(monkeypatch) -> None:
|
|
monkeypatch.setenv("ANTHROPIC_TARGET_API_URL", "https://auto.internal/v1")
|
|
captured = _apply_capturing_build_manifest(monkeypatch)
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
["install", "apply", "--env", "ANTHROPIC_TARGET_API_URL=https://explicit.internal/v1"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
# An explicit --env must win over the auto-captured value.
|
|
assert captured["extra_env"]["ANTHROPIC_TARGET_API_URL"] == "https://explicit.internal/v1"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("anthropic_url", "openai_url", "anthropic_target", "openai_target"),
|
|
[
|
|
(None, None, "default", "default"),
|
|
("", "", "default", "default"),
|
|
("https://anthropic-user:fake-secret@anthropic.invalid/v1", None, "configured", "default"),
|
|
(None, "https://openai-user:fake-secret@openai.invalid/v1", "default", "configured"),
|
|
(
|
|
"https://anthropic-user:fake-secret@anthropic.invalid/v1",
|
|
"https://openai-user:fake-secret@openai.invalid/v1",
|
|
"configured",
|
|
"configured",
|
|
),
|
|
],
|
|
)
|
|
def test_install_status_includes_protocol_targets_from_health_probe(
|
|
monkeypatch, anthropic_url, openai_url, anthropic_target, openai_target
|
|
) -> None:
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: _status_manifest(profile))
|
|
monkeypatch.setattr(inst, "runtime_status", lambda manifest: "running")
|
|
monkeypatch.setattr(inst, "probe_ready", lambda url: True)
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"probe_json",
|
|
lambda url: {
|
|
"config": {
|
|
"backend": "openai",
|
|
"anthropic_api_url": anthropic_url,
|
|
"openai_api_url": openai_url,
|
|
}
|
|
},
|
|
)
|
|
|
|
result = CliRunner().invoke(main, ["install", "status"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "Status: running" in result.output
|
|
assert "Healthy: yes" in result.output
|
|
assert "Default backend: openai" in result.output
|
|
assert f"Anthropic target: {anthropic_target}" in result.output
|
|
assert f"OpenAI target: {openai_target}" in result.output
|
|
for secret in ("fake-secret", "anthropic-user", "openai-user", ".invalid"):
|
|
assert secret not in result.output
|
|
|
|
|
|
def test_install_status_treats_ready_proxy_as_running(monkeypatch) -> None:
|
|
"""Health wins when PID/container bookkeeping incorrectly says stopped.
|
|
|
|
Regression for #3072 bug 2: status previously printed the contradictory
|
|
pair ``Status: stopped`` and ``Healthy: yes`` while doctor correctly
|
|
reported the same proxy as running.
|
|
"""
|
|
manifest = _status_manifest("default")
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: manifest)
|
|
monkeypatch.setattr(inst, "probe_json", lambda url: None)
|
|
monkeypatch.setattr(inst, "probe_ready", lambda url: True)
|
|
monkeypatch.setattr(inst, "runtime_status", lambda deployment: "stopped")
|
|
|
|
result = CliRunner().invoke(main, ["install", "status"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "Status: running" in result.output
|
|
assert "Healthy: yes" in result.output
|
|
assert "Status: stopped" not in result.output
|
|
|
|
|
|
def test_install_status_keeps_runtime_status_when_not_ready(monkeypatch) -> None:
|
|
"""An unhealthy live process remains distinguishable from a stopped one."""
|
|
manifest = _status_manifest("default")
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: manifest)
|
|
monkeypatch.setattr(inst, "probe_json", lambda url: None)
|
|
monkeypatch.setattr(inst, "probe_ready", lambda url: False)
|
|
monkeypatch.setattr(inst, "runtime_status", lambda deployment: "running")
|
|
|
|
result = CliRunner().invoke(main, ["install", "status"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "Status: running" in result.output
|
|
assert "Healthy: no" in result.output
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"payload",
|
|
[
|
|
{"status": "healthy"},
|
|
{"config": {}},
|
|
{"config": {"backend": "anthropic"}},
|
|
{"config": None},
|
|
{"config": "not-a-config"},
|
|
{"config": []},
|
|
{"config": 42},
|
|
{"config": {"anthropic_api_url": False, "openai_api_url": 0}},
|
|
{"config": {"anthropic_api_url": [], "openai_api_url": {}}},
|
|
{"config": {"anthropic_api_url": ["malformed"], "openai_api_url": {"url": "bad"}}},
|
|
],
|
|
)
|
|
def test_install_status_survives_unavailable_config(monkeypatch, payload) -> None:
|
|
"""Redacted or malformed config is unknown, not evidence of unset URLs."""
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: _status_manifest(profile))
|
|
monkeypatch.setattr(inst, "runtime_status", lambda manifest: "running")
|
|
monkeypatch.setattr(inst, "probe_ready", lambda url: True)
|
|
monkeypatch.setattr(inst, "probe_json", lambda url: payload)
|
|
|
|
result = CliRunner().invoke(main, ["install", "status"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "Default backend: anthropic" in result.output
|
|
assert "Anthropic target: unknown" in result.output
|
|
assert "OpenAI target: unknown" in result.output
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("payload", "anthropic_target", "openai_target"),
|
|
[
|
|
({"status": "healthy", "ready": True}, "unknown", "unknown"),
|
|
({"config": {}}, "unknown", "unknown"),
|
|
(
|
|
{"config": {"anthropic_api_url": None, "openai_api_url": None}},
|
|
"default",
|
|
"default",
|
|
),
|
|
(
|
|
{"config": {"openai_api_url": "https://user:fake-secret@openai.invalid/v1"}},
|
|
"unknown",
|
|
"configured",
|
|
),
|
|
({"config": {"anthropic_api_url": ""}}, "default", "unknown"),
|
|
({"config": {"anthropic_api_url": False, "openai_api_url": None}}, "unknown", "default"),
|
|
],
|
|
)
|
|
def test_install_status_probes_live_health_response(
|
|
tmp_path, monkeypatch, payload, anthropic_target, openai_target
|
|
) -> None:
|
|
"""Exercise manifest persistence, HTTP probes and CLI rendering together.
|
|
|
|
The redacted response is the shape returned to an untrusted Docker bridge
|
|
peer. This fixture is an HTTP server, not a Docker networking test.
|
|
"""
|
|
monkeypatch.setenv("HOME", str(tmp_path))
|
|
monkeypatch.setenv("HEADROOM_WORKSPACE_DIR", str(tmp_path / "workspace"))
|
|
monkeypatch.setenv("HEADROOM_CONFIG_DIR", str(tmp_path / "config"))
|
|
monkeypatch.delenv("HEADROOM_DEPLOYMENT_PROFILE", raising=False)
|
|
requests = []
|
|
|
|
class HealthHandler(BaseHTTPRequestHandler):
|
|
def do_GET(self):
|
|
requests.append(self.path)
|
|
body = json.dumps({"ready": True} if self.path == "/readyz" else payload).encode()
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.end_headers()
|
|
self.wfile.write(body)
|
|
|
|
def log_message(self, format, *args):
|
|
pass
|
|
|
|
with ThreadingHTTPServer(("127.0.0.1", 0), HealthHandler) as server:
|
|
thread = Thread(target=server.serve_forever, daemon=True)
|
|
thread.start()
|
|
try:
|
|
port = server.server_address[1]
|
|
save_manifest_strict(
|
|
DeploymentManifest(
|
|
profile="status-proof",
|
|
preset="persistent-task",
|
|
runtime_kind="python",
|
|
supervisor_kind="none",
|
|
scope="user",
|
|
provider_mode="manual",
|
|
targets=[],
|
|
port=port,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
health_url=f"http://127.0.0.1:{port}/readyz",
|
|
base_env={
|
|
"OPENAI_TARGET_API_URL": "https://stale:fake-secret@stale.invalid/v1"
|
|
},
|
|
)
|
|
)
|
|
|
|
result = CliRunner().invoke(main, ["install", "status", "--profile", "status-proof"])
|
|
finally:
|
|
server.shutdown()
|
|
thread.join(timeout=5)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert requests == ["/health", "/readyz"]
|
|
assert "Status: running" in result.output
|
|
assert "Healthy: yes" in result.output
|
|
assert "Default backend: anthropic" in result.output
|
|
assert f"Anthropic target: {anthropic_target}" in result.output
|
|
assert f"OpenAI target: {openai_target}" in result.output
|
|
assert "fake-secret" not in result.output
|
|
assert ".invalid" not in result.output
|
|
|
|
|
|
def test_install_restart_uses_internal_helpers(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = [object()]
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.revert_mutations",
|
|
lambda manifest, **kwargs: calls.append("revert"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.stop_supervisor", lambda manifest: calls.append("stop_supervisor")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.stop_runtime", lambda manifest: calls.append("stop_runtime")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_supervisor", lambda manifest: calls.append("start_supervisor")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda manifest, timeout_seconds=45, **kwargs: True
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.apply_mutations", lambda manifest: calls.append("apply") or []
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda manifest: calls.append("save"))
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.wait_stopped", lambda manifest: True)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "stopped")
|
|
|
|
result = runner.invoke(main, ["install", "restart"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "Restarted deployment 'default'." in result.output
|
|
assert calls == [
|
|
"revert",
|
|
"save",
|
|
"stop_supervisor",
|
|
"stop_runtime",
|
|
"start_supervisor",
|
|
"apply",
|
|
"save",
|
|
]
|
|
|
|
|
|
@pytest.mark.parametrize("supervisor_kind", ["service", "task"])
|
|
def test_stop_deployment_stops_external_supervisor_before_docker(
|
|
monkeypatch, supervisor_kind: str
|
|
) -> None:
|
|
calls: list[str] = []
|
|
manifest = SimpleNamespace(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="docker",
|
|
supervisor_kind=supervisor_kind,
|
|
health_url="http://127.0.0.1:8787/readyz",
|
|
)
|
|
monkeypatch.setattr(inst, "stop_supervisor", lambda current: calls.append("supervisor"))
|
|
monkeypatch.setattr(inst, "stop_runtime", lambda current: calls.append("runtime"))
|
|
monkeypatch.setattr(inst, "wait_stopped", lambda current: calls.append("wait_stopped") or True)
|
|
|
|
inst._stop_deployment(manifest)
|
|
|
|
assert calls == ["supervisor", "runtime", "wait_stopped"]
|
|
|
|
|
|
def test_stop_deployment_stops_docker_even_when_supervisor_stop_fails(monkeypatch) -> None:
|
|
calls: list[str] = []
|
|
manifest = SimpleNamespace(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="docker",
|
|
supervisor_kind="service",
|
|
)
|
|
|
|
def fail_supervisor(current):
|
|
calls.append("supervisor")
|
|
raise RuntimeError("supervisor unavailable")
|
|
|
|
monkeypatch.setattr(inst, "stop_supervisor", fail_supervisor)
|
|
monkeypatch.setattr(inst, "stop_runtime", lambda current: calls.append("runtime"))
|
|
|
|
with pytest.raises(RuntimeError, match="supervisor unavailable"):
|
|
inst._stop_deployment(manifest)
|
|
assert calls == ["supervisor", "runtime"]
|
|
|
|
|
|
def test_remove_deployment_retains_manifest_when_supervisor_stop_fails(monkeypatch) -> None:
|
|
calls: list[str] = []
|
|
manifest = SimpleNamespace(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="docker",
|
|
supervisor_kind="service",
|
|
mutations=[],
|
|
)
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"stop_supervisor",
|
|
lambda current: (_ for _ in ()).throw(RuntimeError("supervisor unavailable")),
|
|
)
|
|
monkeypatch.setattr(inst, "stop_runtime", lambda current: calls.append("runtime"))
|
|
monkeypatch.setattr(
|
|
inst, "remove_supervisor", lambda current: calls.append("remove-supervisor")
|
|
)
|
|
monkeypatch.setattr(inst, "delete_manifest", lambda profile: calls.append("delete"))
|
|
|
|
with pytest.raises(RuntimeError, match="supervisor unavailable"):
|
|
inst._remove_deployment(manifest)
|
|
assert calls == ["runtime", "remove-supervisor"]
|
|
|
|
|
|
def test_remove_deployment_reports_all_cleanup_failures(monkeypatch) -> None:
|
|
manifest = SimpleNamespace(profile="default", mutations=[object()])
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"_deactivate_deployment_mutations",
|
|
lambda *args, **kwargs: (_ for _ in ()).throw(RuntimeError("mutation failed")),
|
|
)
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"_stop_deployment",
|
|
lambda current: (_ for _ in ()).throw(RuntimeError("runtime failed")),
|
|
)
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"remove_supervisor",
|
|
lambda current: (_ for _ in ()).throw(RuntimeError("supervisor failed")),
|
|
)
|
|
|
|
with pytest.raises(RuntimeError) as exc:
|
|
inst._remove_deployment(manifest)
|
|
|
|
message = str(exc.value)
|
|
assert all(
|
|
item in message for item in ("mutation failed", "runtime failed", "supervisor failed")
|
|
)
|
|
|
|
|
|
def _restart_race_manifest():
|
|
class Manifest:
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
port = 8787
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
backend = "anthropic"
|
|
targets: list[str] = []
|
|
tool_envs: dict[str, dict[str, str]] = {}
|
|
mutations: list = []
|
|
|
|
return Manifest()
|
|
|
|
|
|
def test_install_restart_waits_for_old_process_before_starting(monkeypatch) -> None:
|
|
"""#3658: the old proxy still answers /readyz right after stop; restart must
|
|
wait for it to go away, otherwise start is skipped and the service stays down."""
|
|
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.load_manifest", lambda profile: _restart_race_manifest()
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.stop_supervisor", lambda manifest: calls.append("stop_supervisor")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.stop_runtime", lambda manifest: calls.append("stop_runtime")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_stopped",
|
|
lambda manifest, timeout_seconds=15: calls.append("wait_stopped") or True,
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_supervisor", lambda manifest: calls.append("start_supervisor")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready",
|
|
lambda manifest, timeout_seconds=45, **kwargs: True,
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.apply_mutations", lambda manifest: [])
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda manifest: None)
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "stopped")
|
|
|
|
result = runner.invoke(main, ["install", "restart"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert calls == ["stop_supervisor", "stop_runtime", "wait_stopped", "start_supervisor"]
|
|
|
|
|
|
@pytest.mark.parametrize("command", ["stop", "restart"])
|
|
def test_install_stop_and_restart_fail_when_old_process_never_stops(monkeypatch, command) -> None:
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.load_manifest", lambda profile: _restart_race_manifest()
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.stop_supervisor", lambda manifest: None)
|
|
monkeypatch.setattr("headroom.cli.install.stop_runtime", lambda manifest: None)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_stopped", lambda manifest, timeout_seconds=15: False
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_supervisor", lambda manifest: calls.append("start_supervisor")
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda manifest: None)
|
|
|
|
result = runner.invoke(main, ["install", command])
|
|
|
|
assert result.exit_code != 0
|
|
assert "still answering" in result.output
|
|
assert "deployment 'default'." not in result.output
|
|
assert calls == []
|
|
|
|
|
|
def test_install_start_noops_when_already_healthy(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = build_tool_envs(8787, "anthropic", ["claude"])
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = [object()]
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "running")
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: True)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_supervisor", lambda manifest: calls.append("start_supervisor")
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "start"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "Started deployment 'default'." in result.output
|
|
assert calls == []
|
|
|
|
|
|
def test_start_deployment_requires_identity_for_post_start_readiness(monkeypatch) -> None:
|
|
manifest = SimpleNamespace(
|
|
profile="default",
|
|
preset="persistent-task",
|
|
runtime_kind="python",
|
|
supervisor_kind="none",
|
|
health_url="http://127.0.0.1:8787/readyz",
|
|
)
|
|
waits: list[dict[str, object]] = []
|
|
monkeypatch.setattr(inst, "runtime_status", lambda current: "stopped")
|
|
monkeypatch.setattr(inst, "start_detached_agent", lambda profile: None)
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"wait_ready",
|
|
lambda current, timeout_seconds, **kwargs: waits.append(kwargs) or True,
|
|
)
|
|
|
|
inst._start_deployment(manifest, assume_start_lock=True)
|
|
|
|
assert waits == [{"require_identity": True}]
|
|
|
|
|
|
def test_install_start_noops_for_healthy_docker_without_docker_on_path(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = build_tool_envs(8787, "anthropic", ["claude"])
|
|
profile = "default"
|
|
preset = "persistent-docker"
|
|
runtime_kind = "docker"
|
|
supervisor_kind = "none"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = [object()]
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "running")
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: True)
|
|
monkeypatch.setattr("headroom.cli.install.shutil.which", lambda name, *args, **kwargs: None)
|
|
|
|
result = runner.invoke(main, ["install", "start"])
|
|
|
|
assert result.exit_code != 0
|
|
assert "docker' was not found on PATH" in result.output
|
|
|
|
|
|
def test_install_start_does_not_spawn_when_start_lock_is_contended(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = []
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def fake_lock(profile):
|
|
yield False
|
|
|
|
monkeypatch.setattr("headroom.cli.install.acquire_runtime_start_lock", fake_lock)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_supervisor", lambda manifest: calls.append("start_supervisor")
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "start"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "start is already in progress" in result.output
|
|
assert calls == []
|
|
|
|
|
|
def test_install_start_restarts_wedged_runtime_under_single_lock(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = [object()]
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
probe_calls = {"count": 0}
|
|
|
|
def fake_probe_ready(url: str) -> bool:
|
|
probe_calls["count"] += 1
|
|
return probe_calls["count"] > 2
|
|
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", fake_probe_ready)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "running")
|
|
wait_results = iter([False, True])
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready",
|
|
lambda manifest, timeout_seconds, **kwargs: next(wait_results),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.revert_mutations",
|
|
lambda manifest, **kwargs: calls.append("revert"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.apply_mutations", lambda manifest: calls.append("apply") or []
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda manifest: calls.append("save"))
|
|
monkeypatch.setattr("headroom.cli.install.stop_runtime", lambda manifest: calls.append("stop"))
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_supervisor", lambda manifest: calls.append("start_supervisor")
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "start"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert calls == ["revert", "save", "stop", "start_supervisor", "apply", "save"]
|
|
|
|
|
|
def test_install_apply_rejects_invalid_profile() -> None:
|
|
runner = CliRunner()
|
|
|
|
result = runner.invoke(main, ["install", "apply", "--profile", "../bad"])
|
|
|
|
assert result.exit_code != 0
|
|
assert "Invalid profile name '../bad'" in result.output
|
|
|
|
|
|
def test_install_apply_rejects_provider_scope_targets_without_support() -> None:
|
|
runner = CliRunner()
|
|
|
|
result = runner.invoke(
|
|
main,
|
|
["install", "apply", "--scope", "provider", "--providers", "manual", "--target", "copilot"],
|
|
)
|
|
|
|
assert result.exit_code != 0
|
|
assert "Provider scope supports only claude, codex, openclaw, and opencode" in result.output
|
|
|
|
|
|
def test_install_apply_accepts_opencode_target(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
captured: dict[str, object] = {}
|
|
|
|
class Manifest:
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "provider"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
targets = ["opencode"]
|
|
mutations = []
|
|
artifacts = []
|
|
|
|
manifest = Manifest()
|
|
|
|
def fake_build_manifest(**kwargs):
|
|
captured.update(kwargs)
|
|
return manifest
|
|
|
|
monkeypatch.setattr("headroom.cli.install.build_manifest", fake_build_manifest)
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: None)
|
|
monkeypatch.setattr("headroom.cli.install.apply_mutations", lambda deployment: [])
|
|
monkeypatch.setattr("headroom.cli.install.install_supervisor", lambda deployment, **kwargs: [])
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.start_supervisor", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.start_detached_agent", lambda profile: None)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda deployment, timeout_seconds=45, **kwargs: True
|
|
)
|
|
|
|
result = runner.invoke(
|
|
main,
|
|
[
|
|
"install",
|
|
"apply",
|
|
"--scope",
|
|
"provider",
|
|
"--providers",
|
|
"manual",
|
|
"--target",
|
|
"opencode",
|
|
],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert captured["targets"] == ["opencode"]
|
|
assert "Targets: opencode" in result.output
|
|
|
|
|
|
def test_install_apply_old_removal_failure_is_actionable_and_does_not_start_new(
|
|
monkeypatch,
|
|
) -> None:
|
|
previous = SimpleNamespace(profile="default")
|
|
new = SimpleNamespace(profile="default", artifacts=[], mutations=[])
|
|
calls: list[str] = []
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: previous)
|
|
monkeypatch.setattr(inst, "_save_recovery_snapshot", lambda *args: calls.append("snapshot"))
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"_remove_deployment",
|
|
lambda manifest, **kwargs: (_ for _ in ()).throw(RuntimeError("old removal failed")),
|
|
)
|
|
monkeypatch.setattr(inst, "_start_deployment", lambda manifest: calls.append("start"))
|
|
|
|
with pytest.raises(click.ClickException) as exc:
|
|
inst._apply_manifest(new)
|
|
|
|
assert "old removal failed" in str(exc.value)
|
|
assert "no new owner was started" in str(exc.value)
|
|
assert calls == ["snapshot"]
|
|
|
|
|
|
def test_install_apply_uses_requested_profile_for_recovery_snapshot(
|
|
monkeypatch, tmp_path: Path
|
|
) -> None:
|
|
monkeypatch.setattr(Path, "home", lambda: tmp_path)
|
|
previous = DeploymentManifest(
|
|
profile="loaded-profile",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="service",
|
|
scope="user",
|
|
provider_mode="manual",
|
|
targets=["old"],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
new = DeploymentManifest(
|
|
profile="requested-profile",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="service",
|
|
scope="user",
|
|
provider_mode="manual",
|
|
targets=["new"],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: previous)
|
|
monkeypatch.setattr(inst, "_remove_deployment", lambda manifest, **kwargs: None)
|
|
monkeypatch.setattr(inst, "_save_apply_manifest", lambda manifest: None)
|
|
monkeypatch.setattr(inst, "install_supervisor", lambda manifest, **kwargs: [])
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"_start_deployment",
|
|
lambda manifest: (_ for _ in ()).throw(click.ClickException("startup failed")),
|
|
)
|
|
|
|
with pytest.raises(click.ClickException):
|
|
inst._apply_manifest(new)
|
|
|
|
assert (tmp_path / ".headroom" / "deploy" / "requested-profile.recovery.json").exists()
|
|
assert not (tmp_path / ".headroom" / "deploy" / "loaded-profile.recovery.json").exists()
|
|
|
|
|
|
def test_restore_deployment_requires_durable_manifest_before_start(monkeypatch) -> None:
|
|
manifest = DeploymentManifest(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="service",
|
|
scope="user",
|
|
provider_mode="manual",
|
|
targets=[],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
calls: list[str] = []
|
|
monkeypatch.setattr(inst, "install_supervisor", lambda current, **kwargs: [])
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"_save_apply_manifest",
|
|
lambda current: (_ for _ in ()).throw(OSError("restore manifest busy")),
|
|
)
|
|
monkeypatch.setattr(inst, "_start_deployment", lambda current: calls.append("start"))
|
|
|
|
with pytest.raises(OSError, match="restore manifest busy"):
|
|
inst._restore_deployment(manifest)
|
|
assert calls == []
|
|
|
|
|
|
def test_apply_persists_before_darwin_bootstrap_or_start_on_save_failure(monkeypatch) -> None:
|
|
manifest = DeploymentManifest(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="service",
|
|
scope="user",
|
|
provider_mode="manual",
|
|
targets=[],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
install_calls: list[bool] = []
|
|
bootstrap_calls: list[str] = []
|
|
start_calls: list[str] = []
|
|
save_calls = 0
|
|
|
|
def save(current) -> None:
|
|
nonlocal save_calls
|
|
save_calls += 1
|
|
if save_calls == 2:
|
|
raise OSError("active manifest busy")
|
|
|
|
def install(current, *, start=True):
|
|
install_calls.append(start)
|
|
if start:
|
|
bootstrap_calls.append(current.profile)
|
|
return []
|
|
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: None)
|
|
monkeypatch.setattr(inst, "_save_apply_manifest", save)
|
|
monkeypatch.setattr(inst, "install_supervisor", install)
|
|
monkeypatch.setattr(
|
|
inst, "_start_deployment", lambda current: start_calls.append(current.profile)
|
|
)
|
|
monkeypatch.setattr(inst, "_remove_deployment", lambda current, **kwargs: None)
|
|
|
|
with pytest.raises(click.ClickException, match="active manifest busy"):
|
|
inst._apply_manifest(manifest)
|
|
|
|
assert install_calls == [False]
|
|
assert bootstrap_calls == []
|
|
assert start_calls == []
|
|
|
|
|
|
def test_activate_mutations_reverts_side_effects_when_strict_save_fails(monkeypatch) -> None:
|
|
manifest = DeploymentManifest(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="service",
|
|
scope="user",
|
|
provider_mode="manual",
|
|
targets=[],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
mutation = ManagedMutation(target="env", kind="shell-block", path="settings")
|
|
reverted: list[ManagedMutation] = []
|
|
monkeypatch.setattr(inst, "apply_mutations", lambda current: [mutation])
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"_save_apply_manifest",
|
|
lambda current: (_ for _ in ()).throw(OSError("manifest busy")),
|
|
)
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"revert_mutations",
|
|
lambda current, **kwargs: reverted.extend(current.mutations),
|
|
)
|
|
|
|
with pytest.raises(OSError, match="manifest busy"):
|
|
inst._activate_deployment_mutations(manifest)
|
|
assert reverted == [mutation]
|
|
assert manifest.mutations == []
|
|
|
|
|
|
def test_recovery_snapshot_delete_failure_is_actionable(monkeypatch) -> None:
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"delete_recovery_manifest",
|
|
lambda profile: (_ for _ in ()).throw(OSError("snapshot busy")),
|
|
)
|
|
|
|
with pytest.raises(click.ClickException, match="could not be deleted") as exc:
|
|
inst._delete_recovery_snapshot("default")
|
|
assert "snapshot busy" in str(exc.value)
|
|
assert "retained" in str(exc.value)
|
|
|
|
|
|
def test_install_apply_keeps_new_owner_recovery_fail_closed(monkeypatch, tmp_path: Path) -> None:
|
|
monkeypatch.setattr(Path, "home", lambda: tmp_path)
|
|
previous = DeploymentManifest(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="service",
|
|
scope="user",
|
|
provider_mode="manual",
|
|
targets=["old"],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
new = DeploymentManifest(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="service",
|
|
scope="user",
|
|
provider_mode="manual",
|
|
targets=["new"],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: previous)
|
|
|
|
def remove(manifest, **kwargs):
|
|
if manifest is new:
|
|
raise RuntimeError("new deployment cleanup failed")
|
|
|
|
monkeypatch.setattr(inst, "_remove_deployment", remove)
|
|
monkeypatch.setattr(inst, "install_supervisor", lambda manifest, **kwargs: [])
|
|
monkeypatch.setattr(
|
|
inst,
|
|
"_start_deployment",
|
|
lambda manifest: (_ for _ in ()).throw(click.ClickException("startup failed")),
|
|
)
|
|
|
|
with pytest.raises(click.ClickException):
|
|
inst._apply_manifest(new)
|
|
|
|
owner = load_state_manifest("default")
|
|
assert owner is not None
|
|
assert owner.targets == ["new"]
|
|
recovery = tmp_path / ".headroom" / "deploy" / "default.recovery.json"
|
|
assert json.loads(recovery.read_text(encoding="utf-8"))["targets"] == ["old"]
|
|
|
|
|
|
def test_install_apply_keeps_snapshot_when_active_persistence_fails(
|
|
monkeypatch, tmp_path: Path
|
|
) -> None:
|
|
monkeypatch.setattr(Path, "home", lambda: tmp_path)
|
|
previous = DeploymentManifest(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="service",
|
|
scope="user",
|
|
provider_mode="manual",
|
|
targets=["old"],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
new = DeploymentManifest(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="service",
|
|
scope="user",
|
|
provider_mode="manual",
|
|
targets=["new"],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: previous)
|
|
monkeypatch.setattr(inst, "_remove_deployment", lambda manifest, **kwargs: None)
|
|
monkeypatch.setattr(inst, "install_supervisor", lambda manifest, **kwargs: [])
|
|
saves = 0
|
|
|
|
def fail_active_save(manifest):
|
|
nonlocal saves
|
|
saves += 1
|
|
if saves == 1:
|
|
inst.save_manifest_strict(manifest)
|
|
return
|
|
raise OSError("active manifest busy")
|
|
|
|
monkeypatch.setattr(inst, "_save_apply_manifest", fail_active_save)
|
|
|
|
with pytest.raises(click.ClickException):
|
|
inst._apply_manifest(new)
|
|
|
|
owner = load_state_manifest("default")
|
|
assert owner is not None
|
|
assert owner.targets == ["new"]
|
|
recovery = tmp_path / ".headroom" / "deploy" / "default.recovery.json"
|
|
assert json.loads(recovery.read_text(encoding="utf-8"))["targets"] == ["old"]
|
|
|
|
|
|
def test_install_start_rejects_task_lifecycle(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-task"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "task"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
|
|
result = runner.invoke(main, ["install", "start"])
|
|
|
|
assert result.exit_code != 0
|
|
assert "headroom install start" in result.output
|
|
|
|
|
|
def test_install_apply_uses_docker_runtime_for_persistent_docker(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-docker"
|
|
runtime_kind = "docker"
|
|
supervisor_kind = "none"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
container_name = "headroom-default"
|
|
targets: list[str] = []
|
|
mutations = []
|
|
artifacts = []
|
|
|
|
monkeypatch.setattr("headroom.cli.install.build_manifest", lambda **_: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: None)
|
|
monkeypatch.setattr("headroom.cli.install.apply_mutations", lambda deployment: [])
|
|
monkeypatch.setattr("headroom.cli.install.install_supervisor", lambda deployment, **kwargs: [])
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda deployment: "stopped")
|
|
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def fake_lock(profile):
|
|
yield True
|
|
|
|
monkeypatch.setattr("headroom.cli.install.acquire_runtime_start_lock", fake_lock)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_persistent_docker",
|
|
lambda deployment: calls.append("start_docker"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda deployment, timeout_seconds=45, **kwargs: True
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda deployment: "stopped")
|
|
# _start_deployment guards the persistent-docker preset with
|
|
# `shutil.which("docker")`. Fake docker as present so the test exercises the
|
|
# runtime-selection path itself rather than the host's docker install —
|
|
# otherwise it passes on dev machines with Docker but fails on CI runners
|
|
# (e.g. macos-latest) that have no docker on PATH.
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.shutil.which",
|
|
lambda name, *args, **kwargs: "/usr/local/bin/docker" if name == "docker" else None,
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "apply", "--preset", "persistent-docker"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert calls == ["start_docker"]
|
|
|
|
|
|
def test_deploy_prefers_docker_when_available(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
captured: dict[str, object] = {}
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-docker"
|
|
runtime_kind = "docker"
|
|
supervisor_kind = "none"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
targets = ["claude", "codex"]
|
|
mutations = []
|
|
artifacts = []
|
|
|
|
def fake_build(**kwargs):
|
|
captured.update(kwargs)
|
|
return Manifest()
|
|
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install._command_available", lambda command: command == "docker"
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.shutil.which",
|
|
lambda name, *args, **kwargs: "/usr/local/bin/docker" if name == "docker" else None,
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.build_manifest", fake_build)
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: None)
|
|
monkeypatch.setattr("headroom.cli.install.apply_mutations", lambda deployment: [])
|
|
monkeypatch.setattr("headroom.cli.install.install_supervisor", lambda deployment, **kwargs: [])
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda deployment: "stopped")
|
|
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def fake_lock(profile):
|
|
yield True
|
|
|
|
monkeypatch.setattr("headroom.cli.install.acquire_runtime_start_lock", fake_lock)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_persistent_docker",
|
|
lambda deployment: calls.append("start_docker"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda deployment, timeout_seconds=45, **kwargs: True
|
|
)
|
|
|
|
result = runner.invoke(main, ["deploy"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "Selected persistent-docker" in result.output
|
|
assert "Deployed turnkey deployment 'default'" in result.output
|
|
assert captured["preset"] == "persistent-docker"
|
|
assert captured["runtime_kind"] == "docker"
|
|
assert calls == ["start_docker"]
|
|
|
|
|
|
def test_deploy_prefers_gpu_docker_when_available(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
captured: dict[str, object] = {}
|
|
|
|
class Manifest:
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-docker"
|
|
runtime_kind = "docker"
|
|
supervisor_kind = "none"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
targets: list[str] = []
|
|
base_env: dict[str, str] = {}
|
|
mutations = []
|
|
artifacts = []
|
|
|
|
manifest = Manifest()
|
|
|
|
def fake_build(**kwargs):
|
|
captured.update(kwargs)
|
|
return manifest
|
|
|
|
monkeypatch.setattr("headroom.cli.install._detect_nvidia_gpu_names", lambda: ["RTX 4090"])
|
|
monkeypatch.setattr("headroom.cli.install._docker_supports_nvidia_gpus", lambda: True)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.shutil.which",
|
|
lambda name, *args, **kwargs: "/usr/local/bin/docker" if name == "docker" else None,
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.build_manifest", fake_build)
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: None)
|
|
monkeypatch.setattr("headroom.cli.install.apply_mutations", lambda deployment: [])
|
|
monkeypatch.setattr("headroom.cli.install.install_supervisor", lambda deployment, **kwargs: [])
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda deployment: "stopped")
|
|
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def fake_lock(profile):
|
|
yield True
|
|
|
|
monkeypatch.setattr("headroom.cli.install.acquire_runtime_start_lock", fake_lock)
|
|
monkeypatch.setattr("headroom.cli.install.start_persistent_docker", lambda deployment: None)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda deployment, timeout_seconds=45, **kwargs: True
|
|
)
|
|
|
|
result = runner.invoke(main, ["deploy"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "RTX 4090" in result.output
|
|
assert captured["preset"] == "persistent-docker"
|
|
assert captured["runtime_kind"] == "docker"
|
|
assert manifest.base_env["HEADROOM_DOCKER_GPUS"] == "all"
|
|
|
|
|
|
def test_deploy_falls_back_to_detached_python_without_supervisor(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-task"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "task"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
targets: list[str] = []
|
|
mutations = []
|
|
artifacts = []
|
|
|
|
manifest = Manifest()
|
|
|
|
monkeypatch.setattr("headroom.cli.install._command_available", lambda command: False)
|
|
monkeypatch.setattr("headroom.cli.install.build_manifest", lambda **_: manifest)
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: None)
|
|
monkeypatch.setattr("headroom.cli.install.apply_mutations", lambda deployment: [])
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.install_supervisor",
|
|
lambda deployment, **kwargs: calls.append(f"supervisor:{deployment.supervisor_kind}") or [],
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda deployment: None)
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda deployment: "stopped")
|
|
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def fake_lock(profile):
|
|
yield True
|
|
|
|
monkeypatch.setattr("headroom.cli.install.acquire_runtime_start_lock", fake_lock)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_detached_agent",
|
|
lambda profile: calls.append(f"agent:{profile}"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda deployment, timeout_seconds=45, **kwargs: True
|
|
)
|
|
|
|
result = runner.invoke(main, ["deploy", "--no-docker"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "No supported supervisor was detected" in result.output
|
|
assert manifest.supervisor_kind == "none"
|
|
assert calls == ["supervisor:none", "agent:default"]
|
|
|
|
|
|
def test_install_remove_retains_manifest_when_runtime_teardown_errors(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = [object()]
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.revert_mutations",
|
|
lambda manifest, **kwargs: calls.append("revert"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.stop_supervisor",
|
|
lambda manifest: (_ for _ in ()).throw(RuntimeError("boom")),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.stop_runtime",
|
|
lambda manifest: (_ for _ in ()).throw(RuntimeError("boom")),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.remove_supervisor", lambda manifest: calls.append("remove_supervisor")
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.delete_manifest", lambda profile: calls.append("delete")
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "remove"])
|
|
|
|
assert result.exit_code != 0
|
|
assert "Error: Failed to remove deployment 'default': cleanup failed:" in result.output
|
|
assert "Traceback" not in result.output
|
|
assert calls == ["revert", "remove_supervisor"]
|
|
|
|
|
|
def test_install_agent_ensure_reports_already_healthy(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = []
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "running")
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: True)
|
|
|
|
result = runner.invoke(main, ["install", "agent", "ensure"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "already healthy" in result.output
|
|
|
|
|
|
def test_install_agent_run_exits_with_foreground_status(monkeypatch) -> None:
|
|
runner = CliRunner()
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.run_foreground", lambda manifest: 7)
|
|
|
|
result = runner.invoke(main, ["install", "agent", "run"])
|
|
|
|
assert result.exit_code == 7
|
|
|
|
|
|
def test_install_agent_ensure_no_spawn_when_lock_not_acquired(monkeypatch) -> None:
|
|
"""Ensure does not spawn a runtime when the start lock is contended."""
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "stopped")
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def fake_lock(profile):
|
|
yield False
|
|
|
|
monkeypatch.setattr("headroom.cli.install.acquire_runtime_start_lock", fake_lock)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_detached_agent",
|
|
lambda profile: calls.append("start_agent"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_persistent_docker",
|
|
lambda manifest: calls.append("start_docker"),
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "agent", "ensure"])
|
|
assert result.exit_code == 0, result.output
|
|
assert "already in progress" in result.output
|
|
assert calls == []
|
|
|
|
|
|
def test_install_agent_ensure_stops_wedged_runtime_before_restart(monkeypatch) -> None:
|
|
"""Ensure stops a wedged runtime (running but not ready) before starting fresh."""
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
preset = "persistent-task"
|
|
supervisor_kind = "none"
|
|
scope = "user"
|
|
mutations = []
|
|
scope = "user"
|
|
mutations = []
|
|
scope = "user"
|
|
mutations = []
|
|
scope = "user"
|
|
mutations = [object()]
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "running")
|
|
wait_calls: list[dict[str, object]] = []
|
|
|
|
def fake_wait_ready(manifest, timeout_seconds, **kwargs):
|
|
wait_calls.append(kwargs)
|
|
return False
|
|
|
|
monkeypatch.setattr("headroom.cli.install.wait_ready", fake_wait_ready)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.revert_mutations",
|
|
lambda manifest, **kwargs: calls.append("revert"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.apply_mutations", lambda manifest: calls.append("apply") or []
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda manifest: calls.append("save"))
|
|
monkeypatch.setattr("headroom.cli.install.stop_runtime", lambda manifest: calls.append("stop"))
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_detached_agent",
|
|
lambda profile: calls.append("start_agent"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_persistent_docker",
|
|
lambda manifest: calls.append("start_docker"),
|
|
)
|
|
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def fake_lock(profile):
|
|
yield True
|
|
|
|
monkeypatch.setattr("headroom.cli.install.acquire_runtime_start_lock", fake_lock)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install._start_deployment",
|
|
lambda manifest, **kwargs: calls.append("start_deployment"),
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "agent", "ensure"])
|
|
assert result.exit_code == 0, result.output
|
|
# stop must come before start_deployment — that's the bug guard.
|
|
assert calls.index("revert") < calls.index("stop")
|
|
assert calls.index("stop") < calls.index("start_deployment")
|
|
assert calls.index("start_deployment") < calls.index("apply")
|
|
assert wait_calls == [{"require_identity": True}]
|
|
assert "start_agent" not in calls
|
|
assert "start_docker" not in calls
|
|
|
|
|
|
def test_install_agent_ensure_starts_when_stopped_and_lock_acquired(monkeypatch) -> None:
|
|
"""Ensure starts a runtime when none is running and lock is acquired."""
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
preset = "persistent-task"
|
|
supervisor_kind = "none"
|
|
scope = "user"
|
|
mutations = []
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "stopped")
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.apply_mutations", lambda manifest: calls.append("apply") or []
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda manifest: calls.append("save"))
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_detached_agent",
|
|
lambda profile: calls.append("start_agent"),
|
|
)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_persistent_docker",
|
|
lambda manifest: calls.append("start_docker"),
|
|
)
|
|
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def fake_lock(profile):
|
|
yield True
|
|
|
|
monkeypatch.setattr("headroom.cli.install.acquire_runtime_start_lock", fake_lock)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda manifest, timeout_seconds, **kwargs: True
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "agent", "ensure"])
|
|
assert result.exit_code == 0, result.output
|
|
assert calls == ["start_agent", "apply", "save"]
|
|
|
|
|
|
def test_install_agent_ensure_no_duplicate_spawn_after_lock_recheck(monkeypatch) -> None:
|
|
"""Ensure does not spawn if proxy becomes ready between initial probe and lock."""
|
|
runner = CliRunner()
|
|
calls: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
|
|
# First probe_ready (before lock) returns False, second (after lock) returns True
|
|
probe_results = iter([False, True])
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "running")
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: next(probe_results))
|
|
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.start_detached_agent",
|
|
lambda profile: calls.append("start_agent"),
|
|
)
|
|
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def fake_lock(profile):
|
|
yield True
|
|
|
|
monkeypatch.setattr("headroom.cli.install.acquire_runtime_start_lock", fake_lock)
|
|
|
|
result = runner.invoke(main, ["install", "agent", "ensure"])
|
|
assert result.exit_code == 0, result.output
|
|
assert "already healthy" in result.output
|
|
assert calls == []
|
|
|
|
|
|
def test_install_agent_ensure_propagates_start_deployment_failure(monkeypatch) -> None:
|
|
"""Ensure must exit non-zero and surface the error when _start_deployment fails.
|
|
|
|
Regression for review feedback on PR #1301: the previous implementation wrapped
|
|
the guarded block in `except Exception` and returned normally, which made
|
|
a failed ensure indistinguishable from a successful one. Automation callers
|
|
need a non-zero exit code to detect that the deployment did not come up.
|
|
"""
|
|
runner = CliRunner()
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs = {}
|
|
profile = "default"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
preset = "persistent-task"
|
|
supervisor_kind = "none"
|
|
scope = "user"
|
|
mutations = []
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: Manifest())
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: False)
|
|
monkeypatch.setattr("headroom.cli.install.runtime_status", lambda manifest: "stopped")
|
|
|
|
import contextlib
|
|
|
|
@contextlib.contextmanager
|
|
def fake_lock(profile):
|
|
yield True
|
|
|
|
monkeypatch.setattr("headroom.cli.install.acquire_runtime_start_lock", fake_lock)
|
|
|
|
def boom(manifest, **kwargs):
|
|
raise click.ClickException("simulated start failure")
|
|
|
|
monkeypatch.setattr("headroom.cli.install._start_deployment", boom)
|
|
|
|
result = runner.invoke(main, ["install", "agent", "ensure"])
|
|
assert result.exit_code != 0, f"expected non-zero exit, got {result.exit_code}: {result.output}"
|
|
assert "simulated start failure" in result.output
|
|
|
|
|
|
def test_install_start_reconciles_a_healthy_deployment(monkeypatch) -> None:
|
|
"""The regression this whole change exists for.
|
|
|
|
``install start`` activated mutations only when the deployment had NONE
|
|
recorded. A normally-installed, working deployment always has some, so the
|
|
reconcile never ran on the one command the affected users actually type --
|
|
and the stale env var stayed stale forever.
|
|
"""
|
|
runner = CliRunner()
|
|
applied: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
# Pre-#746: base URL written, tool search never enabled.
|
|
tool_envs = {"claude": {"ANTHROPIC_BASE_URL": "http://127.0.0.1:8787"}}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = [object()] # healthy AND already mutated: the skipped case
|
|
artifacts = []
|
|
|
|
manifest = Manifest()
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: manifest)
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: True)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.apply_mutations", lambda m: applied.append("apply") or []
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda m: None)
|
|
monkeypatch.setattr("headroom.cli.install.start_supervisor", lambda m: None)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda m, timeout_seconds=None, **kwargs: True
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "start"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "ENABLE_TOOL_SEARCH" in manifest.tool_envs["claude"]
|
|
assert applied == ["apply"] # re-applied so the new key reaches the config
|
|
|
|
|
|
def test_install_start_still_skips_when_nothing_is_pending(monkeypatch) -> None:
|
|
"""A deployment that is already current must not be perturbed."""
|
|
runner = CliRunner()
|
|
applied: list[str] = []
|
|
|
|
class Manifest:
|
|
targets = ["claude"]
|
|
port = 8787
|
|
backend = "anthropic"
|
|
tool_envs: dict = {}
|
|
profile = "default"
|
|
preset = "persistent-service"
|
|
runtime_kind = "python"
|
|
supervisor_kind = "service"
|
|
scope = "user"
|
|
health_url = "http://127.0.0.1:8787/readyz"
|
|
mutations = [object()]
|
|
artifacts = []
|
|
|
|
manifest = Manifest()
|
|
from headroom.cli.install import _reconcile_tool_envs
|
|
|
|
_reconcile_tool_envs(manifest) # bring it fully up to date first
|
|
|
|
monkeypatch.setattr("headroom.cli.install.load_manifest", lambda profile: manifest)
|
|
monkeypatch.setattr("headroom.cli.install.probe_ready", lambda url: True)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.apply_mutations", lambda m: applied.append("apply") or []
|
|
)
|
|
monkeypatch.setattr("headroom.cli.install.save_manifest", lambda m: None)
|
|
monkeypatch.setattr("headroom.cli.install.start_supervisor", lambda m: None)
|
|
monkeypatch.setattr(
|
|
"headroom.cli.install.wait_ready", lambda m, timeout_seconds=None, **kwargs: True
|
|
)
|
|
|
|
result = runner.invoke(main, ["install", "start"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert applied == []
|
|
|
|
|
|
@pytest.mark.parametrize("lifecycle", ["apply", "restart", "ensure"])
|
|
def test_opencode_reactivation_preserves_edits(
|
|
lifecycle: str, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
|
) -> None:
|
|
"""Reapply, restart, and watchdog recovery keep edits made after installation."""
|
|
import contextlib
|
|
|
|
from headroom.install.providers import apply_mutations
|
|
|
|
monkeypatch.setenv("OPENCODE_CONFIG", str(tmp_path / "opencode.json"))
|
|
config_file = tmp_path / "opencode.json"
|
|
original = {"theme": "original", "mcp": {"local": {}}}
|
|
config_file.write_text(json.dumps(original))
|
|
previous = DeploymentManifest(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="none",
|
|
scope="provider",
|
|
provider_mode="manual",
|
|
targets=["opencode"],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
apply_mutations(previous)
|
|
|
|
edited = json.loads(config_file.read_text())
|
|
edited["theme"] = "edited after install"
|
|
edited["provider"] = {"other": {"name": "User provider"}}
|
|
edited["mcp"]["remote"] = {"url": "https://example.test"}
|
|
config_file.write_text(json.dumps(edited))
|
|
|
|
monkeypatch.setattr(inst, "_save_apply_manifest", lambda manifest: None)
|
|
monkeypatch.setattr(inst, "save_manifest", lambda manifest: None)
|
|
monkeypatch.setattr(inst, "load_manifest", lambda profile: previous)
|
|
monkeypatch.setattr(inst, "_stop_deployment", lambda manifest: None)
|
|
monkeypatch.setattr(inst, "_start_deployment", lambda manifest, **kwargs: None)
|
|
monkeypatch.setattr(inst, "install_supervisor", lambda manifest, **kwargs: [])
|
|
monkeypatch.setattr(inst, "remove_supervisor", lambda manifest: None)
|
|
monkeypatch.setattr(inst, "delete_manifest", lambda profile: None)
|
|
|
|
if lifecycle == "apply":
|
|
monkeypatch.setattr(inst, "_save_recovery_snapshot", lambda *args: None)
|
|
monkeypatch.setattr(inst, "_delete_recovery_snapshot", lambda profile: None)
|
|
new = DeploymentManifest(
|
|
profile="default",
|
|
preset="persistent-service",
|
|
runtime_kind="python",
|
|
supervisor_kind="none",
|
|
scope="provider",
|
|
provider_mode="manual",
|
|
targets=["opencode"],
|
|
port=8787,
|
|
host="127.0.0.1",
|
|
backend="anthropic",
|
|
)
|
|
inst._apply_manifest(new)
|
|
elif lifecycle == "restart":
|
|
monkeypatch.setattr(inst, "probe_ready", lambda url: False)
|
|
result = CliRunner().invoke(main, ["install", "restart"])
|
|
assert result.exit_code == 0, result.output
|
|
else:
|
|
monkeypatch.setattr(inst, "runtime_status", lambda manifest: "running")
|
|
monkeypatch.setattr(inst, "probe_ready", lambda url: False)
|
|
monkeypatch.setattr(inst, "wait_ready", lambda *args, **kwargs: False)
|
|
monkeypatch.setattr(inst, "stop_runtime", lambda manifest: None)
|
|
monkeypatch.setattr(
|
|
inst, "acquire_runtime_start_lock", lambda profile: contextlib.nullcontext(True)
|
|
)
|
|
result = CliRunner().invoke(main, ["install", "agent", "ensure"])
|
|
assert result.exit_code == 0, result.output
|
|
|
|
actual = json.loads(config_file.read_text())
|
|
assert actual["theme"] == "edited after install"
|
|
assert actual["provider"]["other"] == {"name": "User provider"}
|
|
assert actual["provider"]["headroom"]["options"]["baseURL"] == ("http://127.0.0.1:8787/v1")
|
|
assert actual["mcp"]["remote"] == {"url": "https://example.test"}
|