Download tui_gateway/methods_browser.py from SaylorTwift/hermes-agent: direct link, hf CLI and curl.
- Browser
- Download file 8.8 kB
-
https://huggingface.co/SaylorTwift/hermes-agent/resolve/main/tui_gateway/methods_browser.py
- Command line
-
hf download hf://SaylorTwift/hermes-agent/tui_gateway/methods_browser.py
-
curl -L -o methods_browser.py https://huggingface.co/SaylorTwift/hermes-agent/resolve/main/tui_gateway/methods_browser.py
8.8 kB
| """Browser connect/disconnect helpers for the browser.* RPCs (CDP probing, no network I/O on | |
| status). Bodies are rebound onto server.py's globals at install time (method_ctx.bind_module).""" | |
| from __future__ import annotations | |
| from .method_ctx import HandlerRegistry, bind_module | |
| _registry = HandlerRegistry() | |
| _CDP_SCHEMES = {"http", "https", "ws", "wss"} | |
| def _resolve_browser_cdp_url() -> str: | |
| """Configured browser CDP override without network I/O (``/browser status`` must be fast; | |
| ``tools.browser_tool_cdp._get_cdp_override`` HTTP-probes discovery URLs). Same precedence (env, | |
| then ``browser.cdp_url``) minus WS resolution; ``browser_navigate`` normalizes on the next call.""" | |
| if env_url := os.environ.get("BROWSER_CDP_URL", "").strip(): | |
| return env_url | |
| with contextlib.suppress(Exception): | |
| from hermes_cli.config import read_raw_config | |
| cfg = read_raw_config() | |
| browser_cfg = cfg.get("browser", {}) if isinstance(cfg, dict) else {} | |
| if isinstance(browser_cfg, dict): | |
| return str(browser_cfg.get("cdp_url", "") or "").strip() | |
| return "" | |
| def _is_default_local_cdp(parsed) -> bool: | |
| """Match the discovery-style local default; never the concrete WS form — a | |
| ``ws://127.0.0.1:9222/devtools/browser/<id>`` is connectable as-is and collapsing it to bare | |
| ``http://...:9222`` would break the connect.""" | |
| with contextlib.suppress(ValueError): | |
| return (parsed.scheme in {"http", "ws"} and parsed.hostname in {"127.0.0.1", "localhost"} | |
| and (parsed.port or 80) == 9222 and parsed.path in {"", "/", "/json", "/json/version"}) | |
| return False | |
| def _cdp_http_reachable(parsed, timeout: float = 2.0) -> bool: | |
| """True when ``/json/version`` or ``/json`` on the CDP host answers 2xx.""" | |
| import urllib.request | |
| scheme = {"ws": "http", "wss": "https"}.get(parsed.scheme, parsed.scheme) | |
| root = f"{scheme}://{parsed.netloc}".rstrip("/") | |
| for url in (f"{root}/json/version", f"{root}/json"): | |
| with contextlib.suppress(Exception), urllib.request.urlopen(url, timeout=timeout) as resp: | |
| if 200 <= getattr(resp, "status", 200) < 300: | |
| return True | |
| return False | |
| def _connect_local_default(port: int, system: str, announce) -> str | None: | |
| """Discover (or launch) the default local debug browser → CDP URL, or None after announcing.""" | |
| from hermes_cli.browser_connect import ( | |
| discover_local_cdp_url, find_free_debug_port, launch_chrome_debug, local_port_in_use, | |
| manual_chrome_debug_command) | |
| # Dual-stack discovery: when another app squats the IPv4 loopback on the debug port, a | |
| # browser bound there comes up on [::1] only; an IPv4-only probe misses it AND hangs | |
| # against squatters that accept TCP but never answer HTTP. | |
| discovered = discover_local_cdp_url(port, timeout=2.0) | |
| if discovered is not None: | |
| announce(f"Chromium-family browser is already listening at {discovered}") | |
| return discovered | |
| launch_port = port | |
| if local_port_in_use(port): | |
| launch_port = find_free_debug_port(port) | |
| announce(f"Port {port} is occupied by another application that isn't a CDP browser " | |
| "(an IDE debugger or dev server may be using it) — launching a debug browser " | |
| f"on port {launch_port} instead...") | |
| else: | |
| announce("Chromium-family browser isn't running with remote debugging — attempting to launch...") | |
| launch = launch_chrome_debug(launch_port, system) | |
| if launch.launched: | |
| # Bounded wait: the whole connect must finish inside the client RPC timeout. | |
| deadline = time.monotonic() + 10.0 | |
| while time.monotonic() < deadline: | |
| if discovered := discover_local_cdp_url(launch_port, timeout=1.0): | |
| break | |
| time.sleep(0.5) | |
| if discovered: | |
| announce(f"Chromium-family browser launched and listening on port {launch_port}") | |
| return discovered | |
| if launch.hint: | |
| announce(launch.hint, level="error") | |
| command = manual_chrome_debug_command(launch_port, system) | |
| hints = ( | |
| ["Start a Chromium-family browser with remote debugging, then retry /browser connect:", command] | |
| if command else [ | |
| "No supported Chromium-family browser executable was found in this environment.", | |
| f"Install one or start a Chromium-family browser with --remote-debugging-port={launch_port}, then retry /browser connect."]) | |
| hints.append("Browser not connected — start a Chromium-family browser with remote debugging and retry /browser connect") | |
| for line in hints: | |
| announce(line, level="error") | |
| return None | |
| def _browser_connect(rid, params: dict) -> dict: | |
| import platform | |
| from hermes_cli.browser_connect import DEFAULT_BROWSER_CDP_URL | |
| from tools.browser_tool_lifecycle import cleanup_all_browsers | |
| from urllib.parse import urlparse | |
| raw_url = params.get("url") | |
| if raw_url is not None and not isinstance(raw_url, str): | |
| return _err(rid, 4015, f"browser url must be a string, got {type(raw_url).__name__}") | |
| url = (raw_url or "").strip() or DEFAULT_BROWSER_CDP_URL | |
| sid, system, messages = params.get("session_id") or "", platform.system(), [] | |
| def announce(message: str, *, level: str = "info") -> None: | |
| messages.append(message) | |
| # Without a session id the TUI prints `messages` from the response (an event would double-render). | |
| if sid: | |
| _emit("browser.progress", sid, {"message": message, "level": level}) | |
| parsed = urlparse(url if "://" in url else f"http://{url}") | |
| if parsed.scheme not in _CDP_SCHEMES: | |
| return _err(rid, 4015, f"unsupported browser url: {url}") | |
| if not parsed.hostname: | |
| return _err(rid, 4015, f"missing host in browser url: {url}") | |
| try: | |
| port = parsed.port or (443 if parsed.scheme in {"https", "wss"} else 80) | |
| except ValueError: | |
| return _err(rid, 4015, f"invalid port in browser url: {url}") | |
| # Normalize default-local to 127.0.0.1:9222 so comparisons + messaging match what we persist. | |
| if _is_default_local_cdp(parsed): | |
| url = DEFAULT_BROWSER_CDP_URL | |
| parsed = urlparse(url) | |
| port = parsed.port or 9222 | |
| try: | |
| # Hosted ws[s]://.../devtools/browser/<id> endpoints don't serve the HTTP discovery path: | |
| # check TCP reachability only and let browser_navigate handshake. | |
| if parsed.scheme in {"ws", "wss"} and parsed.path.startswith("/devtools/browser/"): | |
| import socket | |
| try: | |
| with socket.create_connection((parsed.hostname, port), timeout=2.0): | |
| pass | |
| except OSError as e: | |
| return _err(rid, 5031, f"could not reach browser CDP at {url}: {e}") | |
| elif _is_default_local_cdp(parsed): | |
| discovered = _connect_local_default(port, system, announce) | |
| if discovered is None: | |
| return _ok(rid, {"connected": False, "url": url, "messages": messages}) | |
| # Adopt whatever loopback/port answered ([::1] and/or an alternate port when 9222 was squatted). | |
| url = discovered | |
| parsed = urlparse(url) | |
| elif not _cdp_http_reachable(parsed): | |
| return _err(rid, 5031, f"could not reach browser CDP at {url}") | |
| # Concrete ``/devtools/browser/<id>`` endpoints stay as-is; discovery-style inputs collapse | |
| # to ``scheme://host:port`` so ``_resolve_cdp_override`` can append ``/json/version``. | |
| normalized = (parsed.geturl() if parsed.path.startswith("/devtools/browser/") | |
| else parsed._replace(path="", params="", query="", fragment="").geturl()) | |
| # Reap BEFORE publishing the new env (an in-flight tool call sees the old supervisor closed) | |
| # and AFTER (the default task's cached supervisor drains against the new URL). | |
| cleanup_all_browsers() | |
| os.environ["BROWSER_CDP_URL"] = normalized | |
| cleanup_all_browsers() | |
| except Exception as e: | |
| return _err(rid, 5031, str(e)) | |
| return _ok(rid, {"connected": True, "url": normalized, | |
| **({"messages": messages} if messages else {})}) | |
| def _browser_disconnect(rid) -> dict: | |
| # Reap, drop the override, reap again — same swap window as ``_browser_connect``. | |
| def reap() -> None: | |
| with contextlib.suppress(Exception): | |
| from tools.browser_tool_lifecycle import cleanup_all_browsers | |
| cleanup_all_browsers() | |
| reap() | |
| os.environ.pop("BROWSER_CDP_URL", None) | |
| reap() | |
| return _ok(rid, {"connected": False}) | |
| def register(server) -> None: | |
| """Publish this module's helpers + handlers onto ``server``, rebound to its globals.""" | |
| bind_module(globals(), server, skip=("_",)) | |