claude-dev-env 1.92.1 → 1.93.0

package/hooks/hooks_constants/test_hosted_hook_runner.py

@@ -0,0 +1,101 @@
+"""Behavior tests for the shared in-process hosted-hook runner.
+
+Each test writes a real probe hook to a temp directory, runs it through
+run_hook_capturing_output, and asserts on the captured stdout, the crash flag,
+and the restoration of the interpreter's stdin, stdout, and argv.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+_HOOKS_DIR = str(Path(__file__).resolve().parent.parent)
+if _HOOKS_DIR not in sys.path:
+    sys.path.insert(0, _HOOKS_DIR)
+
+from hooks_constants.hosted_hook_runner import HostedHookRun, run_hook_capturing_output  # noqa: E402
+
+
+def _write_probe(tmp_path: Path, body: str) -> str:
+    """Write a probe hook script and return its absolute path."""
+    probe_path = tmp_path / "probe_hook.py"
+    probe_path.write_text(body, encoding="utf-8")
+    return str(probe_path)
+
+
+def test_captures_stdout_from_a_printing_hook(tmp_path: Path) -> None:
+    """The runner captures what a hook prints to stdout without a crash."""
+    printed_payload = json.dumps({"hookSpecificOutput": {"permissionDecision": "deny"}})
+    probe_path = _write_probe(tmp_path, f"print({printed_payload!r})\n")
+    hook_run = run_hook_capturing_output(probe_path, "{}")
+    assert hook_run.captured_stdout.strip() == printed_payload
+    assert hook_run.did_crash is False
+
+
+def test_hook_reads_the_swapped_stdin(tmp_path: Path) -> None:
+    """A hook reading stdin sees the payload the runner replays."""
+    probe_path = _write_probe(
+        tmp_path,
+        "import json\nimport sys\nprint(json.load(sys.stdin)['tool_name'])\n",
+    )
+    hook_run = run_hook_capturing_output(probe_path, json.dumps({"tool_name": "Bash"}))
+    assert hook_run.captured_stdout.strip() == "Bash"
+    assert hook_run.did_crash is False
+
+
+def test_sets_argv_to_the_hook_script_path(tmp_path: Path) -> None:
+    """The runner sets argv to the hook's own path so argv-branching hooks behave."""
+    argv_result_path = tmp_path / "observed_argv.json"
+    probe_path = _write_probe(
+        tmp_path,
+        "import json\nimport sys\nfrom pathlib import Path\n"
+        f"Path({str(argv_result_path)!r}).write_text(json.dumps(sys.argv), encoding='utf-8')\n",
+    )
+    run_hook_capturing_output(probe_path, "{}")
+    observed_argv = json.loads(argv_result_path.read_text(encoding="utf-8"))
+    assert observed_argv == [probe_path]
+
+
+def test_restores_stdin_stdout_and_argv_after_the_run(tmp_path: Path) -> None:
+    """The runner restores stdin, stdout, and argv to their pre-call objects."""
+    probe_path = _write_probe(tmp_path, "print('anything')\n")
+    original_stdin = sys.stdin
+    original_stdout = sys.stdout
+    original_argv = sys.argv
+    run_hook_capturing_output(probe_path, "{}")
+    assert sys.stdin is original_stdin
+    assert sys.stdout is original_stdout
+    assert sys.argv is original_argv
+
+
+def test_crash_reports_did_crash_and_does_not_propagate(tmp_path: Path) -> None:
+    """A hook that raises is contained: did_crash is True and no exception escapes."""
+    probe_path = _write_probe(tmp_path, "raise ValueError('boom')\n")
+    hook_run = run_hook_capturing_output(probe_path, "{}")
+    assert hook_run.did_crash is True
+    assert hook_run.captured_stdout == ""
+
+
+def test_system_exit_zero_after_output_is_captured(tmp_path: Path) -> None:
+    """A hook that prints then exits zero returns its output and is not a crash."""
+    probe_path = _write_probe(tmp_path, "print('decided')\nimport sys\nsys.exit(0)\n")
+    hook_run = run_hook_capturing_output(probe_path, "{}")
+    assert hook_run.captured_stdout.strip() == "decided"
+    assert hook_run.did_crash is False
+
+
+def test_system_exit_nonzero_without_output_is_not_a_crash(tmp_path: Path) -> None:
+    """A clean nonzero SystemExit yields no output and is not treated as a crash."""
+    probe_path = _write_probe(tmp_path, "import sys\nsys.exit(2)\n")
+    hook_run = run_hook_capturing_output(probe_path, "{}")
+    assert hook_run.did_crash is False
+    assert hook_run.captured_stdout == ""
+
+
+def test_returns_a_hosted_hook_run_instance(tmp_path: Path) -> None:
+    """The runner returns a HostedHookRun carrying the two observable fields."""
+    probe_path = _write_probe(tmp_path, "print('x')\n")
+    hook_run = run_hook_capturing_output(probe_path, "{}")
+    assert isinstance(hook_run, HostedHookRun)

