@forgent3d/cad-runtime 0.1.3 → 0.1.5

package/README.md

@@ -9,7 +9,7 @@ This package is intentionally runtime-light:
 - no React
 - no database clients
 
-`cad-agent` and `cf-sandbox` can both depend on this package without coupling their deploy targets together.
+`@forgent3d/cloud` and `cf-sandbox` can both depend on this package without coupling their deploy targets together.
 
 ## Python Runtime Assets
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgent3d/cad-runtime",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Shared CAD runtime protocol, types, and pure utilities for Forgent3D cloud services.",
   "license": "MIT",
   "author": "Forgent3D",

package/python/export_runner.py

@@ -30,6 +30,58 @@ MODELS_DIR = os.path.join(PROJECT_ROOT, "models")
 CACHE_DIR = os.path.join(PROJECT_ROOT, ".cache")
 MODEL_KINDS = ("part",)
 
+# Sentinel-prefixed line emitted on stdout when --emit-build-json is passed, so a
+# caller can read the build summary (bbox/anchors/hasResult) from this single run
+# instead of a separate aicad-script build pass. Keep in sync with cf-sandbox rebuild.ts.
+BUILD_JSON_SENTINEL = "@@AICAD_BUILD_JSON@@"
+
+
+def _emit_build_json(payload) -> None:
+    print(BUILD_JSON_SENTINEL + json.dumps(payload, ensure_ascii=False, separators=(",", ":")))
+
+
+def _bbox_summary(shape):
+    if shape is None or not hasattr(shape, "bounding_box"):
+        return None
+    try:
+        bb = shape.bounding_box()
+        return {
+            "min": [float(bb.min.X), float(bb.min.Y), float(bb.min.Z)],
+            "max": [float(bb.max.X), float(bb.max.Y), float(bb.max.Z)],
+            "size": [
+                float(bb.max.X - bb.min.X),
+                float(bb.max.Y - bb.min.Y),
+                float(bb.max.Z - bb.min.Z),
+            ],
+        }
+    except Exception:
+        return None
+
+
+def _build_summary_payload(model_name, part_name, source_path, ns, result):
+    metadata = ns.get("metadata") if isinstance(ns, dict) else None
+    anchors = None
+    metadata_keys = []
+    if isinstance(metadata, dict):
+        metadata_keys = sorted(str(k) for k in metadata.keys())
+        if isinstance(metadata.get("anchors"), dict):
+            try:
+                anchors = _json_safe(metadata.get("anchors"))
+            except Exception:
+                anchors = None
+    return {
+        "ok": result is not None,
+        "script": "build",
+        "model": model_name,
+        "part": part_name,
+        "source": os.path.relpath(source_path, PROJECT_ROOT).replace(os.sep, "/") if source_path else None,
+        "resultType": type(result).__name__ if result is not None else None,
+        "hasResult": result is not None,
+        "bbox": _bbox_summary(result),
+        "metadataKeys": metadata_keys,
+        "metadataAnchors": anchors,
+    }
+
 
 def _looks_like_build123d(obj) -> bool:
     return any(c.__module__.startswith("build123d") for c in type(obj).__mro__)
