The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Shared guards for historical exports; real child execution lives in test_old_updater_takeover."""
import builtins
from contextlib import contextmanager
import importlib
import importlib.util
import json
import os
from pathlib import Path
import socket
import subprocess
import sys
import urllib.request
import pytest
ROOT = Path(__file__).resolve().parents[2]
@pytest.fixture
def no_external_work(monkeypatch):
"""Reject old-parent installs, process control, downloads and module reloads."""
import pm
def forbidden(*args, **kwargs):
pytest.fail(f"old updater attempted work outside the fresh child: {args!r}")
for name in ("ensure", "sync_venv", "ensure_environment", "build_environment",
"ensure_python_tool", "ensure_import"):
monkeypatch.setattr(pm, name, forbidden)
for name in ("Popen", "run"):
monkeypatch.setattr(subprocess, name, forbidden)
for name in ("system", "kill"):
monkeypatch.setattr(os, name, forbidden)
monkeypatch.setattr(importlib, "reload", forbidden)
monkeypatch.setattr(socket, "create_connection", forbidden)
monkeypatch.setattr(urllib.request, "urlopen", forbidden)
monkeypatch.setattr(urllib.request, "urlretrieve", forbidden)
return forbidden
class FreshChild:
def __init__(self, monkeypatch):
self.monkeypatch = monkeypatch
# Nonzero by default: an unconditional SystemExit(0) is not a handoff.
self.returncode = 19
self.result = {}
self.requests = []
self.paths = []
def run(self, command, *, cwd, env):
"""Intercept ONLY the fresh-child seam, leaving the real JSON bridge intact."""
assert command[:7] == [
sys.executable, "-I", "-S", "-B", "-X", "utf8", str(ROOT / "hermes_cli/_update_takeover.py"),
], f"old installer/fallback ran instead of takeover: {command!r}"
assert len(command) == 9
assert Path(command[0]).is_absolute()
assert Path(cwd) == ROOT
assert not any(key.startswith(("PYTHON", "UV_")) or key == "VIRTUAL_ENV" for key in env)
context, result = map(Path, command[7:])
assert context.is_absolute() and result.is_absolute()
assert context.parent == result.parent and context != result
request = json.loads(context.read_text(encoding="utf-8"))
assert request["root"] == str(ROOT)
assert request["home"] == os.environ["HERMES_HOME"]
assert request["argv"] == sys.argv
self.requests.append(request)
self.paths.append((context, result))
result.write_text(json.dumps(self.result), encoding="utf-8")
return subprocess.CompletedProcess(command, self.returncode)
@contextmanager
def exits(self):
"""Each independent probe must actually hand off, not reuse another test's result."""
before_calls = len(self.requests)
before_env = dict(os.environ)
before_modules = dict(sys.modules)
home = Path(os.environ["HERMES_HOME"])
before_files = {p: p.read_bytes() for p in home.rglob("*") if p.is_file()}
real_import = builtins.__import__
real_import_module = importlib.import_module
def check_import(name):
if name == "pm" or name.startswith("pm.") or name in {
"hermes_cli._update_takeover", "hermes_cli.update_finish",
}:
pytest.fail(f"fresh updater imported in the old parent: {name}")
def guarded_import(name, globals=None, locals=None, fromlist=(), level=0):
resolved = importlib.util.resolve_name("." * level + name, globals["__package__"]) if level else name
check_import(resolved)
for attr in fromlist or ():
check_import(f"{resolved}.{attr}")
return real_import(name, globals, locals, fromlist, level)
def guarded_import_module(name, package=None):
check_import(importlib.util.resolve_name(name, package) if name.startswith(".") else name)
return real_import_module(name, package)
with self.monkeypatch.context() as guard:
guard.setattr(builtins, "__import__", guarded_import)
guard.setattr(importlib, "import_module", guarded_import_module)
with pytest.raises(SystemExit) as stopped:
yield
assert stopped.value.code == self.returncode
assert len(self.requests) == before_calls + 1
assert all(not path.exists() for path in self.paths[-1])
assert dict(os.environ) == before_env
assert all(sys.modules.get(name) is module for name, module in before_modules.items())
assert {p: p.read_bytes() for p in home.rglob("*") if p.is_file()} == before_files
@pytest.fixture
def fresh_child(monkeypatch, no_external_work):
from hermes_cli import _old_updater
# Production caches across finally/atexit reentry. Test probes model separate
# historical processes, so they must not inherit the previous probe's status.
monkeypatch.setattr(_old_updater, "_result", None)
child = FreshChild(monkeypatch)
monkeypatch.setattr(subprocess, "run", child.run)
return child