Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
refactor: move install init logic into provider slices
JerrettDavis93a1f2113f17
diff --git a/headroom/install/planner.py b/headroom/install/planner.pyindex fad523036..3aac1b7b2 100644--- a/headroom/install/planner.py+++ b/headroom/install/planner.py@@ -8,6 +8,7 @@ from collections.abc import Iterableimport clickfrom headroom import paths as _paths+from headroom.providers.install_registry import build_install_target_envsfrom .models import (ConfigScope,@@ -95,44 +96,9 @@ def resolve_targets(return normalized-def _copilot_env(port: int, backend: str) -> dict[str, str]:- if backend == "anthropic":- return {- "COPILOT_PROVIDER_TYPE": "anthropic",- "COPILOT_PROVIDER_BASE_URL": f"http://127.0.0.1:{port}",- }- return {- "COPILOT_PROVIDER_TYPE": "openai",- "COPILOT_PROVIDER_BASE_URL": f"http://127.0.0.1:{port}/v1",- "COPILOT_PROVIDER_WIRE_API": "completions",- }--def build_tool_envs(port: int, backend: str, targets: list[str]) -> dict[str, dict[str, str]]:"""Build per-target environment variables for the selected tools."""-- target_envs: dict[str, dict[str, str]] = {}- if ToolTarget.CLAUDE.value in targets:- target_envs[ToolTarget.CLAUDE.value] = {- "ANTHROPIC_BASE_URL": f"http://127.0.0.1:{port}",- }- if ToolTarget.CODEX.value in targets:- target_envs[ToolTarget.CODEX.value] = {- "OPENAI_BASE_URL": f"http://127.0.0.1:{port}/v1",- }- if ToolTarget.AIDER.value in targets:- target_envs[ToolTarget.AIDER.value] = {- "OPENAI_API_BASE": f"http://127.0.0.1:{port}/v1",- "ANTHROPIC_BASE_URL": f"http://127.0.0.1:{port}",- }- if ToolTarget.COPILOT.value in targets:- target_envs[ToolTarget.COPILOT.value] = _copilot_env(port, backend)- if ToolTarget.CURSOR.value in targets:- target_envs[ToolTarget.CURSOR.value] = {- "OPENAI_BASE_URL": f"http://127.0.0.1:{port}/v1",- "ANTHROPIC_BASE_URL": f"http://127.0.0.1:{port}",- }- return target_envs+ return build_install_target_envs(port, backend, targets)def build_manifest(diff --git a/headroom/install/providers.py b/headroom/install/providers.pyindex 7dffae4a0..5c410d9ba 100644--- a/headroom/install/providers.py+++ b/headroom/install/providers.py@@ -2,23 +2,21 @@from __future__ import annotations-import jsonimport osimport reimport subprocessfrom pathlib import Path-import click+from headroom.providers.install_registry import (+ apply_provider_scope_mutations,+ revert_provider_scope_mutation,+)-from .models import ConfigScope, DeploymentManifest, ManagedMutation, ToolTarget+from .models import ConfigScope, DeploymentManifest, ManagedMutationfrom .paths import (- claude_settings_path,- codex_config_path,- openclaw_config_path,unix_system_env_targets,unix_user_env_targets,)-from .runtime import resolve_headroom_command_ENV_MARKER_START = "# >>> headroom persistent env >>>"_ENV_MARKER_END = "# <<< headroom persistent env <<<"@@ -26,12 +24,6 @@ _ENV_PATTERN = re.compile(re.escape(_ENV_MARKER_START) + r".*?" + re.escape(_ENV_MARKER_END),re.DOTALL,)-_CODEX_MARKER_START = "# --- Headroom persistent provider ---"-_CODEX_MARKER_END = "# --- end Headroom persistent provider ---"-_CODEX_PATTERN = re.compile(- re.escape(_CODEX_MARKER_START) + r".*?" + re.escape(_CODEX_MARKER_END),- re.DOTALL,-)def _merge_marker_block(file_path: Path, block: str, pattern: re.Pattern[str], marker: str) -> str:@@ -153,112 +145,6 @@ def _remove_windows_env_scope(mutations: list[ManagedMutation]) -> None:subprocess.run(command, check=True)-def _apply_claude_provider_scope(manifest: DeploymentManifest) -> ManagedMutation:- path = claude_settings_path()- path.parent.mkdir(parents=True, exist_ok=True)- payload: dict[str, object] = {}- if path.exists():- payload = json.loads(path.read_text())- env = payload.get("env")- env_map = dict(env) if isinstance(env, dict) else {}- previous = {- name: env_map.get(name) for name in manifest.tool_envs.get(ToolTarget.CLAUDE.value, {})- }- env_map.update(manifest.tool_envs[ToolTarget.CLAUDE.value])- payload["env"] = env_map- path.write_text(json.dumps(payload, indent=2) + "\n")- return ManagedMutation(- target=ToolTarget.CLAUDE.value,- kind="json-env",- path=str(path),- data={"previous": previous},- )---def _revert_claude_provider_scope(mutation: ManagedMutation, values: dict[str, str]) -> None:- if not mutation.path:- return- path = Path(mutation.path)- if not path.exists():- return- payload = json.loads(path.read_text())- env = payload.get("env")- env_map = dict(env) if isinstance(env, dict) else {}- previous: dict[str, object] = mutation.data.get("previous", {})- for name in values:- if previous.get(name) is None:- env_map.pop(name, None)- else:- env_map[name] = previous[name]- payload["env"] = env_map- path.write_text(json.dumps(payload, indent=2) + "\n")---def _apply_codex_provider_scope(manifest: DeploymentManifest) -> ManagedMutation:- path = codex_config_path()- path.parent.mkdir(parents=True, exist_ok=True)- section = (- f"{_CODEX_MARKER_START}\n"- 'model_provider = "headroom"\n\n'- "[model_providers.headroom]\n"- 'name = "Headroom persistent proxy"\n'- f'base_url = "http://127.0.0.1:{manifest.port}/v1"\n'- 'env_key = "OPENAI_API_KEY"\n'- "requires_openai_auth = true\n"- "supports_websockets = true\n"- f"{_CODEX_MARKER_END}\n"- )- merged = _merge_marker_block(path, section, _CODEX_PATTERN, _CODEX_MARKER_START)- path.write_text(merged)- return ManagedMutation(target=ToolTarget.CODEX.value, kind="toml-block", path=str(path))---def _revert_codex_provider_scope(mutation: ManagedMutation) -> None:- if not mutation.path:- return- path = Path(mutation.path)- if not path.exists():- return- content = path.read_text()- if _CODEX_MARKER_START not in content:- return- path.write_text(_CODEX_PATTERN.sub("", content).strip() + "\n")---def _invoke_openclaw(command: list[str]) -> None:- subprocess.run(command, check=True)---def _apply_openclaw_provider_scope(manifest: DeploymentManifest) -> ManagedMutation:- if not shutil_which("openclaw"):- raise click.ClickException("openclaw not found in PATH; cannot apply provider scope.")- command = [- *resolve_headroom_command(),- "wrap",- "openclaw",- "--no-auto-start",- "--proxy-port",- str(manifest.port),- ]- _invoke_openclaw(command)- return ManagedMutation(- target=ToolTarget.OPENCLAW.value, kind="openclaw-wrap", path=str(openclaw_config_path())- )---def _revert_openclaw_provider_scope() -> None:- if not shutil_which("openclaw"):- return- command = [*resolve_headroom_command(), "unwrap", "openclaw"]- _invoke_openclaw(command)---def shutil_which(name: str) -> str | None:- from shutil import which-- return which(name)--def apply_mutations(manifest: DeploymentManifest) -> list[ManagedMutation]:"""Apply provider/user/system configuration for a deployment."""@@ -268,17 +154,10 @@ def apply_mutations(manifest: DeploymentManifest) -> list[ManagedMutation]:mutations.extend(_apply_windows_env_scope(manifest))else:mutations.extend(_apply_unix_env_scope(manifest))- if ToolTarget.OPENCLAW.value in manifest.targets:- mutations.append(_apply_openclaw_provider_scope(manifest))+ mutations.extend(apply_provider_scope_mutations(manifest))return mutations- if ToolTarget.CLAUDE.value in manifest.targets:- mutations.append(_apply_claude_provider_scope(manifest))- if ToolTarget.CODEX.value in manifest.targets:- mutations.append(_apply_codex_provider_scope(manifest))- if ToolTarget.OPENCLAW.value in manifest.targets:- mutations.append(_apply_openclaw_provider_scope(manifest))- return mutations+ return [*mutations, *apply_provider_scope_mutations(manifest)]def revert_mutations(manifest: DeploymentManifest) -> None:@@ -292,11 +171,4 @@ def revert_mutations(manifest: DeploymentManifest) -> None:_remove_unix_env_scope(shell_mutations)for mutation in manifest.mutations:- if mutation.target == ToolTarget.CLAUDE.value and mutation.kind == "json-env":- _revert_claude_provider_scope(- mutation, manifest.tool_envs.get(ToolTarget.CLAUDE.value, {})- )- elif mutation.target == ToolTarget.CODEX.value and mutation.kind == "toml-block":- _revert_codex_provider_scope(mutation)- elif mutation.target == ToolTarget.OPENCLAW.value and mutation.kind == "openclaw-wrap":- _revert_openclaw_provider_scope()+ revert_provider_scope_mutation(manifest, mutation)diff --git a/headroom/providers/aider/install.py b/headroom/providers/aider/install.pynew file mode 100644index 000000000..ceb326129--- /dev/null+++ b/headroom/providers/aider/install.py@@ -0,0 +1,12 @@+"""Aider install-time helpers."""++from __future__ import annotations++from .runtime import build_launch_env+++def build_install_env(*, port: int, backend: str) -> dict[str, str]:+ """Build the persistent install environment for Aider."""+ del backend+ env, _lines = build_launch_env(port=port, environ={})+ return {key: env[key] for key in ("OPENAI_API_BASE", "ANTHROPIC_BASE_URL")}diff --git a/headroom/providers/claude/install.py b/headroom/providers/claude/install.pynew file mode 100644index 000000000..db5d03059--- /dev/null+++ b/headroom/providers/claude/install.py@@ -0,0 +1,63 @@+"""Claude install-time helpers."""++from __future__ import annotations++import json+from pathlib import Path++from headroom.install.models import ConfigScope, DeploymentManifest, ManagedMutation, ToolTarget+from headroom.install.paths import claude_settings_path++from .runtime import proxy_base_url+++def build_install_env(*, port: int, backend: str) -> dict[str, str]:+ """Build the persistent install environment for Claude."""+ del backend+ return {"ANTHROPIC_BASE_URL": proxy_base_url(port)}+++def apply_provider_scope(manifest: DeploymentManifest) -> ManagedMutation | None:+ """Apply Claude provider-scope configuration when requested."""+ if manifest.scope != ConfigScope.PROVIDER.value:+ return None++ path = claude_settings_path()+ path.parent.mkdir(parents=True, exist_ok=True)+ payload: dict[str, object] = {}+ if path.exists():+ payload = json.loads(path.read_text())+ env = payload.get("env")+ env_map = dict(env) if isinstance(env, dict) else {}+ values = manifest.tool_envs.get(ToolTarget.CLAUDE.value, {})+ previous = {name: env_map.get(name) for name in values}+ env_map.update(values)+ payload["env"] = env_map+ path.write_text(json.dumps(payload, indent=2) + "\n")+ return ManagedMutation(+ target=ToolTarget.CLAUDE.value,+ kind="json-env",+ path=str(path),+ data={"previous": previous},+ )+++def revert_provider_scope(mutation: ManagedMutation, manifest: DeploymentManifest) -> None:+ """Revert Claude provider-scope configuration."""+ if not mutation.path:+ return+ path = Path(mutation.path)+ if not path.exists():+ return+ payload = json.loads(path.read_text())+ env = payload.get("env")+ env_map = dict(env) if isinstance(env, dict) else {}+ previous: dict[str, object] = mutation.data.get("previous", {})+ values = manifest.tool_envs.get(ToolTarget.CLAUDE.value, {})+ for name in values:+ if previous.get(name) is None:+ env_map.pop(name, None)+ else:+ env_map[name] = previous[name]+ payload["env"] = env_map+ path.write_text(json.dumps(payload, indent=2) + "\n")diff --git a/headroom/providers/codex/install.py b/headroom/providers/codex/install.pynew file mode 100644index 000000000..0bdbbbc20--- /dev/null+++ b/headroom/providers/codex/install.py@@ -0,0 +1,68 @@+"""Codex install-time helpers."""++from __future__ import annotations++import re+from pathlib import Path++from headroom.install.models import ConfigScope, DeploymentManifest, ManagedMutation, ToolTarget+from headroom.install.paths import codex_config_path++from .runtime import proxy_base_url++_CODEX_MARKER_START = "# --- Headroom persistent provider ---"+_CODEX_MARKER_END = "# --- end Headroom persistent provider ---"+_CODEX_PATTERN = re.compile(+ re.escape(_CODEX_MARKER_START) + r".*?" + re.escape(_CODEX_MARKER_END),+ re.DOTALL,+)+++def build_install_env(*, port: int, backend: str) -> dict[str, str]:+ """Build the persistent install environment for Codex."""+ del backend+ return {"OPENAI_BASE_URL": proxy_base_url(port)}+++def apply_provider_scope(manifest: DeploymentManifest) -> ManagedMutation | None:+ """Apply Codex provider-scope configuration when requested."""+ if manifest.scope != ConfigScope.PROVIDER.value:+ return None++ path = codex_config_path()+ path.parent.mkdir(parents=True, exist_ok=True)+ section = (+ f"{_CODEX_MARKER_START}\n"+ 'model_provider = "headroom"\n\n'+ "[model_providers.headroom]\n"+ 'name = "Headroom persistent proxy"\n'+ f'base_url = "{proxy_base_url(manifest.port)}"\n'+ 'env_key = "OPENAI_API_KEY"\n'+ "requires_openai_auth = true\n"+ "supports_websockets = true\n"+ f"{_CODEX_MARKER_END}\n"+ )+ if path.exists():+ existing = path.read_text()+ if _CODEX_MARKER_START in existing:+ merged = _CODEX_PATTERN.sub(section, existing)+ else:+ merged = existing.rstrip() + "\n\n" + section + "\n"+ else:+ merged = section + "\n"+ path.write_text(merged)+ return ManagedMutation(target=ToolTarget.CODEX.value, kind="toml-block", path=str(path))+++def revert_provider_scope(mutation: ManagedMutation, manifest: DeploymentManifest) -> None:+ """Revert Codex provider-scope configuration."""+ del manifest+ if not mutation.path:+ return+ path = Path(mutation.path)+ if not path.exists():+ return+ content = path.read_text()+ if _CODEX_MARKER_START not in content:+ return+ path.write_text(_CODEX_PATTERN.sub("", content).strip() + "\n")diff --git a/headroom/providers/copilot/install.py b/headroom/providers/copilot/install.pynew file mode 100644index 000000000..5b0df8e32--- /dev/null+++ b/headroom/providers/copilot/install.py@@ -0,0 +1,25 @@+"""Copilot install-time helpers."""++from __future__ import annotations++from .wrap import build_launch_env, resolve_provider_type+++def build_install_env(*, port: int, backend: str) -> dict[str, str]:+ """Build the persistent install environment for Copilot."""+ provider_type = resolve_provider_type(backend, "auto", {"HEADROOM_BACKEND": backend})+ env, _lines = build_launch_env(+ port=port,+ provider_type=provider_type,+ wire_api=None,+ environ={},+ )+ return {+ key: env[key]+ for key in (+ "COPILOT_PROVIDER_TYPE",+ "COPILOT_PROVIDER_BASE_URL",+ "COPILOT_PROVIDER_WIRE_API",+ )+ if key in env+ }diff --git a/headroom/providers/cursor/install.py b/headroom/providers/cursor/install.pynew file mode 100644index 000000000..6724f496f--- /dev/null+++ b/headroom/providers/cursor/install.py@@ -0,0 +1,15 @@+"""Cursor install-time helpers."""++from __future__ import annotations++from .runtime import build_proxy_targets+++def build_install_env(*, port: int, backend: str) -> dict[str, str]:+ """Build the persistent install environment for Cursor."""+ del backend+ targets = build_proxy_targets(port)+ return {+ "OPENAI_BASE_URL": targets.openai_base_url,+ "ANTHROPIC_BASE_URL": targets.anthropic_base_url,+ }diff --git a/headroom/providers/install_registry.py b/headroom/providers/install_registry.pynew file mode 100644index 000000000..416046655--- /dev/null+++ b/headroom/providers/install_registry.py@@ -0,0 +1,86 @@+"""Install-time provider registry helpers."""++from __future__ import annotations++from collections.abc import Callable++from headroom.install.models import DeploymentManifest, ManagedMutation+from headroom.providers.aider.install import build_install_env as _build_aider_install_env+from headroom.providers.claude.install import (+ apply_provider_scope as _apply_claude_provider_scope,+)+from headroom.providers.claude.install import (+ build_install_env as _build_claude_install_env,+)+from headroom.providers.claude.install import (+ revert_provider_scope as _revert_claude_provider_scope,+)+from headroom.providers.codex.install import (+ apply_provider_scope as _apply_codex_provider_scope,+)+from headroom.providers.codex.install import build_install_env as _build_codex_install_env+from headroom.providers.codex.install import (+ revert_provider_scope as _revert_codex_provider_scope,+)+from headroom.providers.copilot.install import (+ build_install_env as _build_copilot_install_env,+)+from headroom.providers.cursor.install import build_install_env as _build_cursor_install_env+from headroom.providers.openclaw.install import (+ apply_provider_scope as _apply_openclaw_provider_scope,+)+from headroom.providers.openclaw.install import (+ revert_provider_scope as _revert_openclaw_provider_scope,+)++_InstallEnvBuilder = Callable[..., dict[str, str]]+_ProviderScopeApplier = Callable[[DeploymentManifest], ManagedMutation | None]+_ProviderScopeReverter = Callable[[ManagedMutation, DeploymentManifest], None]++_ENV_BUILDERS: dict[str, _InstallEnvBuilder] = {+ "claude": _build_claude_install_env,+ "copilot": _build_copilot_install_env,+ "codex": _build_codex_install_env,+ "aider": _build_aider_install_env,+ "cursor": _build_cursor_install_env,+}++_PROVIDER_SCOPE_HANDLERS: dict[str, tuple[_ProviderScopeApplier, _ProviderScopeReverter]] = {+ "claude": (_apply_claude_provider_scope, _revert_claude_provider_scope),+ "codex": (_apply_codex_provider_scope, _revert_codex_provider_scope),+ "openclaw": (_apply_openclaw_provider_scope, _revert_openclaw_provider_scope),+}+++def build_install_target_envs(+ port: int, backend: str, targets: list[str]+) -> dict[str, dict[str, str]]:+ """Build per-target install environment values via provider slices."""+ target_envs: dict[str, dict[str, str]] = {}+ for target in targets:+ builder = _ENV_BUILDERS.get(target)+ if builder is None:+ continue+ target_envs[target] = builder(port=port, backend=backend)+ return target_envs+++def apply_provider_scope_mutations(manifest: DeploymentManifest) -> list[ManagedMutation]:+ """Apply provider-scope mutations owned by provider slices."""+ mutations: list[ManagedMutation] = []+ for target in manifest.targets:+ handlers = _PROVIDER_SCOPE_HANDLERS.get(target)+ if handlers is None:+ continue+ mutation = handlers[0](manifest)+ if mutation is not None:+ mutations.append(mutation)+ return mutations+++def revert_provider_scope_mutation(manifest: DeploymentManifest, mutation: ManagedMutation) -> None:+ """Revert a provider-scope mutation via the owning provider slice."""+ handlers = _PROVIDER_SCOPE_HANDLERS.get(mutation.target)+ if handlers is None:+ return+ handlers[1](mutation, manifest)diff --git a/headroom/providers/openclaw/install.py b/headroom/providers/openclaw/install.pynew file mode 100644index 000000000..e7e2b6f59--- /dev/null+++ b/headroom/providers/openclaw/install.py@@ -0,0 +1,50 @@+"""OpenClaw install-time helpers."""++from __future__ import annotations++import click++from headroom.install.models import DeploymentManifest, ManagedMutation, ToolTarget+from headroom.install.paths import openclaw_config_path+from headroom.install.runtime import resolve_headroom_command+++def shutil_which(name: str) -> str | None:+ from shutil import which++ return which(name)+++def _invoke_openclaw(command: list[str]) -> None:+ import subprocess++ subprocess.run(command, check=True)+++def apply_provider_scope(manifest: DeploymentManifest) -> ManagedMutation:+ """Configure OpenClaw to route through the persistent proxy."""+ if not shutil_which("openclaw"):+ raise click.ClickException("openclaw not found in PATH; cannot apply provider scope.")+ command = [+ *resolve_headroom_command(),+ "wrap",+ "openclaw",+ "--no-auto-start",+ "--proxy-port",+ str(manifest.port),+ ]+ _invoke_openclaw(command)+ return ManagedMutation(+ target=ToolTarget.OPENCLAW.value,+ kind="openclaw-wrap",+ path=str(openclaw_config_path()),+ )+++def revert_provider_scope(mutation: ManagedMutation, manifest: DeploymentManifest) -> None:+ """Undo OpenClaw persistent proxy configuration."""+ del mutation, manifest+ if not shutil_which("openclaw"):+ return+ command = [*resolve_headroom_command(), "unwrap", "openclaw"]+ _invoke_openclaw(command)diff --git a/tests/test_install/test_planner.py b/tests/test_install/test_planner.pyindex 0a672c78d..6a84369b1 100644--- a/tests/test_install/test_planner.py+++ b/tests/test_install/test_planner.py@@ -44,6 +44,41 @@ def test_build_manifest_for_persistent_docker_sets_expected_defaults() -> None:assert "--memory" in manifest.proxy_args+def test_build_manifest_uses_provider_slice_env_builders_for_all_supported_targets() -> None:+ manifest = build_manifest(+ profile="default",+ preset=InstallPreset.PERSISTENT_SERVICE.value,+ runtime_kind="python",+ scope="user",+ provider_mode="manual",+ targets=["claude", "copilot", "codex", "aider", "cursor"],+ port=9999,+ backend="anyllm",+ anyllm_provider="groq",+ region=None,+ proxy_mode="token",+ memory_enabled=False,+ telemetry_enabled=True,+ image="ghcr.io/chopratejas/headroom:latest",+ )++ assert manifest.tool_envs["claude"]["ANTHROPIC_BASE_URL"] == "http://127.0.0.1:9999"+ assert manifest.tool_envs["codex"]["OPENAI_BASE_URL"] == "http://127.0.0.1:9999/v1"+ assert manifest.tool_envs["aider"] == {+ "OPENAI_API_BASE": "http://127.0.0.1:9999/v1",+ "ANTHROPIC_BASE_URL": "http://127.0.0.1:9999",+ }+ assert manifest.tool_envs["cursor"] == {+ "OPENAI_BASE_URL": "http://127.0.0.1:9999/v1",+ "ANTHROPIC_BASE_URL": "http://127.0.0.1:9999",+ }+ assert manifest.tool_envs["copilot"] == {+ "COPILOT_PROVIDER_TYPE": "openai",+ "COPILOT_PROVIDER_BASE_URL": "http://127.0.0.1:9999/v1",+ "COPILOT_PROVIDER_WIRE_API": "completions",+ }++def test_resolve_targets_provider_scope_auto_excludes_copilot(monkeypatch) -> None:monkeypatch.setattr("headroom.install.planner.detect_targets", lambda: [])diff --git a/tests/test_install/test_providers.py b/tests/test_install/test_providers.pyindex 40350c3ce..9c10f29a8 100644--- a/tests/test_install/test_providers.py+++ b/tests/test_install/test_providers.py@@ -1,17 +1,15 @@from __future__ import annotationsimport json+import osfrom pathlib import Pathfrom headroom.install.models import DeploymentManifest, ManagedMutation-from headroom.install.providers import (- _apply_claude_provider_scope,- _apply_codex_provider_scope,- _apply_windows_env_scope,- _remove_windows_env_scope,- _revert_claude_provider_scope,- _revert_codex_provider_scope,-)+from headroom.install.providers import _apply_windows_env_scope, _remove_windows_env_scope+from headroom.providers.claude.install import apply_provider_scope as apply_claude_provider_scope+from headroom.providers.claude.install import revert_provider_scope as revert_claude_provider_scope+from headroom.providers.codex.install import apply_provider_scope as apply_codex_provider_scope+from headroom.providers.codex.install import revert_provider_scope as revert_codex_provider_scopedef _manifest(tmp_path: Path) -> DeploymentManifest:@@ -39,15 +37,18 @@ def test_apply_and_revert_claude_provider_scope(monkeypatch, tmp_path: Path) ->settings_path.write_text(json.dumps({"env": {"ANTHROPIC_API_KEY": "keep", "ANTHROPIC_BASE_URL": "https://old"}}))- monkeypatch.setattr("headroom.install.providers.claude_settings_path", lambda: settings_path)+ monkeypatch.setattr(+ "headroom.providers.claude.install.claude_settings_path", lambda: settings_path+ )manifest = _manifest(tmp_path)- mutation = _apply_claude_provider_scope(manifest)+ mutation = apply_claude_provider_scope(manifest)payload = json.loads(settings_path.read_text())assert payload["env"]["ANTHROPIC_BASE_URL"] == "http://127.0.0.1:8787"assert payload["env"]["ANTHROPIC_API_KEY"] == "keep"- _revert_claude_provider_scope(mutation, manifest.tool_envs["claude"])+ assert mutation is not None+ revert_claude_provider_scope(mutation, manifest)reverted = json.loads(settings_path.read_text())assert reverted["env"]["ANTHROPIC_BASE_URL"] == "https://old"assert reverted["env"]["ANTHROPIC_API_KEY"] == "keep"@@ -56,15 +57,16 @@ def test_apply_and_revert_claude_provider_scope(monkeypatch, tmp_path: Path) ->def test_apply_and_revert_codex_provider_scope(monkeypatch, tmp_path: Path) -> None:config_path = tmp_path / "config.toml"config_path.write_text('model = "gpt-4o"\n')- monkeypatch.setattr("headroom.install.providers.codex_config_path", lambda: config_path)+ monkeypatch.setattr("headroom.providers.codex.install.codex_config_path", lambda: config_path)manifest = _manifest(tmp_path)- mutation = _apply_codex_provider_scope(manifest)+ mutation = apply_codex_provider_scope(manifest)content = config_path.read_text()assert 'model_provider = "headroom"' in contentassert 'base_url = "http://127.0.0.1:8787/v1"' in content- _revert_codex_provider_scope(mutation)+ assert mutation is not None+ revert_codex_provider_scope(mutation, manifest)reverted = config_path.read_text()assert 'model_provider = "headroom"' not in revertedassert reverted.strip() == 'model = "gpt-4o"'@@ -72,25 +74,27 @@ def test_apply_and_revert_codex_provider_scope(monkeypatch, tmp_path: Path) -> Ndef test_apply_openclaw_provider_scope_uses_manifest_port(monkeypatch, tmp_path: Path) -> None:recorded: list[list[str]] = []- monkeypatch.setattr("headroom.install.providers.shutil_which", lambda name: "openclaw")+ monkeypatch.setattr("headroom.providers.openclaw.install.shutil_which", lambda name: "openclaw")monkeypatch.setattr(- "headroom.install.providers.resolve_headroom_command",+ "headroom.providers.openclaw.install.resolve_headroom_command",lambda: ["headroom"],)monkeypatch.setattr(- "headroom.install.providers._invoke_openclaw",+ "headroom.providers.openclaw.install._invoke_openclaw",lambda command: recorded.append(command),)monkeypatch.setattr(- "headroom.install.providers.openclaw_config_path",+ "headroom.providers.openclaw.install.openclaw_config_path",lambda: tmp_path / "openclaw.json",)manifest = _manifest(tmp_path)manifest.port = 9999- from headroom.install.providers import _apply_openclaw_provider_scope+ from headroom.providers.openclaw.install import (+ apply_provider_scope as apply_openclaw_provider_scope,+ )- _apply_openclaw_provider_scope(manifest)+ apply_openclaw_provider_scope(manifest)assert recorded == [["headroom", "wrap", "openclaw", "--no-auto-start", "--proxy-port", "9999"]]@@ -165,11 +169,17 @@ def test_apply_mutations_runs_openclaw_for_user_scope(monkeypatch, tmp_path: Patmanifest.base_env = {"HEADROOM_PORT": "8787"}manifest.tool_envs = {}- monkeypatch.setattr("headroom.install.providers.os.name", "posix")- monkeypatch.setattr("headroom.install.providers._apply_unix_env_scope", lambda deployment: [])+ if os.name == "nt":+ monkeypatch.setattr(+ "headroom.install.providers._apply_windows_env_scope", lambda deployment: []+ )+ else:+ monkeypatch.setattr(+ "headroom.install.providers._apply_unix_env_scope", lambda deployment: []+ )monkeypatch.setattr(- "headroom.install.providers._apply_openclaw_provider_scope",- lambda deployment: ManagedMutation(target="openclaw", kind="openclaw-wrap"),+ "headroom.install.providers.apply_provider_scope_mutations",+ lambda deployment: [ManagedMutation(target="openclaw", kind="openclaw-wrap")],)from headroom.install.providers import apply_mutations