In the process tree that the Store app's execution alias starts, a program whose own executable is outside WindowsApps cannot start one inside it. cmd.exe gets "Access is denied" from the packaged node.exe, and npm starts every package bin through cmd.exe. So every npx MCP server died, and so did each `npm exec` in the terminal on a machine without its own Node. A venv's Scripts\python.exe redirector exits 101 when it starts the packaged interpreter, which broke `python -m venv`. A copy of the same files in the writable store starts without error. PM already makes one for Python builds (#135236). That code moves from pm._uv._toolchain to pm.user_facing.writable_copy. pm.user_facing.copies swaps each packaged npm, node and python dir for that copy, made on first use from the verified entry: a copy plus a digest check, no download. Two places use it: - the terminal's fallback dirs (user_facing_path), behind the user's own tools; - Hermes's npx/npm/node for a bare `command: npx` MCP server, which stays Hermes's own as on main. When lazy installs are off, PM makes no copy and the packaged dir stays. Live check on Windows 11 arm64 (Store build 2026.6819.1065.0), in the alias-started process tree: cmd.exe -> npx.cmd -> node.exe fails with "Access is denied" from the package, and passes from a copy of the same node and npm dirs in the user profile.
153 lines
6.5 KiB
Python
153 lines
6.5 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, _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 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]))
|