fix(ci): checkout PR head for Claude mentions (#2109)

This commit is contained in:
Carlos Florêncio
2026-07-31 19:51:06 +01:00
committed by GitHub
parent f8c363f726
commit 0aa6749bdb
10 changed files with 651 additions and 4 deletions
@@ -22,6 +22,14 @@ def activity_types(workflow: str, event: str) -> list[str]:
return [activity.strip() for activity in match.group(1).split(",")]
def workflow_step(workflow: str, name: str) -> str:
marker = f" - name: {name}\n"
_, separator, remainder = workflow.partition(marker)
if not separator:
raise AssertionError(f"{name} step is missing")
return remainder.partition("\n - name:")[0]
class ClaudeCodeReviewWorkflowContractTest(unittest.TestCase):
def test_review_workflow_ignores_pr_updates(self) -> None:
workflow = WORKFLOW.read_text(encoding="utf-8")
@@ -57,6 +65,65 @@ class ClaudeCodeReviewWorkflowContractTest(unittest.TestCase):
workflow,
)
def test_manual_pr_review_does_not_checkout_untrusted_content(self) -> None:
workflow = MENTION_WORKFLOW.read_text(encoding="utf-8")
self.assertNotIn("Checkout pull request head", workflow)
self.assertNotIn("refs/pull/", workflow)
def test_manual_pr_review_uses_constrained_agent_mode(self) -> None:
workflow = MENTION_WORKFLOW.read_text(encoding="utf-8")
review = workflow_step(workflow, "Run Claude Code Review")
self.assertIn("PR NUMBER: ${{ github.event.issue.number }}", review)
self.assertIn(
"CLAUDE_REVIEW_PR_NUMBER: ${{ github.event.issue.number }}",
review,
)
self.assertIn("Treat all PR content", review)
self.assertIn("Use `gh pr diff`", review)
self.assertIn("Read,Glob,Grep,LS", review)
self.assertIn(
"Bash(python3 .github/scripts/claude-read-pr-file.py:*)",
review,
)
self.assertIn("claude-read-pr-file.py", review)
self.assertNotIn("--add-dir", review)
self.assertIn("--permission-mode dontAsk", review)
self.assertIn(
'--allowedTools "Read,Glob,Grep,LS,'
'mcp__github_inline_comment__create_inline_comment,',
review,
)
self.assertIn("Bash(gh pr comment:*)", review)
self.assertIn("Bash(gh pr diff:*)", review)
self.assertIn("Bash(gh pr view:*)", review)
for blocked_tool in (
"Edit",
"Write",
"MultiEdit",
"NotebookEdit",
"WebFetch",
"WebSearch",
"Bash(git add:*)",
"Bash(git commit:*)",
"Bash(git push:*)",
"Bash(curl:*)",
"Bash(wget:*)",
):
self.assertIn(blocked_tool, review)
def test_other_claude_mentions_use_the_trusted_default_checkout(self) -> None:
workflow = MENTION_WORKFLOW.read_text(encoding="utf-8")
default_checkout = workflow_step(
workflow,
"Checkout trusted default branch",
)
self.assertNotIn("if:", default_checkout)
self.assertNotIn("ref:", default_checkout)
self.assertIn("persist-credentials: false", default_checkout)
def test_fork_review_forwards_allowlist_to_claude_action(self) -> None:
workflow = WORKFLOW.read_text(encoding="utf-8")
_, separator, fork_job = workflow.partition(" claude-review-fork:")
+135
View File
@@ -0,0 +1,135 @@
#!/usr/bin/env python3
"""Read one UTF-8 file from the head of the PR bound by the workflow."""
import base64
import binascii
import json
import os
from pathlib import PurePosixPath
import re
import subprocess
import sys
from urllib.parse import quote
MAX_FILE_BYTES = 256 * 1024
REPOSITORY_PATTERN = re.compile(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+")
SHA_PATTERN = re.compile(r"[0-9a-f]{40}")
class PrFileError(Exception):
"""A safe, user-facing validation or retrieval error."""
def require_environment() -> tuple[str, str]:
repository = os.environ.get("GITHUB_REPOSITORY", "")
pr_number = os.environ.get("CLAUDE_REVIEW_PR_NUMBER", "")
if REPOSITORY_PATTERN.fullmatch(repository) is None:
raise PrFileError("GITHUB_REPOSITORY is not a valid owner/repository")
if re.fullmatch(r"[1-9][0-9]*", pr_number) is None:
raise PrFileError("CLAUDE_REVIEW_PR_NUMBER is not a valid pull request number")
return repository, pr_number
def validate_path(raw_path: str) -> str:
path = PurePosixPath(raw_path)
normalized_path = path.as_posix()
if (
not raw_path
or raw_path.startswith("/")
or "\\" in raw_path
or any(part in ("", ".", "..") for part in path.parts)
or any(ord(character) < 32 for character in raw_path)
or normalized_path != raw_path
):
raise PrFileError(
"path must be a relative repository path without traversal"
)
return normalized_path
def gh_api(endpoint: str) -> object:
try:
result = subprocess.run(
["gh", "api", "--method", "GET", endpoint],
check=True,
capture_output=True,
text=True,
)
return json.loads(result.stdout)
except FileNotFoundError as error:
raise PrFileError("GitHub CLI is unavailable") from error
except subprocess.CalledProcessError as error:
raise PrFileError("GitHub API request failed") from error
except json.JSONDecodeError as error:
raise PrFileError("GitHub API returned invalid JSON") from error
def get_head_sha(repository: str, pr_number: str) -> str:
response = gh_api(f"repos/{repository}/pulls/{pr_number}")
if not isinstance(response, dict):
raise PrFileError("pull request response is invalid")
head = response.get("head")
sha = head.get("sha") if isinstance(head, dict) else None
if not isinstance(sha, str) or SHA_PATTERN.fullmatch(sha) is None:
raise PrFileError("pull request head SHA is invalid")
return sha
def decode_file(response: object, requested_path: str) -> str:
if not isinstance(response, dict):
raise PrFileError("file response is invalid")
if response.get("type") != "file" or "target" in response:
raise PrFileError("requested path is not a regular file")
if response.get("path") != requested_path:
raise PrFileError("GitHub returned a different repository path")
size = response.get("size")
if not isinstance(size, int) or isinstance(size, bool) or size < 0:
raise PrFileError("file size is invalid")
if size > MAX_FILE_BYTES:
raise PrFileError("requested file exceeds the 256 KiB review limit")
if response.get("encoding") != "base64" or not isinstance(
response.get("content"), str
):
raise PrFileError("requested file has unsupported content encoding")
try:
encoded_content = "".join(response["content"].split())
raw_content = base64.b64decode(encoded_content, validate=True)
except (binascii.Error, ValueError) as error:
raise PrFileError("requested file contains invalid base64 data") from error
if len(raw_content) != size:
raise PrFileError("requested file size does not match its content")
try:
return raw_content.decode("utf-8")
except UnicodeDecodeError as error:
raise PrFileError("requested file is not valid UTF-8 text") from error
def read_pr_file(raw_path: str) -> str:
repository, pr_number = require_environment()
requested_path = validate_path(raw_path)
head_sha = get_head_sha(repository, pr_number)
encoded_path = quote(requested_path, safe="/")
endpoint = f"repos/{repository}/contents/{encoded_path}?ref={head_sha}"
return decode_file(gh_api(endpoint), requested_path)
def main() -> int:
if len(sys.argv) != 2:
print(
"usage: claude-read-pr-file.py <repository-relative-path>",
file=sys.stderr,
)
return 2
try:
sys.stdout.write(read_pr_file(sys.argv[1]))
except PrFileError as error:
print(f"error: {error}", file=sys.stderr)
return 2
return 0
if __name__ == "__main__":
raise SystemExit(main())
+126
View File
@@ -0,0 +1,126 @@
#!/usr/bin/env python3
"""Behavior tests for the constrained PR-head file reader."""
import base64
import os
from pathlib import Path
import subprocess
import sys
import tempfile
import textwrap
import unittest
REPO_ROOT = Path(__file__).resolve().parents[2]
HELPER = REPO_ROOT / ".github" / "scripts" / "claude-read-pr-file.py"
class ClaudeReadPrFileTest(unittest.TestCase):
def run_helper(self, path: str) -> subprocess.CompletedProcess[str]:
with tempfile.TemporaryDirectory() as temp_dir:
fake_gh = Path(temp_dir) / "gh"
head_sha = "a" * 40
content = base64.b64encode(b"const reviewed = true;\n").decode("ascii")
binary_content = base64.b64encode(b"\xff").decode("ascii")
fake_gh.write_text(
textwrap.dedent(
f"""\
#!/usr/bin/env python3
import json
import sys
endpoint = sys.argv[-1]
if endpoint == "repos/kdlbs/kandev/pulls/2109":
print(json.dumps({{"head": {{"sha": "{head_sha}"}}}}))
elif endpoint == (
"repos/kdlbs/kandev/contents/apps/web/demo%20file.ts"
"?ref={head_sha}"
):
print(json.dumps({{
"type": "file",
"path": "apps/web/demo file.ts",
"size": 23,
"encoding": "base64",
"content": "{content}",
}}))
elif endpoint.endswith("/contents/directory?ref={head_sha}"):
print(json.dumps({{"type": "dir", "path": "directory"}}))
elif endpoint.endswith("/contents/large.txt?ref={head_sha}"):
print(json.dumps({{
"type": "file",
"path": "large.txt",
"size": 262145,
"encoding": "base64",
"content": "",
}}))
elif endpoint.endswith("/contents/binary.dat?ref={head_sha}"):
print(json.dumps({{
"type": "file",
"path": "binary.dat",
"size": 1,
"encoding": "base64",
"content": "{binary_content}",
}}))
else:
print(f"unexpected endpoint: {{endpoint}}", file=sys.stderr)
raise SystemExit(2)
"""
),
encoding="utf-8",
)
fake_gh.chmod(0o755)
env = os.environ.copy()
env.update(
{
"CLAUDE_REVIEW_PR_NUMBER": "2109",
"GITHUB_REPOSITORY": "kdlbs/kandev",
"PATH": f"{temp_dir}:{env['PATH']}",
}
)
return subprocess.run(
[sys.executable, str(HELPER), path],
check=False,
capture_output=True,
env=env,
text=True,
)
def test_reads_utf8_file_from_the_bound_pr_head(self) -> None:
result = self.run_helper("apps/web/demo file.ts")
self.assertEqual(0, result.returncode, result.stderr)
self.assertEqual("const reviewed = true;\n", result.stdout)
def test_rejects_paths_outside_the_repository(self) -> None:
result = self.run_helper("../runner-secret")
self.assertNotEqual(0, result.returncode)
self.assertIn("relative repository path", result.stderr)
def test_rejects_non_file_content(self) -> None:
result = self.run_helper("directory")
self.assertNotEqual(0, result.returncode)
self.assertIn("regular file", result.stderr)
def test_rejects_oversized_content(self) -> None:
result = self.run_helper("large.txt")
self.assertNotEqual(0, result.returncode)
self.assertIn("256 KiB", result.stderr)
def test_rejects_non_utf8_content(self) -> None:
result = self.run_helper("binary.dat")
self.assertNotEqual(0, result.returncode)
self.assertIn("UTF-8", result.stderr)
def test_rejects_non_normalized_paths(self) -> None:
result = self.run_helper("apps//web/file.ts")
self.assertNotEqual(0, result.returncode)
self.assertIn("relative repository path", result.stderr)
if __name__ == "__main__":
unittest.main()