ceo-orchestration 1.0.0

package/.claude/hooks/tests/test_audit_log.py

@@ -0,0 +1,280 @@
+"""Unit tests for audit_log.py — the PostToolUse agent spawn audit hook.
+
+Covers the 11 scenarios from PLAN-002 §7 Item A.3 spec plus a few extras:
+- valid JSONL on clean payload
+- secret redaction (JWT, API key, URL creds)
+- SHA-256 hash regardless of redaction
+- rotation when over size threshold
+- concurrent writes no interleaving (via multiprocessing)
+- breadcrumb on lock timeout
+- silent stdout (exit 0, no output)
+- no jq dependency (the Python impl doesn't use it)
+- fallback when CLAUDE_PROJECT_DIR unset
+- fixture anonymization (no secrets in committed fixtures after redact)
+- hook_duration_ms present in entry
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import multiprocessing
+import os
+import subprocess
+import sys
+import time
+import unittest
+from pathlib import Path
+
+
+from _lib.testing import TestEnvContext, load_fixture  # noqa: E402
+
+import audit_log as al  # noqa: E402
+
+
+# Module-level worker for multiprocessing concurrency test
+def _concurrent_write_worker(worker_id, env):
+    """Child: set env, run audit_log.main() N times with fake stdin."""
+    for k, v in env.items():
+        os.environ[k] = v
+    # Reimport in child so env is picked up
+    import importlib
+    import audit_log
+    importlib.reload(audit_log)
+
+    for i in range(10):
+        payload = json.dumps({
+            "session_id": f"child-{worker_id}-{i}",
+            "tool_name": "Agent",
+            "tool_input": {
+                "description": f"worker {worker_id} iter {i}",
+                "prompt": f"SKILL: test-skill\n## AGENT PROFILE\n## FILE ASSIGNMENT\n- x",
+            },
+        })
+        old_stdin = sys.stdin
+        old_stdout = sys.stdout
+        sys.stdin = io.StringIO(payload)
+        sys.stdout = io.StringIO()
+        try:
+            audit_log.main()
+        finally:
+            sys.stdin = old_stdin
+            sys.stdout = old_stdout
+
+
+class TestBuildEntry(TestEnvContext):
+    def test_bucket_prompt_length(self):
+        self.assertEqual(al.bucket_prompt_length(0), "<256")
+        self.assertEqual(al.bucket_prompt_length(255), "<256")
+        self.assertEqual(al.bucket_prompt_length(256), "<1024")
+        self.assertEqual(al.bucket_prompt_length(1000), "<1024")
+        self.assertEqual(al.bucket_prompt_length(5000), "<16384")
+        self.assertEqual(al.bucket_prompt_length(100000), ">=65536")
+
+    def test_extract_skill_from_inject_format(self):
+        prompt = "## AGENT PROFILE\nfoo\n\nSKILL: security-and-auth\nrules..."
+        self.assertEqual(al.extract_skill(prompt), "security-and-auth")
+
+    def test_extract_skill_unknown_when_missing(self):
+        self.assertEqual(al.extract_skill("no skill here"), "unknown")
+        self.assertEqual(al.extract_skill(""), "unknown")
+
+    def test_has_profile_detection(self):
+        self.assertTrue(al.has_profile("## AGENT PROFILE\n..."))
+        self.assertTrue(al.has_profile("PERSONA: Sofia"))
+        self.assertTrue(al.has_profile("## PERSONA\n..."))
+        self.assertFalse(al.has_profile("just some text"))
+
+    def test_has_file_assignment_detection(self):
+        self.assertTrue(al.has_file_assignment("## FILE ASSIGNMENT\n- x"))
+        self.assertFalse(al.has_file_assignment("## SKILL CONTENT"))
+
+
+class TestAppendEntryIntegration(TestEnvContext):
+    """Write real entries to the isolated audit dir and inspect them."""
+
+    def _run_main_with(self, payload_dict):
+        """Run audit_log.main() with a JSON payload on stdin."""
+        payload_str = json.dumps(payload_dict)
+        old_stdin = sys.stdin
+        old_stdout = sys.stdout
+        sys.stdin = io.StringIO(payload_str)
+        sys.stdout = io.StringIO()
+        try:
+            rc = al.main()
+            out = sys.stdout.getvalue()
+        finally:
+            sys.stdin = old_stdin
+            sys.stdout = old_stdout
+        return rc, out
+
+    def test_emits_valid_jsonl_on_clean_payload(self):
+        fixture = load_fixture("sample_payload_clean.json")
+        rc, out = self._run_main_with(fixture)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out, "")  # silent stdout
+
+        log_text = self.read_audit_log()
+        self.assertTrue(log_text)
+        lines = [ln for ln in log_text.split("\n") if ln]
+        self.assertEqual(len(lines), 1)
+        entry = json.loads(lines[0])
+
+        self.assertEqual(entry["action"], "agent_spawn")
+        self.assertEqual(entry["skill"], "security-and-auth")
+        self.assertTrue(entry["has_profile"])
+        self.assertTrue(entry["has_file_assignment"])
+        self.assertIn("hook_duration_ms", entry)
+        self.assertIsInstance(entry["hook_duration_ms"], int)
+        self.assertGreaterEqual(entry["hook_duration_ms"], 0)
+        self.assertEqual(len(entry["desc_hash"]), 64)
+
+    def test_redacts_secrets_in_description(self):
+        fixture = load_fixture("sample_payload_with_secrets.json")
+        rc, out = self._run_main_with(fixture)
+        self.assertEqual(rc, 0)
+
+        log_text = self.read_audit_log()
+        entry = json.loads([ln for ln in log_text.split("\n") if ln][0])
+
+        # The redacted preview must NOT contain the raw secret fragments
+        preview = entry["desc_preview"]
+        self.assertNotIn("sk-ABCDEFGHIJKLMNOPQRSTUV", preview)
+        self.assertNotIn("hunter2", preview)
+        self.assertNotIn("admin:hunter2", preview)
+        # But placeholders should appear
+        self.assertTrue(
+            "[API_KEY]" in preview or "[REDACTED]" in preview,
+            f"expected a redacted placeholder in: {preview}",
+        )
+
+    def test_hashes_full_description_regardless_of_redaction(self):
+        fixture = load_fixture("sample_payload_with_secrets.json")
+        self._run_main_with(fixture)
+        log_text = self.read_audit_log()
+        entry = json.loads([ln for ln in log_text.split("\n") if ln][0])
+        # SHA-256 hex length
+        self.assertEqual(len(entry["desc_hash"]), 64)
+        self.assertTrue(all(c in "0123456789abcdef" for c in entry["desc_hash"]))
+
+    def test_silent_stdout_exit_zero(self):
+        rc, out = self._run_main_with({
+            "session_id": "s",
+            "tool_name": "Agent",
+            "tool_input": {"description": "d", "prompt": "p"},
+        })
+        self.assertEqual(rc, 0)
+        self.assertEqual(out, "")
+
+    def test_handles_malformed_stdin_writes_breadcrumb(self):
+        old_stdin = sys.stdin
+        sys.stdin = io.StringIO("{not json")
+        try:
+            rc = al.main()
+        finally:
+            sys.stdin = old_stdin
+        self.assertEqual(rc, 0)
+        errs = self.read_audit_errors()
+        self.assertIn("stdin parse error", errs)
+
+    def test_rotates_when_over_size_threshold(self):
+        # Force a tiny rotation threshold
+        os.environ["CEO_AUDIT_LOG_ROTATE_BYTES"] = "200"
+        # Pre-seed the log with 300 bytes of dummy content
+        log_path = Path(os.environ["CEO_AUDIT_LOG_PATH"])
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        log_path.write_text("x" * 300, encoding="utf-8")
+
+        fixture = load_fixture("sample_payload_clean.json")
+        self._run_main_with(fixture)
+
+        # The original file should have been rotated away; a fresh one
+        # should hold our new entry.
+        rotated = list(self.audit_dir.glob("audit-log-*.jsonl"))
+        self.assertTrue(rotated, "rotation should have produced a monthly file")
+        fresh = self.read_audit_log()
+        fresh_lines = [ln for ln in fresh.split("\n") if ln]
+        self.assertEqual(len(fresh_lines), 1)
+
+    def test_non_agent_tool_name_is_noop(self):
+        rc, out = self._run_main_with({
+            "session_id": "s",
+            "tool_name": "Read",
+            "tool_input": {"description": "d", "prompt": "p"},
+        })
+        self.assertEqual(rc, 0)
+        self.assertEqual(self.read_audit_log(), "")
+
+    def test_fallback_when_claude_project_dir_unset(self):
+        os.environ.pop("CLAUDE_PROJECT_DIR", None)
+        fixture = load_fixture("sample_payload_clean.json")
+        rc, out = self._run_main_with(fixture)
+        self.assertEqual(rc, 0)
+        log_text = self.read_audit_log()
+        entry = json.loads([ln for ln in log_text.split("\n") if ln][0])
+        # Must have SOME project path (falls back to cwd resolve)
+        self.assertTrue(entry["project"])
+
+
+class TestFixtureAnonymization(TestEnvContext):
+    """Make sure committed fixtures don't accidentally contain real secrets."""
+
+    def test_clean_fixture_preview_is_stable(self):
+        from _lib.redact import redact_secrets
+
+        fixture = load_fixture("sample_payload_clean.json")
+        desc = fixture["tool_input"]["description"]
+        once = redact_secrets(desc, max_chars=0)
+        twice = redact_secrets(once, max_chars=0)
+        self.assertEqual(once, twice)
+
+    def test_secrets_fixture_redacts_to_placeholders(self):
+        from _lib.redact import redact_secrets
+
+        fixture = load_fixture("sample_payload_with_secrets.json")
+        desc = fixture["tool_input"]["description"]
+        redacted = redact_secrets(desc, max_chars=0)
+        self.assertNotIn("sk-ABCDEFGHIJKLMNOPQRSTUV", redacted)
+        self.assertNotIn("hunter2", redacted)
+
+
+@unittest.skipUnless(os.name == "posix", "POSIX only")
+class TestConcurrentWrites(TestEnvContext):
+    """Concurrent writes must not interleave — uses multiprocessing not threads."""
+
+    def test_concurrent_writes_no_interleaving(self):
+        # Snapshot env for children
+        env = {
+            "HOME": os.environ["HOME"],
+            "CLAUDE_PROJECT_DIR": os.environ["CLAUDE_PROJECT_DIR"],
+            "CEO_AUDIT_LOG_DIR": os.environ["CEO_AUDIT_LOG_DIR"],
+            "CEO_AUDIT_LOG_PATH": os.environ["CEO_AUDIT_LOG_PATH"],
+            "CEO_AUDIT_LOG_ERR": os.environ["CEO_AUDIT_LOG_ERR"],
+            "CEO_AUDIT_LOG_LOCK": os.environ["CEO_AUDIT_LOG_LOCK"],
+            "PYTHONPATH": str(Path(__file__).resolve().parent.parent),
+        }
+
+        workers = 3
+        iters_per_worker = 10
+        procs = []
+        for wid in range(workers):
+            p = multiprocessing.Process(
+                target=_concurrent_write_worker, args=(wid, env)
+            )
+            procs.append(p)
+            p.start()
+        for p in procs:
+            p.join(timeout=30)
+            self.assertFalse(p.is_alive())
+
+        log_text = self.read_audit_log()
+        lines = [ln for ln in log_text.split("\n") if ln]
+        self.assertEqual(len(lines), workers * iters_per_worker)
+        # Every line must be valid JSON
+        for ln in lines:
+            entry = json.loads(ln)
+            self.assertEqual(entry["action"], "agent_spawn")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/.claude/hooks/tests/test_audit_log_coverage.py