package/hooks/hooks_constants/test_layout_constants.py

@@ -0,0 +1,28 @@
+"""Constants for the test-module dead-scaffolding checks in ``code_rules_enforcer``.
+
+Lives under the hooks-tree ``hooks_constants`` package so module-level
+UPPER_SNAKE constants satisfy the CODE_RULES "constants live in config"
+requirement and share a home with the other hook-tree configuration. The
+values here drive two test-file checks that catch scaffolding a removed
+monkeypatch line leaves behind: a dead private module constant, and an
+unused private-helper parameter.
+"""
+
+import re
+
+PRIVATE_NAME_PREFIX: str = "_"
+TEST_FUNCTION_MODULE_BASENAME_PATTERN: re.Pattern[str] = re.compile(r"^(test_.+|.+_test)\.py$")
+FIXTURE_DECORATOR_MARKER: str = "fixture"
+SELF_PARAMETER_NAME: str = "self"
+CLASS_METHOD_FIRST_PARAMETER_NAME: str = "cls"
+MINIMUM_CONSTANT_NAME_LENGTH: int = 2
+MAX_TEST_LAYOUT_ISSUES: int = 50
+DEAD_TEST_CONSTANT_GUIDANCE: str = (
+    "module-level constant is defined in this test module but read by no other"
+    " line in the file - remove the dead constant, or reference it where its"
+    " value is needed (CODE_RULES §9.8)"
+)
+UNUSED_TEST_HELPER_PARAMETER_GUIDANCE: str = (
+    "parameter is declared on this private test helper but read nowhere in its"
+    " body - drop the dead parameter and stop forwarding it at every call site"
+)

package/hooks/hooks_constants/test_local_identity.py

@@ -0,0 +1,88 @@
+"""Tests for the NAS local-identity loader used by the ssh enforcer hook."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from hooks_constants import local_identity  # noqa: E402
+
+ALL_NAS_ENV_VARS = ("CLAUDE_NAS_HOST", "CLAUDE_NAS_SSH_USER", "CLAUDE_NAS_SSH_PORT")
+
+
+def _clear_nas_env() -> None:
+    for each_env_var in ALL_NAS_ENV_VARS:
+        os.environ.pop(each_env_var, None)
+
+
+class TestNasValuesFromEnvironment:
+    def should_read_host_user_and_port_from_the_environment(self) -> None:
+        with patch.dict(
+            os.environ,
+            {
+                "CLAUDE_NAS_HOST": "10.0.0.5",
+                "CLAUDE_NAS_SSH_USER": "tester",
+                "CLAUDE_NAS_SSH_PORT": "2200",
+            },
+            clear=False,
+        ):
+            assert local_identity.nas_host() == "10.0.0.5"
+            assert local_identity.nas_ssh_user() == "tester"
+            assert local_identity.nas_ssh_port() == 2200
+
+
+class TestNasValuesFromLocalFile:
+    def should_read_host_user_and_port_from_the_local_identity_file(
+        self, tmp_path: Path
+    ) -> None:
+        claude_home = tmp_path / ".claude"
+        claude_home.mkdir()
+        (claude_home / "local-identity.json").write_text(
+            json.dumps(
+                {"nas": {"host": "10.1.1.9", "ssh_user": "fileuser", "ssh_port": 2222}}
+            ),
+            encoding="utf-8",
+        )
+        with patch.dict(os.environ, {}, clear=False):
+            _clear_nas_env()
+            with patch.object(Path, "home", return_value=tmp_path):
+                assert local_identity.nas_host() == "10.1.1.9"
+                assert local_identity.nas_ssh_user() == "fileuser"
+                assert local_identity.nas_ssh_port() == 2222
+
+
+class TestNasValuesPlaceholderDefault:
+    def should_return_placeholders_when_no_env_and_no_file(self, tmp_path: Path) -> None:
+        with patch.dict(os.environ, {}, clear=False):
+            _clear_nas_env()
+            with patch.object(Path, "home", return_value=tmp_path):
+                assert local_identity.nas_host() == "nas.example.local"
+                assert local_identity.nas_ssh_user() == "operator"
+                assert local_identity.nas_ssh_port() == 22
+
+
+class TestDenyMessagesQuoteTheResolvedHost:
+    def should_include_the_resolved_host_and_port_in_the_bare_binary_message(
+        self,
+    ) -> None:
+        with patch.dict(
+            os.environ,
+            {"CLAUDE_NAS_HOST": "10.0.0.5", "CLAUDE_NAS_SSH_PORT": "2200"},
+            clear=False,
+        ):
+            os.environ.pop("CLAUDE_NAS_SSH_USER", None)
+            message = local_identity.bare_ssh_binary_deny_message()
+            assert "10.0.0.5" in message
+            assert "-p 2200" in message
+            assert "BatchMode=yes" in message
+
+    def should_include_the_resolved_host_in_the_missing_batch_mode_message(self) -> None:
+        with patch.dict(os.environ, {"CLAUDE_NAS_HOST": "10.0.0.5"}, clear=False):
+            message = local_identity.missing_batch_mode_deny_message()
+            assert "10.0.0.5" in message
+            assert "BatchMode=yes" in message

package/hooks/hooks_constants/test_session_env_cleanup_constants.py

@@ -41,7 +41,7 @@ class TestSessionIdPatternRejects:
         assert SESSION_ID_PATTERN.match("etc/passwd") is None
 
     def test_rejects_back_slash(self) -> None:
-        assert SESSION_ID_PATTERN.match("Users\\jon") is None
+        assert SESSION_ID_PATTERN.match("Users\\example") is None
 
     def test_rejects_parent_traversal(self) -> None:
         assert SESSION_ID_PATTERN.match("..") is None

package/hooks/hooks_constants/test_stop_dispatcher_constants.py

@@ -0,0 +1,32 @@
+"""Tests for the Stop-hook dispatcher hosted-hook roster."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_HOOKS_DIR = str(Path(__file__).resolve().parent.parent)
+if _HOOKS_DIR not in sys.path:
+    sys.path.insert(0, _HOOKS_DIR)
+
+from hooks_constants.stop_dispatcher_constants import ALL_STOP_HOSTED_HOOK_PATHS  # noqa: E402
+
+_EXPECTED_STOP_ORDER = (
+    "blocking/hedging_language_blocker.py",
+    "blocking/question_to_user_enforcer.py",
+    "blocking/intent_only_ending_blocker.py",
+    "blocking/session_handoff_blocker.py",
+    "diagnostic/hook_log_stop_wrapper.py",
+)
+
+
+def test_roster_lists_all_stop_hooks_in_registration_order() -> None:
+    """The roster reproduces the standalone Stop chain order exactly."""
+    assert ALL_STOP_HOSTED_HOOK_PATHS == _EXPECTED_STOP_ORDER
+
+
+def test_every_roster_path_points_at_an_existing_hook() -> None:
+    """Each roster path names a hook script present on disk, catching a typo."""
+    hooks_root = Path(__file__).resolve().parent.parent
+    for each_relative_path in ALL_STOP_HOSTED_HOOK_PATHS:
+        assert (hooks_root / each_relative_path).is_file()

