The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
fix(config-remote): review round 9b: guard reads keep the caller's read base, dashboard model saves mask inherited route keys, MCP ack checks every toggle field
Ben Barclayb8a41f7bf22e
diff --git a/hermes_cli/config.py b/hermes_cli/config.pyindex 48027c52471..590b7ca1da0 100644--- a/hermes_cli/config.py+++ b/hermes_cli/config.py@@ -1972,7 +1972,10 @@ def _write_config_state("""Shared comment-preserving config writer; omission policy is selected by the public wrapper."""_refuse_failed_read(config_path, data)if not allow_omissions:- existing = require_readable_config_before_write(config_path)+ # A guard read, not the caller's read: *data* came from the caller's own earlier read, so a+ # Remote Config save must still be diffed against THAT read, not a poll that landed since.+ from hermes_cli.config_backend import keeping_read_base+ existing = keeping_read_base(lambda: require_readable_config_before_write(config_path))omitted = _omitted_config_paths(existing, data)if omitted:shown = ", ".join(omitted[:12])diff --git a/hermes_cli/model_switch.py b/hermes_cli/model_switch.pyindex 85fccf3d0a9..3a8d5c36808 100644--- a/hermes_cli/model_switch.py+++ b/hermes_cli/model_switch.py@@ -1829,22 +1829,52 @@ def selection_route_changed(model_cfg: dict, result: ModelSwitchResult) -> bool:return normalize_route_base_url(model_cfg.get("base_url")) != normalize_route_base_url(result.base_url)-def apply_model_selection(model_cfg: Any, result: ModelSwitchResult) -> dict:+def apply_model_selection(model_cfg: Any, result: ModelSwitchResult, *, mask_cleared: bool = False) -> dict:"""Apply the canonical shape to an in-memory ``model:`` dict (``None`` = key removed) for- callers that save a whole config document they are already mutating."""- return _merge_selection_updates(model_cfg, model_selection_config_updates(result, model_cfg))+ callers that save a whole config document they are already mutating.+ ``mask_cleared``: a key the switch clears that *model_cfg* holds is set to ``None`` instead of+ removed. For a document saved to Remote Config, where *model_cfg* is the EFFECTIVE block and+ a removal only drops the profile override, so an upper level's old-endpoint ``api_key`` /+ ``key_env`` / ``context_length`` would still apply at the new endpoint (contract §5.4: a+ stored null is "no value"). The same rule :func:`persist_model_selection` applies."""+ return _merge_selection_updates(model_cfg, model_selection_config_updates(result, model_cfg),+ mask_cleared=mask_cleared)-def _merge_selection_updates(model_cfg: Any, updates: dict[str, Any]) -> dict:++def _merge_selection_updates(model_cfg: Any, updates: dict[str, Any], *, mask_cleared: bool = False) -> dict:model_cfg = dict(model_cfg) if isinstance(model_cfg, dict) else {}for key, value in updates.items():- if value is None:+ if value is None and not (mask_cleared and key in model_cfg):model_cfg.pop(key, None)else:model_cfg[key] = valuereturn model_cfg+def remote_model_selection_guard(before: Any, after: Any) -> None:+ """Remote Config: refuse a whole-document model assignment when any ``model.*`` key it+ changes is locked by an upper level. A bulk save omits a locked key instead of raising, which+ would land the rest of the route (a new endpoint with the old provider, say) half-applied;+ :func:`persist_model_selection` gets the same all-or-nothing refusal from its one keyed write.+ No-op for the file backend."""+ from hermes_cli.config_backend import ConfigLockedError, get_config_backend, supports_file_tooling+ if supports_file_tooling():+ return+ from hermes_constants import get_hermes_home+ before = before if isinstance(before, dict) else {}+ after = after if isinstance(after, dict) else {}+ backend, home = get_config_backend(), get_hermes_home()+ for key in sorted(set(before) | set(after)):+ if before.get(key, _MISSING) != after.get(key, _MISSING):+ level = backend.locked(home, f"model.{key}")+ if level:+ raise ConfigLockedError(f"model.{key}", level)+++_MISSING = object()++def persist_model_selection(result: ModelSwitchResult, config_path: Any = None) -> None:"""Write a successful :func:`switch_model` result to ``config_path`` (default:``HERMES_HOME/config.yaml`` — the context override or ``HERMES_HOME`` at call time).@@ -1874,9 +1904,10 @@ def persist_model_selection(result: ModelSwitchResult, config_path: Any = None)# still holds is therefore masked with null ("no value"); an absent one is just unset.from hermes_cli.config_backend import Changes, write_changesheld = planned_from if isinstance(planned_from, dict) else {}+ masked = _merge_selection_updates(held, updates, mask_cleared=True)write_changes(path, Changes(- set={f"model.{k}": v for k, v in updates.items() if v is not None or k in held},- unset=tuple(f"model.{k}" for k, v in updates.items() if v is None and k not in held)))+ set={f"model.{k}": masked[k] for k in updates if k in masked},+ unset=tuple(f"model.{k}" for k in updates if k not in masked)))returnwith _CONFIG_LOCK:config = read_user_config_raw(path)diff --git a/hermes_cli/web_server_config.py b/hermes_cli/web_server_config.pyindex ae7d509c286..139cea4b24b 100644--- a/hermes_cli/web_server_config.py+++ b/hermes_cli/web_server_config.py@@ -517,12 +517,17 @@ def _apply_main_model_assignment(model_cfg: Any, result: "ModelSwitchResult", apdropped so a stale secret cannot shadow it.Returns a new dict."""- from hermes_cli.model_switch import apply_model_selection+ from hermes_cli.config_backend import supports_file_tooling+ from hermes_cli.model_switch import apply_model_selection, remote_model_selection_guard- model_cfg = apply_model_selection(model_cfg, result)+ before = model_cfg+ # Remote Config: the caller saves the effective block as a whole document, so a cleared+ # inherited key must be masked (null), and a locked route key refuses the whole assignment.+ model_cfg = apply_model_selection(model_cfg, result, mask_cleared=not supports_file_tooling())if api_key.strip():model_cfg["api_key"] = api_key.strip()model_cfg.pop("api", None)+ remote_model_selection_guard(before, model_cfg)return model_cfgdiff --git a/tests/plugins/config_backends/test_remote_backend.py b/tests/plugins/config_backends/test_remote_backend.pyindex 6fc60932fae..e6b18371a02 100644--- a/tests/plugins/config_backends/test_remote_backend.py+++ b/tests/plugins/config_backends/test_remote_backend.py@@ -1701,3 +1701,68 @@ def test_model_switch_masks_inherited_endpoint_credentials(plane, monkeypatch):model = read_user_config_raw()["model"]assert model["base_url"] == "https://new.example/v1"assert all(model.get(k) is None for k in ("api_key", "key_env", "api_key_env", "context_length")), model+++def test_poll_between_read_and_atomic_config_write_sends_only_the_callers_edit(plane, monkeypatch):+ """Same schedule through ``atomic_config_write`` (``/verbose``, ``/footer``): its no-omission+ guard read must not become the base the caller's stale document is diffed against."""+ from gateway import slash_commands as sc+ plane.profile("default").update(values={"display": {"personality": "concise", "compact": False}}, version=1)+ backend = get_config_backend()+ orig = sc.atomic_config_write++ def poll_before_write(path, doc):+ p = plane.profile("default")+ p["values"]["display"]["compact"] = True+ p["version"] += 1+ assert backend.poll_one(backend._state(plane.home))+ return orig(path, doc)++ monkeypatch.setattr(sc, "atomic_config_write", poll_before_write)+ sc._write_raw_config_leaf(plane.home / "config.yaml", ("display", "personality"), "pirate")+ bodies = [r["body"] for r in plane.patches()]+ assert len(bodies) == 1 and bodies[0]["set"] == {"display.personality": "pirate"}, bodies+ assert plane.profile("default")["values"]["display"] == {"personality": "pirate", "compact": True}+++def _dashboard_switch(monkeypatch, url):+ import asyncio+ from hermes_cli.model_switch import ModelSwitchResult+ from hermes_cli.web_models import ModelAssignment+ from hermes_cli.web_routers import models+ result = ModelSwitchResult(success=True, new_model="new", target_provider="custom", provider_changed=True,+ base_url=url, api_mode="chat_completions", is_global=True)+ monkeypatch.setattr(models, "_dashboard_code_skew_guard", lambda: None)+ monkeypatch.setattr(models, "_prepare_main_assignment", lambda *a, **kw: (url, result))+ return asyncio.run(models.set_model_assignment(ModelAssignment(+ scope="main", provider="custom", model="new", base_url=url, confirm_expensive_model=True)))+++_OLD_ROUTE = {"default": "old", "provider": "custom:old", "base_url": "https://old.example/v1",+ "api_key": "${OLD_KEY}", "key_env": "OLD_KEY", "api_key_env": "OLD_KEY", "context_length": 123456}+++def test_dashboard_model_switch_masks_inherited_endpoint_credentials(plane, monkeypatch):+ """POST /api/model/set saves the whole document. Under Remote Config its model block is the+ effective one, so the endpoint-bound keys it clears must be masked (null), not dropped from+ the profile, or the old endpoint's key would reach the new endpoint."""+ from hermes_cli.config import read_user_config_raw+ url = "https://new.example/v1"+ plane.upper = {"model": dict(_OLD_ROUTE), "providers": {"known-new": {"base_url": url}}}+ assert _dashboard_switch(monkeypatch, url)["ok"] is True+ model = read_user_config_raw()["model"]+ assert model["base_url"] == url+ assert all(model.get(k) is None for k in ("api_key", "key_env", "api_key_env", "context_length")), model+++def test_dashboard_model_switch_refuses_whole_assignment_on_a_locked_route_key(plane, monkeypatch):+ """A lock on one route key refuses the dashboard assignment entirely (409/403), like+ persist_model_selection: nothing is sent, so the old route stays whole."""+ from fastapi import HTTPException+ url = "https://new.example/v1"+ plane.upper = {"model": dict(_OLD_ROUTE), "providers": {"known-new": {"base_url": url}}}+ plane.upper_locks = [{"path": "model.base_url", "level": "tenant"}]+ with pytest.raises(HTTPException) as exc:+ _dashboard_switch(monkeypatch, url)+ assert exc.value.status_code in (403, 409), exc.value+ assert plane.patches() == []diff --git a/tests/plugins/config_backends/test_remote_grouped_and_migration_reads.py b/tests/plugins/config_backends/test_remote_grouped_and_migration_reads.pyindex 5e898d5f59b..82ed95da580 100644--- a/tests/plugins/config_backends/test_remote_grouped_and_migration_reads.py+++ b/tests/plugins/config_backends/test_remote_grouped_and_migration_reads.py@@ -314,6 +314,53 @@ def test_migration_recursion_still_sees_its_private_copy(plane, monkeypatch):assert plane.patches() == []+class _Transport:+ def __init__(self):+ self.frames, self.done = [], threading.Event()++ def write(self, obj):+ self.frames.append(obj)+ self.done.set()+ return True++ def close(self):+ pass+++def _configure(server, rid, **params):+ import json+ t = _Transport()+ ret = server.dispatch({"jsonrpc": "2.0", "id": rid, "method": "profiles.configure",+ "params": {"name": "default", **params}}, t)+ if ret is not None:+ t.write(ret)+ assert t.done.wait(10), "no terminal response"+ return json.loads(json.dumps(t.frames[-1]))["result"]+++def test_profile_editor_reports_mcp_unapplied_when_legacy_disabled_cleanup_is_locked(plane, monkeypatch):+ """Enabling an MCP server writes ``enabled: true`` AND drops the legacy ``disabled``. When a+ lock keeps ``disabled: true``, the editor (which honours ``disabled``) still shows the server+ off, so the edit must not be acknowledged; unlocked, it lands and the editor agrees."""+ from hermes_cli.config import read_user_config_raw+ from tui_gateway.methods_profiles import _mcp_entry_enabled+ plane.upper = {"mcp_servers": {"example": {"command": "unused", "enabled": False}}}+ plane.profile("default")["values"] = {"mcp_servers": {"example": {"disabled": True}}}+ plane.upper_locks = [{"path": "mcp_servers.example.disabled", "level": "tenant"}]+ server = _tui_server(monkeypatch, plane.home)++ locked = _configure(server, 1, enabled_mcp_servers=["example"])+ assert locked["applied"]["mcp_servers"] is False and locked["ok"] is False, locked+ assert _mcp_entry_enabled(read_user_config_raw()["mcp_servers"]["example"]) is False++ plane.upper_locks = []+ backend = get_config_backend()+ backend.poll_one(backend._state(plane.home))+ unlocked = _configure(server, 2, enabled_mcp_servers=["example"])+ assert unlocked["applied"]["mcp_servers"] is True and unlocked["ok"] is True, unlocked+ assert _mcp_entry_enabled(read_user_config_raw()["mcp_servers"]["example"]) is True++def test_profile_editor_reports_a_locked_skills_edit_as_not_applied(plane, monkeypatch):"""``profiles.configure`` saves its sections through bulk ``save_config``, which omits aRemote Config lock instead of raising. The editor must report that section unapplied, notdiff --git a/tui_gateway/methods_profiles.py b/tui_gateway/methods_profiles.pyindex 22bc197973a..c5b1e649a82 100644--- a/tui_gateway/methods_profiles.py+++ b/tui_gateway/methods_profiles.py@@ -749,8 +749,19 @@ def _configure_cfg_sections(profile_dir, params, applied) -> None:mcp_cfg = load_config() or {}applied["mcp_servers"] = _best_effort(lambda: _save_mcp_toggles(mcp_cfg, params["enabled_mcp_servers"], launch_mcp, save_config)) \- and _landed(mcp_cfg, ("mcp_servers",), lambda v: {- k: e.get("enabled") for k, e in v.items() if isinstance(e, dict)} if isinstance(v, dict) else v)+ and _landed(mcp_cfg, ("mcp_servers",), _mcp_toggle_state)+++def _mcp_toggle_state(servers):+ """Every toggle field ``_save_mcp_toggles`` writes, per server: ``enabled`` AND the legacy+ ``disabled`` it removes. A lock that kept ``disabled: true`` leaves the server off for the+ editor (and on for the runtime) although ``enabled`` landed, so it must not read as applied."""+ if not isinstance(servers, dict):+ return servers+ return {k: (e.get("enabled"), e.get("disabled", _ABSENT)) for k, e in servers.items() if isinstance(e, dict)}+++_ABSENT = "<absent>"def _landed(cfg: dict, path: tuple, key=lambda v: v) -> bool: