mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 04:11:35 +00:00
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.
91 lines
3.5 KiB
Python
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"
|