hermes-agent/tests/tools/test_terminal_pre_guard_deadline.py
teknium1 30b22b54ae fix(tools): bound execute_code's lifecycle probe and keep the terminal guard answerable to /stop
execute_code ran the same unbounded _is_supervised_gateway_process() probe
ahead of every cell, so the wedge #111922 bounds in terminal_tool still hung
an execute_code call (and its cron slot) forever: share the cell's deadline
and fail closed with a retryable error when the probe renders no verdict.

Moving the terminal pre-exec guard onto a deadline worker made it blind to
/stop, which keys on the tool thread's ident: record the acting-for tid in a
contextvar (copied into the worker by run_bounded_sync) so is_interrupted()
on the worker honours the tool thread's bit too.

Floor the guard's share of the deadline at 30s so a short command timeout
does not turn the guard's own cold-start cost (imports, git probes under
load) into a refusal — tests/tools/test_terminal_error_redaction.py was red
on the branch for exactly that.
2026-09-15 19:09:29 -07:00

91 lines
3.5 KiB
Python

"""Terminal pre-execution guards share the command's wall-clock deadline (#111922).
The supervised-gateway identity probe inside ``_pre_exec_block`` ends in a kernel process
query that can wedge; before the deadline wrap, ``terminal_tool`` never returned and the
cron run held its slot forever.
"""
from __future__ import annotations
import json
import time
from types import SimpleNamespace
import pytest
import tools.terminal_tool as terminal_module
def _plan(timeout: float = 0.05) -> SimpleNamespace:
return SimpleNamespace(
config={},
env_type="local",
effective_task_id="pre-guard-deadline-test",
cwd="/tmp",
effective_timeout=timeout,
promoted_from_foreground_timeout=None,
)
@pytest.fixture
def stubbed_pipeline(monkeypatch):
"""Stub planning/env/approval/execution; returns the list of executions that happened."""
calls: list[str] = []
monkeypatch.setattr(terminal_module, "_PRE_EXEC_GUARD_MIN_TIMEOUT_S", 0)
monkeypatch.setattr(terminal_module, "_plan_execution", lambda *_a, **_k: _plan())
monkeypatch.setattr(terminal_module, "_acquire_env", lambda *_a, **_k: object())
monkeypatch.setattr(
terminal_module, "_run_approval_guards", lambda *_a, **_k: terminal_module._ApprovalVerdict(),
)
monkeypatch.setattr(
terminal_module, "_run_foreground", lambda *_a, **_k: calls.append("foreground") or "foreground-ran",
)
return calls
def test_wedged_pre_execution_guard_returns_bounded_error_without_running(monkeypatch, stubbed_pipeline):
"""A stalled identity probe returns a retryable error within the deadline; the command does not run."""
def _wedged_probe(*_a, **_k):
time.sleep(1)
monkeypatch.setattr(terminal_module, "_pre_exec_block", _wedged_probe)
start = time.monotonic()
result = json.loads(terminal_module.terminal_tool("echo ok"))
elapsed = time.monotonic() - start
assert elapsed < 0.5, f"pre-execution guard wedged terminal_tool for {elapsed:.2f}s"
assert result["status"] == "error"
assert "did not finish" in result["error"]
assert stubbed_pipeline == [], "a guard with no verdict must not fail open into execution"
def test_completed_pre_execution_guard_verdicts_pass_through(monkeypatch, stubbed_pipeline):
"""A finished guard keeps its outcome: pass → execution, rejection → its own blocked result."""
monkeypatch.setattr(terminal_module, "_pre_exec_block", lambda *_a, **_k: None)
assert terminal_module.terminal_tool("echo ok") == "foreground-ran"
def _rejecting_probe(*_a, **_k):
raise terminal_module._Rejected('{"status":"blocked"}')
monkeypatch.setattr(terminal_module, "_pre_exec_block", _rejecting_probe)
assert terminal_module.terminal_tool("echo ok") == '{"status":"blocked"}'
assert stubbed_pipeline == ["foreground"]
def test_pre_execution_guard_on_the_deadline_worker_sees_the_tool_threads_interrupt(monkeypatch, stubbed_pipeline):
"""/stop keys on the tool thread's tid; the guard chain moved onto a worker must still see it."""
from tools.interrupt import is_interrupted, set_interrupt
seen: list[bool] = []
monkeypatch.setattr(terminal_module, "_pre_exec_block", lambda *_a, **_k: seen.append(is_interrupted()))
set_interrupt(True)
try:
terminal_module.terminal_tool("echo ok")
finally:
set_interrupt(False)
assert seen == [True], "guard on the deadline worker was blind to the tool thread's interrupt bit"
assert is_interrupted() is False, "the tool thread's own interrupt view must not leak past the guard"