@vextrix3d/machine-agent 2.0.0 → 2.1.0

package/LICENSE

@@ -1,4 +1,4 @@
-Vextrix3D Printer Agent Licence
+Vextrix3D Machine Agent Licence
 
 Copyright (c) 2026 VEXTRIX3D LTD. All rights reserved.
 
@@ -7,7 +7,7 @@ VEXTRIX3D LTD is a company registered in England and Wales under company number
 
 1. The Software
 
-   This licence covers the Vextrix3D Printer Agent ("the Software"): the code, files and
+   This licence covers the Vextrix3D Machine Agent ("the Software"): the code, files and
    documentation in this package or repository, apart from the third-party components in
    section 6. The Software is licensed, not sold.
 
@@ -15,7 +15,7 @@ VEXTRIX3D LTD is a company registered in England and Wales under company number
 
    Vextrix3D grants you a non-exclusive, non-transferable and revocable licence to install and
    run the Software on machines you control, for the sole purpose of connecting printers and
-   other machines to the Vextrix3D service at vextrix3d.co.uk with a printer agent API key that
+   other machines to the Vextrix3D service at vextrix3d.co.uk with a machine agent API key that
    Vextrix3D has issued for them, for as long as that key and your Vextrix3D account remain
    active. You may make the copies that installing and running it needs.
 

package/README.md

@@ -17,7 +17,7 @@ The backend remains the source of truth for printer configuration, production st
 - Automatic cancellation and failure reporting
 - Batched state reporting to minimize API traffic
 - Automatic reconnection
-- A Bambu printer's camera relayed to its page, where ffmpeg is installed
+- The printer's camera relayed to its page, where ffmpeg is installed - a Bambu printer's, or a Klipper printer's webcam
 - Low bandwidth and minimal backend writes
 
 ---
@@ -83,6 +83,7 @@ Responsibilities:
 - pass the status on again every 30 seconds while nothing changes, and ask again whether Klipper can give one while it cannot
 - reconnect after 2, 5, 15 and 30 seconds, then once a minute
 - read the slicer's estimate from a file's metadata