@@ -0,0 +1,173 @@
+"""In-process coverage uplift for audit_log.py utility functions.
+
+PLAN-112-FOLLOWUP-coverage-doctrine-reconcile (S157) / ADR-139 Tier-1.
+
+audit_log.py is exercised mostly through build_entry/append_entry happy
+paths; the rotation, breadcrumb, sanitize and validation helpers carry
+fail-open `except` branches and bucket edges that the subprocess suite
+does not reach. These tests call those helpers directly in-process.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from _lib.testing import TestEnvContext  # noqa: E402
+
+import audit_log as al  # noqa: E402
+
+
+class AuditLogHelpersTest(TestEnvContext):
+
+    # --- rotate_threshold ------------------------------------------------
+
+    def test_rotate_threshold_bad_env_falls_back(self):
+        with mock.patch.dict(os.environ, {"CEO_AUDIT_LOG_ROTATE_BYTES": "notanint"}):
+            self.assertEqual(al.rotate_threshold(), al.DEFAULT_ROTATE_AT_BYTES)
+
+    def test_rotate_threshold_good_env(self):
+        with mock.patch.dict(os.environ, {"CEO_AUDIT_LOG_ROTATE_BYTES": "12345"}):
+            self.assertEqual(al.rotate_threshold(), 12345)
+
+    # --- bucket_prompt_length (all buckets) ------------------------------
+
+    def test_bucket_prompt_length_all_buckets(self):
+        self.assertEqual(al.bucket_prompt_length(10), "<256")
+        self.assertEqual(al.bucket_prompt_length(500), "<1024")
+        self.assertEqual(al.bucket_prompt_length(2000), "<4096")
+        self.assertEqual(al.bucket_prompt_length(10000), "<16384")
+        self.assertEqual(al.bucket_prompt_length(40000), "<65536")
+        self.assertEqual(al.bucket_prompt_length(100000), ">=65536")
+
+    # --- _sanitize_prompt ------------------------------------------------
+
+    def test_sanitize_prompt_non_string(self):
+        self.assertIsNone(al._sanitize_prompt(12345))  # type: ignore[arg-type]
+
+    def test_sanitize_prompt_empty(self):
+        self.assertIsNone(al._sanitize_prompt("   "))
+
+    def test_sanitize_prompt_over_char_cap(self):
+        self.assertIsNone(al._sanitize_prompt("a" * (al._MAX_INPUT_CHARS + 1)))
+
+    def test_sanitize_prompt_nul_byte(self):
+        self.assertIsNone(al._sanitize_prompt("hello\x00world"))
+
+    def test_sanitize_prompt_ok(self):
+        self.assertEqual(al._sanitize_prompt("normal prompt"), "normal prompt")
+
+    # --- _validate_skill_name --------------------------------------------
+
+    def test_validate_skill_name_too_long(self):
+        self.assertFalse(al._validate_skill_name("a" * (al._MAX_SKILL_NAME_CHARS + 1)))
+
+    def test_validate_skill_name_traversal(self):
+        self.assertFalse(al._validate_skill_name("../etc"))
+        self.assertFalse(al._validate_skill_name("a/b"))
+        self.assertFalse(al._validate_skill_name("a\\b"))
+
+    def test_validate_skill_name_bad_charset(self):
+        self.assertFalse(al._validate_skill_name("bad name!"))
+
+    def test_validate_skill_name_ok(self):
+        self.assertTrue(al._validate_skill_name("security-engineer"))
+
+    # --- _legacy_rotate_inline -------------------------------------------
+
+    def test_legacy_rotate_inline_nonexistent(self):
+        missing = self.project_dir / "nope.jsonl"
+        self.assertIsNone(al._legacy_rotate_inline(missing, 10))
+
+    def test_legacy_rotate_inline_under_threshold(self):
+        small = self.project_dir / "small.jsonl"
+        small.write_text("x", encoding="utf-8")
+        self.assertIsNone(al._legacy_rotate_inline(small, 1024))
+
+    def test_legacy_rotate_inline_rotates(self):
+        big = self.project_dir / "audit-log.jsonl"
+        big.write_text("y" * 200, encoding="utf-8")
+        rotated = al._legacy_rotate_inline(big, 50)
+        self.assertIsNotNone(rotated)
+        self.assertTrue(rotated.exists())
+        self.assertFalse(big.exists())
+
+    def test_legacy_rotate_inline_collision_suffix(self):
+        big = self.project_dir / "audit-log.jsonl"
+        big.write_text("z" * 200, encoding="utf-8")
+        # Pre-create the primary rotated name so the collision loop fires.
+        month = al.now_month_slug()
+        (self.project_dir / f"audit-log-{month}.jsonl").write_text("old", encoding="utf-8")
+        rotated = al._legacy_rotate_inline(big, 50)
+        self.assertIsNotNone(rotated)
+        self.assertIn(f"{month}-1", rotated.name)
+
+    # --- rotate_if_needed ------------------------------------------------
+
+    def test_rotate_if_needed_import_fallback(self):
+        big = self.project_dir / "audit-log.jsonl"
+        big.write_text("q" * 200, encoding="utf-8")
+        with mock.patch.dict("sys.modules", {"_lib.audit_rotation": None}):
+            rotated = al.rotate_if_needed(big, 50)
+        self.assertIsNotNone(rotated)
+
+    def test_rotate_if_needed_no_rotation(self):
+        small = self.project_dir / "audit-log.jsonl"
+        small.write_text("x", encoding="utf-8")
+        self.assertIsNone(al.rotate_if_needed(small, 100000))
+
+    # --- write_breadcrumb ------------------------------------------------
+
+    def test_write_breadcrumb_ok(self):
+        err = self.audit_dir / "audit-log.errors"
+        al.write_breadcrumb(err, "test message")
+        self.assertIn("test message", err.read_text(encoding="utf-8"))
+
+    def test_write_breadcrumb_oserror_falls_back_to_stderr(self):
+        # Parent is a regular file -> mkdir(parents=True) raises OSError.
+        blocker = self.project_dir / "blocker"
+        blocker.write_text("f", encoding="utf-8")
+        bad = blocker / "sub" / "err.log"
+        # Must not raise.
+        al.write_breadcrumb(bad, "breadcrumb under file")
+
+    # --- _is_safe_audit_path ---------------------------------------------
+
+    def test_is_safe_audit_path_nonexistent(self):
+        ok, reason = al._is_safe_audit_path(self.project_dir / "ghost", os.getuid())
+        self.assertTrue(ok)
+        self.assertEqual(reason, "")
+
+    def test_is_safe_audit_path_symlink_rejected(self):
+        target = self.project_dir / "real.jsonl"
+        target.write_text("x", encoding="utf-8")
+        link = self.project_dir / "link.jsonl"
+        link.symlink_to(target)
+        ok, reason = al._is_safe_audit_path(link, os.getuid())
+        self.assertFalse(ok)
+        self.assertEqual(reason, "symlink_rejected")
+
+    def test_is_safe_audit_path_uid_mismatch(self):
+        target = self.project_dir / "owned.jsonl"
+        target.write_text("x", encoding="utf-8")
+        ok, reason = al._is_safe_audit_path(target, os.getuid() + 999999)
+        self.assertFalse(ok)
+        self.assertIn("uid_mismatch", reason)
+
+    # --- _fallback_security_breadcrumb -----------------------------------
+
+    def test_fallback_security_breadcrumb_ok(self):
+        # Must not raise.
+        al._fallback_security_breadcrumb("unit-test security breadcrumb")
+
+    def test_fallback_security_breadcrumb_getuser_raises(self):
+        with mock.patch("getpass.getuser", side_effect=OSError("no user")), \
+                mock.patch.dict(os.environ, {"USER": "fallbackuser"}):
+            al._fallback_security_breadcrumb("getuser raised path")
+
+
+if __name__ == "__main__":
+    unittest.main()