Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

10.6 KB
Raw Blame
"""
Integration gate for the CAD sandbox: real builds through the warm pool and
real escape attempts against each isolation layer. Runs in the Docker build
(as root, like Cloud Run) and needs build123d installed.

    python test_sandbox.py
"""

import base64
import os
import shutil
import subprocess
import sys
import textwrap
import unittest

os.environ.setdefault("API_KEY", "build-gate")
os.environ["BUILD_TIMEOUT_S"] = "10"

import main  # noqa: E402

BRACKET = """
from build123d import *

LENGTH = 60  # Length [30..200 mm]
WIDTH = 40  # Width [20..120 mm]
THICKNESS = 10  # Thickness [4..30 mm]

with BuildPart() as plate:
    Box(LENGTH, WIDTH, THICKNESS)
    fillet(plate.edges().filter_by(Axis.Z), radius=5)
    with Locations(plate.faces().sort_by(Axis.Z)[-1]):
        with GridLocations(LENGTH - 20, WIDTH - 20, 2, 2):
            CounterBoreHole(radius=2, counter_bore_radius=3.5, counter_bore_depth=2)

result = plate.part
print("built", LENGTH)
"""


def build(code):
    return main.run_build(textwrap.dedent(code))


class SandboxBuildTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        main.pool.refill()

    @classmethod
    def tearDownClass(cls):
        main.pool.close()

    def test_builds_a_real_part_with_every_artifact(self):
        out = build(BRACKET)
        self.assertTrue(out["ok"], out.get("error"))
        size = out["metrics"]["size_mm"]
        self.assertAlmostEqual(size[0], 60, places=2)
        self.assertAlmostEqual(size[1], 40, places=2)
        self.assertAlmostEqual(size[2], 10, places=2)
        self.assertTrue(out["metrics"]["valid"])
        self.assertEqual(out["metrics"]["solids"], 1)
        self.assertLess(out["metrics"]["volume_mm3"], 60 * 40 * 10)
        art = {k: base64.b64decode(v) for k, v in out["artifacts"].items()}
        self.assertTrue(art["glb"].startswith(b"glTF"))
        self.assertIn(b"ISO-10303-21", art["step"][:200])
        self.assertGreater(len(art["stl"]), 84)
        self.assertIn(b"<svg", art["thumb_svg"][:400])
        self.assertIn(b"ISOMETRIC", art["drawing_svg"])
        self.assertIn(b'fill="rgb(246,247,249)"', art["thumb_svg"])
        import xml.dom.minidom
        xml.dom.minidom.parseString(art["thumb_svg"])
        xml.dom.minidom.parseString(art["drawing_svg"])
        self.assertIn("built 60", out["log"])
        if main.REQUIRE_SECCOMP:
            self.assertTrue(out["seccomp"])

    def test_runtime_error_reports_the_program_line(self):
        out = build("from build123d import *\nx = 1\nresult = Box(10, 10, 10) / 0\n")
        self.assertFalse(out["ok"])
        self.assertEqual(out["error"]["kind"], "runtime")
        self.assertEqual(out["error"]["line"], 3)

    def test_missing_result_is_explained(self):
        out = build("from build123d import *\nshape = Box(1, 1, 1)\n")
        self.assertFalse(out["ok"])
        self.assertEqual(out["error"]["kind"], "result")

    def test_a_lone_builder_is_accepted_as_the_result(self):
        out = build("from build123d import *\nwith BuildPart() as p:\n    Box(5, 5, 5)\n")
        self.assertTrue(out["ok"], out.get("error"))

    def test_two_dimensional_result_is_refused(self):
        out = build("from build123d import *\nwith BuildSketch() as s:\n    Circle(5)\nresult = s\n")
        self.assertFalse(out["ok"])
        self.assertIn("2D", out["error"]["message"])

    def test_policy_refusal_is_reported(self):
        out = build("import os\nresult = os.listdir('/')\n")
        self.assertFalse(out["ok"])
        self.assertEqual(out["error"]["kind"], "policy")

    def test_builtins_handle_is_refused(self):
        out = build("from build123d import *\nimport math\nm = __builtins__\n")
        self.assertEqual(out["error"]["kind"], "policy")

    def test_infinite_loop_is_killed(self):
        out = build("x = 0\nwhile True:\n    x += 1\n")
        self.assertFalse(out["ok"])
        self.assertEqual(out["error"]["kind"], "timeout")

    def test_memory_bomb_is_contained(self):
        out = build("x = [0] * (10 ** 10)\n")
        self.assertFalse(out["ok"])
        self.assertEqual(out["error"]["kind"], "memory")

    def test_oversized_fillet_is_reduced_and_reported(self):
        out = build(
            "from build123d import *\n"
            "with BuildPart() as p:\n"
            "    Box(20, 20, 2)\n"
            "    fillet(p.edges().group_by(Axis.Z)[-1], radius=3)\n"
            "result = p.part\n"
        )
        self.assertTrue(out["ok"], out.get("error"))
        self.assertTrue(any("fillet 3 mm" in a for a in out["adjustments"]), out["adjustments"])

    def test_impossible_fillet_is_skipped_and_reported(self):
        out = build(
            "from build123d import *\n"
            "with BuildPart() as p:\n"
            "    Box(20, 20, 0.4)\n"
            "    fillet(p.edges(), radius=5)\n"
            "result = p.part\n"
        )
        self.assertTrue(out["ok"], out.get("error"))
        self.assertTrue(any("left the edges sharp" in a for a in out["adjustments"]), out["adjustments"])
        self.assertAlmostEqual(out["metrics"]["volume_mm3"], 160, places=1)

    def test_impossible_algebra_fillet_returns_the_part(self):
        out = build(
            "from build123d import *\n"
            "box = Box(20, 20, 0.4)\n"
            "result = fillet(box.edges(), radius=5)\n"
        )
        self.assertTrue(out["ok"], out.get("error"))
        self.assertAlmostEqual(out["metrics"]["volume_mm3"], 160, places=1)

    def test_standard_parts_from_bd_warehouse(self):
        out = build(
            "from build123d import *\n"
            "from bd_warehouse.gear import SpurGear\n"
            "result = SpurGear(module=2, tooth_count=20, pressure_angle=20, thickness=8, root_fillet=0.5)\n"
        )
        self.assertTrue(out["ok"], out.get("error"))
        self.assertAlmostEqual(out["metrics"]["size_mm"][0], 44, places=0)

    def test_module_object_import_is_refused_at_runtime(self):
        out = build("from build123d import exporters\n")
        self.assertFalse(out["ok"])
        self.assertIn("module", out["error"]["message"])

    def test_pool_recovers_after_failures(self):
        out = build(BRACKET)
        self.assertTrue(out["ok"], out.get("error"))


