"""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())