| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344 |
- """Dump command for hermes CLI."""
- import json
- import os
- import platform
- import subprocess
- import sys
- from pathlib import Path
- from hermes_cli.config import get_hermes_home, get_env_path, get_project_root, load_config
- from hermes_cli.env_loader import load_hermes_dotenv
- from hermes_constants import display_hermes_home
- from agent.skill_utils import is_excluded_skill_path
- from datetime import UTC
- def _dotenv_key_names() -> set[str]:
- """Env-var names assigned a non-empty value in ~/.hermes/.env — what the managed backends (launchd /
- systemd / desktop ``serve``) load, as opposed to the shell exports ``os.getenv`` reflects here.
- ``hermes debug share`` runs in a terminal, so ``os.getenv`` reflects the shell's environment, which can
- include exported keys the managed backend never sees. Comparing against this set lets the dump flag that
- mismatch (the exact trap behind #48504-style "no web_search" reports: key exported in the shell, absent
- from .env, invisible to the launchd backend).
- """
- try:
- env_path = get_env_path()
- text = env_path.read_text(encoding="utf-8-sig", errors="ignore")
- except (OSError, UnicodeError):
- return set()
- names: set[str] = set()
- for raw in text.splitlines():
- line = raw.strip()
- if not line or line.startswith("#") or "=" not in line:
- continue
- if line.lower().startswith("export "):
- line = line[len("export "):].lstrip()
- name, _, value = line.partition("=")
- if name.strip() and value.strip().strip("'\""): # a bare `KEY=` is effectively unset for the backend
- names.add(name.strip())
- return names
- def _git_output(project_root: Path, *args: str) -> str:
- """Stripped stdout of ``git <args>`` run in *project_root*, or '' on any failure."""
- try:
- result = subprocess.run(["git", *args], capture_output=True, text=True, encoding='utf-8', errors='replace',
- timeout=5, cwd=str(project_root), check=False)
- return result.stdout.strip() if result.returncode == 0 else ""
- except Exception:
- return ""
- def _get_git_commit(project_root: Path) -> str:
- """Short git commit hash, or '(unknown)'.
- The requested *project_root* is authoritative: when it has no git,
- the install-stamp fallback is only valid for the RUNNING install
- (``hermes_cli.version_info`` has no per-root API — it reads
- HERMES_INSTALL_ROOT / the running code root, never an arbitrary
- directory). For any other root the provenance is unknown.
- """
- value = _git_output(project_root, "rev-parse", "--short=8", "HEAD")
- if value:
- return value
- if project_root.resolve() != get_project_root():
- return "(unknown)"
- try:
- from hermes_cli.version_info import get_code_identity # deferred: keeps dump cheap on non-dump paths
- return get_code_identity().get("short_sha") or "(unknown)"
- except Exception:
- return "(unknown)"
- def _get_git_commit_date(project_root: Path) -> str:
- """Return the date the HEAD commit was authored (YYYY-MM-DD), or ''.
- Same authority rule as :func:`_get_git_commit`: the stamp fallback
- describes the running install only.
- """
- value = _git_output(project_root, "log", "-1", "--format=%cd", "--date=short", "HEAD")
- if value:
- return value
- if project_root.resolve() != get_project_root():
- return ""
- try:
- from datetime import datetime, timezone
- from hermes_cli.version_info import get_version_info # deferred: keeps dump cheap on non-dump paths
- commit_date = get_version_info().commit_date
- return datetime.fromtimestamp(commit_date, tz=UTC).strftime("%Y-%m-%d") if commit_date else ""
- except Exception:
- return ""
- def _redact(value: str) -> str:
- """Redact all but first 4 and last 4 chars; ``""`` for an empty value (dump formats empties as blank)."""
- from agent.redact import mask_secret
- return mask_secret(value)
- def _gateway_status() -> str:
- """Return a short gateway status string."""
- try:
- from hermes_cli.gateway import get_gateway_runtime_snapshot
- snapshot = get_gateway_runtime_snapshot()
- if snapshot.running:
- mode = "manual" if snapshot.has_process_service_mismatch else snapshot.manager
- # A supervised gateway may have no scannable PID (s6 `python -c` launcher, #125390).
- pid = f", pid {snapshot.gateway_pids[0]}" if snapshot.gateway_pids else ""
- return f"running ({mode}{pid})"
- return f"stopped ({snapshot.manager})"
- except Exception:
- return "unknown" if sys.platform.startswith(("linux", "darwin")) else "N/A"
- def _count_skills(hermes_home: Path) -> int:
- """Count installed skills."""
- skills_dir = hermes_home / "skills"
- return sum(1 for item in skills_dir.rglob("SKILL.md") if not is_excluded_skill_path(item)) if skills_dir.is_dir() else 0
- def _cron_summary(hermes_home: Path) -> str:
- """Return cron jobs summary."""
- jobs_file = 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.
- with open(jobs_file, encoding="utf-8-sig") as f:
- jobs = json.load(f).get("jobs", [])
- active = sum(1 for j in jobs if j.get("enabled", True))
- return f"{active} active / {len(jobs)} total"
- except Exception:
- return "(error reading)"
- _PLATFORM_ENV_VARS = {
- "telegram": "TELEGRAM_BOT_TOKEN", "discord": "DISCORD_BOT_TOKEN", "slack": "SLACK_BOT_TOKEN",
- "whatsapp": "WHATSAPP_ENABLED", "signal": "SIGNAL_HTTP_URL", "email": "EMAIL_ADDRESS",
- "sms": "TWILIO_ACCOUNT_SID", "matrix": "MATRIX_HOMESERVER_URL", "mattermost": "MATTERMOST_URL",
- "dingtalk": "DINGTALK_CLIENT_ID", "feishu": "FEISHU_APP_ID",
- "wecom": "WECOM_BOT_ID", "wecom_callback": "WECOM_CALLBACK_CORP_ID", "weixin": "WEIXIN_ACCOUNT_ID",
- "qqbot": "QQ_APP_ID",
- }
- def _get_model_and_provider(config: dict) -> tuple[str, str]:
- """Extract model and provider from config."""
- model_cfg = config.get("model", "")
- if isinstance(model_cfg, dict):
- return (model_cfg.get("default") or model_cfg.get("model") or model_cfg.get("name") or "(not set)", model_cfg.get("provider") or "(auto)")
- return (model_cfg if isinstance(model_cfg, str) else "") or "(not set)", "(auto)"
- # Sections with interesting user-facing overrides
- _INTERESTING_PATHS = (
- ("agent", "max_turns"), ("agent", "gateway_timeout"), ("agent", "session_stall_timeout"),
- ("agent", "sanitizer_heal_escalation_threshold"), ("agent", "tool_use_enforcement"),
- ("agent", "execution_guidance"), ("terminal", "backend"), ("terminal", "docker_image"),
- ("terminal", "persistent_shell"), ("browser", "allow_private_urls"), ("compression", "enabled"),
- ("compression", "threshold"), ("compression", "in_place"), ("display", "streaming"),
- ("display", "skin"), ("display", "show_reasoning"), ("privacy", "redact_pii"), ("tts", "provider"),
- )
- def _config_overrides(config: dict) -> dict[str, str]:
- """Find non-default config values worth reporting."""
- from hermes_cli.config import DEFAULT_CONFIG
- overrides = {}
- for section, key in _INTERESTING_PATHS:
- default_section = DEFAULT_CONFIG.get(section, {})
- user_section = config.get(section, {})
- if not isinstance(default_section, dict) or not isinstance(user_section, dict):
- continue
- user_val = user_section.get(key)
- if user_val is not None and user_val != default_section.get(key):
- overrides[f"{section}.{key}"] = str(user_val)
- user_toolsets = config.get("toolsets", [])
- if user_toolsets != DEFAULT_CONFIG.get("toolsets", []):
- overrides["toolsets"] = str(user_toolsets)
- fallbacks = config.get("fallback_providers", [])
- if fallbacks:
- from hermes_cli.debug_redaction import redact_debug_support_text
- overrides["fallback_providers"] = redact_debug_support_text(
- str(_fallback_debug_projection(fallbacks))
- )
- return overrides
- _FALLBACK_DEBUG_FIELDS = (
- "provider",
- "model",
- "base_url",
- "api_mode",
- "key_env",
- "api_key_env",
- "max_tokens",
- )
- def _fallback_debug_projection(value) -> list[dict]:
- """Render only route metadata useful to support; omit arbitrary containers.
- Fallback entries are open mappings consumed by provider-specific code, so a
- denylist cannot make their ``headers``, ``env``, command/argv, or future
- fields safe to serialize. Credential pointer names remain useful and carry
- no values; an inline key is represented only as a source status.
- """
- entries = [value] if isinstance(value, dict) else value if isinstance(value, list) else []
- projected: list[dict] = []
- for entry in entries:
- if not isinstance(entry, dict):
- continue
- item: dict = {}
- for key in _FALLBACK_DEBUG_FIELDS:
- child = entry.get(key)
- if key == "max_tokens":
- if isinstance(child, (int, float)) and not isinstance(child, bool):
- item[key] = child
- elif isinstance(child, str):
- item[key] = child
- if entry.get("api_key"):
- item["credential_source"] = "inline"
- projected.append(item)
- return projected
- # (env var, dump label) in display order.
- _API_KEYS = [
- ("OPENROUTER_API_KEY", "openrouter"), ("OPENAI_API_KEY", "openai"),
- ("ANTHROPIC_API_KEY", "anthropic"), ("ANTHROPIC_TOKEN", "anthropic_token"),
- ("NOUS_API_KEY", "nous"), ("GOOGLE_API_KEY", "google/gemini"), ("GEMINI_API_KEY", "gemini"),
- ("GLM_API_KEY", "glm/zai"), ("ZAI_API_KEY", "zai"), ("KIMI_API_KEY", "kimi"),
- ("MINIMAX_API_KEY", "minimax"), ("DEEPSEEK_API_KEY", "deepseek"),
- ("DASHSCOPE_API_KEY", "dashscope"), ("HF_TOKEN", "huggingface"), ("NVIDIA_API_KEY", "nvidia"),
- ("AI_GATEWAY_API_KEY", "ai_gateway"), ("OPENCODE_ZEN_API_KEY", "opencode_zen"),
- ("OPENCODE_GO_API_KEY", "opencode_go"), ("COMMANDCODE_API_KEY", "commandcode"),
- ("KILOCODE_API_KEY", "kilocode"), ("FIRECRAWL_API_KEY", "firecrawl"), ("TAVILY_API_KEY", "tavily"), ("PERPLEXITY_API_KEY", "perplexity"),
- ("KEENABLE_API_KEY", "keenable"), ("BROWSERBASE_API_KEY", "browserbase"), ("FAL_KEY", "fal"),
- ("ELEVENLABS_API_KEY", "elevenlabs"), ("GITHUB_TOKEN", "github"),
- ]
- def _version_line(project_root: Path) -> str:
- """``<version> [<commit>] (<commit date>)`` using the running code identity."""
- try:
- from hermes_cli.version_info import get_version_info
- version = get_version_info().derived_version
- except Exception:
- version = "(unknown)"
- ver_str = f"{version} [{_get_git_commit(project_root)}]"
- commit_date = _get_git_commit_date(project_root)
- return f"{ver_str} ({commit_date})" if commit_date else ver_str
- def _effective_terminal_backend(config: dict) -> str:
- """The EFFECTIVE backend: a TERMINAL_ENV set directly in .env / the shell overrides ``terminal.backend`` and
- is what terminal_tool uses. run_dump() has already loaded .env, so os.environ reflects the override."""
- config_backend = config.get("terminal", {}).get("backend", "local")
- env_backend = (os.environ.get("TERMINAL_ENV") or "").strip().lower()
- if env_backend and env_backend != str(config_backend).strip().lower():
- return f"{env_backend} (TERMINAL_ENV overrides config.yaml terminal.backend={config_backend})"
- return config_backend
- def _api_key_lines(show_keys: bool) -> list[str]:
- dotenv_keys = _dotenv_key_names()
- lines = []
- for env_var, label in _API_KEYS:
- val = os.getenv(env_var, "")
- display = _redact(val) if show_keys and val else ("set" if val else "not set")
- # Set in this shell but absent from ~/.hermes/.env: a managed backend loads .env, not the login
- # shell, so it likely can't see this key — flag it so support doesn't chase a phantom "configured".
- if val and env_var not in dotenv_keys:
- display += " (shell only — not in .env; managed/desktop backend may not see it)"
- # `hermes auth add openrouter` credentials live in the pool, not env — don't read "not set".
- # A credential added via `hermes auth add openrouter` lives in the credential pool, not as an env
- # var — surface it so the dump doesn't misleadingly read "not set" while `hermes auth list` shows it
- # (#42130).
- if not val and label == "openrouter":
- try:
- from agent.credential_pool import load_pool as _load_pool
- if _load_pool("openrouter").has_credentials():
- display = "set (auth pool)"
- except Exception:
- pass
- lines.append(f" {label:<20} {display}")
- return lines
- def _openai_version() -> str:
- try:
- import openai
- return openai.__version__
- except ImportError:
- return "not installed"
- def run_dump(args):
- """Output a compact, copy-pasteable setup summary."""
- show_keys = getattr(args, "show_keys", False)
- # Load env from .env file so key checks work
- load_hermes_dotenv(hermes_home=get_env_path().parent, project_env=get_project_root() / ".env")
- project_root, hermes_home = get_project_root(), get_hermes_home()
- try:
- config = load_config()
- except Exception:
- config = {}
- model, provider = _get_model_and_provider(config)
- try:
- from hermes_cli.profiles import get_active_profile_name
- profile = get_active_profile_name() or "(default)"
- except Exception:
- profile = "(default)"
- toolsets = config.get("toolsets", ["hermes-cli"])
- platforms = [name for name, env in _PLATFORM_ENV_VARS.items() if os.getenv(env)]
- lines = [
- "--- hermes dump ---",
- f"version: {_version_line(project_root)}",
- f"os: {platform.system()} {platform.release()} {platform.machine()}",
- f"python: {sys.version.split()[0]}",
- f"openai_sdk: {_openai_version()}",
- f"profile: {profile}",
- f"hermes_home: {display_hermes_home()}",
- f"model: {model}",
- f"provider: {provider}",
- f"terminal: {_effective_terminal_backend(config)}",
- "", "api_keys:", *_api_key_lines(show_keys),
- "", "features:",
- f" toolsets: {', '.join(toolsets) if toolsets else '(default)'}",
- f" mcp_servers: {len(config.get('mcp', {}).get('servers', {}))}",
- f" memory_provider: {config.get('memory', {}).get('provider', '') or 'built-in'}",
- f" gateway: {_gateway_status()}",
- f" platforms: {', '.join(platforms) if platforms else 'none'}",
- f" cron_jobs: {_cron_summary(hermes_home)}",
- f" skills: {_count_skills(hermes_home)}",
- ]
- overrides = _config_overrides(config)
- if overrides:
- lines += ["", "config_overrides:"] + [f" {key}: {val}" for key, val in overrides.items()]
- print("\n".join(lines + ["--- end dump ---"]))
|