+- list the webcams as it connects, and again with each `notify_webcams_changed` - see [A Klipper printer's webcam](#a-klipper-printers-webcam)
 
 ---
 
@@ -143,12 +144,12 @@ Authentication is performed using Machine Agent API keys.
 
 ### Camera Relay
 
-Runs go2rtc beside the printer, and the printer's Cloudflare Tunnel, so that its page in vextrix3d can show the camera live - see [Camera relay](#camera-relay). Where ffmpeg is installed, for a Bambu printer alone: the relay reads the RTSP stream a Bambu printer serves, or the JPEG frames an A1's or P1's camera sends - see [An A1 or a P1](#an-a1-or-a-p1) - and vextrix3d relays no other printer's camera.
+Runs go2rtc beside the printer, and the printer's Cloudflare Tunnel, so that its page in vextrix3d can show the camera live - see [Camera relay](#camera-relay). Where ffmpeg is installed: the relay reads the RTSP stream a Bambu printer serves, or the JPEG frames an A1's or P1's camera sends - see [An A1 or a P1](#an-a1-or-a-p1) - or a Klipper printer's first webcam in Moonraker - see [A Klipper printer's webcam](#a-klipper-printers-webcam).
 
 - fetches the builds of go2rtc and cloudflared it pins into `camera/`, from their GitHub releases, each checked against its SHA-256 before it is made executable, and keeps them there from one start to the next
-- writes go2rtc's config itself, into `camera/runtime/`, readable by the agent's user alone, from what the agent already has: the printer's id, access code and serial number from vextrix3d, and the camera's address from the printer's own status (`ipcam.rtsp_url`) - or, for an A1 or a P1, the printer's own address, its camera's frames read on port 6000 and encoded to H.264
-- starts go2rtc with the first status that names a camera stream, starts it again if it stops, and stops it with the agent
-- follows a new camera address in the status without restarting go2rtc
+- writes go2rtc's config itself, into `camera/runtime/`, readable by the agent's user alone, from what the agent already has: the printer's id, access code and serial number from vextrix3d, and the camera's address from the printer's own status (`ipcam.rtsp_url`) - or, for an A1 or a P1, the printer's own address, its camera's frames read on port 6000 and encoded to H.264 - or, for a Klipper printer, its webcam as Moonraker lists it
+- starts go2rtc with the first report of a camera stream - a Bambu printer's status, or Moonraker's list of webcams - starts it again if it stops, and stops it with the agent
+- follows a new camera address without restarting go2rtc, and starts it again at once for a webcam to be read another way
 - runs go2rtc on a pair of ports it finds free, and notes them where the machine's other agents find them
 - takes the machine's camera requests on port 1984, together with every other agent there, and hands each to the go2rtc of the printer it names, once its relay token checks out against that printer's key
 - asks vextrix3d for the printer's camera (`getMachineAgentCamera`) once the printer names a camera stream in its status and go2rtc and cloudflared are there - the relay key, and the token of the printer's own tunnel, which vextrix3d makes the first time - and runs `camera/cloudflared` with it, starting it again if it stops
@@ -169,7 +170,7 @@ The backend receives the following information:
 - bed temperature
 - chamber temperature
 - Wi-Fi signal strength, of a Bambu printer
-- whether a Bambu printer names a camera stream - a change in it sent at once, as a new state is
+- whether the printer has a camera stream - a Bambu printer one it names, a Klipper printer a webcam the agent reads - a change in it sent at once, as a new state is
 - the agent's own version, which the machine's page shows, from 1.1.0
 - last seen timestamp
 
@@ -215,6 +216,7 @@ The agent follows Moonraker's own [API documentation](https://moonraker.readthed
 - **Klipper restarting** — a `FIRMWARE_RESTART` or a saved config drops the subscription while Moonraker stays up. The agent subscribes again on `notify_klippy_ready`, and asks with each heartbeat while Klipper is starting up.
 - **Time left** — Klipper reckons none. It is the slicer's estimate, `estimated_time` in the file's metadata, less `print_stats.print_duration`, as Fluidd and Mainsail give it; from a file with no estimate, the time printed drawn out over the progress. `print_duration` counts from the first extrusion, so a print still heating up has no time left yet.
 - **Job name** — `print_stats.filename`, without its folder or `.gcode`.
+- **Webcams** — `server.webcams.list` as the agent connects, whatever Klipper's state, and `notify_webcams_changed` as they are changed in Mainsail or Fluidd; a Moonraker from before 2023, which has no list, has none, and the log says it is too old to list them. The first the agent reads is relayed - see [A Klipper printer's webcam](#a-klipper-printers-webcam).
 
 Tried against Mainsail's [virtual Klipper printer](https://github.com/mainsail-crew/virtual-klipper-printer) in Docker: the API key, idle, running, cancelled, finished, Klipper shut down, and subscribing again after a host restart.
 
@@ -353,51 +355,11 @@ pm2 restart /machine-agent-/
 pm2 delete machine-agent-p2s-01 && pm2 save
 ```
 
-### Moving from the printer agent
-
-Until 2.0.0 the agent was the printer agent, `@vextrix3d/printer-agent`, run as `printer-agent-<name>` from `/opt/printer-agents/<name>`. Vextrix3D answers none of its endpoints, nor its keys (`vx3d-pa.…`), so an agent before 2.0.0 stops reporting until it is moved - its machine's page in Vextrix3D says Move to the machine agent. Moving takes a new API key, made under the machine's **Agent API keys**, and on its computer:
-
-1. **The machine agent**, beside the printer agent for now:
-
-```bash
-npm install -g @vextrix3d/machine-agent
-```
-
-2. **For each printer**, the printer agent stopped, its folder moved beside the machine agent's, its `.env.prod` written again with the new key, and the machine agent started there:
-
-```bash
-pm2 delete printer-agent-p2s-01
-```
-
-```bash
-sudo mkdir -p /opt/machine-agents && sudo chown "$USER": /opt/machine-agents && mv /opt/printer-agents/p2s-01 /opt/machine-agents/
-```
-
-```bash
-cd /opt/machine-agents/p2s-01
-```
-
-```bash
-read -rs KEY && printf 'VEXTRIX3D_FUNCTIONS_URL=https://api.vextrix3d.co.uk\nVEXTRIX3D_MACHINE_AGENT_API_KEY=%s\n' "$KEY" > .env.prod; unset KEY
-```
-
-```bash
-NODE_ENV=production pm2 start machine-agent --name machine-agent-p2s-01 && pm2 save
-```
-
-3. **The printer agent itself**, once no `printer-agent-` is left in `pm2 list`:
-
-```bash
-npm uninstall -g @vextrix3d/printer-agent
-```
-
-The printer's `camera/` moves with its folder, and its go2rtc and cloudflared are kept; its tunnel is the one it had.
-
 ---
 
 ## Camera relay
 
-A Bambu printer's page in Vextrix3D can show its camera live. The agent runs [go2rtc](https://github.com/AlexxIT/go2rtc) beside the printer, which reads its RTSPS stream through ffmpeg, and takes the machine's camera requests on `127.0.0.1:1984`. The agent opens the printer's RTSPS itself and checks its certificate as it checks its MQTT's - issued by Bambu, to the printer's serial number - and hands ffmpeg the stream as plain RTSP on a port of this machine alone, so that the check is the same whatever ffmpeg, and whatever OpenSSL, the machine has: OpenSSL 4 matches no name against the common name a Bambu printer's certificate names its serial in, and ffmpeg before 8 checks nothing on RTSPS. A printer whose certificate fails the check is not relayed, and the log says why once, `[camera] The camera of "P2S-01" at 192.168.0.119:322 was not opened: …`. The way from there to the printer's page is the printer's own [Cloudflare Tunnel](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/), which vextrix3d makes for it the first time the agent asks, and which the agent runs with `cloudflared` - there is nothing to set up in Cloudflare.
+A printer's page in Vextrix3D can show its camera live - a Bambu printer's, as below, or a Klipper printer's webcam, as under [A Klipper printer's webcam](#a-klipper-printers-webcam). The agent runs [go2rtc](https://github.com/AlexxIT/go2rtc) beside the printer, which reads its RTSPS stream through ffmpeg, and takes the machine's camera requests on `127.0.0.1:1984`. The agent opens the printer's RTSPS itself and checks its certificate as it checks its MQTT's - issued by Bambu, to the printer's serial number - and hands ffmpeg the stream as plain RTSP on a port of this machine alone, so that the check is the same whatever ffmpeg, and whatever OpenSSL, the machine has: OpenSSL 4 matches no name against the common name a Bambu printer's certificate names its serial in, and ffmpeg before 8 checks nothing on RTSPS. A printer whose certificate fails the check is not relayed, and the log says why once, `[camera] The camera of "P2S-01" at 192.168.0.119:322 was not opened: …`. The way from there to the printer's page is the printer's own [Cloudflare Tunnel](https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/), which vextrix3d makes for it the first time the agent asks, and which the agent runs with `cloudflared` - there is nothing to set up in Cloudflare.
 
 The machine's camera port, 1984, is every agent's on the machine at once - Linux lets the processes of one user hold a port together, and deals the connections out among them. A page's request names its printer, `/api/ws?src=<printer id>`, and whichever agent takes it hands it to that printer's go2rtc, whose port the printer's own agent notes in `~/.local/state/machine-agent/cameras/`. Every printer's tunnel points at that port, so the printers on a machine each run their own tunnel into it.
 
@@ -421,6 +383,34 @@ What it costs, measured against a stand-in printer sending a 1280×720 frame a s
 
 None of this has been tried on one of these printers yet - the models, the login and the frames are as the community documents them, and the agent is tested against a stand-in printer that checks the login and sends frames.
 
+### A Klipper printer's webcam
+
+A Klipper printer's camera is the first of its webcams that the agent reads, as Moonraker lists them (`server.webcams.list`) - the order Mainsail shows them in - set in Mainsail's or Fluidd's settings, or in `moonraker.conf`. Moonraker is asked as the agent connects and tells it of each change (`notify_webcams_changed`), so a webcam added, changed or removed is followed with no restart; one in `moonraker.conf` is read again as Moonraker restarts. Each state report says whether the printer has one, and the agent asks vextrix3d for its camera once it does.
+
+An address with no host - Mainsail fills a new webcam in with `/webcam/?action=stream` - is on the page's host, as Mainsail resolves it: the printer's address, on port 80, where nginx hands `/webcam/` to the streamer, or on the port the printer is saved with where that is not a Moonraker's own - 7125, and the 7126, 7127 and on that KIAUH gives a second and third printer's Moonraker on the same computer, all behind the one page. crowsnest's streamer listens on the printer's own computer alone unless its `no_proxy` is set, so nginx is the way to it from another computer. A login in the address is sent as Basic auth, and left out of the log.
+
+By the webcam's service:
+
+- **MJPEG-Streamer, Adaptive MJPEG-Streamer and UV4L-MJPEG** (`mjpegstreamer`, `mjpegstreamer-adaptive`, `uv4l-mjpeg`) - crowsnest's ustreamer, mjpg-streamer, and what Mainsail gives a new webcam. The agent reads the MJPEG stream, and ffmpeg encodes it to H.264 while somebody watches. A bridge on this machine alone, as for an A1 or a P1, hands ffmpeg no more than 10 frames a second and drops the rest before ffmpeg decodes them. ffmpeg then encodes at a constant 10 frames a second - each frame repeated until the next where the webcam stalls, as go2rtc gives a frame that comes more than a second after the last a millisecond's duration. It scales the picture down to 720 lines where it has more, holds it to 1.5 Mbit/s, and puts a keyframe every two seconds. It turns the picture as the webcam's rotation and flips say, rotated first, as Mainsail and Fluidd turn it on their pages.
+- **WebRTC (camera-streamer)** (`webrtc-camerastreamer`) - camera-streamer, which crowsnest runs for a Raspberry Pi's own camera, and which encodes H.264 on the Pi itself. The webcam's address is its WebRTC page, `/webcam/webrtc`, and ffmpeg reads the H.264 beside it, `video.h264`, and copies it as it comes, which costs next to nothing. Where the webcam is flipped or rotated, which only encoding can do, its MJPEG beside it, `stream`, is encoded as above instead.
+- **Anything else** - go2rtc's, MediaMTX's or Janus's WebRTC, HLS, an iframe - names a page or a player rather than a stream, and is not read.
+
+The log says which webcam it relays, and how, `[camera] "Voron-01" relays its webcam "Webcam" (mjpegstreamer-adaptive): its MJPEG is read from http://192.168.0.130/webcam/?action=stream and encoded to H.264 …`. Where there is none, it lists the webcams Moonraker has, `[camera] "Voron-01" has no webcam the agent reads - Moonraker lists "Bed" (webrtc-janus) - …`. The first time frames come, it says how many come and how large, `[camera] The webcam "Webcam" of "Voron-01" at … sends 15.0 frames a second, 40 KB each, of which no more than 10 a second are encoded`. A webcam that cannot be read fails ffmpeg's request at once, and the log says why once, `… was not opened: it answered 404`. A webcam changed to be read another way - camera-streamer where it was MJPEG, or turned - starts go2rtc again on a config for it.
+
+What an MJPEG webcam costs, measured with ffmpeg 9 on an Apple M1 Max, for a still scene with sensor noise, 10 frames a second encoded:
+
+| Webcam | ffmpeg, of one core | Sent |
+| --- | --- | --- |
+| 640×480 | 2.7% | 0.8 Mbit/s |
+| 1280×720 | 6.1% | 1.6 Mbit/s |
+| 1920×1080, scaled to 720 lines | 8% | 1.0 Mbit/s |
+
+Decoding every frame of a webcam sending 30 a second, rather than the bridge's 10, cost 1.7 to 2 times as much. On a Raspberry Pi it has not been measured. By the usual gap between the two, expect a Pi 4 to take 15 to 30% of one of its four cores for crowsnest's default 640×480, and 40 to 80% for a 1080p webcam. That is while somebody watches, and often on the Pi running Klipper itself. A Pi 5 takes about half that, and a Pi 3 about twice.
+
+Tried with go2rtc 1.9.14 and ffmpeg 9 against a stand-in ustreamer at 30 frames a second, at 720p and 1080p, rotated and flipped, and stalling for two and a half seconds, and a stand-in camera-streamer's H.264, each played through go2rtc's WebSocket as the page plays it. None of it has been tried with a real Klipper printer: crowsnest, nginx and camera-streamer's `video.h264` are as their sources read.
+
+`npm run check:webcam` runs those checks again from a checkout, with go2rtc in `camera/`, ffmpeg and ffprobe installed, and Node 22.18 or later, which runs the script's TypeScript as it is - `-- 1080`, `-- turned`, `-- stall` or `-- h264` for the others - and `-- --url http://voron.local/webcam/?action=stream` reads a real webcam on this computer's network instead, with `--service`, `--rotation`, `--flip-horizontal` and `--flip-vertical` as Moonraker would list it. It says what played: `Played 1280×720, 69 frames over 6.7s, 10.1 a second, the longest step between two 0.10s, …`.
+
 ### Setting it up
 
 In the printer's folder, the agent started there as under [Deployment](#deployment). ffmpeg is all there is to install: the agent fetches go2rtc and cloudflared itself.

package/dist/bootstrap.js

@@ -3,11 +3,14 @@ import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { loadEnvFile } from 'node:process';
 import { fileURLToPath } from 'node:url';
+import { createBambuCameraSource, readCameraStream } from './camera-bambu.js';
 import { readJpegCamera } from './camera-jpeg-connection.js';
-import { hasCameraStream, readCameraStream, resolveCameraRelay } from './camera-relay.js';
+import { resolveCameraRelay } from './camera-relay.js';
+import { createWebcamCameraSource, createWebcamReader } from './camera-webcam.js';
 import { BambuMqttClient } from './clients/BambuMqttClient.js';
 import { MoonrakerClient } from './clients/MoonrakerClient.js';
 import { PrinterConnectionType, Vextrix3dApiClient, } from './clients/Vextrix3dApiClient.js';
+import { createMoonrakerCameraReporter } from './moonraker-camera-reporter.js';
 import { createPrintAttemptSynchronizer } from './print-attempt-synchronizer.js';
 import { createPrinterGone } from './printer-gone.js';
 import { createPrinterStateReporter } from './printer-state-reporter.js';
@@ -40,17 +43,12 @@ const parseWifiSignalDbm = (value) => {
     const parsed = Number.parseInt(value, 10);
     return Number.isFinite(parsed) ? parsed : null;
 };
-const connectToBambuPrinter = (printer, connection, apiClient, printerGone) => {
-    const { ip, serialNumber, accessCode } = connection;
-    const jpegCamera = readJpegCamera(serialNumber, ip);
+const startPrinterReporting = (printer, cameraSource, apiClient, printerGone) => {
     const cameraRelay = resolveCameraRelay({
         workDir,
-        caFile: resolve(packageDir, 'certs', 'bambu-ca.pem'),
         printerId: printer.id,
         printerLabel: printer.label,
-        accessCode,
-        serialNumber,
-        jpegCamera,
+        source: cameraSource,
         fetchesBinaries: fetchesCameraBinaries,
         getCameraAccess: () => apiClient.getCamera(),
         printerGone,
@@ -64,6 +62,27 @@ const connectToBambuPrinter = (printer, connection, apiClient, printerGone) => {
         },
         printerGone,
     });
+    return {
+        cameraRelay,
+        stateReporter,
+        hasCameraStream: report => (report === undefined ? undefined : cameraSource.hasStream(report)),
+        stop: async () => {
+            await cameraRelay?.stop();
+            await stateReporter.flush();
+            stateReporter.stop();
+        },
+    };
+};
+const connectToBambuPrinter = (printer, connection, apiClient, printerGone) => {
+    const { ip, serialNumber, accessCode } = connection;
+    const cameraSource = createBambuCameraSource({
+        printerLabel: printer.label,
+        accessCode,
+        serialNumber,
+        caFile: resolve(packageDir, 'certs', 'bambu-ca.pem'),
+        jpegCamera: readJpegCamera(serialNumber, ip),
+    });
+    const { cameraRelay, stateReporter, hasCameraStream, stop: stopReporting, } = startPrinterReporting(printer, cameraSource, apiClient, printerGone);
     const printAttemptSynchronizer = createPrintAttemptSynchronizer({
         printerLabel: printer.label,
         apiClient,
@@ -90,7 +109,7 @@ const connectToBambuPrinter = (printer, connection, apiClient, printerGone) => {
                 bedTemperature: print.bed_temper ?? null,
                 chamberTemperature: readBambuTemperature(print.device?.ctc?.info?.temp),
                 wifiSignalDbm: parseWifiSignalDbm(print.wifi_signal),
-                hasCameraStream: cameraStream === undefined ? undefined : hasCameraStream(cameraStream, jpegCamera),
+                hasCameraStream: hasCameraStream(cameraStream),
             });
             printAttemptSynchronizer.handleState(state);
             cameraRelay?.update(cameraStream);
@@ -107,19 +126,22 @@ const connectToBambuPrinter = (printer, connection, apiClient, printerGone) => {
     });
     return {
         stop: once(async () => {
-            await cameraRelay?.stop();
-            await stateReporter.flush();
-            stateReporter.stop();
+            await stopReporting();
             await mqttClient.stop();
         }),
     };
 };
 const connectToMoonrakerPrinter = (printer, connection, apiClient, printerGone) => {
     const { ip, port, apiKey } = connection;
-    const stateReporter = createPrinterStateReporter({
+    const cameraSource = createWebcamCameraSource({
         printerLabel: printer.label,
-        reportPrinterState: state => apiClient.reportPrinterState(state),
-        printerGone,
+    });
+    const { cameraRelay, stateReporter, hasCameraStream, stop: stopReporting, } = startPrinterReporting(printer, cameraSource, apiClient, printerGone);
+    const cameraReporter = createMoonrakerCameraReporter({
+        stateReporter,
+        cameraRelay,
+        readWebcams: createWebcamReader(ip, port),
+        hasCameraStream,
     });
     const printAttemptSynchronizer = createPrintAttemptSynchronizer({
         printerLabel: printer.label,
@@ -160,9 +182,10 @@ const connectToMoonrakerPrinter = (printer, connection, apiClient, printerGone)
             const filename = status.print_stats?.filename;
             loadEstimatedTime(typeof filename === 'string' ? filename : '');
             const agentState = buildMoonrakerAgentState(status, estimatedTimeS);
-            stateReporter.report(agentState);
+            cameraReporter.reportState(agentState);
             printAttemptSynchronizer.handleState(agentState.state);
         },
+        onWebcams: webcams => cameraReporter.noteWebcams(webcams),
         onReconnect: () => {
             console.log(`Reconnecting to "${printer.label}"...`);
         },
@@ -175,8 +198,7 @@ const connectToMoonrakerPrinter = (printer, connection, apiClient, printerGone)
     });
     return {
         stop: once(async () => {
-            await stateReporter.flush();
-            stateReporter.stop();
+            await stopReporting();
             await client.stop();
         }),
     };

package/dist/camera-bambu.js

@@ -0,0 +1,92 @@
+import { createCameraJpegBridge } from './camera-jpeg-bridge.js';
+import { createCameraStreamBridge, } from './camera-stream-bridge.js';
+export const readCameraStream = (ipcam) => ipcam === undefined ? undefined : (ipcam.rtsp_url ?? null);
+const parseCameraStreamUrl = (rtspUrl) => {
+    if (!rtspUrl) {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(rtspUrl);
+    }
+    catch {
+        return null;
+    }
+    return url.protocol === 'rtsps:' || url.protocol === 'rtsp:' ? url : null;
+};
+export const hasCameraStream = (rtspUrl, jpegCamera = null) => (jpegCamera ? rtspUrl !== undefined : parseCameraStreamUrl(rtspUrl) !== null);
+export const readCameraStreamTarget = (rtspUrl) => {
+    const url = parseCameraStreamUrl(rtspUrl);
+    return url?.protocol === 'rtsps:'
+        ? {
+            host: url.hostname,
+            port: Number(url.port) || 322,
+        }
+        : null;
+};
+export const buildCameraStreamUrl = (rtspUrl, accessCode, bridgePort) => {
+    const url = parseCameraStreamUrl(rtspUrl);
+    if (!url) {
+        return null;
+    }
+    const streamUrl = url.protocol === 'rtsps:'
+        ? new URL(`rtsp://127.0.0.1:${bridgePort}${url.pathname}${url.search}`)
+        : url;
+    streamUrl.username = 'bblp';
+    streamUrl.password = accessCode;
+    return streamUrl.toString();
+};
+const defaultBambuDependencies = {
+    createStreamBridge: options => createCameraStreamBridge(options),
+    createJpegBridge: options => createCameraJpegBridge(options),
+};
+export const createBambuCameraSource = ({ printerLabel, accessCode, serialNumber, caFile, jpegCamera }, dependencies = defaultBambuDependencies) => ({
+    hasStream: rtspUrl => hasCameraStream(rtspUrl, jpegCamera),
+    encodedCamera: jpegCamera ? `a Bambu ${jpegCamera.model}'s camera` : null,
+    describeStream: () => jpegCamera
+        ? `"${printerLabel}" is a Bambu ${jpegCamera.model}, whose camera has no RTSP: its JPEG frames are read from ${jpegCamera.host}:${jpegCamera.port} and encoded to H.264 while somebody watches`
+        : null,
+    describeNoStream: rtspUrl => `"${printerLabel}" reports no camera stream (${rtspUrl || 'none'}) - its LAN live view is off, or its camera is of a model the agent does not read - so its camera is not relayed until it names one`,
+    openInput: () => {
+        if (jpegCamera) {
+            const bridge = dependencies.createJpegBridge({
+                host: jpegCamera.host,
+                port: jpegCamera.port,
+                serialNumber,
+                accessCode,
+                caFile,
+                printerLabel,
+            });
+            return {
+                resolveTarget: async () => ({
+                    kind: 'jpeg',
+                    streamUrl: await bridge.streamUrl,
+                    orientation: null,
+                }),
+                close: bridge.close,
+            };
+        }
+        const bridge = dependencies.createStreamBridge({
+            serialNumber,
+            caFile,
+            printerLabel,
+        });
+        return {
+            resolveTarget: async (rtspUrl) => {
+                const target = readCameraStreamTarget(rtspUrl);
+                if (target) {
+                    bridge.setTarget(target.host, target.port);
+                }
+                const streamUrl = buildCameraStreamUrl(rtspUrl, accessCode, await bridge.port);
+                return streamUrl
+                    ? {
+                        kind: 'rtsp',
+                        streamUrl,
+                        orientation: null,
+                    }
+                    : null;
+            },
+            close: bridge.close,
+        };
+    },
+});

package/dist/camera-frame-bridge.js

@@ -0,0 +1,102 @@
+import { randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+const BOUNDARY = 'frame';
+const FRAMES_MEASURED = 10;
+export const createFramePacer = (maxFps) => {
+    if (maxFps === null) {
+        return () => true;
+    }
+    const intervalMs = 1000 / maxFps;
+    let dueAt = -Infinity;
+    return (now) => {
+        if (now < dueAt) {
+            return false;
+        }
+        dueAt = Math.max(dueAt + intervalMs, now + intervalMs / 2);
+        return true;
+    };
+};
+export const createCameraFrameBridge = ({ open, describe, describeRate, maxFps, }) => {
+    const path = `/${randomBytes(16).toString('hex')}`;
+    const sources = new Set();
+    let reportedFailure = null;
+    let hasReportedRate = false;
+    const reportRate = (firstFrameAt, bytes) => {
+        hasReportedRate = true;
+        const intervalS = (Date.now() - firstFrameAt) / 1000 / (FRAMES_MEASURED - 1);
+        console.log(`[camera] ${describeRate(intervalS, Math.round(bytes / FRAMES_MEASURED / 1024))}`);
+    };
+    const reportFailure = (error) => {
+        if (error.message === reportedFailure) {
+            return;
+        }
+        reportedFailure = error.message;
+        console.error(`[camera] ${describe()} was not opened: ${error.message}`);
+    };
+    const relay = (request, response) => {
+        if (request.method !== 'GET' || request.url !== path) {
+            response.writeHead(404).end();
+            return;
+        }
+        const isDue = createFramePacer(maxFps);
+        let frames = 0;
+        let bytes = 0;
+        let firstFrameAt = 0;
+        const source = open({
+            onFrame: frame => {
+                if (!frames) {
+                    reportedFailure = null;
+                    firstFrameAt = Date.now();
+                    response.writeHead(200, {
+                        'Content-Type': `multipart/x-mixed-replace; boundary=${BOUNDARY}`,
+                        'Cache-Control': 'no-store',
+                    });
+                }
+                frames += 1;
+                bytes += frame.length;
+                if (frames === FRAMES_MEASURED && !hasReportedRate) {
+                    reportRate(firstFrameAt, bytes);
+                }
+                if (!isDue(Date.now()) || response.writableNeedDrain) {
+                    return;
+                }
+                response.write(`--${BOUNDARY}\r\nContent-Type: image/jpeg\r\nContent-Length: ${frame.length}\r\n\r\n`);
+                response.write(frame);
+                response.write('\r\n');
+            },
+            onFailure: error => {
+                if (!response.headersSent) {
+                    response.writeHead(502).end();
+                }
+                reportFailure(error);
+            },
+            onClose: () => {
+                sources.delete(source);
+                if (!response.writableEnded) {
+                    response.destroy();
+                }
+            },
+        });
+        sources.add(source);
+        response.once('close', () => source.close());
+    };
+    const server = createServer(relay);
+    const streamUrl = new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen({
+            host: '127.0.0.1',
+            port: 0,
+        }, () => {
+            const address = server.address();
+            resolve(`http://127.0.0.1:${typeof address === 'object' && address ? address.port : 0}${path}`);
+        });
+    });
+    return {
+        streamUrl,
+        close: () => new Promise(resolve => {
+            sources.forEach(source => source.close());
+            server.close(() => resolve());
+            server.closeAllConnections();
+        }),
+    };
+};

package/dist/camera-jpeg-bridge.js

@@ -1,90 +1,19 @@
-import { randomBytes } from 'node:crypto';
 import { readFileSync } from 'node:fs';
-import { createServer } from 'node:http';
+import { createCameraFrameBridge } from './camera-frame-bridge.js';
 import { CameraJpegConnection } from './camera-jpeg-connection.js';
-const BOUNDARY = 'frame';
-const FRAMES_MEASURED = 10;
 export const createCameraJpegBridge = ({ host, port, serialNumber, accessCode, caFile, printerLabel, }) => {
     const ca = readFileSync(caFile);
-    const path = `/${randomBytes(16).toString('hex')}`;
-    const connections = new Set();
-    let reportedFailure = null;
-    let hasReportedRate = false;
-    const reportRate = (firstFrameAt, bytes) => {
-        hasReportedRate = true;
-        const intervalS = (Date.now() - firstFrameAt) / 1000 / (FRAMES_MEASURED - 1);
-        console.log(`[camera] "${printerLabel}" sends its camera as a JPEG frame every ${intervalS.toFixed(1)}s, ${Math.round(bytes / FRAMES_MEASURED / 1024)} KB each`);
-    };
-    const relay = (request, response) => {
-        if (request.method !== 'GET' || request.url !== path) {
-            response.writeHead(404).end();
-            return;
-        }
-        let frames = 0;
-        let bytes = 0;
-        let firstFrameAt = 0;
-        const connection = new CameraJpegConnection({
+    return createCameraFrameBridge({
+        open: handlers => new CameraJpegConnection({
             host,
             port,
             serialNumber,
             accessCode,
             ca,
-            onFrame: frame => {
-                if (!frames) {
-                    reportedFailure = null;
-                    firstFrameAt = Date.now();
-                    response.writeHead(200, {
-                        'Content-Type': `multipart/x-mixed-replace; boundary=${BOUNDARY}`,
-                        'Cache-Control': 'no-store',
-                    });
-                }
-                frames += 1;
-                bytes += frame.length;
-                if (frames === FRAMES_MEASURED && !hasReportedRate) {
-                    reportRate(firstFrameAt, bytes);
-                }
-                if (response.writableNeedDrain) {
-                    return;
-                }
-                response.write(`--${BOUNDARY}\r\nContent-Type: image/jpeg\r\nContent-Length: ${frame.length}\r\n\r\n`);
-                response.write(frame);
-                response.write('\r\n');
-            },
-            onFailure: error => {
-                if (!response.headersSent) {
-                    response.writeHead(502).end();
-                }
-                if (error.message === reportedFailure) {
-                    return;
-                }
-                reportedFailure = error.message;
-                console.error(`[camera] The camera of "${printerLabel}" at ${host}:${port} was not opened: ${error.message}`);
-            },
-            onClose: () => {
-                connections.delete(connection);
-                response.destroy();
-            },
-        });
-        connections.add(connection);
-        response.once('close', () => connection.close());
-    };
-    const server = createServer(relay);
-    const streamUrl = new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen({
-            host: '127.0.0.1',
-            port: 0,
-        }, () => {
-            const address = server.address();
-            resolve(`http://127.0.0.1:${typeof address === 'object' && address ? address.port : 0}${path}`);
-        });
-    });
-    return {
-        streamUrl,
-        close: () => new Promise(resolve => {
-            connections.forEach(connection => connection.close());
-            server.close(() => resolve());
-            server.closeAllConnections();
+            ...handlers,
         }),
-    };
+        describe: () => `The camera of "${printerLabel}" at ${host}:${port}`,
+        describeRate: (intervalS, frameKb) => `"${printerLabel}" sends its camera as a JPEG frame every ${intervalS.toFixed(1)}s, ${frameKb} KB each`,
+        maxFps: null,
+    });
 };

package/dist/camera-jpeg-connection.js

@@ -1,5 +1,6 @@
 import { connect } from 'node:tls';
 import { checkPrinterCertificate } from './camera-stream-connection.js';
+import { isJpeg } from './utils.js';
 export const JPEG_CAMERA_PORT = 6000;
 const JPEG_CAMERA_MODELS = {
     '01S': 'P1P',
@@ -60,11 +61,7 @@ export const createJpegFrameReader = (onFrame) => {
             }
             const frame = take(frameSize);
             frameSize = null;
-            const isJpeg = frame[0] === 0xff &&
-                frame[1] === 0xd8 &&
-                frame[frame.length - 2] === 0xff &&
-                frame[frame.length - 1] === 0xd9;
-            if (!isJpeg) {
+            if (!isJpeg(frame)) {
                 throw new Error('it sent a frame that is not a JPEG');
             }
             onFrame(frame);