eitri-hardware 0.6.0__py3-none-any.whl

eitri/__init__.py

@@ -0,0 +1,22 @@
+"""eitri - a Claude-Code-like agent for parametric CAD.
+
+Model files start with `from eitri import *`, which gives them build123d (both
+as `bd` and as bare names), the feature library and the measurement helpers.
+"""
+from __future__ import annotations
+
+try:
+    import build123d as bd
+except ImportError as _exc:                          # the one system library the kernel needs on Linux
+    if "libGL" not in str(_exc):
+        raise
+    raise ImportError(f"{_exc}. The CAD kernel (OpenCASCADE) needs the system OpenGL library: on Debian/Ubuntu "
+                      "`sudo apt-get install libgl1`, on Fedora `sudo dnf install mesa-libGL`") from _exc
+from build123d import *  # noqa: F401,F403  - bare build123d names for model files
+
+from .model import PALETTE, Params, Parts, Checker, srgb  # noqa: F401
+from .measure import *  # noqa: F401,F403
+from .lib import *  # noqa: F401,F403
+from .anchors import anchor  # noqa: F401  - named points and frames of the model (eitri.anchors)
+
+__version__ = "0.6.0"

eitri/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

eitri/_render_cli.py

@@ -0,0 +1,61 @@
+"""Subprocess entry point for extra views (view tool and `eitri view`)."""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--views", default="")
+    ap.add_argument("--section", default="")
+    ap.add_argument("--exploded", action="store_true")
+    ap.add_argument("--hide", default="")
+    ap.add_argument("--only", default="")
+    ap.add_argument("--size", type=int, default=720)
+    ap.add_argument("--set", action="append", default=[])
+    ap.add_argument("--turntable", type=int, default=0, help="frames of a turntable GIF instead of a contact sheet")
+    args = ap.parse_args(argv)
+
+    from .model import Parts, load_model
+    from .render import contact_sheet, exploded_parts, section_sheet
+
+    overrides = dict(s.split("=", 1) for s in args.set)
+    model = load_model(args.model, overrides)
+    parts = model.build()
+    hide = {h for h in args.hide.split(",") if h}
+    only = {o for o in args.only.split(",") if o}
+    unknown = (hide | only) - set(parts.names)
+    if unknown:
+        print(f"unknown part names {sorted(unknown)}; parts are {parts.names}", file=sys.stderr)
+        return 2
+    if only:
+        parts = Parts([p for p in parts if p.name in only])
+    elif hide:
+        parts = Parts([p for p in parts if p.name not in hide])
+    if args.exploded:
+        parts = exploded_parts(parts)
+    w = args.size
+    cell = (w, int(w * 0.75))
+    if args.turntable:
+        from .render import turntable
+        turntable(parts, args.out, frames=args.turntable, size=(w, int(w * 0.75)))
+        print(f"turntable GIF, {args.turntable} frames; parts shown: {parts.names}" + (" (exploded)" if args.exploded else ""))
+        return 0
+    if args.section:
+        plane, _, off = args.section.partition(":")
+        offset = float(off) if off else 0.0
+        section_sheet(parts, args.out, plane=plane.upper(), offset=offset, cell=cell)
+        print(f"section {plane.upper()} at {offset:g}: cut faces are red; parts shown: {parts.names}")
+    else:
+        views = tuple(v for v in args.views.split(",") if v) or ("iso_back", "bottom")
+        contact_sheet(parts, args.out, views=views, cell=cell, title=Path(args.model).stem)
+        print(f"views {', '.join(views)}; parts shown: {parts.names}" + (" (exploded)" if args.exploded else ""))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

eitri/_runner.py

