| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567 |
- """Detect Git operations that can rewrite the checkout backing this process."""
- from __future__ import annotations
- import contextlib
- import os
- import re
- import shlex
- import subprocess
- from dataclasses import dataclass, field
- from pathlib import Path
- from typing import Callable
- from tools.approval_detection import (
- _bash_exec_payload, _deobfuscate_shell_word_for_detection, _iter_shell_command_starts,
- _is_shell_comment_start, _read_shell_word, _scan_shell)
- # bisect drives repeated checkouts of the running root — the exact skew hazard guarded here.
- _WORKTREE_MUTATIONS = frozenset({
- "checkout", "switch", "rebase", "merge", "pull", "restore", "clean", "cherry-pick", "revert",
- "bisect"})
- _WORKTREE_TARGET_ACTIONS = frozenset({"move", "remove"})
- _STASH_SAFE_ACTIONS = frozenset({"list", "show", "create", "store", "drop", "clear"})
- _RESET_WORKTREE_MODES = frozenset({"--hard", "--merge", "--keep"})
- # `reset`/`stash`/`clean`/`restore` reach this set only in their SAFE forms (_mutates_worktree
- # runs first); listing them skips a pointless `git config --get alias.<sub>` subprocess.
- _KNOWN_GIT_BUILTINS = frozenset({
- "add", "am", "apply", "blame", "branch", "bundle", "cat-file", "clean", "clone", "commit",
- "config", "describe", "diff", "fetch", "format-patch", "grep", "help", "init", "log",
- "ls-files", "ls-remote", "ls-tree", "maintenance", "merge-base", "mv", "notes", "push",
- "range-diff", "reflog", "remote", "repack", "replace", "reset", "restore", "rev-list",
- "rev-parse", "rm", "shortlog", "show", "show-ref", "stash", "status", "submodule", "tag",
- "worktree"})
- _SHELL_EXECUTABLES = frozenset({"bash", "dash", "ksh", "sh", "zsh"})
- _ASSIGNMENT_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*=(.*)", re.DOTALL)
- _RESET_HARD_RE = re.compile(r"--h(?:a(?:r(?:d)?)?)?\Z")
- # ``<<-`` opener + optional blanks + a quoted delimiter (closing quote required) or a bare word.
- _HEREDOC_OPENER_RE = re.compile(
- r"<<(?P<dash>-?)[ \t]*(?:(?P<q>['\"])(?P<quoted>.*?)(?P=q)|(?!['\"])(?P<bare>[^\s;|&<>]*))")
- _NO_OPTIONS: frozenset[str] = frozenset()
- # Wrapper executables skipped to reach the real command -> options that consume an argument.
- _WRAPPER_OPTIONS_WITH_ARG: dict[str, frozenset[str]] = {
- "sudo": frozenset({
- "-C", "--chdir", "-c", "--close-from", "-g", "--group", "-h", "--host",
- "-p", "--prompt", "-R", "--chroot", "-T", "--command-timeout", "-u", "--user"}),
- "env": frozenset({"-a", "--argv0", "-C", "--chdir", "-S", "--split-string", "-u", "--unset"}),
- "command": _NO_OPTIONS, "builtin": _NO_OPTIONS, "nohup": _NO_OPTIONS, "setsid": _NO_OPTIONS,
- "exec": frozenset({"-a"}), "nice": frozenset({"-n", "--adjustment"}),
- "time": frozenset({"-f", "--format", "-o", "--output"})}
- _MAX_RECURSION = 4
- # git global options that consume the next argument (-C/--work-tree/-c are acted on).
- _GIT_GLOBAL_OPTIONS_WITH_ARG = frozenset(
- {"-C", "-c", "--work-tree", "--git-dir", "--namespace", "--exec-path"})
- @dataclass
- class _Heredoc:
- delimiter: str
- strip_tabs: bool
- opener: int # offset of the ``<<`` in the masked command
- body: list[str] = field(default_factory=list)
- @dataclass
- class _ShellContext: # one `(` / `$(` / backtick nesting level and its live quote state
- kind: str
- opener: int
- quote: str | None = None
- def get_running_source_root() -> Path | None:
- """The source checkout backing this process, if there is one."""
- try:
- root = Path(__file__).resolve().parent.parent
- except (OSError, RuntimeError):
- return None
- return root if (root / ".git").exists() else None
- def _resolve(path_str: str, base: Path) -> Path:
- path = base / Path(os.path.expanduser(path_str)) # ``/`` keeps an absolute right operand
- with contextlib.suppress(OSError, RuntimeError, ValueError):
- return path.resolve()
- return path
- def _is_within(path: Path, root: Path) -> bool:
- with contextlib.suppress(OSError, RuntimeError, ValueError):
- return path == root or path.is_relative_to(root)
- return False
- def _executable_name(value: str) -> str:
- return Path(value.replace("\\", "/")).name.removesuffix(".exe").lower()
- def _shell_words_at(command: str, start: int) -> list[str]:
- """Deobfuscated words of the simple command at ``start`` (stops at a newline, a redirection
- or a trailing ``# comment``; max 64). The fd prefix of ``2>/dev/null`` / ``2>&1`` belongs to
- the redirection, not to the command's operands."""
- words: list[str] = []
- cursor = start
- for _ in range(64):
- word_start, word_end, raw_word = _read_shell_word(command, cursor)
- if word_start == word_end or (words and "\n" in command[cursor:word_start]) or (
- _is_shell_comment_start(command, word_start)) or (
- raw_word.isdigit() and command[word_end : word_end + 1] in ("<", ">")):
- break
- words.append(_deobfuscate_shell_word_for_detection(raw_word))
- cursor = word_end
- return words
- def _consume_options(
- words: list[str], start: int, options_with_arg: frozenset[str] = _NO_OPTIONS) -> int:
- """Index of the first positional at/after ``start`` (``--`` ends options)."""
- index = start
- while index < len(words) and words[index].startswith("-") and words[index] != "-":
- if words[index] == "--":
- return index + 1
- index += 2 if "=" not in words[index] and words[index] in options_with_arg else 1
- return index
- def _command_parts(words: list[str]) -> tuple[dict[str, str], str | None, list[str]]:
- """Split leading VAR=value assignments and wrappers off -> (env, executable, args)."""
- env: dict[str, str] = {}
- index = 0
- while index < len(words):
- if _ASSIGNMENT_RE.fullmatch(words[index]):
- name, value = words[index].split("=", 1)
- env[name] = value
- index += 1
- continue
- executable = _executable_name(words[index])
- wrapper_options = _WRAPPER_OPTIONS_WITH_ARG.get(executable)
- if wrapper_options is None:
- return env, words[index], words[index + 1 :]
- if executable == "command" and words[index + 1 : index + 2] in (["-v"], ["-V"]):
- break # `command -v/-V` only reports; nothing runs
- index = _consume_options(words, index + 1, wrapper_options)
- return env, None, []
- def _scope_keys(command: str, starts: list[int]) -> dict[int, tuple[int, ...]]:
- """Map each command start to the tuple of enclosing ``(``/``$(``/backtick openers."""
- contexts = [_ShellContext("root", -1)]
- scopes: dict[int, tuple[int, ...]] = {}
- cursor = 0
- for start in sorted(set(starts)):
- while cursor < start:
- context = contexts[-1]
- quote = context.quote
- char = command[cursor]
- closes = quote is None and len(contexts) > 1 # an unquoted closer may pop a scope
- if quote is not None and char == quote:
- context.quote = None
- elif quote == "'":
- pass # single quotes: no escapes, no substitutions
- elif char == "\\" and cursor + 1 < start:
- cursor += 1
- elif quote is None and char in "'\"":
- context.quote = char
- # Unquoted or inside double quotes: substitutions still open scopes.
- elif command.startswith("$(", cursor):
- contexts.append(_ShellContext("$(", cursor))
- cursor += 1
- elif quote is None and char == "(":
- contexts.append(_ShellContext("(", cursor))
- elif (char == ")" and closes and context.kind in {"(", "$("}) or (
- char == "`" and closes and context.kind == "`"):
- contexts.pop()
- elif char == "`":
- contexts.append(_ShellContext("`", cursor))
- cursor += 1
- scopes[start] = tuple(item.opener for item in contexts[1:])
- return scopes
- def _operator_before(command: str, start: int) -> str | None:
- """The list/grouping operator (or newline) immediately preceding a command start."""
- head = command[:start].rstrip()
- for tail in (head[-2:], head[-1:]):
- if tail in {"&&", "||", ";", "|", "&", "(", "{"}:
- return tail
- return "\n" if "\n" in command[len(head):start] else None
- def _cd_target(executable: str, args: list[str], cwd: Path) -> Path | None:
- """Directory a ``cd``/``pushd`` would land in (existing dirs only), else None."""
- if _executable_name(executable) not in {"cd", "pushd"}:
- return None
- index = _consume_options(args, 0)
- if index >= len(args) or args[index] == "-":
- return None
- target = _resolve(args[index], cwd)
- return target if target.is_dir() else None
- def _shell_script_arg(args: list[str]) -> str | None:
- """Script string owned by a shell's ``-c``, if present. ``_bash_exec_payload`` parses bash's
- real option grammar (``-o pipefail -c '<script>'``); when it finds no ``-c``, fall back to a
- permissive scan: zsh/dash/ksh letters (``zsh -yc``) would otherwise fail this guard open."""
- has_c, payload = _bash_exec_payload(args)
- if has_c:
- return payload
- for index, arg in enumerate(args):
- if arg == "--" or not arg.startswith("-"):
- return None
- if "c" in arg[1:]:
- return args[index + 1] if index + 1 < len(args) else None
- return None
- def _executes_heredoc_body(words: list[str]) -> bool:
- """A bare shell (no ``-c`` script, no script operand) executes whatever it reads on stdin."""
- _, executable, args = _command_parts(words)
- return bool(
- executable and _executable_name(executable) in _SHELL_EXECUTABLES
- and _shell_script_arg(args) is None
- and not any(arg and not arg.startswith("-") for arg in args))
- def _group_token(masked: str, index: int) -> bool:
- """``{`` / ``}`` at ``index`` is a brace-group delimiter (its own word), not ``${x}``/``a{b,c}``."""
- before = masked[index - 1] if index else " "
- after = masked[index + 1] if index + 1 < len(masked) else " "
- return (before.isspace() or before in "(;&|") and (after.isspace() or after in ";)|&")
- def _pipeline_end(masked: str, opener: int) -> int:
- """Offset where the pipeline carrying a heredoc ends: the first ``;``/``&&``/``||``/``&`` or
- bare newline at top level. Newlines right after ``|`` continue the pipeline (the consumer may
- follow the terminator line). Inside a group the walk runs on until the group closes, then a
- pipe after the closer continues it (``(cat <<EOF; echo) | bash``) and anything else ends it."""
- depth = 0
- level: int | None = None # nesting depth of the opener's command, once the scan reaches it
- after_pipe = False
- backtick = False
- for kind, index, end, quote in _scan_shell(masked, comments=True):
- if level is None and index >= opener:
- level = depth
- if kind == "comment":
- continue
- if kind != "char" or quote is not None:
- after_pipe = False # part of a word
- continue
- char = masked[index]
- if char.isspace():
- if char == "\n" and level == 0 and depth == 0 and not after_pipe:
- return index
- continue
- if char in ";&|":
- if char == "&" and (masked[index - 1] in "<>" or masked.startswith("&>", index)):
- continue # `2>&1` / `>&2` / `&>file` redirect fds: not a list operator
- if char == "|" and not masked.startswith("||", index):
- after_pipe = True
- elif level == 0 and depth == 0 and masked[index - 1] != "|": # `|&` is a pipe
- return index
- continue
- after_pipe = False
- if char == "`":
- depth += -1 if backtick else 1
- backtick = not backtick
- elif char == "(" or (char == "{" and _group_token(masked, index)):
- depth += 1
- elif char == ")" or (char == "}" and _group_token(masked, index)):
- depth -= 1
- if level is not None and depth < level:
- rest = masked[end:].lstrip(" \t")
- if not rest.startswith("|") or rest.startswith("||"):
- return index
- level = depth
- return len(masked)
- def _shell_consumes_heredoc(
- masked: str, starts: list[int], scopes: dict[int, tuple[int, ...]], opener: int) -> bool:
- """Whether a bare shell reads the heredoc body: the command owning the ``<<`` or anything
- downstream in its pipeline. Pipe-joined segments, and the groups or substitutions inside them,
- all inherit the pipe as stdin (``| tee f | bash``, ``| (bash)``, ``| { echo; bash; }``)."""
- scope = scopes[opener]
- owner = max((start for start in starts if start <= opener and scopes[start] == scope),
- default=None)
- end = _pipeline_end(masked, opener)
- candidates = [*([owner] if owner is not None else []),
- *(start for start in starts if opener < start < end)]
- return any(_executes_heredoc_body(_shell_words_at(masked, start)) for start in candidates)
- def _heredoc_specs(line: str) -> list[_Heredoc]:
- """Heredoc openers on one command line, with their ``<<`` offsets."""
- specs: list[_Heredoc] = []
- quote: str | None = None
- index = 0
- while index < len(line):
- char = line[index]
- if quote:
- if char == "\\" and quote == '"' and index + 1 < len(line):
- index += 1 # skip the escaped character too
- elif char == quote:
- quote = None
- elif char in "'\"":
- quote = char
- if quote or not line.startswith("<<", index) or line.startswith("<<<", index):
- index += 1
- continue
- opener = _HEREDOC_OPENER_RE.match(line, index)
- if opener is None: # unterminated quoted delimiter: give up on this line
- break
- start, index = index, opener.end()
- delimiter = opener.group("quoted") if opener.group("q") else opener.group("bare")
- if delimiter:
- specs.append(_Heredoc(delimiter, bool(opener.group("dash")), start))
- return specs
- def _join_continued_line(lines: list[str], index: int) -> tuple[str, int]:
- """Physical line ``index`` plus every line a trailing ``\\`` joins onto it -> (line, next).
- The shell removes backslash-newline before it reads anything else, so the heredoc body only
- starts after the joined line: ``cat <<EOF | \\`` + ``bash`` pipes the body into bash. The pair
- is blanked (offsets preserved) so the joined text reads as one command line."""
- line = lines[index]
- index += 1
- while index < len(lines):
- text = line.rstrip("\r\n")
- newline = line[len(text):]
- if not newline or (len(text) - len(text.rstrip("\\"))) % 2 == 0:
- break
- line = text[:-1] + " " * (1 + len(newline)) + lines[index]
- index += 1
- return line, index
- def _mask_heredocs(command: str) -> tuple[str, list[_Heredoc]]:
- """Blank heredoc bodies -> (masked command, heredocs with their bodies). Unterminated heredocs
- run to end of input and are still reported."""
- output: list[str] = []
- offset = 0
- pending: list[_Heredoc] = []
- finished: list[_Heredoc] = []
- lines = command.splitlines(keepends=True)
- index = 0
- while index < len(lines):
- if not pending:
- line, index = _join_continued_line(lines, index)
- for spec in _heredoc_specs(line):
- spec.opener += offset
- pending.append(spec)
- output.append(line)
- offset += len(line)
- continue
- line = lines[index]
- index += 1
- current = pending[0]
- candidate = line.rstrip("\r\n")
- if (candidate.lstrip("\t") if current.strip_tabs else candidate) == current.delimiter:
- finished.append(pending.pop(0))
- else:
- current.body.append(line)
- output.append(re.sub(r"[^\r\n]", " ", line))
- offset += len(line)
- return "".join(output), finished + pending
- def _record_alias(config: str, aliases: dict[str, str]) -> None:
- """Record an inline ``-c alias.<name>=<value>`` git config override."""
- key, sep, value = config.partition("=")
- if sep and key.lower().startswith("alias."):
- aliases[key[6:].lower()] = value
- def _git_target_and_subcommand(
- args: list[str], current_dir: Path, env: dict[str, str],
- ) -> tuple[Path, str | None, list[str], dict[str, str]]:
- """Parse git's global options -> (target dir, subcommand, sub args, inline aliases)."""
- target = current_dir
- work_tree: str | None = None
- aliases: dict[str, str] = {}
- index = 0
- while index < len(args):
- arg = args[index]
- if arg == "--":
- index += 1
- break
- if not arg.startswith("-"):
- break
- # Separate-argument form (`-C dir`) vs attached form (`-Cdir`, `--work-tree=dir`, `-cK=V`).
- if arg in _GIT_GLOBAL_OPTIONS_WITH_ARG:
- option, value = arg, args[index + 1] if index + 1 < len(args) else None
- index += 2
- else:
- option, value = next(((o, arg[len(o):]) for o in ("-C", "--work-tree=", "-c")
- if arg.startswith(o) and len(arg) > len(o)), (None, None))
- index += 1
- if option == "-C" and value is not None:
- target = _resolve(value, target)
- elif option and option.startswith("--work-tree") and value is not None:
- work_tree = value
- elif option == "-c" and value is not None:
- _record_alias(value, aliases) # only alias.* overrides matter; others are ignored
- explicit_work_tree = work_tree or env.get("GIT_WORK_TREE")
- if explicit_work_tree:
- target = _resolve(explicit_work_tree, target)
- return target, args[index].lower() if index < len(args) else None, args[index + 1 :], aliases
- def _has_flag(args: list[str], long: str, letter: str, short_only: bool = False) -> bool:
- """``--long`` present, or ``letter`` inside a dash-prefixed arg (``-fdn``; ``short_only``
- additionally excludes ``--`` args from the letter scan)."""
- return any(
- arg == long or (arg.startswith("-") and letter in arg[1:]
- and not (short_only and arg.startswith("--")))
- for arg in args)
- # Subcommands whose worktree impact depends on their arguments -> predicate(args).
- _CONDITIONAL_MUTATIONS: dict[str, Callable[[list[str]], bool]] = {
- "reset": lambda args: any(
- arg in _RESET_WORKTREE_MODES or _RESET_HARD_RE.fullmatch(arg) for arg in args),
- "stash": lambda args: next(
- (arg for arg in args if not arg.startswith("-")), "push") not in _STASH_SAFE_ACTIONS,
- "clean": lambda args: not _has_flag(args, "--dry-run", "n", short_only=True),
- # `restore` touches the worktree unless ONLY --staged was requested.
- "restore": lambda args: (_has_flag(args, "--worktree", "W")
- or not _has_flag(args, "--staged", "S"))}
- def _mutates_worktree(subcommand: str, args: list[str]) -> bool:
- check = _CONDITIONAL_MUTATIONS.get(subcommand, lambda _args: subcommand in _WORKTREE_MUTATIONS)
- return check(args)
- def _inspect_git_worktree(args: list[str], cwd: Path, root: Path) -> str | None:
- """Block `worktree remove|move` aimed at the running root, from any directory."""
- action_index = _consume_options(args, 0)
- action = args[action_index].lower() if action_index < len(args) else None
- target_index = _consume_options(args, action_index + 1)
- if (action in _WORKTREE_TARGET_ACTIONS and target_index < len(args)
- and _resolve(args[target_index], cwd) == root):
- return f"git worktree {action}"
- return None
- def _read_git_alias(executable: str, target: Path, alias: str) -> str | None:
- with contextlib.suppress(OSError, subprocess.SubprocessError):
- result = subprocess.run(
- [executable, "-C", str(target), "config", "--get", f"alias.{alias}"],
- stdin=subprocess.DEVNULL, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=1, check=False)
- return (result.stdout.strip() or None) if result.returncode == 0 else None
- return None
- def _inspect_git(
- executable: str, args: list[str], current_dir: Path, env: dict[str, str], root: Path, depth: int
- ) -> str | None:
- target, subcommand, sub_args, inline_aliases = _git_target_and_subcommand(
- args, current_dir, env)
- if subcommand is None:
- return None
- if subcommand == "worktree": # names its victim as an argument: the cwd check does not apply
- return _inspect_git_worktree(sub_args, target, root)
- if not _is_within(target, root):
- return None
- if _mutates_worktree(subcommand, sub_args):
- return f"git {subcommand}"
- if subcommand in _KNOWN_GIT_BUILTINS or depth >= _MAX_RECURSION:
- return None
- alias = (inline_aliases[subcommand] if subcommand in inline_aliases
- else _read_git_alias(executable, target, subcommand))
- if not alias:
- return None
- if alias.startswith("!"): # shell alias: scan it as a command
- return _find_mutation(alias[1:], target, root, depth + 1)
- try:
- alias_args = shlex.split(alias, posix=True)
- except ValueError:
- return None
- return _inspect_git(executable, [*alias_args, *sub_args], target, {}, root, depth + 1)
- def _inspect_github_cli(
- executable: str, args: list[str], current_dir: Path, env: dict[str, str], root: Path, depth: int
- ) -> str | None:
- if not _is_within(current_dir, root):
- return None
- index = _consume_options(args, 0, frozenset({"-R", "--repo", "--hostname"}))
- is_checkout = args[index : index + 2] == ["pr", "checkout"]
- return f"{_executable_name(executable)} pr checkout" if is_checkout else None
- def _inspect_shell(
- executable: str, args: list[str], current_dir: Path, env: dict[str, str], root: Path, depth: int
- ) -> str | None:
- script = _shell_script_arg(args)
- return _find_mutation(script, current_dir, root, depth + 1) if script else None
- # executable name -> inspector(executable, args, current_dir, env, root, depth)
- _INSPECTORS: dict[str, Callable[..., str | None]] = {
- "git": _inspect_git, "gh": _inspect_github_cli, "hub": _inspect_github_cli,
- **{shell: _inspect_shell for shell in _SHELL_EXECUTABLES}}
- def _find_mutation(command: str, cwd: Path, root: Path, depth: int = 0) -> str | None:
- """Name of the first command in ``command`` that would rewrite ``root``, else None."""
- if depth > _MAX_RECURSION:
- return None
- masked_command, heredocs = _mask_heredocs(command)
- starts = sorted(set(_iter_shell_command_starts(masked_command)))
- scopes = _scope_keys(masked_command, [*starts, *(heredoc.opener for heredoc in heredocs)])
- # Bodies a bare shell reads (`bash <<EOF`, `cat <<EOF | bash`) are scripts: scan them.
- for heredoc in heredocs:
- if _shell_consumes_heredoc(masked_command, starts, scopes, heredoc.opener) and (
- operation := _find_mutation("".join(heredoc.body), cwd, root, depth + 1)):
- return operation
- # cwd per subshell scope; `cd` applies to the NEXT command only via `&&`, `;`, newline.
- cwd_by_scope: dict[tuple[int, ...], Path] = {(): cwd}
- pending_cd: dict[tuple[int, ...], Path] = {}
- for start in starts:
- scope = scopes[start]
- cwd_by_scope.setdefault(scope, cwd_by_scope.get(scope[:-1], cwd))
- pending = pending_cd.pop(scope, None)
- if pending is not None and _operator_before(masked_command, start) in {"&&", ";", "\n"}:
- cwd_by_scope[scope] = pending
- env, executable, args = _command_parts(_shell_words_at(masked_command, start))
- if executable is None:
- continue
- current_dir = cwd_by_scope[scope]
- if (cd_target := _cd_target(executable, args, current_dir)) is not None:
- pending_cd[scope] = cd_target
- elif (inspect := _INSPECTORS.get(_executable_name(executable))) and (
- operation := inspect(executable, args, current_dir, env, root, depth)):
- return operation
- return None
- def guard_active() -> bool:
- """Windows-only: NTFS locks loaded .py/.pyd files, so overwriting the live checkout can
- corrupt the running process. On POSIX open handles keep the old inode alive; the mixed-module
- hazard is limited to later lazy imports — not worth blocking every git workflow for."""
- return os.name == "nt"
- def detect_self_repo_git_mutation(
- command: str, cwd: str | None, source_root: Path | None = None) -> tuple[bool, str | None]:
- """-> (blocked, message): whether a command would rewrite the live source checkout."""
- root = source_root if source_root is not None else get_running_source_root()
- if root is None or not command:
- return False, None
- root = _resolve(str(root), Path("/"))
- operation = _find_mutation(command, _resolve(cwd or "/", Path("/")), root)
- return (True, _block_message(operation, root)) if operation is not None else (False, None)
- def _block_message(operation: str, root: Path) -> str:
- hermes_home = os.environ.get("HERMES_HOME", "").strip()
- scratch = (Path(hermes_home).expanduser() if hermes_home else Path.home() / ".hermes") / "scratch"
- return (
- f"Blocked: `{operation}` would rewrite Hermes's live source checkout "
- f"({root}) and can mix module versions in this running process. "
- f"Use a separate worktree or a shared clone on real disk, e.g. "
- f"`git clone --shared {root} {scratch}/<task>` — avoid /tmp for " # no-tmp: ok — guidance telling the model to AVOID /tmp
- "clones that install node/python deps: /tmp is usually RAM-backed tmpfs and a few " # no-tmp: ok — guidance telling the model to AVOID /tmp
- "dependency installs can fill it and ENOSPC other work. Delete the clone when the branch "
- "is pushed. To change this checkout, stop Hermes, run the command externally, then restart "
- "Hermes.")
|