mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-19 05:19:42 +03:00
7062229090
pnpm 12.15.0 (native executable) installs every JS workspace from one pnpm-lock.yaml, imported from package-lock.json with the same resolved versions. website/, the WhatsApp bridge and the photon sidecar stay separate npm projects. Configuration moves from .npmrc and the root manifest into pnpm-workspace.yaml: the 14-day minimumReleaseAge and its excludes, overrides, allowBuilds (the old allowScripts set, with strictDepBuilds failing any unlisted build script), engineStrict, sideEffectsCache: false (in-place rebuilds must not write into the store) and verifyDepsBeforeRun: false (a `pnpm run` never installs). The pnpm version is pinned in pm/lock.json and in root devEngines. pmOnFail: ignore keeps that pin out of pnpm-lock.yaml: a leading pin document makes osv-scanner read zero packages. scripts/build/node-deps.mjs enforces the exact version instead, and every lock reader refuses a multi-document lock. A root preinstall refuses `npm install`; devEngines onFail is warn so npx (MCP servers, the tsc linter) keeps working inside the checkout. User-machine installs run --frozen-lockfile --trust-lockfile (release age is checked when locking, in CI, not per user). node-deps removes npm-era node_modules trees before the first pnpm install. Nix builds the store with fetchPnpmDeps and a hash file that CI checks.
266 lines
14 KiB
Python
266 lines
14 KiB
Python
"""Child-scoped desktop build tools, independent of the invoking Hermes install.
|
|
|
|
This module is stdlib-only until preparation runs inside the isolated child.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Mapping
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import platform
|
|
import subprocess
|
|
import sys
|
|
import uuid
|
|
|
|
|
|
_INSTALL_ENV = {
|
|
"HERMES_INSTALL_ROOT", "HERMES_PAYLOAD_ROOT", "HERMES_PAYLOAD_TAG", "HERMES_BUILD_COMMIT",
|
|
"HERMES_SITE", "HERMES_PYTHON", "HERMES_NODE", "HERMES_PROFILE", "HERMES_REAL_HOME",
|
|
"HERMES_DATA_DIR_SUFFIX", "HERMES_BUNDLED_SKILLS", "HERMES_OPTIONAL_SKILLS",
|
|
"HERMES_BUNDLED_PLUGINS", "HERMES_BUNDLED_LOCALES", "HERMES_OPTIONAL_MCPS",
|
|
"PYTHONPATH", "PYTHONHOME", "PYTHONUSERBASE", "VIRTUAL_ENV", "CONDA_PREFIX",
|
|
}
|
|
|
|
|
|
def bootstrap_environment(source: Path, work: Path, cache: Path,
|
|
env: Mapping[str, str]) -> dict[str, str]:
|
|
"""Return launch state; never import PM, mutate the process, or write files."""
|
|
source, work, cache = source.resolve(), work.resolve(), cache.resolve()
|
|
owned = {"HOME", "USERPROFILE", "LOCALAPPDATA", "APPDATA", "HERMES_HOME", "HERMES_RUNTIME_DIR",
|
|
"HERMES_PYTHON_SRC_ROOT", "XDG_CONFIG_HOME", "XDG_CACHE_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME",
|
|
"UV_CACHE_DIR", "NPM_CONFIG_CACHE", "NPM_EXECPATH", "NPM_NODE_EXECPATH",
|
|
"NPM_CONFIG_USERCONFIG", "NPM_CONFIG_GLOBALCONFIG", "NPM_CONFIG_PREFIX",
|
|
"PNPM_CONFIG_STORE_DIR", "PNPM_CONFIG_CACHE_DIR", "PNPM_CONFIG_STATE_DIR",
|
|
"PYTHONUTF8", "PYTHONDONTWRITEBYTECODE", "CARGO_HOME", "RUSTUP_HOME", "CARGO_TARGET_DIR"}
|
|
result = {key: value for key, value in env.items() if key.upper() not in _INSTALL_ENV | owned}
|
|
canonical = {key.upper(): value for key, value in env.items()}
|
|
# Rustup must still find the runner's installed toolchain after HOME moves.
|
|
home_key = "USERPROFILE" if os.name == "nt" else "HOME"
|
|
original_home = Path(canonical.get("HERMES_REAL_HOME") or canonical.get(home_key) or Path.home())
|
|
for key, directory in (("CARGO_HOME", ".cargo"), ("RUSTUP_HOME", ".rustup")):
|
|
result[key] = canonical.get(key) or str(original_home / directory)
|
|
home = work / "home"
|
|
result.update({
|
|
"HOME": str(home), "USERPROFILE": str(home),
|
|
"LOCALAPPDATA": str(home / "AppData/Local"),
|
|
"APPDATA": str(home / "AppData/Roaming"),
|
|
"HERMES_HOME": str(work / "hermes-home"),
|
|
"HERMES_RUNTIME_DIR": str(cache / "tools"),
|
|
"HERMES_PYTHON_SRC_ROOT": str(source),
|
|
"XDG_CONFIG_HOME": str(home / "config"), "XDG_CACHE_HOME": str(home / "cache"),
|
|
"XDG_DATA_HOME": str(home / "data"), "XDG_STATE_HOME": str(home / "state"),
|
|
"UV_CACHE_DIR": str(cache / "python/runtime"),
|
|
# Rust sdists (obstore via maturin) otherwise compile into target/ inside uv's
|
|
# nested sdist cache entry; on Windows that pushes build-script paths past
|
|
# MAX_PATH and link.exe fails with LNK1104. A job-local root keeps them short.
|
|
"CARGO_TARGET_DIR": str(work / "cargo"),
|
|
# vcpkg's default binary cache is under LOCALAPPDATA, which moved into the
|
|
# job-local home above; keep its archives in the transported native domain.
|
|
"VCPKG_DEFAULT_BINARY_CACHE": str(cache / "native/vcpkg-archives"),
|
|
# Only the package store is reusable; pnpm's metadata cache and state stay
|
|
# in the job-local XDG directories above.
|
|
"pnpm_config_store_dir": str(cache / "pnpm/store"),
|
|
# pnpm reads registry and auth from npm's user config.
|
|
"npm_config_userconfig": os.devnull,
|
|
"PYTHONUTF8": "1", "PYTHONDONTWRITEBYTECODE": "1",
|
|
})
|
|
return result
|
|
|
|
|
|
def run_preparation(source: Path, work: Path, cache: Path, request_file: Path,
|
|
*, worker: Path | None = None) -> int:
|
|
"""Bootstrap PM after process isolation, then run the preparation worker.
|
|
|
|
The request contains paths/selection only; credentials stay in the inherited
|
|
child environment. Return the worker's exit status without hiding failures.
|
|
"""
|
|
source, work, cache = source.resolve(), work.resolve(), cache.resolve()
|
|
environment = bootstrap_environment(source, work, cache, os.environ)
|
|
Path(environment["HOME"]).mkdir(parents=True, exist_ok=True)
|
|
launcher = (
|
|
"import subprocess, sys; from pathlib import Path; "
|
|
"source, cache, request, entry, worker = map(Path, sys.argv[1:]); "
|
|
"sys.path.insert(0, str(source)); from pm.runtime import runtime_command; "
|
|
"command = runtime_command(entry, "
|
|
"[str(worker), '--request', str(request), '--worker'], "
|
|
"cache=cache / 'python/runtime'); "
|
|
"sys.exit(subprocess.run(command, stdin=subprocess.DEVNULL).returncode)"
|
|
)
|
|
return subprocess.run(
|
|
[sys.executable, "-I", "-S", "-B", "-c", launcher,
|
|
str(source), str(cache), str(request_file.resolve()), str(Path(__file__).resolve()),
|
|
str(worker or source / "scripts/bundles/desktop_prepare.py")],
|
|
cwd=source, env=environment, stdin=subprocess.DEVNULL,
|
|
check=False,
|
|
).returncode
|
|
|
|
|
|
def prepare_tools(source: Path, work: Path, cache: Path,
|
|
env: Mapping[str, str]) -> tuple[Path, Path, dict[str, str]]:
|
|
"""Run only in the bootstrapped worker; return native Python, Node and env.
|
|
|
|
PM owns pin selection and verification. The caller passes the resulting env
|
|
to every build child, including its explicit native-wheel UV_CACHE_DIR.
|
|
"""
|
|
import pm
|
|
from pm.paths import store_root
|
|
|
|
source, work, cache = source.resolve(), work.resolve(), cache.resolve()
|
|
if store_root() != cache / "tools":
|
|
raise ValueError("desktop tools require the isolated preparation worker")
|
|
prepared = dict(env)
|
|
if pm.current_target() == "win32-arm64":
|
|
from pm.native_build import prepare_windows_environment
|
|
|
|
prepared = prepare_windows_environment(source=source, state=cache / "native/prerequisites", env=prepared)
|
|
if pm.current_target().startswith("darwin"):
|
|
# python-build-standalone's sysconfig names its absent build-host tools.
|
|
prepared.setdefault("AR", "/usr/bin/ar")
|
|
prepared.setdefault("CC", "clang")
|
|
for name in ("uv", "pnpm"):
|
|
pm.ensure(name, explicit=True)
|
|
binaries = {}
|
|
for name in ("python", "node"):
|
|
installed = pm.installed_package(name)
|
|
if installed is None or installed.binary is None or not installed.binary.is_file():
|
|
raise FileNotFoundError(f"PM did not prepare a native {name} executable")
|
|
binaries[name] = installed.binary
|
|
prepared = pm.env_for("python", "pnpm", base_env=prepared)
|
|
uv_cache = native_cache_path(cache, prepared)
|
|
if os.name == "nt":
|
|
uv_cache = short_alias(uv_cache, work / "uv")
|
|
prepared.update({"HERMES_PYTHON": str(binaries["python"]), "HERMES_NODE": str(binaries["node"]),
|
|
"UV_CACHE_DIR": str(uv_cache)})
|
|
return binaries["python"], binaries["node"], prepared
|
|
|
|
|
|
def short_alias(directory: Path, link: Path) -> Path:
|
|
"""Reach a transported cache directory through a short job-local junction.
|
|
|
|
uv builds each sdist in <cache>/sdists-v10/pypi/<name>/<version>/<id>/src, and
|
|
MSVC link.exe cannot open paths past MAX_PATH, so a deep cache root pushes
|
|
native build outputs over 260 characters (LNK1104). uv keeps the spelling it
|
|
is given, so builds run under the junction while the bytes stay in the cache.
|
|
"""
|
|
import _winapi
|
|
|
|
from pm.filesystem import is_junction
|
|
|
|
directory.mkdir(parents=True, exist_ok=True)
|
|
link.parent.mkdir(parents=True, exist_ok=True)
|
|
if is_junction(link):
|
|
os.rmdir(link) # Removes only the reparse point, never the cache behind it.
|
|
_winapi.CreateJunction(str(directory), str(link))
|
|
return link
|
|
|
|
|
|
def _msvc_identity() -> dict[str, str] | None:
|
|
"""The newest VC toolset vswhere reports, with its default tools version."""
|
|
from hermes_platform.resolver import locate_command
|
|
from hermes_platform.resolver.known_dirs import visual_studio_installer_dirs
|
|
|
|
vswhere = locate_command("vswhere.exe", known_dirs=visual_studio_installer_dirs())
|
|
if not vswhere.found:
|
|
print("warning: MSVC cache identity unavailable: vswhere.exe was not found", file=sys.stderr, flush=True)
|
|
return None
|
|
try:
|
|
result = subprocess.run([*vswhere.command, "-latest", "-products", "*", "-requires",
|
|
"Microsoft.VisualStudio.Component.VC.Tools.x86.x64", "-format", "json"],
|
|
capture_output=True, text=True, encoding="utf-8", errors="replace",
|
|
timeout=30, stdin=subprocess.DEVNULL, check=False)
|
|
instances = json.loads(result.stdout or "[]")
|
|
if not instances:
|
|
print("warning: MSVC cache identity unavailable: vswhere found no matching installations",
|
|
file=sys.stderr, flush=True)
|
|
return None
|
|
instance = instances[0]
|
|
tools = Path(instance["installationPath"], "VC/Auxiliary/Build/Microsoft.VCToolsVersion.default.txt")
|
|
return {"installationVersion": instance["installationVersion"],
|
|
"VCToolsVersion": tools.read_text(encoding="utf-8-sig").strip()}
|
|
except (OSError, subprocess.TimeoutExpired, ValueError, IndexError, KeyError) as error:
|
|
print(f"warning: MSVC cache identity unavailable: {error}", file=sys.stderr, flush=True)
|
|
return None
|
|
|
|
|
|
def native_cache_path(cache: Path, env: Mapping[str, str]) -> Path:
|
|
"""Partition built wheels by observed native inputs, not just the OS label.
|
|
|
|
Missing tool/SDK identity deliberately gets a fresh partition. No inherited
|
|
environment or credential-bearing Cargo configuration is written to cache.
|
|
"""
|
|
from pm.store import current_target
|
|
|
|
target = current_target()
|
|
keys = {"CC", "CXX", "AR", "CFLAGS", "CXXFLAGS", "LDFLAGS", "RUSTFLAGS", "RUSTUP_TOOLCHAIN",
|
|
"SDKROOT", "MACOSX_DEPLOYMENT_TARGET", "WindowsSDKVersion", "VCToolsVersion",
|
|
"WindowsSdkDir", "INCLUDE", "LIB", "LIBPATH", "OPENSSL_DIR", "OPENSSL_LIB_DIR",
|
|
"OPENSSL_INCLUDE_DIR", "OPENSSL_STATIC"}
|
|
selected = {key: value for key, value in env.items() if key in keys or key.startswith("CC_")}
|
|
identity = {"recipe": 1, "target": target, "host": platform.platform(),
|
|
"libc": platform.libc_ver(), "inputs": selected, "probes": [], "openssl": {}}
|
|
commands = [["rustc", "-vV"]]
|
|
if target.startswith("win32"):
|
|
if env.get("VCToolsVersion"):
|
|
commands.append(["cl", "/Bv"])
|
|
complete = bool(env.get("WindowsSDKVersion"))
|
|
else:
|
|
# No developer environment (win32-x64 builds never run VsDevCmd): rustc's cc
|
|
# crate finds MSVC through vswhere, so identify the toolchain the same way.
|
|
msvc = _msvc_identity()
|
|
identity["msvc"] = msvc
|
|
complete = msvc is not None
|
|
else:
|
|
commands.extend([[env.get("CC") or "cc", "--version"], [env.get("CXX") or "c++", "--version"]])
|
|
complete = True
|
|
commands.extend([[value, "--version"] for key, value in selected.items() if key.startswith("CC_")])
|
|
if target.startswith("darwin"):
|
|
commands.extend([["xcrun", "--show-sdk-path"], ["xcrun", "--show-sdk-build-version"]])
|
|
openssl = env.get("OPENSSL_DIR")
|
|
if openssl or env.get("OPENSSL_LIB_DIR") or env.get("OPENSSL_INCLUDE_DIR"):
|
|
roots = {"include": Path(env["OPENSSL_INCLUDE_DIR"]) if env.get("OPENSSL_INCLUDE_DIR")
|
|
else Path(openssl or "") / "include",
|
|
"lib": Path(env["OPENSSL_LIB_DIR"]) if env.get("OPENSSL_LIB_DIR")
|
|
else Path(openssl or "") / "lib"}
|
|
for kind, root in roots.items():
|
|
files = sorted(path for path in root.rglob("*") if path.is_file()) if root.is_dir() else []
|
|
complete = complete and bool(files)
|
|
for path in files:
|
|
with path.open("rb") as stream:
|
|
identity["openssl"][f"{kind}/{path.relative_to(root).as_posix()}"] = hashlib.file_digest(stream, "sha256").hexdigest()
|
|
else:
|
|
commands.append(["openssl", "version", "-a"])
|
|
if target == "win32-arm64":
|
|
complete = False # The provider must identify the linked static libraries.
|
|
for command in commands:
|
|
try:
|
|
result = subprocess.run(command, env=dict(env), capture_output=True, text=True, encoding="utf-8",
|
|
errors="replace", timeout=30, stdin=subprocess.DEVNULL, check=False)
|
|
output = result.stdout + result.stderr
|
|
# cl /Bv reports its identity and exits 2 when no source is supplied.
|
|
valid = result.returncode in ((0, 2) if command == ["cl", "/Bv"] else (0,)) and bool(output.strip())
|
|
identity["probes"].append([command, output])
|
|
complete = complete and valid
|
|
except (OSError, subprocess.TimeoutExpired):
|
|
complete = False
|
|
# Build-owned locations move across runners; their bytes and relative layout
|
|
# identify them. Keep external compiler/SDK paths significant.
|
|
encoded = json.dumps(identity, sort_keys=True)
|
|
owned = str(cache.resolve())
|
|
encoded = encoded.replace(json.dumps(owned)[1:-1], "<build-cache>")
|
|
# uv builds sdists below this root. Keep the partition compact so compiler
|
|
# outputs fit Windows MAX_PATH; the target is already part of the identity.
|
|
digest = hashlib.sha256(encoded.encode()).hexdigest()[:32] if complete else uuid.uuid4().hex
|
|
return cache.resolve() / "python/runtime" / digest
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import runpy
|
|
import truststore
|
|
|
|
# Like pm/launch.py: initialize platform trust before PM creates HTTPS clients.
|
|
truststore.inject_into_ssl()
|
|
sys.argv = sys.argv[1:]
|
|
runpy.run_path(sys.argv[0], run_name="__main__")
|