#!/usr/bin/env python3 """Strict, machine-readable verification for final CAD showcase delivery.""" from __future__ import annotations import argparse import base64 import gzip import hashlib import json import re import sys from datetime import datetime, timezone from pathlib import Path from typing import Any import showcase_schema def sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as stream: for chunk in iter(lambda: stream.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def add_check(checks: list[dict[str, Any]], name: str, status: str, detail: str, **data) -> None: checks.append({"name": name, "status": status, "detail": detail, **data}) def inspect_glb(path: Path, budget_mb: float, checks: list[dict[str, Any]]) -> dict[str, Any] | None: if not path.exists() or path.stat().st_size == 0: add_check(checks, f"glb:{path.name}", "FAIL", f"Missing or empty GLB: {path}") return None with path.open("rb") as stream: header = stream.read(4) if header != b"glTF": add_check(checks, f"glb:{path.name}", "FAIL", "File does not have a GLB header") return None try: from pygltflib import GLTF2 model = GLTF2().load(str(path)) nodes = [node.name or "" for node in model.nodes] named = [name for name in nodes if "__" in name] meshes = len(model.meshes or []) primitives = sum(len(mesh.primitives) for mesh in model.meshes or []) if meshes == 0 or primitives == 0: add_check(checks, f"glb:{path.name}", "FAIL", "GLB contains no mesh primitives") return None if not named: add_check(checks, f"glb:{path.name}:names", "FAIL", "No __ node names found") else: add_check(checks, f"glb:{path.name}:names", "PASS", f"{len(named)} named node(s)") extensions = list(model.extensionsUsed or []) detail = f"{meshes} meshes, {primitives} primitives, {path.stat().st_size / 1024 / 1024:.2f} MB" status = "PASS" if path.stat().st_size <= budget_mb * 1024 * 1024 else "FAIL" if status == "FAIL": detail += f"; exceeds {budget_mb:.2f} MB budget" add_check(checks, f"glb:{path.name}:structure", status, detail) return { "path": str(path), "bytes": path.stat().st_size, "sha256": sha256(path), "meshes": meshes, "primitives": primitives, "nodes": named, "extensions": extensions, } except Exception as exc: add_check(checks, f"glb:{path.name}", "FAIL", f"GLB parser failed: {exc}") return None def inspect_render(path: Path, checks: list[dict[str, Any]]) -> None: if not path.exists() or path.stat().st_size == 0: add_check(checks, f"render:{path.name}", "FAIL", f"Missing render: {path}") return try: from PIL import Image, ImageStat image = Image.open(path).convert("RGB") stat = ImageStat.Stat(image.resize((128, 128))) spread = max(stat.var) status = "PASS" if image.width >= 320 and image.height >= 240 and spread > 2.0 else "FAIL" add_check( checks, f"render:{path.name}", status, f"{image.width}x{image.height}, max channel variance {spread:.2f}", ) except Exception as exc: add_check(checks, f"render:{path.name}", "FAIL", f"Image inspection failed: {exc}") def inspect_web(web_dir: Path, checks: list[dict[str, Any]]) -> None: required = [ "index.html", "app.js", "styles.css", "model.glb", "model_metadata.json", "node_modules/three/build/three.module.js", "node_modules/lucide/dist/umd/lucide.js", ] missing = [name for name in required if not (web_dir / name).exists()] if missing: add_check(checks, "web:files", "FAIL", "Missing Web files: " + ", ".join(missing)) return text = (web_dir / "index.html").read_text(encoding="utf-8") + (web_dir / "app.js").read_text(encoding="utf-8") placeholders = sorted(set(re.findall(r"\{\{[^}]+\}\}", text))) if placeholders: add_check(checks, "web:placeholders", "FAIL", f"Unexpanded placeholders: {placeholders}") else: add_check(checks, "web:placeholders", "PASS", "Template placeholders expanded") features = ("window.__renders", "invalidate(", "DRACOLoader", "restoreStateFromHash", "switchVariant") absent = [feature for feature in features if feature not in text] add_check( checks, "web:features", "FAIL" if absent else "PASS", "Missing features: " + ", ".join(absent) if absent else "Required viewer features present", ) try: metadata = json.loads((web_dir / "model_metadata.json").read_text(encoding="utf-8")) missing_variants = [ item.get("file", "?") for item in metadata.get("model_variants", []) if not (web_dir / item.get("file", "")).exists() ] add_check( checks, "web:variants", "FAIL" if missing_variants else "PASS", "Missing variant assets: " + ", ".join(missing_variants) if missing_variants else "Variant assets accounted for", ) except Exception as exc: add_check(checks, "web:metadata", "FAIL", f"Metadata parse failed: {exc}") def inspect_offline(path: Path, checks: list[dict[str, Any]]) -> None: if not path.exists(): add_check(checks, "offline:viewer", "FAIL", f"Offline viewer missing: {path}") return text = path.read_text(encoding="utf-8") match = re.search(r'const GLB_B64="([A-Za-z0-9+/=]+)";', text) if not match: add_check(checks, "offline:payload", "FAIL", "Embedded GLB payload not found") return try: payload = gzip.decompress(base64.b64decode(match.group(1))) if payload[:4] != b"glTF": raise ValueError("decoded payload is not a GLB") add_check(checks, "offline:payload", "PASS", f"Decoded {len(payload)} GLB bytes") except Exception as exc: add_check(checks, "offline:payload", "FAIL", f"Embedded payload decode failed: {exc}") def inspect_browser_report(path: Path, checks: list[dict[str, Any]]) -> None: try: report = json.loads(path.read_text(encoding="utf-8")) passed = report.get("status") == "PASS" and not report.get("console_errors") detail = report.get("detail") or json.dumps(report, ensure_ascii=False)[:500] add_check(checks, "browser:smoke", "PASS" if passed else "FAIL", detail) except Exception as exc: add_check(checks, "browser:smoke", "FAIL", f"Browser report invalid: {exc}") def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--spec", required=True) parser.add_argument("--source-report", required=True) parser.add_argument("--glb", nargs="*", default=[]) parser.add_argument("--variants-manifest") parser.add_argument("--web-dir") parser.add_argument("--offline-viewer") parser.add_argument("--render", nargs="*", default=[]) parser.add_argument("--browser-report") parser.add_argument("--require-browser-report", action="store_true") parser.add_argument("--budget-mb", type=float, default=25.0) parser.add_argument("--evidence-out", default="evidence_manifest.json") args = parser.parse_args() checks: list[dict[str, Any]] = [] artifacts: list[dict[str, Any]] = [] try: source_report = json.loads(Path(args.source_report).read_text(encoding="utf-8")) showcase_schema.validate_source_report(source_report) add_check( checks, "cad_source_report", "PASS", f"Source gate PASS; {len(source_report['files'])} readable DXF file(s)", ) except Exception as exc: add_check(checks, "cad_source_report", "FAIL", str(exc)) spec_path = Path(args.spec) try: spec = json.loads(spec_path.read_text(encoding="utf-8")) showcase_schema.validate_spec(spec) add_check(checks, "building_spec", "PASS", f"Schema v{spec['schema_version']}; {len(spec['floors'])} floor(s)") except Exception as exc: add_check(checks, "building_spec", "FAIL", str(exc)) glb_paths = [Path(item) for item in args.glb] if args.variants_manifest: manifest_path = Path(args.variants_manifest) try: manifest = json.loads(manifest_path.read_text(encoding="utf-8")) showcase_schema.validate_manifest(manifest) add_check(checks, "variants_manifest", "PASS", f"{len(manifest['variants'])} variant(s)") for variant in manifest["variants"]: source = Path(variant["source_glb"]) if not source.is_absolute(): source = manifest_path.parent / source glb_paths.append(source) spec_file = Path(variant["spec"]) if not spec_file.is_absolute(): spec_file = manifest_path.parent / spec_file variant_spec = json.loads(spec_file.read_text(encoding="utf-8")) showcase_schema.validate_spec(variant_spec) metadata_file = Path(variant["metadata"]) if not metadata_file.is_absolute(): metadata_file = manifest_path.parent / metadata_file metadata = json.loads(metadata_file.read_text(encoding="utf-8")) if metadata.get("metadata_version") != 1: raise ValueError(f"{metadata_file}: metadata_version must be 1") if metadata.get("schema_version") != variant_spec.get("schema_version"): raise ValueError(f"{metadata_file}: schema_version does not match {spec_file}") except Exception as exc: add_check(checks, "variants_manifest", "FAIL", str(exc)) seen = set() for path in glb_paths: resolved = path.resolve() if resolved in seen: continue seen.add(resolved) artifact = inspect_glb(path, args.budget_mb, checks) if artifact: artifacts.append(artifact) if not glb_paths: add_check(checks, "glb", "FAIL", "No GLB supplied") for path in args.render: inspect_render(Path(path), checks) if not args.render: add_check(checks, "render", "FAIL", "At least one inspected render is required") if args.web_dir: inspect_web(Path(args.web_dir), checks) if args.offline_viewer: inspect_offline(Path(args.offline_viewer), checks) if args.browser_report: inspect_browser_report(Path(args.browser_report), checks) elif args.require_browser_report: add_check(checks, "browser:smoke", "FAIL", "Browser smoke report required but not supplied") else: add_check(checks, "browser:smoke", "WARN", "No browser smoke report supplied") status = "FAIL" if any(item["status"] == "FAIL" for item in checks) else "PASS" evidence = { "evidence_version": 1, "generated_at": datetime.now(timezone.utc).isoformat(), "status": status, "checks": checks, "artifacts": artifacts, } out = Path(args.evidence_out) out.parent.mkdir(parents=True, exist_ok=True) out.write_text(json.dumps(evidence, ensure_ascii=False, indent=2), encoding="utf-8") print(json.dumps({"status": status, "evidence": str(out), "checks": len(checks)}, ensure_ascii=False)) if status == "FAIL": for item in checks: if item["status"] == "FAIL": print(f"GATE FAIL [{item['name']}]: {item['detail']}", file=sys.stderr) return 3 return 0 if __name__ == "__main__": raise SystemExit(main())