@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/.dockerignore

@@ -0,0 +1,9 @@
+**
+!Dockerfile
+!pyproject.toml
+!uv.lock
+!README.md
+!LICENSE
+!src/
+!src/openscad_mcp/
+!src/openscad_mcp/*.py

package/mcp_servers/openscad-mcp-server/.github/workflows/test.yml

@@ -0,0 +1,40 @@
+name: Test
+on:
+  push:
+  pull_request:
+permissions:
+  contents: read
+jobs:
+  linux:
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        python: ["3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Install OpenSCAD and headless display
+        run: sudo apt-get update && sudo apt-get install -y openscad xvfb
+      - run: uv sync --locked --group dev
+      - run: uv run ruff check src/openscad_mcp tests scripts
+      - run: uv run ruff format --check src/openscad_mcp tests scripts
+      - name: Test real geometry and both MCP transports
+        run: xvfb-run -a uv run pytest -q
+
+  docker:
+    strategy:
+      matrix:
+        runner: [ubuntu-24.04, ubuntu-24.04-arm]
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: '3.13'
+      - run: uv sync --locked --group dev
+      - name: Build headless image
+        run: docker build --tag openscad-mcp:ci .
+      - name: Test real container MCP and rendering without network or GPU
+        run: uv run python scripts/test_docker.py --image openscad-mcp:ci

package/mcp_servers/openscad-mcp-server/Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.13-slim-bookworm AS builder
+
+# Match the lockfile tooling used for the native installation.
+RUN python -m pip install --no-cache-dir uv==0.6.3
+WORKDIR /app
+COPY pyproject.toml uv.lock README.md LICENSE ./
+COPY src/openscad_mcp ./src/openscad_mcp
+ENV UV_PROJECT_ENVIRONMENT=/opt/venv UV_LINK_MODE=copy
+RUN uv sync --locked --no-dev --no-editable
+
+FROM python:3.13-slim-bookworm AS runtime
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    openscad xvfb xauth libgl1-mesa-dri fonts-liberation tini \
+    && rm -rf /var/lib/apt/lists/* \
+    && useradd --create-home --uid 10001 app \
+    && mkdir -p /data /tmp/runtime-app \
+    && chown app:app /data /tmp/runtime-app \
+    && chmod 700 /tmp/runtime-app
+COPY --from=builder /opt/venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH" \
+    OPENSCAD_OUTPUT_DIR=/data \
+    LIBGL_ALWAYS_SOFTWARE=1 \
+    XDG_RUNTIME_DIR=/tmp/runtime-app \
+    PYTHONUNBUFFERED=1
+USER app
+WORKDIR /data
+# MCP uses stdin/stdout. Xvfb supplies a headless display; no GPU is required.
+# tini forwards termination to the entire process group, including renderers.
+ENTRYPOINT ["tini", "-g", "--", "xvfb-run", "-a", "-s", "-screen 0 1024x768x24 -nolisten tcp", "openscad-mcp"]

package/mcp_servers/openscad-mcp-server/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jack Hacksman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/mcp_servers/openscad-mcp-server/README.md

@@ -0,0 +1,154 @@
+# OpenSCAD MCP Server
+
+A local MCP server that turns OpenSCAD source or explicit primitive dimensions into editable SCAD, STL geometry, and four PNG previews. The connected assistant can write SCAD for complex designs; this server compiles and renders it with the installed OpenSCAD executable.
+
+**Status:** the supported implementation is in `src/openscad_mcp`. The previous image generation, CUDA reconstruction, remote processing, and printer code is archived in [`legacy/`](legacy/README.md). It is unfinished and is not part of the installed server. See the [audit and machine test results](docs/audit.md).
+
+## Install
+
+Requires Python 3.11+ and OpenSCAD. No API keys, CUDA, Open3D, or separate image renderer are required.
+
+Install OpenSCAD using the [official downloads](https://openscad.org/downloads.html). On macOS, the current native Apple Silicon/Intel build is available with:
+
+```sh
+brew install --cask openscad@snapshot
+openscad --version
+```
+
+On Debian/Ubuntu, `sudo apt-get install openscad` installs the distribution package. Linux PNG rendering may need an X display; use `xvfb-run -a` around the server or tests on a headless machine. Windows users can set `OPENSCAD_EXECUTABLE` to the full path of `openscad.exe`.
+
+```sh
+git clone https://github.com/jhacksman/OpenSCAD-MCP-Server.git
+cd OpenSCAD-MCP-Server
+uv sync --locked
+uv run openscad-mcp --help
+```
+
+Alternatively, install into a virtual environment with `python -m pip install .` and run `openscad-mcp`. `requirements.txt` installs this same package. `uv.lock` pins the tested dependency resolution; the project metadata permits compatible updates.
+
+On an external filesystem that cannot create symlinks, put the environment on the internal disk:
+
+```sh
+export UV_PROJECT_ENVIRONMENT="$HOME/.cache/openscad-mcp-venv"
+uv sync --locked
+```
+
+## Docker and Jetson
+
+A headless stdio image is available through the root `Dockerfile`. See [Docker setup and verification](docs/docker.md) for build commands, MCP client configuration, persistent model storage, and Glama listing requirements. The image needs no GPU.
+
+For the hardware question in issue #19, see [Jetson Orin Nano and CUDA](docs/jetson.md). The supported server does not use CUDA; the archived reconstruction prototype is not restored by this Docker support.
+
+## Connect an MCP client
+
+Stdio is the default. Configure the client to launch the server process, using absolute paths:
+
+```json
+{
+  "mcpServers": {
+    "openscad": {
+      "command": "/absolute/path/to/venv/bin/openscad-mcp",
+      "args": ["--output-dir", "/absolute/path/to/models"]
+    }
+  }
+}
+```
+
+For clients supporting Streamable HTTP:
+
+```sh
+uv run openscad-mcp --transport http --port 8000
+```
+
+The MCP endpoint is **`http://127.0.0.1:8000/mcp`**. `/` is server information; `/health` reports the OpenSCAD version and primitive defaults. HTTP also serves preview pages and downloads. In stdio mode, use returned absolute file paths or `get_model_preview`; there is no HTTP listener.
+
+## Tools
+
+| Tool | Purpose |
+| --- | --- |
+| `get_capabilities` | OpenSCAD version and supported primitives with default parameters |
+| `create_3d_model` | Create a primitive using `model_type` and `parameters`, or a limited description |
+| `create_model_from_scad` | Compile trusted `scad_code` for a custom 3D model |
+| `modify_3d_model` | Change primitive parameters or replace a model's `scad_code` |
+| `get_model` | Read a saved model and its artifact paths |
+| `get_model_source` | Read saved SCAD source and its revision, including inside Docker |
+| `get_model_preview` | Return a PNG image as MCP image content |
+| `export_model` | Export `scad`, `stl`, `csg`, or `3mf` |
+
+Example arguments to `create_3d_model`:
+
+```json
+{
+  "model_type": "box",
+  "parameters": {"width": 40, "depth": 30, "height": 20, "thickness": 2}
+}
+```
+
+Dimensions are in millimeters. Supported types: `cube` (also rectangular blocks), `sphere`, `cylinder`, `box` (open hollow box), `rounded_box` (solid), `tube`, `cone`, `torus`, `prism` (right triangular cross-section), `hexagonal_prism`, and `text`. Call `get_capabilities` for each type's exact parameter names. A torus uses the radius to the tube center (`major_radius`) and the tube radius (`minor_radius`).
+
+The optional description parser recognizes named dimensions such as `hollow box width 40 mm depth 30 mm height 20 mm thickness 2 mm` or `cube 2 cm wide 1 inch high`. It supports mm, cm, m, and inches; omitted units mean mm. It is a small parser, not a general natural-language model. Unspecified dimensions use the returned defaults. Prefer explicit parameters for precision. For arbitrary objects, have the assistant write self-contained SCAD and call `create_model_from_scad`.
+
+```json
+{
+  "scad_code": "difference() { cube([40,30,8]); translate([20,15,-1]) cylinder(h=10,r=5,$fn=48); }",
+  "description": "Mounting plate with a through hole"
+}
+```
+
+To modify a primitive:
+
+```json
+{"model_id": "ID_FROM_CREATION", "parameters": {"height": 25}}
+```
+
+For custom models, call `get_model_source` with the model ID to retrieve `scad_code` and `revision` directly through MCP. Edit the returned source, then call `modify_3d_model` with the new `scad_code` and `expected_revision` set to the revision you read. No access to the server's filesystem is needed to read the source.
+
+The same optional revision check works for primitive parameter edits:
+
+```json
+{
+  "model_id": "ID_FROM_CREATION",
+  "parameters": {"height": 25},
+  "expected_revision": "REVISION_FROM_GET_MODEL"
+}
+```
+
+If another edit has already committed, the operation fails before rendering or changing files. MCP reports a tool error; the HTTP `/tool_call` API returns **409** with `current_revision`. Read the latest source/parameters and incorporate the intervening changes before retrying. Omitting `expected_revision` preserves the original unconditional edit behavior.
+
+Only **SCAD** retains editable source parameters. CSG is an evaluated geometry tree. STL and 3MF are meshes; they do not preserve the design's parametric relationships. AMF (removed in current OpenSCAD builds), STEP, OBJ, 2D exports, image reconstruction, and printing are not offered.
+
+## HTTP smoke test
+
+With the HTTP server running:
+
+```sh
+curl --fail http://127.0.0.1:8000/tool_call \
+  -H 'Content-Type: application/json' \
+  -d '{"tool_name":"create_3d_model","tool_params":{"model_type":"box","parameters":{"width":40,"depth":30,"height":20,"thickness":2}}}'
+```
+
+Open the returned `preview_url` on the same server. Download `/download/MODEL_ID?format=stl` or `?format=scad`. `/tool_call` is a convenience JSON API, separate from the actual MCP protocol at `/mcp`. Image retrieval over this API uses `/preview/VIEW/MODEL_ID`.
+
+## Behavior and limits
+
+- Creation succeeds only after a real STL and all four PNGs have been generated. Renderer failures, empty output, and OpenSCAD warnings/errors are reported as failures; no placeholder geometry or preview is substituted.
+- Edits create a new revision and update the manifest only after successful rendering. Earlier revisions remain on disk. Models survive server restarts.
+- Default storage is `~/.local/share/openscad-mcp/models`. Override with `--output-dir` or `OPENSCAD_OUTPUT_DIR`. Each render subprocess has a 120-second timeout, configurable with `--timeout`. A model requires five subprocesses, so the total request can take longer.
+- Run one server process per output directory. Renders and edits are serialized. There is no automatic disk cleanup, distributed job queue, or multi-process store coordination.
+- This is a trusted local tool. Custom SCAD executes with the current user's file access, including OpenSCAD `import`, `include`, and `use`; it is not sandboxed. HTTP binds to loopback and rejects non-local Host/Origin headers. There is no authentication or supported public/LAN deployment.
+- Tested locally on macOS arm64 and in Ubuntu 24.04 CI under Xvfb. Windows and other platform/display combinations are unverified. No hardware printer or remote GPU was exercised.
+
+## Development and verification
+
+```sh
+uv sync --locked --group dev
+uv run ruff check src/openscad_mcp tests scripts
+uv run ruff format --check src/openscad_mcp tests scripts
+uv run pytest -q
+```
+
+The full suite requires OpenSCAD and fails if it is unavailable. Tests launch real stdio and HTTP server processes, use the official MCP client, download exports, decode PNGs, inspect mesh topology/dimensions/volume, test persistence and failed edits, and exercise invalid requests. `uv run pytest -m 'not integration'` runs the unit checks only and does not establish end-to-end correctness.
+
+## License
+
+[MIT](LICENSE), copyright 2026 Jack Hacksman.

package/mcp_servers/openscad-mcp-server/docs/audit.md

@@ -0,0 +1,56 @@
+# Refresh audit — 2026-09-06
+
+Reviewed upstream `6948c2d` on macOS 26.5.2 arm64. The starting workspace was empty; the repository was cloned and work isolated on `refresh/local-e2e`.
+
+## Verdict
+
+The original checkout could not substantiate its advertised end-to-end workflow. The supported server has been replaced with a smaller implementation that directly compiles and renders OpenSCAD, exposes actual MCP transports, and verifies its outputs. Image reconstruction and printer features remain archived, not certified.
+
+## Confirmed problems and disposition
+
+| Original problem | Evidence | Change |
+| --- | --- | --- |
+| Startup failure | The official installed `mcp` package raises `ImportError` for `MCPServer`; `main.py` also references a missing SAM module and undefined classes | Use official `FastMCP`; clean entrypoint and package |
+| Missing MCP endpoint | `/tool_call` was a custom HTTP dispatcher; issue #18 asks where to connect | Real stdio and Streamable HTTP at `/mcp`, tested with official clients |
+| Source/file confusion | `CodeGenerator.generate_code` returns a path, which `main.py` writes as SCAD source | One source-generation interface and self-contained SCAD |
+| Fake outputs | CUDA converter writes a single hardcoded triangle; renderers substitute placeholders | Archive those paths; fail when actual rendering fails |
+| Unfounded reconstruction | Identical synthetic camera poses and placeholder mesh conversion; tests mock outputs | Remove reconstruction from the supported tools and claims |
+| Incorrect dimensions and type selection | Original shape matching selects cube before hollow/rounded box; unit handling and edit defaults are unreliable | Explicit primitive parameters, validation, limited parser with unit tests |
+| False export promises | Mesh formats and evaluated CSG described as preserving parametric properties | Only SCAD is described as editable source; test portable SCAD and mesh exports |
+| Broken current AMF support | Native OpenSCAD 2026.09.05 rejects `.amf` with “Invalid suffix amf” | Do not advertise AMF |
+| Installation overload | Unconditional Open3D/CUDA/image dependencies; issue #20 reports M3 installation failure | Three direct runtime dependencies; lockfile and clean-wheel installation |
+| State and error handling | In-memory models, blocking async routes, missing timeouts, permissive CORS | Persistent revision manifests; worker-thread dispatch; timeouts; loopback HTTP; explicit errors |
+
+Related upstream reports: [startup #17](https://github.com/jhacksman/OpenSCAD-MCP-Server/issues/17), [endpoint #18](https://github.com/jhacksman/OpenSCAD-MCP-Server/issues/18), [Apple Silicon install #20](https://github.com/jhacksman/OpenSCAD-MCP-Server/issues/20). No claims are made that the archived CUDA/Jetson workflow is fixed.
+
+## Machine and dependency evidence
+
+- macOS 26.5.2, arm64; Python 3.12.9.
+- OpenSCAD 2026.09.05, installed through the official Homebrew `openscad@snapshot` cask. The old `openscad` cask is disabled; the [official downloads page](https://openscad.org/downloads.html) recommends the snapshot on macOS.
+- MCP SDK 1.29.1, FastAPI 0.141.1, Uvicorn 0.52.4. Exact resolved dependencies are in `uv.lock`.
+- The MEDIA volume does not support the virtual environment's links. The development environment is `/Users/jackhacksman/.cache/openscad-mcp-venv` on the internal disk. A separate wheel-check environment is `/Users/jackhacksman/.cache/openscad-mcp-wheel-check`.
+
+## Verification
+
+`pytest -q`: **59 passed in 54.19 seconds**, no skipped tests. `ruff check`, `ruff format --check`, and `git diff --check` pass. Wheel and source-distribution builds succeed. A clean environment installs the wheel, exposes the CLI, and successfully creates a cylinder through stdio MCP from `/tmp`, then retrieves it after restart.
+
+The suite exercises:
+
+- All 11 supported primitives through the actual OpenSCAD executable; closed meshes, winding consistency, positive volume, and representative analytic dimensions/volumes.
+- Four real PNG views, image decoding and distinct outputs.
+- SCAD, STL, CSG and 3MF exports; exported SCAD compiles from a different directory without template files.
+- Parameter edits, preservation of unrelated dimensions, state reload, and rollback after invalid source.
+- Empty geometry, malformed SCAD, unknown modules and failed assertions.
+- Real stdio subprocess initialization, tool discovery, generation, image content, modification, export, errors and persistence after restart.
+- Real HTTP subprocess initialization and MCP calls, browser HTML, image and file downloads, legacy JSON API validation, escaping, bad model IDs, and Host/Origin rejection.
+- Fault injection for timeouts, warnings, nonzero exit, zero-exit errors and empty output. These tests complement real rendering; they do not replace it.
+
+A separately generated mounting plate was inspected in PNG files and the browser preview page. Its STL is watertight, has 1,052 triangles and measures exactly **60 × 40 × 6 mm**. Measured volume is **13,722.5055 mm³** versus **13,721.4160 mm³** analytically (0.00794% difference from faceted circular holes). All four offered exports exist.
+
+Local artifacts are retained under `output/manual-e2e/`, indexed by `output/manual-e2e-result.json`. These generated files are intentionally gitignored.
+
+## Scope and remaining limits
+
+This is a breaking replacement of the non-working prototype, not a repair of every archived experiment. The original source, scripts, and historical notes are preserved under `legacy/`; tracked bytecode was removed. The installable wheel contains only the supported package.
+
+This macOS machine was exercised locally. The Ubuntu 24.04 CI run also passed all 59 tests in 14.71 seconds under Xvfb, plus lint and formatting ([run 34081686256](https://github.com/jhacksman/OpenSCAD-MCP-Server/actions/runs/34081686256)). Windows, other Linux/display configurations, remote GPUs, external image providers and hardware printers are not certified here. Custom SCAD is trusted code with the current user's filesystem access. One server process owns an output directory; edits are serialized and old revisions are retained. No public server deployment, mesh repair, slicing, or physical printing is claimed.

package/mcp_servers/openscad-mcp-server/docs/docker.md

@@ -0,0 +1,66 @@
+# Docker
+
+The root `Dockerfile` builds a headless **stdio MCP** server. It includes OpenSCAD, Xvfb, software OpenGL, and Liberation fonts. The runtime uses an unprivileged user (UID 10001); no host display, GPU, CUDA, or API keys are needed. Python dependencies come from `uv.lock`. Debian packages and the Python base image receive upstream updates at build time.
+
+## Build and connect
+
+```sh
+docker build -t openscad-mcp:local .
+docker run --rm -i --network none \
+  -v openscad-models:/data \
+  openscad-mcp:local
+```
+
+The process waits for MCP messages on stdin. Use `-i` and **do not use `-t`**, which would mix terminal output with protocol messages. Configure a local MCP client to run:
+
+```json
+{
+  "mcpServers": {
+    "openscad": {
+      "command": "docker",
+      "args": [
+        "run", "--rm", "-i", "--network", "none",
+        "-v", "openscad-models:/data",
+        "openscad-mcp:local"
+      ]
+    }
+  }
+}
+```
+
+The named volume preserves models across container restarts. A fresh named volume receives the image's `/data` ownership. If you use a bind mount or an existing volume, make sure UID 10001 can write to it. Run only one server per volume.
+
+Returned paths such as `/data/MODEL_ID/REVISION/model.stl` are **inside the container**. `get_model_preview` returns the image directly over MCP. `get_model_source` returns the actual SCAD text and its revision, so a client can read and edit a custom model without a host filesystem mount. Pass that revision as `expected_revision` when submitting the edited source to avoid overwriting a newer edit. To copy an export to the host while the container is running, find its name with `docker ps`, then use the exact `model_file` returned by `export_model`:
+
+```sh
+docker cp CONTAINER_NAME:/data/MODEL_ID/REVISION/model.stl ./model.stl
+```
+
+The image does not expose an HTTP port. For browser previews and HTTP clients, use the native `--transport http` setup in the root README. Container port publishing does not make the server's loopback-only HTTP listener accessible.
+
+Custom SCAD can access files within the container and any mounted directories. Mount only the model data and assets you intend it to read. Networking is not required for generation; the example disables it.
+
+## Test the image
+
+Install development dependencies on the host, build the image, and run:
+
+```sh
+uv sync --locked --group dev
+uv run python scripts/test_docker.py --image openscad-mcp:local
+```
+
+This starts disposable containers with networking disabled and an isolated named volume. It uses the actual MCP protocol, verifies non-root execution, creates a hollow box, checks mesh dimensions and volume, decodes all four views, retrieves every supported export, edits the model, rejects invalid SCAD without losing the good revision, and verifies persistence in a fresh container. The script removes its containers and test volume afterward.
+
+On macOS, a Docker-compatible Linux VM is required. The local test used a dedicated Colima profile with Docker context `colima-openscad-mcp`; this does not require changing your default Docker context:
+
+```sh
+colima start --profile openscad-mcp --vm-type vz --cpu 4 --memory 6 --disk 20 --activate=false
+DOCKER_CONTEXT=colima-openscad-mcp docker build -t openscad-mcp:local .
+DOCKER_CONTEXT=colima-openscad-mcp uv run python scripts/test_docker.py --image openscad-mcp:local
+```
+
+## Glama listing
+
+`Dockerfile`, the MIT `LICENSE`, and `glama.json` identifying `jhacksman` as maintainer address the repository prerequisites discussed in issue #14. Glama documents the maintainer file and ownership synchronization in [What is glama.json?](https://glama.ai/blog/2025-07-08-what-is-glamajson).
+
+A successful local image test is not a Glama deployment. After merging, sync/claim the existing listing through its owner account and run Glama's build/tool checks. No external account permissions, hosted deployment, or listing score changes are implied by these repository files.

package/mcp_servers/openscad-mcp-server/docs/issue-followup.md

@@ -0,0 +1,19 @@
+# Issue follow-up — 2026-09-07
+
+PR #21 is merged into `main`. Issues #17 (startup/demo), #18 (MCP endpoint), and #20 (Open3D installation) received replies with the merged fix, current commands, scope, and test evidence, and were closed.
+
+## Additional local verification
+
+- Python **3.13.2**, macOS arm64: **59 tests passed in 22.00 seconds**, with actual OpenSCAD and both MCP transports. This verifies the Python 3.13 family on this Mac; it does not reproduce the reporter's exact M3/Conda/Python 3.13.11 installation.
+- Built the root Dockerfile in a dedicated Colima Linux arm64 VM. The image runs Python 3.13, Debian Bookworm's OpenSCAD 2021.01, Xvfb, and software OpenGL.
+- `scripts/test_docker.py` passed against the built image with **networking disabled**, no GPU, and UID **10001**. It exercised tool discovery, actual geometry and analytic volume, all four PNG views, SCAD/STL/CSG/3MF exports, modification, failed-edit rollback, and persistence after replacing the container.
+- The Docker test cleans up its disposable containers and named volume. The image is retained locally as `openscad-mcp:issue14`; the dedicated Docker context is `colima-openscad-mcp`.
+- `glama.json` validates against Glama's published JSON schema. The owner selected MIT; the root license and package license metadata have been added.
+
+CI now includes native Python 3.12/3.13 tests and real Docker builds/tests on amd64 and arm64 runners. Remote results are tracked on the follow-up pull request.
+
+## Remaining external checks
+
+The Jetson question is answered in [Jetson Orin Nano and CUDA](jetson.md). General CUDA capability and successful ARM64 container testing do not establish physical Jetson or archived reconstruction support.
+
+The repository changes address the missing Dockerfile and license in #14. The [Glama owner listing](https://glama.ai/mcp/servers/jhacksman/OpenSCAD-MCP-Server) still needs to sync the merged revision and pass Glama's own build/tool checks. No Glama deployment or score improvement is claimed by the local test results.

package/mcp_servers/openscad-mcp-server/docs/jetson.md

@@ -0,0 +1,17 @@
+# Jetson Orin Nano and CUDA
+
+The Jetson Orin Nano supports CUDA workloads beyond robotics. NVIDIA's [CUDA setup guide](https://docs.nvidia.com/jetson/orin-nano-devkit/user-guide/setup_cuda.html) documents CUDA on the host and in Jetson-compatible containers. CUDA capability alone does not establish that an arbitrary project builds or runs correctly on the board.
+
+## Current OpenSCAD server
+
+The supported server does **not use CUDA**. It compiles SCAD and renders previews with OpenSCAD. The Docker image uses software rendering and does not require `--gpus`, an NVIDIA runtime, or JetPack CUDA packages.
+
+The image has been built and tested on Linux arm64 in a VM on an Apple Silicon Mac. That verifies the ARM64 Linux container path, not physical Jetson hardware, JetPack integration, performance, or memory limits. Build it on the target using the [Docker instructions](docker.md) and run the container smoke test to validate that environment. Native installation requires Python 3.11+; if a board's OS has an older Python, use a compatible virtual environment or the container's bundled Python 3.13.
+
+## Archived CUDA reconstruction prototype
+
+The earlier README described remote CUDA reconstruction as supported. That was inaccurate: the integration generated artificial camera poses and wrote dummy OBJ geometry. It is now archived under `legacy/`, outside the installed server. Changing GPU hardware cannot fix that implementation.
+
+The referenced [Fixstars CUMVS project](https://github.com/fixstars/cuda-multi-view-stereo#requirements) implements depth estimation and lists CUDA compute capability >= 6.0, OpenCV >= 4.6 with CUDA and Viz modules, and VTK >= 9.0. Its published benchmark uses an RTX 3080, not an Orin Nano. Those requirements and GPU benchmarks are not evidence of this repository's Jetson support.
+
+Restoring a reconstruction feature would require a working ARM64 dependency build, real camera calibration/poses, actual mesh reconstruction, and tests with real image sets on the target GPU. No Jetson hardware or remote CUDA machine was used in this refresh, and no such support is claimed.

package/mcp_servers/openscad-mcp-server/glama.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://glama.ai/mcp/schemas/server.json",
+  "maintainers": ["jhacksman"]
+}

package/mcp_servers/openscad-mcp-server/legacy/README.md

@@ -0,0 +1,15 @@
+# Archived prototype — unsupported
+
+This directory preserves the previous implementation and its historical notes/tests for reference. It is **not installed, imported, or exposed** by the supported server. The old imports and entrypoints are not maintained. Do not use the original README here as setup instructions.
+
+The September 2026 review found:
+
+- `src/main.py` imports nonexistent MCP SDK classes, a removed SAM module, and several undefined components. Its `/tool_call` route is not an MCP transport.
+- `CodeGenerator.generate_code` returns a filename, while the entrypoint treats it as source text. It also points at the wrong template directory.
+- CUDA reconstruction synthesizes uncalibrated camera matrices and its OBJ conversion writes a dummy triangle. The provided mock tests do not establish working reconstruction.
+- Printer discovery returns simulated printer entries.
+- Renderer fallbacks produce placeholder images after errors.
+- The original installation pulls heavy unrelated packages (including Open3D) into the base server, obstructing Apple Silicon installation.
+- Parametric export claims incorrectly include mesh formats and evaluated CSG. Several helpers silently ignore unsupported operations or fall back to a cube.
+
+The root README documents the replacement implementation. Historical tracked Python bytecode was removed rather than preserved. Reviving an experiment requires a separate implementation and genuine integration tests; passing the archived mocks would not establish support.