@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/src/openscad_mcp/service.py

@@ -0,0 +1,190 @@
+"""Persistent models with immutable revisions and commit-on-success edits."""
+
+import json
+import os
+import re
+import shutil
+import tempfile
+import threading
+import uuid
+from pathlib import Path
+
+from .engine import FORMATS, VIEWS, OpenSCAD
+from .geometry import generate_source, parse_description
+
+
+class ModelNotFound(ValueError):
+    pass
+
+
+class ModelConflict(ValueError):
+    def __init__(self, current_revision: str):
+        self.current_revision = current_revision
+        super().__init__(
+            "Model changed since it was read. Read the current source/parameters before retrying the edit."
+        )
+
+
+class ModelService:
+    def __init__(self, output_dir: str | Path, engine: OpenSCAD | None = None):
+        self.root = Path(output_dir).expanduser().resolve()
+        self.root.mkdir(parents=True, exist_ok=True)
+        self.engine = engine or OpenSCAD()
+        # One process owns this store. Serialize renders/edits so updates cannot race.
+        self.lock = threading.RLock()
+
+    def _directory(self, model_id: str) -> Path:
+        if not re.fullmatch(r"[0-9a-f]{32}", model_id):
+            raise ModelNotFound("Invalid model ID")
+        return self.root / model_id
+
+    def _load(self, model_id: str) -> dict:
+        try:
+            return json.loads((self._directory(model_id) / "model.json").read_text())
+        except FileNotFoundError as exc:
+            raise ModelNotFound(f"Model {model_id} not found") from exc
+
+    def _save(self, model_id: str, metadata: dict):
+        directory = self._directory(model_id)
+        with tempfile.NamedTemporaryFile(
+            mode="w", dir=directory, delete=False, suffix=".json"
+        ) as stream:
+            temporary = Path(stream.name)
+            json.dump(metadata, stream, indent=2)
+        try:
+            os.replace(temporary, directory / "model.json")
+        finally:
+            temporary.unlink(missing_ok=True)
+
+    def _build(
+        self, model_id: str, source: str, shape: str, parameters: dict, description: str
+    ) -> dict:
+        directory = self._directory(model_id)
+        directory.mkdir(exist_ok=True)
+        revision = uuid.uuid4().hex
+        target = directory / revision
+        target.mkdir()
+        try:
+            scad = target / "model.scad"
+            scad.write_text(source, encoding="utf-8")
+            self.engine.export(scad, target / "model.stl")
+            for view in VIEWS:
+                self.engine.export(scad, target / f"{view}.png", view)
+            data = {
+                "model_id": model_id,
+                "revision": revision,
+                "model_type": shape,
+                "parameters": parameters,
+                "description": description,
+            }
+            self._save(model_id, data)
+        except Exception:
+            shutil.rmtree(target)
+            if not (directory / "model.json").exists():
+                directory.rmdir()
+            raise
+        return self._public(data)
+
+    def _public(self, data: dict) -> dict:
+        model_id = data["model_id"]
+        directory = self._directory(model_id) / data["revision"]
+        return data | {
+            "scad_file": str(directory / "model.scad"),
+            "model_file": str(directory / "model.stl"),
+            "preview_url": f"/ui/preview/{model_id}",
+            "previews": {view: f"/preview/{view}/{model_id}" for view in VIEWS},
+            "preview_files": {view: str(directory / f"{view}.png") for view in VIEWS},
+            "download_url": f"/download/{model_id}?format=stl",
+            "supported_formats": list(FORMATS),
+        }
+
+    def create(
+        self,
+        description: str = "",
+        model_type: str | None = None,
+        parameters: dict | None = None,
+    ) -> dict:
+        if model_type is None:
+            model_type, extracted = parse_description(description)
+            parameters = extracted | (parameters or {})
+        source, parameters = generate_source(model_type, parameters)
+        with self.lock:
+            return self._build(
+                uuid.uuid4().hex, source, model_type, parameters, description
+            )
+
+    def from_scad(self, source: str, description: str = "") -> dict:
+        if not source.strip() or len(source.encode()) > 100_000:
+            raise ValueError("SCAD source must contain 1–100000 bytes")
+        with self.lock:
+            return self._build(uuid.uuid4().hex, source, "custom", {}, description)
+
+    def modify(
+        self,
+        model_id: str,
+        modifications: str = "",
+        parameters: dict | None = None,
+        scad_code: str | None = None,
+        expected_revision: str | None = None,
+    ) -> dict:
+        with self.lock:
+            data = self._load(model_id)
+            if expected_revision is not None and expected_revision != data["revision"]:
+                raise ModelConflict(data["revision"])
+            if scad_code is not None:
+                if modifications or parameters:
+                    raise ValueError("Supply scad_code alone when replacing source")
+                if not scad_code.strip() or len(scad_code.encode()) > 100_000:
+                    raise ValueError("SCAD source must contain 1–100000 bytes")
+                return self._build(
+                    model_id, scad_code, "custom", {}, data["description"]
+                )
+            if data["model_type"] == "custom":
+                raise ValueError("Supply scad_code to replace a custom model's source")
+            if not modifications and not parameters:
+                raise ValueError("Supply modifications, parameters, or scad_code")
+            values = data["parameters"]
+            if modifications:
+                _, values = parse_description(modifications, data["model_type"], values)
+            source, values = generate_source(
+                data["model_type"], values | (parameters or {})
+            )
+            return self._build(
+                model_id, source, data["model_type"], values, data["description"]
+            )
+
+    def get(self, model_id: str) -> dict:
+        return self._public(self._load(model_id))
+
+    def source(self, model_id: str) -> dict:
+        data = self._load(model_id)
+        path = self._directory(model_id) / data["revision"] / "model.scad"
+        return {
+            "model_id": model_id,
+            "revision": data["revision"],
+            "model_type": data["model_type"],
+            "parameters": data["parameters"],
+            "scad_code": path.read_text(encoding="utf-8"),
+        }
+
+    def export(self, model_id: str, format: str = "stl") -> dict:
+        if format not in FORMATS:
+            raise ValueError(f"Unsupported format. Choose from {', '.join(FORMATS)}")
+        with self.lock:
+            data = self._load(model_id)
+            directory = self._directory(model_id) / data["revision"]
+            output = directory / f"model.{format}"
+            if not output.exists():
+                self.engine.export(directory / "model.scad", output)
+            return {
+                "model_id": model_id,
+                "format": format,
+                "model_file": str(output),
+                "download_url": f"/download/{model_id}?format={format}",
+            }
+
+    def preview(self, model_id: str, view: str) -> Path:
+        if view not in VIEWS:
+            raise ModelNotFound("Unknown preview view")
+        data = self._load(model_id)
+        return self._directory(model_id) / data["revision"] / f"{view}.png"

