@vextrix3d/machine-agent 0.0.0-stage → 2.1.0

package/dist/camera-binaries.js

@@ -0,0 +1,185 @@
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { chmodSync, createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { join } from 'node:path';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { promisify } from 'node:util';
+import { describeError, sha256File } from './utils.js';
+const GO2RTC_VERSION = 'v1.9.14';
+const CLOUDFLARED_VERSION = '2026.10.7';
+const pinGo2rtc = (file, sha256) => ({
+    name: 'go2rtc',
+    version: GO2RTC_VERSION,
+    file,
+    url: `https://github.com/AlexxIT/go2rtc/releases/download/${GO2RTC_VERSION}/${file}`,
+    sha256,
+    packing: file.endsWith('.zip') ? 'zip' : 'raw',
+});
+const pinCloudflared = (file, sha256) => ({
+    name: 'cloudflared',
+    version: CLOUDFLARED_VERSION,
+    file,
+    url: `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARED_VERSION}/${file}`,
+    sha256,
+    packing: file.endsWith('.tgz') ? 'tgz' : 'raw',
+});
+const LINUX_ARM_CLOUDFLARED_PIN = pinCloudflared('cloudflared-linux-arm', '74f690f6707182839b63e0465726c7776dd63f0a174390b911d5d71f35cab94e');
+const CAMERA_BINARY_PINS = {
+    'linux-arm64': [
+        pinGo2rtc('go2rtc_linux_arm64', '359fabade8a7a51e81a55fe6df6b0ef81764a5e1d63179577534eaaa71904b50'),
+        pinCloudflared('cloudflared-linux-arm64', '3df43aedc9ff291d1735b5cb576cb97e0b157488796db2e32b28aecabb445775'),
+    ],
+    'linux-arm': [
+        pinGo2rtc('go2rtc_linux_arm', '4d7e1639af5a2722a28e864468fd8099b3c1682565446c798bf9e3b38fde12e4'),
+        LINUX_ARM_CLOUDFLARED_PIN,
+    ],
+    'linux-x64': [
+        pinGo2rtc('go2rtc_linux_amd64', '32d616af226bd731678ffde328b94cfb94e30339bfefc469cfb76323144615a6'),
+        pinCloudflared('cloudflared-linux-amd64', '1f99fb518b83dec2ba8d870a7cc991d82a77e6196295a3d2754ba17ab9f91872'),
+    ],
+    'darwin-arm64': [
+        pinGo2rtc('go2rtc_mac_arm64.zip', '919b78adc759d6b3883d1e1b2ac915ac0985bb903ff1897b4d228527bd64690c'),
+        pinCloudflared('cloudflared-darwin-arm64.tgz', '3586ccf397e98e5f437e60e7c307ca6ac463e110580503af8bb8e6f9ebf831bd'),
+    ],
+    'darwin-x64': [
+        pinGo2rtc('go2rtc_mac_amd64.zip', '9b0b9a27a4dc3a5b8b93376e7e8fc2787c6af624a512842622be84aec0171c7a'),
+        pinCloudflared('cloudflared-darwin-amd64.tgz', '02f3edfd87684dd5b705607688e4eb4b323f6e777b81e7b3a85af556aa356848'),
+    ],
+};
+const LINUX_ARMV6_PINS = [
+    pinGo2rtc('go2rtc_linux_armv6', '4dc20370556b29f3a90f4c7a09dcd95472c8f74cca56d4d1fb91f32bdd15174c'),
+    LINUX_ARM_CLOUDFLARED_PIN,
+];
+export const findCameraBinaryPins = (platform, arch, armVersion) => {
+    if (platform === 'linux' && arch === 'arm') {
+        if (armVersion === '6') {
+            return LINUX_ARMV6_PINS;
+        }
+        if (armVersion !== '7') {
+            console.log(`[camera] Node reports ARM version ${armVersion || 'none'} - fetching go2rtc and cloudflared for ARMv7`);
+        }
+    }
+    const key = `${platform}-${arch}`;
+    return Object.hasOwn(CAMERA_BINARY_PINS, key) ? CAMERA_BINARY_PINS[key] : null;
+};
+const execFileAsync = promisify(execFile);
+export const unpackArchiveEntry = async (archivePath, name, dir) => {
+    try {
+        await execFileAsync('tar', ['-xf', archivePath, '-C', dir, name]);
+    }
+    catch (error) {
+        const reason = error.stderr?.trim().split('\n')[0];
+        throw new Error(`tar could not unpack ${name}${reason ? ` (${reason})` : ''}`, {
+            cause: error,
+        });
+    }
+};
+export const resolveCameraBinarySourcePath = (binaryPath) => `${binaryPath}.pin.json`;
+const isPinnedBuild = async (path, pin) => {
+    try {
+        if (pin.packing === 'raw') {
+            return (await sha256File(path)) === pin.sha256;
+        }
+        const source = JSON.parse(readFileSync(resolveCameraBinarySourcePath(path), 'utf8'));
+        return (source.archiveSha256 === pin.sha256 &&
+            typeof source.sha256 === 'string' &&
+            (await sha256File(path)) === source.sha256);
+    }
+    catch {
+        return false;
+    }
+};
+const defaultDependencies = {
+    fetch: (url, init) => fetch(url, init),
+    timeoutMs: 10 * 60_000,
+    unpack: unpackArchiveEntry,
+};
+const download = async (url, path, { fetch, timeoutMs }) => {
+    const response = await fetch(url, {
+        redirect: 'follow',
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response.ok || !response.body) {
+        throw new Error(`GitHub answered ${response.status} ${response.statusText}`.trim());
+    }
+    const hash = createHash('sha256');
+    await pipeline(Readable.from(response.body), new Transform({
+        transform(chunk, _encoding, callback) {
+            hash.update(chunk);
+            callback(null, chunk);
+        },
+    }), createWriteStream(path, {
+        mode: 0o600,
+    }));
+    return hash.digest('hex');
+};
+const ensureCameraBinary = async (cameraDir, pin, dependencies) => {
+    const path = join(cameraDir, pin.name);
+    if (await isPinnedBuild(path, pin)) {
+        if ((statSync(path).mode & 0o111) === 0) {
+            chmodSync(path, 0o755);
+        }
+        return;
+    }
+    const hadFile = existsSync(path);
+    const downloadPath = `${path}.download`;
+    const unpackedPath = `${path}.unpacked`;
+    const removeLeftovers = () => {
+        rmSync(downloadPath, {
+            force: true,
+        });
+        rmSync(unpackedPath, {
+            recursive: true,
+            force: true,
+        });
+    };
+    mkdirSync(cameraDir, {
+        recursive: true,
+    });
+    removeLeftovers();
+    try {
+        const sha256 = await download(pin.url, downloadPath, dependencies);
+        if (sha256 !== pin.sha256) {
+            throw new Error(`its SHA-256 is ${sha256}, not the pinned ${pin.sha256} - deleted unrun`);
+        }
+        if (pin.packing === 'raw') {
+            chmodSync(downloadPath, 0o755);
+            renameSync(downloadPath, path);
+        }
+        else {
+            mkdirSync(unpackedPath);
+            await dependencies.unpack(downloadPath, pin.name, unpackedPath);
+            const unpackedBinaryPath = join(unpackedPath, pin.name);
+            const source = {
+                file: pin.file,
+                version: pin.version,
+                archiveSha256: pin.sha256,
+                sha256: await sha256File(unpackedBinaryPath),
+            };
+            chmodSync(unpackedBinaryPath, 0o755);
+            renameSync(unpackedBinaryPath, path);
+            writeFileSync(resolveCameraBinarySourcePath(path), `${JSON.stringify(source, null, 2)}\n`);
+        }
+    }
+    finally {
+        removeLeftovers();
+    }
+    console.log(`[camera] ${hadFile
+        ? `Replaced camera/${pin.name} with ${pin.name} ${pin.version}`
+        : `Fetched ${pin.name} ${pin.version} into camera/${pin.name}`} (${pin.file}, its SHA-256 checked)`);
+};
+export const ensureCameraBinaries = async (cameraDir, pins, dependencies = defaultDependencies) => {
+    let isReady = true;
+    for (const pin of pins) {
+        try {
+            await ensureCameraBinary(cameraDir, pin, dependencies);
+        }
+        catch (error) {
+            isReady = false;
+            const path = join(cameraDir, pin.name);
+            console.error(`[camera] Could not fetch ${pin.name} ${pin.version} (${pin.file}): ${describeError(error)}; ${existsSync(path) ? `the camera/${pin.name} there is used meanwhile` : 'trying again later'}`);
+        }
+    }
+    return isReady;
+};

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-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,19 @@
+import { readFileSync } from 'node:fs';
+import { createCameraFrameBridge } from './camera-frame-bridge.js';
+import { CameraJpegConnection } from './camera-jpeg-connection.js';
+export const createCameraJpegBridge = ({ host, port, serialNumber, accessCode, caFile, printerLabel, }) => {
+    const ca = readFileSync(caFile);
+    return createCameraFrameBridge({
+        open: handlers => new CameraJpegConnection({
+            host,
+            port,
+            serialNumber,
+            accessCode,
+            ca,
+            ...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

@@ -0,0 +1,121 @@
+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',
+    '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;
+            if (!isJpeg(frame)) {
+                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();
+    }
+}