@vextrix3d/machine-agent 0.0.0-stage → 2.0.0

package/dist/camera-gateway.js

@@ -0,0 +1,201 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { connect } from 'node:net';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const CAMERA_GATEWAY_PORT = 1984;
+export const CAMERA_REGISTRY_DIR = join(homedir(), '.local', 'state', 'machine-agent', 'cameras');
+const PRINTER_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+export const CAMERA_RELAY_HEADER = 'x-vextrix3d-camera';
+const CAMERA_RELAY_TOKEN_PAST_SECS = 120;
+const CAMERA_RELAY_TOKEN_FUTURE_SECS = 180;
+export const checkCameraRelayToken = (token, printerId, key, nowSecs) => {
+    const match = token?.match(/^(\d{1,12})\.([A-Za-z0-9_-]{43})$/);
+    if (!match) {
+        return 'invalid';
+    }
+    const expiresAt = Number(match[1]);
+    const expected = createHmac('sha256', key).update(`${printerId}.${expiresAt}`).digest();
+    const signature = Buffer.from(match[2], 'base64url');
+    if (signature.length !== expected.length || !timingSafeEqual(signature, expected)) {
+        return 'invalid';
+    }
+    const isInTime = expiresAt >= nowSecs - CAMERA_RELAY_TOKEN_PAST_SECS &&
+        expiresAt <= nowSecs + CAMERA_RELAY_TOKEN_FUTURE_SECS;
+    return isInTime ? 'valid' : 'mistimed';
+};
+export const createCameraRegistry = (dir) => {
+    const resolvePath = (printerId) => join(dir, `${printerId}.json`);
+    return {
+        register: (printerId, port, key) => {
+            if (!PRINTER_ID_PATTERN.test(printerId)) {
+                throw new Error(`"${printerId}" is not a printer id the camera registry can hold`);
+            }
+            mkdirSync(dir, {
+                recursive: true,
+            });
+            chmodSync(dir, 0o700);
+            const path = resolvePath(printerId);
+            const pendingPath = `${path}.${process.pid}`;
+            writeFileSync(pendingPath, JSON.stringify({ port, key }), {
+                mode: 0o600,
+            });
+            renameSync(pendingPath, path);
+        },
+        unregister: printerId => {
+            if (PRINTER_ID_PATTERN.test(printerId)) {
+                rmSync(resolvePath(printerId), {
+                    force: true,
+                });
+            }
+        },
+        lookup: printerId => {
+            if (!PRINTER_ID_PATTERN.test(printerId)) {
+                return null;
+            }
+            try {
+                const { port, key } = JSON.parse(readFileSync(resolvePath(printerId), 'utf8'));
+                if (!Number.isInteger(port)) {
+                    return null;
+                }
+                return {
+                    port,
+                    key: typeof key === 'string' && key ? key : null,
+                };
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+};
+const refuse = (socket, status) => {
+    socket.end(`HTTP/1.1 ${status}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`, () => socket.destroy());
+};
+const buildRequestHead = (request) => {
+    const lines = [`${request.method} ${request.url} HTTP/${request.httpVersion}`];
+    for (let index = 0; index < request.rawHeaders.length; index += 2) {
+        if (request.rawHeaders[index].toLowerCase() !== CAMERA_RELAY_HEADER) {
+            lines.push(`${request.rawHeaders[index]}: ${request.rawHeaders[index + 1]}`);
+        }
+    }
+    return `${lines.join('\r\n')}\r\n\r\n`;
+};
+export const createCameraGateway = ({ port, registry, reusePort, retryDelayMs = 30_000, }) => {
+    const sockets = new Set();
+    let server = null;
+    let retryTimeoutId;
+    let hasReportedTaken = false;
+    let isStopping = false;
+    const pass = (request, socket, head) => {
+        sockets.add(socket);
+        socket.once('close', () => sockets.delete(socket));
+        socket.on('error', () => socket.destroy());
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        const printerId = url.searchParams.get('src') ?? '';
+        if (url.pathname !== '/api/ws' || request.headers.upgrade?.toLowerCase() !== 'websocket') {
+            refuse(socket, '404 Not Found');
+            return;
+        }
+        const entry = registry.lookup(printerId);
+        if (!entry) {
+            console.error(`[camera] A viewer asked for printer ${JSON.stringify(printerId)}, which no agent on this machine relays`);
+            refuse(socket, '404 Not Found');
+            return;
+        }
+        const token = request.headers[CAMERA_RELAY_HEADER];
+        const check = entry.key === null
+            ? 'invalid'
+            : checkCameraRelayToken(typeof token === 'string' ? token : undefined, printerId, entry.key, Date.now() / 1000);
+        if (check === 'mistimed') {
+            console.error(`[camera] A viewer asked for printer ${printerId} with a relay token that has expired or is not yet valid by this computer's clock - is the clock more than two minutes off? Keep it set by NTP`);
+        }
+        else if (check === 'invalid') {
+            console.error(`[camera] A viewer asked for printer ${printerId} without a valid relay token${entry.key === null ? ' - its agent has no relay key; restart it' : ''}`);
+        }
+        if (check !== 'valid') {
+            refuse(socket, '401 Unauthorized');
+            return;
+        }
+        const go2rtcPort = entry.port;
+        const go2rtc = connect(go2rtcPort, '127.0.0.1');
+        sockets.add(go2rtc);
+        go2rtc.once('close', () => sockets.delete(go2rtc));
+        let isConnected = false;
+        const close = () => {
+            socket.destroy();
+            go2rtc.destroy();
+        };
+        socket.once('close', close);
+        go2rtc.on('error', error => {
+            if (isConnected) {
+                close();
+                return;
+            }
+            console.error(`[camera] The go2rtc of printer ${printerId} is not answering on 127.0.0.1:${go2rtcPort}:`, error.message);
+            refuse(socket, '502 Bad Gateway');
+        });
+        go2rtc.once('connect', () => {
+            isConnected = true;
+            go2rtc.once('close', close);
+            go2rtc.write(buildRequestHead(request));
+            if (head.length) {
+                go2rtc.write(head);
+            }
+            socket.pipe(go2rtc).pipe(socket);
+        });
+    };
+    const listen = () => new Promise(resolve => {
+        const nextServer = createServer((_request, response) => {
+            response.writeHead(404).end();
+        });
+        nextServer.on('upgrade', pass);
+        nextServer.once('error', (error) => {
+            if (error.code !== 'EADDRINUSE') {
+                console.error(`[camera] Could not take camera requests on 127.0.0.1:${port}:`, error);
+                resolve(false);
+                return;
+            }
+            if (!hasReportedTaken) {
+                hasReportedTaken = true;
+                console.error(`[camera] Port ${port}, where this machine's agents take camera requests together, is held by something else - the printer-camera pm2 process from before? (\`yarn pm2 delete printer-camera\`). Trying again every ${retryDelayMs / 1000}s`);
+            }
+            if (!isStopping) {
+                retryTimeoutId = setTimeout(() => void listen(), retryDelayMs);
+            }
+            resolve(false);
+        });
+        nextServer.listen({
+            host: '127.0.0.1',
+            port,
+            reusePort,
+        }, () => {
+            if (isStopping) {
+                nextServer.close();
+                resolve(false);
+                return;
+            }
+            server = nextServer;
+            console.log(`[camera] Taking this machine's camera requests on 127.0.0.1:${port}`);
+            resolve(true);
+        });
+    });
+    return {
+        start: listen,
+        stop: async () => {
+            isStopping = true;
+            clearTimeout(retryTimeoutId);
+            for (const socket of sockets) {
+                socket.destroy();
+            }
+            const runningServer = server;
+            if (runningServer) {
+                await new Promise(resolve => {
+                    runningServer.close(() => resolve());
+                    runningServer.closeAllConnections();
+                });
+            }
+        },
+    };
+};

package/dist/camera-jpeg-bridge.js

@@ -0,0 +1,90 @@
+import { randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+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({
+            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();
+        }),
+    };
+};

package/dist/camera-jpeg-connection.js

@@ -0,0 +1,124 @@
+import { connect } from 'node:tls';
+import { checkPrinterCertificate } from './camera-stream-connection.js';
+export const JPEG_CAMERA_PORT = 6000;
+const JPEG_CAMERA_MODELS = {
+    '01S': 'P1P',
+    '01P': 'P1S',
+    '030': 'A1 mini',
+    '039': 'A1',
+    '26A': 'A2L',
+};
+export const readJpegCamera = (serialNumber, host) => {
+    const model = JPEG_CAMERA_MODELS[serialNumber.slice(0, 3).toUpperCase()];
+    return model
+        ? {
+            model,
+            host,
+            port: JPEG_CAMERA_PORT,
+        }
+        : null;
+};
+export const buildJpegCameraAuthPacket = (accessCode) => {
+    const packet = Buffer.alloc(80);
+    packet.writeUInt32LE(0x40, 0);
+    packet.writeUInt32LE(0x3000, 4);
+    packet.write('bblp', 16, 32, 'ascii');
+    packet.write(accessCode, 48, 32, 'ascii');
+    return packet;
+};
+const FRAME_HEADER_SIZE = 16;
+const MAX_FRAME_SIZE = 4 * 1024 * 1024;
+export const createJpegFrameReader = (onFrame) => {
+    const chunks = [];
+    let buffered = 0;
+    let frameSize = null;
+    const take = (size) => {
+        const joined = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, buffered);
+        chunks.length = 0;
+        if (joined.length > size) {
+            chunks.push(joined.subarray(size));
+        }
+        buffered -= size;
+        return joined.subarray(0, size);
+    };
+    return (chunk) => {
+        chunks.push(chunk);
+        buffered += chunk.length;
+        while (true) {
+            if (frameSize === null) {
+                if (buffered < FRAME_HEADER_SIZE) {
+                    return;
+                }
+                const size = take(FRAME_HEADER_SIZE).readUInt32LE(0);
+                if (size < 4 || size > MAX_FRAME_SIZE) {
+                    throw new Error(`it sent a frame of ${size} bytes`);
+                }
+                frameSize = size;
+            }
+            if (buffered < frameSize) {
+                return;
+            }
+            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) {
+                throw new Error('it sent a frame that is not a JPEG');
+            }
+            onFrame(frame);
+        }
+    };
+};
+export class CameraJpegConnection {
+    printer;
+    hasFrame = false;
+    isClosed = false;
+    constructor({ host, port, serialNumber, accessCode, ca, onFrame, onFailure, onClose, }) {
+        this.printer = connect({
+            host,
+            port,
+            servername: serialNumber,
+            ca,
+            checkServerIdentity: checkPrinterCertificate(serialNumber),
+            maxVersion: 'TLSv1.2',
+        });
+        const fail = (error) => {
+            if (!this.isClosed) {
+                onFailure(error);
+                this.close();
+            }
+        };
+        const readFrames = createJpegFrameReader(frame => {
+            this.hasFrame = true;
+            onFrame(frame);
+        });
+        this.printer.once('secureConnect', () => {
+            this.printer.write(buildJpegCameraAuthPacket(accessCode));
+        });
+        this.printer.on('data', (chunk) => {
+            try {
+                readFrames(chunk);
+            }
+            catch (error) {
+                fail(error);
+            }
+        });
+        this.printer.on('error', fail);
+        this.printer.once('close', () => {
+            if (!this.hasFrame) {
+                fail(new Error('the printer closed the connection before sending a frame, as it does where the access code is wrong'));
+            }
+            this.close();
+            onClose();
+        });
+    }
+    close() {
+        if (this.isClosed) {
+            return;
+        }
+        this.isClosed = true;
+        this.printer.destroy();
+    }
+}