| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659 |
- """TUI (ui-tui) launcher: prepared source builds and argv/env assembly.
- Split out of ``hermes_cli/main.py``. Names that still live in main (``PROJECT_ROOT``, ...)
- are imported lazily inside the functions that use them (avoids an import cycle).
- """
- import logging
- import contextlib
- import json
- import os
- import shutil
- import sqlite3
- import subprocess
- import sys
- from pathlib import Path
- from typing import Optional
- from agent.i18n import t
- # Log-record parity with the origin module.
- logger = logging.getLogger("hermes_cli.main")
- def _bypass_chat_launch(args) -> bool:
- """--safe-mode / --ignore-user-config chat: the gateway owner freezes code defaults and runs
- the turn out of process, so the profile's display.interface must not pick a surface and the
- client performs no discovery. Explicit --tui forwards the flags in its session.create policy."""
- return bool(getattr(args, "safe_mode", False) or getattr(args, "ignore_user_config", False)) \
- and not getattr(args, "tui", False)
- def _read_tui_active_session_file(path: Optional[str]) -> Optional[str]:
- if not path:
- return None
- try:
- data = json.loads(Path(path).read_text(encoding="utf-8-sig"))
- return str(data.get("session_id") or "").strip() or None
- except Exception:
- return None
- # A canonical local session is keyed ``local-`` + 64 hex; main's epilogue printed 22-char stored ids.
- _SHORT_RESUME_LEN = 22
- def _short_resume_id(db, session_id: str) -> str:
- """The 22-char prefix of a canonical ``local-…`` id when it names only that session (``--resume``
- resolves a unique prefix back); every other id, or an ambiguous prefix, prints whole."""
- if not session_id.startswith("local-") or len(session_id) <= _SHORT_RESUME_LEN:
- return session_id
- short = session_id[:_SHORT_RESUME_LEN]
- try:
- return short if db.resolve_session_id(short) == session_id else session_id
- except sqlite3.Error: # an unreadable store prints the whole id
- return session_id
- def _branch_lineage(db, session: dict) -> list:
- """*session* plus each ``/branch`` ancestor it was cut from. Main's epilogue after ``/branch`` still
- named the parent and so reported the conversation's tokens; a canonical branch child is named
- itself, and its copied history was billed on the ancestors."""
- rows, seen = [session], {session.get("id")}
- while True:
- try:
- config = json.loads(rows[-1].get("model_config") or "{}")
- except (TypeError, ValueError):
- break
- parent_id = config.get("_branched_from") if isinstance(config, dict) else None
- parent = db.get_session(parent_id) if parent_id and parent_id not in seen else None
- if not parent:
- break
- seen.add(parent_id)
- rows.append(parent)
- return rows
- def _print_tui_exit_summary(session_id: Optional[str], active_session_file: Optional[str] = None) -> None:
- """Print a shell-visible epilogue after TUI exits."""
- from hermes_cli.main import _resolve_last_session
- target = (
- _read_tui_active_session_file(active_session_file) or session_id or _resolve_last_session(source="tui")
- )
- if not target:
- return
- db = None
- try:
- from hermes_state import SessionDB
- from hermes_cli.config import get_hermes_home
- db = SessionDB(db_path=get_hermes_home() / "state.db", read_only=True)
- session = db.get_session(target)
- if not session:
- return
- title = db.get_session_title(target)
- resume_id = _short_resume_id(db, target)
- message_count = int(session.get("message_count") or 0)
- if message_count == 0:
- return # No real conversation — don't show resume info
- tokens = {k: 0 for k in ("input", "output", "cache_read", "cache_write", "reasoning")}
- for row in _branch_lineage(db, session):
- for k in tokens:
- tokens[k] += int(row.get(f"{k}_tokens") or 0)
- except Exception:
- return
- finally:
- if db is not None:
- db.close()
- # Sessions live under the profile's HERMES_HOME — mirror cli_session_mixin::_print_exit_summary.
- from hermes_cli.profiles import get_active_profile_name
- active_profile = get_active_profile_name()
- profile_flag = "" if active_profile in ("default", "custom") else f" -p {active_profile}"
- print(f"\n{t('cli.session.exit_resume_hint')}\n hermes --tui --resume {resume_id}{profile_flag}")
- if title:
- print(f' hermes --tui -c "{title}"{profile_flag}')
- print(f"\nSession: {resume_id}")
- if title:
- print(f"Title: {title}")
- print(f"Messages: {message_count}")
- print(
- "Tokens: "
- f"{sum(tokens.values())} (in {tokens['input']}, out {tokens['output']}, "
- f"cache {tokens['cache_read'] + tokens['cache_write']}, reasoning {tokens['reasoning']})"
- )
- def _tui_need_rebuild(root: Path) -> bool:
- from hermes_cli.source_build import source_product_current
- force = (os.environ.get("HERMES_TUI_FORCE_BUILD") or "").strip().lower()
- return force in {"1", "true", "yes", "on"} or not source_product_current(root.parent, "tui", root / "dist")
- def _find_bundled_tui(hermes_cli_dir: Path | None = None) -> Path | None:
- """Find a pre-built TUI entry.js bundled in the wheel."""
- if hermes_cli_dir is None:
- hermes_cli_dir = Path(__file__).parent
- bundled = hermes_cli_dir / "tui_dist" / "entry.js"
- return bundled if bundled.is_file() else None
- def _restore_tui_workspace(tui_dir: Path) -> bool:
- """Best-effort ``git restore`` of a missing ``ui-tui/`` (Windows AV/NTFS filters can delete
- tracked files after ``hermes update``); True when the directory exists afterwards.
- On Windows an antivirus / NTFS filter driver can leave tracked ``ui-tui/`` files deleted in the working
- tree after ``hermes update`` (HEAD stays intact; the files just vanish — see issue #49145). Those files
- are tracked, so ``git restore`` puts them back deterministically. Best-effort: returns False (rather
- than raising) when git is unavailable, this isn't a checkout, or the restore leaves the directory still
- missing — the caller then prints the manual-recovery message.
- """
- git = shutil.which("git")
- if not git or not (tui_dir.parent / ".git").exists():
- return False
- try:
- subprocess.run(
- [git, "restore", "--", tui_dir.name], cwd=str(tui_dir.parent), capture_output=True,
- text=True, encoding="utf-8", errors="replace", check=False)
- except OSError:
- return False
- return tui_dir.is_dir()
- def _ensure_tui_workspace(tui_dir: Path) -> None:
- """Ensure ``ui-tui/`` exists before it is used as a subprocess cwd (else ``NotADirectoryError``
- / ``WinError 267`` with no usable message): git-restore first, then abort with recovery steps.
- Without this, a missing workspace falls through to ``subprocess.run(..., cwd=<missing ui-tui>)``, which
- crashes with ``NotADirectoryError`` (``WinError 267`` on Windows) instead of a usable message (#49145).
- We first try to self-heal via ``git restore``; only if that can't recover the directory do we abort with
- concrete manual-recovery steps.
- """
- if tui_dir.is_dir():
- return
- if _restore_tui_workspace(tui_dir):
- if not os.environ.get("HERMES_QUIET"):
- print(f"Restored missing TUI workspace: {tui_dir}")
- return
- print(
- "Error: the TUI workspace is missing from this Hermes checkout.\n"
- f"Expected directory: {tui_dir}\n"
- "This usually means `hermes update` left tracked ui-tui files deleted.\n"
- "Recovery:\n"
- " 1. From the Hermes checkout, run `git restore -- ui-tui`\n"
- " 2. Run `npm install --silent --no-fund --no-audit --progress=false`\n"
- " 3. Retry `hermes --tui`\n"
- "If the checkout is still inconsistent, run `hermes update --force`.",
- file=sys.stderr)
- sys.exit(1)
- def _tui_node_bin(bin: str) -> str:
- """Resolve the TUI runtime through PM; an explicit bundled HERMES_NODE wins."""
- if bin == "node":
- env_node = os.environ.get("HERMES_NODE")
- if env_node and os.path.isfile(env_node) and os.access(env_node, os.X_OK):
- return env_node
- from pm import ensure
- path = shutil.which(bin, path=ensure(bin).env["PATH"])
- if not path:
- print(
- f"Node.js is required for the TUI but `{bin}` was not found. Install it from "
- "https://nodejs.org (run `hermes doctor` for the install hint for your OS), then "
- "retry `hermes --tui`. To keep working now, run `hermes --cli`."
- )
- sys.exit(1)
- return path
- def _make_tui_argv(tui_dir: Path, tui_dev: bool) -> tuple[list[str], Path]:
- """TUI: --dev → tsx src; else node dist (HERMES_TUI_DIR prebuilt or esbuild)."""
- # Footgun: --dev against a prebuilt bundle that has no source/node_modules.
- ext_dir = os.environ.get("HERMES_TUI_DIR")
- if tui_dev and ext_dir:
- print(
- f"Error: --dev is incompatible with HERMES_TUI_DIR={ext_dir}\n"
- f"The prebuilt TUI has no source code to hot-reload.\n"
- f"Unset HERMES_TUI_DIR (e.g. `unset HERMES_TUI_DIR`) to use --dev from a checkout.",
- file=sys.stderr)
- sys.exit(1)
- # 1. Prebuilt bundle (nix / packaged release / Docker image): just run it.
- # Must run BEFORE _ensure_tui_workspace(): a prebuilt install ships
- # hermes_cli/tui_dist/entry.js but never ui-tui/ (git checkouts only).
- # 1. A prebuilt install (Docker image, Nix build, or prior `npm run build`) ships
- # hermes_cli/tui_dist/entry.js but never ships ui-tui/ at all (that directory only exists in a git
- # checkout) — so requiring the workspace to exist first made every prebuilt dashboard Chat tab
- # connection hard-exit before it ever got a chance to try the bundled entry.js it already has. See
- # #56665.
- if not tui_dev:
- if ext_dir:
- p = Path(ext_dir)
- if (p / "dist" / "entry.js").is_file():
- return [_tui_node_bin("node"), "--expose-gc", str(p / "dist" / "entry.js")], p
- bundled = _find_bundled_tui()
- if bundled is not None:
- return [_tui_node_bin("node"), "--expose-gc", str(bundled)], bundled.parent
- # About to npm install/build from source, so the workspace must exist.
- if not ext_dir:
- _ensure_tui_workspace(tui_dir)
- if not tui_dev and not _tui_need_rebuild(tui_dir):
- return [_tui_node_bin("node"), "--expose-gc", str(tui_dir / "dist/entry.js")], tui_dir
- from hermes_cli.source_build import build_source_tui, prepare_launch_dependencies, source_build_env
- project_root = tui_dir.parent
- env = source_build_env()
- prepare_launch_dependencies(project_root, env=env)
- if tui_dev:
- # tsx imports @hermes/ink's built exports; the production bundle instead
- # compiles its source directly through scripts/build/tui.mjs.
- npm = shutil.which("npm", path=env["PATH"])
- subprocess.run([npm, "run", "build"], cwd=tui_dir / "packages/hermes-ink", env=env, check=True)
- tsx = tui_dir / "node_modules/.bin/tsx"
- return ([str(tsx), "src/entry.tsx"] if tsx.exists() else [npm, "start"]), tui_dir
- build_source_tui(project_root, env=env)
- node = shutil.which("node", path=env["PATH"])
- return [node, "--expose-gc", str(tui_dir / "dist/entry.js")], tui_dir
- def _split_comma_items(items, *, split_non_str: bool = True) -> list[str]:
- """Flatten str / list (comma-separated) input into stripped non-empty parts."""
- raw_items = [items] if isinstance(items, str) else items
- if not isinstance(raw_items, (list, tuple)):
- raw_items = [raw_items]
- normalized: list[str] = []
- for item in raw_items:
- if split_non_str or isinstance(item, str):
- normalized.extend(part.strip() for part in str(item).split(","))
- else:
- normalized.append(str(item).strip())
- return [item for item in normalized if item]
- def _normalize_tui_toolsets(toolsets: object) -> list[str]:
- """Normalize argparse/Fire-style toolset input for the TUI subprocess."""
- try:
- from hermes_cli.oneshot import _normalize_toolsets
- return _normalize_toolsets(toolsets) or []
- except (AttributeError, ImportError):
- return _split_comma_items(toolsets, split_non_str=False) if toolsets else []
- def _read_cgroup_memory_limit() -> Optional[int]:
- """Container memory limit in bytes, or None if unconstrained (v2 ``memory.max``, then v1).
- V8 is NOT cgroup-aware: a flat 8GB heap grows past a smaller container limit
- and the OOM-killer SIGKILLs Node with no breadcrumb (bare ``stdin EOF``).
- """
- candidates = (
- "/sys/fs/cgroup/memory.max", # cgroup v2
- "/sys/fs/cgroup/memory/memory.limit_in_bytes", # cgroup v1
- )
- for path in candidates:
- try:
- with open(path, "r", encoding="utf-8-sig") as f:
- raw = f.read().strip()
- except (OSError, ValueError):
- continue
- if raw == "max":
- return None
- if not raw:
- continue # don't mistake an empty v2 file for "unlimited"
- try:
- limit = int(raw)
- except ValueError:
- continue
- if limit <= 0:
- continue
- if limit >= (1 << 50): # >= ~1 PB is the v1 "unlimited" sentinel
- return None
- return limit
- return None
- def _resolve_tui_heap_mb(default_mb: int = 8192) -> int:
- """V8 ``--max-old-space-size`` (MB) that fits the container: ``default_mb`` when unconstrained,
- else 75% of the cgroup limit (headroom for non-heap RSS + the gateway child), floored at
- 1536MB when the container is > 2GB (below that V8 GC-thrashes)."""
- limit = _read_cgroup_memory_limit()
- if not limit:
- return default_mb
- limit_mb = limit // (1024 * 1024)
- sized = int(limit_mb * 0.75)
- if sized >= default_mb:
- return default_mb
- # Below the floor, honor the limit-derived value anyway: a graceful V8 exit
- # beats a silent cgroup kill.
- return max(1536, sized) if limit_mb > 2048 else sized
- def _safe_tui_cwd(env: Optional[dict] = None) -> str:
- """Return a stable cwd value for the Node TUI child environment."""
- from hermes_cli.main import PROJECT_ROOT
- try:
- return os.getcwd()
- except FileNotFoundError:
- candidate = ((env or {}).get("PWD") or os.environ.get("PWD") or "").strip()
- if candidate and Path(candidate).is_dir():
- return candidate
- return str(PROJECT_ROOT)
- def _apply_tui_python_env(env: dict) -> None:
- """Seed/repair Python-related env vars shared by CLI and dashboard TUI launches."""
- from hermes_cli.main import PROJECT_ROOT
- src_root = str(env.get("HERMES_PYTHON_SRC_ROOT") or "").strip()
- if not src_root or not Path(src_root).is_dir():
- env["HERMES_PYTHON_SRC_ROOT"] = str(PROJECT_ROOT)
- cwd = str(env.get("HERMES_CWD") or "").strip()
- if not cwd or not Path(cwd).is_dir():
- env["HERMES_CWD"] = _safe_tui_cwd(env)
- python = str(env.get("HERMES_PYTHON") or "").strip()
- if os.path.dirname(python):
- python_path = Path(python)
- if not python_path.is_absolute():
- python_path = Path(env["HERMES_CWD"]) / python_path
- python_is_executable = python_path.is_file() and os.access(python_path, os.X_OK)
- else:
- python_is_executable = bool(shutil.which(python, path=env.get("PATH")))
- if not python_is_executable:
- env["HERMES_PYTHON"] = sys.executable
- def _setup_tui_worktree() -> dict:
- """Create the ``--worktree`` checkout for a TUI launch (prune + async pack maintenance); exits on failure."""
- wt_info = None
- try:
- from cli import _git_repo_root, _maintain_pack_health, _prune_stale_worktrees, _setup_worktree
- repo = _git_repo_root()
- if repo:
- _prune_stale_worktrees(repo)
- # Repack on pack sprawl so `worktree add` never crawls on a
- # multi-agent box; on a thread so it can't block launch.
- import threading as _threading
- _threading.Thread(
- target=_maintain_pack_health, args=(repo,), name="pack-maintenance", daemon=True).start()
- from hermes_cli.config import get_hermes_home
- # The session's frozen cwd keeps this checkout; name the store from creation so a
- # launcher killed with its terminal still leaves the tree to its sessions.
- wt_info = _setup_worktree(retain_db=get_hermes_home() / "state.db")
- except Exception as exc:
- print(f"✗ Failed to create TUI worktree: {exc}", file=sys.stderr)
- if not wt_info:
- sys.exit(1)
- return wt_info
- def _remove_idle_clean_tui_worktree(wt_info: dict) -> bool:
- """Remove the ``--tui -w`` checkout on quit when nothing still needs it (N8) -> True if gone.
- Kept when the gateway has queued or started work for a session inside it (quitting only
- detaches the viewer), still schedules work for one (an active loop, heartbeat or goal
- continuation, or a cron job bound to it), another viewer still holds one, or another process
- still works in it; and by ``_cleanup_worktree`` when it is dirty, holds unpushed commits or
- something no branch keeps.
- """
- from hermes_cli.config import get_hermes_home
- from hermes_cli.worktree_exit import _still_in_use
- from hermes_cli.worktree_ops import _retained_tree_is_live, _tree_still_served
- path = wt_info.get("path")
- if not path or not Path(path).is_dir():
- return False
- try:
- db_path = str(get_hermes_home() / "state.db")
- if _retained_tree_is_live(db_path, path, pending_only=True):
- return False
- if _still_in_use(path):
- return False
- # After the grace above: a legacy sidecar stamps its rows ``tui_shutdown`` as it exits.
- if _tree_still_served(db_path, path):
- return False
- from cli import _cleanup_worktree
- _cleanup_worktree(wt_info)
- except Exception:
- logger.debug("TUI worktree cleanup failed; keeping %s", path, exc_info=True)
- return False
- return not Path(path).exists()
- def _require_bypass_model(env: dict, model: Optional[str], resume_session_id: Optional[str]) -> None:
- """A --safe-mode / --ignore-user-config session reads no profile default model, so the owner
- refuses its session.create without one (bare invalid_params). Say so before the TUI starts,
- as classic chat does; a resume reuses the frozen route and needs none."""
- from utils import is_truthy_value
- bypass = any(is_truthy_value(env.get(name)) for name in ("HERMES_SAFE_MODE", "HERMES_IGNORE_USER_CONFIG"))
- if bypass and not resume_session_id and not (model or env.get("HERMES_MODEL", "").strip()):
- print("Error: --safe-mode / --ignore-user-config (or HERMES_IGNORE_USER_CONFIG=1) read no profile "
- "default model: pass --model explicitly.\n"
- " Example: hermes --tui --safe-mode --provider openrouter --model anthropic/claude-sonnet-4",
- file=sys.stderr)
- raise SystemExit(1)
- # Launch flags the Ink client cannot carry into session.create yet. Refused (exit 2, as classic
- # chat refuses unsupported flags), never dropped: a dropped --api-key/--base-url would silently
- # run the session on the profile's own endpoint and credentials.
- _TUI_UNFORWARDED = {"api_key": "--api-key", "base_url": "--base-url", "reasoning": "--reasoning"}
- def _refuse_unforwarded_tui_flags(args) -> None:
- flags = [flag for name, flag in _TUI_UNFORWARDED.items() if getattr(args, name, None)]
- if flags:
- print(f"Error: Unsupported --tui options: {', '.join(flags)}. No session was started.\n"
- f" Use classic chat for this launch: hermes chat --cli {' '.join(flags)} ...\n"
- " Or set model.base_url / agent.reasoning_effort in config.yaml (/reasoning in the TUI).",
- file=sys.stderr)
- raise SystemExit(2)
- def _launch_tui(
- resume_session_id: Optional[str] = None, tui_dev: bool = False, native_mode: Optional[bool] = None,
- model: Optional[str] = None,
- provider: Optional[str] = None, toolsets: object = None, skills: object = None,
- verbose: Optional[bool] = None, quiet: bool = False, query: Optional[str] = None,
- image: Optional[str] = None, worktree: bool = False, checkpoints: bool = False,
- pass_session_id: bool = False, max_turns: Optional[int] = None, accept_hooks: bool = False):
- """Replace current process with the TUI."""
- from hermes_cli.main import PROJECT_ROOT
- tui_dir = PROJECT_ROOT / "ui-tui"
- import tempfile
- # TUI child is a hermes process: propagate the profile-home contract via
- # the single factory; keep secrets (the TUI/agent needs provider creds).
- from tools.environments.local import build_subprocess_env
- env = build_subprocess_env(scrub_secrets=False, inherit_profile_home=True)
- _require_bypass_model(env, model, resume_session_id)
- # The directory this launch was invoked from is the source of truth. An inherited
- # HERMES_CWD (exported by an outer `hermes --tui`, or by the user's own shell) merely
- # names *a* real directory, so the is_dir() repair in _apply_tui_python_env keeps it
- # and the gateway starts in last session's project. `--worktree` still wins below.
- env["HERMES_CWD"] = _safe_tui_cwd(env)
- from hermes_cli.shared_session_attach import configure_tui_attachment
- try:
- configure_tui_attachment(env, resume_session_id)
- except (ValueError, RuntimeError) as exc:
- print(f"Error: {exc}", file=sys.stderr)
- raise SystemExit(1) from None
- try:
- from hermes_cli.config import apply_terminal_config_to_env
- apply_terminal_config_to_env(env=env)
- except Exception:
- logger.debug("Failed to apply terminal config bridge for TUI launch", exc_info=True)
- active_session_fd, active_session_file = tempfile.mkstemp(
- prefix="hermes-tui-active-session-", suffix=".json")
- os.close(active_session_fd)
- env["HERMES_TUI_ACTIVE_SESSION_FILE"] = active_session_file
- env.setdefault("NODE_ENV", "development" if tui_dev else "production")
- if native_mode is None:
- try:
- from hermes_cli.config import load_config
- from utils import is_truthy_value
- display = load_config().get("display", {})
- native_mode = is_truthy_value(display.get("tui_native", False)) if isinstance(display, dict) else False
- except Exception:
- native_mode = False
- env["HERMES_TUI_NATIVE"] = "1" if native_mode else "0"
- wt_info = None
- if worktree:
- wt_info = _setup_tui_worktree()
- env["HERMES_CWD"] = wt_info["path"]
- env["TERMINAL_CWD"] = wt_info["path"]
- # A local interactive session starts where the user launched (or in the --worktree), the
- # classic CLI's rule; terminal.cwd stays the default for gateway, cron and remote backends.
- # HERMES_TUI_CWD is what the TUI sends on session.create, which beats the configured cwd (#84015).
- if str(env.get("TERMINAL_ENV") or "local") == "local":
- env["TERMINAL_CWD"] = env["HERMES_TUI_CWD"] = env["HERMES_CWD"]
- else:
- env.pop("HERMES_TUI_CWD", None)
- _apply_tui_python_env(env)
- # This shell's allowlisted environment, sent as each session's ``client_env`` (LC-8, T3): taken from
- # the shell before the launcher's own edits (NODE_OPTIONS heap, TUI pins) so the session gets the
- # PATH / venv / HERMES_* values the user exported.
- from hermes_cli.gateway_chat import shell_client_env
- env["HERMES_TUI_CLIENT_ENV"] = json.dumps(shell_client_env())
- skills_value = ""
- if skills:
- skills_value = (
- ",".join(_split_comma_items(skills)) if isinstance(skills, (list, tuple)) else str(skills).strip())
- for key, value in (
- ("HERMES_MODEL", model), ("HERMES_INFERENCE_MODEL", model),
- ("HERMES_TUI_PROVIDER", provider), ("HERMES_INFERENCE_PROVIDER", provider),
- ("HERMES_TUI_TOOLSETS", ",".join(_normalize_tui_toolsets(toolsets))),
- ("HERMES_TUI_SKILLS", skills_value),
- ("HERMES_TUI_QUERY", query), ("HERMES_TUI_IMAGE", image),
- ("HERMES_TUI_CHECKPOINTS", "1" if checkpoints else None),
- ("HERMES_TUI_PASS_SESSION_ID", "1" if pass_session_id else None),
- ("HERMES_TUI_MAX_TURNS", str(max_turns) if max_turns is not None else None),
- ("HERMES_TUI_TOOL_PROGRESS", "verbose" if verbose else "off" if quiet else None),
- ("HERMES_ACCEPT_HOOKS", "1" if accept_hooks else None)):
- if value:
- env[key] = value
- # Generous V8 heap (8GB target; default cap can fatal-OOM on long sessions),
- # sized below the cgroup limit by _resolve_tui_heap_mb() so V8 exits
- # gracefully instead of being reaped silently. Token-level merge respects a
- # user-supplied --max-old-space-size. --expose-gc is NOT added here: Node
- # rejects it in NODE_OPTIONS; _make_tui_argv() passes it as a direct flag.
- _tokens = env.get("NODE_OPTIONS", "").split()
- if not any(t.startswith("--max-old-space-size=") for t in _tokens):
- _tokens.append(f"--max-old-space-size={_resolve_tui_heap_mb()}")
- env["NODE_OPTIONS"] = " ".join(_tokens)
- # HERMES_TUI_RESUME is an internal hand-off to the Ink app. We start from a
- # full os.environ snapshot, so a stale exported value would make a plain
- # `hermes --tui` try to resume a non-existent session; only forward the id
- # argparse resolved for this invocation.
- env.pop("HERMES_TUI_RESUME", None)
- if resume_session_id:
- env["HERMES_TUI_RESUME"] = resume_session_id
- argv, cwd = _make_tui_argv(tui_dir, tui_dev)
- code: Optional[int] = None
- try:
- try:
- code = subprocess.call(argv, cwd=str(cwd), env=env)
- except KeyboardInterrupt:
- code = 130
- if code in {0, 130}:
- _print_tui_exit_summary(resume_session_id, active_session_file)
- finally:
- attached_session = _read_tui_active_session_file(active_session_file) or resume_session_id
- with contextlib.suppress(OSError):
- os.unlink(active_session_file)
- if wt_info and code in {0, 130}:
- from hermes_cli.worktree_exit import ask_exit_choice
- ask_exit_choice(wt_info)
- from hermes_cli.worktree_exit import apply_exit_choice
- if wt_info and apply_exit_choice(wt_info, print):
- wt_info = None # archived or discarded at the user's request
- if wt_info and _remove_idle_clean_tui_worktree(wt_info):
- wt_info = None # clean and idle: removed with its branch, as before the shared gateway
- if wt_info:
- # Quitting detaches a viewer; the gateway may still be executing in
- # this checkout and future resumes retain its frozen cwd.
- if attached_session:
- # The launch lock names this (exiting) pid; hand it to the session so a later
- # launch's stale prune keeps the tree while the session is resumable.
- from hermes_cli.config import get_hermes_home
- from hermes_cli.worktree_ops import _retain_worktree_for_session
- _retain_worktree_for_session(wt_info["repo_root"], wt_info["path"], attached_session,
- get_hermes_home() / "state.db")
- print(f"Worktree retained for this session: {wt_info['path']}", file=sys.stderr)
- # Exit code 42 = TUI requested an update. Relaunch as `hermes update`;
- # preserve_inherited=False keeps --tui and other flags out of the subcommand.
- if code == 42:
- from hermes_cli.relaunch import relaunch
- print("\n☤ Launching update...\n")
- relaunch(["update"], preserve_inherited=False)
- sys.exit(code)
- def _pin_kanban_board_env() -> None:
- """Pin the active kanban board into ``HERMES_KANBAN_BOARD`` so in-process tools and shelled-out
- ``hermes kanban`` calls agree even if a concurrent ``boards switch`` flips the file mid-turn.
- Without this, in-process tools (``kanban_*``) and shelled-out CLI calls (``hermes kanban …``) resolve
- the board on different paths: the env-pin if set, otherwise the global ``<root>/kanban/current`` file. A
- concurrent ``hermes kanban boards switch`` from another session can flip the file mid-turn, so the same
- chat sees its tool calls hit board A while its shell calls hit board B (#20074). Pinning at chat boot
- mirrors what the dispatcher already does for spawned workers.
- """
- if os.environ.get("HERMES_KANBAN_BOARD"):
- return
- with contextlib.suppress(Exception):
- from hermes_cli.kanban_db import get_current_board
- os.environ["HERMES_KANBAN_BOARD"] = get_current_board()
- def _sync_bundled_skills_quietly() -> None:
- """Seed ``~/.hermes/skills/`` with the bundled library (idempotent, milliseconds when synced).
- Failures are swallowed: skills are an enhancement, not a hard dependency."""
- with contextlib.suppress(Exception):
- from tools.skills_sync import sync_skills
- sync_skills(quiet=True)
- def _resolve_use_tui(args) -> bool:
- """Decide whether to launch the TUI: ``--cli`` → classic; ``--tui`` → TUI; no TTY → classic;
- ``HERMES_TUI=1`` → TUI; ``display.interface`` config; default classic.
- The TTY gate is load-bearing: ambient preferences must never hijack a piped
- ``hermes chat -q`` (kanban workers, cron) — the Ink no-TTY bail-out exits 0 and
- the worker dies with a protocol violation. Explicit ``--tui`` still bails out.
- """
- if getattr(args, "cli", False):
- return False
- if getattr(args, "tui", False) or getattr(args, "tui_native", False):
- return True
- try:
- if not (sys.stdin.isatty() and sys.stdout.isatty()):
- return False
- except Exception:
- return False
- if os.environ.get("HERMES_TUI") == "1":
- return True
- try:
- from hermes_cli.config import load_config
- iface = (load_config().get("display", {}) or {}).get("interface", "cli")
- return isinstance(iface, str) and iface.strip().lower() == "tui"
- except Exception:
- return False
|