@vextrix3d/machine-agent 0.0.0-stage → 2.1.0

package/dist/camera-tunnel.js

@@ -0,0 +1,80 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { backoffDelayMs, isExecutable, stopChildProcess } from './utils.js';
+const defaultDependencies = {
+    spawn: (command, args, env) => spawn(command, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env,
+    }),
+};
+export const createCameraTunnel = ({ cloudflaredPath, tunnelToken, printerLabel }, dependencies = defaultDependencies) => {
+    let cloudflared = null;
+    let restartTimeoutId;
+    let failures = 0;
+    let startedAt = 0;
+    let isStopping = false;
+    const forward = (output) => {
+        if (!output) {
+            return;
+        }
+        createInterface({
+            input: output,
+        }).on('line', line => {
+            const log = / ERR /.test(line) ? console.error : console.log;
+            log(`[tunnel] ${line}`);
+        });
+    };
+    const scheduleStart = (reason) => {
+        failures = Date.now() - startedAt >= 60_000 ? 1 : failures + 1;
+        const delayMs = backoffDelayMs(failures, 5_000, 60_000);
+        console.error(`[tunnel] ${reason}; starting cloudflared again in ${delayMs / 1000}s`);
+        restartTimeoutId = setTimeout(() => start(), delayMs);
+    };
+    const start = () => {
+        startedAt = Date.now();
+        const child = dependencies.spawn(cloudflaredPath, ['tunnel', '--no-autoupdate', 'run'], {
+            ...process.env,
+            TUNNEL_TOKEN: tunnelToken,
+        });
+        cloudflared = child;
+        console.log(`[tunnel] Opening the camera tunnel of "${printerLabel}"`);
+        forward(child.stdout);
+        forward(child.stderr);
+        child.once('error', error => {
+            console.error('[tunnel] cloudflared could not start:', error);
+        });
+        child.once('exit', (code, signal) => {
+            cloudflared = null;
+            if (!isStopping) {
+                scheduleStart(`cloudflared stopped (${signal ?? `exit code ${code}`})`);
+            }
+        });
+    };
+    start();
+    return {
+        stop: async () => {
+            isStopping = true;
+            clearTimeout(restartTimeoutId);
+            if (cloudflared) {
+                await stopChildProcess(cloudflared);
+            }
+        },
+    };
+};
+export const resolveCameraTunnel = ({ workDir, tunnelToken, printerLabel }, dependencies) => {
+    if (!tunnelToken) {
+        console.log('[tunnel] Off: vextrix3d makes no camera tunnel here');
+        return null;
+    }
+    const cloudflaredPath = join(workDir, 'camera', 'cloudflared');
+    if (!isExecutable(cloudflaredPath)) {
+        console.log('[tunnel] Off: there is no camera/cloudflared to run');
+        return null;
+    }
+    return createCameraTunnel({
+        cloudflaredPath,
+        tunnelToken,
+        printerLabel,
+    }, dependencies);
+};

package/dist/camera-webcam-connection.js

