| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158 |
- """Per-platform slash command access control.
- A second axis beside ``allow_from``: of the users allowed to talk to the gateway, which may run
- which slash commands. Two lists per scope (DM vs group, mirroring ``allow_from`` /
- ``group_allow_from``): ``allow_admin_from`` (user IDs that get every registered command, built-in
- and plugin) and ``user_allowed_commands`` (names non-admins may run; empty/unset -> only the
- ``_ALWAYS_ALLOWED_FOR_USERS`` floor). No ``allow_admin_from`` for a scope => gating disabled there,
- so existing installs are unaffected until an operator lists an admin. Applied at the dispatch
- site in ``gateway/run.py`` via the live registry; never affects plain chat.
- """
- from __future__ import annotations
- from dataclasses import dataclass
- from typing import Any, Callable, FrozenSet, Iterable, Optional
- # Read-only floor every allowed user keeps under gating, so a non-admin can still discover what
- # they can do. ``user_allowed_commands`` only adds to this set, never restricts it.
- _ALWAYS_ALLOWED_FOR_USERS: frozenset[str] = frozenset({"help", "whoami"})
- _DM_CHAT_TYPES = frozenset({"dm", "direct", "private", ""})
- # scope -> (admin list key, user command list key)
- _SCOPE_KEYS = {
- "dm": ("allow_admin_from", "user_allowed_commands"),
- "group": ("group_allow_admin_from", "group_user_allowed_commands"),
- }
- @dataclass(frozen=True)
- class SlashAccessPolicy:
- """Resolved access policy for one (platform, scope) pair; scope is ``"dm"`` or ``"group"``."""
- enabled: bool # gating active for this scope?
- admin_user_ids: frozenset[str]
- user_allowed_commands: frozenset[str]
- def is_admin(self, user_id: Optional[str]) -> bool:
- # Gating disabled -> everyone is admin so callers can use is_admin/can_run uniformly.
- if not self.enabled:
- return True
- return bool(user_id) and str(user_id) in self.admin_user_ids
- def can_run(self, user_id: Optional[str], canonical_cmd: str) -> bool:
- if self.is_admin(user_id):
- return True
- return bool(canonical_cmd) and (
- canonical_cmd in _ALWAYS_ALLOWED_FOR_USERS or canonical_cmd in self.user_allowed_commands
- )
- _DISABLED_POLICY = SlashAccessPolicy(
- enabled=False, admin_user_ids=frozenset(), user_allowed_commands=frozenset()
- )
- # Gated with nobody on the admin list: only the ``_ALWAYS_ALLOWED_FOR_USERS`` floor runs.
- _FAIL_CLOSED_POLICY = SlashAccessPolicy(
- enabled=True, admin_user_ids=frozenset(), user_allowed_commands=frozenset()
- )
- def _coerce_list(raw: Any, normalize: Callable[[str], str] = str) -> frozenset[str]:
- """Normalize a YAML-loaded value (None, list/tuple/set, comma string, or scalar) into a
- frozenset of stripped, non-empty strings, applying ``normalize`` to each."""
- if raw is None:
- return frozenset()
- if isinstance(raw, (list, tuple, set, frozenset)):
- items: Iterable[Any] = raw
- elif isinstance(raw, str):
- items = (s for s in raw.split(",") if s.strip())
- else:
- items = (raw,) # single scalar (int user id, etc.)
- return frozenset(s for s in (normalize(str(it).strip()) for it in items) if s)
- def _coerce_id_list(raw: Any) -> frozenset[str]:
- """Normalize an admin/user id list into a frozenset of strings."""
- return _coerce_list(raw)
- def _coerce_command_list(raw: Any) -> frozenset[str]:
- """Command allowlist: strip leading slashes (``/help`` or ``help``) and lowercase to match
- how ``resolve_command()`` stores names."""
- return _coerce_list(raw, lambda s: s.lstrip("/").lower())
- def policy_from_extra(extra: dict, scope: str) -> SlashAccessPolicy:
- """Build a policy from a platform's ``extra`` dict for one scope.
- DM scope falls back to ``group_user_allowed_commands`` ONLY for the command list, and only
- when DM didn't set its own. Admin lists are NOT cross-scope: a DM admin is not a group admin.
- """
- admin_key, cmd_key = _SCOPE_KEYS.get(scope, _SCOPE_KEYS["dm"])
- admin_ids = _coerce_id_list(extra.get(admin_key))
- cmds = _coerce_command_list(extra.get(cmd_key))
- if scope == "dm" and not cmds:
- cmds = _coerce_command_list(extra.get("group_user_allowed_commands"))
- return SlashAccessPolicy(enabled=bool(admin_ids), admin_user_ids=admin_ids, user_allowed_commands=cmds)
- def policy_for_source(gateway_config: Any, source: Any) -> SlashAccessPolicy:
- """Resolve the slash-gating policy for a SessionSource.
- Disabled (allow-everything) when gateway_config/source is None, the platform has no
- PlatformConfig, or no admin list is set for the scope. Gates slash commands only, never chat.
- """
- if gateway_config is None or source is None:
- return _DISABLED_POLICY
- platforms = getattr(gateway_config, "platforms", None)
- platform_config = None
- if platforms is not None:
- try:
- platform_config = platforms.get(source.platform)
- except Exception:
- platform_config = None
- # ``extra`` from a PlatformConfig-like object, or a bare dict as some test harnesses pass.
- extra = getattr(platform_config, "extra", None)
- if not isinstance(extra, dict):
- extra = platform_config if isinstance(platform_config, dict) else {}
- chat_type = getattr(source, "chat_type", None)
- normalized = str(chat_type).strip().lower() if chat_type is not None else ""
- if normalized:
- scope = "dm" if normalized in _DM_CHAT_TYPES else "group"
- return policy_from_extra(extra, scope)
- # Blank/None chat_type is ambiguous (relay frames may send "" / null; restored rows keep a
- # stored empty value verbatim). _DM_CHAT_TYPES lists "" but a truthiness guard made it
- # unreachable: resolve to whichever scope is gated so an ambiguous source never lands in an
- # ungated allow-everything scope; keep the historical group scope on a tie.
- dm_policy = policy_from_extra(extra, "dm")
- group_policy = policy_from_extra(extra, "group")
- return dm_policy if dm_policy.enabled and not group_policy.enabled else group_policy
- __all__ = ["SlashAccessPolicy", "policy_for_source", "policy_from_extra"]
- def policy_for_runner_source(runner: Any, source: Any) -> SlashAccessPolicy:
- """Slash-gating policy from the profile whose bot received ``source``.
- Under ``multiplex_profiles`` the runner's ``config`` is the launch profile's alone, so a platform
- configured only in a secondary profile had no PlatformConfig there and every caller came back
- unrestricted (#121705). Authorization follows the transport (bot-owning) profile, the owner
- ``RoutingIdentity.authorization_home`` already names; a served profile whose config is not cached
- fails closed instead of inheriting the launch profile's open policy.
- """
- config = getattr(runner, "config", None)
- if not getattr(config, "multiplex_profiles", False) or source is None:
- return policy_for_source(config, source)
- from gateway.session_identity import identity_of
- identity = identity_of(source)
- owner = identity.transport_profile if identity is not None else getattr(source, "profile", None)
- primary = getattr(runner, "_primary_profile_name", None) or "default"
- if owner and owner != primary:
- config = (getattr(runner, "_profile_configs", None) or {}).get(owner)
- if config is None:
- return _FAIL_CLOSED_POLICY
- return policy_for_source(config, source)
|