@vextrix3d/machine-agent 2.0.0 → 2.1.0

package/dist/camera-webcam.js

@@ -0,0 +1,156 @@
+import { createCameraFrameBridge } from './camera-frame-bridge.js';
+import { WEBCAM_MAX_FPS } from './camera-relay.js';
+import { CameraWebcamConnection, describeWebcamUrl } from './camera-webcam-connection.js';
+const MJPEG_SERVICES = new Set(['mjpegstreamer', 'mjpegstreamer-adaptive', 'uv4l-mjpeg']);
+const CAMERA_STREAMER_SERVICE = 'webrtc-camerastreamer';
+const isMoonrakerPort = (port) => port >= 7125 && port <= 7199;
+export const resolveWebcamBaseUrl = (host, port) => `http://${host}${port === 80 || isMoonrakerPort(port) ? '' : `:${port}`}/`;
+const readString = (value) => (typeof value === 'string' ? value.trim() : '');
+const readService = (webcam) => readString(webcam.service) || 'mjpegstreamer';
+const readOrientation = (webcam) => {
+    const rotation = Number(webcam.rotation);
+    return {
+        flipHorizontal: webcam.flip_horizontal === true,
+        flipVertical: webcam.flip_vertical === true,
+        rotation: [90, 180, 270].includes(rotation) ? rotation : 0,
+    };
+};
+const isTurned = ({ flipHorizontal, flipVertical, rotation }) => flipHorizontal || flipVertical || rotation !== 0;
+const resolveHttpUrl = (url, baseUrl) => {
+    if (!url) {
+        return null;
+    }
+    try {
+        const resolved = new URL(url, baseUrl);
+        return resolved.protocol === 'http:' || resolved.protocol === 'https:' ? resolved : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const readWebcamStream = (webcam, baseUrl) => {
+    const service = readService(webcam);
+    const streamUrl = resolveHttpUrl(readString(webcam.stream_url), baseUrl);
+    if (webcam.enabled === false || !streamUrl) {
+        return null;
+    }
+    const orientation = readOrientation(webcam);
+    const stream = {
+        name: readString(webcam.name),
+        service,
+        orientation,
+    };
+    if (MJPEG_SERVICES.has(service)) {
+        return {
+            ...stream,
+            kind: 'mjpeg',
+            url: streamUrl.toString(),
+        };
+    }
+    if (service !== CAMERA_STREAMER_SERVICE) {
+        return null;
+    }
+    return isTurned(orientation)
+        ? {
+            ...stream,
+            kind: 'mjpeg',
+            url: new URL('stream', streamUrl).toString(),
+        }
+        : {
+            ...stream,
+            kind: 'h264',
+            url: new URL('video.h264', streamUrl).toString(),
+        };
+};
+const describeListedWebcam = (webcam) => `"${readString(webcam.name)}" (${webcam.enabled === false ? 'off' : readService(webcam)})`;
+export const createWebcamReader = (host, port) => {
+    const baseUrl = resolveWebcamBaseUrl(host, port);
+    let last = null;
+    return (webcams) => {
+        const next = {
+            stream: webcams
+                ?.map(webcam => readWebcamStream(webcam, baseUrl))
+                .find((stream) => stream !== null) ?? null,
+            listed: webcams?.map(describeListedWebcam) ?? null,
+        };
+        if (!last || JSON.stringify(last) !== JSON.stringify(next)) {
+            last = next;
+        }
+        return last;
+    };
+};
+export const createCameraWebcamBridge = ({ printerLabel, webcam: firstWebcam, }) => {
+    let webcam = firstWebcam;
+    const describe = () => `The webcam "${webcam.name}" of "${printerLabel}" at ${describeWebcamUrl(webcam.url)}`;
+    const bridge = createCameraFrameBridge({
+        open: handlers => new CameraWebcamConnection({
+            url: webcam.url,
+            ...handlers,
+        }),
+        describe,
+        describeRate: (intervalS, frameKb) => `${describe()} sends ${intervalS > 0 ? (1 / intervalS).toFixed(1) : 'many'} frames a second, ${frameKb} KB each, of which no more than ${WEBCAM_MAX_FPS} a second are encoded`,
+        maxFps: WEBCAM_MAX_FPS,
+    });
+    return {
+        ...bridge,
+        setWebcam: next => {
+            webcam = next;
+        },
+    };
+};
+const defaultDependencies = {
+    createWebcamBridge: options => createCameraWebcamBridge(options),
+};
+export const createWebcamCameraSource = ({ printerLabel }, dependencies = defaultDependencies) => ({
+    hasStream: report => Boolean(report?.stream),
+    encodedCamera: "a webcam's MJPEG",
+    describeStream: report => {
+        const stream = report?.stream;
+        if (!stream) {
+            return null;
+        }
+        const webcam = `"${printerLabel}" relays its webcam "${stream.name}" (${stream.service})`;
+        const url = describeWebcamUrl(stream.url);
+        return stream.kind === 'h264'
+            ? `${webcam}: its H.264 is read from ${url} and relayed as it comes`
+            : `${webcam}: its MJPEG is read from ${url} and encoded to H.264, at no more than ${WEBCAM_MAX_FPS} frames a second and 720 lines, while somebody watches${isTurned(stream.orientation) ? ', turned as Moonraker has it set' : ''}`;
+    },
+    describeNoStream: report => report?.listed
+        ? `"${printerLabel}" has no webcam the agent reads - Moonraker lists ${report.listed.length ? report.listed.join(', ') : 'none'} - so its camera is not relayed until it lists one: an MJPEG stream, or camera-streamer's`
+        : `"${printerLabel}" has a Moonraker too old to list its webcams, with no server.webcams.list, so its camera is not relayed until Moonraker is updated`,
+    openInput: () => {
+        let bridge = null;
+        return {
+            resolveTarget: async (report) => {
+                const stream = report?.stream;
+                if (!stream) {
+                    return null;
+                }
+                if (stream.kind === 'h264') {
+                    return {
+                        kind: 'h264',
+                        streamUrl: stream.url,
+                        orientation: null,
+                    };
+                }
+                if (bridge) {
+                    bridge.setWebcam(stream);
+                }
+                else {
+                    bridge = dependencies.createWebcamBridge({
+                        printerLabel,
+                        webcam: stream,
+                    });
+                }
+                return {
+                    kind: 'mjpeg',
+                    streamUrl: await bridge.streamUrl,
+                    orientation: stream.orientation,
+                };
+            },
+            close: async () => {
+                await bridge?.close();
+            },
+        };
+    },
+});

package/dist/clients/MoonrakerClient.js

@@ -1,5 +1,13 @@
 import { KlippyState } from '../types/index.js';
 import { findMoonrakerChamberObject, MOONRAKER_SUBSCRIBED_OBJECTS, mergeMoonrakerStatus, } from '../utils.js';
+const METHOD_NOT_FOUND = -32601;
+class MoonrakerRequestError extends Error {
+    code;
+    constructor(code, message) {
+        super(`Moonraker error ${code}: ${message}`);
+        this.code = code;
+    }
+}
 const RECONNECT_DELAYS_MS = [2_000, 5_000, 15_000, 30_000, 60_000];
 export class MoonrakerClient {
     options;
@@ -10,6 +18,7 @@ export class MoonrakerClient {
     isSubscribed = false;
     subscribing = null;
     isStopped = false;
+    hasListedWebcams = false;
     reconnectAttempt = 0;
     reconnectTimer = null;
     heartbeatTimer = null;
@@ -87,12 +96,32 @@ export class MoonrakerClient {
                 url: 'https://vextrix3d.co.uk',
             });
             this.startHeartbeat();
+            void this.listWebcams();
             await this.subscribeOnceKlippyAnswers();
         }
         catch (error) {
             this.handleError(error);
         }
     }
+    async listWebcams() {
+        let webcams;
+        try {
+            const result = await this.request('server.webcams.list');
+            webcams = Array.isArray(result.webcams) ? result.webcams : [];
+        }
+        catch (error) {
+            if (!(error instanceof MoonrakerRequestError && error.code === METHOD_NOT_FOUND)) {
+                this.handleError(error);
+                return;
+            }
+            webcams = null;
+        }
+        this.passWebcams(webcams);
+    }
+    passWebcams(webcams) {
+        this.hasListedWebcams = true;
+        this.options.onWebcams?.(webcams);
+    }
     async subscribeOnceKlippyAnswers() {
         const { klippy_state: klippyState } = await this.request('server.info');
         const isAnswering = klippyState === KlippyState.READY ||
@@ -129,6 +158,9 @@ export class MoonrakerClient {
     startHeartbeat() {
         this.stopHeartbeat();
         this.heartbeatTimer = setInterval(() => {
+            if (!this.hasListedWebcams) {
+                void this.listWebcams();
+            }
             if (this.isSubscribed) {
                 this.options.onStatus?.(this.status);
                 return;
@@ -195,6 +227,13 @@ export class MoonrakerClient {
                 this.options.onStatus?.(this.status);
                 break;
             }
+            case 'notify_webcams_changed': {
+                const { webcams } = (message.params?.[0] ?? {});
+                if (Array.isArray(webcams)) {
+                    this.passWebcams(webcams);
+                }
+                break;
+            }
             case 'notify_klippy_ready':
                 void this.subscribe().catch(error => this.handleError(error));
                 break;
@@ -211,7 +250,7 @@ export class MoonrakerClient {
         clearTimeout(pending.timeout);
         this.pendingRequests.delete(message.id);
         if (message.error) {
-            pending.reject(new Error(`Moonraker error ${message.error.code}: ${message.error.message}`));
+            pending.reject(new MoonrakerRequestError(message.error.code, message.error.message));
             return;
         }
         pending.resolve(message.result);
@@ -222,6 +261,7 @@ export class MoonrakerClient {
         }
         this.socket = null;
         this.isSubscribed = false;
+        this.hasListedWebcams = false;
         this.stopHeartbeat();
         this.pendingRequests.forEach(({ reject, timeout }) => {
             clearTimeout(timeout);

package/dist/moonraker-camera-reporter.js

@@ -0,0 +1,21 @@
+export const createMoonrakerCameraReporter = ({ stateReporter, cameraRelay, readWebcams, hasCameraStream, }) => {
+    let webcamReport;
+    let lastState = null;
+    const reportState = (state) => {
+        lastState = state;
+        stateReporter.report({
+            ...state,
+            hasCameraStream: hasCameraStream(webcamReport),
+        });
+    };
+    return {
+        reportState,
+        noteWebcams: webcams => {
+            webcamReport = readWebcams(webcams);
+            cameraRelay?.update(webcamReport);
+            if (lastState) {
+                reportState(lastState);
+            }
+        },
+    };
+};

package/dist/utils.js

@@ -66,6 +66,11 @@ export const stopChildProcess = (child, killAfterMs = 3_000) => new Promise(reso
     });
     child.kill('SIGTERM');
 });
+export const isJpeg = (frame) => frame.length >= 4 &&
+    frame[0] === 0xff &&
+    frame[1] === 0xd8 &&
+    frame[frame.length - 2] === 0xff &&
+    frame[frame.length - 1] === 0xd9;
 export const formatSubtaskName = (value) => {
     const subtaskName = value?.trim();
     if (!subtaskName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vextrix3d/machine-agent",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Connects a Bambu or Klipper printer to Vextrix3D: reports its state and print progress, and relays its camera",
   "keywords": [
     "vextrix3d",
@@ -39,9 +39,10 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    "typecheck": "tsc --noEmit -p tsconfig.json",
-    "lint": "eslint src && prettier --check src",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc -p scripts",
+    "lint": "eslint src scripts && prettier --check src scripts",
     "test": "vitest",
+    "check:webcam": "npm run build && node scripts/check-webcam-relay.ts",
     "prepublishOnly": "CI=1 npm test && npm run build",
     "start": "npm run build && pm2 start dist/bootstrap.js --name \"$(basename \"$(pwd -P)\")\"",
     "start:prod": "npm run build && NODE_ENV=production pm2 start dist/bootstrap.js --name \"$(basename \"$(pwd -P)\")\"",