package/mcp_servers/openscad-mcp-server/tests/conftest.py

@@ -0,0 +1,17 @@
+import pytest
+
+from openscad_mcp.engine import OpenSCAD
+from openscad_mcp.service import ModelService
+
+
+@pytest.fixture
+def engine():
+    # Missing OpenSCAD is a failure: a green suite must include actual rendering.
+    result = OpenSCAD(timeout=120)
+    result.version()
+    return result
+
+
+@pytest.fixture
+def service(tmp_path, engine):
+    return ModelService(tmp_path / "models", engine)

package/mcp_servers/openscad-mcp-server/tests/test_engine.py

@@ -0,0 +1,37 @@
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from openscad_mcp.engine import OpenSCAD, OpenSCADError
+
+
+def test_missing_executable():
+    with pytest.raises(OpenSCADError, match="Cannot launch"):
+        OpenSCAD("/no/such/openscad").version()
+
+
+@pytest.mark.parametrize("mode", ["timeout", "empty", "warning", "error", "nonzero"])
+def test_failures_do_not_replace_existing_outputs(tmp_path, monkeypatch, mode):
+    destination = tmp_path / "model.stl"
+    destination.write_bytes(b"previous valid revision")
+
+    def run(command, **kwargs):
+        if mode == "timeout":
+            raise subprocess.TimeoutExpired(command, 1)
+        output = Path(command[command.index("-o") + 1])
+        if mode != "empty":
+            output.write_bytes(b"bad output")
+        message = {
+            "warning": "WARNING: Ignoring unknown module",
+            "error": "ERROR: Assertion failed",
+        }.get(mode, "")
+        return subprocess.CompletedProcess(
+            command, 1 if mode == "nonzero" else 0, "", message
+        )
+
+    monkeypatch.setattr(subprocess, "run", run)
+    with pytest.raises(OpenSCADError):
+        OpenSCAD("openscad").export(tmp_path / "source.scad", destination)
+    assert destination.read_bytes() == b"previous valid revision"
+    assert not list(tmp_path.glob(".render-*"))

package/mcp_servers/openscad-mcp-server/tests/test_geometry.py

