Blame for common/source/starBenchserver/benchmarks/simBenchmarks/RoboDojo/environment/official_runtime.py

"""Create-only official-source deployment; no historical private asset manifest.

The checked-in asset inventory comes from the official Hugging Face Git/LFS
tree, not from an operator's local files. Existing assets are reused only after
their bytes match that inventory. Preparation never launches Isaac or accepts
its licence, and never edits the supplied source, dependencies or asset tree.
"""
from __future__ import annotations

import argparse
import io
import json
import re
from pathlib import Path
import subprocess
import tarfile

from benchmarks.simBenchmarks.RoboDojo.environment.reference_eef_runtime import (
    VERSIONS, canonical_digest, git, inventory, pins, safe_relative, sha,
    verify_layouts, verify_rows,
)

SCHEMA = "starvla-rsi.robodojo-official-runtime/v1"
PROTOCOL = "robodojo-official-hf91f76c28-rgb-proprio28-eef16-feedback-v1"
ASSET_REPOSITORY = "RoboDojo-Benchmark/RoboDojo"
ASSET_REVISION = "91f76c28d93dd20c5fa46ce6a5a1d96a4f384acd"
ASSET_GIT_TREE = "c83388f8d8300ad7bf09f5970e7822f024c4d4cd"
ASSET_INVENTORY_SHA256 = "2737e6458b05286210587a15023176845376ffbc02def02ab58716e28cbc487b"
ASSET_FILE = Path(__file__).with_name("official_assets.json")
DEPENDENCIES = {
    "isaaclab": ("https://github.com/yuechen0614/IsaacLab.git", "afca7b09d60d8beb9c1cb28b43066499940b969b"),
    "curobo": ("https://github.com/yuechen0614/curobo.git", "d17b54ce32cba095c0b000c4c58777075d11de0e"),
}
OFFICIAL_TASKS = ("classify_objects", "stack_bowls")


def task_layout_rows(task: str) -> list[dict]:
    """Bind exact numbered candidate names to the official Git/LFS inventory.

    No layout JSON is parsed. Candidate count is independent of eval_num.
    """
    if task not in OFFICIAL_TASKS:
        raise ValueError("unsupported official RoboDojo task")
    pattern = re.compile(rf"Eval_Layout/RoboDojo/arx_x5/0/{re.escape(task)}_\d+\.json")
    rows = [{"name": row["path"].rsplit("/", 1)[1], "bytes": row["bytes"], "sha256": row["sha256"]}
            for row in asset_rows() if pattern.fullmatch(row["path"])]
    rows.sort(key=lambda row: int(row["name"].rsplit("_", 1)[1][:-5]))
    if not rows or [r["name"] for r in rows] != [f"{task}_{i}.json" for i in range(len(rows))]:
        raise ValueError("official task layout names are not a contiguous native schedule")
    return rows


def official_task_spec(task: str) -> dict:
    from benchmarks.simBenchmarks.RoboDojo.bench_server.protocol.task_catalog import task_spec
    spec = task_spec(task)
    rows = task_layout_rows(task)
    if spec["layout_binding"]["inventory_count"] != len(rows):
        raise ValueError("official task catalog candidate count differs from pinned assets")
    if task == "stack_bowls" and spec["layout_binding"] != {
            "inventory_count": len(rows), "id": "official-hf91f76c28-stack-bowls",
            "snapshot_sha256": sha(ASSET_FILE)}:
        raise ValueError("official task catalog and asset snapshot differ")
    return spec


def verify_task_layouts(source: Path, task: str) -> list[dict]:
    """Hash selected task files without interpreting private reset contents."""
    expected = task_layout_rows(task)
    directory = source / "Assets/Eval_Layout/RoboDojo/arx_x5/0"
    actual_names = sorted(p.name for p in directory.iterdir()
                          if re.fullmatch(rf"{re.escape(task)}_\d+\.json", p.name))
    if actual_names != sorted(row["name"] for row in expected):
        raise ValueError("official task layout candidate set changed")
    for row in expected:
        path = directory / row["name"]
        if path.is_symlink() or not path.is_file() or path.stat().st_size != row["bytes"] or sha(path) != row["sha256"]:
            raise ValueError("official task layout bytes changed")
    return expected


