| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132 |
- """Bring back a ``hermes --tui -w`` worktree a resume needs (N8).
- Quitting a clean, idle ``--tui -w`` session removes its tree and branch, but the session's policy
- froze that cwd, and the owner refuses every turn in a missing directory (``workspace_unavailable``).
- So the launcher records each tree it creates in the profile's ``tui_worktrees.json``, and a resume
- whose session cwd is such a missing tree recreates it at the same path before attaching: from its
- branch when that still exists, else a new branch of the same name from the repo's current HEAD.
- Only a path this profile's launcher recorded, directly under its repo's ``.worktrees/``, is ever
- created; any other missing directory is left alone (the resume warns as before).
- """
- from __future__ import annotations
- import logging
- import os
- import subprocess
- import threading
- from pathlib import Path
- from typing import Optional
- logger = logging.getLogger(__name__)
- _RECORD_NAME = "tui_worktrees.json"
- _MAX_RECORDS = 500
- _holder = threading.local()
- def _record_path() -> Path:
- from hermes_constants import get_hermes_home
- return get_hermes_home() / _RECORD_NAME
- def _key(path) -> str:
- return os.path.normcase(os.path.realpath(str(path)))
- def _read() -> dict:
- from utils import read_json_or_empty
- trees = read_json_or_empty(_record_path()).get("trees")
- return trees if isinstance(trees, dict) else {}
- def record_tui_worktree(wt_info: dict) -> None:
- """Remember a tree the ``-w`` / ``--tui -w`` launcher created, or a classic ``/worktree new``
- moved its gateway session into. Never raises."""
- try:
- from hermes_cli.auth import _file_lock
- from utils import atomic_json_write
- path = _record_path()
- with _file_lock(path.with_name(path.name + ".lock"), _holder, 5.0,
- "Timed out waiting for the TUI worktree record lock"):
- trees = {k: v for k, v in _read().items()
- if isinstance(v, dict) and (Path(str(v.get("repo_root") or "")) / ".git").exists()}
- trees[_key(wt_info["path"])] = {"path": str(wt_info["path"]), "branch": wt_info["branch"],
- "repo_root": str(wt_info["repo_root"])}
- atomic_json_write(path, {"version": 1, "trees": dict(list(trees.items())[-_MAX_RECORDS:])})
- except Exception: # health: allow BLE001 -- a lost record only means no recreate on resume
- logger.debug("TUI worktree record failed for %s", wt_info.get("path"), exc_info=True)
- def _recorded_tree_for(cwd: str) -> Optional[dict]:
- """The launcher's record of the missing tree *cwd* is (or is inside), or None."""
- try:
- trees = _read()
- except Exception: # health: allow BLE001 -- unreadable record: create nothing
- return None
- probe = Path(cwd)
- for candidate in (probe, *probe.parents):
- entry = trees.get(_key(candidate))
- if not isinstance(entry, dict):
- continue
- repo = Path(str(entry.get("repo_root") or ""))
- tree = Path(str(entry.get("path") or ""))
- branch = str(entry.get("branch") or "")
- # Only a direct child of the repo's Hermes worktree dir, as _setup_worktree makes them.
- if (branch and (repo / ".git").exists()
- and _key(tree.parent) == _key(repo / ".worktrees") and _key(tree) == _key(candidate)):
- return {"path": str(tree), "branch": branch, "repo_root": str(repo)}
- return None
- return None
- def _branch_exists(repo_root: str, branch: str) -> bool:
- from hermes_cli.worktree_ops import _git
- result = _git(["rev-parse", "--verify", "--quiet", f"refs/heads/{branch}"], repo_root)
- return result.returncode == 0
- def recreate_tui_worktree(cwd: str, session_id: str) -> Optional[str]:
- """Recreate the launcher-made tree a resumed session's missing *cwd* names -> its path, or None.
- Reuses the branch when it survived (its commits come back), else makes it again from the repo's
- current HEAD. The tree is locked for the session so the stale-tree prune keeps it. Never raises.
- """
- if not cwd or os.path.isdir(cwd):
- return None
- entry = _recorded_tree_for(cwd)
- if entry is None:
- return None
- from hermes_cli._subprocess_compat import noninteractive_repo_git_env
- from hermes_cli.worktree_ops import (
- _copy_worktree_includes,
- _git,
- _git_quiet,
- _retain_worktree_for_session,
- )
- from hermes_constants import get_hermes_home
- repo_root, tree, branch = entry["repo_root"], Path(entry["path"]), entry["branch"]
- if tree.exists(): # a file, or a dir that appeared since: never overwrite it
- return None
- env = noninteractive_repo_git_env(repo_root)
- if env is None:
- return None
- try:
- # A tree deleted by hand leaves its admin entry; drop it so the path can be added again.
- _git_quiet(["worktree", "prune"], repo_root, timeout=15, stdin=subprocess.DEVNULL, env=env)
- tree.parent.mkdir(parents=True, exist_ok=True)
- args = ([str(tree), branch] if _branch_exists(repo_root, branch)
- else [str(tree), "-b", branch, "HEAD"])
- result = _git(["worktree", "add", *args], repo_root, timeout=120, stdin=subprocess.DEVNULL, env=env)
- if result.returncode != 0:
- logger.warning("could not recreate worktree %s: %s", tree, result.stderr.strip())
- return None
- _copy_worktree_includes(repo_root, tree)
- _retain_worktree_for_session(repo_root, str(tree), session_id, get_hermes_home() / "state.db")
- except (OSError, subprocess.SubprocessError) as exc:
- logger.warning("could not recreate worktree %s: %s", tree, exc)
- return None
- return str(tree)
|