"""Send ``hermes update`` back to the install whose interpreter it is running on. An install's in-tree venv can end up importing another checkout's code: an editable install recorded against a dev tree (what ``project_venv_dir`` used to cause when a dev checkout ran on the app install's interpreter) turns ``/venv/bin/hermes`` into the dev tree's CLI. Every update the Desktop hands to that launcher then pulls the dev tree, the install never moves, and the app keeps relaunching its stale build. Running the install's own updater repairs it: it pulls the install and reinstalls the install into its venv, which rewrites the editable record to point home again. """ from __future__ import annotations import os from pathlib import Path import subprocess import sys def owning_install_root(project_root: Path) -> Path | None: """The checkout whose in-tree venv this interpreter is, when that is not *project_root*. ``None`` when this process runs on its own checkout's interpreter, a venv outside any checkout, or when *project_root* was put on ``PYTHONPATH`` on purpose (a wrapper that runs a dev tree on another interpreter chose that tree; it is not a redirected install). """ if sys.prefix == sys.base_prefix: return None venv = Path(sys.prefix).resolve() root = Path(project_root).resolve() if venv.name not in ("venv", ".venv"): return None owner = venv.parent if (venv.parent / "hermes_cli" / "main.py").is_file() else _pm_environment_owner(venv) if owner is None or owner == root: return None chosen = (Path(p).resolve() for p in os.environ.get("PYTHONPATH", "").split(os.pathsep) if p) if root in chosen: return None return owner def _pm_environment_owner(venv: Path) -> Path | None: """The checkout a PM generation venv (``//environments//venv``) belongs to. Its ``hermes_cli`` is the generation's ``workspace/`` snapshot, which has no ``.git``, so an update run from it must go to the checkout (#122627). The install key hashes the checkout path, which proves the path recorded beside it. """ from pm.environments import install_key state = venv.parent.parent.parent if venv.parent.parent.name != "environments": return None try: # pm.environments.record_activation_inputs writes it on every full install. owner = Path((state / "inputs" / ".project-root").read_text(encoding="utf-8-sig").strip()) except OSError: return None if install_key(owner) != state.name or not (owner / "hermes_cli" / "main.py").is_file(): return None return owner def retarget_to_owning_install(project_root: Path) -> None: """Re-run this command with the owning install's code; returns only when nothing is redirected.""" owner = owning_install_root(project_root) if owner is None: return print(f"⚠ {owner / Path(sys.prefix).name} is running the checkout at {project_root}, not its own code.") print(f"→ Updating {owner} with its own updater; this also points its venv back at it.") sys.stdout.flush() # PYTHONPATH entries resolve before the editable finder on sys.meta_path, so the # owner's hermes_cli wins; in the child, project_root == owner and this is a no-op. env = dict(os.environ, PYTHONPATH=str(owner)) code = subprocess.call([sys.executable, "-m", "hermes_cli.main", *sys.argv[1:]], cwd=owner, env=env) raise SystemExit(code)