@@ -0,0 +1,106 @@
+import json
+
+import pytest
+
+from openscad_mcp.geometry import generate_source, parameters_for, parse_description
+
+
+@pytest.mark.parametrize(
+    ("description", "shape", "expected"),
+    [
+        (
+            "hollow box width 30 mm depth 20 mm height 15 mm thickness 2 mm",
+            "box",
+            {"width": 30, "thickness": 2},
+        ),
+        ("rounded box width 40 mm", "rounded_box", {"width": 40}),
+        (
+            "tube outer_radius 12 inner_radius 6 height 30",
+            "tube",
+            {"outer_radius": 12, "inner_radius": 6},
+        ),
+        (
+            "cube 2 cm wide 1 inch high depth 5 mm",
+            "cube",
+            {"width": 20, "height": 25.4, "depth": 5},
+        ),
+        ("sphere diameter 30 mm", "sphere", {"radius": 15}),
+        ("cube centered width 12", "cube", {"center": True, "width": 12}),
+        ("cube not centered width 12", "cube", {"center": False}),
+    ],
+)
+def test_descriptions(description, shape, expected):
+    actual_shape, parameters = parse_description(description)
+    assert actual_shape == shape
+    assert expected.items() <= parameters.items()
+
+
+@pytest.mark.parametrize(
+    "description",
+    [
+        "a rabbit",
+        "cube 20x30x40",
+        "cube width -3 mm",
+        "cube height 0",
+        "cube width 3 feet",
+    ],
+)
+def test_reject_unrecognized_or_invalid_descriptions(description):
+    with pytest.raises(ValueError):
+        parse_description(description)
+
+
+@pytest.mark.parametrize(
+    ("shape", "values"),
+    [
+        ("cube", {"width": float("nan")}),
+        ("cube", {"width": float("inf")}),
+        ("cube", {"width": True}),
+        ("cube", {"center": "false"}),
+        ("cube", {"radius": 3}),
+        ("tube", {"inner_radius": 12}),
+        ("box", {"thickness": 11}),
+        ("rounded_box", {"radius": 20}),
+        ("sphere", {"segments": 2}),
+        ("torus", {"minor_radius": 20}),
+        ("custom", {}),
+    ],
+)
+def test_reject_invalid_parameters(shape, values):
+    with pytest.raises(ValueError):
+        parameters_for(shape, values)
+
+
+def test_edit_preserves_unspecified_dimensions():
+    existing = parameters_for("cube", {"width": 23, "center": True})
+    _, result = parse_description("height 32 mm", "cube", existing)
+    assert result == existing | {"height": 32}
+    assert existing["height"] == 10
+    with pytest.raises(ValueError, match="No parameter changes"):
+        parse_description("make it prettier", "cube", existing)
+
+
+def test_source_is_self_contained_and_strings_are_escaped():
+    value = 'say "hello";\n cube(999); //'
+    source, _ = generate_source("text", {"text": value})
+    assert f"text = {json.dumps(value)};" in source
+    assert "include <" not in source
+
+
+@pytest.mark.parametrize(
+    "description",
+    [
+        "cube width 20 radius 3",
+        "cube with a hole",
+        "cube and sphere",
+        "sphere segments 24 mm",
+    ],
+)
+def test_does_not_ignore_unsupported_dimensions_or_operations(description):
+    with pytest.raises(ValueError):
+        parse_description(description)
+
+
+def test_huge_number_is_validation_error():
+    with pytest.raises(ValueError):
+        parameters_for("cube", {"width": 10**400})

package/mcp_servers/openscad-mcp-server/tests/test_integration.py

