The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""An "Always" approval inside a frozen managed worker reaches config.yaml.
A fresh profile has no ``command_allowlist`` in the live file. An ordinary worker's
snapshot does not have it either. A safe-mode or ``--ignore-user-config`` worker
freezes a copy of the schema, so the snapshot does contain ``command_allowlist: []``.
Neither is an operator deletion: the list exists only because the schema default
was merged in, and the grant must be written. An explicit empty list the operator
put in an ordinary snapshot and then removed stays removed.
Ordinary path: ``build_policy`` on the raw file, then ``_worker_config``, bound with
``_bind_worker_config``. Bypass path: ``_bypass_policy`` then ``_worker_config``, bound
with ``_bind_safe_worker_policy`` the way the worker bootstrap binds it. Always goes
through ``tools.approval._persist_choice``.
"""
import json
import subprocess
import sys
import textwrap
from pathlib import Path
from types import SimpleNamespace
import pytest
ROOT = Path(__file__).resolve().parents[2]
KEY = "recursive delete"
def _snapshot(home, monkeypatch):
monkeypatch.setenv("HERMES_HOME", str(home))
from gateway.run import _load_gateway_config
from gateway.session_managed_worker import _worker_config
from gateway.session_policy import build_policy
policy = build_policy({"source": "cli", "cwd": str(home)}, _load_gateway_config(home / "config.yaml"))
return _worker_config(SimpleNamespace(profile_id=str(home)), policy)
def _bypass_snapshot(home, monkeypatch, *, safe_mode):
monkeypatch.setenv("HERMES_HOME", str(home))
from gateway.session_local import _bypass_policy
from gateway.session_managed_worker import _worker_config
params = {"source": "cli", "cwd": str(home), "model": "m"}
if safe_mode:
params["safe_mode"] = True
else:
params["ignore_user_config"] = True
policy = _bypass_policy(params, private_secrets={})
return _worker_config(SimpleNamespace(profile_id=str(home)), policy)
def _always_in_worker(tmp_path, monkeypatch, live_yaml, bind=True, *, safe_mode=False, action="always"):
home = tmp_path / "home"
home.mkdir()
(home / "config.yaml").write_text(live_yaml, encoding="utf-8")
if bind == "bypass":
snapshot = _bypass_snapshot(home, monkeypatch, safe_mode=safe_mode)
bind_mode = "bypass"
elif bind:
snapshot = _snapshot(home, monkeypatch)
bind_mode = "worker"
else:
snapshot = None
bind_mode = "off"
script = tmp_path / "grant.py"
script.write_text(
f"import sys; sys.path.insert(0, {str(ROOT)!r})\n" + textwrap.dedent(
"""
import json, os
snap = json.loads(os.environ["GRANT_SNAPSHOT"])
mode = os.environ["GRANT_BIND"]
if mode == "bypass":
from agent.safe_worker_policy import _bind_safe_worker_policy
_bind_safe_worker_policy(
safe_mode=os.environ["GRANT_SAFE"] == "1",
ignore_user_config=True,
config=snap,
)
elif mode == "worker":
from agent.safe_worker_policy import _bind_worker_config
_bind_worker_config(snap)
if os.environ["GRANT_ACTION"] == "approvals":
from hermes_cli.config import load_config, save_config
cfg = load_config()
cfg["approvals"]["mode"] = "off"
save_config(cfg)
print(json.dumps({"ok": True}))
else:
from tools import approval
approval._persist_choice("route-1", "always", [os.environ["GRANT_KEY"]])
print(json.dumps({"in_memory": approval._is_permanently_approved(os.environ["GRANT_KEY"])}))
"""
),
encoding="utf-8",
)
from tests.gateway.fixtures.local_recovery_probe import child_env
env = child_env()
env.update(
HOME=str(home), USERPROFILE=str(home), HERMES_HOME=str(home), GRANT_KEY=KEY,
GRANT_SNAPSHOT=json.dumps(snapshot), GRANT_BIND=bind_mode,
GRANT_SAFE="1" if safe_mode else "0", GRANT_ACTION=action,
HERMES_DISABLE_LAZY_INSTALLS="1",
)
proc = subprocess.run(
[sys.executable, str(script)], cwd=ROOT, env=env, stdin=subprocess.DEVNULL,
capture_output=True, text=True, timeout=90, check=False,
)
assert proc.returncode == 0, proc.stdout + proc.stderr
import hermes_yaml
on_disk = hermes_yaml.safe_load((home / "config.yaml").read_text(encoding="utf-8")) or {}
return json.loads(proc.stdout.strip().splitlines()[-1]), on_disk, snapshot
def _assert_saved(on_disk, allowlist):
assert on_disk.get("model", {}).get("default") == "m"
assert on_disk.get("command_allowlist") == allowlist, on_disk
assert set(on_disk) <= {"model", "command_allowlist", "_config_version"}, on_disk
def test_first_always_in_frozen_worker_persists(tmp_path, monkeypatch):
receipt, on_disk, snapshot = _always_in_worker(tmp_path, monkeypatch, "model:\n default: m\n")
assert "command_allowlist" not in snapshot, snapshot
assert receipt["in_memory"] is True
_assert_saved(on_disk, [KEY])
@pytest.mark.parametrize(
"live_yaml, bind, expected",
[
("model:\n default: m\ncommand_allowlist: []\n", True, [KEY]),
("model:\n default: m\ncommand_allowlist:\n- other\n", True, ["other", KEY]),
("model:\n default: m\n", False, [KEY]),
],
ids=["explicit-empty", "existing-list", "in-process"],
)
def test_controls_persist(tmp_path, monkeypatch, live_yaml, bind, expected):
receipt, on_disk, _ = _always_in_worker(tmp_path, monkeypatch, live_yaml, bind=bind)
assert receipt["in_memory"] is True
_assert_saved(on_disk, expected)
def _bind_snapshot(monkeypatch, snapshot):
import copy
from hermes_cli import config as cfg
monkeypatch.setattr(cfg, "_worker_config_snapshot", lambda: copy.deepcopy(snapshot))
return cfg
def test_rebase_applies_an_edit_to_a_default_only_list(monkeypatch):
from hermes_cli.config_worker_save import rebase_for_save
snapshot = {"model": {"default": "m"}}
cfg = _bind_snapshot(monkeypatch, snapshot)
desired = cfg.load_config()
desired["command_allowlist"] = ["recursive delete"]
saved = rebase_for_save(desired, {"model": {"default": "m"}}, False)
assert saved["command_allowlist"] == ["recursive delete"]
def test_rebase_keeps_a_list_the_snapshot_carried_and_the_operator_deleted(monkeypatch):
from hermes_cli.config_worker_save import rebase_for_save
snapshot = {"model": {"default": "m"}, "command_allowlist": ["a *"]}
cfg = _bind_snapshot(monkeypatch, snapshot)
desired = cfg.load_config()
desired["command_allowlist"] = ["a *", "b *"]
saved = rebase_for_save(desired, {"model": {"default": "m"}}, False)
assert "command_allowlist" not in saved
def test_rebase_applies_an_edit_to_a_default_only_mapping(monkeypatch):
import copy
from hermes_cli.config_worker_save import rebase_for_save
snapshot = {"model": {"default": "m"}}
cfg = _bind_snapshot(monkeypatch, snapshot)
base = cfg.load_config()
desired = copy.deepcopy(base)
desired["approvals"]["mode"] = "off"
saved = rebase_for_save(desired, {"model": {"default": "m"}}, False)
expected = copy.deepcopy(base["approvals"])
expected["mode"] = "off"
assert saved["approvals"] == expected
assert saved["model"] == {"default": "m"}
assert set(saved) == {"model", "approvals"}
def test_rebase_keeps_a_mapping_the_snapshot_carried_and_the_operator_deleted(monkeypatch):
from hermes_cli.config_worker_save import rebase_for_save
snapshot = {"model": {"default": "m"}, "approvals": {"mode": "manual"}}
cfg = _bind_snapshot(monkeypatch, snapshot)
desired = cfg.load_config()
desired["approvals"]["mode"] = "off"
saved = rebase_for_save(desired, {"model": {"default": "m"}}, False)
assert "approvals" not in saved
def test_rebase_applies_an_edit_to_a_nested_default_only_list(monkeypatch):
from hermes_cli.config_worker_save import rebase_for_save
# The parent is in the snapshot and the live file. ``deny`` is not: it comes
# only from the schema defaults under that parent.
snapshot = {"model": {"default": "m"}, "approvals": {"mode": "manual"}}
live = {"model": {"default": "m"}, "approvals": {"mode": "manual"}}
cfg = _bind_snapshot(monkeypatch, snapshot)
desired = cfg.load_config()
desired["approvals"]["deny"] = ["rm -rf"]
saved = rebase_for_save(desired, live, False)
assert saved["approvals"] == {"mode": "manual", "deny": ["rm -rf"]}
_BYPASS_FRESH = "model:\n default: m\ndisplay:\n skin: mono\n"
def _assert_kept(on_disk, **extra):
assert on_disk.get("model") == {"default": "m"}, on_disk
assert on_disk.get("display") == {"skin": "mono"}, on_disk
for key, value in extra.items():
assert on_disk.get(key) == value, on_disk
assert set(on_disk) <= {"model", "display", "_config_version", *extra}, on_disk
@pytest.mark.parametrize("safe_mode", [True, False], ids=["safe-mode", "ignore-user-config"])
def test_first_always_in_bypass_worker_persists(tmp_path, monkeypatch, safe_mode):
receipt, on_disk, snapshot = _always_in_worker(
tmp_path, monkeypatch, _BYPASS_FRESH, bind="bypass", safe_mode=safe_mode,
)
assert snapshot.get("command_allowlist") == []
assert receipt["in_memory"] is True
_assert_kept(on_disk, command_allowlist=[KEY])
@pytest.mark.parametrize("safe_mode", [True, False], ids=["safe-mode", "ignore-user-config"])
def test_bypass_worker_persists_a_default_only_mapping_edit(tmp_path, monkeypatch, safe_mode):
receipt, on_disk, snapshot = _always_in_worker(
tmp_path, monkeypatch, _BYPASS_FRESH, bind="bypass", safe_mode=safe_mode, action="approvals",
)
assert snapshot.get("approvals", {}).get("mode") == "smart"
assert receipt == {"ok": True}
_assert_kept(on_disk, approvals={"mode": "off"})
def test_bypass_worker_keeps_an_existing_allowlist_and_unrelated_keys(tmp_path, monkeypatch):
receipt, on_disk, snapshot = _always_in_worker(
tmp_path, monkeypatch, _BYPASS_FRESH + "command_allowlist:\n- other\n",
bind="bypass", safe_mode=True,
)
assert snapshot.get("command_allowlist") == []
assert receipt["in_memory"] is True
_assert_kept(on_disk, command_allowlist=["other", KEY])
def test_rebase_keeps_an_explicit_empty_list_the_operator_deleted(monkeypatch):
from hermes_cli.config_worker_save import rebase_for_save
snapshot = {"model": {"default": "m"}, "command_allowlist": []}
cfg = _bind_snapshot(monkeypatch, snapshot)
desired = cfg.load_config()
desired["command_allowlist"] = ["recursive delete"]
saved = rebase_for_save(desired, {"model": {"default": "m"}}, False)
assert "command_allowlist" not in saved
def test_rebase_keeps_a_nested_list_the_snapshot_carried_and_the_operator_deleted(monkeypatch):
from hermes_cli.config_worker_save import rebase_for_save
snapshot = {"model": {"default": "m"}, "approvals": {"mode": "manual", "deny": ["old"]}}
live = {"model": {"default": "m"}, "approvals": {"mode": "manual"}}
cfg = _bind_snapshot(monkeypatch, snapshot)
desired = cfg.load_config()
desired["approvals"]["deny"] = ["old", "new"]
saved = rebase_for_save(desired, live, False)
assert saved["approvals"] == {"mode": "manual"}