From 792a69ebfea6e879c5053d8b47d8ffcd32bb0b1b Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Thu, 22 Oct 2026 12:11:05 -0400 Subject: [PATCH] Combine authorship validation with the required APK result (#1329) Combine trusted source and squash-metadata validation with the exact-head APK compilation result. Preserve automatic trailer cleanup in the installed hooks. Validated with 10 authorship/hook tests and 9 combined-gate tests. --- .github/workflows/authorship.yml | 50 +++++---------- .github/workflows/build.yml | 2 +- tools/release/validate_apk.py | 106 ++++++++++++++++++++++++++++++ tools/tests/test_validate_apk.py | 107 +++++++++++++++++++++++++++++++ 4 files changed, 230 insertions(+), 35 deletions(-) create mode 100644 tools/release/validate_apk.py create mode 100644 tools/tests/test_validate_apk.py diff --git a/.github/workflows/authorship.yml b/.github/workflows/authorship.yml index 4bbefa414b..97c6637a8f 100644 --- a/.github/workflows/authorship.yml +++ b/.github/workflows/authorship.yml @@ -1,58 +1,40 @@ -name: Human authorship +name: Build validation on: pull_request_target: + branches: [main] types: [opened, synchronize, reopened, edited, ready_for_review] push: branches: [main] + workflow_run: + workflows: [Build APK] + types: [completed] workflow_dispatch: + inputs: + pr_number: + description: Pull request to validate; empty for main + required: false permissions: contents: read + actions: read pull-requests: read statuses: write jobs: - authorship: - name: Validate human authorship + validate: + name: Build APK runs-on: ubuntu-24.04 timeout-minutes: 5 steps: - uses: actions/checkout@v4 with: - ref: ${{ github.event.repository.default_branch }} + ref: ${{ github.workflow_sha }} fetch-depth: 0 persist-credentials: false - - name: Check the proposed or merged history - id: validate + - name: Validate source and APK compilation env: GH_TOKEN: ${{ github.token }} - EVENT_NAME: ${{ github.event_name }} - PR_NUMBER: ${{ github.event.pull_request.number }} - BEFORE: ${{ github.event.before }} - AFTER: ${{ github.sha }} - PR_HEAD: ${{ github.event.pull_request.head.sha }} run: | - set -euo pipefail - if [ "$EVENT_NAME" = pull_request_target ]; then - gh auth setup-git - git fetch --no-tags origin "refs/pull/$PR_NUMBER/head" - test "$(git rev-parse FETCH_HEAD)" = "$PR_HEAD" - base=$(git merge-base HEAD FETCH_HEAD) - python3 tools/release/check_authorship.py "$base..FETCH_HEAD" --event "$GITHUB_EVENT_PATH" - elif [ "$EVENT_NAME" = push ] && [ "$BEFORE" != 0000000000000000000000000000000000000000 ]; then - python3 tools/release/check_authorship.py "$BEFORE..$AFTER" - else - python3 tools/release/check_authorship.py HEAD - fi - - name: Publish the required result on the actual proposed commit - if: always() - env: - GH_TOKEN: ${{ github.token }} - TARGET_SHA: ${{ github.event.pull_request.head.sha || github.sha }} - RESULT: ${{ steps.validate.outcome == 'success' && 'success' || 'failure' }} - RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} - run: | - gh api --method POST "repos/$GITHUB_REPOSITORY/statuses/$TARGET_SHA" \ - -f context='Human authorship' -f state="$RESULT" -f target_url="$RUN_URL" \ - -f description='Bot authors and bot co-author trailers are forbidden' + gh auth setup-git + python3 tools/release/validate_apk.py diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 32ea61e34d..aacad45f03 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -87,7 +87,7 @@ jobs: build: needs: xbox - name: Build APK + name: Compile and test APK if: ${{ github.event_name != 'pull_request' || !github.event.pull_request.draft }} runs-on: ubuntu-24.04 timeout-minutes: 45 diff --git a/tools/release/validate_apk.py b/tools/release/validate_apk.py new file mode 100644 index 0000000000..8ed51ebf19 --- /dev/null +++ b/tools/release/validate_apk.py @@ -0,0 +1,106 @@ +#!/usr/bin/env python3 +"""Publish the APK result only after trusted source and metadata validation.""" +import json +import os +import subprocess +from urllib.parse import urlencode + +from check_authorship import check_revision, event_violations + + +def api(path, *args): + return json.loads(subprocess.check_output(["gh", "api", path, *args], text=True)) + + +def compilation_state(run, jobs): + for job in jobs: + if job["name"] in ("Compile and test APK", "Build APK"): + if job["status"] != "completed": + return "pending" + return "success" if job["conclusion"] == "success" else "failure" + return "failure" if run["status"] == "completed" else "pending" + + +def fetch_source(ref, sha): + subprocess.run(["git", "fetch", "--no-tags", "origin", ref], check=True) + fetched = subprocess.check_output(["git", "rev-parse", "FETCH_HEAD"], text=True).strip() + if fetched != sha: + raise RuntimeError("Pull request changed while validating") + + +def documentation_only(sha): + base = subprocess.check_output(["git", "merge-base", "origin/main", sha], text=True).strip() + paths = subprocess.check_output(["git", "diff", "--no-renames", "--name-only", "-z", base, sha]).split(b"\0") + return all(path.endswith(b".md") or path in (b"LICENSE", b".gitignore") for path in paths if path) + + +def main(): + with open(os.environ["GITHUB_EVENT_PATH"], encoding="utf-8") as source: + event = json.load(source) + repo = os.environ["GITHUB_REPOSITORY"] + event_name = os.environ["GITHUB_EVENT_NAME"] + pr_number = event.get("number") if event_name == "pull_request_target" else None + if event_name == "workflow_dispatch": + pr_number = int(event.get("inputs", {}).get("pr_number") or 0) + run = event.get("workflow_run", {}) + expected = event.get("pull_request", {}).get("head", {}).get("sha") + if event_name == "workflow_run": + expected = run["head_sha"] + if run["event"] == "pull_request": + prs = api(f"repos/{repo}/commits/{expected}/pulls") + pr_number = next((pr["number"] for pr in prs + if pr["state"] == "open" and pr["head"]["sha"] == expected), None) + if pr_number is None: + print("Ignoring a superseded or closed pull request build") + return + elif run["head_branch"] != event["repository"]["default_branch"]: + return + if pr_number: + pr = api(f"repos/{repo}/pulls/{pr_number}") + sha = pr["head"]["sha"] + if pr["state"] != "open" or (expected and sha != expected): + print("Ignoring a superseded or closed pull request event") + return + ref = f"refs/pull/{pr_number}/head" + source_event = "pull_request" + else: + pr = None + sha = expected or event.get("after") or os.environ["GITHUB_SHA"] + ref = sha + source_event = "push" + state = "failure" + description = "APK source validation failed" + target = f"https://github.com/{repo}/actions/runs/{os.environ['GITHUB_RUN_ID']}" + try: + fetch_source(ref, sha) + commits, errors = check_revision(sha) + if pr: + errors.extend(event_violations({"pull_request": pr})) + if errors: + raise RuntimeError("\n".join(errors)) + print(f"Source and metadata validated for {len(commits)} commits") + if pr and documentation_only(sha): + state = "success" + description = "Source validated; no APK source changes" + return + query = urlencode({"head_sha": sha, "event": source_event, "per_page": 20}) + runs = api(f"repos/{repo}/actions/workflows/build.yml/runs?{query}")["workflow_runs"] + runs = [item for item in runs if item["head_sha"] == sha] + if runs: + latest = max(runs, key=lambda item: item["id"]) + jobs = api(f"repos/{repo}/actions/runs/{latest['id']}/jobs?per_page=100")["jobs"] + state = compilation_state(latest, jobs) + target = latest["html_url"] + else: + state = "pending" + description = {"pending": "Source validated; awaiting APK compilation", + "success": "Source validation and APK compilation passed", + "failure": "APK compilation failed"}[state] + finally: + api(f"repos/{repo}/statuses/{sha}", "--method", "POST", + "-f", "context=Build APK", "-f", f"state={state}", + "-f", f"description={description}", "-f", f"target_url={target}") + + +if __name__ == "__main__": + main() diff --git a/tools/tests/test_validate_apk.py b/tools/tests/test_validate_apk.py new file mode 100644 index 0000000000..d197d74cff --- /dev/null +++ b/tools/tests/test_validate_apk.py @@ -0,0 +1,107 @@ +import contextlib +import json +import os +from pathlib import Path +import subprocess +import sys +import tempfile +import unittest +from unittest.mock import patch + +RELEASE = Path(__file__).resolve().parents[1] / "release" +sys.path.insert(0, str(RELEASE)) +import validate_apk + + +class ValidateApkTest(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + subprocess.run(["git", "init", "-q", self.root], check=True) + self.git("config", "user.name", "Human Developer") + self.git("config", "user.email", "human@example.org") + self.git("commit", "--allow-empty", "-qm", "Baseline") + self.git("update-ref", "refs/remotes/origin/main", "HEAD") + self.statuses = [] + + def git(self, *args): + return subprocess.check_output(["git", "-C", self.root, *args], text=True).strip() + + def validate(self, message="Source change", body="", result="success", stale=False, completed=False, filename="source.kt"): + (self.root / filename).write_text(message) + self.git("add", filename) + self.git("commit", "--allow-empty", "-qm", message) + sha = self.git("rev-parse", "HEAD") + pr = {"number": 1, "state": "open", "head": {"sha": sha}, "user": {"login": "human", "type": "User"}, + "title": "Source change", "body": body} + event = {"number": 1, "pull_request": {"head": {"sha": "stale" if stale else sha}}} + if completed: + event = {"workflow_run": {"event": "pull_request", "head_sha": "stale" if stale else sha}} + path = self.root / "event.json" + path.write_text(json.dumps(event)) + + def api(path, *args): + if "/statuses/" in path: + self.statuses.append(dict(value.split("=", 1) for value in args if "=" in value)) + return {} + if path.endswith("/pulls/1"): + return pr + if "/commits/" in path and path.endswith("/pulls"): + return [pr] + if "workflows/build.yml/runs?" in path: + return {"workflow_runs": [{"id": 7, "head_sha": sha, "status": "completed", "html_url": "https://example.org/build"}]} + if path.endswith("/jobs?per_page=100"): + return {"jobs": [{"name": "Compile and test APK", "status": "in_progress" if result == "pending" else "completed", "conclusion": result}]} + raise AssertionError(path) + + env = {"GITHUB_EVENT_PATH": str(path), "GITHUB_REPOSITORY": "owner/repo", + "GITHUB_EVENT_NAME": "workflow_run" if completed else "pull_request_target", "GITHUB_RUN_ID": "8"} + with contextlib.chdir(self.root), patch.dict(os.environ, env), patch.object(validate_apk, "api", side_effect=api), patch.object(validate_apk, "fetch_source"): + validate_apk.main() + + def test_success_requires_compilation_and_clean_authorship(self): + self.validate() + self.assertEqual(self.statuses[-1]["state"], "success") + + def test_successful_build_cannot_hide_bot_commit(self): + with self.assertRaises(RuntimeError): + self.validate(message="Change\n\nCo-authored-by: OpenAI Codex ") + self.assertEqual(self.statuses[-1]["state"], "failure") + + def test_successful_build_cannot_hide_squash_metadata(self): + with self.assertRaises(RuntimeError): + self.validate(body="Co-authored-by: Claude ") + self.assertEqual(self.statuses[-1]["state"], "failure") + + def test_pending_or_failed_compilation_never_passes(self): + for result in ("pending", "failure"): + self.validate(result=result) + self.assertEqual(self.statuses[-1]["state"], result) + + def test_superseded_event_cannot_replace_current_status(self): + self.validate(stale=True) + self.assertEqual(self.statuses, []) + + def test_completed_build_revalidates_current_squash_metadata(self): + with self.assertRaises(RuntimeError): + self.validate(body="Co-authored-by: Claude ", completed=True) + self.assertEqual(self.statuses[-1]["state"], "failure") + + def test_superseded_build_cannot_replace_current_status(self): + self.validate(stale=True, completed=True) + self.assertEqual(self.statuses, []) + + def test_documentation_passes_without_waiting_for_a_skipped_build(self): + self.validate(filename="README.md", result="pending") + self.assertEqual(self.statuses[-1]["state"], "success") + + def test_renaming_code_to_documentation_still_requires_compilation(self): + (self.root / "source.kt").write_text("source") + self.git("add", "source.kt") + self.git("commit", "-qm", "Add source") + self.git("update-ref", "refs/remotes/origin/main", "HEAD") + self.git("mv", "source.kt", "README.md") + self.git("commit", "-qm", "Rename source") + with contextlib.chdir(self.root): + self.assertFalse(validate_apk.documentation_only(self.git("rev-parse", "HEAD")))