mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 03:12:19 +03:00
f546a7e88b
Python >= 3.13 gives tempfile folders a protected DACL on Windows (SYSTEM, Administrators, OWNER RIGHTS), and plugin install/update stage in one, so the published plugin dropped every entry plugins/ grants (the user, Users, the sandbox groups). A gateway run as a Windows service is elevated, so its __pycache__ there was owned by Administrators and the same user's non-elevated hermes could neither read nor delete it. StagedPlugin.publish now calls pm.filesystem.inherit_parent_acl on the published root after the os.replace: an empty, unprotected DACL that Windows propagates down the tree. Explicit entries are kept; best effort, no-op off Windows. [BearHuddleston: adapted to #152234, whose worker already granted the user at the same point; kept that grant below this call so this commit stays this change alone. The next commit drops it.] Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 80ad13f6e5edce0301b0ade12ca347c6401ce515)
259 lines
10 KiB
Python
259 lines
10 KiB
Python
"""Stdlib-only filesystem primitives PM needs before it can replace the caller's interpreter.
|
|
|
|
Boot-time dependency selection (``hermes_cli.runtime_state``) imports these, so nothing here
|
|
may import a dependency or another PM module.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from contextlib import suppress
|
|
import errno
|
|
import hashlib
|
|
import ntpath
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
import stat
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
|
|
_LOCK_POLL_SECONDS = 0.05
|
|
|
|
|
|
def is_junction(path: Path) -> bool:
|
|
"""Keep junctions opaque even before Python 3.12's Path.is_junction exists.
|
|
|
|
A path that cannot be stat'ed is not a junction, matching ``os.path.isjunction``: callers
|
|
probe slots that do not exist yet (a first plugin install) and must get False, not a crash.
|
|
POSIX stat results carry no reparse tag, which lands in the same False.
|
|
"""
|
|
if os.name != "nt":
|
|
return False
|
|
try:
|
|
return path.lstat().st_reparse_tag == stat.IO_REPARSE_TAG_MOUNT_POINT
|
|
except (OSError, AttributeError):
|
|
return False
|
|
|
|
|
|
_VERBATIM = "\\\\?\\"
|
|
_VERBATIM_UNC = "\\\\?\\UNC\\"
|
|
|
|
|
|
def _long_form(text: str) -> str:
|
|
if text.startswith(_VERBATIM):
|
|
return text
|
|
# Windows stops normalising a verbatim path, so it must already be absolute,
|
|
# backslashed and free of `..` before the prefix goes on.
|
|
text = ntpath.abspath(text)
|
|
if text.startswith("\\\\"):
|
|
return _VERBATIM_UNC + text[2:]
|
|
return _VERBATIM + text
|
|
|
|
|
|
def long_root(path: Path) -> Path:
|
|
"""Spell a PM-owned root so Windows file calls beneath it are not cut at
|
|
MAX_PATH when LongPathsEnabled is 0 (the default). Every path joined onto the
|
|
result inherits the spelling; relative paths and digests are unchanged."""
|
|
return Path(_long_form(os.fspath(path))) if os.name == "nt" else path
|
|
|
|
|
|
def native(path: str | os.PathLike[str]) -> str:
|
|
"""The ordinary spelling, for text that leaves PM's own file calls: argv, cwd,
|
|
environment values, hashed identities, records and messages."""
|
|
text = os.fspath(path)
|
|
if text.startswith(_VERBATIM_UNC):
|
|
return "\\\\" + text[len(_VERBATIM_UNC):]
|
|
return text.removeprefix(_VERBATIM)
|
|
|
|
|
|
def lock_fd(fd: int, *, wait: bool, timeout: float | None = None) -> bool:
|
|
"""Take the byte lock; ``timeout`` bounds the retry loop (None waits forever, 0 tries once)."""
|
|
deadline = None if timeout is None else time.monotonic() + timeout
|
|
if os.name == "nt":
|
|
import msvcrt
|
|
while True:
|
|
try:
|
|
os.lseek(fd, 0, os.SEEK_SET)
|
|
msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
|
|
return True
|
|
except OSError as exc:
|
|
if exc.errno not in (errno.EACCES, errno.EAGAIN, errno.EDEADLK):
|
|
raise
|
|
if not wait or (deadline is not None and time.monotonic() >= deadline):
|
|
return False
|
|
time.sleep(_LOCK_POLL_SECONDS)
|
|
else:
|
|
import fcntl
|
|
while True:
|
|
try:
|
|
fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
|
return True
|
|
except BlockingIOError:
|
|
pass
|
|
if not wait or (deadline is not None and time.monotonic() >= deadline):
|
|
return False
|
|
time.sleep(_LOCK_POLL_SECONDS)
|
|
|
|
|
|
def unlock_fd(fd: int) -> None:
|
|
"""Release :func:`lock_fd`'s byte lock; best effort, since closing the descriptor releases it too."""
|
|
with suppress(OSError):
|
|
if os.name == "nt":
|
|
import msvcrt
|
|
os.lseek(fd, 0, os.SEEK_SET)
|
|
msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
|
|
else:
|
|
import fcntl
|
|
fcntl.flock(fd, fcntl.LOCK_UN)
|
|
|
|
|
|
def lock_path(path: Path, *, timeout: float | None, create_dir: bool = False) -> int | None:
|
|
"""Open *path* (created if missing), wait up to ``timeout`` for its byte lock and return the
|
|
held descriptor; None when the wait expired. The caller closes the descriptor to release.
|
|
|
|
A holder that removes the lock file unlinks it while still holding it (the install-state
|
|
collector), so a waiter that opened the old file gets a lock on an inode no one else can
|
|
reach while the next opener creates a fresh file: both would hold "the" lock. Once held,
|
|
the descriptor must still be the file at *path*, else retry on the current one. Windows
|
|
cannot unlink an open file, so the check is POSIX-only. ``create_dir`` re-creates the
|
|
parent the remover may have taken with it.
|
|
"""
|
|
deadline = None if timeout is None else time.monotonic() + timeout
|
|
while True:
|
|
if create_dir:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
try:
|
|
fd = os.open(path, os.O_CREAT | os.O_RDWR, 0o600)
|
|
except FileNotFoundError:
|
|
# Only a parent removed between mkdir and open is worth another try; anything else
|
|
# (a dangling symlink at *path*) fails the same way every time.
|
|
if not create_dir or path.parent.is_dir():
|
|
raise
|
|
if deadline is not None and time.monotonic() >= deadline:
|
|
return None
|
|
continue
|
|
try:
|
|
remaining = None if deadline is None else max(0.0, deadline - time.monotonic())
|
|
if not lock_fd(fd, wait=True, timeout=remaining):
|
|
os.close(fd)
|
|
return None
|
|
if os.name == "nt" or _same_file(fd, path):
|
|
return fd
|
|
except BaseException:
|
|
os.close(fd)
|
|
raise
|
|
os.close(fd)
|
|
if deadline is not None and time.monotonic() >= deadline:
|
|
return None
|
|
|
|
|
|
def _same_file(fd: int, path: Path) -> bool:
|
|
try:
|
|
return os.path.samestat(os.fstat(fd), os.stat(path))
|
|
except FileNotFoundError:
|
|
return False
|
|
|
|
|
|
def read_bytes_or_none(path: Path) -> bytes | None:
|
|
try:
|
|
return path.read_bytes()
|
|
except FileNotFoundError:
|
|
return None
|
|
|
|
|
|
def file_digest(path: Path) -> str | None:
|
|
data = read_bytes_or_none(path)
|
|
return hashlib.sha256(data).hexdigest() if data is not None else None
|
|
|
|
|
|
def durable_write_bytes(path: Path, data: bytes) -> None:
|
|
"""Replace ``path`` atomically and fsync file and directory so a crash keeps old or new bytes."""
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
fd, temporary = tempfile.mkstemp(dir=path.parent, prefix=".publish-")
|
|
try:
|
|
with os.fdopen(fd, "wb") as stream:
|
|
stream.write(data)
|
|
stream.flush()
|
|
os.fsync(stream.fileno())
|
|
os.replace(temporary, path)
|
|
if os.name != "nt":
|
|
directory = os.open(path.parent, os.O_RDONLY)
|
|
try:
|
|
os.fsync(directory)
|
|
finally:
|
|
os.close(directory)
|
|
finally:
|
|
Path(temporary).unlink(missing_ok=True)
|
|
|
|
|
|
def inherit_parent_acl(path: Path) -> bool:
|
|
"""Windows: give a tree just moved into place the access rules of its new parent.
|
|
|
|
``tempfile`` folders on Python >= 3.13 carry a private, protected DACL (SYSTEM, Administrators,
|
|
OWNER RIGHTS) and ``os.replace`` moves a staged tree with the DACL it had, so a plugin staged
|
|
that way keeps none of ``plugins/``'s entries: not the user's own, not the sandbox groups'. A
|
|
gateway running elevated (a Windows service) then writes ``__pycache__`` owned by Administrators
|
|
that the same user's non-elevated processes can neither read nor delete. An empty, unprotected
|
|
DACL makes the root inherit from its parent, and Windows propagates that down the tree in place
|
|
of the entries the children inherited from the staging folder. Explicit entries are kept.
|
|
|
|
Best effort, never raises: a volume without ACLs (FAT, some shares) keeps what it had. Returns
|
|
whether the DACL was applied; always False off Windows.
|
|
"""
|
|
if os.name != "nt":
|
|
return False
|
|
import ctypes
|
|
from ctypes import wintypes
|
|
|
|
advapi = ctypes.WinDLL("advapi32", use_last_error=True)
|
|
advapi.InitializeAcl.argtypes = [ctypes.c_void_p, wintypes.DWORD, wintypes.DWORD]
|
|
advapi.InitializeAcl.restype = wintypes.BOOL
|
|
advapi.SetNamedSecurityInfoW.argtypes = [wintypes.LPCWSTR, ctypes.c_int, wintypes.DWORD, ctypes.c_void_p,
|
|
ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
|
|
advapi.SetNamedSecurityInfoW.restype = wintypes.DWORD
|
|
acl = ctypes.create_string_buffer(8) # sizeof(ACL) with no entries
|
|
if not advapi.InitializeAcl(acl, ctypes.sizeof(acl), 2): # ACL_REVISION
|
|
return False
|
|
se_file_object, dacl, unprotected_dacl = 1, 0x00000004, 0x20000000
|
|
return advapi.SetNamedSecurityInfoW(os.fspath(path), se_file_object, dacl | unprotected_dacl,
|
|
None, None, acl, None) == 0
|
|
|
|
|
|
#: A handle still open inside the tree. Windows reports antivirus and indexer scans of freshly
|
|
#: written files this way (WinError 5 and 32 both surface as EACCES) and they clear in moments;
|
|
#: a missing source or an occupied destination never does, so those raise at once.
|
|
_HELD_ERRNOS = frozenset({errno.EACCES, errno.EPERM, errno.EBUSY})
|
|
_HELD_RETRY_DELAYS = (0.1, 0.2, 0.4, 0.8, 1.6)
|
|
|
|
|
|
def retry_held(operation):
|
|
"""Run a rename-like mutation, riding out a transient Windows hold (~3s) before raising."""
|
|
for delay in (*_HELD_RETRY_DELAYS, None):
|
|
try:
|
|
return operation()
|
|
except OSError as error:
|
|
if delay is None or error.errno not in _HELD_ERRNOS:
|
|
raise
|
|
time.sleep(delay)
|
|
|
|
|
|
def remove_tree(path: Path) -> None:
|
|
"""``shutil.rmtree`` that clears a Windows read-only attribute and retries that one unlink.
|
|
|
|
Windows refuses to unlink read-only files (PortableGit ships ``etc/hosts`` read-only), and no
|
|
retry clears that bit. Every other failure, and every POSIX failure, raises as plain rmtree
|
|
would: a POSIX permission error is about the parent directory, and chmodding the path there
|
|
would follow a symlink out of the tree. Lives here, not in ``hermes_cli``: PM installs run
|
|
before the rest of the tree exists (the Docker toolchain stage copies only ``pm/``).
|
|
"""
|
|
def _retry_writable(func, failed, error):
|
|
error = error[1] if isinstance(error, tuple) else error
|
|
if os.name != "nt" or func not in (os.unlink, os.rmdir) or not isinstance(error, PermissionError):
|
|
raise error
|
|
# Windows >= 3.13 chmod follows links; the attribute to clear is the link's own.
|
|
os.chmod(failed, stat.S_IWRITE, **({"follow_symlinks": False} if os.chmod in os.supports_follow_symlinks else {}))
|
|
func(failed)
|
|
|
|
handler = {"onexc": _retry_writable} if sys.version_info >= (3, 12) else {"onerror": _retry_writable}
|
|
shutil.rmtree(path, **handler)
|