cli_config_load.py 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318
  1. """Classic-CLI config loading: prefill messages, reasoning/service-tier parsing, terminal env mirroring, CLI defaults + user YAML merge and the logging/display bootstrap.
  2. Split out of ``cli.py``; ``cli`` re-exports every public name and moved bodies late-bind
  3. cli-level names through ``from cli import ...`` at call time so facade monkeypatch seams hold.
  4. """
  5. from __future__ import annotations
  6. import json
  7. import logging
  8. import os
  9. import sys
  10. from pathlib import Path
  11. from typing import List, Dict, Any
  12. # Log-record parity with the origin module.
  13. logger = logging.getLogger("cli")
  14. def _cli():
  15. """Late import of the ``cli`` facade: mutable CLI module state (and its test seams) lives there."""
  16. import cli
  17. return cli
  18. def _load_prefill_messages(file_path: str, base_dir: Path | None = None) -> list[dict[str, Any]]:
  19. """Load prefill messages (JSON array) from *file_path*; missing/empty -> [].
  20. Relative paths resolve against *base_dir*, defaulting to the CLI's hermes home.
  21. """
  22. if not file_path:
  23. return []
  24. path = Path(file_path).expanduser()
  25. if not path.is_absolute():
  26. path = (base_dir or _cli()._hermes_home) / path
  27. if not path.exists():
  28. logger.warning("Prefill messages file not found: %s", path)
  29. return []
  30. try:
  31. with open(path, "r", encoding="utf-8-sig") as f:
  32. data = json.load(f)
  33. if not isinstance(data, list):
  34. logger.warning("Prefill messages file must contain a JSON array: %s", path)
  35. return []
  36. return data
  37. except Exception as e:
  38. logger.warning("Failed to load prefill messages from %s: %s", path, e)
  39. return []
  40. def _resolve_prefill_messages_file(config: dict[str, Any]) -> str:
  41. """Prefill file path: env, then top-level ``prefill_messages_file``, then legacy ``agent.*``."""
  42. from agent.session_client_env import session_env
  43. agent_cfg = config.get("agent", {})
  44. return (
  45. session_env("HERMES_PREFILL_MESSAGES_FILE").strip()
  46. or str(config.get("prefill_messages_file", "") or "").strip()
  47. or (str(agent_cfg.get("prefill_messages_file", "") or "").strip() if isinstance(agent_cfg, dict) else "")
  48. )
  49. def _parse_reasoning_config(effort) -> dict | None:
  50. """Parse a reasoning effort level (string or YAML bool; ``false``/``off`` = disabled)."""
  51. from hermes_constants import parse_reasoning_effort
  52. result = parse_reasoning_effort(effort)
  53. if effort and str(effort).strip() and result is None:
  54. logger.warning("Unknown reasoning_effort '%s', using default (medium)", effort)
  55. return result
  56. def _parse_service_tier_config(raw: str) -> str | None:
  57. """Parse a persisted fast-mode preference: None, "priority", "ultrafast", "auto", or "cold"."""
  58. from agent.fast_mode import NORMAL_TIER_WORDS, parse_service_tier
  59. tier = parse_service_tier(raw)
  60. if tier is None and str(raw or "").strip().lower() not in NORMAL_TIER_WORDS:
  61. logger.warning("Unknown service_tier '%s', ignoring", raw)
  62. return tier
  63. # terminal.<key> -> TERMINAL_<KEY> env var. Container-resource keys apply to docker,
  64. # modal, daytona, vercel_sandbox and container plugin backends (ignored for local/ssh).
  65. _TERMINAL_ENV_MAPPINGS = {
  66. key: f"TERMINAL_{key.upper()}"
  67. for key in (
  68. "degraded_mode", "cwd", "timeout", "home_mode", "lifetime_seconds", "docker_image",
  69. "docker_forward_env", "modal_image", "daytona_image", "vercel_runtime", "vercel_image",
  70. "ssh_host", "ssh_user", "ssh_port", "ssh_key", "container_cpu", "container_memory",
  71. "container_disk", "container_persistent", "docker_volumes", "docker_env", "docker_extra_args",
  72. "docker_shm_size", "docker_mount_cwd_to_workspace", "docker_network", "docker_run_as_host_user",
  73. "docker_snap_compat",
  74. "docker_persist_across_processes", "docker_shared_container_key", "docker_orphan_reaper",
  75. "sandbox_dir", "persistent_shell",
  76. )
  77. }
  78. _TERMINAL_ENV_MAPPINGS = {"env_type": "TERMINAL_ENV", **_TERMINAL_ENV_MAPPINGS, "sudo_password": "SUDO_PASSWORD"}
  79. # Per-task auxiliary endpoint tuples (config key -> env var).
  80. _AUXILIARY_TASK_ENV = {
  81. "vision": {
  82. "provider": "AUXILIARY_VISION_PROVIDER",
  83. "model": "AUXILIARY_VISION_MODEL",
  84. "base_url": "AUXILIARY_VISION_BASE_URL",
  85. "api_key": "AUXILIARY_VISION_API_KEY",
  86. },
  87. "approval": {
  88. "provider": "AUXILIARY_APPROVAL_PROVIDER",
  89. "model": "AUXILIARY_APPROVAL_MODEL",
  90. "base_url": "AUXILIARY_APPROVAL_BASE_URL",
  91. "api_key": "AUXILIARY_APPROVAL_API_KEY",
  92. },
  93. }
  94. _CWD_PLACEHOLDERS = (".", "auto", "cwd")
  95. def _mirror_config_to_env(defaults, _file_has_terminal_config):
  96. """Project config.yaml values into the env vars the tool modules read (terminal/browser/auxiliary/security/sessions). Env always wins when already set."""
  97. from cli import _AUXILIARY_TASK_ENV, _CWD_PLACEHOLDERS, _TERMINAL_ENV_MAPPINGS
  98. terminal_config = defaults.get("terminal", {})
  99. # "backend" (documented) and legacy "env_type" are both accepted; "backend" wins.
  100. if "backend" in terminal_config:
  101. terminal_config["env_type"] = terminal_config["backend"]
  102. # Local backend: cwd is always os.getcwd(). Non-local: a placeholder is popped so
  103. # terminal_tool uses its per-backend default; an explicit path is kept.
  104. effective_backend = terminal_config.get("env_type", "local")
  105. if effective_backend == "local":
  106. terminal_config["cwd"] = os.getcwd()
  107. defaults["terminal"]["cwd"] = terminal_config["cwd"]
  108. elif terminal_config.get("cwd") in _CWD_PLACEHOLDERS:
  109. terminal_config.pop("cwd", None)
  110. # TERMINAL_CWD is force-exported (beats stale .env) except inside a gateway process,
  111. # whose config bridge already set it. Ask whether THIS process imported gateway.run:
  112. # its _HERMES_GATEWAY env marker is inherited by every shell the gateway's terminal
  113. # tool spawns, so a `hermes chat` launched there would keep the gateway's directory.
  114. _is_gateway = "gateway.run" in sys.modules
  115. for config_key, env_var in _TERMINAL_ENV_MAPPINGS.items():
  116. if config_key not in terminal_config:
  117. continue
  118. val = terminal_config[config_key]
  119. if env_var == "TERMINAL_CWD":
  120. if not _is_gateway:
  121. os.environ[env_var] = str(val)
  122. elif _file_has_terminal_config or env_var not in os.environ:
  123. os.environ[env_var] = json.dumps(val) if isinstance(val, (list, dict)) else str(val)
  124. browser_config = defaults.get("browser", {})
  125. if "inactivity_timeout" in browser_config:
  126. os.environ["BROWSER_INACTIVITY_TIMEOUT"] = str(browser_config["inactivity_timeout"])
  127. # Only non-empty / non-"auto" auxiliary values are bridged so auto-detection still works.
  128. auxiliary_config = defaults.get("auxiliary", {})
  129. for task_key, env_map in _AUXILIARY_TASK_ENV.items():
  130. task_cfg = auxiliary_config.get(task_key, {})
  131. if not isinstance(task_cfg, dict):
  132. continue
  133. for field, env_var in env_map.items():
  134. val = str(task_cfg.get(field, "")).strip()
  135. if val and not (field == "provider" and val == "auto"):
  136. os.environ[env_var] = val
  137. security_config = defaults.get("security", {})
  138. if isinstance(security_config, dict):
  139. redact = security_config.get("redact_secrets")
  140. if redact is not None:
  141. os.environ["HERMES_REDACT_SECRETS"] = str(redact).lower()
  142. # Session-search index knobs (hermes_state reads the env carriers).
  143. sessions_config = defaults.get("sessions", {})
  144. if isinstance(sessions_config, dict):
  145. if "cjk_fts" in sessions_config:
  146. os.environ["HERMES_CJK_FTS"] = str(sessions_config["cjk_fts"])
  147. if "search_slow_ms" in sessions_config:
  148. os.environ["HERMES_SEARCH_SLOW_MS"] = str(sessions_config["search_slow_ms"])
  149. def _cli_config_defaults():
  150. """Built-in defaults for every config key the CLI reads (the file overlays these)."""
  151. from hermes_cli.config_defaults import DEFAULT_SANDBOX_IMAGE as img
  152. return {
  153. "model": {"default": "", "base_url": "", "provider": "auto"},
  154. "terminal": {
  155. "env_type": "local", "cwd": ".", "home_mode": "auto", "lifetime_seconds": 300, # cwd "." -> os.getcwd()
  156. "docker_image": img, "docker_forward_env": [], "modal_image": img, "daytona_image": img, "docker_volumes": [],
  157. "docker_mount_cwd_to_workspace": False, # opt-in only: sandbox isolation
  158. "docker_shared_container_key": "",
  159. },
  160. "browser": {"inactivity_timeout": 120, "engine": "auto"}, # engine: auto (Chromium) | lightpanda
  161. # threshold: fraction of the model's context limit; min_tail: real user messages kept in the tail
  162. "compression": {"enabled": True, "threshold": 0.50, "min_tail_user_messages": 1},
  163. "agent": {
  164. "max_turns": 500, "verbose": False, "system_prompt": "", "prefill_messages_file": "", # max_turns shared with subagents
  165. "reasoning_effort": "", "service_tier": "",
  166. "personalities": {}, # user overrides merged by name over hermes_cli.personality builtins
  167. },
  168. "display": {
  169. "compact": False,
  170. # /resume recap tuning and show_reasoning: keep in sync with hermes_cli/config.py DEFAULT_CONFIG
  171. "resume_display": "full", "resume_exchanges": 10, "resume_max_user_chars": 300,
  172. "resume_max_assistant_chars": 200, "resume_max_assistant_lines": 3, "resume_skip_tool_only": True,
  173. "show_reasoning": True, "reasoning_full": False, "streaming": True, "busy_input_mode": "interrupt",
  174. "cli_layout": "modern",
  175. "persistent_output": True, "persistent_output_max_lines": 200,
  176. # Also clear scrollback on redraw/resize recovery; off because users prefer history.
  177. "cli_rebuild_scrollback_on_redraw": False,
  178. "persist_prompts": True, # one-line summary of resolved modal prompts into scrollback
  179. "skin": "default",
  180. },
  181. "code_execution": {"timeout": 300, "max_tool_calls": 50},
  182. "auxiliary": {"vision": {"provider": "auto", "model": "", "base_url": "", "api_key": ""}},
  183. # delegation: empty model/provider = inherit parent; api_key falls back to OPENAI_API_KEY
  184. "delegation": {"max_iterations": 45, "model": "", "provider": "", "base_url": "", "api_key": ""},
  185. "onboarding": {"seen": {}}, # first-touch hint flags (agent/onboarding.py), latched once shown
  186. }
  187. def _merge_file_config(defaults: dict[str, Any], file_config: dict[str, Any]) -> None:
  188. """Overlay a parsed config file onto *defaults* in place (model normalization, deep merge, legacy keys)."""
  189. # model: string (new format) or dict (old format with default/base_url)
  190. if "model" in file_config:
  191. if isinstance(file_config["model"], str):
  192. defaults["model"]["default"] = file_config["model"]
  193. elif isinstance(file_config["model"], dict):
  194. defaults["model"].update(file_config["model"])
  195. # Promote model.model -> model.default (HermesCLI checks "default" first).
  196. if "model" in file_config["model"] and "default" not in file_config["model"]:
  197. defaults["model"]["default"] = file_config["model"]["model"]
  198. # Deep-merge dict sections, overwrite scalars; a None section keeps the defaults;
  199. # unknown keys (platform_toolsets, memory, ...) are carried over.
  200. for key, value in file_config.items():
  201. if key == "model":
  202. continue
  203. if isinstance(defaults.get(key), dict):
  204. if isinstance(value, dict):
  205. defaults[key].update(value)
  206. elif value is not None:
  207. defaults[key] = value
  208. else:
  209. defaults[key] = value
  210. # Legacy root-level max_turns -> agent.max_turns whenever the nested key is missing.
  211. agent_file_config = file_config.get("agent")
  212. if "max_turns" in file_config and not (
  213. isinstance(agent_file_config, dict) and agent_file_config.get("max_turns") is not None
  214. ):
  215. defaults["agent"]["max_turns"] = file_config["max_turns"]
  216. def load_cli_config() -> dict[str, Any]:
  217. """~/.hermes/config.yaml (else ./cli-config.yaml) over built-in defaults; env vars win.
  218. ``HERMES_IGNORE_USER_CONFIG=1`` skips the user config entirely (``.env`` still loads).
  219. """
  220. from cli import _cli_config_defaults, _hermes_home, _merge_file_config, _mirror_config_to_env
  221. from hermes_cli.config_backend import config_exists, read_config_doc
  222. config_path = _hermes_home / 'config.yaml'
  223. # A backend whose user layer always exists never takes the repo-file fallback.
  224. if not config_exists(config_path) or os.environ.get("HERMES_IGNORE_USER_CONFIG") == "1":
  225. config_path = Path(__file__).parent / 'cli-config.yaml'
  226. defaults = _cli_config_defaults()
  227. # Only a file's terminal section may overwrite terminal env vars already set by .env.
  228. _file_has_terminal_config = False
  229. if config_exists(config_path):
  230. try:
  231. from hermes_cli.config import _normalize_root_model_keys
  232. file_config = _normalize_root_model_keys(read_config_doc(config_path) or {})
  233. _file_has_terminal_config = "terminal" in file_config
  234. _merge_file_config(defaults, file_config)
  235. except Exception as e:
  236. logger.warning("Failed to load cli-config.yaml: %s", e)
  237. # Expand ${ENV_VAR} references before bridging to env vars.
  238. from hermes_cli.config import _expand_env_vars
  239. defaults = _expand_env_vars(defaults)
  240. # Administrator-pinned (managed scope) values overlay LAST; cli.py builds its config
  241. # independently of hermes_cli.config, so this keeps parity with `hermes config`. Fail-open.
  242. from hermes_cli import managed_scope
  243. defaults = managed_scope.apply_managed_overlay(defaults)
  244. _mirror_config_to_env(defaults, _file_has_terminal_config)
  245. return defaults
  246. def _init_logging_and_display_from_config() -> None:
  247. """Best-effort startup side effects: logging, config warnings, skin, display knobs."""
  248. from importlib import import_module as _im
  249. def _display(key, default):
  250. return _cli().CLI_CONFIG.get("display", {}).get(key, default)
  251. for step in (
  252. lambda: _im("hermes_logging").setup_logging(mode="cli"),
  253. lambda: _im("hermes_cli.config").print_config_warnings(),
  254. lambda: _im("hermes_cli.skin_engine").init_skin_from_config(_cli().CLI_CONFIG),
  255. lambda: _im("agent.display").set_tool_preview_max_len(int(_display("tool_preview_length", 0) or 0)),
  256. lambda: _im("agent.display").set_friendly_tool_labels(bool(_display("friendly_tool_labels", True))),
  257. ):
  258. try:
  259. step()
  260. except Exception:
  261. pass