| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424 |
- """Status command for hermes CLI."""
- import json
- import os
- import sys
- import time
- import importlib.util
- from pathlib import Path
- from types import SimpleNamespace
- PROJECT_ROOT = Path(__file__).parent.parent.resolve()
- from hermes_cli.auth import AuthError, resolve_provider
- from hermes_cli.colors import Colors, color
- from hermes_cli.config import get_env_path, get_env_value, get_hermes_home, load_config
- from hermes_cli.config_defaults import DEFAULT_SANDBOX_IMAGE, DEFAULT_VERCEL_IMAGE
- from hermes_cli.models import provider_label
- from hermes_cli.runtime_provider import resolve_requested_provider
- from hermes_cli.vercel_auth import describe_vercel_auth
- from hermes_cli.status_auth import ( # renderers wired into _SECTIONS below
- _render_api_keys, _render_apikey_providers, _render_auth_providers, _render_nous_gateway)
- from hermes_constants import OPENROUTER_MODELS_URL
- def check_mark(ok: bool) -> str:
- return color("✓", Colors.GREEN) if ok else color("✗", Colors.RED)
- def _section(title: str) -> None:
- """Print a blank line followed by a bold cyan ``◆`` section heading."""
- print()
- print(color(f"◆ {title}", Colors.CYAN, Colors.BOLD))
- def _row(name: str, ok: bool, text: str, width: int = 12, sep: str = " ") -> None:
- """Print one ``name ✓/✗ text`` status row."""
- print(f" {name:<{width}}{sep}{check_mark(ok)} {text}")
- def _detail(label: str, value) -> None:
- """Print an indented ``label: value`` detail line under a status row."""
- _kv(label, value, " ", 12)
- def _kv(label: str, value, indent: str = " ", width: int = 14) -> None:
- """Print a `` Label: value`` line (label padded to the 14-col status layout)."""
- print(f"{indent}{label:<{width}}{value}")
- def _kv_flag(label: str, ok, on: str, off: str) -> None:
- """``_kv`` with a ✓/✗ mark followed by ``on`` or ``off`` text."""
- _kv(label, f"{check_mark(bool(ok))} {on if ok else off}")
- def _configured(ok) -> str:
- return "configured" if ok else "not configured"
- def _first_env_value(names) -> str:
- """Return the first non-empty env value among ``names`` (a str or tuple of names)."""
- return next((v for v in (get_env_value(n) or "" for n in ((names,) if isinstance(names, str) else names)) if v), "")
- def _configured_model_label(config: dict) -> str:
- """Return the configured default model from config.yaml."""
- model_cfg = config.get("model")
- if isinstance(model_cfg, dict):
- model_cfg = model_cfg.get("default") or model_cfg.get("name") or ""
- return (model_cfg.strip() if isinstance(model_cfg, str) else "") or "(not set)"
- def _effective_provider_label() -> str:
- """Return the provider label matching current CLI runtime resolution."""
- requested = resolve_requested_provider()
- try:
- effective = resolve_provider(requested)
- except AuthError:
- effective = requested or "auto"
- if effective == "openrouter":
- # A custom endpoint may live in config.yaml (model.base_url, the canonical location) or
- # the legacy OPENAI_BASE_URL env var; either way labeling it "OpenRouter" is misleading.
- try:
- model_cfg = load_config().get("model")
- except Exception:
- model_cfg = None
- config_base_url = (model_cfg.get("base_url") or "").strip() if isinstance(model_cfg, dict) else ""
- if config_base_url or get_env_value("OPENAI_BASE_URL"):
- effective = "custom"
- return provider_label(effective)
- def _estop_status_line():
- """One-line pause banner for `hermes status`, or None when not paused."""
- try:
- from agent.estop import get_state
- except ImportError:
- return None
- state = get_state()
- if state is None:
- return None
- reason = state.get("reason")
- return f"⏸️ PAUSED (global emergency stop{f' — reason: {reason}' if reason else ''}; `hermes resume` to lift)"
- # --- Data tables driving the per-section renderers -------------------------
- # Simple env-driven terminal backends: (label, env var, default, empty-counts-as-unset).
- _TERMINAL_ENV_ROWS = {
- "ssh": (("SSH Host:", "TERMINAL_SSH_HOST", "(not set)", True), ("SSH User:", "TERMINAL_SSH_USER", "(not set)", True)),
- "docker": (("Docker Image:", "TERMINAL_DOCKER_IMAGE", DEFAULT_SANDBOX_IMAGE, False),),
- "daytona": (("Daytona Image:", "TERMINAL_DAYTONA_IMAGE", DEFAULT_SANDBOX_IMAGE, False),),
- }
- # Gateway manager label when the runtime snapshot is unavailable, keyed by platform.
- _GATEWAY_FALLBACK = {"termux": ("unknown", "Termux / manual process"), "linux": ("unknown", "systemd/manual"),
- "darwin": ("unknown", "launchd")}
- def _banner(lines, *styles) -> None:
- """Blank line, then each line in ``styles``."""
- print()
- for line in lines:
- print(color(line, *styles))
- def _render_header(ctx):
- _banner(("┌─────────────────────────────────────────────────────────┐",
- "│ ☤ Hermes Agent Status │",
- "└─────────────────────────────────────────────────────────┘"), Colors.CYAN)
- paused = _estop_status_line()
- if paused:
- _banner((paused,), Colors.YELLOW, Colors.BOLD)
- def _load_ctx_config(ctx) -> None:
- """Load config.yaml into the shared context (fail-soft)."""
- try:
- ctx.config = load_config()
- except Exception:
- ctx.config = {}
- def _render_environment(ctx):
- _section("Environment")
- _kv("Project:", PROJECT_ROOT)
- _kv("Python:", sys.version.split()[0])
- _kv_flag(".env file:", get_env_path().exists(), "exists", "not found")
- _load_ctx_config(ctx)
- _kv("Model:", _configured_model_label(ctx.config))
- _kv("Provider:", _effective_provider_label())
- def _render_terminal(ctx):
- _section("Terminal Backend")
- terminal_cfg = ctx.config.get("terminal", {}) if isinstance(ctx.config.get("terminal"), dict) else {}
- terminal_env = os.getenv("TERMINAL_ENV", "") or terminal_cfg.get("backend", "local")
- _kv("Backend:", terminal_env)
- if terminal_env in _TERMINAL_ENV_ROWS:
- for label, var, default, empty_is_unset in _TERMINAL_ENV_ROWS[terminal_env]:
- value = (os.getenv(var, "") or default) if empty_is_unset else os.getenv(var, default)
- print(f" {label:<13} {value}")
- elif terminal_env == "vercel_sandbox":
- persist = os.getenv("TERMINAL_CONTAINER_PERSISTENT")
- persist_enabled = (bool(terminal_cfg.get("container_persistent", True)) if persist is None
- else persist.lower() in {"1", "true", "yes", "on"})
- auth_status = describe_vercel_auth()
- _kv("Image:", os.getenv('TERMINAL_VERCEL_RUNTIME') or terminal_cfg.get('vercel_runtime')
- or os.getenv('TERMINAL_VERCEL_IMAGE') or terminal_cfg.get('vercel_image') or DEFAULT_VERCEL_IMAGE)
- _kv_flag("SDK:", importlib.util.find_spec("vercel") is not None, "installed",
- "missing (run hermes setup terminal and select Vercel Sandbox, then restart Hermes)")
- _kv("Auth:", f"{check_mark(auth_status.ok)} {auth_status.label}")
- for line in auth_status.detail_lines:
- _kv("Auth detail:", line)
- _kv("Persistence:", 'snapshot filesystem' if persist_enabled else 'ephemeral filesystem')
- _kv("Processes:", "live processes do not survive cleanup, snapshots, or sandbox recreation")
- else:
- # Plugin-registered terminal backends: show availability via the provider's doctor rows
- # (fail-soft — never break `hermes status`).
- try:
- from hermes_cli.plugins import discover_plugins
- discover_plugins()
- from agent.terminal_env_registry import get_provider
- provider = get_provider(terminal_env)
- if provider is not None:
- for ok, label, text in provider.doctor_checks():
- print(f" {label}: {check_mark(bool(ok))} {text}")
- except Exception:
- pass
- _kv_flag("Sudo:", os.getenv("SUDO_PASSWORD", ""), "enabled", "disabled")
- def _render_platforms(ctx):
- """One row per platform, judged by the gateway (same verdict as the summary's Platforms line)."""
- _section("Messaging Platforms")
- try:
- from gateway.config import load_gateway_config
- from gateway.platform_registry import platform_registry
- from hermes_cli.plugins import discover_plugins
- discover_plugins() # labels come from the plugin entries
- cfg = load_gateway_config()
- except Exception:
- return
- connected = {p.value for p in cfg.get_connected_platforms()}
- homes = {p.value: pc.home_channel for p, pc in cfg.platforms.items() if pc.home_channel}
- labels = {e.name: e.label for e in platform_registry.plugin_entries()}
- for value, label in sorted(labels.items(), key=lambda kv: kv[1].lower()):
- home = homes.get(value)
- _row(label, value in connected,
- _configured(value in connected) + (f" (home: {home.chat_id})" if home else ""))
- def _render_gateway(ctx):
- _section("Gateway Service")
- try:
- from hermes_cli.gateway import (
- get_gateway_runtime_snapshot, _format_gateway_pids, named_profile_served_by_running_multiplexer)
- from hermes_cli.gateway_multiplex_served import multiplexer_served_secondaries
- snapshot = get_gateway_runtime_snapshot()
- # A satellite profile has no gateway.pid of its own; the default multiplexer is its live process.
- if not snapshot.running and named_profile_served_by_running_multiplexer():
- _kv_flag("Status:", True, "running (via the default-profile multiplexer)", "stopped")
- _kv("Manage with:", "hermes gateway status # from the default profile")
- return
- _kv_flag("Status:", snapshot.running, "running", "stopped")
- _kv("Manager:", snapshot.manager)
- if snapshot.gateway_pids:
- _kv("PID(s):", _format_gateway_pids(snapshot.gateway_pids))
- if snapshot.running and (served := multiplexer_served_secondaries()):
- _kv("Serves:", ", ".join(served))
- from hermes_cli.gateway_multiplex_served import served_profile_ingress_urls
- for name, per_platform in sorted(served_profile_ingress_urls().items()):
- for platform, url in sorted(per_platform.items()):
- _kv(f" {name}/{platform}:", url)
- if snapshot.has_process_service_mismatch:
- _kv("Service:", "installed but not managing the current running gateway")
- elif snapshot.service_installed and not snapshot.service_running:
- _kv("Service:", "installed but stopped")
- except Exception:
- platform = "linux" if sys.platform.startswith("linux") else sys.platform
- status_text, manager = _GATEWAY_FALLBACK.get(platform, ("N/A", "(not supported on this platform)"))
- _kv("Status:", color(status_text, Colors.DIM))
- _kv("Manager:", manager)
- def _load_json(path: Path, encoding: str = "utf-8"):
- with open(path, encoding=encoding) as f:
- return json.load(f)
- def _cron_summary() -> str:
- """``N active, M total`` jobs line, shared by the full and short status renderers."""
- jobs_file = get_hermes_home() / "cron" / "jobs.json"
- if not jobs_file.exists():
- return "0"
- try:
- # utf-8-sig: same dialect as cron/jobs.load_jobs — Windows editors may leave a UTF-8 BOM
- # that plain utf-8 json.load rejects.
- jobs = _load_json(jobs_file, "utf-8-sig").get("jobs", [])
- return f"{sum(1 for j in jobs if j.get('enabled', True))} active, {len(jobs)} total"
- except Exception:
- return "(error reading jobs file)"
- def _render_cron(ctx):
- _section("Scheduled Jobs")
- _kv("Jobs:", _cron_summary())
- def _render_sessions(ctx):
- _section("Sessions")
- # Gateway session count: state.db is the source of truth; fall back to sessions.json for
- # pre-migration installs.
- try:
- from hermes_state import SessionDB
- db = SessionDB(db_path=get_hermes_home() / "state.db", read_only=True)
- try:
- gateway_rows = db.list_gateway_sessions(active_only=True) or []
- finally:
- db.close()
- except Exception:
- gateway_rows = []
- if gateway_rows:
- _kv("Active:", f"{len(gateway_rows)} session(s)")
- freshest = max((float(r.get("last_active") or 0) for r in gateway_rows), default=0.0)
- if freshest > 0:
- from hermes_cli.timefmt import relative_time
- print(f" Last activity:{relative_time(freshest):>13}")
- elif not (sessions_file := get_hermes_home() / "sessions" / "sessions.json").exists():
- _kv("Active:", 0)
- else:
- try:
- data = _load_json(sessions_file, encoding="utf-8-sig")
- entries = [k for k in data if not str(k).startswith("_")] if isinstance(data, dict) else []
- _kv("Active:", f"{len(entries)} session(s)")
- except Exception:
- _kv("Active:", "(error reading sessions file)")
- # Slot usage, only when max_concurrent_sessions is set. The cap is shared across CLI,
- # desktop/TUI and the messaging gateway, so the surface that gets rejected is rarely the one
- # holding the slots — without this the only way to find out is reading
- # runtime/active_sessions.json by hand.
- try:
- from hermes_cli.active_sessions import (
- active_session_registry_snapshot, format_age, resolve_max_concurrent_sessions)
- cap = resolve_max_concurrent_sessions(ctx.config)
- except Exception:
- cap = None
- if cap:
- try:
- held = active_session_registry_snapshot()
- except Exception:
- held = []
- _kv("Slots:", color(f"{len(held)}/{cap} in use", Colors.YELLOW if len(held) >= cap else Colors.GREEN))
- now = time.time()
- for entry in sorted(held, key=lambda e: e.get("started_at") or 0):
- age = format_age(now - float(entry.get("started_at") or now))
- print(f" {entry.get('surface') or 'unknown':<17} {entry.get('session_id') or '?':<24} {age}")
- def _render_deep(ctx):
- if not ctx.deep:
- return
- _section("Deep Checks")
- openrouter_key = os.getenv("OPENROUTER_API_KEY", "")
- if openrouter_key:
- try:
- import httpx
- response = httpx.get(OPENROUTER_MODELS_URL, headers={"Authorization": f"Bearer {openrouter_key}"}, timeout=10)
- _kv_flag("OpenRouter:", response.status_code == 200, "reachable", f"error ({response.status_code})")
- except Exception as e:
- _kv("OpenRouter:", f"{check_mark(False)} error: {e}")
- try: # gateway port, informational: in use == gateway likely running
- import socket
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- sock.settimeout(1)
- port_in_use = sock.connect_ex(('127.0.0.1', 18789)) == 0
- sock.close()
- _kv("Port 18789:", 'in use' if port_in_use else 'available')
- except OSError:
- pass
- def _render_footer(ctx):
- _banner(("─" * 60, " Run 'hermes doctor' for detailed diagnostics", " Run 'hermes setup' to configure"),
- Colors.DIM)
- print()
- def _connected_platforms() -> list:
- """Platforms the gateway would start (``GatewayConfig.get_connected_platforms``)."""
- from gateway.config import load_gateway_config
- return load_gateway_config().get_connected_platforms()
- def _connected_platform_labels() -> list:
- from gateway.platform_registry import platform_registry
- return [getattr(platform_registry.get(p.value), "label", p.value) for p in _connected_platforms()]
- def _authenticated_provider_names() -> list:
- """The providers the /model picker offers: cached catalogs only, no endpoint probes."""
- from hermes_cli.inventory import load_picker_context
- from hermes_cli.model_switch import list_authenticated_providers
- pick = load_picker_context()
- return [row["name"] for row in list_authenticated_providers(
- user_providers=pick.user_providers, custom_providers=pick.custom_providers,
- excluded_providers=pick.excluded_providers, max_models=0, non_blocking_catalogs=True,
- probe_custom_providers=False)]
- def _gateway_state() -> tuple:
- from hermes_cli.gateway import get_gateway_runtime_snapshot, named_profile_served_by_running_multiplexer
- if get_gateway_runtime_snapshot().running:
- return True, "running"
- if named_profile_served_by_running_multiplexer(): # satellite profile: no gateway.pid of its own
- return True, "running (via the default-profile multiplexer)"
- return False, "stopped"
- def _summary_row(label: str, probe, empty: str) -> None:
- """One summary row; a failing probe degrades only its own row."""
- try:
- values = list(dict.fromkeys(probe()))
- except Exception:
- values = None
- _kv(label, "unknown" if values is None else ", ".join(values) or empty)
- def _render_summary(ctx):
- """Default ``hermes status``: one line per component; ``--full`` prints every section."""
- _render_header(ctx)
- print()
- _load_ctx_config(ctx)
- _kv("Model:", _configured_model_label(ctx.config))
- _kv("Provider:", _effective_provider_label())
- _summary_row("Providers:", _authenticated_provider_names, "none connected")
- try:
- running, text = _gateway_state()
- _kv_flag("Gateway:", running, text, text)
- except Exception:
- _kv("Gateway:", "unknown")
- _summary_row("Platforms:", _connected_platform_labels, "none configured")
- _kv("Jobs:", _cron_summary())
- _banner((" Run 'hermes status --full' for every section",), Colors.DIM)
- print()
- # Print order of `hermes status`; each renderer takes the shared _StatusContext.
- _SECTIONS = (
- _render_header, _render_environment, _render_api_keys, _render_auth_providers, _render_nous_gateway,
- _render_apikey_providers, _render_terminal, _render_platforms, _render_gateway, _render_cron,
- _render_sessions, _render_deep, _render_footer)
- def show_status(args):
- """One-screen summary by default; ``--full``/``--deep`` print every section."""
- # Shared by section renderers: config, --deep, and the Nous login facts Auth Providers derives
- # for the later Nous Tool Gateway section.
- ctx = SimpleNamespace(deep=getattr(args, 'deep', False), config={}, nous_logged_in=False,
- nous_inference_present=False, nous_account_info=None)
- for render in _SECTIONS if getattr(args, 'full', False) or ctx.deep else (_render_summary,):
- render(ctx)
|