"""Which deferred platform adapters a gateway config/env pass must import. Bundled platform plugins register lazily (``PlatformRegistry.register_deferred``); importing all ~20 of them costs every cold gateway start about half a second (discord, telegram, google_chat SDKs, telegram's i18n catalog) although a fresh profile configures none. The config passes in ``gateway.config_loader`` / ``gateway.config_env`` only need a platform's hooks (``apply_yaml_config_fn``, ``env_enablement_fn``, ``is_connected``) when the profile could be configuring that platform, so they materialize only names with *activation evidence*: * a config block for it (top-level ``:``, ``platforms.``, ``gateway.platforms.``, ``gateway.``, or a legacy ``gateway.json`` row) — including a sibling block such as ``wecom_callback`` (registered by the ``wecom`` plugin); * an env var (process env, the profile ``.env``, or the active secret scope) under the platform's prefix (``TELEGRAM_*``, ``GOOGLE_CHAT_*``) or named in its manifest ``requires_env`` (``TWILIO_*`` for sms); * a credential-pool record for it in the profile ``auth.json`` (Photon stores project creds there). The rule over-approximates on purpose: a false positive costs one import, a false negative would leave a configured platform down. Any lookup by name (``platform_registry.get``) still imports a deferred adapter on demand. """ from __future__ import annotations import json import logging import os from pathlib import Path from typing import Any, Callable, Iterable, Optional logger = logging.getLogger(__name__) def _yaml_block_names(yaml_cfg: Any) -> set[str]: """Keys of every mapping a platform block may live in (``platform_section`` / ``merge_platform_sections`` read the same places): ``:``, ``platforms.``, ``gateway.``, ``gateway.platforms.``.""" if not isinstance(yaml_cfg, dict): return set() gateway: dict = yaml_cfg["gateway"] if isinstance(yaml_cfg.get("gateway"), dict) else {} parents = (yaml_cfg, yaml_cfg.get("platforms"), gateway, gateway.get("platforms")) return {str(k) for parent in parents if isinstance(parent, dict) for k, v in parent.items() if isinstance(v, dict)} def _env_names(home: Optional[Path]) -> set[str]: names = {k for k, v in os.environ.items() if str(v).strip()} try: from agent.secret_scope import current_secret_scope, load_env_file scope = current_secret_scope() if scope is not None: names.update(k for k, v in scope.items() if str(v).strip()) if home is not None: names.update(k for k, v in load_env_file(home / ".env").items() if str(v).strip()) # Values an external secret source (Bitwarden, 1Password) resolved for this home, and # the administrator-managed .env: both feed the profile scope the adapters read. from hermes_cli.env_loader import get_secret_source_values names.update(k for k, v in get_secret_source_values(home).items() if str(v).strip()) from hermes_cli.managed_scope import load_managed_env names.update(k for k, v in load_managed_env().items() if str(v).strip()) except Exception: logger.debug("platform activation: env scan degraded", exc_info=True) return names def _credential_pool_names(home: Optional[Path]) -> set[str]: if home is None: return set() try: with open(home / "auth.json", encoding="utf-8-sig") as handle: pool = (json.load(handle) or {}).get("credential_pool") or {} return {str(k) for k in pool} if isinstance(pool, dict) else set() except FileNotFoundError: return set() except Exception: logger.debug("platform activation: auth.json unreadable", exc_info=True) return set() def _matches(name: str, candidates: Iterable[str]) -> bool: lowered = name.lower() return any(c.lower() == lowered or c.lower().startswith(lowered + "_") for c in candidates) def _legacy_gateway_json_names(home: Path) -> set[str]: try: with open(home / "gateway.json", encoding="utf-8-sig") as handle: rows = (json.load(handle) or {}).get("platforms") or {} return {str(k) for k in rows} if isinstance(rows, dict) else set() except FileNotFoundError: return set() except (OSError, ValueError, AttributeError): # Unreadable or not a {"platforms": {...}} document: the YAML/env/pool evidence still applies. logger.debug("platform activation: gateway.json unreadable", exc_info=True) return set() def activation_predicate( *, yaml_cfg: Any = None, platform_names: Iterable[str] = (), home: Optional[Path] = None, registry: Any = None, ) -> Callable[[str], bool]: """``name -> bool``: does this profile show evidence of configuring platform *name*? *yaml_cfg* is the loaded config.yaml layer (read from *home* when omitted), *platform_names* any already-merged platform keys (``GatewayConfig.platforms``). *home* defaults to the active Hermes home. """ if home is None: from hermes_constants import get_hermes_home home = get_hermes_home() if yaml_cfg is None and home is not None: try: from gateway.config_loader import read_yaml_layers yaml_cfg = read_yaml_layers(home) except Exception: logger.debug("platform activation: config.yaml unreadable", exc_info=True) blocks = _yaml_block_names(yaml_cfg) | {str(getattr(n, "value", n)) for n in platform_names} if home is not None: blocks |= _legacy_gateway_json_names(home) env = _env_names(home) upper_env = {e.upper() for e in env} pools = _credential_pool_names(home) def has_evidence(name: str) -> bool: if _matches(name, blocks) or _matches(name, pools): return True prefix = name.upper().replace("-", "_") + "_" if any(e.startswith(prefix) for e in upper_env): return True declared = registry.activation_env(name) if registry is not None else frozenset() return any(d.upper() in upper_env for d in declared) return has_evidence def configured_plugin_entries(registry: Any, **evidence: Any) -> list: """Plugin entries for platforms this profile configures (see module docstring); already-loaded entries are always included. Never imports an adapter with no activation evidence.""" if registry is None: return [] wanted = activation_predicate(registry=registry, **evidence) return [e for e in registry.configured_entries(wanted) if e.source == "plugin"]