@@ -0,0 +1,186 @@
+import { request as requestHttp } from 'node:http';
+import { request as requestHttps } from 'node:https';
+import { isJpeg } from './utils.js';
+export const readMjpegBoundary = (contentType) => {
+    const match = contentType?.match(/^\s*multipart\/x-mixed-replace\s*;(?:.*;)?\s*boundary=([^;]+)/i);
+    const boundary = match?.[1].trim().replace(/^"(.*)"$/, '$1');
+    return boundary || null;
+};
+const MAX_FRAME_SIZE = 16 * 1024 * 1024;
+const JPEG_END = Buffer.from([0xff, 0xd9]);
+export const createMjpegFrameReader = (boundary, onFrame) => {
+    const delimiter = Buffer.from(boundary, 'latin1');
+    const pieces = [];
+    let buffer = Buffer.alloc(0);
+    let piecesSize = 0;
+    let state = 'boundary';
+    let contentLength = null;
+    const takeLine = () => {
+        const end = buffer.indexOf(0x0a);
+        if (end < 0) {
+            return null;
+        }
+        const line = buffer.toString('latin1', 0, end).replace(/\r$/, '');
+        buffer = buffer.subarray(end + 1);
+        return line;
+    };
+    const emit = (frame) => {
+        if (isJpeg(frame)) {
+            onFrame(frame);
+        }
+    };
+    const step = () => {
+        switch (state) {
+            case 'boundary': {
+                const at = buffer.indexOf(delimiter);
+                if (at < 0) {
+                    buffer = buffer.subarray(Math.max(0, buffer.length - delimiter.length));
+                    return false;
+                }
+                const lineEnd = buffer.indexOf(0x0a, at + delimiter.length);
+                if (lineEnd < 0) {
+                    buffer = buffer.subarray(at);
+                    return false;
+                }
+                buffer = buffer.subarray(lineEnd + 1);
+                state = 'headers';
+                contentLength = null;
+                return true;
+            }
+            case 'headers': {
+                const line = takeLine();
+                if (line === null) {
+                    return false;
+                }
+                if (line) {
+                    const length = /^content-length\s*:\s*(\d+)\s*$/i.exec(line);
+                    if (length) {
+                        contentLength = Number(length[1]);
+                        if (contentLength > MAX_FRAME_SIZE) {
+                            throw new Error(`it sent a part of ${contentLength} bytes`);
+                        }
+                    }
+                    return true;
+                }
+                state = 'body';
+                return true;
+            }
+            case 'body': {
+                if (contentLength !== null) {
+                    if (buffer.length < contentLength) {
+                        return false;
+                    }
+                    emit(buffer.subarray(0, contentLength));
+                    buffer = buffer.subarray(contentLength);
+                    state = 'boundary';
+                    return true;
+                }
+                const next = buffer.indexOf(delimiter);
+                if (next < 0) {
+                    return false;
+                }
+                const body = buffer.subarray(0, next);
+                const end = body.lastIndexOf(JPEG_END);
+                emit(end < 0 ? body : body.subarray(0, end + 2));
+                buffer = buffer.subarray(next);
+                state = 'boundary';
+                return true;
+            }
+        }
+    };
+    return (chunk) => {
+        pieces.push(chunk);
+        piecesSize += chunk.length;
+        const isBodyComing = state === 'body' && contentLength !== null && buffer.length + piecesSize < contentLength;
+        if (isBodyComing) {
+            return;
+        }
+        buffer =
+            buffer.length || pieces.length > 1
+                ? Buffer.concat([buffer, ...pieces], buffer.length + piecesSize)
+                : chunk;
+        pieces.length = 0;
+        piecesSize = 0;
+        while (step()) {
+        }
+        if (buffer.length > MAX_FRAME_SIZE) {
+            throw new Error(`it sent ${MAX_FRAME_SIZE / 1024 / 1024} MB with no frame in it`);
+        }
+    };
+};
+const FRAME_TIMEOUT_MS = 10_000;
+export const describeWebcamUrl = (url) => {
+    try {
+        const parsed = new URL(url);
+        parsed.username = '';
+        parsed.password = '';
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+};
+export class CameraWebcamConnection {
+    request;
+    frameTimeoutId;
+    isClosed = false;
+    constructor({ url, onFrame, onFailure, onClose }) {
+        const target = new URL(url);
+        const fail = (error) => {
+            if (!this.isClosed) {
+                onFailure(error);
+                this.close();
+            }
+        };
+        const awaitFrame = () => {
+            clearTimeout(this.frameTimeoutId);
+            this.frameTimeoutId = setTimeout(() => fail(new Error(`it sent no frame in ${FRAME_TIMEOUT_MS / 1000}s`)), FRAME_TIMEOUT_MS);
+        };
+        const read = (response) => {
+            const boundary = readMjpegBoundary(response.headers['content-type']);
+            response.on('error', fail);
+            if (response.statusCode !== 200) {
+                fail(new Error(`it answered ${response.statusCode}`));
+                return;
+            }
+            if (!boundary) {
+                fail(new Error(`it answered with ${response.headers['content-type'] ?? 'no content type'}, not an MJPEG stream`));
+                return;
+            }
+            const readFrames = createMjpegFrameReader(boundary, frame => {
+                awaitFrame();
+                onFrame(frame);
+            });
+            response.on('data', (chunk) => {
+                try {
+                    readFrames(chunk);
+                }
+                catch (error) {
+                    fail(error);
+                }
+            });
+            response.once('end', () => fail(new Error('it ended the stream')));
+        };
+        this.request = (target.protocol === 'https:' ? requestHttps : requestHttp)(target, {
+            headers: {
+                Accept: 'multipart/x-mixed-replace, */*',
+            },
+        });
+        this.request.once('response', read);
+        this.request.on('error', fail);
+        this.request.once('close', () => {
+            this.close();
+            onClose();
+        });
+        this.request.end();
+        awaitFrame();
+    }
+    close() {
+        if (this.isClosed) {
+            return;
+        }
+        this.isClosed = true;
+        clearTimeout(this.frameTimeoutId);
+        this.request.destroy();
+    }
+}

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/ApiRequestError.js

@@ -0,0 +1,7 @@
+export class ApiRequestError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}

