@forgent3d/cad-runtime 0.1.4 → 0.1.5

package/package.json

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

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