@vextrix3d/machine-agent 0.0.0-stage → 2.1.0

package/dist/camera-relay.js

@@ -0,0 +1,542 @@
+import { execFileSync, spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { chmodSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { ensureCameraBinaries, findCameraBinaryPins } from './camera-binaries.js';
+import { CAMERA_GATEWAY_PORT, CAMERA_REGISTRY_DIR, createCameraGateway, createCameraRegistry, } from './camera-gateway.js';
+import { resolveCameraTunnel } from './camera-tunnel.js';
+import { backoffDelayMs, isExecutable, isPortFree, readArmVersion, stopChildProcess, } from './utils.js';
+const quoteFfconcat = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+export const buildCameraFile = ({ streamUrl, kind, readsOptions }) => [
+    'ffconcat version 1.0',
+    `file ${quoteFfconcat(streamUrl)}`,
+    ...(readsOptions
+        ? [
+            ...(kind === 'rtsp' ? ['option rtsp_transport tcp'] : []),
+            'option analyzeduration 1000000',
+            'option probesize 1000000',
+            'option fflags nobuffer',
+        ]
+        : []),
+    '',
+].join('\n');
+const RTSP_PORT_OFFSET = 6570;
+export const GO2RTC_API_PORT_RANGE = [CAMERA_GATEWAY_PORT + 1, CAMERA_GATEWAY_PORT + 99];
+export const findFreeCameraRelayPorts = async (isPortFree) => {
+    const [firstApiPort, lastApiPort] = GO2RTC_API_PORT_RANGE;
+    for (let apiPort = firstApiPort; apiPort <= lastApiPort; apiPort++) {
+        const rtspPort = apiPort + RTSP_PORT_OFFSET;
+        if ((await isPortFree(apiPort)) && (await isPortFree(rtspPort))) {
+            return {
+                apiPort,
+                rtspPort,
+            };
+        }
+    }
+    return null;
+};
+const buildH264Encoding = ({ ffmpegFpsModeFlag, fps, filters, maxrateKbps, }) => [
+    ...(filters ? [`-vf ${filters}`] : []),
+    '-c:v libx264 -preset ultrafast -tune zerolatency -pix_fmt yuv420p',
+    ...(maxrateKbps ? [`-maxrate ${maxrateKbps}k -bufsize ${maxrateKbps}k`] : []),
+    '-force_key_frames expr:gte(t,n_forced*2)',
+    `${ffmpegFpsModeFlag} cfr -r ${fps}`,
+].join(' ');
+export const WEBCAM_MAX_FPS = 10;
+const WEBCAM_MAX_HEIGHT = 720;
+export const buildWebcamFilters = (orientation) => [
+    `scale=-2:'min(ih,${WEBCAM_MAX_HEIGHT})'`,
+    ...(orientation?.rotation === 90 ? ['transpose=clock'] : []),
+    ...(orientation?.rotation === 180 ? ['hflip,vflip'] : []),
+    ...(orientation?.rotation === 270 ? ['transpose=cclock'] : []),
+    ...(orientation?.flipHorizontal ? ['hflip'] : []),
+    ...(orientation?.flipVertical ? ['vflip'] : []),
+].join(',');
+const PROTOCOL_WHITELISTS = {
+    rtsp: 'file,rtsp,tcp,udp,rtp',
+    jpeg: 'file,http,tcp',
+    mjpeg: 'file,http,tcp',
+    h264: 'file,http,https,tcp,tls',
+};
+export const buildFfmpegCommand = ({ cameraFile, kind, orientation, ffmpegFpsModeFlag, }) => {
+    const encodings = {
+        rtsp: '-c copy',
+        jpeg: buildH264Encoding({
+            ffmpegFpsModeFlag,
+            fps: 2,
+        }),
+        mjpeg: buildH264Encoding({
+            ffmpegFpsModeFlag,
+            fps: WEBCAM_MAX_FPS,
+            filters: buildWebcamFilters(orientation),
+            maxrateKbps: 1500,
+        }),
+        h264: '-c copy',
+    };
+    return [
+        'exec:ffmpeg -hide_banner -loglevel error',
+        '-fflags nobuffer -analyzeduration 1000000 -probesize 1000000',
+        '-use_wallclock_as_timestamps 1',
+        `-f concat -safe 0 -protocol_whitelist ${PROTOCOL_WHITELISTS[kind]}`,
+        `-i ${cameraFile}`,
+        `-map 0:v ${encodings[kind]}`,
+        '-rtsp_transport tcp -f rtsp {output}',
+    ].join(' ');
+};
+export const buildGo2rtcConfig = ({ printerId, ports, ffmpegCommand, }) => `${JSON.stringify({
+    streams: {
+        [printerId]: ffmpegCommand,
+    },
+    api: {
+        listen: `127.0.0.1:${ports.apiPort}`,
+        allow_paths: ['/api/ws'],
+    },
+    rtsp: {
+        listen: `127.0.0.1:${ports.rtspPort}`,
+    },
+    webrtc: {
+        listen: '',
+    },
+    srtp: {
+        listen: '',
+    },
+}, null, 2)}\n`;
+export const parseFfmpegMajorVersion = (output) => {
+    const match = output.match(/^ffmpeg version n?(\d+)\./m);
+    return match ? Number(match[1]) : null;
+};
+const defaultDependencies = {
+    spawn: (command, args) => spawn(command, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    }),
+    ensurePrivateDir: path => {
+        mkdirSync(path, {
+            recursive: true,
+        });
+        chmodSync(path, 0o700);
+    },
+    writePrivateFile: (path, content) => {
+        writeFileSync(path, content, {
+            mode: 0o600,
+        });
+        chmodSync(path, 0o600);
+    },
+    findFreePorts: () => findFreeCameraRelayPorts(isPortFree),
+};
+export const createCameraRelay = ({ printerId, printerLabel, go2rtcPath, runtimeDir, ffmpegReadsOptions, ffmpegFpsModeFlag, source, relayKey, registry, }, dependencies = defaultDependencies) => {
+    const configPath = join(runtimeDir, 'go2rtc.json');
+    const cameraFilePath = join(runtimeDir, 'stream.ffconcat');
+    const input = source.openInput();
+    let currentRelayKey = relayKey;
+    let reported;
+    let target = null;
+    let startedCommand = null;
+    let go2rtc = null;
+    let registeredPort = null;
+    let restartTimeoutId;
+    let failures = 0;
+    let startedAt = 0;
+    let isRestarting = false;
+    let isStopping = false;
+    const buildCommand = ({ kind, orientation }) => buildFfmpegCommand({
+        cameraFile: cameraFilePath,
+        kind,
+        orientation,
+        ffmpegFpsModeFlag,
+    });
+    const forward = (output, log) => {
+        if (!output) {
+            return;
+        }
+        createInterface({
+            input: output,
+        }).on('line', line => log(`[camera] ${line}`));
+    };
+    const scheduleStart = (reason) => {
+        failures = Date.now() - startedAt >= 60_000 ? 1 : failures + 1;
+        const delayMs = backoffDelayMs(failures, 5_000, 60_000);
+        console.error(`[camera] ${reason}; starting go2rtc again in ${delayMs / 1000}s`);
+        restartTimeoutId = setTimeout(() => void start(), delayMs);
+    };
+    const start = async () => {
+        startedAt = Date.now();
+        const ports = await dependencies.findFreePorts();
+        if (isStopping || !target) {
+            return;
+        }
+        if (!ports) {
+            const [firstApiPort, lastApiPort] = GO2RTC_API_PORT_RANGE;
+            scheduleStart(`No pair of free ports for go2rtc between ${firstApiPort} and ${lastApiPort}`);
+            return;
+        }
+        startedCommand = buildCommand(target);
+        dependencies.writePrivateFile(configPath, buildGo2rtcConfig({
+            printerId,
+            ports,
+            ffmpegCommand: startedCommand,
+        }));
+        const child = dependencies.spawn(go2rtcPath, ['-config', configPath]);
+        go2rtc = child;
+        registeredPort = ports.apiPort;
+        registry.register(printerId, ports.apiPort, currentRelayKey);
+        console.log(`[camera] Relaying the camera of "${printerLabel}" through go2rtc on 127.0.0.1:${ports.apiPort}, its RTSP on ${ports.rtspPort}`);
+        forward(child.stdout, line => console.log(line));
+        forward(child.stderr, line => console.error(line));
+        child.once('error', error => {
+            console.error('[camera] go2rtc could not start:', error);
+        });
+        child.once('exit', (code, signal) => {
+            go2rtc = null;
+            if (isStopping) {
+                return;
+            }
+            if (isRestarting) {
+                isRestarting = false;
+                void start();
+                return;
+            }
+            scheduleStart(`go2rtc stopped (${signal ?? `exit code ${code}`})`);
+        });
+    };
+    const writeCameraFile = async (report) => {
+        const nextTarget = await input.resolveTarget(report);
+        if (isStopping || !nextTarget || report !== reported) {
+            return;
+        }
+        dependencies.ensurePrivateDir(runtimeDir);
+        dependencies.writePrivateFile(cameraFilePath, buildCameraFile({
+            streamUrl: nextTarget.streamUrl,
+            kind: nextTarget.kind,
+            readsOptions: ffmpegReadsOptions,
+        }));
+        const isFirst = target === null;
+        target = nextTarget;
+        if (isFirst) {
+            void start();
+            return;
+        }
+        if (!go2rtc || isRestarting || buildCommand(nextTarget) === startedCommand) {
+            return;
+        }
+        console.log(`[camera] The camera of "${printerLabel}" is to be read another way; starting go2rtc again for it`);
+        isRestarting = true;
+        void stopChildProcess(go2rtc);
+    };
+    return {
+        update: report => {
+            if (isStopping || !source.hasStream(report) || report === reported) {
+                return;
+            }
+            reported = report;
+            void writeCameraFile(report).catch(error => {
+                console.error('[camera] Could not write the camera file:', error);
+            });
+        },
+        setRelayKey: nextRelayKey => {
+            currentRelayKey = nextRelayKey;
+            if (registeredPort !== null && !isStopping) {
+                registry.register(printerId, registeredPort, currentRelayKey);
+            }
+        },
+        stop: async () => {
+            isStopping = true;
+            clearTimeout(restartTimeoutId);
+            if (target) {
+                registry.unregister(printerId);
+            }
+            await input.close();
+            if (go2rtc) {
+                await stopChildProcess(go2rtc);
+            }
+        },
+    };
+};
+export const fingerprintRelayKey = (relayKey) => createHash('sha256').update(relayKey).digest('hex').slice(0, 16);
+const createDefaultResolveDependencies = () => ({
+    readFfmpegVersion: () => {
+        try {
+            return execFileSync('ffmpeg', ['-version'], {
+                encoding: 'utf8',
+            });
+        }
+        catch {
+            return null;
+        }
+    },
+    isExecutable,
+    findBinaryPins: () => findCameraBinaryPins(process.platform, process.arch, readArmVersion()),
+    ensureBinaries: (cameraDir, pins) => ensureCameraBinaries(cameraDir, pins),
+    createRegistry: () => createCameraRegistry(CAMERA_REGISTRY_DIR),
+    createGateway: registry => createCameraGateway({
+        port: CAMERA_GATEWAY_PORT,
+        registry,
+        reusePort: process.platform === 'linux',
+    }),
+    createRelay: options => createCameraRelay(options),
+    resolveTunnel: options => resolveCameraTunnel(options),
+});
+const CAMERA_ACCESS_REFRESH_MS = 24 * 60 * 60_000;
+export const resolveCameraRelay = ({ printerId, printerLabel, source, workDir, fetchesBinaries, getCameraAccess, printerGone, }, dependencies = createDefaultResolveDependencies()) => {
+    const ffmpegVersion = dependencies.readFfmpegVersion();
+    if (ffmpegVersion === null) {
+        console.log('[camera] Relay off: ffmpeg is not installed');
+        return null;
+    }
+    if (source.encodedCamera && !/--enable-libx264\b/.test(ffmpegVersion)) {
+        console.log(`[camera] Relay off: ffmpeg has no libx264, which ${source.encodedCamera} is encoded to H.264 with`);
+        return null;
+    }
+    const ffmpegMajorVersion = parseFfmpegMajorVersion(ffmpegVersion);
+    const cameraDir = join(workDir, 'camera');
+    const go2rtcPath = join(cameraDir, 'go2rtc');
+    const cloudflaredPath = join(cameraDir, 'cloudflared');
+    const pins = fetchesBinaries ? dependencies.findBinaryPins() : null;
+    if (!fetchesBinaries) {
+        console.log('[camera] VEXTRIX3D_CAMERA_BINARIES=manual: running camera/go2rtc and camera/cloudflared as they are');
+    }
+    else if (!pins) {
+        console.log(`[camera] No go2rtc or cloudflared build is pinned for ${process.platform} ${process.arch}: running camera/go2rtc and camera/cloudflared as they are`);
+    }
+    const relayOptions = {
+        printerId,
+        printerLabel,
+        source,
+        go2rtcPath,
+        runtimeDir: join(cameraDir, 'runtime'),
+        ffmpegReadsOptions: ffmpegMajorVersion === null || ffmpegMajorVersion >= 5,
+        ffmpegFpsModeFlag: ffmpegMajorVersion === null || ffmpegMajorVersion >= 6 ? '-fps_mode' : '-vsync',
+    };
+    let camera = null;
+    let lastAccess = null;
+    let report;
+    let isWaitingForStream = true;
+    let hasReportedNoStream = false;
+    let timeoutId;
+    let accessFailures = 0;
+    let binariesFailures = 0;
+    let binariesDueAt = 0;
+    let isTaskRunning = false;
+    let askedRelayKeyFingerprint = null;
+    let isStopping = false;
+    const run = (task) => {
+        isTaskRunning = true;
+        void task()
+            .catch(error => {
+            console.error('[camera] Could not set the camera up:', error);
+            schedule(refresh, CAMERA_ACCESS_REFRESH_MS);
+        })
+            .finally(() => {
+            isTaskRunning = false;
+        });
+    };
+    const schedule = (task, delayMs) => {
+        if (!isStopping) {
+            timeoutId = setTimeout(() => run(task), delayMs);
+        }
+    };
+    const fetchBinaries = async () => {
+        if (!pins) {
+            return true;
+        }
+        try {
+            return await dependencies.ensureBinaries(cameraDir, pins);
+        }
+        catch (error) {
+            console.error('[camera] Could not fetch go2rtc and cloudflared:', error);
+            return false;
+        }
+    };
+    const startTunnel = (tunnelToken) => dependencies.resolveTunnel({
+        workDir,
+        tunnelToken,
+        printerLabel,
+    });
+    const startCamera = (relayKey, tunnelToken) => {
+        const registry = dependencies.createRegistry();
+        const gateway = dependencies.createGateway(registry);
+        const relay = dependencies.createRelay({
+            ...relayOptions,
+            relayKey,
+            registry,
+        });
+        void gateway.start();
+        camera = {
+            gateway,
+            relay,
+            tunnel: startTunnel(tunnelToken),
+        };
+        if (report !== undefined) {
+            relay.update(report);
+        }
+    };
+    const stopCamera = async () => {
+        const running = camera;
+        camera = null;
+        if (running) {
+            await Promise.all([running.gateway.stop(), running.relay.stop(), running.tunnel?.stop()]);
+        }
+    };
+    const stop = async () => {
+        isStopping = true;
+        clearTimeout(timeoutId);
+        await stopCamera();
+    };
+    const apply = async (access) => {
+        const previous = lastAccess;
+        const { relayKey, tunnelToken } = access;
+        lastAccess = access;
+        if (!relayKey) {
+            if (camera) {
+                console.log('[camera] Relay off: vextrix3d gives this printer no camera key any more');
+                await stopCamera();
+            }
+            else if (!previous || previous.relayKey) {
+                console.log('[camera] Relay off: vextrix3d gives this printer no camera key');
+            }
+            return;
+        }
+        if (!camera) {
+            startCamera(relayKey, tunnelToken);
+            return;
+        }
+        const running = camera;
+        if (relayKey !== previous?.relayKey) {
+            running.relay.setRelayKey(relayKey);
+            console.log('[camera] vextrix3d gave this printer a new relay key, which its streams are checked against from now on');
+        }
+        const isTunnelStale = tunnelToken !== previous?.tunnelToken || (tunnelToken !== null && running.tunnel === null);
+        if (!isTunnelStale) {
+            return;
+        }
+        const previousTunnel = running.tunnel;
+        running.tunnel = null;
+        if (previousTunnel) {
+            console.log(tunnelToken
+                ? '[tunnel] vextrix3d gave this printer a new tunnel token; starting cloudflared again on it'
+                : '[tunnel] vextrix3d gives this printer no camera tunnel any more; stopping cloudflared');
+            await previousTunnel.stop();
+        }
+        if (isStopping || camera !== running || !tunnelToken) {
+            return;
+        }
+        running.tunnel = startTunnel(tunnelToken);
+    };
+    const askForCamera = async (onFailure) => {
+        let access;
+        try {
+            access = await getCameraAccess();
+        }
+        catch (error) {
+            if (printerGone.notice(error)) {
+                await stop();
+            }
+            else {
+                onFailure(error);
+            }
+            return false;
+        }
+        if (isStopping) {
+            return false;
+        }
+        await apply(access);
+        schedule(refresh, CAMERA_ACCESS_REFRESH_MS);
+        return true;
+    };
+    const start = async () => {
+        if (Date.now() >= binariesDueAt) {
+            const isReady = await fetchBinaries();
+            binariesFailures = isReady ? 0 : binariesFailures + 1;
+            binariesDueAt = isReady
+                ? Infinity
+                : Date.now() + backoffDelayMs(binariesFailures, 5_000, 3_600_000);
+        }
+        if (isStopping) {
+            return;
+        }
+        const hasGo2rtc = dependencies.isExecutable(go2rtcPath);
+        if (!pins && !hasGo2rtc) {
+            console.log('[camera] Relay off: there is no camera/go2rtc to run');
+            return;
+        }
+        if (pins && !(hasGo2rtc && dependencies.isExecutable(cloudflaredPath))) {
+            if (binariesDueAt === Infinity) {
+                binariesDueAt = 0;
+            }
+            schedule(start, Math.max(5_000, binariesDueAt - Date.now()));
+            return;
+        }
+        const isAnswered = await askForCamera(error => {
+            accessFailures++;
+            const delayMs = backoffDelayMs(accessFailures, 5_000, 60_000);
+            if (accessFailures === 1) {
+                console.error(`[camera] vextrix3d did not give this printer its camera; asking again in ${delayMs / 1000}s, and on until it does:`, error);
+            }
+            else if (accessFailures % 10 === 0) {
+                console.error(`[camera] vextrix3d has not given this printer its camera in ${accessFailures} tries; asking again every ${delayMs / 1000}s`);
+            }
+            schedule(start, delayMs);
+        });
+        if (isAnswered && accessFailures) {
+            console.log(`[camera] vextrix3d gave this printer its camera after ${accessFailures + 1} tries`);
+            accessFailures = 0;
+        }
+    };
+    const refresh = async () => {
+        await fetchBinaries();
+        if (isStopping) {
+            return;
+        }
+        await askForCamera(error => {
+            console.error('[camera] Could not ask vextrix3d for the camera again, which runs on as it is; asking again in a day:', error);
+            schedule(refresh, CAMERA_ACCESS_REFRESH_MS);
+        });
+    };
+    const noteRelayKeyFingerprint = (reportedFingerprint) => {
+        const heldFingerprint = lastAccess?.relayKey ? fingerprintRelayKey(lastAccess.relayKey) : null;
+        const isAskDue = typeof reportedFingerprint === 'string' &&
+            lastAccess !== null &&
+            reportedFingerprint !== heldFingerprint &&
+            reportedFingerprint !== askedRelayKeyFingerprint;
+        if (!isAskDue || isTaskRunning || isStopping) {
+            return;
+        }
+        askedRelayKeyFingerprint = reportedFingerprint;
+        console.log("[camera] vextrix3d names another key for this printer's camera - asking for its new tunnel and key now, ahead of the daily ask");
+        clearTimeout(timeoutId);
+        run(async () => {
+            await askForCamera(error => {
+                console.error('[camera] Could not ask vextrix3d for the camera again, which runs on as it is; asking again with the next state report:', error);
+                askedRelayKeyFingerprint = null;
+                schedule(refresh, CAMERA_ACCESS_REFRESH_MS);
+            });
+        });
+    };
+    return {
+        noteRelayKeyFingerprint,
+        update: nextReport => {
+            report = nextReport;
+            if (isStopping) {
+                return;
+            }
+            if (!isWaitingForStream) {
+                camera?.relay.update(nextReport);
+                return;
+            }
+            if (source.hasStream(nextReport)) {
+                isWaitingForStream = false;
+                const description = source.describeStream(nextReport);
+                if (description) {
+                    console.log(`[camera] ${description}`);
+                }
+                run(start);
+                return;
+            }
+            if (nextReport !== undefined && !hasReportedNoStream) {
+                hasReportedNoStream = true;
+                console.log(`[camera] ${source.describeNoStream(nextReport)}`);
+            }
+        },
+        stop,
+    };
+};

package/dist/camera-stream-bridge.js

@@ -0,0 +1,58 @@
+import { readFileSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { CameraStreamConnection } from './camera-stream-connection.js';
+export const createCameraStreamBridge = ({ serialNumber, caFile, printerLabel, }) => {
+    const ca = readFileSync(caFile);
+    const connections = new Set();
+    let target = null;
+    let reportedFailure = null;
+    const bridge = (ffmpeg) => {
+        if (!target) {
+            ffmpeg.destroy();
+            return;
+        }
+        const { host, port } = target;
+        const connection = new CameraStreamConnection(ffmpeg, {
+            host,
+            port,
+            serialNumber,
+            ca,
+            onOpen: () => {
+                reportedFailure = null;
+            },
+            onFailure: error => {
+                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),
+        });
+        connections.add(connection);
+    };
+    const server = createServer(bridge);
+    const port = new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen({
+            host: '127.0.0.1',
+            port: 0,
+        }, () => {
+            const address = server.address();
+            resolve(typeof address === 'object' && address ? address.port : 0);
+        });
+    });
+    return {
+        port,
+        setTarget: (host, targetPort) => {
+            target = {
+                host,
+                port: targetPort,
+            };
+        },
+        close: () => new Promise(resolve => {
+            connections.forEach(connection => connection.close());
+            server.close(() => resolve());
+        }),
+    };
+};