@@ -552,7 +604,7 @@ def _build_namespace(model_name: str, part_name: str, source_override: str = Non
     return ns, source_path, 0
 
 
-def build_one(model_name: str, part_name: str = None, export_format: str = "brep", output: str = None, source_override: str = None) -> int:
+def build_one(model_name: str, part_name: str = None, export_format: str = "brep", output: str = None, source_override: str = None, emit_build_json: bool = False) -> int:
     part_name = part_name or model_name
     build_started = time.perf_counter()
     ns, source_path, err = _build_namespace(model_name, part_name, source_override)
@@ -566,6 +618,8 @@ def build_one(model_name: str, part_name: str = None, export_format: str = "brep
         if candidate is not None:
             result = candidate
     if result is None:
+        if emit_build_json:
+            _emit_build_json(_build_summary_payload(model_name, part_name, source_path, ns, None))
         print(f"[export_runner] {source_path} must define a global result (or assembly) object (build123d).",
               file=sys.stderr)
         return 4
@@ -575,6 +629,8 @@ def build_one(model_name: str, part_name: str = None, export_format: str = "brep
     except Exception as exc:
         print(f"[export_runner] Failed to write metadata.json: {exc}", file=sys.stderr)
         return 8
+    if emit_build_json:
+        _emit_build_json(_build_summary_payload(model_name, part_name, source_path, ns, result))
 
     fmt = (export_format or "brep").strip().lower()
     if fmt not in ("brep", "step", "stl", "obj", "glb", "3mf"):
@@ -625,6 +681,8 @@ def main() -> int:
     parser.add_argument("--source", default=None, help="Optional project-relative or absolute source file path (overrides default lookup)")
     parser.add_argument("--export-format", default="brep", choices=["brep", "step", "stl", "obj", "glb", "3mf"])
     parser.add_argument("--output", default=None, help="Optional absolute path for exported file")
+    parser.add_argument("--emit-build-json", action="store_true",
+                        help="Emit a sentinel-prefixed build-summary JSON line on stdout (cloud rebuild fast path)")
     args = parser.parse_args()
     global PROJECT_ROOT, MODELS_DIR, CACHE_DIR
     PROJECT_ROOT = os.path.abspath(args.project) if args.project else HERE
@@ -633,7 +691,7 @@ def main() -> int:
     model_name = args.model or args.part
     if not model_name:
         parser.error("one of --model / --part is required")
-    return build_one(model_name, args.part_name or model_name, args.export_format, args.output, args.source)
+    return build_one(model_name, args.part_name or model_name, args.export_format, args.output, args.source, args.emit_build_json)
 
 
 if __name__ == "__main__":

package/python/rebuild_daemon.py

@@ -0,0 +1,217 @@
+"""
+rebuild_daemon.py - warm build123d/OCP worker for cf-sandbox rebuilds.
+
+A plain `python3 export_runner.py` pays ~2.2s to `import build123d` (CPU-bound OCP
+type registration, not just .so paging) on *every* call. This long-lived daemon
+imports build123d/OCP once and then serves build+export requests over a localhost
+HTTP port, so each rebuild only pays the actual geometry cost (single-digit to low
+hundreds of ms for typical parts).
+
+It is a single-process server (build123d/OCP is not thread-safe and a session's
+rebuilds are sequential). The caller (cf-sandbox) treats it as a best-effort fast
+path and falls back to one-shot export_runner.py on any failure, so this never has
+to be bulletproof — if it crashes, the next request relaunches and re-warms it.
+
+Protocol (newline JSON bodies):
+  GET  /health        -> {"ok": true, "pid": <int>, "ready": <bool>}
+  POST /build_export  -> body {project, model, part?, output, format?, source?}
+                         returns the export_runner build-summary dict
+                         {ok, model, part, source, resultType, hasResult, bbox,
+                          metadataKeys, metadataAnchors, error?}, GLB written to `output`.
+"""
+import argparse
+import json
+import os
+import sys
+import traceback
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+if HERE not in sys.path:
+    sys.path.insert(0, HERE)
+
+import export_runner as er  # reuse the exact build/export/metadata logic
+
+# Modules + sys.path present right after warmup. Anything a request adds (the user's
+# part.py and its local imports) is rolled back afterwards so edits rebuild fresh and
+# sys.path/sys.modules don't grow unbounded across requests.
+_BASE_MODULES: set = set()
+_BASE_SYS_PATH: list = []
+
+
+def _warmup() -> None:
+    global _BASE_MODULES, _BASE_SYS_PATH
+    import build123d  # noqa: F401
+    from build123d import export_gltf, Unit  # noqa: F401  (load the GLB export path too)
+    for optional in ("aicad_select", "aicad_attach"):
+        try:
+            __import__(optional)
+        except Exception:
+            pass
+    _BASE_MODULES = set(sys.modules)
+    _BASE_SYS_PATH = list(sys.path)
+
+
+def _reset_after_request() -> None:
+    for name in list(sys.modules):
+        if name not in _BASE_MODULES:
+            sys.modules.pop(name, None)
+    sys.path[:] = _BASE_SYS_PATH
+
+
+def _build_export(req: dict) -> dict:
+    project = os.path.abspath(str(req.get("project") or os.getcwd()))
+    er.PROJECT_ROOT = project
+    er.MODELS_DIR = os.path.join(project, "models")
+    er.CACHE_DIR = os.path.join(project, ".cache")
+
+    model = str(req.get("model") or "").strip()
+    part = str(req.get("part") or model).strip()
+    fmt = str(req.get("format") or "glb").strip().lower()
+    output = req.get("output")
+    source = req.get("source")
+    if not model:
+        return {"ok": False, "model": "", "part": "", "hasResult": False, "error": "model is required."}
+
+    ns, source_path, err = er._build_namespace(model, part, source)
+    if err:
+        return {"ok": False, "model": model, "part": part, "hasResult": False,
+                "error": f"build failed (export_runner code {err}); see daemon stderr"}
+
+    result = ns.get("result", None)
+    if result is None:
+        result = ns.get("assembly", None)
+    payload = er._build_summary_payload(model, part, source_path, ns, result)
+    if result is None:
+        return payload  # ok=False, hasResult=False -> caller emits "must define a global result"
+
+    try:
+        er._ensure_assembly_metadata(ns, result)
+        er._write_metadata(source_path, ns)
+    except Exception as exc:
+        payload["ok"] = False
+        payload["error"] = f"metadata write failed: {exc}"
+        return payload
+
+    out = os.path.abspath(output) if output else os.path.join(er.CACHE_DIR, f"{model}__{part}.{fmt}")
+    os.makedirs(os.path.dirname(out), exist_ok=True)
+    try:
+        if fmt == "glb":
+            er._write_glb(result, out, er._load_model_params(model))
+        elif fmt == "brep":
+            er._write_brep(result, out)
+        elif fmt == "step":
+            er._write_step(result, out)
+        elif fmt == "stl":
+            er._write_stl(result, out)
+        elif fmt == "obj":
+            er._write_obj(result, out, model)
+        elif fmt == "3mf":
+            er._write_3mf(result, out, er._load_model_params(model), model)
+        else:
+            payload["ok"] = False
+            payload["error"] = f"unsupported export format: {fmt}"
+            return payload
+    except Exception as exc:
+        payload["ok"] = False
+        payload["error"] = f"{fmt} export failed: {exc}"
+        return payload
+
+    size = os.path.getsize(out) if os.path.exists(out) else 0
+    if size <= 0:
+        payload["ok"] = False
+        payload["error"] = "exported file is empty"
+        return payload
+    payload["outputSize"] = size
+    return payload
+
+
+class Handler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def log_message(self, *args):  # silence default request logging
+        pass
+
+    def _send(self, code: int, obj: dict) -> None:
+        body = json.dumps(obj, ensure_ascii=False).encode("utf-8")
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        if self.path.rstrip("/") == "/health":
+            self._send(200, {"ok": True, "pid": os.getpid(), "ready": bool(_BASE_MODULES)})
+        else:
+            self._send(404, {"ok": False, "error": "not found"})
+
+    def do_POST(self):
+        if self.path.rstrip("/") != "/build_export":
+            self._send(404, {"ok": False, "error": "not found"})
+            return
+        try:
+            length = int(self.headers.get("Content-Length") or 0)
+            req = json.loads(self.rfile.read(length) or b"{}")
+        except Exception as exc:
+            self._send(400, {"ok": False, "error": f"bad request: {exc}"})
+            return
+        try:
+            result = _build_export(req)
+            self._send(200, result)
+        except Exception as exc:
+            print(f"[rebuild_daemon] handler error: {exc}", file=sys.stderr)
+            traceback.print_exc()
+            self._send(200, {"ok": False, "error": f"daemon error: {exc}"})
+        finally:
+            _reset_after_request()
+
+
+def client_main(argv) -> int:
+    """`rebuild_daemon.py client <METHOD> <PATH> [<base64-json-body>] [<port>]`
+
+    A dependency-free way for cf-sandbox to reach the daemon: a bare `python3`
+    spawn (no build123d import) that POSTs to the localhost daemon and prints the
+    response JSON. On connection failure it prints {"__client_error__": ...} so the
+    caller can fall back to one-shot export_runner.py.
+    """
+    import base64
+    import urllib.request
+
+    method = argv[0] if argv else "GET"
+    path = argv[1] if len(argv) > 1 else "/health"
+    body = base64.b64decode(argv[2]) if len(argv) > 2 and argv[2] else None
+    port = int(argv[3]) if len(argv) > 3 and argv[3] else 8765
+    req = urllib.request.Request(
+        f"http://127.0.0.1:{port}{path}", data=body, method=method,
+        headers={"Content-Type": "application/json"},
+    )
+    try:
+        sys.stdout.write(urllib.request.urlopen(req, timeout=125).read().decode())
+        return 0
+    except Exception as exc:
+        sys.stdout.write(json.dumps({"__client_error__": str(exc)}))
+        return 3
+
+
+def main() -> int:
+    if len(sys.argv) > 1 and sys.argv[1] == "client":
+        return client_main(sys.argv[2:])
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8765)
+    args = parser.parse_args()
+
+    _warmup()
+    server = HTTPServer((args.host, args.port), Handler)
+    print(f"[rebuild_daemon] ready on {args.host}:{args.port} pid={os.getpid()}", flush=True)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())