"""Chat/terminal WebSocket plumbing: PTY bridge selection and registry, WS client/origin/auth gates, chat argv resolution, gateway/sidecar URL building. """ import logging import asyncio import atexit import concurrent.futures import contextlib import functools import hmac import os import re import sys import tempfile import threading import urllib.request from typing import Optional from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect from pathlib import Path from typing import Optional from hermes_cli.pty_session import PtySessionRegistry # Same logger the code used before extraction (record parity). _log = logging.getLogger("hermes_cli.web_server") # /api/pty spawns ``hermes --tui`` behind a pseudo-terminal and forwards bytes + # resize escapes to xterm.js. POSIX uses pty_bridge (fcntl/termios); native # Windows uses win_pty_bridge (pywinpty/ConPTY); same surface, no handler guards. try: if sys.platform.startswith("win"): from hermes_cli.win_pty_bridge import WinPtyBridge as PtyBridge, PtyUnavailableError else: from hermes_cli.pty_bridge import PtyBridge, PtyUnavailableError _PTY_BRIDGE_AVAILABLE = True except ImportError: # pragma: no cover - pywinpty / ptyprocess missing PtyBridge = None # type: ignore[assignment] _PTY_BRIDGE_AVAILABLE = False class PtyUnavailableError(RuntimeError): # type: ignore[no-redef] """Stub when the platform PTY bridge cannot be imported.""" _RESIZE_RE = re.compile(rb"\x1b\[RESIZE:(\d+);(\d+)\]") _PTY_READ_CHUNK_TIMEOUT = 0.2 # Back-off between idle PTY reads so a quiet terminal does not spin the event # loop (keeps dashboard idle CPU low). # A positive sleep lets other coroutines run and keeps dashboard idle CPU low (#42627). _PTY_IDLE_BACKOFF = 0.05 PTY_REGISTRY = PtySessionRegistry( ttl=30 * 60, max_sessions=16, buffer_cap=1 * 1024 * 1024, read_timeout=_PTY_READ_CHUNK_TIMEOUT) async def _close_stalled_pty_input(ws: WebSocket, *, path: str) -> None: """Close only the terminal socket when its child stops accepting input.""" _log.warning("pty input stalled path=%s; recycling terminal session", path) try: await ws.close(code=1013, reason="PTY input stalled") except Exception: pass async def _legacy_pump(ws: WebSocket, bridge) -> None: """Original 1:1 socket<->PTY pump: stream until disconnect, then close the bridge. Used when no ``?attach=`` token is supplied (keep-alive opt-in). Behavior is identical to the pre-keep-alive ``pty_ws`` body, including the 54028 half-open-socket protection (reader EOF → close the WS so the writer's ``ws.receive()`` unparks) and the #53227 ``to_thread`` offloads for the blocking ``bridge.close()``. """ loop = asyncio.get_running_loop() async def pump_pty_to_ws() -> None: try: while True: chunk = await loop.run_in_executor(None, bridge.read, _PTY_READ_CHUNK_TIMEOUT) if chunk is None: # EOF return if not chunk: # no data this tick; yield control and retry await asyncio.sleep(_PTY_IDLE_BACKOFF) continue try: await ws.send_bytes(chunk) except Exception: return finally: # Close the WS so the writer's ``ws.receive()`` returns instead of # blocking forever on a half-open browser socket (fds would leak and # auto-reconnect stacks a fresh PTY on each orphan). Reap the bridge # here too (idempotent): cancelling the handler the instant the WS # closes can skip the writer's ``finally``. with contextlib.suppress(Exception): # The child has exited (EOF) or the send side broke. Closing from the EOF path makes the # reap independent of that cancellation race (#54028). await asyncio.to_thread(bridge.close) with contextlib.suppress(Exception): await ws.close() reader_task = asyncio.create_task(pump_pty_to_ws()) try: while True: try: msg = await ws.receive() except RuntimeError: # ws.receive() after the socket is already disconnected # (e.g. closed by the reader task above). break if msg.get("type") == "websocket.disconnect": break raw = msg.get("bytes") if raw is None: text = msg.get("text") raw = text.encode("utf-8") if isinstance(text, str) else b"" if not raw: continue # Resize escape is consumed locally, never written to the PTY. match = _RESIZE_RE.match(raw) if match and match.end() == len(raw): bridge.resize(cols=int(match.group(1)), rows=int(match.group(2))) continue if not await bridge.write(raw): await _close_stalled_pty_input(ws, path="legacy") break except WebSocketDisconnect: pass finally: reader_task.cancel() with contextlib.suppress(asyncio.CancelledError, Exception): await reader_task await asyncio.to_thread(bridge.close) from hermes_cli.web_server_boundary import _LOOPBACK_HOSTS def _ws_client_reason(ws: WebSocket) -> Optional[str]: """Return a rejection reason token for the peer IP, or None when allowed (:func:`hermes_cli.web_server_boundary.ws_client_reason` on the dashboard app state).""" from hermes_cli.web_server import app from hermes_cli.web_server_boundary import ws_client_reason return ws_client_reason(ws, app.state) def _ws_client_is_allowed(ws: WebSocket) -> bool: """True when the peer IP passes :func:`_ws_client_reason`.""" return _ws_client_reason(ws) is None def _ws_host_origin_reason(ws: WebSocket) -> Optional[str]: """Return ``host_mismatch …`` / ``origin_mismatch …``, or None when allowed (:func:`hermes_cli.web_server_boundary.ws_host_origin_reason` on the dashboard app state).""" from hermes_cli.web_server import app from hermes_cli.web_server_boundary import ws_host_origin_reason return ws_host_origin_reason(ws, app.state) def _ws_host_origin_is_allowed(ws: WebSocket) -> bool: """True when the upgrade passes the dashboard Host/Origin guard.""" return _ws_host_origin_reason(ws) is None def _ws_request_is_allowed(ws: WebSocket) -> bool: """Return True when the WebSocket upgrade matches dashboard boundaries.""" return _ws_host_origin_is_allowed(ws) and _ws_client_is_allowed(ws) from hermes_cli.web_server_boundary import ( _GATEWAY_WS_PROTOCOL, _GATEWAY_WS_TICKET_PROTOCOL_PREFIX, _gateway_ws_ticket_from_subprotocol, ) def _ws_request_view(ws: WebSocket, app) -> Request: """A ``Request`` facade over a ``WebSocket`` for the auth helpers. ``_verify_access_token`` only touches ``request.headers`` (X-Forwarded-For via ``client_ip``) and ``request.client`` on this path (``audit=False``, no cookie/redirect work), and ``webapp_sign_in.token_works_alone`` reads ``request.app.state``, so a lightweight stand-in carrying *app* avoids constructing a real ASGI request inside the upgrade. ``scan_session_providers`` itself never sees the request — only the provider callbacks do. ``webapp_sign_in.token_works_alone`` reads the listener's state from *app*. """ from fastapi import Request return Request({ "type": "http", "app": app, "headers": [(k.lower().encode("latin-1"), v.encode("latin-1")) for k, v in getattr(ws.headers, "items", dict)()], "client": (ws.client.host, 0) if ws.client else None, "server": None, "scheme": "ws", "method": "GET", "path": ws.url.path, "query_string": b"", "root_path": "", }) def _ws_auth_reason(ws: WebSocket, *, allow_internal: bool = False, socket: Optional[str] = None) -> tuple[Optional[str], str]: """Validate WS-upgrade auth; return ``(reason, credential)``. ``reason`` is None when accepted, else a short token (``no_credential``, ``token_mismatch``, ``ticket_invalid``, ``internal_invalid``); ``credential`` names what was presented so the accept path can log *how*. *socket* names the route's socket for its own tickets (``web_session_sockets.GATEWAY_SOCKET``, ``HOST_TERMINAL_SOCKET`` or one of ``AUDIO_SOCKETS``): a ticket minted for one socket opens no other, and the host terminal opens only with its own ticket. Loopback / ``--insecure``: legacy ``?token=`` (constant-time compared); on the gateway's Webapp a one-use socket ticket first (``/api/webapp/socket-ticket``). Gated: ``?ticket=`` (browser-minted, single-use, 30s TTL) or ``?internal=`` (process-lifetime, multi-use, only for server-spawned WS clients so the PTY child can reconnect; never injected into the SPA; on the gateway's Webapp it opens only the sockets that pass *allow_internal*), or ``?token=`` holding a user session access token (verified against the dashboard auth session providers — the same ``verify_session`` seam the native bearer REST leg uses — e.g. a token-mode Remote desktop connection; on the gateway's Webapp only a token that listener gave a native app's sign-in, as for the bearer header, ``webapp_sign_in.token_works_alone``). The legacy in-process ``_SESSION_TOKEN`` is rejected in gated mode: a leaked ``_SESSION_TOKEN`` must not grant access. Either mode: a local Desktop (no static token) presents the private one-use ``X-Hermes-Gateway-Ticket`` grant its REST calls use (``authenticate_native_ws``). A socket that sends that header is judged by it alone: on a core socket (``/api/ws``, ``/api/pty``, the audio streams) the grant is refused (``native_invalid``) even when a valid ``token`` query credential rides along. That is intended; only the plugin WebSocket gate accepts the grant. The audio streams instead take the ``interactive`` grant of the Desktop's ``/api/ws`` dial, in its gateway subprotocol (``redeem_audio_ws``), stamped on ``_hermes_native_grant``. """ from hermes_cli.dashboard_auth.native_http import HEADER, authenticate_native_ws, redeem_audio_ws from hermes_cli.web_server import _SESSION_TOKEN, app from hermes_cli.browser_credential import generation_of from hermes_cli.web_session_sockets import OWN_TICKET_SOCKETS, track auth_required = bool(getattr(app.state, "auth_required", False)) # The Webapp's own rules (socket tickets on the loopback gate, the server's credential only where # its spawned clients dial) apply on its listener; the standalone dashboard and serve keep main's. webapp = getattr(app.state, "ui_surface", None) == "webapp" if socket in OWN_TICKET_SOCKETS: # No standing credential (the session token, a native grant, a login's access token) opens it. reject = functools.partial(_audit_ws_rejection, ws) if auth_required else _ignore_rejection return _consume_ws_ticket(ws, reject, socket, auth_required=auth_required) or ("no_credential", "none") if HEADER in ws.headers: grant = authenticate_native_ws(ws) if grant is None: return "native_invalid", "native" ws._hermes_auth_identity = {"user_id": grant["subject"], "provider": "local"} return None, "native" grant = redeem_audio_ws(ws) if grant is not None: ws._hermes_auth_identity = {"user_id": grant["subject"], "provider": "local"} ws._hermes_native_grant = grant ws._hermes_ws_subprotocol = _GATEWAY_WS_PROTOCOL return None, "native" if auth_required: # Lazy import — keeps this function importable in test harnesses # that don't bring in the dashboard_auth layer. from hermes_cli.dashboard_auth.audit import AuditEvent, audit_log from hermes_cli.dashboard_auth.ws_tickets import TicketInvalid, consume_internal_credential _reject = functools.partial(_audit_ws_rejection, ws) def _stamp_identity(info) -> None: # Server-minted {user_id, provider} stamped onto the WS object is the # sole identity authority downstream (gateway transport / controller # registration); a client can never supply it through RPC params. # Only identity fields are carried — bookkeeping such as # ``minted_at`` is not part of the identity contract. ws._hermes_auth_identity = { "user_id": info.get("user_id"), "provider": info.get("provider")} if info.get("issuer"): ws._hermes_auth_identity["issuer"] = info["issuer"] internal = ws.query_params.get("internal", "") if internal: if webapp and not allow_internal: _reject("internal: endpoint not allowed") return "internal_not_allowed", "internal" try: _stamp_identity(consume_internal_credential(internal)) return None, "internal" except TicketInvalid as exc: _reject(f"internal: {exc}") return "internal_invalid", "internal" consumed = _consume_ws_ticket(ws, _reject, socket, auth_required=True) if consumed is not None: return consumed # A user session access token (``?token=``) is verified against the # dashboard auth session providers — the SAME ``verify_session`` seam # the native bearer REST leg uses (``_verify_access_token``). A # token-mode Remote desktop connection bakes its stored session token # into the WS URL (buildGatewayWsUrl), so before this leg existed the # only credentials gated mode accepted were browser-minted tickets and # the WS upgrade 403'd forever. The legacy in-process # ``_SESSION_TOKEN`` never reaches this check: gated mode falls # through to the explicit rejection below (leaked-constant safety), # and a provider-verified token is accepted on identity merit. On the # gateway's Webapp it follows the bearer header's rule: only a token this # listener gave a native app's sign-in works on its own, so a browser # login's tokens work only as its cookies, which sign-out ends. token = ws.query_params.get("token", "") if token: from hermes_cli import webapp_sign_in from hermes_cli.dashboard_auth.base import ProviderError from hermes_cli.dashboard_auth.middleware import _verify_access_token view = _ws_request_view(ws, app) try: # On the gateway's Webapp a browser login's tokens work only as its cookies, which # sign-out ends; only a token this listener gave a native app's sign-in works alone. session = (_verify_access_token(view, access_token=token, audit=False) if webapp_sign_in.token_works_alone(view, token) else None) except ProviderError as exc: # All providers unreachable (IDP outage) — reject without # crashing the upgrade; the REST bearer leg answers 503, and # the WS accept path has no status channel, only close codes. _reject(f"session token verify unavailable: {exc}") return "token_unavailable", "token" if session is not None: _stamp_identity({ "user_id": getattr(session, "user_id", None), "provider": getattr(session, "provider", None), }) audit_log( AuditEvent.TOKEN_AUTH_SUCCESS, provider=getattr(session, "provider", None), user_id=getattr(session, "user_id", None), ip=(ws.client.host if ws.client else ""), path=ws.url.path, ) return None, "token" audit_log( AuditEvent.TOKEN_AUTH_FAILURE, reason="session_token_invalid", ip=(ws.client.host if ws.client else ""), path=ws.url.path, ) return "token_invalid", "token" return "no_credential", "none" # Loopback: on the Webapp a one-use ticket ``/api/webapp/socket-ticket`` minted for the # session-token owner (its sockets on this same origin), else the legacy ``?token=``. consumed = _consume_ws_ticket(ws, _ignore_rejection, socket) if webapp else None if consumed is not None: return consumed token = ws.query_params.get("token", "") if not token: return "no_credential", "none" if hmac.compare_digest(token.encode(), _SESSION_TOKEN.encode()): track(ws, generation_of(token)) return None, "token" return "token_mismatch", "token" def _ignore_rejection(reason: str) -> None: """The loopback gate keeps no audit record of a refused credential.""" def _audit_ws_rejection(ws: WebSocket, reason: str) -> None: """The gated gate's audit record of a refused upgrade credential.""" from hermes_cli.dashboard_auth.audit import AuditEvent, audit_log audit_log(AuditEvent.WS_TICKET_REJECTED, reason=reason, ip=(ws.client.host if ws.client else ""), path=ws.url.path) def _consume_ws_ticket(ws: WebSocket, reject, socket: Optional[str] = None, *, auth_required: bool = False) -> Optional[tuple[Optional[str], str]]: """A one-use ticket offered as the ``hermes-gateway-ticket.`` subprotocol or ``?ticket=``: ``(reason, credential)`` once judged, or None when the upgrade presents none. An accepted ticket stamps the server-minted identity onto the socket; the client never supplies it through RPC params. *socket* is the route's socket (``web_session_sockets.ticket_refusal``); a socket a session-token ticket, or a Webapp login's ticket, opens is tracked so signing out closes it.""" from hermes_cli.dashboard_auth.ws_tickets import TicketInvalid, consume_ticket from hermes_cli.web_session_sockets import admitted_with, ticket_refusal, track protocol_ticket, protocol_reason = _gateway_ws_ticket_from_subprotocol(ws) if protocol_reason == "invalid": return "ticket_invalid", "ticket-subprotocol" ticket = protocol_ticket or ws.query_params.get("ticket", "") if not ticket: return None try: info = consume_ticket(ticket) except TicketInvalid as exc: reject(str(exc)) return "ticket_invalid", "ticket" refusal = ticket_refusal(info, socket, auth_required=auth_required) if refusal is not None: reject(refusal) return "ticket_invalid", "ticket" if info.get("provider") == "bot-desktop": # A display ticket admits one RFB bridge on /api/display/ws (a watch-only capability handed # to a screen viewer); it must not double as a login here. reject("display ticket presented as a gateway login") return "ticket_invalid", "ticket" # Only identity fields are carried; bookkeeping such as ``minted_at`` is not part of it. ws._hermes_auth_identity = {"user_id": info.get("user_id"), "provider": info.get("provider")} if info.get("issuer"): ws._hermes_auth_identity["issuer"] = info["issuer"] if info.get("profile_home"): ws._hermes_ticket_profile_home = info["profile_home"] if (admitted := admitted_with(info)) is not None: track(ws, admitted) if not protocol_ticket: return None, "ticket" # Select only the stable public protocol during accept. The ticket-bearing protocol is a # credential and must never be reflected back to the browser or retained after admission. ws._hermes_ws_subprotocol = _GATEWAY_WS_PROTOCOL return None, "ticket-subprotocol" def _ws_auth_ok(ws: WebSocket, *, allow_internal: bool = False, socket: Optional[str] = None) -> bool: """True when the WS-upgrade credential is accepted. See _ws_auth_reason.""" return _ws_auth_reason(ws, allow_internal=allow_internal, socket=socket)[0] is None def _ws_auth_mode() -> str: """Short label for the active WS auth mode — logged on every connection.""" from hermes_cli.web_server import app if getattr(app.state, "auth_required", False): return "gated" bound_host = (getattr(app.state, "bound_host", "") or "").strip().lower() if bound_host and bound_host not in _LOOPBACK_HOSTS: return "insecure" return "loopback" def _ws_close_reason(text: str) -> str: """Clamp to RFC 6455's 123-byte close-reason limit (uvicorn raises past it); reasons embed an attacker-controlled origin, so truncate rather than crash.""" encoded = text.encode("utf-8", "replace") if len(encoded) <= 123: return text return encoded[:120].decode("utf-8", "ignore") + "..." async def _ws_gate(ws: WebSocket, kind: str) -> Optional[tuple[str, str, str]]: """Run the pre-accept gates for /api/console, /api/pty and /api/host-terminal. Each gate maps to a distinct close code so the log and the browser banner agree on the cause: 4404 chat disabled, 4401 bad credential, 4403 host/origin mismatch, 4408 peer not allowed. Returns ``(peer, mode, cred)`` once every gate passes, or None after closing the socket. """ from hermes_cli.web_server import _DASHBOARD_EMBEDDED_CHAT_ENABLED peer = ws.client.host if ws.client else "?" if not _DASHBOARD_EMBEDDED_CHAT_ENABLED: _log.info("%s refused: embedded chat disabled peer=%s", kind, peer) await ws.close(code=4404, reason="embedded chat disabled") return None auth_reason, cred = _ws_auth_reason(ws, socket=kind) mode = _ws_auth_mode() if auth_reason is not None: _log.warning("%s auth rejected reason=%s mode=%s cred=%s peer=%s", kind, auth_reason, mode, cred, peer) await ws.close(code=4401, reason=_ws_close_reason(f"auth: {auth_reason}")) return None host_origin_reason = _ws_host_origin_reason(ws) if host_origin_reason is not None: _log.warning("%s refused: %s peer=%s", kind, host_origin_reason, peer) await ws.close(code=4403, reason=_ws_close_reason(host_origin_reason)) return None client_reason = _ws_client_reason(ws) if client_reason is not None: _log.warning("%s refused: %s", kind, client_reason) await ws.close(code=4408, reason=_ws_close_reason(client_reason)) return None return peer, mode, cred async def _pty_fail(ws: WebSocket, exc: BaseException, *, surface: str = "Chat") -> None: """Tell the user why chat could not start, then close 1011 so the SPA renders "Start new session". The raw exception goes to the server log only.""" from hermes_cli.web_routers.chat_ws_errors import chat_start_failure_message _log.warning("pty start failed: %s: %s", type(exc).__name__, exc) await ws.send_text(f"\r\n\x1b[31m{chat_start_failure_message(exc, surface=surface)}\x1b[0m\r\n") await ws.close(code=1011) def _resolve_chat_argv( resume: Optional[str] = None, sidecar_url: Optional[str] = None, profile: Optional[str] = None, active_session_file: Optional[str] = None, workspace_cwd: Optional[str] = None) -> tuple[list[str], Optional[str], Optional[dict]]: """Resolve the argv + cwd + env for the chat PTY (what ``hermes --tui`` runs). Tests monkeypatch this with a tiny fake command. Env contract: resume goes through ``HERMES_TUI_RESUME`` (``ui-tui`` does not parse argv), resolved to the newest descendant; ``HERMES_TUI_GATEWAY_URL`` attaches to this process's in-memory gateway but is SKIPPED for profile-scoped chats (that gateway runs under the dashboard's own profile, so a scoped chat attaches to its profile's gateway); ``profile`` scopes the ENTIRE chat by pointing ``HERMES_HOME`` at the profile dir, the same propagation ``hermes -p `` performs. ``workspace_cwd`` (an already-validated host directory, ``chat_workspaces.resolve_chat_cwd``) is the workspace the user picked for a FRESH chat: it becomes ``HERMES_CWD`` (where a self-spawned gateway starts) and ``HERMES_TUI_CWD`` (what the TUI passes as the explicit ``cwd`` of ``session.create`` when attached to the in-memory gateway, whose own cwd is the dashboard's launch dir). """ from hermes_cli.web_server_profiles import _config_profile_scope, _resolve_profile_dir from hermes_cli.web_server_sessions import _open_session_db_for_profile, _session_latest_descendant from hermes_cli.main import PROJECT_ROOT from hermes_cli.main_tui_launch import _apply_tui_python_env, _make_tui_argv profile_dir: Optional[Path] = None requested = (profile or "").strip() if requested and requested.lower() != "current": profile_dir = _resolve_profile_dir(requested) argv, cwd = _make_tui_argv(PROJECT_ROOT / "ui-tui", tui_dev=False) # Secrets kept — the spawned agent needs provider creds. An explicit profile # scope overrides HERMES_HOME before config is bridged into the env. from tools.environments.local import build_subprocess_env env = build_subprocess_env(scrub_secrets=False, inherit_profile_home=True) if profile_dir is not None: env["HERMES_HOME"] = str(profile_dir) try: from hermes_cli.config import ( apply_terminal_config_to_env, read_raw_config, terminal_config_owned_env_vars) if profile_dir is not None: # Drop only the terminal keys the launch profile owns before applying # the selected profile; operator exports for other keys stay valid. raw_launch_terminal = read_raw_config().get("terminal") for env_var in terminal_config_owned_env_vars(raw_launch_terminal): env.pop(env_var, None) with _config_profile_scope(requested): apply_terminal_config_to_env(env=env) else: apply_terminal_config_to_env(env=env) except Exception: _log.warning("Failed to apply terminal config bridge for dashboard chat", exc_info=True) if workspace_cwd: env["HERMES_CWD"] = workspace_cwd env["HERMES_TUI_CWD"] = workspace_cwd _apply_tui_python_env(env) env.setdefault("NODE_ENV", "production") # Mouse tracking would swallow wheel events the browser needs for # transcript scrolling; disable it for the dashboard PTY only. env.setdefault("HERMES_TUI_DISABLE_MOUSE", "1") env.setdefault("HERMES_TUI_INLINE", "1") # chalk in the child picks its color depth from the SERVER env; hosted # deploys have no COLORTERM, so hex colors would snap to the 256 palette. env.setdefault("COLORTERM", "truecolor") env["HERMES_TUI_DASHBOARD"] = "1" if resume: _resume_db = _open_session_db_for_profile( requested if profile_dir is not None else None, read_only=True) try: latest_resume, _latest_path = _session_latest_descendant(resume, _resume_db) finally: _resume_db.close() if latest_resume: resume = latest_resume env["HERMES_TUI_RESUME"] = resume if sidecar_url: env["HERMES_TUI_SIDECAR_URL"] = sidecar_url if active_session_file: env["HERMES_TUI_ACTIVE_SESSION_FILE"] = active_session_file # Without the attach URL, gatewayClient bootstraps through the profile's own # gateway (ui-tui/scripts/gateway_bootstrap.py) under the HERMES_HOME set above; # it never spawns a standalone `tui_gateway.entry` writer. if profile_dir is None and (gateway_ws_url := _build_gateway_ws_url()): env["HERMES_TUI_GATEWAY_URL"] = gateway_ws_url return list(argv), str(cwd) if cwd else None, env # Wildcard bind hosts an in-container client must NOT dial: behind a forward # proxy (HTTPS_PROXY without 0.0.0.0 in NO_PROXY) the handshake gets MITM'd. _WILDCARD_HOSTS = frozenset({"0.0.0.0", "::"}) def _resolve_client_ws_host() -> Optional[str]: """Host the in-container WS client should dial: ``HERMES_DASHBOARD_WS_HOST`` wins always; a wildcard bind becomes ``127.0.0.1``; others verbatim.""" from hermes_cli.web_server import app explicit = os.environ.get("HERMES_DASHBOARD_WS_HOST", "").strip() if explicit: return explicit host = getattr(app.state, "bound_host", None) if not host: return None return "127.0.0.1" if host in _WILDCARD_HOSTS else host def _server_internal_ws_url(path: str, **extra_qs) -> Optional[str]: """``ws://:?&`` for server-spawned WS clients, or None when unbound. Gated mode uses the process-lifetime internal credential, NOT a single-use browser ticket: the child reads the URL once and reuses it on every reconnect, and a 30s-TTL ticket can expire before a slow cold boot dials. """ from hermes_cli.web_server import _SESSION_TOKEN, app host = _resolve_client_ws_host() port = getattr(app.state, "bound_port", None) if not host or not port: return None netloc = f"[{host}]:{port}" if ":" in host and not host.startswith("[") else f"{host}:{port}" if getattr(app.state, "auth_required", False): from hermes_cli.dashboard_auth.ws_tickets import internal_ws_credential auth = {"internal": internal_ws_credential()} else: auth = {"token": _SESSION_TOKEN} return f"ws://{netloc}{path}?{urllib.parse.urlencode({**auth, **extra_qs})}" def _build_gateway_ws_url() -> Optional[str]: """ws:// URL the PTY child attaches to for JSON-RPC gateway traffic.""" return _server_internal_ws_url("/api/ws") def _build_sidecar_url(channel: str) -> Optional[str]: """ws:// URL the PTY child publishes events to, or None when unbound.""" return _server_internal_ws_url("/api/pub", channel=channel) async def _resolve_chat_argv_async( resume: Optional[str] = None, sidecar_url: Optional[str] = None, profile: Optional[str] = None, active_session_file: Optional[str] = None, workspace_cwd: Optional[str] = None) -> tuple[list[str], Optional[str], Optional[dict]]: """Resolve chat argv off the event loop (it may run ``npm run build``); the async lock keeps one-build-at-a-time without parking worker threads.""" from hermes_cli.web_server import _get_chat_argv_lock, app kwargs = {"resume": resume, "sidecar_url": sidecar_url, "profile": profile} if active_session_file is not None: kwargs["active_session_file"] = active_session_file if workspace_cwd is not None: kwargs["workspace_cwd"] = workspace_cwd async with _get_chat_argv_lock(app): return await asyncio.to_thread(_resolve_chat_argv, **kwargs) def _active_session_file_for_channel(app: FastAPI, channel: str) -> Path: """Return the per-channel file where a dashboard TUI writes its active sid.""" from hermes_cli.web_server import _get_pty_active_session_files files = _get_pty_active_session_files(app) if files.get(channel) is None: fd, raw_path = tempfile.mkstemp(prefix="hermes-pty-active-", suffix=".json") os.close(fd) files[channel] = Path(raw_path) return files[channel] # On timeout asyncio cancels the awaitable but the console thread keeps running; # a small dedicated pool caps the leak instead of exhausting the default pool. _CONSOLE_EXECUTOR_MAX_WORKERS = 4 _console_executor: Optional[concurrent.futures.ThreadPoolExecutor] = None _console_executor_lock = threading.Lock() def _get_console_executor() -> concurrent.futures.ThreadPoolExecutor: """Lazily create the bounded console worker pool (once per process).""" global _console_executor if _console_executor is None: with _console_executor_lock: if _console_executor is None: _console_executor = concurrent.futures.ThreadPoolExecutor( max_workers=_CONSOLE_EXECUTOR_MAX_WORKERS, thread_name_prefix="hermes-console") # Tear down on interpreter exit without waiting on in-flight # workers: a stuck 60s console command must not block shutdown. atexit.register( lambda: _console_executor and _console_executor.shutdown(wait=False, cancel_futures=True)) return _console_executor