"""Per-session setting commands of the classic CLI on the shared gateway (``slash.exec``). On main ``/personality`` ``/busy`` ``/approvals`` ``/footer`` ``/fast`` changed this process's own agent or config. Rewired, the session's agent lives in the gateway, so the gateway's handler decides and applies the change (gateway/session_setting_commands.py; RULING ยง1: one behaviour per command, every surface) and the CLI prints its reply. Client-side state the CLI itself enforces (``/busy``: what Enter does while a turn runs) is mirrored locally after the owner accepts it. ``/refine`` and ``/review`` take the same route: their background reviewer must run beside the session's agent in the gateway (as on messaging), where its result is delivered back to the session. ``/cron`` too: the profile's cron store belongs to the gateway that fires its jobs, so the gateway runs main's handler (one writer); ``/cron run`` lasts as long as the job, so a write waits with no deadline. ``/toolsets`` too: the gateway builds the report from its own registry (MCP and plugin toolsets included) with this session's toolsets marked (gateway/session_info_reads.py). """ from __future__ import annotations import shlex # Canonical command -> mirror(cli, arg) run after the owner applied it (None: nothing local). _BUSY_MODES = frozenset({"queue", "steer", "interrupt"}) def _mirror_busy(cli, arg): if arg.lower() in _BUSY_MODES: cli.busy_input_mode = arg.lower() def _watch_reviewer(cli, _arg): """/review spawns its reviewer off-turn: have the live-work dock poll for it right away.""" from hermes_cli.gateway_tools import process_view view = process_view() if view is not None: view.watch_subagents() # Reports the owner already lays out (main's own line builders): printed as is. _VERBATIM = frozenset({"toolsets"}) GATEWAY_SETTINGS = {"personality": None, "busy": _mirror_busy, "approvals": None, "footer": None, "fast": None, "refine": None, "review": _watch_reviewer, "cron": None, "toolsets": None} def _unbounded(canonical, arg): """True for a form answered only once its work is done, however long: a /cron write (``run`` runs the job). Its reads keep the deadline, and so does an unclosed quote, which the owner refuses at once.""" if canonical != "cron": return False from gateway.session_cron_commands import cron_read try: return cron_read(shlex.split(arg)) is None except ValueError: return False def _call(cli, connection, canonical, arg): command = canonical + (" " + arg if arg else "") if not _unbounded(canonical, arg): return connection.call("slash.exec", session_id=cli.session_id, command=command) # No deadline, on a socket of its own so the session's prompts never queue behind it # (GatewayConnection.call_until); Ctrl+C stops waiting. from hermes_cli.gateway_plugin_commands import call_unbounded return call_unbounded(cli, connection, canonical, command) def run(cli, canonical, cmd): """True when the gateway answered the command (the local handler must not run).""" from hermes_cli.gateway_side import connection_for if canonical not in GATEWAY_SETTINGS: return False connection = connection_for(cli) if connection is None: return False from cli import _cprint from hermes_cli.gateway_client import GatewayClientError from hermes_cli.gateway_plugin_commands import STOPPED parts = (cmd or "").strip().split(None, 1) arg = parts[1].strip() if len(parts) > 1 else "" try: reply = _call(cli, connection, canonical, arg) except GatewayClientError as exc: _cprint(f" /{canonical}: {exc}") return True if reply is STOPPED: return True for line in str((reply or {}).get("output") or "").splitlines(): _cprint(f" {line}" if line and canonical not in _VERBATIM else line) mirror = GATEWAY_SETTINGS[canonical] if mirror is not None: mirror(cli, arg) return True