package/hooks/validators/README.md

@@ -6,7 +6,7 @@ AST-based Python style checks for code quality enforcement.
 
 1. **Imports at top** - All import statements must be at the top of the file
 2. **No empty line after decorators** - Decorators must be directly above functions (no blank lines)
-3. **Single empty line between functions** - Exactly one blank line between top-level functions
+3. **Two empty lines between functions** - Exactly two blank lines between top-level functions
 4. **View function naming** - Functions in `views.py` with `request` parameter must end with `_view`
 
 ## Usage
@@ -39,7 +39,7 @@ import ast
 from python_style_checks import (
     check_imports_at_top,
     check_no_empty_line_after_decorators,
-    check_single_empty_line_between_functions,
+    check_blank_lines_between_functions,
     check_view_function_naming,
 )
 
@@ -49,7 +49,7 @@ tree = ast.parse(source)
 # Run individual checks
 violations = check_imports_at_top(tree, "myfile.py")
 violations = check_no_empty_line_after_decorators(source, "myfile.py")
-violations = check_single_empty_line_between_functions(source, "myfile.py")
+violations = check_blank_lines_between_functions(source, "myfile.py")
 violations = check_view_function_naming(tree, "views.py")
 ```
 
@@ -75,7 +75,7 @@ def foo() -> None:
     """Do something."""
     pass
 
-@decorator
+
 def bar() -> None:
     """Another function."""
     pass
@@ -100,8 +100,7 @@ def bar() -> None:  # VIOLATION: No empty line after decorator
 def baz() -> None:
     pass
 
-
-def qux() -> None:  # VIOLATION: Expected 1 empty line, found 2
+def qux() -> None:  # VIOLATION: Expected 2 empty lines, found 1
     pass
 
 # View naming (in views.py)

package/hooks/validators/__init__.py

@@ -2,18 +2,18 @@
 
 from .python_style_checks import (
     Violation,
+    check_blank_lines_between_functions,
     check_imports_at_top,
     check_no_empty_line_after_decorators,
-    check_single_empty_line_between_functions,
     check_view_function_naming,
     validate_file,
 )
 
 __all__ = [
     "Violation",
+    "check_blank_lines_between_functions",
     "check_imports_at_top",
     "check_no_empty_line_after_decorators",
-    "check_single_empty_line_between_functions",
     "check_view_function_naming",
     "validate_file",
 ]