@@ -0,0 +1,300 @@
+"""Subprocess entry point: build one model file and write result.json.
+
+Invoked by eitri.kernel.build_model; not meant to be called by hand.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+import traceback
+from dataclasses import asdict
+from pathlib import Path
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--formats", default="step,glb")
+    ap.add_argument("--views", default="iso,front,top,right")
+    ap.add_argument("--quality", type=float, default=1.0)
+    ap.add_argument("--wall-samples", type=int, default=600)
+    ap.add_argument("--no-render", action="store_true")
+    ap.add_argument("--set", action="append", default=[], help="param=value override")
+    ap.add_argument("--guards", default="", help="JSON: what the project remembers for this model's extensions (eitri.extensions)")
+    ap.add_argument("--max-parts", type=int, default=0, help="refuse a model with more parts than this (0: no limit)")
+    args = ap.parse_args(argv)
+
+    out_dir = Path(args.out)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    model_path = Path(args.model)
+    result: dict = {"ok": False, "outputs": {}, "params": {}, "report": None, "summary": "", "error": None}
+
+    def finish(code: int) -> int:
+        tmp = out_dir / "result.json.tmp"           # replaced in one step: a reader never sees half a file
+        tmp.write_text(json.dumps(result, indent=1, default=str), encoding="utf-8")
+        os.replace(tmp, out_dir / "result.json")
+        _Stages(out_dir)("done", done=True)
+        return code
+
+    overrides = {}
+    for item in args.set:
+        if "=" not in item:
+            result["error"] = f"bad --set {item!r}; use name=value"
+            return finish(2)
+        k, v = item.split("=", 1)
+        overrides[k.strip()] = v.strip()
+
+    stage = _Stages(out_dir)
+    stage("building the geometry")
+    t0 = time.time()
+    try:
+        from .model import load_model
+        model = load_model(model_path, overrides)
+        result["params"] = {k: v for k, v in model.params.items()}
+        parts = model.build()
+    except Exception:
+        result["error"] = _clean_traceback(traceback.format_exc(), model_path)
+        return finish(1)
+    from .domains import kind_of_object, module as domain_module
+    kind = kind_of_object(parts)
+    if kind:                                             # another domain (harness, mechanism, ...): no geometry, its own build
+        result["build_seconds"] = round(time.time() - t0, 2)
+        result["timings"] = {"build": result["build_seconds"]}
+        domain_module(kind).build(model, parts, model_path, out_dir, result, stage, _clean_traceback, render=not args.no_render,
+                                  guards=json.loads(args.guards) if args.guards else {})
+        result["ok"] = result["error"] is None
+        return finish(0 if result["ok"] else 1)
+    if args.max_parts and len(parts) > args.max_parts:
+        result["error"] = (f"the model has {len(parts)} parts; this deployment allows at most {args.max_parts} per assembly "
+                           "(combine parts, or build the assembly in smaller projects)")
+        return finish(1)
+    build_seconds = time.time() - t0
+    result["build_seconds"] = round(build_seconds, 2)
+    timings = result["timings"] = {"build": round(build_seconds, 3)}
+    # exact-geometry fingerprints, taken before meshing: the analysis reuses what it measured on unchanged parts
+    from .report import fingerprint
+    fingerprints = {p.name: fingerprint(p.shape) for p in parts}
+
+    # the viewer's model first, announced as a preview: the page shows the new geometry at once while the
+    # checks, the exports and the review render (the slow part) are still running
+    stage("making the 3D view")
+    t = time.time()
+    try:
+        from .viewglb import write_view_glb
+        vg = out_dir / f"{model_path.stem}.view.glb"
+        tj = out_dir / f"{model_path.stem}.topology.json"
+        pg = out_dir / f"{model_path.stem}.partial.glb"
+        pt = out_dir / f"{model_path.stem}.partial.topology.json"
+
+        def partial(glb: bytes, topo, done: int, total: int) -> None:
+            """The parts meshed so far, shown by the page while the rest are meshed (an assembly appears part
+            by part; build(p) itself makes every part in one call, so this is as early as parts can appear)."""
+            _write_atomic(pg, glb)
+            _write_atomic(pt, json.dumps(topo.to_dict()).encode())
+            _announce_preview(out_dir, pg, pt, parts_done=done, parts_total=total)
+
+        # how often a batch of meshed parts is shown while the rest are meshed: EITRI_PREVIEW_EVERY_S seconds
+        # (default 1) or EITRI_PREVIEW_EVERY_PARTS parts (default off), whichever comes first
+        every_s = _env_float("EITRI_PREVIEW_EVERY_S", 1.0)
+        every_parts = int(_env_float("EITRI_PREVIEW_EVERY_PARTS", 0))
+        write_view_glb(parts, vg, tj, quality=args.quality, fingerprints=fingerprints, progress=stage, on_partial=partial,
+                       partial_every=every_s, partial_parts=every_parts)
+        result["outputs"]["view_glb"] = str(vg)
+        result["outputs"]["topology"] = str(tj)
+        _announce_preview(out_dir, vg, tj)
+        for f in (pg, pt):
+            f.unlink(missing_ok=True)
+    except Exception:
+        result["error"] = (result.get("error") or "") + "\nviewer export failed:\n" + _clean_traceback(traceback.format_exc(), model_path)
+    timings["view"] = round(time.time() - t, 3)
+
+    stage("running the model's own checks")
+    t = time.time()
+    try:
+        checker = model.verify(parts)
+    except Exception:
+        from .model import Checker
+        checker = Checker()
+        checker.true("verify() ran without error", False, _clean_traceback(traceback.format_exc(), model_path, short=True))
+    timings["verify"] = round(time.time() - t, 3)
+
+    stage("exporting " + ", ".join(f.upper() for f in args.formats.split(",") if f))
+    t = time.time()
+    export_note = ""
+    try:
+        from .kernel import export_parts
+        formats = tuple(f for f in args.formats.split(",") if f)
+        outputs = export_parts(parts, out_dir, model_path.stem, formats)
+        export_note = outputs.pop("notes", "")
+        result["outputs"].update(outputs)
+    except Exception:
+        result["error"] = "export failed:\n" + _clean_traceback(traceback.format_exc(), model_path)
+    timings["export"] = round(time.time() - t, 3)
+
+    t = time.time()
+    try:
+        from .report import analyze, summarize
+        report = analyze(parts, checker, wall_samples=args.wall_samples, progress=stage, fingerprints=fingerprints)
+        _run_extensions(result, report, "cad", model, parts, model_path, out_dir, args.guards, stage)
+        if export_note:
+            report.issues.append(export_note) if "LOST" in export_note else None
+        for note in model.edit_notes:
+            if not note.ok:
+                report.issues.append(f"direct edit failed: {note.line()}")
+        result["report"] = report.to_dict()
+        from .anchors import describe as describe_anchors, to_json as anchors_json
+        result["anchors"] = anchors_json(parts)
+        summary = summarize(report) + (f"\n{export_note}" if export_note else "")
+        if result["anchors"]:
+            summary += "\n" + describe_anchors(result["anchors"])
+        if model.edit_notes:
+            summary += "\nDirect edits (EDITS in the model file):\n" + "\n".join("  " + n.line() for n in model.edit_notes)
+        result["summary"] = summary
+        result["edit_notes"] = [n.__dict__ for n in model.edit_notes]
+        result["joints"] = list(getattr(parts, "joints", []) or [])
+        result["sheets"] = dict(getattr(parts, "sheets", {}) or {})
+        result["flats"] = dict(getattr(parts, "flats", {}) or {})
+        result["forms"] = dict(getattr(parts, "forms", {}) or {})
+        result["groups"] = {q.name: q.group for q in parts if getattr(q, "group", None)}
+    except Exception:
+        result["error"] = (result.get("error") or "") + "\nanalysis failed:\n" + _clean_traceback(traceback.format_exc(), model_path)
+    timings["analyze"] = round(time.time() - t, 3)
+
+    t = time.time()
+    if not args.no_render:
+        stage("rendering the review image")
+        try:
+            from .render import contact_sheet
+            views = tuple(v for v in args.views.split(",") if v)
+            png = out_dir / f"{model_path.stem}.png"
+            contact_sheet(parts, str(png), views=views, quality=args.quality, title=model_path.stem)
+            result["outputs"]["png"] = str(png)
+        except Exception:
+            result["error"] = (result.get("error") or "") + "\nrender failed:\n" + _clean_traceback(traceback.format_exc(), model_path)
+        timings["render"] = round(time.time() - t, 3)
+
+    result["ok"] = result["error"] is None
+    return finish(0 if result["ok"] else 1)
+
+
+def _run_extensions(result: dict, report, kind: str, model, built, model_path: Path, out_dir: Path, guards_json: str, stage) -> None:
+    """Registered build extensions (eitri.extensions): their checks join the report; their data and guards go in the result."""
+    from . import extensions
+    try:
+        ctx = extensions.BuildContext(model_path, out_dir, kind, model.module, dict(model.params), built, report, result,
+                                      json.loads(guards_json) if guards_json else {}, stage)
+        checks, data, guards = extensions.run(ctx)
+    except Exception:
+        report.issues.append("build extensions failed to run: " + _clean_traceback(traceback.format_exc(), model_path, short=True))
+        return
+    report.checks.extend(checks)
+    if data:
+        result["extensions"] = data
+    if guards:
+        result["guards"] = guards
+
+
+class _Stages:
+    """out/progress.json: what the build is doing now, for the page (written when the stage changes)."""
+
+    def __init__(self, out_dir: Path):
+        self.out_dir, self.last = out_dir, None
+
+    def __call__(self, message: str, done: bool = False) -> None:
+        if message == self.last:
+            return
+        self.last = message
+        try:
+            tmp = self.out_dir / "progress.json.tmp"
+            tmp.write_text(json.dumps({"stage": message, "ts": time.time(), "done": done}), encoding="utf-8")
+            os.replace(tmp, self.out_dir / "progress.json")
+        except OSError:
+            pass
+
+
+def _env_float(name: str, default: float) -> float:
+    try:
+        return float(os.environ.get(name, "") or default)
+    except ValueError:
+        return default
+
+
+def _write_atomic(path: Path, data: bytes) -> None:
+    tmp = path.with_name(path.name + ".tmp")
+    tmp.write_bytes(data)
+    os.replace(tmp, path)
+
+
+def _announce_preview(out_dir: Path, glb: Path, topo: Path, parts_done: int | None = None, parts_total: int | None = None) -> None:
+    """out/preview.json: the newest geometry, before the build is checked and recorded as a revision (with
+    parts_done/parts_total while an assembly is still being meshed)."""
+    data = {"glb": glb.name, "topology": topo.name, "ts": time.time()}
+    if parts_total:
+        data.update(parts_done=parts_done, parts_total=parts_total)
+    tmp = out_dir / "preview.json.tmp"
+    tmp.write_text(json.dumps(data), encoding="utf-8")
+    os.replace(tmp, out_dir / "preview.json")
+
+
+def _clean_traceback(tb: str, model_path: Path, short: bool = False) -> str:
+    """Keep the frames that are in the model file; drop eitri/importlib noise."""
+    lines = tb.splitlines()
+    keep: list[str] = []
+    model_name = model_path.name
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        if line.startswith("  File "):
+            in_model = model_name in line or "/build123d/" in line or "/OCP/" in line
+            if in_model:
+                keep.append(line)
+                if i + 1 < len(lines) and not lines[i + 1].startswith("  File "):
+                    keep.append(lines[i + 1])
+                    i += 1
+            else:
+                if i + 1 < len(lines) and not lines[i + 1].startswith("  File ") and not lines[i + 1].startswith("Traceback"):
+                    i += 1
+            i += 1
+            continue
+        if line.startswith("Traceback"):
+            i += 1
+            continue
+        keep.append(line)
+        i += 1
+    text = "\n".join(keep).strip()
+    if short:
+        return text.splitlines()[-1] if text else tb.strip().splitlines()[-1]
+    text = text or tb
+    hint = _hint_for(tb)
+    return text + ("\n\nHint: " + hint if hint else "")
+
+
+def _hint_for(tb: str) -> str | None:
+    """Turn the kernel's opaque errors into advice."""
+    low = tb.lower()
+    if "fillet" in low or "chamfer" in low:
+        return ("the fillet/chamfer failed in the kernel. Usual causes: radius larger than an adjacent face or wall, "
+                "edges that meet tangent faces (cylinder seams, previous fillets), or tiny faces left by a boolean. "
+                "Use a smaller radius, select fewer edges, fillet the 2D sketch before extruding, or try_fillet(body, "
+                "edges, r, fallbacks=(...)).")
+    if "command not done" in low or "brep_api" in low:
+        return ("an OCCT operation failed (BRep_API: command not done). Check that booleans have overlapping, "
+                "non-coincident faces (extend cutters past walls by 1 mm), that lofted sections have the same "
+                "orientation, and that sweeps/revolves do not self-intersect.")
+    if "no attribute 'to_tuple'" in low:
+        return "Vector has no to_tuple() here; use tuple(v) or v.X/v.Y/v.Z."
+    if "object has no attribute" in low and "'shapelist'" in low:
+        return "ShapeList methods: filter_by(Axis|GeomType|callable), sort_by(Axis|SortBy), group_by(Axis)[i], first/last."
+    if "unexpected keyword argument 'align'" in low:
+        return "this object takes no align=; place it with Pos(...) * shape instead."
+    if "zero_vector" in low or "zero length" in low or ("null" in low and "direction" in low):
+        return "a degenerate (zero-length) vector or edge was created; check for coincident points or zero dimensions."
+    return None
+
+
+if __name__ == "__main__":
+    sys.exit(main())

