The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Regression tests for profile-scoped dashboard Channels endpoints.
Before the ``profile`` parameter existed, ``/api/messaging/platforms`` always
read/wrote the dashboard process's own (root) ``.env`` via ``load_env()`` /
``save_env_value()`` — so a dashboard switched to a freshly created profile
still displayed and persisted the ROOT install's messaging credentials.
These tests pin the new behavior: reads and writes land in the REQUESTED
profile's HERMES_HOME, and the dashboard's own profile stays untouched.
"""
import pytest
import hermes_yaml as yaml
import gateway.status as _gw_status
_VALID_WORKER_BOT_TOKEN = "123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZ_1234"
_VALID_BODY_BOT_TOKEN = "987654321:ZYXWVUTSRQPONMLKJIHGFEDCBA_4321"
@pytest.fixture
def isolated_profiles(tmp_path, monkeypatch, _isolate_hermes_home):
"""Isolated default home + one named profile, each with its own .env."""
from hermes_constants import get_hermes_home
from hermes_cli import profiles
default_home = get_hermes_home()
profiles_root = default_home / "profiles"
worker_home = profiles_root / "worker_alpha"
for home in (default_home, worker_home):
home.mkdir(parents=True, exist_ok=True)
(home / "config.yaml").write_text("{}\n", encoding="utf-8")
(default_home / ".env").write_text(
"TELEGRAM_BOT_TOKEN=root-token\n", encoding="utf-8"
)
(worker_home / ".env").write_text("", encoding="utf-8")
monkeypatch.setattr(profiles, "_get_default_hermes_home", lambda: default_home)
monkeypatch.setattr(profiles, "_get_profiles_root", lambda: profiles_root)
return {"default": default_home, "worker_alpha": worker_home}
@pytest.fixture
def client(monkeypatch, isolated_profiles):
try:
from starlette.testclient import TestClient
except ImportError:
pytest.skip("fastapi/starlette not installed")
import hermes_state
from hermes_constants import get_hermes_home
from hermes_cli.web_server import app, _SESSION_HEADER_NAME, _SESSION_TOKEN
monkeypatch.setattr(hermes_state, "DEFAULT_DB_PATH", get_hermes_home() / "state.db")
# The dashboard process's os.environ may carry root-install credentials;
# make sure the scoped path never falls back to them.
monkeypatch.delenv("TELEGRAM_BOT_TOKEN", raising=False)
c = TestClient(app)
c.headers[_SESSION_HEADER_NAME] = _SESSION_TOKEN
return c
def _telegram(payload):
return next(p for p in payload["platforms"] if p["id"] == "telegram")
def _env_field(platform, key):
return next(f for f in platform["env_vars"] if f["key"] == key)
def _on(platform_id, **block):
return {"platforms": {platform_id: {"enabled": True, **block}}}
@pytest.fixture
def no_platform_env(monkeypatch):
"""The token-free tables below assume none of these leak in from the host (a hosted container
stamps GATEWAY_RELAY_URL, which disables direct platforms)."""
for name in ("GATEWAY_RELAY_URL", "GATEWAY_RELAY_ALLOW_DIRECT_PLATFORMS", "WHATSAPP_ENABLED", "WEBHOOK_ENABLED",
"API_SERVER_ENABLED", "API_SERVER_KEY", "MSGRAPH_WEBHOOK_ENABLED", "MSGRAPH_WEBHOOK_CLIENT_STATE"):
monkeypatch.delenv(name, raising=False)
@pytest.mark.parametrize("platform_id, config, env, enabled, configured", [
# Dashboard QR onboarding writes both; ``hermes whatsapp`` writes only the env flag.
pytest.param("whatsapp", _on("whatsapp"), "WHATSAPP_ENABLED=true\n", True, True, id="whatsapp-paired"),
pytest.param("whatsapp", {}, "WHATSAPP_ENABLED=true\n", True, True, id="whatsapp-env-flag-only"),
# Declared but never paired: the gateway would not start the bridge.
pytest.param("whatsapp", _on("whatsapp"), "", True, False, id="whatsapp-unpaired"),
# The flag off wins over an enabled block (the explicit enable stops the plugin's re-enable pass).
pytest.param("whatsapp", _on("whatsapp", extra={"mode": "bot"}), "WHATSAPP_ENABLED=false\n",
False, False, id="whatsapp-flag-off"),
# The dashboard's disable writes only ``enabled: false``; the leftover env flag must not re-enable it.
pytest.param("whatsapp", {"platforms": {"whatsapp": {"enabled": False}}}, "WHATSAPP_ENABLED=true\n",
False, True, id="whatsapp-disabled-flag-on"),
pytest.param("webhook", _on("webhook"), "", True, True, id="webhook"),
# Settings without ``enabled``: the gateway leaves it off, so the card must not say enabled.
pytest.param("webhook", {"platforms": {"webhook": {"extra": {"port": 8123}}}}, "", False, True, id="webhook-not-enabled"),
pytest.param("api_server", {}, "", False, False, id="api-server-absent"),
# The API server refuses to start without a usable key.
pytest.param("api_server", _on("api_server"), "", True, False, id="api-server-no-key"),
pytest.param("api_server", _on("api_server", extra={"key": "k" * 24}), "", True, True, id="api-server-key"),
pytest.param("api_server", {"platforms": {"api_server": {"enabled": False}}}, "API_SERVER_KEY=" + "k" * 32 + "\n",
False, True, id="api-server-disabled-env-key"),
# A top-level block is the gateway's too, explicit disable included.
pytest.param("whatsapp", {"whatsapp": {"enabled": False}}, "WHATSAPP_ENABLED=true\n", False, True,
id="whatsapp-toplevel-disabled-flag-on"),
pytest.param("msgraph_webhook", _on("msgraph_webhook"), "", True, False, id="msgraph-no-client-state"),
pytest.param("msgraph_webhook", _on("msgraph_webhook", extra={"client_state": "state"}), "", True, True,
id="msgraph-client-state"),
pytest.param("msgraph_webhook", {"platforms": {"msgraph_webhook": {"enabled": False}}},
"MSGRAPH_WEBHOOK_ENABLED=true\nMSGRAPH_WEBHOOK_CLIENT_STATE=state\n", False, True,
id="msgraph-disabled-env-on"),
pytest.param("relay", _on("relay"), "", True, False, id="relay-no-url"),
])
def test_scoped_token_free_platform_status_matches_the_gateway(
client, isolated_profiles, no_platform_env, platform_id, config, env, enabled, configured
):
"""Token-free built-ins show exactly what the profile's gateway decides for them."""
worker_home = isolated_profiles["worker_alpha"]
(worker_home / "config.yaml").write_text(yaml.safe_dump(config), encoding="utf-8")
(worker_home / ".env").write_text(env, encoding="utf-8")
resp = client.get("/api/messaging/platforms", params={"profile": "worker_alpha"})
assert resp.status_code == 200
platform = next((p for p in resp.json()["platforms"] if p["id"] == platform_id), None)
assert platform is not None, platform_id
assert (platform["enabled"], platform["configured"]) == (enabled, configured)
_MSGRAPH = {"msgraph_webhook": {"enabled": True, "extra": {"client_state": "state"}}}
@pytest.mark.parametrize("config, direct_enabled", [
pytest.param({"platforms": {**_MSGRAPH, "relay": {"enabled": True}}}, False, id="relay-owns-connections"),
pytest.param({"platforms": {**_MSGRAPH, "relay": {"enabled": False}}}, True, id="relay-opted-out"),
pytest.param({"platforms": _MSGRAPH, "relay": {"enabled": False}}, True, id="relay-opted-out-toplevel"),
])
def test_scoped_status_follows_the_profiles_relay_block(
client, isolated_profiles, no_platform_env, monkeypatch, config, direct_enabled
):
"""A container's relay URL disables direct platforms unless the profile's relay is turned off."""
monkeypatch.setenv("GATEWAY_RELAY_URL", "https://relay.example.test")
worker_home = isolated_profiles["worker_alpha"]
(worker_home / "config.yaml").write_text(yaml.safe_dump(config), encoding="utf-8")
platforms = client.get("/api/messaging/platforms", params={"profile": "worker_alpha"}).json()["platforms"]
msgraph = next(p for p in platforms if p["id"] == "msgraph_webhook")
assert (msgraph["enabled"], msgraph["configured"]) == (direct_enabled, True)
@pytest.mark.parametrize("source_enabled, token, counts", [
pytest.param(True, "1" * 9 + ":" + "a" * 35, True, id="enabled"),
pytest.param(False, "1" * 9 + ":" + "a" * 35, False, id="disabled"),
pytest.param(True, "", False, id="enabled-empty-value"),
pytest.param(True, " ", False, id="enabled-blank-value"),
])
def test_scoped_onepassword_credential_counts_only_when_the_source_is_enabled(
client, isolated_profiles, monkeypatch, source_enabled, token, counts
):
"""A 1Password-mapped token is set/configured only when the profile's source is on and resolves it
to a value."""
from agent.secret_sources.base import FetchResult
from agent.secret_sources.onepassword import OnePasswordSource
fetched = []
def fake_fetch(self, cfg, home_path):
fetched.append(home_path)
return FetchResult(secrets={"TELEGRAM_BOT_TOKEN": token})
monkeypatch.setattr(OnePasswordSource, "fetch", fake_fetch)
worker_home = isolated_profiles["worker_alpha"]
(worker_home / "config.yaml").write_text(yaml.safe_dump({
"secrets": {"onepassword": {"enabled": source_enabled,
"env": {"TELEGRAM_BOT_TOKEN": "op://vault/item/credential"}}},
}), encoding="utf-8")
telegram = _telegram(client.get("/api/messaging/platforms", params={"profile": "worker_alpha"}).json())
assert telegram["configured"] is counts
assert _env_field(telegram, "TELEGRAM_BOT_TOKEN")["is_set"] is counts
assert bool(fetched) is source_enabled
class TestProfileScopedMessagingReads:
def test_scoped_read_does_not_show_root_credentials(
self, client, isolated_profiles
):
resp = client.get(
"/api/messaging/platforms", params={"profile": "worker_alpha"}
)
assert resp.status_code == 200
telegram = _telegram(resp.json())
token = _env_field(telegram, "TELEGRAM_BOT_TOKEN")
# The worker profile has an empty .env — the root token must not leak.
assert token["is_set"] is False
assert telegram["configured"] is False
def test_allowlist_value_is_readable_but_secrets_stay_redacted(
self, client, isolated_profiles
):
"""Clients edit an allowlist one ID per entry, so they need its saved value;
the bot token next to it must still only ever leave as a redacted preview."""
(isolated_profiles["worker_alpha"] / ".env").write_text(
f"TELEGRAM_BOT_TOKEN={_VALID_WORKER_BOT_TOKEN}\nTELEGRAM_ALLOWED_USERS=111,222\n",
encoding="utf-8",
)
telegram = _telegram(
client.get("/api/messaging/platforms", params={"profile": "worker_alpha"}).json()
)
allowlist = _env_field(telegram, "TELEGRAM_ALLOWED_USERS")
token = _env_field(telegram, "TELEGRAM_BOT_TOKEN")
assert (allowlist["is_list"], allowlist["value"]) == (True, "111,222")
assert (token["is_list"], token["value"]) == (False, None)
assert _VALID_WORKER_BOT_TOKEN not in str(token)
def test_unknown_profile_returns_404(self, client, isolated_profiles):
resp = client.get(
"/api/messaging/platforms", params={"profile": "no_such_profile"}
)
assert resp.status_code == 404
def test_scoped_read_returns_profile_path_command_and_startup_failure(
self, client, isolated_profiles, monkeypatch
):
from hermes_cli import web_server
worker_home = isolated_profiles["worker_alpha"]
(worker_home / ".env").write_text(
"TELEGRAM_BOT_TOKEN=worker-token\n", encoding="utf-8"
)
(worker_home / "config.yaml").write_text(
yaml.safe_dump({"platforms": {"telegram": {"enabled": True}}}),
encoding="utf-8",
)
monkeypatch.setattr(_gw_status, "get_running_pid", lambda *a, **k: None)
monkeypatch.setattr(
_gw_status, "get_running_pid_cached", lambda *a, **k: None
)
monkeypatch.setattr(
_gw_status,
"read_runtime_status",
# Accepts path= : the profile-scoped read now passes the
# profile's own gateway_state.json explicitly rather than
# relying on process-level HERMES_HOME resolution (#71211).
lambda *a, **k: {
"gateway_state": "startup_failed",
"exit_reason": "all configured messaging platforms failed to connect",
"platforms": {},
},
)
resp = client.get(
"/api/messaging/platforms", params={"profile": "worker_alpha"}
)
assert resp.status_code == 200
payload = resp.json()
assert payload["env_path"] == str(worker_home / ".env")
assert payload["gateway_start_command"] == (
"hermes -p worker_alpha gateway start"
)
telegram = _telegram(payload)
assert telegram["state"] == "startup_failed"
assert telegram["error_code"] == "startup_failed"
assert telegram["error_message"] == (
"all configured messaging platforms failed to connect"
)
class TestProfileScopedMessagingWrites:
def test_scoped_write_lands_in_target_profile_env(
self, client, isolated_profiles
):
resp = client.put(
"/api/messaging/platforms/telegram",
params={"profile": "worker_alpha"},
json={
"enabled": True,
"env": {"TELEGRAM_BOT_TOKEN": _VALID_WORKER_BOT_TOKEN},
},
)
assert resp.status_code == 200
worker_env = (
isolated_profiles["worker_alpha"] / ".env"
).read_text(encoding="utf-8")
assert f"TELEGRAM_BOT_TOKEN={_VALID_WORKER_BOT_TOKEN}" in worker_env
# The dashboard's own .env must stay untouched — this was the bug.
root_env = (isolated_profiles["default"] / ".env").read_text(
encoding="utf-8"
)
assert _VALID_WORKER_BOT_TOKEN not in root_env
assert "TELEGRAM_BOT_TOKEN=root-token" in root_env
# Enablement lands in the target profile's config.yaml.
worker_cfg = yaml.safe_load(
(isolated_profiles["worker_alpha"] / "config.yaml").read_text(encoding="utf-8")
) or {}
assert worker_cfg.get("platforms", {}).get("telegram", {}).get("enabled") is True
root_cfg = yaml.safe_load(
(isolated_profiles["default"] / "config.yaml").read_text(encoding="utf-8")
) or {}
assert "telegram" not in (root_cfg.get("platforms") or {})
def test_scoped_read_after_scoped_write_round_trips(
self, client, isolated_profiles
):
client.put(
"/api/messaging/platforms/telegram",
params={"profile": "worker_alpha"},
json={
"enabled": True,
"env": {"TELEGRAM_BOT_TOKEN": _VALID_WORKER_BOT_TOKEN},
},
)
resp = client.get(
"/api/messaging/platforms", params={"profile": "worker_alpha"}
)
telegram = _telegram(resp.json())
assert telegram["enabled"] is True
assert _env_field(telegram, "TELEGRAM_BOT_TOKEN")["is_set"] is True
assert telegram["configured"] is True
def _enable_multiplex(default_home):
(default_home / "config.yaml").write_text(
yaml.safe_dump({"gateway": {"multiplex_profiles": True}}),
encoding="utf-8",
)
class TestMultiplexPortBindingGuard:
"""Enabling api_server/webhook on a secondary multiplexed profile is rejected BEFORE anything
is persisted: the default profile's listener already mirrors them at ``/p/<profile>/`` (#62791).
Every other inbound-port platform is allowed — the gateway serves it on the shared listener.
"""
@pytest.fixture(autouse=True)
def _no_multiplex_env_override(self, monkeypatch):
# The operator env override must not leak into these tests: the
# multiplex flag under test comes from the default profile's config.
monkeypatch.delenv("GATEWAY_MULTIPLEX_PROFILES", raising=False)
def test_rejects_only_mirrored_listeners_on_secondary(
self, client, isolated_profiles
):
from gateway.config import PORT_BINDING_PLATFORM_VALUES, SHARED_LISTENER_MIRROR_PLATFORMS
_enable_multiplex(isolated_profiles["default"])
assert SHARED_LISTENER_MIRROR_PLATFORMS # guard set must not be empty
catalog = {p["id"] for p in client.get("/api/messaging/platforms").json()["platforms"]}
for platform_id in sorted(PORT_BINDING_PLATFORM_VALUES & catalog):
resp = client.put(
f"/api/messaging/platforms/{platform_id}",
params={"profile": "worker_alpha"},
json={"enabled": True},
)
if platform_id in SHARED_LISTENER_MIRROR_PLATFORMS:
assert resp.status_code == 409, platform_id
else: # served at /p/worker_alpha/<path> on the shared listener
assert resp.status_code == 200, (platform_id, resp.text)
def test_secondary_can_disable_and_clear_invalid_config(
self, client, isolated_profiles
):
_enable_multiplex(isolated_profiles["default"])
worker_home = isolated_profiles["worker_alpha"]
(worker_home / "config.yaml").write_text(
yaml.safe_dump({"platforms": {"api_server": {"enabled": True}}}),
encoding="utf-8",
)
resp = client.put(
"/api/messaging/platforms/api_server",
params={"profile": "worker_alpha"},
json={"enabled": False},
)
assert resp.status_code == 200
cfg = yaml.safe_load((worker_home / "config.yaml").read_text(encoding="utf-8"))
assert cfg["platforms"]["api_server"]["enabled"] is False
catalog = client.get(
"/api/messaging/platforms", params={"profile": "worker_alpha"}
).json()
api_server = next(p for p in catalog["platforms"] if p["id"] == "api_server")
if api_server["env_vars"]:
resp = client.put(
"/api/messaging/platforms/api_server",
params={"profile": "worker_alpha"},
json={"clear_env": [api_server["env_vars"][0]["key"]]},
)
assert resp.status_code == 200
def test_named_current_home_matches_unscoped(client, isolated_profiles, monkeypatch):
from hermes_cli.web_server_profiles import _config_profile_scope, _hermes_home_scope
from hermes_constants import get_hermes_home
monkeypatch.setenv("TELEGRAM_BOT_TOKEN", "root-token")
for scope in (None, "current", "default"):
response = client.get("/api/messaging/platforms", params={"profile": scope} if scope else {})
assert response.status_code == 200
assert _telegram(response.json())["enabled"] is True
with _hermes_home_scope(isolated_profiles["worker_alpha"]):
with _config_profile_scope("default") as scoped:
assert scoped is None
assert get_hermes_home() == isolated_profiles["default"]
def test_scoped_enablement_uses_only_own_credentials(client, isolated_profiles, monkeypatch):
monkeypatch.setenv("TELEGRAM_BOT_TOKEN", "root-token")
worker = isolated_profiles["worker_alpha"]
params = {"profile": "worker_alpha"}
assert _telegram(client.get("/api/messaging/platforms", params=params).json())["enabled"] is False
(worker / ".env").write_text("TELEGRAM_BOT_TOKEN=worker-token\n", encoding="utf-8")
payload = client.get("/api/messaging/platforms", params=params).json()
assert _telegram(payload)["enabled"] is True
assert _telegram(payload)["configured"] is True
assert _telegram(payload)["state"] != "disabled"
from hermes_cli.web_server_messaging import _messaging_platform_catalog
empty = {entry["id"] for entry in _messaging_platform_catalog() if not entry["required_env"]}
for platform in payload["platforms"]:
if platform["id"] in empty:
assert platform["enabled"] is False
assert platform["configured"] is False
for enabled in (False, True):
(worker / "config.yaml").write_text(yaml.safe_dump({"platforms": {"telegram": {"enabled": enabled}}}), encoding="utf-8")
platform = _telegram(client.get("/api/messaging/platforms", params=params).json())
assert platform["enabled"] is enabled
assert platform["configured"] is True
assert "root-token" in (isolated_profiles["default"] / ".env").read_text(encoding="utf-8")
@pytest.mark.parametrize("topology", ["scoped_query", "pooled_unscoped"])
def test_credential_write_hot_serves_a_multiplexed_profile(client, isolated_profiles, monkeypatch, topology):
"""A token saved for a profile the live multiplexer serves is handed to the multiplexer right
away (``hot_served``), so the UI skips its restart banner. Both Desktop topologies: the dashboard's
``?profile=`` and a pooled ``hermes --profile X serve`` that receives the PUT unscoped (#109088)."""
import hermes_cli.gateway as gateway_cli
import hermes_cli.gateway_multiplex_served as served_mod
notified = []
monkeypatch.setattr(gateway_cli, "named_profile_served_by_running_multiplexer", lambda name=None: name == "worker_alpha")
monkeypatch.setattr(served_mod, "notify_multiplexer_profiles_changed", lambda name, **kw: notified.append(name) or ["default", name])
if topology == "pooled_unscoped":
monkeypatch.setattr(gateway_cli, "_current_profile_name", lambda: "worker_alpha")
params = {}
else:
params = {"profile": "worker_alpha"}
resp = client.put("/api/messaging/platforms/telegram", params=params,
json={"enabled": True, "env": {"TELEGRAM_BOT_TOKEN": _VALID_WORKER_BOT_TOKEN}})
assert resp.status_code == 200
assert resp.json()["hot_served"] is True
assert notified == ["worker_alpha"]
def test_credential_write_on_default_profile_is_not_hot_served(client, isolated_profiles, monkeypatch):
"""The default profile is the multiplexer itself (its own adapters are restart-managed): never
claim a hot serve for it."""
import hermes_cli.gateway_multiplex_served as served_mod
monkeypatch.setattr(served_mod, "notify_multiplexer_profiles_changed",
lambda name, **kw: pytest.fail("default profile must not ping the multiplexer"))
resp = client.put("/api/messaging/platforms/telegram",
json={"enabled": True, "env": {"TELEGRAM_BOT_TOKEN": _VALID_WORKER_BOT_TOKEN}})
assert resp.status_code == 200
assert resp.json()["hot_served"] is False