class FailureClassificationTests(unittest.TestCase):
    def test_kernel_segfault_names_the_program_line(self):
        stderr = 'Fatal Python error: Segmentation fault\n\nCurrent thread:\n  File "<design>", line 14 in <module>\n'
        failure = main._signal_failure(-11, stderr)
        self.assertEqual(failure["kind"], "crash")
        self.assertEqual(failure["line"], 14)
        self.assertIn("line 14", failure["message"])

    def test_crash_on_a_kernel_thread_reports_the_innermost_program_line(self):
        stderr = (
            "Fatal Python error: Segmentation fault\n\n"
            "Thread 0x00007f2a9b512340 (most recent call first):\n"
            '  File "<design>", line 3 in run\n'
            '  File "<design>", line 4 in <module>\n'
        )
        self.assertEqual(main._signal_failure(-11, stderr)["line"], 3)

    def test_cpu_and_memory_limits(self):
        self.assertEqual(main._signal_failure(-24, "")["kind"], "timeout")
        self.assertEqual(main._signal_failure(-9, "")["kind"], "memory")
        self.assertEqual(main._signal_failure(-6, "")["kind"], "memory")


PROBE = r"""
import errno, os, socket, sys
sys.path.insert(0, "/app" if os.path.isdir("/app") else os.getcwd())
from sandbox_child import install_seccomp
results = {"uid": os.getuid(), "seccomp": install_seccomp()}
try:
    socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    results["socket"] = "opened"
except OSError as exc:
    results["socket"] = exc.errno
try:
    os.execv("/bin/true", ["/bin/true"])
except OSError as exc:
    results["exec"] = exc.errno
try:
    pid = os.fork()
    if pid == 0:
        os._exit(0)
    results["fork"] = "forked"
except OSError as exc:
    results["fork"] = exc.errno
try:
    open("/proc/1/environ", "rb").read()
    results["parent_env"] = "read"
except OSError as exc:
    results["parent_env"] = exc.errno
import threading
t = threading.Thread(target=lambda: None); t.start(); t.join()
results["threads"] = "ok"
print(repr(results))
"""


