hermes-agent/tests/tui_gateway/test_heartbeat_tui_tick.py
teknium1 490ee1607a fix(tui): heartbeat ownership follows the gateway's live routing index, not the row source
_notif_gateway_owns_heartbeat decided by the immutable sessions.source column,
so a heartbeat on an ARCHIVED gateway-sourced row (Telegram /reset, idle/daily
auto-reset, compression rotation) was skipped by the Desktop poller and never
registered by the gateway either — restore_heartbeat_watches only claims a key
whose current session_id is that row. The tick belonged to nobody and stayed
due forever, where origin/main's Desktop fired it.

Ownership now uses the same predicate the gateway does: a gateway_routing entry
whose current session_id is this session, with an origin and not suspended
(SessionDB.gateway_routing_entry_for_session; both the session's profile store
and the launch store are consulted so multiplexed and per-profile gateways are
covered). No entry is fail-open, as on main. The check runs after the cheap
is_active/is_due gate so idle sessions never touch the DB per poll.

Probe (SessionStore telegram -> force_new, heartbeat on the archived sid):
before: desktop fired False / gateway watches [] / still due True;
after: desktop fired True / still due False; the current gateway sid is still
left to the gateway (desktop fired False) — the hijack fix stays intact.
2026-09-15 18:57:09 -07:00

174 lines
6.7 KiB
Python