def asset_rows() -> list[dict]:
    rows = json.loads(ASSET_FILE.read_text())
    if canonical_digest(rows) != ASSET_INVENTORY_SHA256:
        raise ValueError("official HF asset inventory changed")
    return rows


def verify_asset_rows(root: Path, rows: list[dict]) -> None:
    # Path sorts components (Water/ before Water.mdl); the HF inventory sorts
    # complete POSIX names (Water.mdl before Water/). Compare canonical order
    # without changing either the required file set or any content hash.
    actual = sorted(inventory(root), key=lambda row: row["path"])
    if actual != rows:
        raise ValueError("official asset file inventory or bytes changed")


def _canonical(path: Path) -> Path:
    if not path.is_absolute() or path.resolve() != path or path.is_symlink():
        raise ValueError("official runtime paths must be canonical")
    return path


def verify_dependencies(document: dict) -> None:
    for name, (_, revision) in DEPENDENCIES.items():
        root = _canonical(Path(document[name + "_root"]))
        if (Path(git(root, "rev-parse", "--show-toplevel")) != root
                or git(root, "rev-parse", "HEAD") != revision
                or git(root, "status", "--porcelain", "--untracked-files=all")):
            raise ValueError(f"official {name} requires the clean pinned upstream checkout")
        verify_rows(root, document[name + "_files"], exclude=(".git",))
    for name in ("python", "recording_support", "asset_root"):
        _canonical(Path(document[name]))
    if not Path(document["python"]).is_file():
        raise ValueError("official native interpreter missing")
    verify_rows(Path(document["recording_support"]), document["recording_support_files"])


def worker_pythonpath(document: dict) -> list[str]:
    isaac = Path(document["isaaclab_root"])
    return [document["recording_support"],
            *(str(isaac / "source" / name) for name in
              ("isaaclab", "isaaclab_assets", "isaaclab_tasks", "isaaclab_mimic", "isaaclab_rl")),
            document["curobo_root"]]


def verify_import_locations(document: dict) -> None:
    """Reject editable-package paths that resolve to a different installation."""
    import importlib.util
    expected = {"isaaclab": Path(document["isaaclab_root"]) / "source/isaaclab/isaaclab",
                "curobo": Path(document["curobo_root"]) / "curobo",
                "numpy": Path(document["recording_support"]) / "numpy",
                "av": Path(document["recording_support"]) / "av"}
    for name, root in expected.items():
        spec = importlib.util.find_spec(name)
        if spec is None or not spec.origin or not Path(spec.origin).resolve().is_relative_to(root):
            raise ValueError(f"{name} import resolves outside the declared official runtime")


def load_runtime(manifest: Path, expected_sha256: str) -> dict:
    if (manifest.is_symlink() or not manifest.is_file() or manifest.stat().st_size > 32 * 1024 * 1024
            or sha(manifest) != expected_sha256):
        raise ValueError("official runtime manifest hash or file changed")
    value = json.loads(manifest.read_text())
    expected = {"schema": SCHEMA, "protocol": PROTOCOL,
                "native_revision": pins()["native_revision"], "versions": VERSIONS,
                "asset_repository": ASSET_REPOSITORY, "asset_revision": ASSET_REVISION,
                "asset_git_tree": ASSET_GIT_TREE, "asset_inventory_sha256": ASSET_INVENTORY_SHA256,
                "dependency_patches": {}, "historical_reference_equivalent": False}
    if any(value.get(key) != item for key, item in expected.items()):
        raise ValueError("official deployment identity changed")
    if value.get("asset_files") != asset_rows():
        raise ValueError("official deployment asset inventory changed")
    return value


def verify_runtime(manifest: Path, expected_sha256: str) -> dict:
    value = load_runtime(manifest, expected_sha256)
    source = manifest.parent.resolve() / "RoboDojo"
    verify_rows(source, value["source_files"], exclude=("Assets",))
    for row in pins()["source_files"]:
        if sha(source / row["path"]) != row["sha256"]:
            raise ValueError(f"official native source changed: {row['path']}")
    assets = _canonical(Path(value["asset_root"]))
    if not (source / "Assets").is_symlink() or (source / "Assets").resolve() != assets:
        raise ValueError("official external asset binding changed")
    verify_asset_rows(assets, asset_rows())
    verify_layouts(source)
    verify_dependencies(value)
    return value