class IsolationLayerTests(unittest.TestCase):
    """Each layer on its own, so a policy bypass would still hit a wall."""

    def test_seccomp_and_uid_drop(self):
        drop = os.geteuid() == 0
        proc = subprocess.run(
            [sys.executable, "-c", PROBE],
            capture_output=True,
            text=True,
            env={"PATH": "/usr/bin:/bin", "OMP_NUM_THREADS": "2", "OPENBLAS_NUM_THREADS": "2"},
            cwd=os.path.dirname(os.path.abspath(__file__)),
            user=main.SANDBOX_UID if drop else None,
            group=main.SANDBOX_UID if drop else None,
            extra_groups=[] if drop else None,
            preexec_fn=main._limits,
            timeout=60,
        )
        self.assertEqual(proc.returncode, 0, proc.stderr)
        results = eval(proc.stdout.strip())  # noqa: S307  (our own repr, test only)
        if not main.REQUIRE_SECCOMP and not results["seccomp"]:
            self.skipTest("seccomp unavailable on this host")
        self.assertTrue(results["seccomp"])
        self.assertEqual(results["socket"], 1)  # EPERM
        self.assertEqual(results["exec"], 1)
        self.assertEqual(results["fork"], 1)
        self.assertEqual(results["threads"], "ok")
        if drop:
            self.assertEqual(results["uid"], main.SANDBOX_UID)
            self.assertNotEqual(results["parent_env"], "read")


class PerJobUidTests(unittest.TestCase):
    def test_live_children_never_share_a_uid(self):
        uids = [main.next_sandbox_uid() for _ in range(main.SANDBOX_UID_SPAN)]
        self.assertEqual(len(set(uids)), main.SANDBOX_UID_SPAN)
        self.assertTrue(all(u >= main.SANDBOX_UID_BASE for u in uids))


class CollectTests(unittest.TestCase):
    def test_collect_does_not_follow_symlinked_artifacts(self):
        import tempfile

        secret = tempfile.NamedTemporaryFile(delete=False)
        secret.write(b"parent-only-secret")
        secret.close()
        workdir = tempfile.mkdtemp(prefix="cad-collect-")
        try:
            os.symlink(secret.name, os.path.join(workdir, "part.glb"))
            with open(os.path.join(workdir, "part.stl"), "wb") as fh:
                fh.write(b"solid")
            child = main.Child(proc=None, workdir=workdir, started=0.0)
            out = main._collect(child, {"ok": True, "files": ["part.glb", "part.stl"]})
            self.assertNotIn("glb", out["artifacts"])
            self.assertEqual(base64.b64decode(out["artifacts"]["stl"]), b"solid")
        finally:
            os.unlink(secret.name)
            shutil.rmtree(workdir, ignore_errors=True)


if __name__ == "__main__":
    unittest.main(verbosity=2)