Datasets:
Tasks:
Text Generation
Formats:
parquet
Sub-tasks:
language-modeling
Languages:
English
Size:
< 1K
License:
| """Run the original trusted coding rubric in a fresh, offline verifier container.""" | |
| from __future__ import annotations | |
| import asyncio | |
| import hashlib | |
| import importlib | |
| import importlib.metadata | |
| import json | |
| import os | |
| import shlex | |
| import shutil | |
| import signal | |
| import subprocess | |
| import sys | |
| from pathlib import Path | |
| from typing import Any | |
| from evidence import REVISION, validate_report | |
| OUT = Path("/logs/verifier") | |
| PRIVATE = Path("/var/lib/task-evidence") | |
| CONFIG = Path("/tests/config.json") | |
| PATCH = Path("/workspace/submissions/submitted.patch") | |
| GRADER_HOME = "/tmp/agent-home" | |
| def _run(command: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]: | |
| return subprocess.run(command, text=True, capture_output=True, timeout=300, **kwargs) | |
| def _preflight(config: dict[str, Any]) -> None: | |
| if importlib.metadata.version("hud") != config["grader_version"]: | |
| raise RuntimeError("Grader library version does not match the task") | |
| for filename, expected in config["verifier_files"].items(): | |
| if hashlib.sha256(Path(filename).read_bytes()).hexdigest() != expected: | |
| raise RuntimeError(f"Verifier source changed: {filename}") | |
| for command in config["preflight"]: | |
| completed = _run(command, cwd="/workspace/repo") | |
| if completed.returncode: | |
| raise RuntimeError(f"Prerequisite failed: {command}: {completed.stderr[-2000:]}") | |
| def _readable_mode(path: Path) -> int: | |
| # World-readable, keeping what is executable so: a grader may ship tools. | |
| return 0o755 if path.is_dir() or path.stat().st_mode & 0o111 else 0o644 | |
| def _permissions() -> None: | |
| # The orchestrator owns reports and rubric definitions. Grader commands, | |
| # and so the candidate's code, run as uid 1000: the user the task installed | |
| # its toolchain and caches for. They cannot read gold/vault or overwrite | |
| # the rubric or the result files, which stay root's. | |
| Path("/hud").chmod(0o711) | |
| for root in (Path("/hud/grader"), Path("/hud/base"), Path("/hud/base-src")): | |
| if root.exists(): | |
| root.chmod(0o755) | |
| for path in root.rglob("*"): | |
| if not path.is_symlink(): | |
| path.chmod(_readable_mode(path)) | |
| home = Path(GRADER_HOME) | |
| home.mkdir(parents=True, exist_ok=True) | |
| os.chown(home, 1000, 1000) | |
| for directory in ("/hud/logs", "/hud/gocache", "/hud/grader/runner"): | |
| path = Path(directory) | |
| path.mkdir(parents=True, exist_ok=True) | |
| for item in (path, *path.rglob("*")): | |
| if not item.is_symlink(): | |
| os.chown(item, 1000, 1000) | |
| item.chmod(_readable_mode(item)) | |
| def _hand_over_checkout() -> None: | |
| # The original grader runs as root and may run the candidate's own suite in | |
| # place, which writes into the tree. The rubric resets and re-applies the | |
| # candidate as root, so give what root touched back to the grading user. | |
| # Installed dependency trees are large and already that user's. | |
| subprocess.run( | |
| [ | |
| "find", | |
| "/workspace/repo", | |
| "-path", | |
| "*/node_modules", | |
| "-prune", | |
| "-o", | |
| "!", | |
| "-user", | |
| "1000", | |
| "-exec", | |
| "chown", | |
| "-h", | |
| "1000:1000", | |
| "{}", | |
| "+", | |
| ], | |
| check=True, | |
| capture_output=True, | |
| timeout=3600, | |
| ) | |
| async def _grade(config: dict[str, Any], record: dict[str, Any]) -> None: | |
| _preflight(config) | |
| sys.path.insert(0, "/app") | |
| task: Any = importlib.import_module("tasks") | |
| await task._setup() | |
| _permissions() | |
| patch = PATCH.read_bytes() | |
| if patch: | |
| checked = _run(["git", "apply", "--check", str(PATCH)], cwd="/workspace/repo") | |
| if checked.returncode: | |
| record.update( | |
| status="rejected_patch", | |
| patch_error=checked.stderr[-4000:], | |
| result={"reward": 0.0, "subscores": None}, | |
| ) | |
| return | |
| _run(["git", "apply", str(PATCH)], cwd="/workspace/repo", check=True) | |
| original = task.BashGrader | |
| fault_exit = config.get("fault_exit") | |
| faulted: list[tuple[tuple[Any, ...], dict[str, Any], str]] = [] | |
| class ObservedGrader: | |
| async def grade(cls, *args: Any, **kwargs: Any) -> Any: | |
| command = kwargs["command"] | |
| _hand_over_checkout() | |
| kwargs["command"] = ( | |
| "setpriv --reuid 1000 --regid 1000 --clear-groups --no-new-privs " | |
| f"env HOME={GRADER_HOME} bash -lc " + shlex.quote(command) | |
| ) | |
| score = await original.grade(*args, **kwargs) | |
| snapshot = score.model_dump(mode="json") | |
| record["commands"].append(snapshot) | |
| (PRIVATE / "commands.json").write_text(json.dumps(record["commands"], indent=2)) | |
| info = snapshot.get("info") or {} | |
| if info.get("timed_out") or type(info.get("exit_code")) is not int: | |
| raise RuntimeError(f"Grader infrastructure failure: {snapshot['name']}") | |
| if fault_exit is not None and info["exit_code"] == fault_exit: | |
| # The grader says it could not judge. Whether the submission or | |
| # the environment is the reason is settled after grading. | |
| faulted.append((args, dict(kwargs), snapshot["name"])) | |
| elif info["exit_code"] not in (0, 1): | |
| raise RuntimeError(f"Grader command exit {info['exit_code']}: {snapshot['name']}") | |
| return score | |
| task.BashGrader = ObservedGrader | |
| result = await task._grade(None) | |
| if faulted: | |
| # Ask the same commands about the untouched repository. A verdict there | |
| # means the grader works here and the submission is what it could not | |
| # judge, so the criterion stays unmet. No verdict there means the | |
| # environment is at fault, and the attempt is invalid. | |
| await task.repo_lib.git(task.REPO_DIR, "reset", "--hard", "HEAD") | |
| await task.repo_lib.git(task.REPO_DIR, "clean", "-fd") | |
| # Graders keep state between criteria, some of them a copy of the tree | |
| # they judged. It describes the submission, so it goes too. | |
| for leftover in Path(getattr(task, "LOGS_DIR", "/hud/logs")).iterdir(): | |
| if leftover.is_dir() and not leftover.is_symlink(): | |
| shutil.rmtree(leftover) | |
| else: | |
| leftover.unlink() | |
| record["fault_probes"] = [] | |
| for args, kwargs, name in faulted: | |
| _hand_over_checkout() | |
| probe = (await original.grade(*args, **kwargs)).model_dump(mode="json") | |
| info = probe.get("info") or {} | |
| record["fault_probes"].append( | |
| { | |
| "name": name, | |
| "exit_code": info.get("exit_code"), | |
| "timed_out": info.get("timed_out"), | |
| "stdout": (info.get("stdout") or "")[-2000:], | |
| } | |
| ) | |
| (PRIVATE / "fault_probes.json").write_text(json.dumps(record["fault_probes"], indent=2)) | |
| if info.get("timed_out") or info.get("exit_code") not in (0, 1): | |
| raise RuntimeError(f"Grader cannot judge the untouched repository: {name}") | |
| record["result"] = result.model_dump(mode="json") | |
| # A rubric may answer an empty change without running any criterion. | |
| record["status"] = "empty_patch" if not patch and not record["commands"] else "graded" | |
| def _stop_candidate_processes() -> None: | |
| # A candidate may fork. End its UID's processes before publishing evidence | |
| # to a host bind mount, whose permissions may differ on Docker Desktop. | |
| for directory in Path("/proc").iterdir(): | |
| if not directory.name.isdecimal(): | |
| continue | |
| try: | |
| status = (directory / "status").read_text() | |
| uid = next(line.split()[1] for line in status.splitlines() if line.startswith("Uid:")) | |
| if uid == "1000": | |
| os.kill(int(directory.name), signal.SIGKILL) | |
| except (FileNotFoundError, ProcessLookupError): | |
| pass | |
| def main() -> None: | |
| """Persist structured evidence and publish reward only after validation.""" | |
| OUT.mkdir(parents=True, exist_ok=True) | |
| PRIVATE.mkdir(parents=True, exist_ok=True, mode=0o700) | |
| PRIVATE.chmod(0o700) | |
| reward_path = OUT / "reward.txt" | |
| reward_path.unlink(missing_ok=True) | |
| config = json.loads(CONFIG.read_text()) | |
| shutil.copy2(CONFIG, OUT / "config.json") | |
| record: dict[str, Any] = { | |
| "revision": REVISION, | |
| "task_id": config["task_id"], | |
| "grader_version": importlib.metadata.version("hud"), | |
| "commands": [], | |
| "status": "error", | |
| } | |
| try: | |
| if PATCH.is_symlink() or not PATCH.is_file() or PATCH.stat().st_size > 32 * 1024 * 1024: | |
| raise ValueError("Missing, oversized or symlink submission") | |
| record["patch_sha256"] = hashlib.sha256(PATCH.read_bytes()).hexdigest() | |
| try: | |
| asyncio.run(_grade(config, record)) | |
| finally: | |
| _stop_candidate_processes() | |
| reward_path.unlink(missing_ok=True) | |
| validate_report(record, config, record["patch_sha256"]) | |
| (OUT / "report.json").write_text(json.dumps(record, indent=2)) | |
| reward_path.write_text(str(record["result"]["reward"]) + "\n") | |
| except BaseException as error: | |
| reward_path.unlink(missing_ok=True) | |
| record.update(status="error", error={"type": type(error).__name__, "message": str(error)}) | |
| (OUT / "report.json").write_text(json.dumps(record, indent=2)) | |
| raise | |
| if __name__ == "__main__": | |
| main() | |