The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Tests for gateway /yolo session scoping."""
import os
import pytest
import gateway.run as gateway_run
from gateway.config import Platform
from gateway.platforms.event import MessageEvent
from gateway.session import SessionSource
from tools.approval import disable_session_yolo, is_session_yolo_enabled
@pytest.fixture(autouse=True)
def _clean_yolo_state(monkeypatch):
monkeypatch.delenv("HERMES_YOLO_MODE", raising=False)
disable_session_yolo("agent:main:telegram:dm:chat-a")
disable_session_yolo("agent:main:telegram:dm:chat-b")
yield
monkeypatch.delenv("HERMES_YOLO_MODE", raising=False)
disable_session_yolo("agent:main:telegram:dm:chat-a")
disable_session_yolo("agent:main:telegram:dm:chat-b")
def _make_runner():
runner = object.__new__(gateway_run.GatewayRunner)
runner.session_store = None
runner.config = None
return runner
def _make_event(chat_id: str) -> MessageEvent:
source = SessionSource(
platform=Platform.TELEGRAM,
user_id=f"user-{chat_id}",
chat_id=chat_id,
user_name="tester",
chat_type="dm",
)
return MessageEvent(text="/yolo", source=source)
@pytest.mark.asyncio
async def test_yolo_command_toggles_only_current_session(monkeypatch):
runner = _make_runner()
event_a = _make_event("chat-a")
session_a = runner._session_key_for_source(event_a.source)
session_b = runner._session_key_for_source(_make_event("chat-b").source)
await runner._handle_yolo_command(event_a)
assert is_session_yolo_enabled(session_a) is True
assert is_session_yolo_enabled(session_b) is False
assert os.environ.get("HERMES_YOLO_MODE") is None
await runner._handle_yolo_command(event_a)
assert is_session_yolo_enabled(session_a) is False
assert os.environ.get("HERMES_YOLO_MODE") is None
def test_launch_yolo_revocation_survives_the_next_turn(monkeypatch):
"""`hermes chat --yolo` seeds the bypass once; a later `/yolo` off is not re-enabled per turn."""
from types import SimpleNamespace
from gateway import session_policy
from gateway.run_turn_runner import TurnRunner
from gateway.turn_context import TurnContext
runner = _make_runner()
source = SessionSource(platform=Platform.LOCAL, chat_id="launch-yolo", user_id="u", chat_type="dm")
key = "agent:main:local:dm:launch-yolo"
monkeypatch.setattr(session_policy, "policy_for_source",
lambda _runner, _source: SimpleNamespace(yolo=True, platform="cli", max_turns=5,
skills_prompt=None))
def _stop(**_kw):
raise RuntimeError("stop after the yolo seam")
runner._resolve_session_agent_runtime = _stop
runner._pre_agent_fallback_notice = None
runner._get_system_prompt_for_channel = lambda *a, **k: ""
def turn():
TurnRunner(runner, TurnContext(source=source, session_key=key))._run_sync_scoped()
try:
turn()
assert is_session_yolo_enabled(key) is True
disable_session_yolo(key)
turn()
assert is_session_yolo_enabled(key) is False
finally:
from tools.approval import clear_session
clear_session(key)
@pytest.mark.asyncio
async def test_yolo_survives_gateway_restart_and_dies_at_session_boundary(tmp_path):
"""/yolo is persisted on the routing entry: a fresh process re-arms it on the next turn, and a
conversation boundary (/new, /resume) clears both copies so a restart cannot revive it."""
from gateway.config import GatewayConfig
from gateway.session import SessionStore
from tools.approval_yolo import restore_session_yolo
def _runner():
runner = _make_runner()
runner.session_store = SessionStore(sessions_dir=tmp_path, config=GatewayConfig())
runner.session_store._db = None # JSON routing index: the restart reads it back from disk
return runner
event = _make_event("chat-a")
first = _runner()
key = first._session_key_for_source(event.source)
await first._handle_yolo_command(event)
assert is_session_yolo_enabled(key) is True
disable_session_yolo(key) # a new process starts with an empty in-memory approval set
second = _runner()
restore_session_yolo(key, second.session_store.get_or_create_session(event.source).yolo)
assert is_session_yolo_enabled(key) is True
second._clear_session_boundary_security_state(key)
assert is_session_yolo_enabled(key) is False
third = _runner()
restore_session_yolo(key, third.session_store.get_or_create_session(event.source).yolo)
assert is_session_yolo_enabled(key) is False
@pytest.mark.asyncio
async def test_owner_yolo_off_is_not_revived_by_the_persisted_restore(tmp_path):
"""The owner's `config.set key=yolo` (TUI/Desktop/`hermes chat` /yolo) writes the route's persisted
copy too: switching off a persisted /yolo must not be re-armed by the next turn's restore."""
from types import SimpleNamespace
from gateway.config import GatewayConfig
from gateway.session import SessionStore
from gateway.session_busy_controls import busy_config
from tools.approval_yolo import restore_session_yolo
runner = _make_runner()
runner.session_store = SessionStore(sessions_dir=tmp_path, config=GatewayConfig())
runner.session_store._db = None
event = _make_event("chat-a")
key = runner._session_key_for_source(event.source)
await runner._handle_yolo_command(event)
authority = SimpleNamespace(authorize=lambda *_a: None, profile_id=str(tmp_path), runner=runner,
sessions={"sid": SimpleNamespace(route=key, source=event.source)})
connection, ref = SimpleNamespace(actor="a", authority=authority), SimpleNamespace(session_id="sid")
off = await busy_config(connection, ref, {"session_id": "sid", "key": "yolo", "value": "0"}, write=True)
assert off["value"] == "0" and is_session_yolo_enabled(key) is False
restore_session_yolo(key, runner.session_store.get_or_create_session(event.source).yolo)
assert is_session_yolo_enabled(key) is False