The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""A served secondary's api_server/webhook are MIRRORS of the default's listener (``/p/<profile>/...``),
never adapters of their own, so the multiplexer record has no ``<profile>:api_server`` entry. Every
status reader used to fall through to ``pending_restart``: the Desktop Messaging card and Command
Center read "Restart needed" forever for a platform that was answering. The mirror must project as the
default's live state plus the URL the client has to call; ``/api/status?profile=`` names the profiles a
restart of the shared gateway would blip.
"""
from __future__ import annotations
import json
import os
import pytest
@pytest.fixture
def served_root(tmp_path, monkeypatch):
root = tmp_path / "hermes"
(root / "profiles" / "alpha").mkdir(parents=True)
(root / "config.yaml").write_text("gateway: {multiplex_profiles: true}\n", encoding="utf-8")
(root / "gateway.pid").write_text(json.dumps({"pid": os.getpid(), "hermes_home": str(root)}), encoding="utf-8")
(root / "gateway_state.json").write_text(json.dumps({
"pid": os.getpid(), "hermes_home": str(root), "gateway_state": "running",
"served_profiles": ["default", "alpha", "beta"],
"platforms": {
"api_server": {"state": "connected", "listener_base": "http://127.0.0.1:45719"},
"webhook": {"state": "fatal", "error_code": "port_in_use"},
"alpha:telegram": {"state": "connected"},
}}), encoding="utf-8")
monkeypatch.setenv("HERMES_HOME", str(root))
monkeypatch.delenv("GATEWAY_MULTIPLEX_PROFILES", raising=False)
import hermes_constants
from gateway import status
# Liveness is a verified identity; this pytest process passes as the default gateway only by
# wearing a gateway command line.
monkeypatch.setattr(status, "_read_process_cmdline", lambda pid: "hermes gateway run")
monkeypatch.setattr(hermes_constants, "_default_hermes_root_memo", None)
return root
def test_messaging_card_shows_mirrored_api_server_enabled_without_local_config(served_root):
"""#121125: a served secondary never configures api_server itself (enabling it there
409s: the shared listener already serves ``/p/<profile>/v1``), so the REAL enablement
reads (False, False) from its own empty config and the card printed Disabled over a
live mirror. No ``_platform_enablement`` monkeypatch here: that mask hid the bug."""
from hermes_cli.web_routers import messaging
entry = {"id": "api_server", "name": "API server", "description": "", "docs_url": "", "env_vars": [],
"required_env": []}
alpha = served_root / "profiles" / "alpha"
[payload] = messaging._platform_payloads(alpha, [entry])
assert payload["gateway_running"] is True
assert payload["enabled"] is True, payload
assert payload["state"] == "connected", payload
assert payload["ingress_url"] == "http://127.0.0.1:45719/p/alpha/v1", payload
def test_served_profile_projects_the_default_listener_mirrors_with_their_url(served_root):
from gateway.status import profile_platforms_from_multiplexer, resolve_gateway_liveness
alpha = served_root / "profiles" / "alpha"
live = resolve_gateway_liveness(profile_dir=alpha, health_probe=None, use_cache=False)
plats = profile_platforms_from_multiplexer(live.runtime, "alpha")
# The mirror inherits the default's live state and points at the profile's own prefix.
assert plats["api_server"]["state"] == "connected"
assert plats["api_server"]["ingress_url"] == "http://127.0.0.1:45719/p/alpha/v1"
# A dead default listener is dead for the profile too — never "connected" by fiat.
assert "webhook" not in plats
assert plats["telegram"] == {"state": "connected"}
# The default profile keeps its own un-prefixed entries; nothing is mirrored onto it.
assert "ingress_url" not in profile_platforms_from_multiplexer(live.runtime, "default").get("api_server", {})
def test_default_profile_keeps_its_flat_adapters_when_rekeyed(served_root):
"""The default's own adapters are the record's FLAT keys (only secondaries get the
``<profile>:`` prefix), so re-keying the multiplexer record for ``default`` must keep them:
``/api/status`` used to report ``gateway_platforms: {}`` for the default profile under
``gateway.multiplex_profiles`` while its adapters were connected and delivering (#123088).
A STANDALONE record (``served_profiles: []``, flat keys only) reaches the same re-key through
the multiplexer rung and must come back unchanged too (#123869)."""
from gateway.status import profile_platforms_from_multiplexer, resolve_gateway_liveness
standalone = {"gateway_state": "running", "served_profiles": [],
"platforms": {"feishu": {"state": "connected"}}}
assert profile_platforms_from_multiplexer(standalone, "default") == {"feishu": {"state": "connected"}}
alpha = served_root / "profiles" / "alpha"
live = resolve_gateway_liveness(profile_dir=alpha, health_probe=None, use_cache=False)
plats = profile_platforms_from_multiplexer(live.runtime, "default")
# The default's un-prefixed entries survive the re-key, exactly as a standalone gateway for
# "default" would have written them — a live api_server and its own fatal webhook.
assert plats["api_server"]["state"] == "connected"
assert "listener_base" in plats["api_server"] # the listener's own entry, never a mirror
assert plats["webhook"]["state"] == "fatal"
# Nothing is mirrored onto the default and no secondary's entry leaks in.
assert all("ingress_url" not in entry for entry in plats.values() if isinstance(entry, dict))
assert "telegram" not in plats # that entry belongs to alpha
def test_messaging_card_for_the_default_home_rekeys_by_the_profile_not_the_dirname(tmp_path, monkeypatch):
"""The multiplexer fold keys on the profile NAME; ``_platform_payloads`` used to pass
``own_home.name`` — the directory basename, ``.hermes`` for the shipped default root or any
custom ``HERMES_HOME`` name, equal to the profile id only for secondaries under
``profiles/<name>``. On the default home the fold came back empty and the Channels card read
"Restart needed" forever while the multiplexer served its flat-keyed adapters (#123088)."""
from gateway import status
from hermes_cli.web_routers import messaging
root = tmp_path / ".hermes" # the shipped default root's literal name — never equal to "default"
root.mkdir()
(root / "config.yaml").write_text("gateway: {multiplex_profiles: true}\n", encoding="utf-8")
record = {
"pid": os.getpid(), "hermes_home": str(root), "gateway_state": "running",
"served_profiles": ["default", "route-runner"],
"platforms": {"telegram": {"state": "connected"}},
}
monkeypatch.setenv("HERMES_HOME", str(root))
import hermes_constants
monkeypatch.setattr(hermes_constants, "_default_hermes_root_memo", None)
# A launch-service gateway's record fails the own-rung argv check (inline ``-c``), so the card
# falls through to the multiplexer rung — mirrored here by an absent own record.
monkeypatch.setattr(messaging, "read_runtime_status", lambda *a, **k: None)
monkeypatch.setattr(status, "multiplexer_liveness_for_profile", lambda home: (os.getpid(), record))
monkeypatch.setattr(status, "_read_process_cmdline", lambda pid: "hermes gateway run")
monkeypatch.setattr(messaging, "_platform_enablement", lambda *a, **k: (True, True, None))
entry = {"id": "telegram", "name": "Telegram", "description": "", "docs_url": "", "env_vars": [],
"required_env": []}
[payload] = messaging._platform_payloads(None, [entry]) # unscoped: the dashboard's own home
assert payload["gateway_running"] is True
assert payload["state"] == "connected", payload
def test_messaging_card_for_a_served_profile_reads_connected_not_restart_needed(served_root, monkeypatch):
from hermes_cli.web_routers import messaging
monkeypatch.setattr(messaging, "_platform_enablement", lambda *a, **k: (True, True, None))
entry = {"id": "api_server", "name": "API server", "description": "", "docs_url": "", "env_vars": [],
"required_env": []}
alpha = served_root / "profiles" / "alpha"
[payload] = messaging._platform_payloads(alpha, [entry])
assert payload["gateway_running"] is True
assert payload["state"] == "connected", payload
assert payload["ingress_url"] == "http://127.0.0.1:45719/p/alpha/v1"
def test_messaging_card_ignores_a_served_profiles_stale_own_runtime_record(served_root, monkeypatch):
"""A served profile writes no live ``gateway_state.json`` of its own, but one left behind by a
pre-multiplex or standalone run (``stopped``, empty platforms) used to shadow the multiplexer's
record: the fallback only ran when the file was missing, the bare-key lookup found nothing, and
the card read "Restart needed" forever for a platform that was connected (#112765)."""
from hermes_cli.web_routers import messaging
monkeypatch.setattr(messaging, "_platform_enablement", lambda *a, **k: (True, True, None))
entry = {"id": "telegram", "name": "Telegram", "description": "", "docs_url": "", "env_vars": [],
"required_env": []}
alpha = served_root / "profiles" / "alpha"
(alpha / "gateway_state.json").write_text(json.dumps(
{"gateway_state": "stopped", "platforms": {}}), encoding="utf-8")
[payload] = messaging._platform_payloads(alpha, [entry])
assert payload["gateway_running"] is True
assert payload["state"] == "connected", payload
# The shared record is scoped per profile: beta has no ``beta:telegram`` entry, so alpha's
# connected verdict must not bleed into beta's card.
beta = served_root / "profiles" / "beta"
beta.mkdir()
(beta / "gateway_state.json").write_text(json.dumps({"gateway_state": "stopped", "platforms": {}}), encoding="utf-8")
[beta_payload] = messaging._platform_payloads(beta, [entry])
assert beta_payload["state"] == "pending_restart", beta_payload
def test_messaging_card_keeps_a_live_own_gateway_record_over_the_multiplexer(served_root, monkeypatch):
"""Transitional dual-live case: a profile running its own standalone gateway while the live
multiplexer still lists it in ``served_profiles``. ``resolve_gateway_liveness`` answers from the
own record (rung 3) before the multiplexer (rung 4); the card must read the same record, or
liveness and platform state come from two different gateways."""
from gateway import status
from hermes_cli.web_routers import messaging
monkeypatch.setattr(messaging, "_platform_enablement", lambda *a, **k: (True, True, None))
alpha = served_root / "profiles" / "alpha"
# Two live gateways: this process is the default multiplexer; a second (fake, never signalled)
# PID wears alpha's argv. Only the live guard sees a foreign PID, so existence is stubbed.
own_pid = 2 ** 22 - 1
(alpha / "gateway_state.json").write_text(json.dumps({
"pid": own_pid, "hermes_home": str(alpha), "gateway_state": "running",
"platforms": {"telegram": {"state": "retrying", "error_code": "network"}}}), encoding="utf-8")
real_pid_exists = status._pid_exists
monkeypatch.setattr(status, "_pid_exists", lambda pid: pid == own_pid or real_pid_exists(pid))
monkeypatch.setattr(status, "_read_process_cmdline",
lambda pid: "hermes -p alpha gateway run" if pid == own_pid else "hermes gateway run")
assert status.multiplexer_liveness_for_profile(alpha) is not None
entry = {"id": "telegram", "name": "Telegram", "description": "", "docs_url": "", "env_vars": [],
"required_env": []}
[payload] = messaging._platform_payloads(alpha, [entry])
assert payload["gateway_running"] is True
assert payload["state"] == "retrying", payload