Runs the web app as one Docker container on a home NAS, reachable from any browser on your LAN (and optionally over Tailscale). Written for a small x86_64 NAS running Docker; the steps are the same on any consumer NAS or Linux box, and only the notes at the end are vendor-specific.

Placeholders used throughout:

• x86_64 CPU — the tested platform. Current pymeshlab and cadquery-ocp releases do publish Linux aarch64 wheels, so an ARM NAS is no longer ruled out by packaging alone — but nothing in this stack has been verified on ARM Linux, and the Poisson step has already proven platform-sensitive (it crashes on macOS arm64). Treat ARM as untested, not supported.
• RAM — 8 GB minimum, 16 GB comfortable. A 2-million-triangle scan peaks at several GB during Poisson repair.

On a vendor NAS (menu names vary by firmware; these are typical):

1. App Center → install Docker (packaged as "DockerEngine" on some firmwares). Confirm over SSH: docker compose version.
2. App Center → install Git (optional — the deploy script falls back to a throw-away alpine/git container if there is no git binary).
3. Control Panel → Shared Folders → create a plain share for apps (no encryption needed; the app stores only uploaded meshes and generated STEP files, purged after 24 h). Its path is your <share-path>.
4. Enable SSH (Control Panel → Terminal & SNMP) and log in as an admin user.

On any other NAS: install Docker (with Compose v2), create a folder, enable SSH.

cd <share-path>
git clone https://github.com/Crypto69/stlToSolid.git
cd stlToSolid
chmod -R a+rX .       # some NAS shares strip file modes on checkout; harmless elsewhere
mkdir -p data         # job storage, bind-mounted to /data inside the container

docker compose build

Builds natively on the NAS (a few minutes on a NAS CPU; it downloads the ~2 GB CAD stack the first time). Do not copy an image built on an Apple-silicon Mac unless you built it with --platform linux/amd64.

If the build fails with a download timeout in pip or apt-get, just run it again — it is a mirror hiccup, not a code problem (pip is set to 300 s / 10 retries; pymeshlab alone is a 106 MB wheel).

docker compose up -d
docker compose ps                          # state: running
curl -s http://127.0.0.1:<port>/ | head    # serves the UI's index.html

Open http://<your-nas>:<port> in a browser, drop an STL, press Convert. The report card with green PASS gates is the acceptance test. The badge top-right shows version · commit · build time (also at /api/version).

cd <share-path>/stlToSolid
./deploy.sh            # pulls main, fixes share file modes, builds, restarts
./deploy.sh --no-pull  # rebuild what is checked out, without pulling

A restart kills in-flight conversions; re-run them from the browser.

If the project's git history was ever rewritten upstream (force-push), a plain pull refuses. Reset once, then deploy as usual:

git fetch origin && git reset --hard origin/main && ./deploy.sh

All settings live in docker-compose.yml; edit, then docker compose up -d.

data/ is disposable: rm -rf data/* with the container stopped is always safe. There is no database and nothing to back up.

If the NAS is on your tailnet, Tailscale can front the app with HTTPS without opening anything to the internet:

tailscale serve --bg --https=8443 http://127.0.0.1:<port>
tailscale serve status

The app is then at https://<your-nas>.<your-tailnet>.ts.net:8443 — run tailscale status to see your own tailnet name. Use a port nothing else is serving (tailscale serve status lists the entries). The app has no login: anyone on your LAN or tailnet can use it, which is the intended scope.

tests/ and samples/ are not baked into the image. Mount them from the checkout (copy your sample meshes into samples/ first):

docker compose run --rm \
  -v "$PWD/tests:/app/tests:ro" -v "$PWD/samples:/app/samples:ro" \
  stltosolid sh -c 'pip install -q pytest httpx && python -m pytest -q -m "not slow"'
# use `-m slow` instead for the scan end-to-ends (takes minutes)

This is also where the scan path gets proven: Poisson repair does not work on macOS arm64, so a large scan converting to a valid solid here is the platform acceptance test.

restart: unless-stopped brings the container back by itself. Check docker compose ps; if you use the Tailscale front, run tailscale serve status and repeat the serve command if its entry is gone.

These apply to several vendor firmwares; check the equivalents on yours.

• Docker CLI may be off the default PATH — it often lives under the Docker app's own bin directory. Find it with find / -name docker -type f 2>/dev/null | head and add that directory to PATH in your shell rc. If the daemon is down, start the Docker app in the admin UI and the containers come back.
• git may be an alias, not a binary that scripts can call, and may also live under an app directory. deploy.sh copes: it reads .git/HEAD itself and pulls through an alpine/git container when needed.
• Share ACLs strip file modes on clone/pull: run chmod -R a+rX . in the repo directory afterwards (deploy.sh does this for you).
• SSH auto-block: a burst of SSH connections can blacklist your client IP (ping works, SSH times out). Unblock under the vendor security panel, or connect from your other address (LAN vs tailnet).