package/dist/camera-stream-connection.js

@@ -0,0 +1,84 @@
+import { connect } from 'node:tls';
+export const checkPrinterCertificate = (serialNumber) => (_hostname, certificate) => {
+    const commonName = certificate.subject?.CN;
+    return commonName === serialNumber
+        ? undefined
+        : new Error(`its certificate is issued to ${commonName || 'nobody'}, not ${serialNumber}`);
+};
+const toRtspsRequestLine = (head) => head.replace(/^([A-Z_]+) rtsp:\/\//, '$1 rtsps://');
+export const createRtspRequestRewriter = (write) => {
+    let pending = Buffer.alloc(0);
+    return (chunk) => {
+        pending = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+        while (pending.length) {
+            if (pending[0] === 0x24) {
+                if (pending.length < 4) {
+                    return;
+                }
+                const frameSize = 4 + pending.readUInt16BE(2);
+                if (pending.length < frameSize) {
+                    return;
+                }
+                write(pending.subarray(0, frameSize));
+                pending = pending.subarray(frameSize);
+                continue;
+            }
+            const headEnd = pending.indexOf('\r\n\r\n');
+            if (headEnd < 0) {
+                return;
+            }
+            const head = pending.toString('latin1', 0, headEnd + 4);
+            const bodySize = Number(/^content-length:\s*(\d+)/im.exec(head)?.[1] ?? 0);
+            const requestSize = headEnd + 4 + bodySize;
+            if (pending.length < requestSize) {
+                return;
+            }
+            write(Buffer.concat([
+                Buffer.from(toRtspsRequestLine(head), 'latin1'),
+                pending.subarray(headEnd + 4, requestSize),
+            ]));
+            pending = pending.subarray(requestSize);
+        }
+    };
+};
+export class CameraStreamConnection {
+    ffmpeg;
+    printer;
+    isClosed = false;
+    constructor(ffmpeg, { host, port, serialNumber, ca, onOpen, onFailure, onClose }) {
+        this.ffmpeg = ffmpeg;
+        this.printer = connect({
+            host,
+            port,
+            servername: serialNumber,
+            ca,
+            checkServerIdentity: checkPrinterCertificate(serialNumber),
+        });
+        this.printer.once('secureConnect', onOpen);
+        this.printer.on('error', error => {
+            onFailure(error);
+            this.close();
+        });
+        this.ffmpeg.on('error', () => this.close());
+        let openSides = 2;
+        const closeSide = () => {
+            this.close();
+            openSides -= 1;
+            if (!openSides) {
+                onClose();
+            }
+        };
+        this.ffmpeg.once('close', closeSide);
+        this.printer.once('close', closeSide);
+        this.ffmpeg.on('data', createRtspRequestRewriter(chunk => this.printer.write(chunk)));
+        this.printer.pipe(this.ffmpeg);
+    }
+    close() {
+        if (this.isClosed) {
+            return;
+        }
+        this.isClosed = true;
+        this.ffmpeg.destroy();
+        this.printer.destroy();
+    }
+}