claude-dev-env 2.30.1 → 2.31.0

package/hooks/blocking/test_code_rules_enforcer_split_constants_config.py

@@ -6,6 +6,8 @@ import sys
 from pathlib import Path
 from types import SimpleNamespace
 
+import pytest
+
 _BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
 _HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
 if _BLOCKING_DIRECTORY not in sys.path:
@@ -103,7 +105,19 @@ def test_scan_function_body_constants_does_not_flag_module_level() -> None:
     assert advisory_issues == []
 
 
-def test_advisory_should_not_flag_class_attribute_after_method_def() -> None:
+def _advisory_stderr(source: str, capsys: pytest.CaptureFixture[str]) -> str:
+    """Run the advisory check over source and hand back what it wrote to stderr.
+
+    The check returns nothing, so stderr is the only place a finding shows up.
+    """
+    code_rules_enforcer.check_constants_outside_config_advisory(
+        source,
+        "example_module.py",
+    )
+    return capsys.readouterr().err
+
+
+def test_advisory_should_not_flag_class_attribute_after_method_def(capsys: pytest.CaptureFixture[str]) -> None:
     source_with_class_attribute_after_method = (
         "class ExampleModel:\n"
         "    def method_a(self) -> None:\n"
@@ -111,49 +125,40 @@ def test_advisory_should_not_flag_class_attribute_after_method_def() -> None:
         "\n"
         "    TABLE_NAME = \"example\"\n"
     )