eitri/_worker.py

@@ -0,0 +1,208 @@
+"""A warm build worker: one long-lived subprocess that imports the CAD kernel once.
+
+The REPL, the MCP server and the viewer each own one worker (it dies with them;
+there is no global daemon, no state folder). A build request is one JSON line on
+the worker's stdin; the worker runs exactly what `eitri._runner` runs and
+answers with one JSON line. If the kernel crashes or a build times out, the
+parent kills the worker and starts a fresh one on the next build.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+
+def _installed_roots() -> list[str]:
+    """Where installed packages live (this interpreter's prefixes and site-packages). A project folder that holds its own venv
+    must not have them purged: numpy and the CAD kernel's extension modules cannot be imported twice in one process."""
+    import site
+    roots = {sys.prefix, sys.base_prefix, sys.exec_prefix}
+    try:
+        roots.update(site.getsitepackages())
+    except AttributeError:                   # some virtualenv layouts
+        pass
+    roots.add(site.getusersitepackages() if hasattr(site, "getusersitepackages") else "")
+    out = []
+    for r in roots:
+        if r:
+            rp = str(Path(r).resolve())
+            out.append(rp if rp.endswith(os.sep) else rp + os.sep)
+    return out
+
+
+def _purge_project_modules(folder: Path) -> None:
+    """Forget modules loaded from the model's folder so edits to helpers are picked up.
+
+    Also drops the folder's __pycache__: Python validates bytecode by mtime (whole
+    seconds) and size, so a helper edited within a second of the last build with
+    the same length would otherwise keep running the old code.
+    """
+    import importlib
+    import shutil
+
+    folder_s = str(folder)
+    keep = _installed_roots()
+    for name, mod in list(sys.modules.items()):
+        f = getattr(mod, "__file__", None)
+        if not f or name == "eitri" or name.startswith("eitri."):
+            continue
+        rf = str(Path(f).resolve())
+        if rf.startswith(folder_s) and not any(rf.startswith(k) for k in keep):
+            del sys.modules[name]
+    for cache in list(folder.glob("__pycache__")) + list(folder.glob("*/__pycache__")):
+        shutil.rmtree(cache, ignore_errors=True)
+    importlib.invalidate_caches()
+
+
+def serve() -> int:
+    """Worker main loop: stdin JSON lines in, JSON lines out."""
+    from . import _runner   # imports the kernel once, here
+    sys.dont_write_bytecode = True
+    out = sys.stdout
+    sys.stdout = sys.stderr          # anything a model prints must not corrupt the protocol
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if req.get("op") == "ping":
+            out.write(json.dumps({"id": req.get("id"), "ok": True}) + "\n")
+            out.flush()
+            continue
+        argv = list(req.get("argv", []))
+        model = req.get("model")
+        if model:
+            _purge_project_modules(Path(model).resolve().parent)
+        t0 = time.time()
+        try:
+            code = _runner.main(argv)
+            reply = {"id": req.get("id"), "code": code, "seconds": round(time.time() - t0, 2)}
+        except SystemExit as exc:
+            reply = {"id": req.get("id"), "code": int(exc.code or 0), "seconds": round(time.time() - t0, 2)}
+        except BaseException as exc:  # noqa: BLE001 - report anything, keep serving
+            reply = {"id": req.get("id"), "code": 1, "error": f"{type(exc).__name__}: {exc}",
+                     "seconds": round(time.time() - t0, 2)}
+        out.write(json.dumps(reply) + "\n")
+        out.flush()
+    return 0
+
+
+class Worker:
+    """Parent-side handle: starts the worker lazily, restarts it after a crash or timeout."""
+
+    def __init__(self) -> None:
+        self.proc: subprocess.Popen | None = None
+        self._lock = threading.Lock()
+        self._next = 0
+        self.restarts = 0
+
+    def _start(self) -> None:
+        env = dict(os.environ)
+        env.setdefault("PYTHONUNBUFFERED", "1")
+        self.proc = subprocess.Popen([sys.executable, "-m", "eitri._worker"], stdin=subprocess.PIPE,
+                                     stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8", bufsize=1, env=env)
+        self._stderr_tail: list[str] = []
+        threading.Thread(target=self._pump, daemon=True).start()
+
+    def _pump(self) -> None:
+        proc = self.proc
+        assert proc is not None and proc.stderr is not None
+        for line in proc.stderr:
+            self._stderr_tail.append(line.rstrip())
+            if len(self._stderr_tail) > 400:
+                del self._stderr_tail[:-400]
+
+    def alive(self) -> bool:
+        return self.proc is not None and self.proc.poll() is None
+
+    def stop(self) -> None:
+        if self.proc is not None:
+            try:
+                if self.proc.stdin:
+                    self.proc.stdin.close()
+                self.proc.wait(timeout=3)
+            except Exception:
+                try:
+                    self.proc.kill()
+                except Exception:
+                    pass
+            self.proc = None
+
+    def run(self, argv: list[str], model: str, cwd: str | None = None, timeout: float = 240.0) -> tuple[int, str, str]:
+        """Run eitri._runner with argv in the warm worker. Returns (code, stdout_tail, stderr_tail).
+
+        cwd is not changed in the worker: model paths are absolute and the runner
+        resolves everything itself.
+        """
+        with self._lock:
+            if not self.alive():
+                if self.proc is not None:   # it died on its own (kernel crash)
+                    self.restarts += 1
+                self._start()
+            assert self.proc and self.proc.stdin and self.proc.stdout
+            self._next += 1
+            req = {"id": self._next, "argv": argv, "model": model}
+            before = len(self._stderr_tail)
+            try:
+                self.proc.stdin.write(json.dumps(req) + "\n")
+                self.proc.stdin.flush()
+            except (BrokenPipeError, OSError):
+                self.stop()
+                return 1, "", "worker pipe broken"
+            reply = self._read_reply(timeout)
+            err = "\n".join(self._stderr_tail[before:])
+            if reply is None:
+                self.proc.kill()
+                self.proc = None
+                self.restarts += 1          # the next build starts a fresh worker
+                return -9, "", err + "\n[worker killed: timeout or crash]"
+            if reply.get("error"):
+                err += "\n" + reply["error"]
+            return int(reply.get("code", 1)), "", err
+
+    def ping(self, timeout: float = 120.0) -> bool:
+        """Start the worker if needed and wait until it answers: the kernel is imported then."""
+        with self._lock:
+            if not self.alive():
+                self._start()
+            assert self.proc and self.proc.stdin and self.proc.stdout
+            self._next += 1
+            try:
+                self.proc.stdin.write(json.dumps({"op": "ping", "id": self._next}) + "\n")
+                self.proc.stdin.flush()
+            except (BrokenPipeError, OSError):
+                return False
+            reply = self._read_reply(timeout)
+            return bool(reply and reply.get("ok"))
+
+    def _read_reply(self, timeout: float) -> dict | None:
+        assert self.proc and self.proc.stdout
+        result: dict[str, Any] = {}
+
+        def reader() -> None:
+            try:
+                line = self.proc.stdout.readline()  # type: ignore[union-attr]
+                if line:
+                    result["reply"] = json.loads(line)
+            except Exception:
+                pass
+
+        t = threading.Thread(target=reader, daemon=True)
+        t.start()
+        t.join(timeout)
+        if t.is_alive():
+            return None
+        return result.get("reply")
+
+
+if __name__ == "__main__":
+    sys.exit(serve())