package/dist/clients/BambuMqttClient.js

@@ -0,0 +1,108 @@
+import mqtt from 'mqtt';
+import { readFileSync } from 'node:fs';
+import { mergeBambuStatus } from '../utils.js';
+const BAMBU_CA = readFileSync(new URL('../../certs/bambu-ca.pem', import.meta.url));
+export class BambuMqttClient {
+    options;
+    client;
+    reportTopic;
+    requestTopic;
+    sequenceId = 0;
+    status = null;
+    constructor(options) {
+        this.options = options;
+        const { ip, serialNumber, accessCode, reconnectPeriod = 60_000, connectTimeout = 30_000, keepalive = 30, } = options;
+        this.reportTopic = `device/${serialNumber}/report`;
+        this.requestTopic = `device/${serialNumber}/request`;
+        const connectOptions = {
+            username: 'bblp',
+            password: accessCode,
+            ca: BAMBU_CA,
+            servername: serialNumber,
+            maxVersion: 'TLSv1.2',
+            keepalive,
+            reconnectPeriod,
+            connectTimeout,
+        };
+        this.client = mqtt.connect(`mqtts://${ip}:8883`, connectOptions);
+        this.setupListeners();
+    }
+    stop(force = true) {
+        return new Promise((resolve, reject) => {
+            this.client.end(force, {}, error => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    setupListeners() {
+        this.client.on('connect', () => {
+            this.subscribeToReports();
+        });
+        this.client.on('message', (topic, payload) => {
+            if (topic !== this.reportTopic) {
+                return;
+            }
+            this.handleMessage(payload);
+        });
+        this.client.on('reconnect', () => {
+            this.options.onReconnect?.();
+        });
+        this.client.on('close', () => {
+            this.options.onClose?.();
+        });
+        this.client.on('error', error => {
+            this.handleError(error);
+        });
+    }
+    subscribeToReports() {
+        this.client.subscribe(this.reportTopic, error => {
+            if (error) {
+                this.handleError(new Error(`Failed to subscribe to MQTT topic "${this.reportTopic}"`, {
+                    cause: error,
+                }));
+                return;
+            }
+            this.requestFullStatus();
+            this.options.onConnect?.();
+        });
+    }
+    requestFullStatus() {
+        const request = {
+            pushing: {
+                sequence_id: String(this.sequenceId++),
+                command: 'pushall',
+                version: 1,
+                push_target: 1,
+            },
+        };
+        this.client.publish(this.requestTopic, JSON.stringify(request), error => {
+            if (error) {
+                this.handleError(new Error(`Failed to publish to MQTT topic "${this.requestTopic}"`, {
+                    cause: error,
+                }));
+            }
+        });
+    }
+    handleMessage(payload) {
+        try {
+            const data = JSON.parse(payload.toString('utf8'));
+            if (data.print?.command !== 'push_status') {
+                return;
+            }
+            this.status = mergeBambuStatus(this.status, data.print);
+            this.options.onStatus?.(this.status);
+        }
+        catch (error) {
+            this.handleError(new Error('Failed to parse Bambu MQTT message', {
+                cause: error,
+            }));
+        }
+    }
+    handleError(error) {
+        this.options.onError?.(error);
+    }
+}