-    advisory_issues = code_rules_enforcer.check_constants_outside_config_advisory(
-        source_with_class_attribute_after_method,
-        "example_module.py",
-    )
-    assert advisory_issues == [], (
+    flagged_names = _advisory_stderr(source_with_class_attribute_after_method, capsys)
+    assert flagged_names == "", (
         "Class-level TABLE_NAME attribute must not be flagged as function-local"
     )
 
 
-def test_advisory_should_still_flag_actual_method_body_constant() -> None:
+def test_advisory_should_still_flag_actual_method_body_constant(capsys: pytest.CaptureFixture[str]) -> None:
     source_with_method_body_constant = (
         "class ExampleModel:\n"
         "    def method_a(self) -> None:\n"
         "        MAXIMUM_RETRIES = 3\n"
         "        return None\n"
     )
-    advisory_issues = code_rules_enforcer.check_constants_outside_config_advisory(
-        source_with_method_body_constant,
-        "example_module.py",
-    )
-    assert len(advisory_issues) == 1, (
-        "Method-body UPPER_SNAKE constant must still surface as advisory"
+    flagged_names = _advisory_stderr(source_with_method_body_constant, capsys)
+    assert "MAXIMUM_RETRIES" in flagged_names, (
+        f"Method-body UPPER_SNAKE constant must still surface as advisory, "
+        f"got: {flagged_names!r}"
     )
-    assert "MAXIMUM_RETRIES" in advisory_issues[0]
 
 
-def test_advisory_should_flag_annotated_function_body_constant() -> None:
+def test_advisory_should_flag_annotated_function_body_constant(capsys: pytest.CaptureFixture[str]) -> None:
     source_with_annotated_function_body_constant = (
         "def example_function() -> None:\n"
         "    MAXIMUM_RETRIES: int = 3\n"
         "    return None\n"
     )
-    advisory_issues = code_rules_enforcer.check_constants_outside_config_advisory(
-        source_with_annotated_function_body_constant,
-        "example_module.py",
+    flagged_names = _advisory_stderr(source_with_annotated_function_body_constant, capsys)
+    assert "MAXIMUM_RETRIES" in flagged_names, (
+        f"Annotated function-body UPPER_SNAKE constant (PEP 526) must surface as advisory, "
+        f"got: {flagged_names!r}"
     )
-    assert len(advisory_issues) == 1, (
-        "Annotated function-body UPPER_SNAKE constant (PEP 526) must surface as advisory"
-    )
-    assert "MAXIMUM_RETRIES" in advisory_issues[0]
 
 
-def test_advisory_should_flag_outer_constants_after_nested_def() -> None:
+def test_advisory_should_flag_outer_constants_after_nested_def(capsys: pytest.CaptureFixture[str]) -> None:
     source_with_nested_def = (
         "def outer():\n"
         "    OUTER_CONST = 1\n"
@@ -161,11 +166,7 @@ def test_advisory_should_flag_outer_constants_after_nested_def() -> None:
         "        INNER_CONST = 2\n"
         "    ANOTHER_OUTER = 3\n"
     )
-    advisory_issues = code_rules_enforcer.check_constants_outside_config_advisory(
-        source_with_nested_def,
-        "example_module.py",
-    )
-    flagged_names = " ".join(advisory_issues)
+    flagged_names = _advisory_stderr(source_with_nested_def, capsys)
     assert "OUTER_CONST" in flagged_names, (
         "OUTER_CONST before nested def must be flagged"
     )

package/hooks/blocking/test_code_rules_enforcer_split_entry_2.py

@@ -36,6 +36,8 @@ code_rules_enforcer = SimpleNamespace(
     validate_content=validate_content,
 )
 
+pytestmark = pytest.mark.usefixtures("ephemeral_exempt_off")
+
 
 def _oversized_function_source(name: str) -> str:
     body_line_count = code_rules_enforcer.FUNCTION_LENGTH_BLOCKING_THRESHOLD - 1

package/hooks/blocking/test_code_rules_enforcer_stage.py

@@ -33,6 +33,8 @@ from code_rules_gate_parts.tests._repo_test_helpers import (  # noqa: E402
     write_commit_and_stage_change,
 )
 
+pytestmark = pytest.mark.usefixtures("ephemeral_exempt_off")
+
 
 PRODUCTION_FILE_PATH = "packages/app/services.py"
 ENFORCER_SCRIPT_PATH = Path(__file__).with_name("code_rules_enforcer.py")

package/hooks/blocking/test_code_rules_enforcer_zero_payload_alias_hook_routing.py

@@ -36,6 +36,8 @@ from code_rules_enforcer_test_support import (  # noqa: E402
     run_write_entrypoint,
 )
 
+pytestmark = pytest.mark.usefixtures("ephemeral_exempt_off")
+
 PASS_THROUGH_ALIAS_SOURCE = (
     "def find_bare_path_segments(content: str) -> set[str]:\n"
     "    return {part for part in content.split() if part}\n"

package/hooks/blocking/test_codex_apply_patch.py

@@ -0,0 +1,43 @@
+"""Tests for the Codex apply_patch path-only target resolver."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codex_apply_patch import (
+    CODEX_ADD_OPERATION,
+    CodexPatchError,
+    codex_patch_operation_targets,
+)
+
+
+def test_codex_patch_operation_targets_names_every_section_without_reading_content(
+    tmp_path: Path, three_operation_patch: str
+) -> None:
+    """The path-only helper resolves every section's target without any disk read.
+
+    Unlike ``parse_codex_apply_patch``, it never reads prior file content, so a
+    caller that only needs each target path is not tripped up by an unreadable
+    prior file.
+    """
+    all_targets = codex_patch_operation_targets(three_operation_patch, str(tmp_path))
+
+    all_target_names = {
+        (each_operation, str(each_path).rsplit("/", 1)[-1])
+        for each_operation, each_path in all_targets
+    }
+    assert all_target_names == {
+        ("update", "updated.py"),
+        (CODEX_ADD_OPERATION, "added.py"),
+        ("delete", "deleted.py"),
+    }
+
+
+def test_codex_patch_operation_targets_rejects_path_traversal(tmp_path: Path) -> None:
+    """A patch path that escapes the working directory is rejected before any read."""
+    escaping_patch = "*** Begin Patch\n*** Add File: ../outside.py\n+content\n*** End Patch"
+
+    with pytest.raises(CodexPatchError):
+        codex_patch_operation_targets(escaping_patch, str(tmp_path))

package/hooks/blocking/test_duplicate_rmtree_helper_blocker.py

@@ -205,6 +205,74 @@ def test_extract_payload_text_returns_empty_for_unknown_tool() -> None:
     assert extracted == ("", "")
 
 
+def test_every_applicable_tool_name_reads_payload_text() -> None:
+    """extract_payload_text reads content for every name the shared constant lists."""
+    for each_applicable_tool_name in hook_module.ALL_APPLICABLE_TOOL_NAMES:
+        _file_path, scanned_text = extract_payload_text(
+            each_applicable_tool_name,
+            {
+                "file_path": "foo.py",
+                "content": "abc",
+                "new_string": "abc",
+                "edits": [{"old_string": "a", "new_string": "abc"}],
+            },
+        )
+        assert scanned_text, f"{each_applicable_tool_name} must read some scanned text"
+
+
+def test_extract_payload_text_reads_every_multi_edit_new_string() -> None:
+    extracted = extract_payload_text(
+        "MultiEdit",
+        {
+            "file_path": "foo.py",
+            "edits": [
+                {"old_string": "a = 1", "new_string": "a = 11"},
+                {"old_string": "b = 2", "new_string": "def force_rmtree(target_path):\n    pass"},
+            ],
+        },
+    )
+    assert extracted[0] == "foo.py"
+    assert "force_rmtree" in extracted[1]
+
+
+def test_main_blocks_trio_copy_introduced_by_second_multi_edit() -> None:
+    """A helper definition in the second edit of a MultiEdit is caught, not only the first."""
+    stdout_text, exit_code = _run_hook(
+        {
+            "tool_name": "MultiEdit",
+            "tool_input": {
+                "file_path": "shared_utils/samsung_utils/cert_failure_processor/parser.py",
+                "edits": [
+                    {"old_string": "a = 1", "new_string": "a = 11"},
+                    {"old_string": "b = 2", "new_string": COPIED_TRIO},
+                ],
+            },
+        }
+    )
+    assert exit_code == 0
+    response_payload = json.loads(stdout_text)
+    decision_block = response_payload["hookSpecificOutput"]
+    assert decision_block["permissionDecision"] == "deny"
+    assert "duplicate-rmtree-helper" in decision_block["permissionDecisionReason"]
+
+
+def test_main_allows_clean_multi_edit() -> None:
+    stdout_text, exit_code = _run_hook(
+        {
+            "tool_name": "MultiEdit",
+            "tool_input": {
+                "file_path": "shared_utils/samsung_utils/cert_failure_processor/parser.py",
+                "edits": [
+                    {"old_string": "a = 1", "new_string": "a = 11"},
+                    {"old_string": "b = 2", "new_string": "b = 22"},
+                ],
+            },
+        }
+    )
+    assert exit_code == 0
+    assert stdout_text == ""
+
+
 def _run_hook_with_stdin_text(stdin_text: str) -> tuple[str, str, int]:
     captured_stdout = io.StringIO()
     captured_stderr = io.StringIO()

package/hooks/blocking/test_hook_prose_detector_consistency.py

@@ -193,6 +193,16 @@ def test_written_content_reads_edit_new_string() -> None:
     assert written_content("Edit", edit_input) == "edited body"
 
 
+def test_written_content_reads_every_multi_edit_new_string() -> None:
+    multi_edit_input = {
+        "edits": [
+            {"old_string": "a = 1", "new_string": "a = 11"},
+            {"old_string": "b = 2", "new_string": _OVERSTATED_MESSAGE_MODULE},
+        ]
+    }
+    assert _OVERSTATED_MESSAGE_MODULE in written_content("MultiEdit", multi_edit_input)
+
+
 def _run_main_with_io(
     input_text: str, *, is_prose_style_enabled: bool = True
 ) -> str:
@@ -248,6 +258,37 @@ def test_main_blocks_overstated_hook_module_edit() -> None:
     assert payload["hookSpecificOutput"]["permissionDecision"] == "deny"
 
 
+def test_main_blocks_overstatement_introduced_by_second_multi_edit() -> None:
+    """An overstated claim in the second edit of a MultiEdit is caught, not only the first."""
+    hook_input = {
+        "tool_name": "MultiEdit",
+        "tool_input": {
+            "file_path": "/repo/hooks/hooks_constants/some_blocker_constants.py",
+            "edits": [
+                {"old_string": "a = 1", "new_string": "a = 11"},
+                {"old_string": "b = 2", "new_string": _OVERSTATED_MESSAGE_MODULE},
+            ],
+        },
+    }
+    output_text = _run_main_with_io(json.dumps(hook_input))
+    payload = json.loads(output_text)
+    assert payload["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_main_passes_clean_multi_edit() -> None:
+    hook_input = {
+        "tool_name": "MultiEdit",
+        "tool_input": {
+            "file_path": "/repo/hooks/hooks_constants/some_blocker_constants.py",
+            "edits": [
+                {"old_string": "a = 1", "new_string": "a = 11"},
+                {"old_string": "b = 2", "new_string": _FIXED_MESSAGE_MODULE},
+            ],
+        },
+    }
+    assert _run_main_with_io(json.dumps(hook_input)) == ""
+
+
 def test_main_passes_fixed_hook_module_write() -> None:
     hook_input = {
         "tool_name": "Write",

package/hooks/blocking/test_pii_payload_scan.py

@@ -13,12 +13,22 @@ _HOOK_DIR = Path(__file__).parent
 _HOOKS_DIR = _HOOK_DIR.parent
 
 try:
-    from pii_payload_scan import evaluate_post_body_texts, evaluate_write_edit_payload
+    from pii_payload_scan import (
+        evaluate_apply_patch_payload,
+        evaluate_post_body_texts,
+        evaluate_write_edit_payload,
+    )
 except ImportError:
     for each_bootstrap_directory in (str(_HOOK_DIR), str(_HOOKS_DIR)):
         if each_bootstrap_directory not in sys.path:
             sys.path.insert(0, each_bootstrap_directory)
-    from pii_payload_scan import evaluate_post_body_texts, evaluate_write_edit_payload
+    from pii_payload_scan import (
+        evaluate_apply_patch_payload,
+        evaluate_post_body_texts,
+        evaluate_write_edit_payload,
+    )
+
+pytestmark = pytest.mark.usefixtures("ephemeral_exempt_off")
 
 _ALLOW_SLUG = "AllowOwner/allow-repo"
 _OTHER_SLUG = "OtherOwner/other-repo"
@@ -166,3 +176,56 @@ def test_allowlisted_value_under_missing_nested_parent_is_allowed(
     nested_target = repository_root / "new_dir" / "deeper" / "notes.md"
     assert not nested_target.parent.exists()
     assert _write_deny_reason(nested_target, allowed_value) is None
+
+
+def test_apply_patch_add_with_pii_is_denied(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    _init_repo_with_github_origin(repository_root, _ALLOW_SLUG)
+    deny_reason = evaluate_apply_patch_payload(
+        {
+            "command": (
+                "*** Begin Patch\n"
+                "*** Add File: notes.md\n"
+                f"+Reach me at {_assembled_fixture_email()}\n"
+                "*** End Patch"
+            )
+        },
+        hook_payload={"cwd": str(repository_root)},
+    )
+    assert deny_reason is not None
+    assert "email" in deny_reason
+
+
+def test_apply_patch_add_with_clean_content_is_allowed(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    _init_repo_with_github_origin(repository_root, _ALLOW_SLUG)
+    deny_reason = evaluate_apply_patch_payload(
+        {
+            "command": (
+                "*** Begin Patch\n"
+                "*** Add File: notes.md\n"
+                "+nothing sensitive here\n"
+                "*** End Patch"
+            )
+        },
+        hook_payload={"cwd": str(repository_root)},
+    )
+    assert deny_reason is None
+
+
+def test_apply_patch_payload_accepts_the_tool_input_keyword(tmp_path: Path) -> None:
+    """evaluate_apply_patch_payload's first parameter is named all_tool_input."""
+    repository_root = tmp_path / "repo"
+    _init_repo_with_github_origin(repository_root, _ALLOW_SLUG)
+    deny_reason = evaluate_apply_patch_payload(
+        all_tool_input={
+            "command": (
+                "*** Begin Patch\n"
+                "*** Add File: notes.md\n"
+                "+nothing sensitive here\n"
+                "*** End Patch"
+            )
+        },
+        hook_payload={"cwd": str(repository_root)},
+    )
+    assert deny_reason is None

package/hooks/blocking/test_pii_prevention_blocker.py

@@ -6,6 +6,7 @@ import json
 import subprocess
 import sys
 from pathlib import Path
+from typing import Callable
 
 import pytest
 
@@ -37,7 +38,6 @@ from pii_prevention_blocker import (  # noqa: E402
 
 HOOK_PATH = _HOOK_DIR / "pii_prevention_blocker.py"
 
-SYNTHETIC_GITHUB_TOKEN = "ghp_" + ("C" * 36)
 SYNTHETIC_REAL_EMAIL = "owner.fixture@acme-corp.example.io"
 SYNTHETIC_HOME_PATH = r"C:\Users\fixture_commit_user\secret.txt"
 SYNTHETIC_PRIVATE_IP = "10.44.12.9"
@@ -173,14 +173,12 @@ def test_gh_body_file_reads_relative_path_from_working_directory(
     assert "email" in deny_reason
 
 
-def test_gh_post_body_with_secret_is_denied() -> None:
-    command = (
-        f'gh pr comment 12 --body "auth material {SYNTHETIC_GITHUB_TOKEN}"'
-    )
+def test_gh_post_body_with_secret_is_denied(synthetic_github_token: str) -> None:
+    command = f'gh pr comment 12 --body "auth material {synthetic_github_token}"'
     deny_reason = evaluate_bash_command(command, working_directory=None)
     assert deny_reason is not None
     assert "secret" in deny_reason
-    assert SYNTHETIC_GITHUB_TOKEN not in deny_reason
+    assert synthetic_github_token not in deny_reason
 
 
 def test_gh_post_clean_body_is_allowed() -> None:
@@ -201,12 +199,12 @@ def test_mcp_github_body_with_private_ip_is_denied() -> None:
     assert "private-ip" in deny_reason
 
 
-def test_subprocess_hook_denies_write_with_token() -> None:
+def test_subprocess_hook_denies_write_with_token(synthetic_github_token: str) -> None:
     payload = {
         "tool_name": "Write",
         "tool_input": {
             "file_path": "src/config.env.example.md",
-            "content": f"TOKEN={SYNTHETIC_GITHUB_TOKEN}\n",
+            "content": f"TOKEN={synthetic_github_token}\n",
         },
     }
     exit_code, stdout_text = _run_hook(payload)
@@ -217,7 +215,7 @@ def test_subprocess_hook_denies_write_with_token() -> None:
     reason = payload_out["hookSpecificOutput"]["permissionDecisionReason"]
     assert decision == "deny"
     assert "secret" in reason
-    assert SYNTHETIC_GITHUB_TOKEN not in reason
+    assert synthetic_github_token not in reason
 
 
 def test_subprocess_hook_allows_clean_write() -> None:
@@ -362,7 +360,9 @@ def test_dispatcher_roster_hosts_pii_blocker() -> None:
         if each_entry.script_relative_path == "blocking/pii_prevention_blocker.py"
     ]
     assert len(matching_write_entries) == 1
-    assert matching_write_entries[0].applicable_tool_names == ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES
+    assert matching_write_entries[0].applicable_tool_names == (
+        ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES | {"apply_patch"}
+    )
     assert matching_write_entries[0].is_blocking is True
     matching_bash_entries = [
         each_entry
@@ -1202,3 +1202,73 @@ def test_post_body_still_scans_when_repository_is_exempt(
     )
     assert deny_reason is not None
     assert "email" in deny_reason
+
+
+def test_apply_patch_add_with_real_email_is_denied(
+    tmp_path: Path, init_bare_git_repo: Callable[[Path], None]
+) -> None:
+    repository_root = tmp_path / "repo"
+    init_bare_git_repo(repository_root)
+    deny_reason = evaluate(
+        {
+            "tool_name": "apply_patch",
+            "cwd": str(repository_root),
+            "tool_input": {
+                "command": (
+                    "*** Begin Patch\n"
+                    "*** Add File: notes.md\n"
+                    f"+Reach me at {SYNTHETIC_REAL_EMAIL}\n"
+                    "*** End Patch"
+                )
+            },
+        }
+    )
+    assert deny_reason is not None
+    assert "email" in deny_reason
+
+
+def test_apply_patch_add_with_clean_content_is_allowed(
+    tmp_path: Path, init_bare_git_repo: Callable[[Path], None]
+) -> None:
+    repository_root = tmp_path / "repo"
+    init_bare_git_repo(repository_root)
+    deny_reason = evaluate(
+        {
+            "tool_name": "apply_patch",
+            "cwd": str(repository_root),
+            "tool_input": {
+                "command": (
+                    "*** Begin Patch\n"
+                    "*** Add File: notes.md\n"
+                    "+Reach me at user@example.com\n"
+                    "*** End Patch"
+                )
+            },
+        }
+    )
+    assert deny_reason is None
+
+
+def test_subprocess_hook_denies_apply_patch_add_with_token(
+    tmp_path: Path,
+    init_bare_git_repo: Callable[[Path], None],
+    synthetic_github_token: str,
+) -> None:
+    """The standalone hook process denies an apply_patch payload carrying a token."""
+    repository_root = tmp_path / "repo"
+    init_bare_git_repo(repository_root)
+    payload = {
+        "tool_name": "apply_patch",
+        "cwd": str(repository_root),
+        "tool_input": {
+            "command": (
+                "*** Begin Patch\n"
+                "*** Add File: notes.md\n"
+                f"+token is {synthetic_github_token}\n"
+                "*** End Patch"
+            )
+        },
+    }
+    returncode, stdout = _run_hook(payload)
+    assert returncode == 0
+    assert json.loads(stdout)["hookSpecificOutput"]["permissionDecision"] == "deny"