fix: enforce strict CAD showcase delivery gates
This commit is contained in:
@@ -8,8 +8,11 @@ import hashlib
|
||||
import importlib.metadata
|
||||
import json
|
||||
import shutil
|
||||
import socket
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.request
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
@@ -32,8 +35,10 @@ def fingerprint(config: Path, source_report: Path, dxf_dir: Path) -> str:
|
||||
digest = hashlib.sha256()
|
||||
tracked = [config, source_report, *sorted(dxf_dir.glob("*.dxf"))]
|
||||
tracked.extend(sorted(SCRIPTS.glob("*.py")))
|
||||
tracked.extend(sorted(SCRIPTS.glob("*.mjs")))
|
||||
tracked.extend(sorted((ROOT / "schemas").glob("*.json")))
|
||||
tracked.extend(sorted((ROOT / "assets" / "web-showcase-template").glob("*")))
|
||||
tracked.extend(path for path in (ROOT / "package.json", ROOT / "package-lock.json") if path.exists())
|
||||
for path in tracked:
|
||||
if not path.is_file():
|
||||
continue
|
||||
@@ -132,8 +137,122 @@ def python_script(name: str, *args: str) -> list[str]:
|
||||
return [sys.executable, str(SCRIPTS / name), *args]
|
||||
|
||||
|
||||
def parse_waivers(values: list[str]) -> dict[str, str]:
|
||||
waivers: dict[str, str] = {}
|
||||
for value in values:
|
||||
name, separator, reason = value.partition("=")
|
||||
name = name.strip()
|
||||
reason = reason.strip()
|
||||
if not separator or not name or not reason:
|
||||
raise ValueError(f"Invalid waiver {value!r}; expected CHECK=REASON")
|
||||
if name in waivers:
|
||||
raise ValueError(f"Duplicate waiver for {name!r}")
|
||||
waivers[name] = reason
|
||||
return waivers
|
||||
|
||||
|
||||
def enforce_audit_gates(pipeline: Pipeline, audit_path: Path, waivers: dict[str, str]) -> bool:
|
||||
report = json.loads(audit_path.read_text(encoding="utf-8"))
|
||||
blocked = []
|
||||
waived = []
|
||||
for gate in report.get("gates", []):
|
||||
status = str(gate.get("status", "FAIL"))
|
||||
if status == "PASS":
|
||||
continue
|
||||
name = f"audit:{gate.get('name', 'unnamed')}"
|
||||
if status in {"WARN", "SKIP"} and name in waivers:
|
||||
waived.append({"name": name, "original_status": status, "reason": waivers[name]})
|
||||
else:
|
||||
blocked.append({"name": name, "status": status, "detail": gate.get("detail", "")})
|
||||
pipeline.state["audit_waivers"] = waived
|
||||
if blocked:
|
||||
pipeline.state["status"] = "BLOCKED"
|
||||
pipeline.state["blocked_gates"] = blocked
|
||||
pipeline.save()
|
||||
for gate in blocked:
|
||||
print(f"GATE BLOCKED [{gate['name']}]: {gate['detail']}", file=sys.stderr)
|
||||
return False
|
||||
pipeline.save()
|
||||
return True
|
||||
|
||||
|
||||
def available_port() -> int:
|
||||
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as stream:
|
||||
stream.bind(("127.0.0.1", 0))
|
||||
return int(stream.getsockname()[1])
|
||||
|
||||
|
||||
def wait_for_http(url: str, timeout: float = 20.0) -> None:
|
||||
deadline = time.monotonic() + timeout
|
||||
last_error: Exception | None = None
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
with urllib.request.urlopen(url, timeout=1) as response:
|
||||
if response.status < 500:
|
||||
return
|
||||
except Exception as exc: # pragma: no cover - timing depends on host
|
||||
last_error = exc
|
||||
time.sleep(0.2)
|
||||
raise RuntimeError(f"Local Web server did not become ready: {last_error}")
|
||||
|
||||
|
||||
def run_browser_smoke(pipeline: Pipeline, web_dir: Path, report: Path, screenshots: Path) -> None:
|
||||
"""Serve the formal Web bundle and mechanically prove desktop/mobile loading."""
|
||||
pipeline.run(
|
||||
"browser_dependencies",
|
||||
["npm", "install", "--prefix", str(ROOT), "--ignore-scripts"],
|
||||
[ROOT / "node_modules" / "playwright" / "package.json"],
|
||||
)
|
||||
pipeline.run(
|
||||
"browser_runtime",
|
||||
[str(ROOT / "node_modules" / ".bin" / "playwright"), "install", "chromium"],
|
||||
[],
|
||||
)
|
||||
report.parent.mkdir(parents=True, exist_ok=True)
|
||||
port = available_port()
|
||||
url = f"http://127.0.0.1:{port}/"
|
||||
server = subprocess.Popen(
|
||||
[
|
||||
sys.executable,
|
||||
"-m",
|
||||
"http.server",
|
||||
str(port),
|
||||
"--bind",
|
||||
"127.0.0.1",
|
||||
"--directory",
|
||||
str(web_dir),
|
||||
],
|
||||
cwd=ROOT,
|
||||
stdout=subprocess.DEVNULL,
|
||||
stderr=subprocess.DEVNULL,
|
||||
)
|
||||
try:
|
||||
wait_for_http(url)
|
||||
pipeline.run(
|
||||
"browser_smoke",
|
||||
[
|
||||
"node",
|
||||
str(SCRIPTS / "web_smoke_test.mjs"),
|
||||
"--url",
|
||||
url,
|
||||
"--out",
|
||||
str(report),
|
||||
"--screenshots-dir",
|
||||
str(screenshots),
|
||||
],
|
||||
[report, screenshots],
|
||||
)
|
||||
finally:
|
||||
server.terminate()
|
||||
try:
|
||||
server.wait(timeout=5)
|
||||
except subprocess.TimeoutExpired: # pragma: no cover - defensive cleanup
|
||||
server.kill()
|
||||
server.wait(timeout=5)
|
||||
|
||||
|
||||
def doctor() -> int:
|
||||
modules = ["ezdxf", "jsonschema", "numpy", "shapely", "trimesh", "matplotlib", "PIL", "pygltflib"]
|
||||
modules = ["ezdxf", "jsonschema", "numpy", "scipy", "shapely", "trimesh", "matplotlib", "PIL", "pygltflib"]
|
||||
checks = []
|
||||
failed = False
|
||||
for module in modules:
|
||||
@@ -210,6 +329,11 @@ def run_pipeline(args: argparse.Namespace) -> int:
|
||||
return 3
|
||||
out_dir = Path(args.out_dir).resolve()
|
||||
out_dir.mkdir(parents=True, exist_ok=True)
|
||||
try:
|
||||
waivers = parse_waivers(args.waiver)
|
||||
except ValueError as exc:
|
||||
print(f"GATE FAIL [waiver]: {exc}", file=sys.stderr)
|
||||
return 3
|
||||
pipeline = Pipeline(out_dir / "pipeline_state.json", fingerprint(config, source_report, dxf_dir), args.resume)
|
||||
spec = out_dir / "building_spec.json"
|
||||
audit = out_dir / "extraction_audit.json"
|
||||
@@ -247,6 +371,8 @@ def run_pipeline(args: argparse.Namespace) -> int:
|
||||
if args.frames:
|
||||
audit_cmd.extend(["--frames", *args.frames])
|
||||
pipeline.run("audit", audit_cmd, [audit, audit_md])
|
||||
if not enforce_audit_gates(pipeline, audit, waivers):
|
||||
return 3
|
||||
pipeline.run(
|
||||
"overlays",
|
||||
python_script(
|
||||
@@ -307,6 +433,10 @@ def run_pipeline(args: argparse.Namespace) -> int:
|
||||
["npm", "install", "--prefix", str(web_dir), "--ignore-scripts"],
|
||||
[web_dir / "node_modules" / "three" / "build" / "three.module.js"],
|
||||
)
|
||||
browser_report = (
|
||||
Path(args.browser_report).resolve() if args.browser_report else out_dir / "browser_smoke_report.json"
|
||||
)
|
||||
run_browser_smoke(pipeline, web_dir, browser_report, out_dir / "browser_smoke")
|
||||
|
||||
standard = bundle / "variants" / "standard" / "standard.glb"
|
||||
offline = out_dir / "viewer.html"
|
||||
@@ -355,20 +485,32 @@ def run_pipeline(args: argparse.Namespace) -> int:
|
||||
str(manifest),
|
||||
"--render",
|
||||
str(preview),
|
||||
"--audit",
|
||||
str(audit),
|
||||
"--budget-mb",
|
||||
str(args.budget_mb),
|
||||
"--evidence-out",
|
||||
str(evidence),
|
||||
)
|
||||
if args.web:
|
||||
verify_cmd.extend(["--web-dir", str(web_dir)])
|
||||
verify_cmd.extend(
|
||||
["--web-dir", str(web_dir), "--browser-report", str(browser_report), "--require-browser-report"]
|
||||
)
|
||||
if args.offline:
|
||||
verify_cmd.extend(["--offline-viewer", str(offline)])
|
||||
if args.browser_report:
|
||||
verify_cmd.extend(["--browser-report", args.browser_report])
|
||||
if args.require_browser_report:
|
||||
if args.require_browser_report and not args.web:
|
||||
verify_cmd.append("--require-browser-report")
|
||||
if args.scope_manifest:
|
||||
verify_cmd.extend(["--scope-manifest", str(Path(args.scope_manifest).resolve())])
|
||||
for value in args.waiver:
|
||||
verify_cmd.extend(["--waiver", value])
|
||||
pipeline.run("delivery_verification", verify_cmd, [evidence])
|
||||
verification = json.loads(evidence.read_text(encoding="utf-8"))
|
||||
if verification.get("status") != "PASS":
|
||||
pipeline.state["status"] = "BLOCKED"
|
||||
pipeline.save()
|
||||
print(f"GATE BLOCKED [delivery_verification]: {verification.get('status')}", file=sys.stderr)
|
||||
return 3
|
||||
pipeline.state["status"] = "PASS"
|
||||
pipeline.state["finished_at"] = now()
|
||||
pipeline.save()
|
||||
@@ -401,6 +543,14 @@ def parser() -> argparse.ArgumentParser:
|
||||
run.add_argument("--offline", action="store_true")
|
||||
run.add_argument("--browser-report")
|
||||
run.add_argument("--require-browser-report", action="store_true")
|
||||
run.add_argument("--scope-manifest", help="Single-building/campus scope ledger included in final verification")
|
||||
run.add_argument(
|
||||
"--waiver",
|
||||
action="append",
|
||||
default=[],
|
||||
metavar="CHECK=REASON",
|
||||
help="Explicitly acknowledge one WARN/SKIP audit or delivery check",
|
||||
)
|
||||
run.add_argument("--budget-mb", type=float, default=25.0)
|
||||
run.add_argument("--resume", action="store_true")
|
||||
return root
|
||||
|
||||
@@ -29,6 +29,48 @@ def add_check(checks: list[dict[str, Any]], name: str, status: str, detail: str,
|
||||
checks.append({"name": name, "status": status, "detail": detail, **data})
|
||||
|
||||
|
||||
def parse_waivers(values: list[str]) -> dict[str, str]:
|
||||
"""Parse explicit CHECK=REASON waivers.
|
||||
|
||||
Waivers are deliberately verbose: an Agent cannot silently turn WARN/SKIP
|
||||
into PASS, and a misspelled or unused waiver becomes a hard failure.
|
||||
"""
|
||||
waivers: dict[str, str] = {}
|
||||
for value in values:
|
||||
name, separator, reason = value.partition("=")
|
||||
name = name.strip()
|
||||
reason = reason.strip()
|
||||
if not separator or not name or not reason:
|
||||
raise ValueError(f"Invalid waiver {value!r}; expected CHECK=REASON")
|
||||
if name in waivers:
|
||||
raise ValueError(f"Duplicate waiver for {name!r}")
|
||||
waivers[name] = reason
|
||||
return waivers
|
||||
|
||||
|
||||
def apply_waivers(checks: list[dict[str, Any]], waivers: dict[str, str]) -> None:
|
||||
used: set[str] = set()
|
||||
for check in checks:
|
||||
name = str(check["name"])
|
||||
if name not in waivers:
|
||||
continue
|
||||
used.add(name)
|
||||
if check["status"] not in {"WARN", "SKIP"}:
|
||||
add_check(
|
||||
checks,
|
||||
f"waiver:{name}",
|
||||
"FAIL",
|
||||
f"Waivers may only acknowledge WARN/SKIP checks; {name} is {check['status']}",
|
||||
)
|
||||
continue
|
||||
check["original_status"] = check["status"]
|
||||
check["status"] = "PASS"
|
||||
check["waiver_reason"] = waivers[name]
|
||||
check["detail"] = f"WAIVED ({waivers[name]}): {check['detail']}"
|
||||
for name in sorted(set(waivers) - used):
|
||||
add_check(checks, f"waiver:{name}", "FAIL", f"Unused or misspelled waiver: {name}")
|
||||
|
||||
|
||||
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}")
|
||||
@@ -162,13 +204,144 @@ def inspect_offline(path: Path, checks: list[dict[str, Any]]) -> None:
|
||||
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")
|
||||
passed = (
|
||||
report.get("status") == "PASS"
|
||||
and not report.get("console_errors")
|
||||
and not report.get("page_errors")
|
||||
and not report.get("failed_requests")
|
||||
)
|
||||
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 inspect_audit(path: Path, checks: list[dict[str, Any]]) -> None:
|
||||
try:
|
||||
report = json.loads(path.read_text(encoding="utf-8"))
|
||||
gates = report.get("gates")
|
||||
if not isinstance(gates, list) or not gates:
|
||||
raise ValueError("audit has no gates")
|
||||
for gate in gates:
|
||||
status = str(gate.get("status", "FAIL"))
|
||||
if status not in {"PASS", "WARN", "SKIP", "FAIL"}:
|
||||
status = "FAIL"
|
||||
add_check(
|
||||
checks,
|
||||
f"audit:{gate.get('name', 'unnamed')}",
|
||||
status,
|
||||
str(gate.get("detail", "Audit gate has no detail")),
|
||||
)
|
||||
except Exception as exc:
|
||||
add_check(checks, "audit:report", "FAIL", f"Extraction audit invalid: {exc}")
|
||||
|
||||
|
||||
def inspect_scope(path: Path, checks: list[dict[str, Any]]) -> None:
|
||||
"""Validate a single-building/campus scope ledger against real artifacts."""
|
||||
try:
|
||||
scope = json.loads(path.read_text(encoding="utf-8"))
|
||||
if scope.get("scope_version") != 1:
|
||||
raise ValueError("scope_version must be 1")
|
||||
mode = scope.get("mode")
|
||||
if mode not in {"single", "campus"}:
|
||||
raise ValueError("mode must be single or campus")
|
||||
requested = scope.get("requested")
|
||||
buildings = scope.get("buildings")
|
||||
if (
|
||||
not isinstance(requested, list)
|
||||
or not requested
|
||||
or not all(isinstance(item, str) and item for item in requested)
|
||||
):
|
||||
raise ValueError("requested must be a non-empty list of building IDs")
|
||||
if len(set(requested)) != len(requested):
|
||||
raise ValueError("requested contains duplicate building IDs")
|
||||
if not isinstance(buildings, list):
|
||||
raise ValueError("buildings must be a list")
|
||||
by_id: dict[str, dict[str, Any]] = {}
|
||||
for item in buildings:
|
||||
building_id = str(item.get("id", ""))
|
||||
if not building_id or building_id in by_id:
|
||||
raise ValueError(f"missing or duplicate building id: {building_id!r}")
|
||||
by_id[building_id] = item
|
||||
missing = [item for item in requested if item not in by_id]
|
||||
if missing:
|
||||
add_check(
|
||||
checks, "scope:inventory", "FAIL", "Requested buildings missing from ledger: " + ", ".join(missing)
|
||||
)
|
||||
else:
|
||||
add_check(
|
||||
checks, "scope:inventory", "PASS", f"All {len(requested)} requested building(s) are in the ledger"
|
||||
)
|
||||
|
||||
for building_id in requested:
|
||||
item = by_id.get(building_id)
|
||||
if not item:
|
||||
continue
|
||||
status = item.get("status")
|
||||
reason = str(item.get("reason", "")).strip()
|
||||
artifacts = item.get("artifacts", [])
|
||||
if status == "BLOCKED":
|
||||
add_check(
|
||||
checks,
|
||||
f"scope:building:{building_id}",
|
||||
"WARN" if reason else "FAIL",
|
||||
reason or "BLOCKED building has no reason",
|
||||
)
|
||||
continue
|
||||
if status != "PASS":
|
||||
add_check(checks, f"scope:building:{building_id}", "FAIL", f"Invalid status: {status!r}")
|
||||
continue
|
||||
if not isinstance(artifacts, list) or not artifacts:
|
||||
add_check(checks, f"scope:building:{building_id}", "FAIL", "PASS building has no artifacts")
|
||||
continue
|
||||
missing_artifacts = []
|
||||
for artifact in artifacts:
|
||||
artifact_path = Path(str(artifact))
|
||||
if not artifact_path.is_absolute():
|
||||
artifact_path = path.parent / artifact_path
|
||||
if not artifact_path.exists() or (artifact_path.is_file() and artifact_path.stat().st_size == 0):
|
||||
missing_artifacts.append(str(artifact))
|
||||
add_check(
|
||||
checks,
|
||||
f"scope:building:{building_id}",
|
||||
"FAIL" if missing_artifacts else "PASS",
|
||||
"Missing artifacts: " + ", ".join(missing_artifacts)
|
||||
if missing_artifacts
|
||||
else f"{len(artifacts)} declared artifact(s) exist",
|
||||
)
|
||||
|
||||
site = scope.get("site", {})
|
||||
if mode == "campus":
|
||||
site_status = site.get("status") if isinstance(site, dict) else None
|
||||
if site_status == "BLOCKED":
|
||||
reason = str(site.get("reason", "")).strip()
|
||||
add_check(checks, "scope:site", "WARN" if reason else "FAIL", reason or "Campus site is blocked")
|
||||
elif site_status != "PASS":
|
||||
add_check(checks, "scope:site", "FAIL", "Campus scope requires site.status=PASS or BLOCKED")
|
||||
else:
|
||||
artifacts = site.get("artifacts", [])
|
||||
missing_site = []
|
||||
for artifact in artifacts if isinstance(artifacts, list) else []:
|
||||
artifact_path = Path(str(artifact))
|
||||
if not artifact_path.is_absolute():
|
||||
artifact_path = path.parent / artifact_path
|
||||
if not artifact_path.exists() or (artifact_path.is_file() and artifact_path.stat().st_size == 0):
|
||||
missing_site.append(str(artifact))
|
||||
if not artifacts or missing_site:
|
||||
add_check(
|
||||
checks,
|
||||
"scope:site",
|
||||
"FAIL",
|
||||
"Campus site has no artifacts"
|
||||
if not artifacts
|
||||
else "Missing site artifacts: " + ", ".join(missing_site),
|
||||
)
|
||||
else:
|
||||
add_check(checks, "scope:site", "PASS", f"{len(artifacts)} site artifact(s) exist")
|
||||
except Exception as exc:
|
||||
add_check(checks, "scope:manifest", "FAIL", f"Scope manifest invalid: {exc}")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--spec", required=True)
|
||||
@@ -178,14 +351,28 @@ def main() -> int:
|
||||
parser.add_argument("--web-dir")
|
||||
parser.add_argument("--offline-viewer")
|
||||
parser.add_argument("--render", nargs="*", default=[])
|
||||
parser.add_argument("--audit")
|
||||
parser.add_argument("--scope-manifest")
|
||||
parser.add_argument("--browser-report")
|
||||
parser.add_argument("--require-browser-report", action="store_true")
|
||||
parser.add_argument(
|
||||
"--waiver",
|
||||
action="append",
|
||||
default=[],
|
||||
metavar="CHECK=REASON",
|
||||
help="Explicitly acknowledge one WARN/SKIP check with a non-empty reason",
|
||||
)
|
||||
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:
|
||||
waivers = parse_waivers(args.waiver)
|
||||
except ValueError as exc:
|
||||
print(f"GATE FAIL [waiver]: {exc}", file=sys.stderr)
|
||||
return 3
|
||||
try:
|
||||
source_report = json.loads(Path(args.source_report).read_text(encoding="utf-8"))
|
||||
showcase_schema.validate_source_report(source_report)
|
||||
@@ -250,16 +437,25 @@ def main() -> int:
|
||||
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.audit:
|
||||
inspect_audit(Path(args.audit), checks)
|
||||
if args.scope_manifest:
|
||||
inspect_scope(Path(args.scope_manifest), 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")
|
||||
elif args.web_dir or args.require_browser_report:
|
||||
add_check(checks, "browser:smoke", "SKIP", "Formal Web delivery has no browser smoke report")
|
||||
|
||||
status = "FAIL" if any(item["status"] == "FAIL" for item in checks) else "PASS"
|
||||
apply_waivers(checks, waivers)
|
||||
status = (
|
||||
"FAIL"
|
||||
if any(item["status"] == "FAIL" for item in checks)
|
||||
else "BLOCKED"
|
||||
if any(item["status"] in {"WARN", "SKIP"} for item in checks)
|
||||
else "PASS"
|
||||
)
|
||||
evidence = {
|
||||
"evidence_version": 1,
|
||||
"generated_at": datetime.now(timezone.utc).isoformat(),
|
||||
@@ -271,10 +467,10 @@ def main() -> int:
|
||||
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":
|
||||
if status != "PASS":
|
||||
for item in checks:
|
||||
if item["status"] == "FAIL":
|
||||
print(f"GATE FAIL [{item['name']}]: {item['detail']}", file=sys.stderr)
|
||||
if item["status"] in {"FAIL", "WARN", "SKIP"}:
|
||||
print(f"GATE {status} [{item['name']}]: {item['detail']}", file=sys.stderr)
|
||||
return 3
|
||||
return 0
|
||||
|
||||
|
||||
Reference in New Issue
Block a user