| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120 |
- """Where a key-less ``PluginContext.inject_message(text)`` goes when plugin code runs for the gateway.
- Before the one-gateway runtime each classic CLI loaded its own plugins, so a key-less inject meant that
- CLI's own chat. The gateway's copy of a plugin (or its plugin host's) serves every session of its
- profile, so the target is picked here, in order:
- 1. The local session the call is working for: the session bound in the calling context (its slash
- command, a hook fired for it, a tool or hook in its turn). Never a guess, however many are open.
- 2. No session in the calling context (a timer, the plugin's own thread): the one local session of the
- plugin's profile launched by the classic CLI (frozen policy source ``cli``) with a viewer attached.
- 3. Otherwise refused by name: nothing is injected anywhere.
- A calling context that is another profile's local session gets the keyed path's refusal naming the
- plugin's profile; any other one (a messaging chat) keeps main's refusal. A resolved target is
- committed like a keyed plugin inject under the session authority: a queued producer admission in that
- session's FIFO, run once, in order.
- """
- from __future__ import annotations
- import contextlib
- import logging
- from pathlib import Path
- import threading
- import time
- from gateway.config import Platform
- logger = logging.getLogger("gateway.run")
- # One refusal warning per (plugin, kind) per window: a plugin retrying on a timer must not flood the log.
- # (plugin, kind) -> when it last warned; a mark past the window is dropped at the next refusal.
- _WARN_WINDOW_S = 300.0
- _warned: dict[tuple[str, str], float] = {}
- _warned_lock = threading.Lock() # refusals run on plugin threads
- def _refuse(plugin_id: str, kind: str, detail: str) -> None:
- now = time.monotonic()
- with _warned_lock:
- for key in [key for key, at in _warned.items() if now - at >= _WARN_WINDOW_S]:
- del _warned[key]
- repeated = (plugin_id, kind) in _warned
- if not repeated:
- _warned[(plugin_id, kind)] = now
- if repeated:
- logger.debug("inject_message from plugin %s refused again: %s", plugin_id, detail)
- return
- logger.warning("inject_message from plugin %s has no session key and %s; nothing was injected. Pass "
- "session_key= (or origin=) to choose the chat.", plugin_id, detail)
- def _local(runner, live) -> bool:
- from gateway.session_local import authorize_local_source
- source = live.source
- return source is not None and source.platform == Platform.LOCAL and authorize_local_source(runner, source) is True
- def _launched_by_classic_cli(runner, live) -> bool:
- from gateway.session_policy import policy_for_source
- from hermes_state_runtime import RuntimeStoreError
- try:
- policy = policy_for_source(runner, live.source)
- except RuntimeStoreError:
- return False
- return policy is not None and policy.source == "cli"
- def resolve(runner, *, plugin_home, calling_session_key: str, plugin_id: str):
- """``(authority, live session)`` the key-less inject goes to, or ``None`` (logged). Runs on the
- plugin's calling thread so a refusal is the plugin's own ``False``; it only reads the authority's
- live map, never the store."""
- from gateway.session_authorities import all_authorities, authority_for_home
- authority = authority_for_home(runner, plugin_home) if plugin_home is not None else None
- if authority is None:
- _refuse(plugin_id, "unserved", f"its profile home {plugin_home} is not served by this gateway")
- return None
- sessions = list(authority.sessions.values())
- if calling_session_key:
- live = next((s for s in sessions if s.route == calling_session_key and _local(runner, s)), None)
- if live is None:
- if any(s.route == calling_session_key and s.source is not None and s.source.platform == Platform.LOCAL
- for other in all_authorities(runner) if other is not None and other is not authority
- for s in other.sessions.values()):
- # Another profile's local session: the keyed path's refusal, naming the plugin's profile.
- logger.warning("Plugin message injection refused: plugin=%s session=%s is not a live local session "
- "of the plugin's profile home %s", plugin_id, calling_session_key, plugin_home)
- return None
- # Main's answer for a key-less inject from a messaging chat's command, hook or tool.
- logger.warning("inject_message: gateway mode requires an existing session_key or an origin")
- return None
- return authority, live
- attached = [s for s in sessions if s.subscribers and _local(runner, s) and _launched_by_classic_cli(runner, s)]
- if len(attached) == 1:
- return authority, attached[0]
- if not attached:
- _refuse(plugin_id, "none", "no classic CLI session is attached in its profile")
- return None
- _refuse(plugin_id, "several", f"{len(attached)} classic CLI sessions are attached in its profile")
- return None
- async def admit(runner, authority, live, *, content: str, plugin_id: str) -> bool:
- """Commit the text to *live*'s durable FIFO through the keyed path's producer admission, under the
- plugin's profile (whose authority resolved it)."""
- from gateway.session_authorities import active_authority
- if not runner._plugin_injection_accepting():
- return False
- entry = await runner.async_session_store.lookup_by_session_key(live.route)
- if entry is None or not runner._plugin_injection_accepting():
- return False
- scope = contextlib.nullcontext()
- if getattr(getattr(runner, "config", None), "multiplex_profiles", False) is True:
- from gateway.run import _async_profile_runtime_scope
- scope = _async_profile_runtime_scope(Path(authority.profile_id))
- async with scope:
- if active_authority(runner) is not authority:
- return False
- return bool(await runner._admit_plugin_injection(
- runner._adapter_for_source(live.source), live.source, session_key=live.route,
- session_id=entry.session_id, content=content, plugin_id=plugin_id))
|