@@ -0,0 +1,172 @@
+import hashlib
+import math
+import shutil
+import zipfile
+from pathlib import Path
+
+import pytest
+import trimesh
+from PIL import Image
+
+from openscad_mcp.engine import OpenSCADError
+from openscad_mcp.geometry import DEFAULTS, generate_source
+from openscad_mcp.service import ModelNotFound, ModelService
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.mark.parametrize("shape", list(DEFAULTS))
+def test_every_primitive_is_real_closed_geometry(tmp_path, engine, shape):
+    source, _ = generate_source(shape)
+    scad = tmp_path / f"{shape}.scad"
+    scad.write_text(source)
+    stl = engine.export(scad, tmp_path / f"{shape}.stl")
+    mesh = trimesh.load_mesh(stl)
+    assert len(mesh.faces) >= 4
+    assert mesh.is_watertight
+    assert mesh.is_winding_consistent
+    assert mesh.volume > 0
+    if shape == "cube":
+        assert mesh.extents.tolist() == pytest.approx([10, 10, 10])
+        assert mesh.volume == pytest.approx(1000)
+    if shape == "box":
+        assert mesh.volume == pytest.approx(30 * 20 * 15 - 26 * 16 * 13)
+    if shape == "tube":
+        assert mesh.volume == pytest.approx(math.pi * (100 - 64) * 20, rel=0.01)
+    if shape == "prism":
+        assert mesh.volume == pytest.approx(2000)
+
+
+def test_full_model_lifecycle(service, tmp_path):
+    model = service.create(
+        "hollow box width 30 mm depth 20 mm height 15 mm thickness 2 mm"
+    )
+    model_id = model["model_id"]
+    hashes = []
+    for path in model["preview_files"].values():
+        with Image.open(path) as image:
+            assert image.size == (800, 600)
+            assert image.convert("RGB").getextrema() != ((0, 0),) * 3
+            assert len(image.getcolors(800 * 600)) >= 2
+            # A filled silhouette must occupy a meaningful part of the image.
+            colors = image.convert("RGB").getcolors(800 * 600)
+            assert max(count for count, _ in colors) < 800 * 600 * 0.99
+        hashes.append(hashlib.sha256(Path(path).read_bytes()).hexdigest())
+    assert len(set(hashes)) == 4
+    for format in ("scad", "stl", "csg", "3mf"):
+        exported = Path(service.export(model_id, format)["model_file"])
+        assert exported.stat().st_size > 100
+        if format == "3mf":
+            with zipfile.ZipFile(exported) as archive:
+                assert any(name.endswith(".model") for name in archive.namelist())
+        if format == "scad":
+            # The download works outside the source checkout, without template includes.
+            portable = tmp_path / "elsewhere" / "portable.scad"
+            portable.parent.mkdir()
+            shutil.copyfile(exported, portable)
+            service.engine.export(portable, portable.with_suffix(".stl"))
+    changed = service.modify(model_id, "height 25 mm")
+    assert changed["parameters"]["height"] == 25
+    assert changed["parameters"]["thickness"] == 2
+    assert trimesh.load_mesh(changed["model_file"]).extents.tolist() == pytest.approx(
+        [30, 20, 25]
+    )
+    reloaded = ModelService(service.root, service.engine).get(model_id)
+    assert reloaded == changed
+    with pytest.raises(OpenSCADError):
+        service.modify(model_id, scad_code="this is invalid SCAD !!!")
+    assert service.get(model_id) == changed
+    assert (
+        len(list((service.root / model_id).iterdir())) == 3
+    )  # two revisions and manifest
+
+
+@pytest.mark.parametrize(
+    "source",
+    [
+        "nonsense !!!",
+        "",
+        "// no geometry",
+        "unknown_module();",
+        'assert(false, "broken"); cube(2);',
+    ],
+)
+def test_invalid_source_never_creates_success(service, source):
+    with pytest.raises((ValueError, OpenSCADError)):
+        service.from_scad(source)
+    assert not list(service.root.iterdir())
+
+
+def test_custom_geometry(service):
+    model = service.from_scad(
+        "difference() { cube([40,30,8]); translate([20,15,-1]) cylinder(h=10,r=5,$fn=48); }"
+    )
+    mesh = trimesh.load_mesh(model["model_file"])
+    assert mesh.is_watertight
+    assert mesh.volume == pytest.approx(40 * 30 * 8 - math.pi * 25 * 8, rel=0.002)
+    with pytest.raises(ValueError, match="scad_code"):
+        service.modify(model["model_id"], parameters={"width": 2})
+
+
+@pytest.mark.parametrize("model_id", ["../../etc/passwd", "bad", "a" * 32])
+def test_unknown_ids(service, model_id):
+    with pytest.raises(ModelNotFound):
+        service.get(model_id)
+    with pytest.raises(ModelNotFound):
+        service.source(model_id)
+
+
+def test_source_round_trip_and_stale_edits(service):
+    from openscad_mcp.service import ModelConflict
+
+    original = "// café — dimensions\nsize = 4;\ncube(size);\n"
+    model = service.from_scad(original)
+    source = service.source(model["model_id"])
+    assert source["scad_code"] == original
+    assert source["revision"] == model["revision"]
+    edited = service.modify(
+        model["model_id"],
+        scad_code=original.replace("size = 4", "size = 6"),
+        expected_revision=source["revision"],
+    )
+    assert trimesh.load_mesh(edited["model_file"]).volume == pytest.approx(216)
+    with pytest.raises(ModelConflict) as caught:
+        service.modify(
+            model["model_id"],
+            scad_code="cube(10);",
+            expected_revision=source["revision"],
+        )
+    assert caught.value.current_revision == edited["revision"]
+    assert service.source(model["model_id"])["scad_code"] == original.replace(
+        "size = 4", "size = 6"
+    )
+    # Exactly two successful revisions; rejection created no files.
+    assert len(list((service.root / model["model_id"]).iterdir())) == 3
+
+
+def test_concurrent_edits_cannot_both_commit_same_revision(service):
+    from concurrent.futures import ThreadPoolExecutor
+
+    from openscad_mcp.service import ModelConflict
+
+    model = service.create(model_type="cube")
+
+    def edit(height):
+        try:
+            return service.modify(
+                model["model_id"],
+                parameters={"height": height},
+                expected_revision=model["revision"],
+            )
+        except ModelConflict:
+            return None
+
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        results = list(pool.map(edit, [12, 15]))
+    winners = [result for result in results if result is not None]
+    assert len(winners) == 1
+    assert service.get(model["model_id"]) == winners[0]
+    assert (
+        service.source(model["model_id"])["parameters"]["height"]
+        == winners[0]["parameters"]["height"]
+    )