claude-dev-env 1.89.0 → 1.92.0

package/hooks/blocking/test_volatile_path_in_post_blocker.py

@@ -0,0 +1,210 @@
+"""Unit and integration tests for the volatile_path_in_post_blocker PreToolUse hook."""
+
+import importlib.util
+import json
+import pathlib
+import subprocess
+import sys
+
+_HOOK_DIR = pathlib.Path(__file__).parent
+if str(_HOOK_DIR) not in sys.path:
+    sys.path.insert(0, str(_HOOK_DIR))
+
+hook_spec = importlib.util.spec_from_file_location(
+    "volatile_path_in_post_blocker",
+    _HOOK_DIR / "volatile_path_in_post_blocker.py",
+)
+assert hook_spec is not None
+assert hook_spec.loader is not None
+hook_module = importlib.util.module_from_spec(hook_spec)
+hook_spec.loader.exec_module(hook_module)
+
+scan_text_for_volatile_marker = hook_module.scan_text_for_volatile_marker
+extract_gh_post_body_texts = hook_module.extract_gh_post_body_texts
+extract_mcp_body_texts = hook_module.extract_mcp_body_texts
+_collect_body_texts = hook_module._collect_body_texts
+
+
+def _body_names_volatile_path(tool_name: str, tool_input: dict[str, object]) -> bool:
+    all_body_texts = _collect_body_texts(tool_name, tool_input)
+    return hook_module._first_volatile_marker(all_body_texts) is not None
+
+
+def test_scan_detects_job_scratch_path_backslash() -> None:
+    text = r"See C:\Users\jon\.claude-editor\jobs\95762cea\tmp\staging\contact_sheet.png"
+    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+
+
+def test_scan_detects_job_scratch_path_forward_slash() -> None:
+    text = "artifact at /home/user/.claude-editor/jobs/abc/tmp/out.png"
+    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+
+
+def test_scan_detects_worktree_path() -> None:
+    text = r"edited .claude\worktrees\feature\file.py"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_detects_appdata_temp_case_insensitive() -> None:
+    text = r"C:\Users\jon\AppData\Local\Temp\bugteam\worktree"
+    assert scan_text_for_volatile_marker(text) == "appdata/local/temp"
+
+
+def test_scan_detects_unix_tmp() -> None:
+    assert scan_text_for_volatile_marker("output written to /tmp/run/out.log") == "/tmp/"
+
+
+def test_scan_detects_percent_temp_token() -> None:
+    assert scan_text_for_volatile_marker("saved to %TEMP%\\out.txt") == "%temp%"
+
+
+def test_scan_detects_env_temp_token() -> None:
+    assert scan_text_for_volatile_marker("path is $env:TEMP\\out.txt") == "$env:temp"
+
+
+def test_scan_detects_claude_job_dir_token() -> None:
+    assert scan_text_for_volatile_marker("see $CLAUDE_JOB_DIR/staging/report.md") == "$claude_job_dir"
+
+
+def test_scan_clean_body_returns_none() -> None:
+    text = "The failing table is pasted below:\n| case | result |\n| a | pass |"
+    assert scan_text_for_volatile_marker(text) is None
+
+
+def test_gh_comment_with_job_scratch_path_is_blocked() -> None:
+    command = (
+        'gh pr comment 669 --body "Contact sheet at '
+        r'C:\Users\jon\.claude-editor\jobs\95762cea\tmp\staging\contact_sheet.png"'
+    )
+    assert _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_gh_comment_with_clean_body_is_allowed() -> None:
+    command = 'gh pr comment 669 --body "All checks pass. Table pasted inline above."'
+    assert not _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_gh_pr_create_short_flag_blocked() -> None:
+    command = 'gh pr create --title "T" -b "logs under /tmp/run/out.log"'
+    assert _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_gh_issue_create_body_equals_form_blocked() -> None:
+    command = 'gh issue create --title "T" --body="dump in %TEMP%\\dump.json"'
+    assert _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_body_file_content_is_scanned_and_blocked(tmp_path: pathlib.Path) -> None:
+    body_file = tmp_path / "body.md"
+    body_file.write_text(
+        "Artifact: $CLAUDE_JOB_DIR/tmp/contact_sheet.png",
+        encoding="utf-8",
+    )
+    command = f"gh pr comment 669 --body-file {body_file}"
+    assert _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_body_file_clean_content_is_allowed(tmp_path: pathlib.Path) -> None:
+    body_file = tmp_path / "body.md"
+    body_file.write_text("Everything is green. Results inline above.", encoding="utf-8")
+    command = f"gh pr comment 669 --body-file {body_file}"
+    assert not _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_non_post_gh_command_is_untouched() -> None:
+    assert not _body_names_volatile_path("Bash", {"command": "gh pr list --repo owner/repo"})
+
+
+def test_gh_pr_view_with_tmp_in_flag_is_untouched() -> None:
+    command = "gh pr view 10 --json body --jq .body > /tmp/out.json"
+    assert not _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_substring_mention_of_gh_post_does_not_classify() -> None:
+    command = 'echo "example: gh pr comment 42 --body \\"see /tmp/x\\"" >> notes.txt'
+    assert not _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_gh_word_not_first_token_does_not_classify() -> None:
+    command = r'echo gh pr comment 42 --body "see C:\.claude-editor\jobs\x"'
+    assert not _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_env_assignment_prefix_still_classifies() -> None:
+    command = 'GH_TOKEN=abc gh pr comment 669 --body "log at /tmp/run.log"'
+    assert _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_unparseable_command_is_allowed() -> None:
+    assert not _body_names_volatile_path(
+        "Bash", {"command": "gh pr comment 1 --body 'unterminated"}
+    )
+
+
+def test_mcp_issue_comment_body_blocked() -> None:
+    tool_input: dict[str, object] = {"body": "artifact at $CLAUDE_JOB_DIR/tmp/out.png"}
+    assert _body_names_volatile_path("mcp__plugin_github_github__add_issue_comment", tool_input)
+
+
+def test_mcp_review_comment_param_blocked() -> None:
+    tool_input: dict[str, object] = {"comment": r"see .claude\worktrees\x\file"}
+    assert _body_names_volatile_path(
+        "mcp__plugin_github_github__add_reply_to_pull_request_comment", tool_input
+    )
+
+
+def test_mcp_clean_body_allowed() -> None:
+    tool_input: dict[str, object] = {"body": "LGTM, results pasted inline."}
+    assert not _body_names_volatile_path("mcp__plugin_github_github__add_issue_comment", tool_input)
+
+
+def test_mcp_read_tool_without_body_allowed() -> None:
+    tool_input: dict[str, object] = {"pullNumber": 10}
+    assert not _body_names_volatile_path("mcp__plugin_github_github__pull_request_read", tool_input)
+
+
+def test_extract_mcp_body_texts_skips_non_string_values() -> None:
+    tool_input: dict[str, object] = {"body": None, "comment": 42}
+    assert extract_mcp_body_texts(tool_input) == []
+
+
+def test_extract_gh_post_body_texts_returns_inline_and_file(tmp_path: pathlib.Path) -> None:
+    body_file = tmp_path / "b.md"
+    body_file.write_text("file body text", encoding="utf-8")
+    command = f'gh pr create --title "T" --body "inline body" --body-file {body_file}'
+    all_texts = extract_gh_post_body_texts(command)
+    assert "inline body" in all_texts
+    assert "file body text" in all_texts
+
+
+def test_hook_subprocess_denies_volatile_gh_comment() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {
+            "command": 'gh pr comment 669 --body "art at $CLAUDE_JOB_DIR/tmp/x.png"',
+        },
+    }
+    completion = subprocess.run(
+        [sys.executable, str(_HOOK_DIR / "volatile_path_in_post_blocker.py")],
+        input=json.dumps(payload),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    decision = json.loads(completion.stdout)
+    assert decision["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_hook_subprocess_allows_clean_gh_comment() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": 'gh pr comment 669 --body "all green, results inline"'},
+    }
+    completion = subprocess.run(
+        [sys.executable, str(_HOOK_DIR / "volatile_path_in_post_blocker.py")],
+        input=json.dumps(payload),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert completion.stdout.strip() == ""

package/hooks/blocking/verdict_directory_write_blocker.py

@@ -41,6 +41,12 @@ hooks_directory = str(Path(__file__).resolve().parent.parent)
 if hooks_directory not in sys.path:
     sys.path.append(hooks_directory)
 
+from verified_commit_config_bootstrap import (  # noqa: E402
+    register_verified_commit_constants,
+)
+
+register_verified_commit_constants()
+
 from config.verified_commit_constants import (  # noqa: E402
     ALL_GATED_TOOL_NAMES,
     ALL_VERDICT_PATH_SEGMENT_BODIES,

package/hooks/blocking/verification_verdict_store.py

@@ -25,14 +25,22 @@ blocking_directory = str(Path(__file__).resolve().parent)
 if blocking_directory not in sys.path:
     sys.path.insert(0, blocking_directory)
 
+from verified_commit_config_bootstrap import (  # noqa: E402
+    register_verified_commit_constants,
+)
+
+register_verified_commit_constants()
+
 from config.verified_commit_constants import (
     AGENT_META_SIDECAR_SUFFIX,
     AGENT_META_TYPE_KEY,
     AGENT_TRANSCRIPT_GLOB,
     BRANCH_REFERENCE_PREFIX,
+    BRANCH_REMOTE_CONFIG_KEY_TEMPLATE,
     BRANCH_WORKTREE_ABSENT_MESSAGE,
     CLAUDE_HOME_DIRECTORY_NAME,
     CONFTEST_FILE_NAME,
+    DETACHED_HEAD_LABEL,
     DOCS_ONLY_EXTENSIONS,
     ALL_FALLBACK_BASE_REFERENCES,
     EMPTY_SURFACE_GUARD_MESSAGE,
@@ -122,13 +130,65 @@ def _tracked_upstream_reference(repo_root: str) -> str | None:
     )
 
 
+def _head_branch_name(repo_root: str) -> str | None:
+    """Read the short name of the branch HEAD points at.
+
+    Args:
+        repo_root: The repository top-level directory.
+
+    Returns:
+        The short branch name, or None when HEAD is detached or git fails.
+    """
+    branch_name = run_git(repo_root, "rev-parse", "--abbrev-ref", "HEAD")
+    if not branch_name or branch_name == DETACHED_HEAD_LABEL:
+        return None
+    return branch_name
+
+
+def _upstream_is_own_remote_counterpart(repo_root: str, tracked_upstream: str) -> bool:
+    """Decide whether HEAD's upstream is the current branch's own remote ref.
+
+    ::
+
+        branch feature  tracks origin/feature   -> True   (own counterpart)
+        branch feature  tracks origin/develop   -> False  (different branch)
+
+    A branch tracking its own remote counterpart makes the merge base against
+    that ref resolve to the branch tip itself, masking the branch's real state
+    versus the default branch — so the caller ranks that ref below the
+    default-branch fallbacks.
+
+    Args:
+        repo_root: The repository top-level directory.
+        tracked_upstream: HEAD's configured upstream tracking reference.
+
+    Returns:
+        True when the upstream names ``<remote>/<current-branch>``; False when
+        it names a different branch, HEAD is detached, or git fails.
+    """
+    branch_name = _head_branch_name(repo_root)
+    if branch_name is None:
+        return False
+    configured_remote = run_git(
+        repo_root, "config", BRANCH_REMOTE_CONFIG_KEY_TEMPLATE.format(branch_name=branch_name)
+    )
+    if not configured_remote:
+        return False
+    return tracked_upstream == f"{configured_remote}/{branch_name}"
+
+
 def candidate_base_references(repo_root: str) -> tuple[str, ...]:
     """Collect the upstream references to probe for the merge base, in order.
 
-    Probes ``origin/HEAD`` first, then HEAD's configured upstream tracking
-    reference (so a non-standard default branch like ``origin/develop`` is
-    found regardless of its name), then the fixed ``origin/main`` /
-    ``origin/master`` fallbacks for checkouts with no tracking ref set.
+    Probes ``origin/HEAD`` first, then a tracked upstream that names a
+    different branch (so a differently-named default like ``origin/develop`` is
+    found), then the fixed ``origin/main`` / ``origin/master`` fallbacks. A
+    tracked upstream that is the current branch's own remote counterpart
+    (``origin/<current-branch>``) ranks last, below the fallbacks: on a PR
+    branch whose fork carries ``origin/main`` the merge base comes from
+    ``origin/main`` rather than the branch's stale pushed ref, while a repo
+    whose default branch is the tracked branch itself (no ``origin/main`` or
+    ``origin/master`` present) still falls through to that own-counterpart ref.
 
     Args:
         repo_root: The repository top-level directory.
@@ -138,10 +198,18 @@ def candidate_base_references(repo_root: str) -> tuple[str, ...]:
     """
     upstream_head = run_git(repo_root, "symbolic-ref", "--quiet", "refs/remotes/origin/HEAD")
     tracked_upstream = _tracked_upstream_reference(repo_root)
+    high_priority_upstream: tuple[str, ...] = ()
+    demoted_upstream: tuple[str, ...] = ()
+    if tracked_upstream:
+        if _upstream_is_own_remote_counterpart(repo_root, tracked_upstream):
+            demoted_upstream = (tracked_upstream,)
+        else:
+            high_priority_upstream = (tracked_upstream,)
     ordered_references = (
         ((upstream_head,) if upstream_head else ())
-        + ((tracked_upstream,) if tracked_upstream else ())
+        + high_priority_upstream
         + ALL_FALLBACK_BASE_REFERENCES
+        + demoted_upstream
     )
     return tuple(dict.fromkeys(ordered_references))
 

package/hooks/blocking/verified_commit_config_bootstrap.py

@@ -0,0 +1,51 @@
+"""Deterministic loader for the verified-commit constants module.
+
+The blocking hooks import their shared constants as
+``from config.verified_commit_constants import ...``. In the installed hook
+tree a second, unrelated ``config`` package can sit ahead of this package on
+``sys.path`` and win that dotted name by path order, so the import binds to the
+wrong file and raises ImportError on any constant the stale copy lacks. This
+module binds the dotted name to the sibling ``config/verified_commit_constants``
+file by explicit location, so resolution never depends on ``sys.path`` order.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+
+def register_verified_commit_constants() -> None:
+    """Bind ``config.verified_commit_constants`` to the sibling config file.
+
+    ::
+
+        sys.path = ["<installed hooks>", "<blocking>"]  # foreign config first
+        register_verified_commit_constants()
+        from config.verified_commit_constants import DETACHED_HEAD_LABEL
+        ok: bound to <blocking>/config/verified_commit_constants.py
+
+    A ``from config.verified_commit_constants import`` that follows this call
+    reads the entry straight from ``sys.modules``, so it resolves to this file
+    whatever else owns the ``config`` name. An entry already cached is left in
+    place, so the call is idempotent and never displaces a module a caller
+    loaded on purpose.
+
+    Returns:
+        None. The effect is the ``sys.modules`` registration.
+    """
+    config_module_dotted_name = "config.verified_commit_constants"
+    if config_module_dotted_name in sys.modules:
+        return
+    constants_file_path = (
+        Path(__file__).resolve().parent / "config" / "verified_commit_constants.py"
+    )
+    module_spec = importlib.util.spec_from_file_location(
+        config_module_dotted_name, constants_file_path
+    )
+    if module_spec is None or module_spec.loader is None:
+        return
+    constants_module = importlib.util.module_from_spec(module_spec)
+    sys.modules[config_module_dotted_name] = constants_module
+    module_spec.loader.exec_module(constants_module)

package/hooks/blocking/verified_commit_gate.py

@@ -42,6 +42,12 @@ _hooks_dir = str(Path(__file__).resolve().parent.parent)
 if _hooks_dir not in sys.path:
     sys.path.insert(0, _hooks_dir)
 
+from verified_commit_config_bootstrap import (  # noqa: E402
+    register_verified_commit_constants,
+)
+
+register_verified_commit_constants()
+
 from config.verified_commit_constants import (
     ALL_GIT_BINARY_NAMES,
     CORRECTIVE_MESSAGE,

package/hooks/blocking/verifier_verdict_minter.py

@@ -35,6 +35,12 @@ blocking_directory = str(Path(__file__).resolve().parent)
 if blocking_directory not in sys.path:
     sys.path.insert(0, blocking_directory)
 
+from verified_commit_config_bootstrap import (  # noqa: E402
+    register_verified_commit_constants,
+)
+
+register_verified_commit_constants()
+
 from config.verified_commit_constants import (
     MINTING_AGENT_TYPE,
     VERDICT_KEY_MANIFEST_SHA256,