"""/heartbeat firing from the TUI/Desktop session-owner process (#102056, #103044).
The slash worker that parses ``/heartbeat`` runs a HermesCLI whose watchdog queues the due prompt
into its own ``_pending_input`` — a queue no turn loop drains in that process. The per-session
notification poller (the same driver that fires ``/loop``) must poll the persisted HeartbeatManager
and re-enter the live session through ``_run_prompt_submit``.
"""
from __future__ import annotations
import importlib
import threading
import time
from pathlib import Path
from unittest.mock import MagicMock, patch
import pytest
@pytest.fixture()
def hermes_home(tmp_path, monkeypatch):
home = tmp_path / ".hermes"
home.mkdir()
monkeypatch.setattr(Path, "home", lambda: tmp_path)
monkeypatch.setenv("HERMES_HOME", str(home))
from hermes_cli import goals
goals._DB_CACHE.clear()
yield home
goals._DB_CACHE.clear()
@pytest.fixture()
def server(hermes_home):
with patch.dict("sys.modules", {"hermes_cli.env_loader": MagicMock(), "hermes_cli.banner": MagicMock()}):
mod = importlib.import_module("tui_gateway.server")
yield mod
mod._sessions.clear()
@pytest.fixture()
def session(server):
sid, key = "sid-hb-test", "tui-hb-session-1"
s = {"session_key": key, "history": [], "history_lock": threading.Lock(), "history_version": 0,
"running": False, "attached_images": [], "cols": 120, "agent": MagicMock()}
server._sessions[sid] = s
return sid, key, s
def _arm_due(key: str):
from hermes_cli.heartbeat import HeartbeatManager, save_heartbeat
mgr = HeartbeatManager(key)
state = mgr.set("report backend health", 60)
state.created_at = time.time() - 3600
save_heartbeat(key, state)
return mgr
def _submits(server, submit):
return patch.object(server, "_run_prompt_submit", submit), patch.object(server, "_emit")
def test_notification_poller_fires_due_heartbeat_when_idle(server, session):
"""The session-owner poller loop itself dispatches a due heartbeat exactly once; the same state on
the base loop never fired (armed-but-dead)."""
sid, key, s = session
s["source"] = "desktop"
server._get_db().create_session(key, source="desktop")
_arm_due(key)
dispatched: list[str] = []
def submit(rid, sid_, session_, text, **kw):
dispatched.append(text)
return True
stop = threading.Event()
p_submit, p_emit = _submits(server, submit)
with p_submit, p_emit:
t = threading.Thread(target=server._notification_poller_loop, args=(stop, sid, s), daemon=True)
t.start()
deadline = time.monotonic() + 8
while not dispatched and time.monotonic() < deadline:
time.sleep(0.1)
stop.set()
t.join(timeout=5)
from hermes_cli.heartbeat import load_heartbeat
assert len(dispatched) == 1 and "report backend health" in dispatched[0]
assert s["running"] is True # claimed for the heartbeat turn
assert load_heartbeat(key).fire_count == 1 and not load_heartbeat(key).is_due()
def test_desktop_poller_leaves_gateway_owned_heartbeat_for_gateway(server, session, hermes_home):
"""A Desktop viewer must not consume a messaging session's routed heartbeat, but ownership follows the
gateway's live routing index, not the row's immutable ``source``: once /reset archives the row the gateway
never registers a watch for it again, so the Desktop viewer must fire it (else nobody does)."""
from gateway.config import GatewayConfig, Platform
from gateway.session import SessionSource, SessionStore
from hermes_cli.heartbeat import load_heartbeat
sid, _, s = session
s["source"] = "desktop"
store = SessionStore(hermes_home / "sessions", GatewayConfig())
store._db = server._get_db() # the routing index lives in the store the Desktop poller reads
src = SessionSource(platform=Platform.TELEGRAM, chat_id="42")
archived_key = store.get_or_create_session(src).session_id
current_key = store.get_or_create_session(src, force_new=True).session_id
for key, desktop_fires in ((current_key, False), (archived_key, True)):
s["session_key"], s["running"] = key, False
_arm_due(key)
p_submit, p_emit = _submits(server, MagicMock())
with p_submit as submit, p_emit:
server._maybe_fire_tui_heartbeat_tick(sid, s)
assert submit.called is desktop_fires, key
assert (load_heartbeat(key).fire_count == 1) is desktop_fires
assert load_heartbeat(key).is_due() is not desktop_fires
@pytest.mark.parametrize("running,due", [(True, True), (False, False)])
def test_heartbeat_tick_defers_when_busy_or_not_due(server, session, running, due):
sid, key, s = session
mgr = _arm_due(key)
if not due:
mgr.state.created_at = time.time()
from hermes_cli.heartbeat import save_heartbeat
save_heartbeat(key, mgr.state)
s["running"] = running
p_submit, p_emit = _submits(server, MagicMock())
with p_submit as submit, p_emit:
server._maybe_fire_tui_heartbeat_tick(sid, s)
submit.assert_not_called()
from hermes_cli.heartbeat import load_heartbeat
assert s["running"] is running # a busy session is never released by the poller
assert load_heartbeat(key).fire_count == 0 # tick not consumed — still due when the session frees up
@pytest.mark.parametrize("failure", ["refused", "raised"])
def test_heartbeat_dispatch_that_never_starts_a_turn_stays_due(server, session, failure):
"""A refused/failed submit must release the claim AND rewind the persisted fire, otherwise the tick is
silently consumed (fire_count advanced, nothing ran) — the Desktop-side follow-up bug in #104011."""
sid, key, s = session
_arm_due(key)
def submit(*a, **k):
if failure == "raised":
raise RuntimeError("transport down")
with s["history_lock"]:
s["running"] = False # _admit_prompt_turn refusal releases itself and returns False
return False
p_submit, p_emit = _submits(server, submit)
with p_submit, p_emit:
server._maybe_fire_tui_heartbeat_tick(sid, s)
from hermes_cli.heartbeat import load_heartbeat
assert s["running"] is False
assert load_heartbeat(key).fire_count == 0 and load_heartbeat(key).is_due()
def test_abandon_fire_never_overwrites_a_concurrent_pause(hermes_home):
from hermes_cli.heartbeat import HeartbeatManager, load_heartbeat
key = "hb-abandon-race"
driver = _arm_due(key)
assert driver.due_prompt() is not None
HeartbeatManager(key).pause() # lands between the claim and the failed dispatch
assert driver.abandon_fire() is False
assert load_heartbeat(key).status == "paused" and load_heartbeat(key).fire_count == 1