mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 03:12:19 +03:00
dad713f77a
Same class as Greptile "Concurrent installs miss an owner": on a sealed Windows payload, writable_copy returned an existing copy another checkout made without recording this checkout as an owner, so that checkout's upgrade let gc delete the copy this one runs on. A realizing lookup now goes through _refresh_found_env, which claims the row (#149497).
157 lines
6.7 KiB
Python
157 lines
6.7 KiB
Python
"""The terminal's PATH: the user's own tools first, Hermes's after them.
|
|
|
|
Hermes's process puts its store's tool dirs first (``pm.install.activate``), so Hermes's own
|
|
code resolves the pinned binaries. Terminal commands belong to the user and the agent, so they
|
|
run the tools the user installed, and Hermes's tools are the fallback for a machine without
|
|
them. Hermes's own operations must not depend on this PATH: they resolve pinned tools
|
|
through PM (``pm.env_for``, ``pm.installed_package``).
|
|
|
|
A sealed Windows payload's store sits under ``WindowsApps``. In the process tree that the
|
|
app's execution alias starts, a program whose own executable is outside the package cannot
|
|
start one inside it: cmd.exe running npm's ``npx.cmd`` gets "Access is denied" from the
|
|
packaged ``node.exe``, and a venv's ``Scripts\\python.exe`` redirector exits 101 when it
|
|
starts the packaged Python. A copy of the same files outside the package starts without
|
|
error, so there :func:`copies` swaps those dirs for PM's verified copies.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import os
|
|
from pathlib import Path
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
# Packages whose packaged dirs a sealed Windows payload swaps for writable copies.
|
|
COPIED = ("npm", "node", "python")
|
|
|
|
|
|
def applies() -> bool:
|
|
"""True for a sealed payload on Windows, the only layout with the restriction above."""
|
|
from pm.install import sealed
|
|
from pm.store import current_target
|
|
|
|
return current_target().startswith("win32") and sealed()
|
|
|
|
|
|
def writable_copy(name: str, *, realize: bool = True, explicit: bool = False,
|
|
why: str = "a copy outside the package is required"):
|
|
"""``(facts, store)`` of PM's verified copy of the installed *name* in the writable store.
|
|
|
|
The first call copies the installed entry and checks its digest. It downloads nothing.
|
|
If the install already lives in the writable store, that install is the answer. Returns
|
|
``None`` when *name* is not installed, or when no copy exists and *realize* is false.
|
|
Raises the lazy-install refusal, naming *why*, when a copy is needed and lazy installs
|
|
are off.
|
|
"""
|
|
from pm import paths
|
|
from pm.filesystem import long_root
|
|
from pm.install import (_install, _installed_location, _lockfile, _refresh_found_env, _refuse_lazy,
|
|
lazy_installs_allowed)
|
|
from pm.lock import Facts
|
|
from pm.registry import get_package
|
|
from pm.store import Store, current_target
|
|
|
|
package, lockfile, target = get_package(name), _lockfile(), current_target()
|
|
location = _installed_location(package, lockfile, target)
|
|
if location is None:
|
|
return None
|
|
# Spelled like Store spells its root, so the comparison and the copy's file calls agree.
|
|
writable = long_root(paths.writable_store_root())
|
|
if location[1].root == writable:
|
|
return location
|
|
copied = _installed_location(package, lockfile, target, verify=explicit, roots=(writable,))
|
|
if copied is not None and realize:
|
|
# Another install's copy of this pin: running on it makes this checkout an owner (#149497).
|
|
_refresh_found_env(package, copied, target, None)
|
|
if copied is not None or not realize:
|
|
return copied
|
|
if not explicit and not lazy_installs_allowed():
|
|
raise _refuse_lazy(name, why)
|
|
copy_store, copy_facts = Store(writable), Facts(writable / "facts.json")
|
|
_install(package, lockfile, copy_facts, copy_store, target, copy_from=location)
|
|
return copy_facts, copy_store
|
|
|
|
|
|
def _dirs(facts, store, name: str) -> list[str]:
|
|
"""The PATH dirs that *store*'s install of *name* contributes, natively spelled."""
|
|
from pm.filesystem import native
|
|
|
|
dirs = facts.env_for(name, store.root).get("PATH") or []
|
|
return [native(d) for d in ([dirs] if isinstance(dirs, str) else dirs) if d]
|
|
|
|
|
|
def _sealed_dirs(name: str) -> list[str]:
|
|
from pm.install import _facts, _store
|
|
|
|
facts, store = _facts(), _store()
|
|
return _dirs(facts, store, name) if facts.installed(name, None, store.root) else []
|
|
|
|
|
|
def _copy_dirs(name: str) -> list[str]:
|
|
"""The PATH dirs of *name*'s writable copy, made on first use, or ``[]`` when PM may not make one."""
|
|
from pm.package import InstallError
|
|
|
|
try:
|
|
location = writable_copy(name)
|
|
except (InstallError, OSError) as exc:
|
|
LOG.debug("user-facing %s stays the packaged copy: %s", name, exc)
|
|
return []
|
|
return _dirs(*location, name) if location is not None else []
|
|
|
|
|
|
def copies(dirs: list[str]) -> list[str]:
|
|
"""*dirs* with each packaged npm, node and python dir swapped for its writable copy on a
|
|
sealed Windows payload. A packaged dir stays when PM may not copy it (lazy installs off)."""
|
|
if not applies():
|
|
return list(dirs)
|
|
swap: dict[str, list[str]] = {}
|
|
for name in COPIED:
|
|
sealed = _sealed_dirs(name)
|
|
copied = _copy_dirs(name) if sealed else []
|
|
if copied:
|
|
swap.update((os.path.normcase(d), copied) for d in sealed)
|
|
return list(dict.fromkeys(c for d in dirs for c in swap.get(os.path.normcase(d), [d])))
|
|
|
|
|
|
def _python_stub_dir(directory: str) -> bool:
|
|
"""True for the Windows app-alias dir when its ``python.exe`` is only the Store stub.
|
|
|
|
The stub opens the Microsoft Store instead of running Python. A real Store Python puts its
|
|
aliases in the same dir, and it also ships a ``python3.N.exe``, which the stub does not.
|
|
"""
|
|
parts = [os.path.normcase(part) for part in Path(directory).parts[-2:]]
|
|
if parts != [os.path.normcase("Microsoft"), os.path.normcase("WindowsApps")]:
|
|
return False
|
|
try:
|
|
return not any(Path(directory).glob("python3.*.exe"))
|
|
except OSError:
|
|
return True
|
|
|
|
|
|
def _python_dirs() -> list[str]:
|
|
from pm.install import env_for
|
|
|
|
return [d for d in env_for("python", base_env={"PATH": ""}).get("PATH", "").split(os.pathsep) if d]
|
|
|
|
|
|
def user_facing_path(path: str) -> str:
|
|
"""*path* with Hermes's store tool dirs (their writable copies, see :func:`copies`) moved
|
|
behind the user's own entries.
|
|
|
|
Hermes's Python stops just before the app-alias dir that holds the Store stub, so a
|
|
machine without Python still runs a real one.
|
|
"""
|
|
from pm.install import _store_path_dirs
|
|
|
|
store = _store_path_dirs()
|
|
if not store:
|
|
return path
|
|
ours = copies(store)
|
|
keys = {os.path.normcase(d) for d in (*store, *ours)}
|
|
kept = [p for p in path.split(os.pathsep) if p and os.path.normcase(p) not in keys]
|
|
python = {os.path.normcase(d) for d in copies(_python_dirs())}
|
|
cut = next((i for i, p in enumerate(kept) if _python_stub_dir(p)), len(kept))
|
|
early = [d for d in ours if os.path.normcase(d) in python]
|
|
late = [d for d in ours if os.path.normcase(d) not in python]
|
|
return os.pathsep.join(dict.fromkeys([*kept[:cut], *early, *kept[cut:], *late]))
|