mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-16 19:36:54 +00:00
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
99 lines
4 KiB
Python
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)
|