"""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)