fix: healthcheck no longer requires curl

.env.template

@@ -0,0 +1,5 @@
+PRINTER_URLS=["127.0.0.1"]
+FILAMENT_DIAMETER=1.75
+SPOOLMAN_URL=http://127.0.0.1:7912
+SPOOLMAN_MODE=direct
+

.gitignore

@@ -0,0 +1,2 @@
+data/
+.env

CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-Filament-Management is a local web application for tracking 3D printer filament/spool usage, built for Creality K2 Plus CFS (4x4 slot grid) and Klipper/Moonraker-based printers. It runs as a FastAPI backend with a vanilla JavaScript SPA frontend. The UI supports German and English via `static/i18n.js` (auto-detects browser language, persists choice in localStorage).
+CFSync is a local web application for tracking 3D printer filament/spool usage, built for Creality K2 Plus CFS (4x4 slot grid) and Klipper/Moonraker-based printers. It runs as a FastAPI backend with a vanilla JavaScript SPA frontend.
 
 ## Development Commands
 
@@ -21,30 +21,74 @@ uvicorn main:app --reload --host 0.0.0.0 --port 8000
 curl http://localhost:8000/api/health
 ```
 
+### Mock printer server (no real hardware needed)
+
+`mock_printer.py` simulates one or more K2 Plus printers (WebSocket CFS server on port 9999 + Moonraker HTTP on port 7125). Run multiple instances on different loopback IPs to test multi-printer setup:
+
+```bash
+# Terminal 1
+python3 mock_printer.py --host 127.0.0.2 --name "Printer Alpha"
+# Terminal 2
+python3 mock_printer.py --host 127.0.0.3 --name "Printer Beta"
+```
+
+Then set `"printer_urls": ["127.0.0.2", "127.0.0.3"]` in `data/config.json`.
+
+Control API (same port 7125):
+```bash
+curl http://127.0.0.2:7125/mock/state
+curl -X POST http://127.0.0.2:7125/mock/print/start
+curl -X POST http://127.0.0.2:7125/mock/print/complete
+curl -X POST http://127.0.0.2:7125/mock/slot/1A \
+     -H 'Content-Type: application/json' \
+     -d '{"state": 2, "type": "PLA", "color": "#FF0000", "name": "Red PLA", "vendor": "Bambu"}'
+```
+
+SSH auto-linking can also be tested without a real SSH server using `mock_sshpass.sh`. Copy it to `sshpass` and put it on PATH before starting CFSync:
+
+```bash
+cp mock_sshpass.sh sshpass && chmod +x sshpass
+PATH="$PWD:$PATH" uvicorn main:app --reload --host 0.0.0.0 --port 8000
+# Set rfid to a plain integer matching a Spoolman spool ID to trigger auto-link:
+curl -X POST http://127.0.0.2:7125/mock/slot/1A \
+     -H 'Content-Type: application/json' \
+     -d '{"state": 2, "rfid": "42"}'
+```
+
 There are no automated tests, linting tools, or CI/CD pipelines configured.
 
 ## Architecture
 
 **Backend:** Single-file FastAPI app (`main.py`, ~1500 lines) with Pydantic models in `models/schemas.py`. Data is persisted as JSON files in `data/` (state.json, config.json, profiles.json) — no database.
 
-**Frontend:** Vanilla JS SPA in `static/` (index.html, app.js, app.css, style.css). No build step, no framework — pure DOM manipulation.
+**Frontend:** Vanilla JS SPA in `static/` (index.html, app.js, app.css, style.css). No build step, no framework — pure DOM manipulation. `fluidd-panel.js` is a standalone script injected into the Fluidd UI via bookmarklet or Tampermonkey userscript (generated from the settings page).
+
+**Moonraker integration:** Optional async background polling loop that queries the printer's Moonraker API for print job status, filament usage, and CFS slot info. Includes Creality K2 Plus-specific object parsing (box.T1-T4, filament_rack). Printer identity (`printer_name`, `printer_firmware`) is parsed from the Moonraker WebSocket.
 
-**Moonraker integration:** Optional async background polling loop that queries the printer's Moonraker API for print job status, filament usage, and CFS slot info. Includes Creality K2 Plus-specific object parsing (box.T1-T4, filament_rack).
+**Multi-printer support:** Multiple printers are stored as separate entries under `state["printers"][printer_id]`. Each printer runs its own independent WebSocket loop and Moonraker poll loop. Config accepts `printer_urls` (array of IPs/hostnames) or the legacy `printer_url` (single), both are migrated into the same internal `printers` list at startup.
 
 ## Key Patterns
 
 - **Pydantic v1/v2 compatibility:** Helper functions `_model_dump()`, `_model_validate()`, `_req_dump()` abstract over version differences. Always use these instead of calling `.dict()` or `.model_dump()` directly.
 - **State migration:** `_migrate_state_dict()` handles legacy field names (e.g., `color` → `color_hex`, `vendor` → `manufacturer`) and older state.json formats.
 - **Two API tiers:** `/api/*` returns raw JSON; `/api/ui/*` wraps responses in `{"result": {...}}` for the frontend.
-- **Slot IDs:** Literal type `SlotId` = `"1A"` through `"4D"` (4 boxes × 4 colors, 16 total).
+- **Slot IDs:** Literal type `SlotId` = `"1A"` through `"4D"` (4 boxes × 4 colors, 16 total) plus `"SP"` for the printer's direct spool holder (box type=1 in the WebSocket protocol).
 - **Spool epochs:** Incrementing `spool_epoch` counter tracks spool changes per slot, enabling per-spool history filtering.
 - **History conventions:** `_hist_push()` prepends (newest-first); `_hist_upsert_by_src()` updates existing entries by source marker during live prints.
 - **Internal functions** are prefixed with `_` (e.g., `_http_get_json`, `_hist_push`).
 - **Filament calculation:** grams = density × π × (diameter/2)² × length, with material-specific density from profiles.json.
 
 ## Spoolman Integration (Optional)
 
-Set `spoolman_url` in `data/config.json` to enable. This app acts as the only bridge between Spoolman and the printer (Moonraker's Spoolman plugin is not used). Spools are linked manually via the slot modal dropdown. On link, `remaining_weight` is imported from Spoolman. Consumption is synced back via `PUT /api/v1/spool/{id}/use` (fire-and-forget) when prints finalize or manual allocations are made. Roll changes auto-unlink the Spoolman spool. All Spoolman calls are best-effort and never block local tracking.
+Set `spoolman_url` in `data/config.json` to enable. This app acts as the only bridge between Spoolman and the printer (Moonraker's Spoolman plugin is not used). Spools are linked manually via the slot modal dropdown, or auto-linked via SSH serialNum lookup (see below). On link, `remaining_weight` is imported from Spoolman. Consumption is synced back via `PUT /api/v1/spool/{id}/use` (fire-and-forget) when prints finalize or manual allocations are made. Roll changes auto-unlink the Spoolman spool. All Spoolman calls are best-effort (`_spoolman_*` helpers) and never block local tracking.
+
+**Auto-linking (SSH serialNum):** When a slot transitions to RFID state (CFS state=2), `_ssh_fetch_and_apply()` is triggered (at most every 30s per printer). It SSHes into the printer using `sshpass` + system `ssh`, tries multiple passwords (`creality_2023`, `creality_2024`, `creality`) and two file paths (stock firmware: `/usr/data/creality/userdata/box/material_box_info.json`; K2-Improvements: `/mnt/UDISK/creality/userdata/box/material_box_info.json`). Reads each slot's `serialNum` field; if it's a valid integer matching a Spoolman spool ID, that slot is auto-linked. Requires `sshpass` installed and SSH access to the printer.
+
+**Auto-unlinking:** Spoolman is auto-unlinked when: (a) a slot transitions from RFID to any other state, (b) any loaded slot goes to empty, or (c) a loaded slot's material/name/vendor/color fingerprint changes (catches manual spool swaps).
+
+**Spoolman API endpoints:** `GET /api/ui/spoolman/spools`, `POST /api/ui/spoolman/link`, `POST /api/ui/spoolman/unlink`, `GET /api/ui/spoolman/spool_detail`.
+
+**Percentage calculation:** Remaining % is calculated the same way for all linked slots — using Spoolman's `remaining_weight` divided by the spool's initial weight (`filament.weight`). Cached per-slot with a 60s TTL (`_SPOOLMAN_PCT_TTL`).
 
 ## Production Deployment
 

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.12-slim AS builder
+
+# Set working directory
+WORKDIR /app
+
+COPY . .
+
+# Install dependencies to a specific folder
+RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
+
+FROM python:3.12-slim
+
+# Install packages
+RUN apt-get update && apt-get install -y sshpass && rm -rf /var/lib/apt/lists/*
+
+# Set environment variables
+ENV APP_DIR=/opt/filament-management \
+    PYTHONPATH=/opt/filament-management \
+    UI_PORT=8005
+
+WORKDIR $APP_DIR
+
+# Copy Python libs and app code
+COPY --from=builder /install /usr/local
+COPY --from=builder /app $APP_DIR
+
+# Setup Entrypoint
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+# Expose the UI port
+EXPOSE $UI_PORT
+
+ENTRYPOINT ["/entrypoint.sh"]
+
+# Start the application
+CMD uvicorn main:app --host 0.0.0.0 --port $UI_PORT
+

Makefile

@@ -0,0 +1,12 @@
+up:
+	docker-compose up -d
+down:
+	docker-compose down
+restart:
+	docker-compose down && docker-compose up -d
+logs:
+	docker-compose logs -f
+pull:
+	docker-compose pull
+build:
+	docker-compose build

README.md

@@ -1,14 +1,209 @@
-# Filament-Management
+# CFSync
 
-Local filament / spool tracking for Creality CFS & Klipper via Moonraker.
+A local web dashboard for managing filament spools on **Creality K1 series printers with CFS** (Colour Filament System), including the K1, K1C, K1 Max, K1 SE, and K2 Plus. CFSync connects directly to the printer over WebSocket, reads live spool data from all CFS slots, and optionally syncs consumption back to [Spoolman](https://github.com/Donkie/Spoolman).
 
-Track filament usage per slot, handle color changes during prints and keep everything fully local.
+![CFSync screenshot](docs/screenshot.png)
 
-No cloud. No external services.
+## Features
 
----
+- Live CFS slot view — filament colour, material, and fill level per slot
+- RFID spool percent from printer sensor; calculated percent for non-RFID spools via Spoolman
+- Spoolman integration — link spools, track remaining weight, auto-report usage at job end
+- **Two Spoolman sync modes** — direct reporting or Moonraker plugin (`SET_ACTIVE_SPOOL`)
+- Serial-number-based auto-linking via SSH (CFTag-written spools link instantly on insert)
+- Moonraker job tracking — attributes `filament_used` proportionally across active slots at print completion
+- **Multi-printer support** — manage multiple printers from a single CFSync instance
+- **Job history** — per-printer log of recent print jobs with filament usage breakdown
+- **Spool reallocation** — manually assign usage to a specific slot after a print
+- **SP slot** — tracks filament loaded directly into the printer (outside the CFS)
+- Printer name and firmware version shown in header (read from WebSocket)
+- Dark UI, no build step, runs as a systemd service
 
-## 🚀 Installation (One-Liner)
+## Requirements
+
+- Linux host on the same network as the printer (e.g. a Pi or the printer's companion board)
+- Creality K1 series printer with CFS (K1, K1C, K1 Max, K1 SE, K2 Plus)
+- Python 3.10+
+- Optional: [Spoolman](https://github.com/Donkie/Spoolman) for spool tracking
+
+## Install
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/jkef80/Filament-Management/main/install.sh | sudo bash
+curl -fsSL https://raw.githubusercontent.com/koen01/CFSync/refs/heads/spoolman/install.sh | sudo bash
+```
+
+The installer will prompt for:
+
+| Prompt | Example |
+|---|---|
+| UI port | `8005` |
+| Printer IP | `192.168.1.144` |
+| Spoolman URL *(optional)* | `http://192.168.1.10:7912` |
+
+After install, open `http://<host-ip>:<port>` in your browser.
+
+## Configuration
+
+All settings are available through the **cogwheel (⚙) modal** in the UI. They are stored in `data/config.json`:
+
+```json
+{
+  "printer_urls": ["192.168.1.144"],
+  "filament_diameter_mm": 1.75,
+  "spoolman_url": "http://192.168.1.10:7912",
+  "spoolman_mode": "direct"
+}
+```
+
+The legacy `"printer_url"` (single string) is still accepted and migrated automatically.
+
+### Multiple printers
+
+Add all printer IPs to the `printer_urls` array:
+
+```json
+{
+  "printer_urls": ["192.168.1.144", "192.168.1.145"]
+}
+```
+
+Each printer gets its own state, job history, and Spoolman spool links. The UI shows a printer selector when more than one printer is configured.
+
+## Spoolman integration
+
+### Sync modes
+
+CFSync supports two ways to report filament consumption to Spoolman. Set the mode in the settings modal (⚙).
+
+**Direct mode** *(default)*
+
+CFSync calls `PUT /api/v1/spool/{id}/use` directly on Spoolman when a print finishes or a manual allocation is made. No Moonraker configuration needed.
+
+**Moonraker plugin mode**
+
+CFSync calls the `SET_ACTIVE_SPOOL` / `CLEAR_ACTIVE_SPOOL` G-code macros via Moonraker. Moonraker's built-in Spoolman plugin then tracks consumption itself. This requires the `[spoolman]` section in `moonraker.conf` — see setup below.
+
+### Moonraker plugin setup
+
+1. **Configure Moonraker** — add to `moonraker.conf`:
+
+```ini
+[spoolman]
+server: http://192.168.1.10:7912
+```
+
+2. **Restart Moonraker** after saving.
+
+3. **In CFSync settings (⚙)**, set Spoolman URL to the same address and switch the sync mode to **Moonraker plugin**.
+
+> Moonraker must be reachable from the CFSync host. CFSync uses the printer IP (port 7125) for Moonraker API calls. If your setup uses a different Moonraker URL you can configure it separately in `data/config.json` under `moonraker_url`.
+
+> **Trusted clients:** CFSync's host IP must be in Moonraker's `trusted_clients` list. The default Moonraker config already includes `192.168.0.0/16` and `10.0.0.0/8`, so most LAN setups work without changes.
+
+### Auto-linking via serial number (SSH)
+
+When an RFID-tagged spool is inserted (CFS slot transitions to RFID state), CFSync SSHes into the printer and reads `material_box_info.json` to extract each slot's `serialNum` field. If the serial number is a valid integer that matches a Spoolman spool ID, the slot is linked immediately — no manual action required.
+
+**Why SSH and not the RFID material code?**  
+Creality uses shared RFID material-type codes — every spool of the same filament type carries the same code (e.g. all Creality Hyper PLA White rolls share one code). This makes RFID codes unsuitable for identifying individual spools in Spoolman. The `serialNum` read via SSH is written to the physical RFID chip and can be made unique per spool using **[CFTag](https://github.com/koen01/cftag)**.
+
+**SSH requirements:**
+- `sshpass` must be installed on the CFSync host (`apt install sshpass`)
+- The printer must be reachable over SSH (default on Creality firmware, no extra config needed)
+- CFSync tries the standard Creality passwords automatically
+
+> Spools without a CFTag-written serial number (e.g. plain Creality stock spools) will not auto-link and must be linked manually via the slot modal.
+
+**Auto-unlink** happens automatically when:
+- A spool is removed from a slot
+- The RFID value changes on a loaded slot (different spool inserted)
+- The filament material, name, or colour changes while the slot is loaded
+
+## Workflow — adding a new spool with RFID
+
+1. **Open CFTag** on Android → fill in filament details → tap **Create in Spoolman**. CFTag creates the spool entry in Spoolman and immediately prompts you to write the RFID tags. Hold your phone to the tag on each side of the spool — done in one flow.
+2. **Load the spool** into a CFS slot.
+3. **CFSync detects the insert**, SSHes into the printer, reads the serial number from the chip, and links the slot to the Spoolman spool automatically.
+
+From this point on, inserting that spool into any CFS slot will auto-link it instantly. Filament consumption is reported back to Spoolman after each print.
+
+## Fluidd panel
+
+CFSync can inject a spool status panel into the **Fluidd** web UI. The panel script and setup instructions are available in the settings modal (⚙) under **Fluidd panel**.
+
+Two delivery methods are supported:
+
+- **Bookmarklet** — paste a one-liner into your browser's bookmarks bar and click it to activate
+- **Tampermonkey** — install the userscript for automatic injection on every page load
+
+## Development & testing
+
+CFSync includes a mock printer server for local development without real hardware.
+
+### Mock server
+
+`mock_printer.py` simulates a K2 Plus — it runs a WebSocket CFS server (port 9999) and a Moonraker HTTP API (port 7125). Run multiple instances on different loopback IPs to test the multi-printer setup:
+
+```bash
+# In separate terminals:
+python3 mock_printer.py --host 127.0.0.2 --name "Printer Alpha"
+python3 mock_printer.py --host 127.0.0.3 --name "Printer Beta"
+```
+
+Then set `"printer_urls": ["127.0.0.2", "127.0.0.3"]` in `data/config.json` and start CFSync normally. All `127.x.x.x` addresses work as loopback aliases on Linux without extra configuration.
+
+Each mock exposes a control API for triggering state changes:
+
+```bash
+# Simulate a print job lifecycle
+curl -X POST http://127.0.0.2:7125/mock/print/start
+curl -X POST http://127.0.0.2:7125/mock/print/complete
+
+# Change a CFS slot (state 2 = RFID)
+curl -X POST http://127.0.0.2:7125/mock/slot/1A \
+     -H 'Content-Type: application/json' \
+     -d '{"state": 2, "type": "PLA", "color": "#FF5733", "name": "Orange PLA", "vendor": "Bambu"}'
+
+# Empty a slot
+curl -X POST http://127.0.0.2:7125/mock/slot/2C/empty
+
+# Switch active slot
+curl -X POST http://127.0.0.2:7125/mock/slot/1B/select
+
+# View full mock state
+curl http://127.0.0.2:7125/mock/state
+```
+
+### Mocking SSH auto-linking
+
+SSH auto-linking can be tested without a real SSH server using `mock_sshpass.sh`. It intercepts the `sshpass` call and fetches `material_box_info.json` from the mock's HTTP endpoint instead:
+
+```bash
+cp mock_sshpass.sh sshpass && chmod +x sshpass
+PATH="$PWD:$PATH" uvicorn main:app --reload --host 0.0.0.0 --port 8000
+```
+
+To trigger auto-linking, set a slot's RFID to a plain integer matching a Spoolman spool ID:
+
+```bash
+curl -X POST http://127.0.0.2:7125/mock/slot/1A \
+     -H 'Content-Type: application/json' \
+     -d '{"state": 2, "rfid": "42"}'   # auto-links to Spoolman spool #42
+```
+
+## Update
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/koen01/CFSync/refs/heads/spoolman/update.sh | sudo bash
+```
+
+## Logs
+
+```bash
+sudo journalctl -u filament-management -f
+```
+
+## Credits
+
+- [jkef80/Filament-Management](https://github.com/jkef80/Filament-Management) — original Moonraker-based filament management that this project evolved from
+- [DaviBe92/k2-websocket-re](https://github.com/DaviBe92/k2-websocket-re) — reverse-engineered Creality K2 WebSocket protocol documentation that made the CFS integration possible

docker-compose.yml

@@ -0,0 +1,23 @@
+services:
+  cfsync:
+    build: .
+    container_name: cfsync
+    restart: unless-stopped
+    ports:
+      - "8005:8005"
+    # Create .env file here and override the settings below (See .env.template for example)
+    environment:
+      - UI_PORT=8005
+      - TZ=${TZ:-Asia/Jerusalem}
+      - PRINTER_URLS=${PRINTER_URLS:-["127.0.0.1"]}
+      - FILAMENT_DIAMETER=${FILAMENT_DIAMETER:-1.75}
+      - SPOOLMAN_URL=${SPOOLMAN_URL:-http://127.0.0.1:7912}
+      - SPOOLMAN_MODE=${SPOOLMAN_MODE:-direct} # direct or moonraker
+    volumes:
+      # This ensures your filament data survives container updates
+      - ./data:/opt/filament-management/data
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8005/api/health')"]
+      interval: 30s
+      timeout: 10s
+      retries: 3