hermes-agent/tests/tui_gateway/test_session_archive_rpc.py
Brooklyn Nicholson d3f9ba3cd5 feat(tui_gateway): add session.archive RPC for Desktop archive parity
Desktop archives sessions via PATCH /api/sessions/{id} -> set_session_archived,
but the TUI gateway had no equivalent JSON-RPC method, so TUI clients had to
keep every session visible or delete it permanently. Open PR #47184 added this
against the pre-split server.py layout and resolves only live runtime sessions;
this lands the method on current main next to session.set_hidden with the same
two-tier resolution: live runtime id first (unpersisted drafts defer via
pending_archived, applied by _ensure_session_db_row like pending_hidden), then
a stored id/key resolved through the profile db, covering the historical rows
the session.list picker shows. Contract declared in tui_gateway/contracts and
rendered into the generated TS/OpenRPC catalog.

Fixes https://github.com/NousResearch/hermes-agent/issues/47168
2026-09-27 19:06:26 -05:00

99 lines
4 KiB
Python

"""RPC-level tests for ``session.archive`` (tui_gateway, #47168).
Desktop archives sessions via ``PATCH /api/sessions/{id}``; the TUI gateway had no
equivalent JSON-RPC method, so TUI clients had to keep every session visible or
delete it permanently. ``session.archive`` mirrors ``session.set_hidden``:
* a DURABLE stored session id / key archives and un-archives through the profile
db (``SessionDB.set_session_archived``, whole compression lineage);
* a LIVE runtime session id archives its stored key — and a live session with
NO row yet defers via ``pending_archived`` so ``_ensure_session_db_row`` applies
the flag when the first prompt persists the row;
* an unknown id still errors.
"""
import pytest
import tui_gateway.server as srv
import tui_gateway.methods_session # noqa: F401 (registers the RPC methods)
from hermes_state import SessionDB
@pytest.fixture
def db(tmp_path, monkeypatch):
database = SessionDB(tmp_path / "state.db")
monkeypatch.setattr(srv, "_get_db", lambda: database)
try:
yield database
finally:
database.close()
def _call(method: str, params: dict) -> dict:
return srv._methods[method](1, params)
def _seed(db, sid: str) -> None:
db.create_session(sid, source="desktop")
db._conn.execute("UPDATE sessions SET message_count = 1 WHERE id = ?", (sid,))
db._conn.commit()
def test_archive_resolves_stored_id_without_live_session(db):
"""A stored (non-live) session id must be archivable — the session.list picker path."""
_seed(db, "stored-chat")
assert srv._find_live_session_by_key("stored-chat") is None
envelope = _call("session.archive", {"session_id": "stored-chat", "archived": True})
assert "error" not in envelope, envelope
assert envelope["result"]["archived"] is True
assert envelope["result"]["session_key"] == "stored-chat"
assert db.get_session("stored-chat")["archived"] == 1
# And back — unarchive through the same durable path.
envelope = _call("session.archive", {"session_id": "stored-chat", "archived": False})
assert "error" not in envelope, envelope
assert envelope["result"]["archived"] is False
assert db.get_session("stored-chat")["archived"] == 0
def test_archive_accepts_session_key_alias(db):
"""``session_key`` is the documented alias of ``session_id`` (the list rows carry it)."""
_seed(db, "keyed-chat")
envelope = _call("session.archive", {"session_key": "keyed-chat", "archived": True})
assert "error" not in envelope, envelope
assert db.get_session("keyed-chat")["archived"] == 1
def test_archive_unknown_id_still_errors(db):
envelope = _call("session.archive", {"session_id": "no-such-session", "archived": True})
assert envelope.get("error"), envelope
def test_archive_through_the_dispatcher_validates_params(db):
"""The wire path: unknown params are rejected by the contract, and a missing id answers 4006."""
resp = srv.handle_request({"id": "1", "method": "session.archive", "params": {}})
assert resp["error"]["code"] == 4006
resp = srv.handle_request(
{"id": "2", "method": "session.archive", "params": {"session_id": "x", "bogus": 1}})
assert resp["error"]["code"] == 4000
def test_archive_live_runtime_session_defers_until_row_exists(db):
"""A live session with no state.db row yet queues ``pending_archived``; the row is born archived."""
sid = "live-draft"
srv._sessions[sid] = {"session_key": "20260927_000000_draft", "history": [], "running": False}
try:
envelope = _call("session.archive", {"session_id": sid, "archived": True})
assert "error" not in envelope, envelope
assert envelope["result"]["session_key"] == "20260927_000000_draft"
assert db.get_session("20260927_000000_draft") is None # no row yet
# The first prompt persists the row; the deferred intent must land with it.
assert srv._ensure_session_db_row(srv._sessions[sid])
row = db.get_session("20260927_000000_draft")
assert row is not None
assert row["archived"] == 1
finally:
srv._sessions.pop(sid, None)