claude-dev-env 2.18.0 → 2.20.0

package/hooks/blocking/test_hook_subprocess_support.py

@@ -0,0 +1,296 @@
+"""Shared subprocess support for blocking-hook behavior tests."""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+
+import pytest
+
+HOOK_SUBPROCESS_TIMEOUT_SECONDS: int = 10
+
+
+def run_hook_as_subprocess(
+    hook_script_path: str | Path,
+    payload_text: str,
+    working_directory: str | Path,
+    home_directory: str | Path,
+    *,
+    all_environment_names_to_remove: tuple[str, ...] = (),
+    environment_updates_by_name: Mapping[str, str] | None = None,
+) -> subprocess.CompletedProcess[str]:
+    """Run a hook through its real ``__main__`` path with captured text streams."""
+    resolved_hook_script_path = Path(hook_script_path).resolve()
+    environment_update_by_name = environment_updates_by_name or {}
+    all_environment_names_to_exclude = {
+        _environment_name_comparison_key(each_environment_name)
+        for each_environment_name in (
+            *all_environment_names_to_remove,
+            *environment_update_by_name,
+        )
+    }
+    environment_variable_by_name = {
+        each_environment_name: each_environment_value
+        for each_environment_name, each_environment_value in os.environ.items()
+        if _environment_name_comparison_key(each_environment_name)
+        not in all_environment_names_to_exclude
+    }
+    environment_variable_by_name.update(environment_update_by_name)
+    resolved_home_directory = Path(home_directory).resolve()
+    for each_environment_name in ("HOME", "USERPROFILE", "TEMP", "TMP", "TMPDIR"):
+        environment_variable_by_name[each_environment_name] = str(resolved_home_directory)
+    environment_variable_by_name["PYTHONIOENCODING"] = "utf-8"
+    return subprocess.run(
+        [sys.executable, str(resolved_hook_script_path)],
+        input=payload_text,
+        cwd=working_directory,
+        env=environment_variable_by_name,
+        capture_output=True,
+        encoding="utf-8",
+        check=False,
+        timeout=HOOK_SUBPROCESS_TIMEOUT_SECONDS,
+    )
+
+
+def build_bash_payload(command: str, *, tool_input_cwd: str | Path | None = None) -> str:
+    """Build the serialized Bash tool payload for a command."""
+    command_field_by_name = {"command": command}
+    if tool_input_cwd is not None:
+        command_field_by_name["cwd"] = str(tool_input_cwd)
+    return json.dumps(
+        {
+            "tool_name": "Bash",
+            "tool_input": command_field_by_name,
+        }
+    )
+
+
+def read_hook_permission_decision(stdout_text: str) -> tuple[str, str]:
+    """Read the hook permission decision and reason from serialized output."""
+    if not stdout_text.strip():
+        return "", ""
+    hook_output_by_name = json.loads(stdout_text)["hookSpecificOutput"]
+    return (
+        hook_output_by_name["permissionDecision"],
+        hook_output_by_name["permissionDecisionReason"],
+    )
+
+
+def _environment_name_comparison_key(environment_name: str) -> str:
+    if os.name == "nt":
+        return environment_name.casefold()
+    return environment_name
+
+
+def assert_hook_deny_log_contains(
+    home_directory: str | Path, hook_filename: str
+) -> None:
+    """Assert that the isolated hook-block log records the named hook."""
+    deny_log_path = Path(home_directory) / ".claude" / "logs" / "hook-blocks.log"
+    assert deny_log_path.is_file(), f"Missing deny log: {deny_log_path}"
+    deny_log_text = deny_log_path.read_text(encoding="utf-8")
+    assert hook_filename in deny_log_text, (
+        f"Missing {hook_filename} in deny log: {deny_log_text}"
+    )
+
+
+def test_run_hook_as_subprocess_resolves_relative_path_and_isolates_home(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    absolute_hook_script_path = (
+        Path(__file__).resolve().parent / "open_questions_in_plans_blocker.py"
+    )
+    monkeypatch.chdir(absolute_hook_script_path.parent)
+    relative_hook_script_path = Path(absolute_hook_script_path.name)
+    isolated_home_directory = tmp_path / "isolated-home"
+    isolated_home_directory.mkdir()
+    plan_path = tmp_path / "docs" / "plans" / "feature.md"
+    payload_text = json.dumps(
+        {
+            "tool_name": "Write",
+            "tool_input": {
+                "file_path": str(plan_path),
+                "content": "# Feature Plan\n\n## Open Questions\n\n- Choose a value.\n",
+            },
+        }
+    )
+
+    completed = run_hook_as_subprocess(
+        hook_script_path=relative_hook_script_path,
+        payload_text=payload_text,
+        working_directory=tmp_path,
+        home_directory=isolated_home_directory,
+    )
+
+    parsed_stdout = json.loads(completed.stdout)
+    assert completed.returncode == 0, completed.stderr
+    assert parsed_stdout["hookSpecificOutput"]["permissionDecision"] == "deny"
+    assert_hook_deny_log_contains(
+        isolated_home_directory, "open_questions_in_plans_blocker.py"
+    )
+
+
+def test_run_hook_as_subprocess_returns_nonzero_probe_streams(
+    tmp_path: Path,
+) -> None:
+    probe_script_path = tmp_path / "probe.py"
+    probe_script_path.write_text(
+        "import sys\n"
+        "sys.stdout.write('probe stdout\\n')\n"
+        "sys.stderr.write('probe stderr\\n')\n"
+        "sys.exit(7)\n",
+        encoding="utf-8",
+    )
+
+    completed = run_hook_as_subprocess(
+        hook_script_path=probe_script_path,
+        payload_text="",
+        working_directory=tmp_path,
+        home_directory=tmp_path / "isolated-home",
+    )
+
+    assert completed.returncode == 7, completed.stderr
+    assert completed.stdout == "probe stdout\n"
+    assert completed.stderr == "probe stderr\n"
+
+
+def test_build_bash_payload_omits_optional_cwd() -> None:
+    payload_text = build_bash_payload("rm -rf /tmp/example")
+
+    assert json.loads(payload_text) == {
+        "tool_name": "Bash",
+        "tool_input": {
+            "command": "rm -rf /tmp/example",
+        },
+    }
+
+
+def test_build_bash_payload_includes_optional_cwd() -> None:
+    payload_text = build_bash_payload(
+        "rm -rf /tmp/example", tool_input_cwd="/tmp/work"
+    )
+
+    assert json.loads(payload_text) == {
+        "tool_name": "Bash",
+        "tool_input": {
+            "command": "rm -rf /tmp/example",
+            "cwd": "/tmp/work",
+        },
+    }
+
+
+def test_run_hook_as_subprocess_handles_unicode_stdin_as_utf8(
+    tmp_path: Path,
+) -> None:
+    probe_script_path = tmp_path / "probe.py"
+    probe_script_path.write_text(
+        "import sys\n"
+        "sys.stdout.write(','.join(str(ord(each_character)) for each_character in sys.stdin.read()))\n",
+        encoding="utf-8",
+    )
+    unicode_payload = "café 日本語"
+
+    completed = run_hook_as_subprocess(
+        hook_script_path=probe_script_path,
+        payload_text=unicode_payload,
+        working_directory=tmp_path,
+        home_directory=tmp_path / "isolated-home",
+    )
+
+    assert completed.returncode == 0, completed.stderr
+    assert completed.stdout == "99,97,102,233,32,26085,26412,35486"
+
+
+def test_run_hook_as_subprocess_preserves_posix_mixed_case_environment_names(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    probe_script_path = tmp_path / "probe.py"
+    probe_script_path.write_text(
+        "import json\n"
+        "import os\n"
+        "print(json.dumps(sorted((each_name, each_value) for each_name, each_value in os.environ.items() if each_name.casefold() == 'casesensitiveprobe')))\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setenv("CaseSensitiveProbe", "before")
+
+    completed = run_hook_as_subprocess(
+        hook_script_path=probe_script_path,
+        payload_text="",
+        working_directory=tmp_path,
+        home_directory=tmp_path / "isolated-home",
+        environment_updates_by_name={"CASESENSITIVEPROBE": "after"},
+    )
+
+    child_environment_variable_by_name = json.loads(completed.stdout)
+    if os.name == "nt":
+        assert child_environment_variable_by_name == [["CASESENSITIVEPROBE", "after"]]
+    else:
+        assert child_environment_variable_by_name == [
+            ["CASESENSITIVEPROBE", "after"],
+            ["CaseSensitiveProbe", "before"],
+        ]
+
+
+def test_run_hook_as_subprocess_handles_windows_mixed_case_environment_names(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    probe_script_path = tmp_path / "probe.py"
+    probe_script_path.write_text(
+        "import json\n"
+        "import os\n"
+        "print(json.dumps(sorted((each_name, each_value) for each_name, each_value in os.environ.items() if each_name.casefold() == 'casesensitiveprobe')))\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setenv("CaseSensitiveProbe", "before")
+
+    completed = run_hook_as_subprocess(
+        hook_script_path=probe_script_path,
+        payload_text="",
+        working_directory=tmp_path,
+        home_directory=tmp_path / "isolated-home",
+        all_environment_names_to_remove=("casesensitiveprobe",),
+        environment_updates_by_name={"CASESENSITIVEPROBE": "after"},
+    )
+
+    child_environment_variable_by_name = json.loads(completed.stdout)
+    if os.name == "nt":
+        assert child_environment_variable_by_name == [["CASESENSITIVEPROBE", "after"]]
+    else:
+        assert child_environment_variable_by_name == [
+            ["CASESENSITIVEPROBE", "after"],
+            ["CaseSensitiveProbe", "before"],
+        ]
+
+
+def test_run_hook_as_subprocess_keeps_default_home_and_temp_isolation(
+    tmp_path: Path,
+) -> None:
+    probe_script_path = tmp_path / "probe.py"
+    probe_script_path.write_text(
+        "import json\n"
+        "import os\n"
+        "print(json.dumps({each_name: os.environ.get(each_name) for each_name in (\n"
+        "    'HOME', 'USERPROFILE', 'TEMP', 'TMP', 'TMPDIR'\n"
+        ")}))\n",
+        encoding="utf-8",
+    )
+    isolated_home_directory = tmp_path / "isolated-home"
+    isolated_home_directory.mkdir()
+
+    completed = run_hook_as_subprocess(
+        hook_script_path=probe_script_path,
+        payload_text="",
+        working_directory=tmp_path,
+        home_directory=isolated_home_directory,
+    )
+
+    child_environment_variable_by_name = json.loads(completed.stdout)
+    expected_home = str(isolated_home_directory.resolve())
+    assert set(child_environment_variable_by_name.values()) == {expected_home}

package/hooks/blocking/test_package_inventory_stale_blocker.py

@@ -6,7 +6,7 @@ import subprocess
 import sys
 from pathlib import Path
 
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
 
 from package_inventory_stale_blocker import (
     find_stale_inventory,

package/hooks/blocking/test_pii_scanner.py

@@ -61,6 +61,87 @@ def test_flags_unix_home_path() -> None:
     assert any(each.category == "home-path" for each in all_unix_hits)
 
 
+def test_flags_raw_escaped_windows_home_path() -> None:
+    all_home_hits = scan_text_for_pii(r"path is C:\\Users\\concrete-user\\file")
+    assert [each.matched_text for each in all_home_hits] == [
+        r"C:\\Users\\concrete-user"
+    ]
+
+
+def test_flags_unc_windows_home_path_at_each_share_depth() -> None:
+    all_home_hits = scan_text_for_pii(
+        r"path is \\server\Users\concrete-user\file"
+        "\n"
+        r"path is \\server name\My Share\Users\other-user\file"
+    )
+    assert [each.matched_text for each in all_home_hits] == [
+        r"\\server\Users\concrete-user",
+        r"\\server name\My Share\Users\other-user",
+    ]
+
+
+def test_flags_forward_slash_unc_home_paths() -> None:
+    all_home_hits = scan_text_for_pii(
+        "path is //server/Users/concrete-user/file"
+        "\n"
+        "path is //server/share/Users/other-user/file"
+    )
+    assert [each.matched_text for each in all_home_hits] == [
+        "//server/Users/concrete-user",
+        "//server/share/Users/other-user",
+    ]
+
+
+def test_allows_http_urls_with_users_segments() -> None:
+    all_home_hits = scan_text_for_pii(
+        "https://docs-7.example.com/Users/concrete-user/file"
+    ) + scan_text_for_pii("http://server-2/share/Users/concrete-user/file")
+    assert all_home_hits == []
+
+
+def test_allows_http_urls_with_home_segments() -> None:
+    assert scan_text_for_pii("https://home/user/file") == []
+    assert scan_text_for_pii("https://Users/user/file") == []
+    assert scan_text_for_pii("https://[::1]/home/user/file") == []
+    assert scan_text_for_pii("https://[2001:db8::1]/Users/user/file") == []
+    assert scan_text_for_pii("https://docs-7.example.com/home/concrete-user/file") == []
+
+
+def test_flags_absolute_and_file_uri_home_paths() -> None:
+    all_home_hits = scan_text_for_pii("path is /home/concrete-user/file")
+    all_home_hits += scan_text_for_pii("path is file:///home/concrete-user/file")
+    all_home_hits += scan_text_for_pii("path is file://server/home/concrete-user/file")
+    all_home_hits += scan_text_for_pii("path is FILE://server/home/other-user/file")
+    all_home_hits += scan_text_for_pii(
+        "path is FILE://server/share/home/third-user/file"
+    )
+    assert [each.matched_text for each in all_home_hits] == [
+        "/home/concrete-user",
+        "file:///home/concrete-user",
+        "file://server/home/concrete-user",
+        "FILE://server/home/other-user",
+        "FILE://server/share/home/third-user",
+    ]
+
+
+def test_flags_file_uri_home_path() -> None:
+    all_home_hits = scan_text_for_pii(
+        "path is file:///Users/concrete-user/file"
+        "\n"
+        "path is file://server/Users/concrete-user/file"
+        "\n"
+        "path is FILE:///Users/other-user/file"
+        "\n"
+        "path is FILE://server/share/Users/third-user/file"
+    )
+    assert [each.matched_text for each in all_home_hits] == [
+        "file:///Users/concrete-user",
+        "file://server/Users/concrete-user",
+        "FILE:///Users/other-user",
+        "FILE://server/share/Users/third-user",
+    ]
+
+
 def test_flags_private_ip_and_allows_public_ip() -> None:
     all_lan_hits = scan_text_for_pii(f"host {SYNTHETIC_PRIVATE_IP}")
     all_dns_hits = scan_text_for_pii(f"dns {SYNTHETIC_PUBLIC_IP}")

package/hooks/blocking/test_pre_tool_use_dispatcher.py

@@ -42,6 +42,7 @@ from hooks_constants.pre_tool_use_dispatcher_constants import (  # noqa: E402, I
 from pre_tool_use_dispatcher import (  # noqa: E402, I001
     DispatcherDecision,
     HostedHookResult,
+    _emit_allow_decision,
     _emit_deny_decision,
     aggregate_hosted_hook_results,
     run_hosted_hook,
@@ -649,6 +650,28 @@ def test_emit_deny_does_not_cross_collapse_reason_and_context(
     assert parsed["hookSpecificOutput"]["additionalContext"] == shared_text
 
 
+def test_emit_allow_preserves_system_message_and_additional_context(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """An allow payload carries the advisory's system and context messages."""
+    decision = DispatcherDecision(
+        should_deny=False,
+        should_allow=True,
+        all_deny_reasons=[],
+        all_system_messages=["system-a", "system-b"],
+        all_additional_context=["context-a", "context-b"],
+        should_suppress_output=False,
+    )
+
+    _emit_allow_decision(decision)
+
+    parsed = json.loads(capsys.readouterr().out)
+    hook_specific = parsed["hookSpecificOutput"]
+    assert hook_specific["permissionDecision"] == "allow"
+    assert hook_specific["additionalContext"] == "context-a\ncontext-b"
+    assert parsed["systemMessage"] == "system-a\nsystem-b"
+
+
 def test_later_hook_deny_survives_early_hook_exit() -> None:
     """Dispatcher denies even when an earlier hook exits cleanly before a later hook denies.
 
@@ -698,10 +721,16 @@ def test_dispatcher_edit_applies_both_groups() -> None:
 
 
 def test_dispatcher_multi_edit_applies_only_group_b() -> None:
-    """MultiEdit tool triggers only Group B (8 hooks), not Group A."""
+    """MultiEdit applies to 9 hosted Group-B hooks, including the sensitive protector."""
     all_multi_edit_entries = _applicable_entries_for_tool(MULTI_EDIT_TOOL_NAME)
-    assert len(all_multi_edit_entries) == 8, (
-        f"MultiEdit tool must apply to exactly 8 Group-B hooks, got {len(all_multi_edit_entries)}"
+    all_multi_edit_script_paths = {
+        each_entry.script_relative_path for each_entry in all_multi_edit_entries
+    }
+    assert "blocking/sensitive_file_protector.py" in all_multi_edit_script_paths, (
+        "sensitive_file_protector belongs in the MultiEdit applicable set"
+    )
+    assert len(all_multi_edit_entries) == 9, (
+        f"MultiEdit tool must apply to exactly 9 Group-B hooks, got {len(all_multi_edit_entries)}"
     )
 
 

package/hooks/blocking/test_precommit_code_rules_gate.py

@@ -1,8 +1,8 @@
-"""Behavior tests for the precommit_code_rules_gate PreToolUse hook.
+"""Behavior tests for the pass-through precommit_code_rules_gate hook.
 
 Each test builds a real git repository in a temporary directory, stages
 real files, and runs the hook script as a subprocess with a PreToolUse
-JSON payload on stdin — the exact production invocation path.
+JSON payload on stdin through the exact production invocation path.
 """
 
 import json
@@ -140,10 +140,6 @@ def run_hook(bash_command: str, working_directory: Path) -> subprocess.Completed
     )
 
 
-def parse_denial(hook_stdout: str) -> dict:
-    return json.loads(hook_stdout)["hookSpecificOutput"]
-
-
 def test_non_commit_command_passes_through(tmp_path: Path) -> None:
     initialize_repository(tmp_path)
     completed_hook = run_hook("git status", tmp_path)
@@ -157,20 +153,19 @@ def test_commit_with_clean_staged_python_file_is_allowed(tmp_path: Path) -> None
     completed_hook = run_hook("git commit -m add", tmp_path)
     assert completed_hook.returncode == 0
     assert completed_hook.stdout.strip() == ""
+    assert "Git commit proceeds to configured Git hooks." in completed_hook.stderr
 
 
-def test_commit_with_violating_staged_file_is_blocked(tmp_path: Path) -> None:
+def test_commit_with_staged_python_file_passes_through(tmp_path: Path) -> None:
     initialize_repository(tmp_path)
     stage_file(tmp_path, "totals.py", VIOLATING_MODULE_SOURCE)
     completed_hook = run_hook("git commit -m add", tmp_path)
     assert completed_hook.returncode == 0
-    denial = parse_denial(completed_hook.stdout)
-    assert denial["permissionDecision"] == "deny"
-    assert "totals.py" in denial["permissionDecisionReason"]
-    assert "Line" in denial["permissionDecisionReason"]
+    assert completed_hook.stdout.strip() == ""
+    assert "Git commit proceeds to configured Git hooks." in completed_hook.stderr
 
 
-def test_git_dash_c_commit_form_is_blocked(tmp_path: Path) -> None:
+def test_git_dash_c_commit_form_passes_through(tmp_path: Path) -> None:
     repository_root = tmp_path / "repo"
     repository_root.mkdir()
     initialize_repository(repository_root)
@@ -180,9 +175,8 @@ def test_git_dash_c_commit_form_is_blocked(tmp_path: Path) -> None:
     quoted_root = str(repository_root)
     completed_hook = run_hook(f'git -C "{quoted_root}" commit -m add', elsewhere)
     assert completed_hook.returncode == 0
-    denial = parse_denial(completed_hook.stdout)
-    assert denial["permissionDecision"] == "deny"
-    assert "totals.py" in denial["permissionDecisionReason"]
+    assert completed_hook.stdout.strip() == ""
+    assert "Git commit proceeds to configured Git hooks." in completed_hook.stderr
 
 
 def test_commit_with_no_staged_python_files_is_allowed(tmp_path: Path) -> None:
@@ -193,7 +187,7 @@ def test_commit_with_no_staged_python_files_is_allowed(tmp_path: Path) -> None:
     assert completed_hook.stdout.strip() == ""
 
 
-def test_worktree_commit_reads_worktree_paired_tests_not_sibling_checkout(
+def test_worktree_commit_passes_through(
     tmp_path: Path,
 ) -> None:
     main_checkout = tmp_path / "main_checkout"
@@ -213,3 +207,4 @@ def test_worktree_commit_reads_worktree_paired_tests_not_sibling_checkout(
     )
     assert completed_hook.returncode == 0
     assert completed_hook.stdout.strip() == ""
+    assert "Git commit proceeds to configured Git hooks." in completed_hook.stderr