"""File/metadata-only readiness capture; never imports or initializes the SIM. Asset receipts establish archive/extraction provenance, not full live-asset attestation. Selected task/robot files are independently rehashed at reset. """ import argparse import hashlib import importlib.metadata import importlib.util import json import os from pathlib import Path import subprocess import sys from benchmarks.simBenchmarks.Behavior.bench_server.protocol import ( ARCHIVE_DEPLOYMENT, LIVE_DEPLOYMENT, REVISION, TASK_METADATA_SHA256, ) ARCHIVES = { "behavior-1k-assets": "09e9fce600f841dc611aa96c0b1b9f9074f56f0e67898b37b39bd00c38a0095e", "omnigibson-robot-assets": "3d813b2181e0581cf2300a40892de70f8475fe59346ceeea4fb9bf7ff21ce126", "2026-challenge-task-instances": "d4ac3d72dd585178e85d542f28d1b48233b886c80e196e2f9d3aa5993ba21f81", } ASSET_FILES = { "2026-challenge-task-instances/metadata/task.jsonl": TASK_METADATA_SHA256, "omnigibson-robot-assets/models/r1pro/r1pro.yaml": "63f841cffd5c499102416a797a22fa5b4cbaf146539df7dde8a4a1053e2326f1", "omnigibson-robot-assets/models/r1pro/urdf/r1pro.urdf": "b0d76760cbedfbcbe1ddc280380dd5f497bbca380313bc096d7239a2c50dae61", "2026-challenge-task-instances/scene_test/public/house_double_floor_lower/json/house_double_floor_lower_task_turning_on_radio_instances/house_double_floor_lower_task_turning_on_radio_0_301_template-tro_state.json": "30a0fe101da1cbf6eb3683d3f9da716399ccd7409974b459dc12a580d2c8ad13", } PACKAGES = ("omnigibson", "bddl", "joylo", "torch", "numpy", "isaacsim", "omegaconf", "hydra-core", "imageio", "imageio-ffmpeg") def digest(path): result = hashlib.sha256() with Path(path).open("rb") as stream: for block in iter(lambda: stream.read(1024 * 1024), b""): result.update(block) return result.hexdigest() def absolute(value): path = Path(value) if not path.is_absolute() or ".." in path.parts: raise ValueError("explicit absolute deployment paths required") return path def source_identity(source): source = absolute(source) def git(*args): return subprocess.run(["git", "-c", "safe.directory=" + str(source), "-C", str(source), *args], check=True, capture_output=True).stdout if git("rev-parse", "HEAD").decode().strip() != REVISION: raise ValueError("BEHAVIOR source revision differs") rows = [] roots = ("OmniGibson/omnigibson", "bddl3/bddl", "joylo/gello") for entry in git("ls-tree", "-rz", REVISION, "--", *roots).split(b"\0"): if not entry: continue meta, name = entry.split(b"\t", 1) mode, kind, expected = meta.decode().split() relative = name.decode() path = source / relative if kind != "blob" or mode not in ("100644", "100755") or path.is_symlink() or not path.is_file(): raise ValueError("unsupported or missing native source file") data = path.read_bytes() if hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest() != expected: raise ValueError("modified native source: " + relative) rows.append(relative) if not rows: raise ValueError("empty native source inventory") # -B only disables writes: stale or untracked bytecode may still be loaded. known = set(rows) for root in roots: for path in (source / root).rglob("*"): if path.is_symlink(): raise ValueError("native source symlink is not part of this deployment") if path.is_file() and path.suffix in (".py", ".pyc", ".pyo", ".so", ".yaml", ".json") and path.relative_to(source).as_posix() not in known: raise ValueError("untracked executable/config native source: " + str(path)) return {"revision": REVISION, "tracked_files_verified": len(rows), "roots": list(roots)} def runtime_identity(source): source = absolute(source) origins = {} for name, relative in {"omnigibson": "OmniGibson/omnigibson/__init__.py", "bddl": "bddl3/bddl/__init__.py", "gello": "joylo/gello/__init__.py"}.items(): spec = importlib.util.find_spec(name) # top-level only: does not execute package if spec is None or spec.origin is None or Path(spec.origin).resolve() != (source / relative).resolve(): raise ValueError("native module origin differs: " + name) origins[name] = str(Path(spec.origin).resolve()) versions = {name: importlib.metadata.version(name) for name in PACKAGES} if not versions["isaacsim"].startswith("5.1.") or sys.version_info[:2] != (3, 11): raise ValueError("native runtime requires Python3.11 and Isaac Sim5.1") if not Path(sys.executable).is_file() or not Path(sys.base_prefix).is_dir(): raise ValueError("runtime base or interpreter unavailable on current node") return {"python": sys.version.split()[0], "executable": str(Path(sys.executable).absolute()), "executable_sha256": digest(sys.executable), "base_prefix": sys.base_prefix, "versions": versions, "origins": origins} def asset_identity(data_root, receipts): root = absolute(data_root) if set(receipts) != set(ARCHIVES): raise ValueError("all three archive extraction receipts required") result = {} for name, expected in ARCHIVES.items(): path = absolute(receipts[name]) receipt = json.loads(path.read_text()) if (receipt.get("archive_sha256") != expected or receipt.get("source_commit") != REVISION or Path(receipt.get("target", "")).resolve() != (root / name).resolve() or not (root / name).is_dir()): raise ValueError("asset extraction receipt differs: " + name) result[name] = {"path": str(path), "sha256": digest(path)} for name, expected in ASSET_FILES.items(): if digest(root / name) != expected: raise ValueError("selected native asset differs: " + name) return result def live_asset_identity(data_root): """Verify selected current bytes, without asserting archive/download origin.""" root = absolute(data_root).resolve(strict=True) for name in ARCHIVES: directory = root / name if directory.is_symlink() or not directory.is_dir(): raise ValueError("missing real native asset directory: " + name) files = {} for name, expected in ASSET_FILES.items(): path = root / name if (path.is_symlink() or not path.is_file() or not path.resolve(strict=True).is_relative_to(root) or digest(path) != expected): raise ValueError("selected live native asset differs: " + name) files[name] = {"sha256": expected, "size_bytes": path.stat().st_size} return {"selected_files": files, "archive_origin_verified": False, "complete_asset_inventory_verified": False} def verify_track(recorded, deployment_track): """Bind the public deployment choice before creating a native worker.""" if deployment_track == ARCHIVE_DEPLOYMENT: if recorded.get("schema") != "behavior2026-deployment/v1" or "deployment_track" in recorded: raise ValueError("archive deployment manifest/track differs") elif deployment_track == LIVE_DEPLOYMENT: if (recorded.get("schema") != "behavior2026-live-deployment/v1" or recorded.get("deployment_track") != LIVE_DEPLOYMENT): raise ValueError("live deployment manifest/track differs") else: raise ValueError("unknown BEHAVIOR deployment track") def capture(source_root, data_root, receipts=None, *, deployment_track=ARCHIVE_DEPLOYMENT): if deployment_track not in (ARCHIVE_DEPLOYMENT, LIVE_DEPLOYMENT): raise ValueError("unknown BEHAVIOR deployment track") if deployment_track == LIVE_DEPLOYMENT and receipts is not None: raise ValueError("live deployment does not accept archive receipts") if deployment_track == ARCHIVE_DEPLOYMENT and receipts is None: raise ValueError("archive deployment requires extraction receipts") source = source_identity(source_root) runtime = runtime_identity(source_root) if deployment_track == LIVE_DEPLOYMENT: assets = live_asset_identity(data_root) return {"schema": "behavior2026-live-deployment/v1", "deployment_track": LIVE_DEPLOYMENT, "source_root": str(absolute(source_root)), "data_root": str(absolute(data_root)), "source": source, "runtime": runtime, "live_assets": assets, "selected_asset_files": ASSET_FILES, "asset_attestation_scope": "current selected task/robot bytes only; no archive origin or complete asset inventory attestation"} assets = asset_identity(data_root, receipts) return {"schema": "behavior2026-deployment/v1", "source_root": str(absolute(source_root)), "data_root": str(absolute(data_root)), "source": source, "runtime": runtime, "asset_receipts": assets, "selected_asset_files": ASSET_FILES, "asset_attestation_scope": "verified archive extraction receipts and selected files; not all live asset bytes"} def verify(path, expected_sha256, *, deployment_track=ARCHIVE_DEPLOYMENT): path = absolute(path) if digest(path) != expected_sha256: raise ValueError("deployment manifest hash differs") recorded = json.loads(path.read_text()) verify_track(recorded, deployment_track) receipts = ({name: row["path"] for name, row in recorded["asset_receipts"].items()} if deployment_track == ARCHIVE_DEPLOYMENT else None) current = capture(recorded["source_root"], recorded["data_root"], receipts, deployment_track=deployment_track) if current != recorded: raise ValueError("native deployment changed since capture") return current def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--source-root", required=True) parser.add_argument("--data-root", required=True) parser.add_argument("--deployment-track", choices=(ARCHIVE_DEPLOYMENT, LIVE_DEPLOYMENT), default=ARCHIVE_DEPLOYMENT) parser.add_argument("--receipts", help="JSON mapping asset directory name to extraction receipt path (archive track only)") parser.add_argument("--output", required=True) args = parser.parse_args() if (args.deployment_track == ARCHIVE_DEPLOYMENT) != (args.receipts is not None): parser.error("--receipts is required only for archive-receipts/v1") receipts = json.loads(Path(args.receipts).read_text()) if args.receipts else None record = capture(args.source_root, args.data_root, receipts, deployment_track=args.deployment_track) with absolute(args.output).open("x") as stream: json.dump(record, stream, indent=2, allow_nan=False) print(digest(args.output)) if __name__ == "__main__": main()