def prepare(*, native_repository: Path, assets: Path, runtime_root: Path,
            python: Path, isaaclab_root: Path, curobo_root: Path, recording_support: Path) -> dict:
    runtime_root = runtime_root.absolute()
    if runtime_root.exists() or runtime_root.is_symlink() or not runtime_root.parent.is_dir():
        raise ValueError("official deployment must use a new directory under an existing parent")
    expected = pins()
    value = {"schema": SCHEMA, "protocol": PROTOCOL, "native_revision": expected["native_revision"],
             "native_source_url": "https://github.com/RoboDojo-Benchmark/RoboDojo.git",
             "versions": VERSIONS, "asset_repository": ASSET_REPOSITORY, "asset_revision": ASSET_REVISION,
             "asset_git_tree": ASSET_GIT_TREE, "asset_inventory_sha256": ASSET_INVENTORY_SHA256,
             "asset_files": asset_rows(), "asset_root": str(assets.resolve()),
             "python": str(python.resolve()), "recording_support": str(recording_support.resolve()),
             "recording_support_files": inventory(recording_support.resolve()),
             "dependency_patches": {}, "historical_reference_equivalent": False,
             "native_execution": False, "external_assets": True,
             "limitations": ["Native GPU readiness and renderer parity require separate diagnostics.",
                 "External asset bytes are verified before and after reset; this is not an OS access sandbox."]}
    for name, path in (("isaaclab", isaaclab_root), ("curobo", curobo_root)):
        root = path.resolve()
        value[name + "_root"] = str(root)
        value[name + "_files"] = inventory(root, exclude=(".git",))
        value[name + "_source"] = dict(zip(("url", "revision"), DEPENDENCIES[name]))
    verify_dependencies(value)
    verify_asset_rows(assets.resolve(), value["asset_files"])
    payload = subprocess.check_output(["git", "-C", str(native_repository), "archive", expected["native_revision"]])
    runtime_root.mkdir(mode=0o700)
    source = runtime_root / "RoboDojo"
    source.mkdir()
    with tarfile.open(fileobj=io.BytesIO(payload)) as bundle:
        for entry in bundle:
            target = source / safe_relative(entry.name.rstrip("/"))
            if entry.isdir():
                target.mkdir(parents=True, exist_ok=True)
            elif entry.isfile():
                target.parent.mkdir(parents=True, exist_ok=True)
                with bundle.extractfile(entry) as src, target.open("xb") as dst:
                    dst.write(src.read())
                target.chmod(entry.mode & 0o755)
            else:
                raise ValueError("native archive contains a link or special file")
    value["source_files"] = inventory(source)
    (source / "Assets").symlink_to(assets.resolve(), target_is_directory=True)
    manifest = runtime_root / "runtime_manifest.json"
    with manifest.open("x") as stream:
        json.dump(value, stream, indent=2, allow_nan=False)
        stream.write("\n")
    digest = sha(manifest)
    verify_runtime(manifest, digest)
    return {"runtime_manifest": str(manifest), "runtime_manifest_sha256": digest,
            "deployment_track": "official", "protocol": PROTOCOL, "native_execution": False}


def main(argv=None) -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    sub = parser.add_subparsers(dest="command", required=True)
    build = sub.add_parser("prepare")
    for name in ("native-repository", "assets", "runtime-root", "python", "isaaclab-root", "curobo-root", "recording-support"):
        build.add_argument("--" + name, required=True, type=Path)
    check = sub.add_parser("verify")
    check.add_argument("--manifest", required=True, type=Path)
    check.add_argument("--sha256", required=True)
    args = vars(parser.parse_args(argv))
    command = args.pop("command")
    result = prepare(**args) if command == "prepare" else verify_runtime(args["manifest"], args["sha256"])
    if command == "verify":
        result = {"verified": True, "protocol": result["protocol"], "native_execution": False}
    print(json.dumps(result, indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())