mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-16 19:04:08 +03:00
a1bbd329ea
utils.py held three subjects in one 871-line file. It is now a package with one module per subject: utils/files.py (atomic writes, temp files, file mode and owner, signatures and digests, JSON and YAML file helpers), utils/urls.py (the base_url helpers) and utils/env.py (truthy values, env numbers, proxy env helpers). utils/__init__.py re-exports every public name, so no importer changes. Function bodies are unchanged, no function-level import moved, and the logger keeps the name "utils". Tests patch a name in the module that now defines it. Patches stay on the package where production reads the name through a function-level "from utils import". The tests of utils itself move to tests/utils/. A root module that becomes a folder drops out of anything that copies root *.py files plus a fixed list of packages, so the fixtures that build a partial source tree now list utils, as do pyproject's packages.find, three check scripts and the CI change classifier.
797 lines
32 KiB
Python
797 lines
32 KiB
Python
"""Tests for the shell-hooks subprocess bridge (agent.shell_hooks).
|
|
|
|
These tests focus on the pure translation layer — JSON serialisation,
|
|
JSON parsing, matcher behaviour, block-schema correctness, and the
|
|
subprocess runner's graceful error handling. Consent prompts are
|
|
covered in ``test_shell_hooks_consent.py``.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from agent import shell_hooks
|
|
|
|
|
|
# ── helpers ───────────────────────────────────────────────────────────────
|
|
|
|
|
|
def _write_script(tmp_path: Path, name: str, body: str) -> Path:
|
|
path = tmp_path / name
|
|
path.write_text(body)
|
|
path.chmod(0o755)
|
|
return path
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _reset_registration_state():
|
|
shell_hooks.reset_for_tests()
|
|
yield
|
|
shell_hooks.reset_for_tests()
|
|
|
|
|
|
# ── _parse_response ───────────────────────────────────────────────────────
|
|
|
|
|
|
class TestParseResponse:
|
|
def test_block_claude_code_style(self):
|
|
r = shell_hooks._parse_response(
|
|
"pre_tool_call",
|
|
'{"decision": "block", "reason": "nope"}',
|
|
)
|
|
assert r == {"action": "block", "message": "nope"}
|
|
|
|
@pytest.mark.parametrize("stdout, expected", [
|
|
('{"action": "approve", "message": " needs a human ", "rule_key": " terminal:rm "}',
|
|
{"action": "approve", "message": "needs a human", "rule_key": "terminal:rm"}),
|
|
('{"action": "approve", "message": "", "rule_key": 7}', {"action": "approve"}),
|
|
# Claude-Code's ``decision: approve`` means auto-ALLOW, not "ask a human": never mapped.
|
|
('{"decision": "approve", "reason": "ok"}', None),
|
|
('{"action": "approve", "decision": "block", "reason": "no"}', {"action": "block", "message": "no"}),
|
|
])
|
|
def test_approve_is_parsed_like_the_plugin_directive(self, stdout, expected):
|
|
"""The documented ``approve`` action used to parse to None, so the tool ran with no
|
|
approval prompt (#92553). It now yields the same shape Python plugins return."""
|
|
assert shell_hooks._parse_response("pre_tool_call", stdout) == expected
|
|
|
|
def test_empty_stdout_returns_none(self):
|
|
assert shell_hooks._parse_response("pre_tool_call", "") is None
|
|
assert shell_hooks._parse_response("pre_tool_call", " ") is None
|
|
|
|
|
|
# ── _serialize_payload ────────────────────────────────────────────────────
|
|
|
|
|
|
class TestSerializePayload:
|
|
|
|
def test_args_not_dict_becomes_null(self):
|
|
raw = shell_hooks._serialize_payload(
|
|
"pre_tool_call", {"args": ["not", "a", "dict"]},
|
|
)
|
|
payload = json.loads(raw)
|
|
assert payload["tool_input"] is None
|
|
|
|
|
|
# ── Matcher behaviour ─────────────────────────────────────────────────────
|
|
|
|
|
|
class TestMatcher:
|
|
|
|
|
|
def test_alternation_matcher(self):
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call", command="echo", matcher="terminal|file",
|
|
)
|
|
assert spec.matches_tool("terminal")
|
|
assert spec.matches_tool("file")
|
|
assert not spec.matches_tool("web")
|
|
|
|
|
|
def test_matcher_leading_whitespace_stripped(self):
|
|
"""YAML quirks can introduce leading/trailing whitespace — must
|
|
not silently break the matcher."""
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call", command="echo", matcher=" terminal ",
|
|
)
|
|
assert spec.matcher == "terminal"
|
|
assert spec.matches_tool("terminal")
|
|
|
|
|
|
def test_whitespace_only_matcher_becomes_none(self):
|
|
"""A matcher that's pure whitespace is treated as 'no matcher'."""
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call", command="echo", matcher=" ",
|
|
)
|
|
assert spec.matcher is None
|
|
assert spec.matches_tool("anything")
|
|
|
|
|
|
# ── End-to-end subprocess behaviour ───────────────────────────────────────
|
|
|
|
|
|
@pytest.mark.platforms("linux")
|
|
class TestCallbackSubprocess:
|
|
|
|
|
|
def test_block_aggregation_through_plugin_manager(self, tmp_path, monkeypatch):
|
|
"""Registering via register_from_config makes
|
|
get_pre_tool_call_block_message surface the block — the real
|
|
end-to-end control flow used by run_agent._invoke_tool."""
|
|
from hermes_cli import plugins
|
|
|
|
script = _write_script(
|
|
tmp_path, "block.sh",
|
|
"#!/usr/bin/env bash\n"
|
|
'printf \'{"decision": "block", "reason": "blocked-by-shell"}\\n\'\n',
|
|
)
|
|
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path / "home"))
|
|
monkeypatch.setenv("HERMES_ACCEPT_HOOKS", "1")
|
|
|
|
# Fresh manager
|
|
plugins._plugin_manager = plugins.PluginManager()
|
|
|
|
cfg = {
|
|
"hooks": {
|
|
"pre_tool_call": [
|
|
{"matcher": "terminal", "command": str(script)},
|
|
],
|
|
},
|
|
}
|
|
registered = shell_hooks.register_from_config(cfg, accept_hooks=True)
|
|
assert len(registered) == 1
|
|
|
|
msg = plugins.get_pre_tool_call_block_message(
|
|
tool_name="terminal",
|
|
args={"command": "rm"},
|
|
)
|
|
assert msg == "blocked-by-shell"
|
|
|
|
def test_approve_reaches_the_human_gate_through_plugin_manager(self, tmp_path, monkeypatch):
|
|
"""End to end: a shell hook's approve directive escalates to request_tool_approval with its
|
|
message and rule_key, and the gate's denial blocks the tool (#92553)."""
|
|
from hermes_cli import plugins
|
|
|
|
script = _write_script(
|
|
tmp_path, "approve.sh",
|
|
"#!/usr/bin/env bash\n"
|
|
'printf \'{"action": "approve", "message": "risky", "rule_key": "terminal:rm"}\\n\'\n',
|
|
)
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path / "home"))
|
|
monkeypatch.setenv("HERMES_ACCEPT_HOOKS", "1")
|
|
plugins._plugin_manager = plugins.PluginManager()
|
|
cfg = {"hooks": {"pre_tool_call": [{"matcher": "terminal", "command": str(script)}]}}
|
|
assert len(shell_hooks.register_from_config(cfg, accept_hooks=True)) == 1
|
|
|
|
seen = []
|
|
|
|
def _gate(tool_name, reason, **kwargs):
|
|
seen.append((tool_name, reason, kwargs.get("rule_key")))
|
|
return {"approved": False, "message": "denied by human"}
|
|
|
|
monkeypatch.setattr("tools.approval.request_tool_approval", _gate)
|
|
assert plugins.resolve_pre_tool_block("terminal", {"command": "rm"}) == "denied by human"
|
|
assert seen == [("terminal", "risky", "terminal:rm")]
|
|
|
|
def test_matcher_regex_filters_callback(self, tmp_path, monkeypatch):
|
|
"""A matcher set to 'terminal' must not fire for 'web_search'."""
|
|
calls = tmp_path / "calls.log"
|
|
script = _write_script(
|
|
tmp_path, "log.sh",
|
|
f"#!/usr/bin/env bash\n"
|
|
f"echo \"$(cat -)\" >> {calls}\n"
|
|
f"printf '{{}}\\n'\n",
|
|
)
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call",
|
|
command=str(script),
|
|
matcher="terminal",
|
|
)
|
|
cb = shell_hooks._make_callback(spec)
|
|
cb(tool_name="terminal", args={"command": "ls"})
|
|
cb(tool_name="web_search", args={"q": "x"})
|
|
cb(tool_name="file_read", args={"path": "x"})
|
|
assert calls.exists()
|
|
# Only the terminal call wrote to the log
|
|
assert calls.read_text().count("pre_tool_call") == 1
|
|
|
|
def test_payload_schema_delivered(self, tmp_path):
|
|
capture = tmp_path / "payload.json"
|
|
script = _write_script(
|
|
tmp_path, "capture.sh",
|
|
f"#!/usr/bin/env bash\ncat - > {capture}\nprintf '{{}}\\n'\n",
|
|
)
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call", command=str(script),
|
|
)
|
|
cb = shell_hooks._make_callback(spec)
|
|
cb(
|
|
tool_name="terminal",
|
|
args={"command": "echo hi"},
|
|
session_id="sess-77",
|
|
task_id="task-77",
|
|
)
|
|
payload = json.loads(capture.read_text())
|
|
assert payload["hook_event_name"] == "pre_tool_call"
|
|
assert payload["tool_name"] == "terminal"
|
|
assert payload["tool_input"] == {"command": "echo hi"}
|
|
assert payload["session_id"] == "sess-77"
|
|
assert "cwd" in payload
|
|
assert payload["extra"]["task_id"] == "task-77"
|
|
|
|
|
|
def test_modify_canonical_parsing(self, tmp_path):
|
|
"""Shell hook returning canonical modify is parsed correctly."""
|
|
script = _write_script(
|
|
tmp_path, "mod_canon.sh",
|
|
"#!/usr/bin/env bash\n"
|
|
'printf \'{"action": "modify", "args": {"path": "/safe"}}\\n\'',
|
|
)
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call", command=str(script),
|
|
)
|
|
cb = shell_hooks._make_callback(spec)
|
|
result = cb(tool_name="write_file", args={"path": "/unsafe"})
|
|
assert result == {"action": "modify", "args": {"path": "/safe"}}
|
|
|
|
def test_modify_claude_code_parsing(self, tmp_path):
|
|
"""Shell hook returning Claude-Code modify is normalised."""
|
|
script = _write_script(
|
|
tmp_path, "mod_cc.sh",
|
|
"#!/usr/bin/env bash\n"
|
|
'printf \'{"decision": "modify", "tool_input": {"content": "safe"}}\\n\'',
|
|
)
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call", command=str(script),
|
|
)
|
|
cb = shell_hooks._make_callback(spec)
|
|
result = cb(tool_name="write_file", args={"content": "danger"})
|
|
assert result == {"action": "modify", "args": {"content": "safe"}}
|
|
|
|
|
|
# ── config parsing ────────────────────────────────────────────────────────
|
|
|
|
|
|
class TestParseHooksBlock:
|
|
def test_valid_entry(self):
|
|
specs = shell_hooks._parse_hooks_block({
|
|
"pre_tool_call": [
|
|
{"matcher": "terminal", "command": "/tmp/hook.sh", "timeout": 30},
|
|
],
|
|
})
|
|
assert len(specs) == 1
|
|
assert specs[0].event == "pre_tool_call"
|
|
assert specs[0].matcher == "terminal"
|
|
assert specs[0].command == "/tmp/hook.sh"
|
|
assert specs[0].timeout == 30
|
|
|
|
|
|
def test_python_only_event_refused(self):
|
|
# transform_api_error_classification returns a classification directive that
|
|
# _parse_response has no channel for — a shell registration would
|
|
# be silently ignored, so it must be refused with a warning.
|
|
specs = shell_hooks._parse_hooks_block({
|
|
"transform_api_error_classification": [
|
|
{"command": "/tmp/hook.sh"},
|
|
],
|
|
})
|
|
assert specs == []
|
|
|
|
def test_timeout_clamped_to_max(self):
|
|
specs = shell_hooks._parse_hooks_block({
|
|
"post_tool_call": [
|
|
{"command": "/tmp/slow.sh", "timeout": 9999},
|
|
],
|
|
})
|
|
assert specs[0].timeout == shell_hooks.MAX_TIMEOUT_SECONDS
|
|
|
|
|
|
def test_none_hooks_block(self):
|
|
assert shell_hooks._parse_hooks_block(None) == []
|
|
assert shell_hooks._parse_hooks_block("string") == []
|
|
assert shell_hooks._parse_hooks_block([]) == []
|
|
|
|
def test_non_tool_event_matcher_warns_and_drops(self):
|
|
"""matcher: is only honored for pre/post_tool_call; must drop it
|
|
on other events so the spec reflects runtime."""
|
|
cfg = {"pre_llm_call": [{"matcher": "terminal", "command": "/bin/echo"}]}
|
|
specs = shell_hooks._parse_hooks_block(cfg)
|
|
assert len(specs) == 1 and specs[0].matcher is None
|
|
|
|
|
|
# ── Idempotent registration ───────────────────────────────────────────────
|
|
|
|
|
|
class TestIdempotentRegistration:
|
|
def test_double_call_registers_once(self, tmp_path, monkeypatch):
|
|
from hermes_cli import plugins
|
|
|
|
script = _write_script(tmp_path, "h.sh",
|
|
"#!/usr/bin/env bash\nprintf '{}\\n'\n")
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path / "home"))
|
|
monkeypatch.setenv("HERMES_ACCEPT_HOOKS", "1")
|
|
|
|
plugins._plugin_manager = plugins.PluginManager()
|
|
|
|
cfg = {"hooks": {"on_session_start": [{"command": str(script)}]}}
|
|
|
|
first = shell_hooks.register_from_config(cfg, accept_hooks=True)
|
|
second = shell_hooks.register_from_config(cfg, accept_hooks=True)
|
|
assert len(first) == 1
|
|
assert second == []
|
|
# Only one callback on the manager
|
|
mgr = plugins.get_plugin_manager()
|
|
assert len(mgr._hooks.get("on_session_start", [])) == 1
|
|
|
|
def test_same_command_different_matcher_registers_both(
|
|
self, tmp_path, monkeypatch,
|
|
):
|
|
"""Same script used for different matchers under one event must
|
|
register both callbacks — dedupe keys on (event, matcher, command)."""
|
|
from hermes_cli import plugins
|
|
|
|
script = _write_script(tmp_path, "h.sh",
|
|
"#!/usr/bin/env bash\nprintf '{}\\n'\n")
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path / "home"))
|
|
monkeypatch.setenv("HERMES_ACCEPT_HOOKS", "1")
|
|
|
|
plugins._plugin_manager = plugins.PluginManager()
|
|
|
|
cfg = {
|
|
"hooks": {
|
|
"pre_tool_call": [
|
|
{"matcher": "terminal", "command": str(script)},
|
|
{"matcher": "web_search", "command": str(script)},
|
|
],
|
|
},
|
|
}
|
|
|
|
registered = shell_hooks.register_from_config(cfg, accept_hooks=True)
|
|
assert len(registered) == 2
|
|
mgr = plugins.get_plugin_manager()
|
|
assert len(mgr._hooks.get("pre_tool_call", [])) == 2
|
|
|
|
|
|
# ── Allowlist concurrency ─────────────────────────────────────────────────
|
|
|
|
|
|
class TestAllowlistConcurrency:
|
|
"""Regression tests for the Codex#1 finding: simultaneous
|
|
_record_approval() calls used to collide on a fixed tmp path and
|
|
silently lose entries under read-modify-write races."""
|
|
|
|
|
|
def test_save_allowlist_uses_unique_tmp_paths(self, tmp_path, monkeypatch):
|
|
"""Two save_allowlist calls in flight must use distinct tmp files
|
|
so the loser's os.replace does not ENOENT on the winner's sweep."""
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path / "home"))
|
|
p = shell_hooks.allowlist_path()
|
|
p.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
tmp_paths_seen: list = []
|
|
import utils.files
|
|
real_mkstemp = utils.files.tempfile.mkstemp
|
|
|
|
def spying_mkstemp(*args, **kwargs):
|
|
fd, path = real_mkstemp(*args, **kwargs)
|
|
tmp_paths_seen.append(path)
|
|
return fd, path
|
|
|
|
monkeypatch.setattr(utils.files.tempfile, "mkstemp", spying_mkstemp)
|
|
|
|
shell_hooks.save_allowlist({"approvals": [{"event": "a", "command": "x"}]})
|
|
shell_hooks.save_allowlist({"approvals": [{"event": "b", "command": "y"}]})
|
|
|
|
assert len(tmp_paths_seen) == 2
|
|
assert tmp_paths_seen[0] != tmp_paths_seen[1]
|
|
|
|
|
|
# ── fail_closed parsing ───────────────────────────────────────────────────
|
|
|
|
|
|
class TestFailClosedParsing:
|
|
def test_fail_closed_parsed(self):
|
|
specs = shell_hooks._parse_hooks_block({
|
|
"pre_tool_call": [
|
|
{"command": "/tmp/h.sh", "fail_closed": True},
|
|
],
|
|
})
|
|
assert len(specs) == 1
|
|
assert specs[0].fail_closed is True
|
|
|
|
def test_fail_closed_defaults_false(self):
|
|
specs = shell_hooks._parse_hooks_block({
|
|
"pre_tool_call": [{"command": "/tmp/h.sh"}],
|
|
})
|
|
assert specs[0].fail_closed is False
|
|
|
|
def test_failclosed_camel_alias(self):
|
|
"""Cursor/Claude Code configs spell it failClosed."""
|
|
specs = shell_hooks._parse_hooks_block({
|
|
"pre_tool_call": [
|
|
{"command": "/tmp/h.sh", "failClosed": True},
|
|
],
|
|
})
|
|
assert specs[0].fail_closed is True
|
|
|
|
def test_canonical_wins_over_alias(self):
|
|
specs = shell_hooks._parse_hooks_block({
|
|
"pre_tool_call": [
|
|
{"command": "/tmp/h.sh", "fail_closed": False,
|
|
"failClosed": True},
|
|
],
|
|
})
|
|
assert specs[0].fail_closed is False
|
|
|
|
def test_non_bool_warns_and_defaults_false(self):
|
|
specs = shell_hooks._parse_hooks_block({
|
|
"pre_tool_call": [
|
|
{"command": "/tmp/h.sh", "fail_closed": "yes"},
|
|
],
|
|
})
|
|
assert specs[0].fail_closed is False
|
|
|
|
def test_fail_closed_on_non_blocking_event_warns_and_ignores(self):
|
|
specs = shell_hooks._parse_hooks_block({
|
|
"on_session_start": [
|
|
{"command": "/tmp/h.sh", "fail_closed": True},
|
|
],
|
|
})
|
|
assert specs[0].fail_closed is False
|
|
|
|
|
|
# ── _evaluate_result semantics ────────────────────────────────────────────
|
|
|
|
|
|
def _spawn_result(**overrides):
|
|
base = {
|
|
"returncode": 0,
|
|
"stdout": "",
|
|
"stderr": "",
|
|
"timed_out": False,
|
|
"elapsed_seconds": 0.1,
|
|
"error": None,
|
|
}
|
|
base.update(overrides)
|
|
return base
|
|
|
|
|
|
class TestEvaluateResult:
|
|
def _spec(self, event="pre_tool_call", fail_closed=False):
|
|
return shell_hooks.ShellHookSpec(
|
|
event=event, command="/tmp/h.sh", fail_closed=fail_closed,
|
|
)
|
|
|
|
# -- exit code 2 = block --------------------------------------------
|
|
|
|
def test_exit_2_blocks_with_stderr_message(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(),
|
|
_spawn_result(returncode=2, stderr="policy violation\n"),
|
|
)
|
|
assert r == {"action": "block", "message": "policy violation"}
|
|
|
|
def test_exit_2_blocks_with_default_message(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(), _spawn_result(returncode=2),
|
|
)
|
|
assert r == {
|
|
"action": "block",
|
|
"message": shell_hooks._DEFAULT_BLOCK_MESSAGE,
|
|
}
|
|
|
|
def test_exit_2_stdout_block_json_wins(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(),
|
|
_spawn_result(
|
|
returncode=2,
|
|
stdout='{"decision": "block", "reason": "from stdout"}',
|
|
stderr="from stderr",
|
|
),
|
|
)
|
|
assert r == {"action": "block", "message": "from stdout"}
|
|
|
|
def test_exit_2_on_non_blocking_event_does_not_block(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(event="on_session_start"),
|
|
_spawn_result(returncode=2, stderr="boom"),
|
|
)
|
|
assert r is None
|
|
|
|
def test_other_nonzero_exit_still_parses_stdout(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(),
|
|
_spawn_result(
|
|
returncode=1,
|
|
stdout='{"decision": "block", "reason": "nope"}',
|
|
),
|
|
)
|
|
assert r == {"action": "block", "message": "nope"}
|
|
|
|
def test_nonzero_exit_without_directive_is_none(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(), _spawn_result(returncode=1, stderr="oops"),
|
|
)
|
|
assert r is None
|
|
|
|
# -- fail_closed ------------------------------------------------------
|
|
|
|
def test_spawn_error_fails_open_by_default(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(), _spawn_result(error="No such file"),
|
|
)
|
|
assert r is None
|
|
|
|
def test_spawn_error_fail_closed_blocks(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(fail_closed=True), _spawn_result(error="No such file"),
|
|
)
|
|
assert r["action"] == "block"
|
|
assert "failed closed" in r["message"]
|
|
assert "No such file" in r["message"]
|
|
|
|
def test_timeout_fails_open_by_default(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(), _spawn_result(timed_out=True),
|
|
)
|
|
assert r is None
|
|
|
|
def test_timeout_fail_closed_blocks(self):
|
|
spec = self._spec(fail_closed=True)
|
|
r = shell_hooks._evaluate_result(spec, _spawn_result(timed_out=True))
|
|
assert r["action"] == "block"
|
|
assert f"timed out after {spec.timeout}s" in r["message"]
|
|
|
|
def test_unparseable_stdout_fail_closed_blocks(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(fail_closed=True),
|
|
_spawn_result(stdout="Traceback (most recent call last): ..."),
|
|
)
|
|
assert r["action"] == "block"
|
|
assert "unparseable stdout" in r["message"]
|
|
|
|
def test_nonzero_exit_without_directive_fail_closed_blocks(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(fail_closed=True),
|
|
_spawn_result(returncode=1, stderr="Traceback: hook crashed"),
|
|
)
|
|
assert r["action"] == "block"
|
|
assert "hook exited 1 with no directive" in r["message"]
|
|
|
|
def test_unparseable_stdout_fails_open_by_default(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(),
|
|
_spawn_result(stdout="Traceback (most recent call last): ..."),
|
|
)
|
|
assert r is None
|
|
|
|
def test_valid_noop_json_passes_fail_closed(self):
|
|
"""A clean {} no-op must NOT be blocked by fail_closed."""
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(fail_closed=True), _spawn_result(stdout="{}"),
|
|
)
|
|
assert r is None
|
|
|
|
def test_empty_stdout_passes_fail_closed(self):
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(fail_closed=True), _spawn_result(stdout=""),
|
|
)
|
|
assert r is None
|
|
|
|
def test_fail_closed_on_non_blocking_event_still_fails_open(self):
|
|
"""Defense in depth: even if a spec sneaks past parsing with
|
|
fail_closed on a non-blocking event, runtime fails open."""
|
|
r = shell_hooks._evaluate_result(
|
|
self._spec(event="on_session_start", fail_closed=True),
|
|
_spawn_result(error="boom"),
|
|
)
|
|
assert r is None
|
|
|
|
|
|
# ── exit-2 / fail_closed end-to-end ──────────────────────────────────────
|
|
|
|
|
|
class TestFailSemanticsEndToEnd:
|
|
def test_fail_closed_crashed_process_blocks(self, tmp_path):
|
|
script = _write_script(
|
|
tmp_path, "crash.py", 'raise RuntimeError("hook crashed")\n',
|
|
)
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call",
|
|
command=f'"{sys.executable}" "{script}"',
|
|
fail_closed=True,
|
|
)
|
|
cb = shell_hooks._make_callback(spec)
|
|
result = cb(tool_name="terminal", args={"command": "rm -rf /"})
|
|
assert result is not None and result["action"] == "block"
|
|
assert "hook exited 1 with no directive" in result["message"]
|
|
|
|
@pytest.mark.platforms("linux")
|
|
def test_exit_2_script_blocks(self, tmp_path):
|
|
script = _write_script(
|
|
tmp_path, "exit2.sh",
|
|
"#!/usr/bin/env bash\n"
|
|
'echo "rm -rf is not permitted" >&2\n'
|
|
"exit 2\n",
|
|
)
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call", command=str(script),
|
|
)
|
|
cb = shell_hooks._make_callback(spec)
|
|
result = cb(tool_name="terminal", args={"command": "rm -rf /"})
|
|
assert result == {
|
|
"action": "block", "message": "rm -rf is not permitted",
|
|
}
|
|
|
|
def test_fail_closed_missing_command_blocks(self, tmp_path):
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call",
|
|
command=str(tmp_path / "does-not-exist.sh"),
|
|
fail_closed=True,
|
|
)
|
|
cb = shell_hooks._make_callback(spec)
|
|
result = cb(tool_name="terminal", args={"command": "ls"})
|
|
assert result is not None and result["action"] == "block"
|
|
assert "failed closed" in result["message"]
|
|
|
|
@pytest.mark.platforms("linux")
|
|
def test_run_once_reflects_exit_2_block(self, tmp_path):
|
|
"""hermes hooks test must mirror production semantics."""
|
|
script = _write_script(
|
|
tmp_path, "exit2.sh",
|
|
"#!/usr/bin/env bash\n"
|
|
'echo "denied" >&2\n'
|
|
"exit 2\n",
|
|
)
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call", command=str(script),
|
|
)
|
|
result = shell_hooks.run_once(
|
|
spec, {"tool_name": "terminal", "args": {"command": "ls"}},
|
|
)
|
|
assert result["returncode"] == 2
|
|
assert result["parsed"] == {"action": "block", "message": "denied"}
|
|
|
|
@pytest.mark.platforms("linux")
|
|
def test_run_once_reflects_fail_closed_timeout(self, tmp_path):
|
|
script = _write_script(
|
|
tmp_path, "sleepy.sh",
|
|
"#!/usr/bin/env bash\nsleep 5\n",
|
|
)
|
|
spec = shell_hooks.ShellHookSpec(
|
|
event="pre_tool_call", command=str(script),
|
|
timeout=1, fail_closed=True,
|
|
)
|
|
result = shell_hooks.run_once(
|
|
spec, {"tool_name": "terminal", "args": {"command": "ls"}},
|
|
)
|
|
assert result["timed_out"] is True
|
|
assert result["parsed"]["action"] == "block"
|
|
assert "failed closed" in result["parsed"]["message"]
|
|
|
|
|
|
# ── multiplexed profiles ──────────────────────────────────────────────────
|
|
|
|
|
|
class TestRoutedProfileEnv:
|
|
@pytest.mark.platforms("linux")
|
|
def test_hook_child_sees_routed_profile_home_and_no_default_secrets(self, tmp_path, monkeypatch):
|
|
"""Under multiplexing the child gets the ROUTED HERMES_HOME, the default profile's secrets
|
|
stay out of its env, and the payload names the firing profile."""
|
|
from hermes_constants import reset_hermes_home_override, set_hermes_home_override
|
|
|
|
launch, routed = tmp_path / "launch", tmp_path / "routed"
|
|
launch.mkdir(); routed.mkdir()
|
|
monkeypatch.setenv("HERMES_HOME", str(launch))
|
|
monkeypatch.setenv("OPENAI_API_KEY", "sk-default-profile")
|
|
monkeypatch.setattr("agent.secret_scope.is_multiplex_active", lambda: True)
|
|
script = _write_script(
|
|
tmp_path, "env_dump.sh",
|
|
"#!/usr/bin/env bash\ncat > /dev/null\n"
|
|
'printf \'{"home": "%s", "key": "%s"}\\n\' "$HERMES_HOME" "${OPENAI_API_KEY:-}"\n',
|
|
)
|
|
spec = shell_hooks.ShellHookSpec(event="pre_tool_call", command=str(script))
|
|
token = set_hermes_home_override(str(routed))
|
|
try:
|
|
result = shell_hooks._spawn(spec, shell_hooks._serialize_payload("pre_tool_call", {"tool_name": "terminal"}))
|
|
payload = json.loads(shell_hooks._serialize_payload("pre_tool_call", {"tool_name": "terminal"}))
|
|
finally:
|
|
reset_hermes_home_override(token)
|
|
seen = json.loads(result["stdout"])
|
|
assert seen["home"] == str(routed)
|
|
assert seen["key"] == ""
|
|
assert "profile" in payload
|
|
|
|
|
|
# ── bare script paths on native Windows ─────────────────────────────────
|
|
# Real subprocesses, no mocked spawn: the failure being guarded is CreateProcess rejecting a text
|
|
# file, which only exists on the host it happens on. Marked per the root AGENTS.md rule against
|
|
# faking ``sys.platform``.
|
|
|
|
|
|
@pytest.mark.platforms("windows")
|
|
def test_bare_script_hook_path_executes_on_windows(tmp_path):
|
|
"""A hook whose command is a bare script path — the shape every example in
|
|
``website/docs/user-guide/features/hooks.md`` uses — must run. POSIX gets there through the
|
|
kernel's shebang handling; CreateProcess has no equivalent, so the same config failed on
|
|
Windows while working everywhere else. A path that is not a file must still be reported as
|
|
missing rather than laundered through an interpreter."""
|
|
script = _write_script(tmp_path, "hook.sh", '#!/usr/bin/env bash\necho "ran" >&2\nexit 7\n')
|
|
|
|
def spec(command):
|
|
return shell_hooks.ShellHookSpec(event="pre_tool_call", command=command)
|
|
|
|
result = shell_hooks._spawn(spec(str(script)), "{}")
|
|
assert result["error"] is None, result["error"]
|
|
assert result["returncode"] == 7, "the script's own exit code must reach a fail_closed gate"
|
|
assert "ran" in result["stderr"]
|
|
|
|
missing = shell_hooks._spawn(spec(str(tmp_path / "gone.sh")), "{}")
|
|
assert missing["error"] == "command not found"
|
|
|
|
|
|
@pytest.mark.platforms("windows")
|
|
def test_unroutable_script_hook_names_the_remediation(tmp_path):
|
|
"""A suffix we deliberately do not route still fails, but the diagnostic has to say what to do:
|
|
the raw WinError text is localized, so a non-English Windows install could not act on it."""
|
|
script = _write_script(tmp_path, "hook.zsh", "#!/bin/zsh\necho hi\n")
|
|
spec = shell_hooks.ShellHookSpec(event="pre_tool_call", command=str(script))
|
|
|
|
result = shell_hooks._spawn(spec, "{}")
|
|
|
|
assert result["returncode"] is None
|
|
assert "interpreter" in result["error"] and "bash" in result["error"]
|
|
|
|
|
|
@pytest.mark.platforms("posix")
|
|
def test_real_tool_hooks_receive_only_the_owning_workers_identity(tmp_path, monkeypatch):
|
|
import shlex
|
|
import sys
|
|
from contextlib import nullcontext
|
|
from types import SimpleNamespace
|
|
from agent.delegation_context import delegated_child_context, non_dispatcher_owned_context
|
|
from agent.agent_runtime_helpers import _pre_tool_block_message
|
|
from agent.inline_tool_executors import emit_terminal_post_tool_call
|
|
from hermes_cli import plugins
|
|
|
|
home = tmp_path / "home"
|
|
monkeypatch.setenv("HERMES_HOME", str(home))
|
|
monkeypatch.setenv("HERMES_KANBAN_TASK", "t_owner")
|
|
monkeypatch.delenv("HERMES_DELEGATED_CHILD_CONTEXT", raising=False)
|
|
monkeypatch.setattr(plugins, "_plugin_manager", plugins.PluginManager())
|
|
capture = tmp_path / "captured.json"
|
|
script = tmp_path / "gate.py"
|
|
script.write_text(
|
|
"import json, os, sys\nfrom pathlib import Path\n"
|
|
"payload=json.load(sys.stdin)\n"
|
|
"payload['worker_env']=os.environ.get('HERMES_KANBAN_TASK')\n"
|
|
f"Path({str(capture)!r}).write_text(json.dumps(payload))\n"
|
|
"print(json.dumps({'action':'block', 'message':'verified gate fired'}))\n"
|
|
)
|
|
command = f"{shlex.quote(sys.executable)} {shlex.quote(str(script))}"
|
|
shell_hooks.register_from_config({"hooks": {
|
|
event: [{"matcher": "kanban_complete", "command": command}]
|
|
for event in ("pre_tool_call", "post_tool_call")
|
|
}}, accept_hooks=True)
|
|
agent = SimpleNamespace(session_id="session-id")
|
|
for scope, expected in ((nullcontext, "t_owner"), (delegated_child_context, ""),
|
|
(non_dispatcher_owned_context, ""), (nullcontext, "t_owner")):
|
|
with scope():
|
|
message, _ = _pre_tool_block_message(agent, "kanban_complete", {}, "turn-id", "call-id", [])
|
|
assert message == "verified gate fired"
|
|
payload = json.loads(capture.read_text())
|
|
assert payload["extra"]["kanban_task_id"] == expected
|
|
assert payload["extra"]["task_id"] == "turn-id"
|
|
assert payload["session_id"] == "session-id"
|
|
assert payload["worker_env"] is None
|
|
capture.unlink()
|
|
emit_terminal_post_tool_call(agent, function_name="kanban_complete", function_args={},
|
|
result="{}", effective_task_id="turn-id", tool_call_id="call-id")
|
|
payload = json.loads(capture.read_text())
|
|
assert payload["hook_event_name"] == "post_tool_call"
|
|
assert payload["extra"]["kanban_task_id"] == expected
|