@jetforge/zebra-bridge 1.0.0

package/README.md

@@ -0,0 +1,144 @@
+# Zebra Bridge for JetForge
+
+Bridge service for one Zebra handheld barcode scanner connected over a serial COM port. It reads each scan from the configured serial port and sends the scanned value to JetForge as the plain bridge command `barcode`.
+
+The scanner does not need to send a newline. The bridge uses an inter-byte idle timeout to treat one burst of bytes as one scanned value.
+
+## Running
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+PowerShell example for the current scanner on `COM11`:
+
+```powershell
+$env:BRIDGE_TOKEN="jf_..."
+$env:SERIAL_PATH="COM11"
+npm start
+```
+
+Supported environment variables:
+
+| Variable | Default | Meaning |
+| --- | --- | --- |
+| `BRIDGE_TOKEN` | required | JetForge bridge endpoint token |
+| `SERIAL_PATH` | required | Serial port path, for example `COM11` |
+| `SERIAL_BAUD_RATE` | `9600` | Serial baud rate |
+
+All other bridge settings are fixed in code:
+
+| Setting | Value |
+| --- | --- |
+| HTTP base URL | `https://my.jetforge.app` |
+| WebSocket URL | `wss://my.jetforge.app/bridge-ws/` |
+| Scan idle timeout | `75ms` |
+| Scan max buffer size | `2048` bytes |
+| Barcode queue max size | `500` |
+| Barcode queue retry interval | `5000ms` |
+| Log barcode values | `false` |
+
+List detected serial ports:
+
+```bash
+npm run list-ports
+```
+
+Simulate one scan without opening a serial port:
+
+```bash
+node src/server.js --simulate ABC123
+```
+
+## Bridge Protocol
+
+The bridge authenticates to JetForge bridge websocket with:
+
+```http
+Authorization: Bearer jf_<endpoint_id>_<secret>
+```
+
+After `bridge.init`, it sends periodic `heartbeat` messages. For each scan it sends:
+
+```json
+{
+  "type": "barcode",
+  "payload": {
+    "value": "ABC123",
+    "time": 1781860000
+  }
+}
+```
+
+If the WebSocket is unavailable, the bridge falls back to `POST /ips/bridge/` with:
+
+```json
+{
+  "command": "barcode",
+  "payload": {
+    "value": "ABC123",
+    "time": 1781860000
+  }
+}
+```
+
+Runtime diagnostics are appended to `logs/bridge-debug.log`. Bridge tokens are redacted. Barcode values are not logged.
+
+## JetForge Server Update Needed
+
+This repository does not modify JetForge. The Zebra endpoint on the JetForge side should handle the bridge command `barcode`, then publish the existing UI websocket event `scanner.barcode`.
+
+Suggested shape for `Oms\Models\Bridge\Vendor\Zebra\Scanner`:
+
+```php
+public function receiveCommand(string $command, array $payload = []): array
+{
+	if ($command === "barcode")
+	{
+		return $this->receiveBarcode($payload);
+	}
+
+	return parent::receiveCommand($command, $payload);
+}
+
+private function receiveBarcode(array $payload): array
+{
+	$this->attendedAt = time();
+	$this->update();
+
+	$value = trim((string) ($payload["value"] ?? ""));
+	if ($value === "")
+	{
+		throw new \InvalidArgumentException("Barcode value is not specified");
+	}
+
+	$time = (int) ($payload["time"] ?? time());
+
+	\Oms\Models\Bridge\Log::write($this, null, \Oms\Models\Bridge\LogDirection::Incoming, "barcode", [
+		"value" => $value,
+		"time" => $time,
+	]);
+
+	$event = [
+		"type" => "scanner.barcode",
+		"farm_id" => $this->farmId,
+		"payload" => [
+			"value" => $value,
+			"scanner_id" => $this->id,
+			"time" => $time,
+		],
+	];
+
+	$json = json_encode($event, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
+	\__::$sql->query("NOTIFY ui_ws_event, " . \__::$sql->dbo->wrapScalar($json));
+
+	return [
+		"status" => "ok",
+		"value" => $value,
+	];
+}
+```
+
+The bridge command stays unscoped as `barcode`; only the UI websocket event remains `scanner.barcode`.

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@jetforge/zebra-bridge",
+  "version": "1.0.0",
+  "description": "Zebra barcode scanner bridge for JetForge",
+  "main": "src/server.js",
+  "bin": {
+    "zebra-bridge": "src/server.js"
+  },
+  "author": "Smart Dynamics SIA",
+  "type": "module",
+  "files": [
+    "src"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "start": "node src/server.js",
+    "list-ports": "node src/server.js --list-ports"
+  },
+  "dependencies": {
+    "@serialport/parser-inter-byte-timeout": "^12.0.0",
+    "axios": "^1.7.2",
+    "serialport": "^12.0.0",
+    "ws": "^8.18.0"
+  }
+}

package/src/jetforge-bridge-client.js

@@ -0,0 +1,297 @@
+import axios from "axios";
+import WebSocket from "ws";
+
+const heartbeatInterval = 30000;
+const reconnectMinDelay = 1000;
+const reconnectMaxDelay = 30000;
+
+export default class JetForgeBridgeClient {
+	constructor({token, httpBaseUrl, wsUrl, onCommand, onReady, logger}) {
+		if (!token) {
+			throw new Error("BRIDGE_TOKEN is required");
+		}
+
+		this.token = token;
+		this.httpBaseUrl = httpBaseUrl;
+		this.wsUrl = wsUrl;
+		this.onCommand = onCommand;
+		this.onReady = onReady;
+		this.ws = null;
+		this.heartbeatTimer = null;
+		this.reconnectTimer = null;
+		this.reconnectDelay = reconnectMinDelay;
+		this.shouldReconnect = true;
+		this.logger = logger;
+
+		this.axiosInstance = axios.create({
+			baseURL: httpBaseUrl,
+			timeout: 30000,
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json"
+			}
+		});
+	}
+
+	start() {
+		this.connect();
+	}
+
+	connect() {
+		if (this.ws && [WebSocket.CONNECTING, WebSocket.OPEN].includes(this.ws.readyState)) {
+			return;
+		}
+
+		this.log("info", "endpoint.websocket.connecting", {
+			wsUrl: this.wsUrl
+		});
+
+		this.ws = new WebSocket(this.wsUrl, {
+			headers: {
+				Authorization: `Bearer ${this.token}`
+			},
+			handshakeTimeout: 15000
+		});
+
+		this.ws.on("open", () => {
+			this.reconnectDelay = reconnectMinDelay;
+			this.log("info", "endpoint.websocket.opened");
+		});
+
+		this.ws.on("message", data => {
+			this.handleMessage(data).catch(error => {
+				this.log("error", "endpoint.websocket.message_handler_failed", {
+					error
+				});
+			});
+		});
+
+		this.ws.on("close", (code, reason) => {
+			const reasonText = reason?.toString?.() || "";
+			this.log("error", "endpoint.websocket.closed", {
+				code,
+				reason: reasonText
+			});
+			this.stopHeartbeat();
+			this.ws = null;
+			this.scheduleReconnect();
+		});
+
+		this.ws.on("error", error => {
+			this.log("error", "endpoint.websocket.error", {
+				error
+			});
+		});
+	}
+
+	async handleMessage(data) {
+		let message;
+
+		try {
+			message = JSON.parse(data.toString());
+		} catch (error) {
+			this.log("error", "endpoint.websocket.invalid_json", {
+				error
+			});
+			return;
+		}
+
+		if (message.type === "bridge.init") {
+			this.log("info", "endpoint.initialized", {
+				endpointId: message.endpoint_id,
+				serverTime: message.time
+			});
+			this.startHeartbeat();
+			await this.onReady?.(message);
+			return;
+		}
+
+		if (message.type === "response") {
+			this.log("info", "endpoint.websocket.response", {
+				id: message.id ?? null
+			});
+			return;
+		}
+
+		if (message.type === "error") {
+			this.log("error", "endpoint.websocket.backend_error", {
+				message: message.message || "unknown error",
+				id: message.id ?? null
+			});
+			return;
+		}
+
+		if (message.type !== "command" || !message.id) {
+			this.log("info", "endpoint.websocket.service_message_ignored", {
+				type: message.type || "unknown"
+			});
+			return;
+		}
+
+		await this.onCommand?.(message);
+	}
+
+	startHeartbeat() {
+		this.stopHeartbeat();
+		this.sendHeartbeat();
+		this.heartbeatTimer = setInterval(() => {
+			this.sendHeartbeat();
+		}, heartbeatInterval);
+	}
+
+	stopHeartbeat() {
+		if (this.heartbeatTimer) {
+			clearInterval(this.heartbeatTimer);
+			this.heartbeatTimer = null;
+		}
+	}
+
+	sendHeartbeat() {
+		this.sendOverWebSocket({
+			type: "heartbeat",
+			payload: {}
+		}).catch(error => {
+			this.log("error", "endpoint.heartbeat.failed", {
+				error
+			});
+		});
+	}
+
+	scheduleReconnect() {
+		if (!this.shouldReconnect || this.reconnectTimer) {
+			return;
+		}
+
+		const delay = this.reconnectDelay;
+		this.reconnectDelay = Math.min(this.reconnectDelay * 2, reconnectMaxDelay);
+
+		this.log("info", "endpoint.websocket.reconnect_scheduled", {
+			delay
+		});
+
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.connect();
+		}, delay);
+	}
+
+	sendOverWebSocket(message) {
+		return new Promise((resolve, reject) => {
+			if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+				reject(new Error("JetForge bridge websocket is not open"));
+				return;
+			}
+
+			this.ws.send(JSON.stringify(message), error => {
+				if (error) {
+					reject(error);
+					return;
+				}
+
+				resolve();
+			});
+		});
+	}
+
+	async postBridgeCommand(command, payload = {}) {
+		const response = await this.axiosInstance.post("/ips/bridge/", {
+			command,
+			payload
+		});
+
+		return response.data;
+	}
+
+	async sendBridgeMessage(type, payload = {}) {
+		try {
+			await this.sendOverWebSocket({
+				type,
+				payload
+			});
+
+			return {
+				transport: "websocket"
+			};
+		} catch (websocketError) {
+			this.log("error", "endpoint.message.websocket_failed", {
+				type,
+				error: websocketError
+			});
+
+			const response = await this.postBridgeCommand(type, payload);
+
+			return {
+				transport: "http",
+				response
+			};
+		}
+	}
+
+	sendBarcode(value, {time = Math.floor(Date.now() / 1000)} = {}) {
+		return this.sendBridgeMessage("barcode", {
+			value,
+			time
+		});
+	}
+
+	async sendCommandStatus(type, commandId, payload = {}) {
+		const statusPayload = {
+			command_id: commandId,
+			...payload
+		};
+
+		try {
+			await this.sendOverWebSocket({
+				type,
+				payload: statusPayload
+			});
+		} catch (error) {
+			this.log("error", "endpoint.command_status.websocket_failed", {
+				type,
+				commandId,
+				error
+			});
+			await this.postBridgeCommand(type, statusPayload);
+		}
+	}
+
+	ackCommand(commandId) {
+		return this.sendCommandStatus("command.ack", commandId);
+	}
+
+	failCommand(commandId, error) {
+		return this.sendCommandStatus("command.failed", commandId, {
+			error: error instanceof Error ? error.message : String(error || "Command failed")
+		});
+	}
+
+	close() {
+		this.shouldReconnect = false;
+		this.stopHeartbeat();
+
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+
+		if (this.ws) {
+			this.ws.close();
+			this.ws = null;
+		}
+	}
+
+	log(level, event, data = {}) {
+		if (this.logger) {
+			this.logger[level]?.(event, data);
+			return;
+		}
+
+		const message = `${level.toUpperCase()} ${event}`;
+		if (level === "error") {
+			console.error(message, data);
+			return;
+		}
+
+		console.log(message, data);
+	}
+}

package/src/logger.js

@@ -0,0 +1,70 @@
+import fs from "fs";
+import path from "path";
+
+export default class Logger {
+	constructor({filePath = path.resolve(process.cwd(), "logs", "bridge-debug.log")} = {}) {
+		this.filePath = filePath;
+		fs.mkdirSync(path.dirname(this.filePath), {recursive: true});
+	}
+
+	info(event, data = {}) {
+		this.write("info", event, data);
+	}
+
+	error(event, data = {}) {
+		this.write("error", event, data);
+	}
+
+	write(level, event, data = {}) {
+		const entry = {
+			...sanitize(data),
+			time: new Date().toISOString(),
+			level,
+			event
+		};
+
+		const line = JSON.stringify(entry);
+		fs.appendFileSync(this.filePath, `${line}\n`);
+
+		const message = `[${entry.time}] ${level.toUpperCase()} ${event}`;
+		if (level === "error") {
+			console.error(message, sanitize(data));
+			return;
+		}
+
+		console.log(message, sanitize(data));
+	}
+}
+
+function sanitize(value) {
+	if (value instanceof Error) {
+		return {
+			message: value.message,
+			stack: value.stack
+		};
+	}
+
+	if (Array.isArray(value)) {
+		return value.map(sanitize);
+	}
+
+	if (!value || typeof value !== "object") {
+		return value;
+	}
+
+	const result = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (isSecretKey(key)) {
+			result[key] = "[redacted]";
+			continue;
+		}
+
+		result[key] = sanitize(item);
+	}
+
+	return result;
+}
+
+function isSecretKey(key) {
+	return /token|secret|password|authorization/i.test(key);
+}

package/src/serial-scanner.js

@@ -0,0 +1,187 @@
+import {InterByteTimeoutParser} from "@serialport/parser-inter-byte-timeout";
+import {SerialPort} from "serialport";
+
+const reconnectMinDelay = 1000;
+const reconnectMaxDelay = 10000;
+
+export default class SerialScanner {
+	constructor({path, baudRate, idleMs, maxBufferSize, onBarcode, logger, logBarcodeValue = false}) {
+		if (!path) {
+			throw new Error("SERIAL_PATH is required");
+		}
+
+		this.path = path;
+		this.baudRate = baudRate;
+		this.idleMs = idleMs;
+		this.maxBufferSize = maxBufferSize;
+		this.onBarcode = onBarcode;
+		this.logger = logger;
+		this.logBarcodeValue = logBarcodeValue;
+		this.port = null;
+		this.parser = null;
+		this.reconnectTimer = null;
+		this.reconnectDelay = reconnectMinDelay;
+		this.shouldReconnect = true;
+	}
+
+	static listPorts() {
+		return SerialPort.list();
+	}
+
+	start() {
+		this.shouldReconnect = true;
+		this.open();
+	}
+
+	open() {
+		if (this.port?.isOpen) {
+			return;
+		}
+
+		this.log("info", "scanner.serial.opening", {
+			path: this.path,
+			baudRate: this.baudRate,
+			idleMs: this.idleMs
+		});
+
+		const port = new SerialPort({
+			path: this.path,
+			baudRate: this.baudRate,
+			autoOpen: false
+		});
+
+		this.port = port;
+		this.parser = port.pipe(new InterByteTimeoutParser({
+			interval: this.idleMs,
+			maxBufferSize: this.maxBufferSize
+		}));
+
+		this.parser.on("data", data => this.handleData(data));
+
+		port.on("error", error => {
+			this.log("error", "scanner.serial.error", {
+				path: this.path,
+				error
+			});
+		});
+
+		port.on("close", () => {
+			this.log("error", "scanner.serial.closed", {
+				path: this.path
+			});
+			this.port = null;
+			this.parser = null;
+			this.scheduleReconnect();
+		});
+
+		port.open(error => {
+			if (error) {
+				this.log("error", "scanner.serial.open_failed", {
+					path: this.path,
+					error
+				});
+				this.port = null;
+				this.parser = null;
+				this.scheduleReconnect();
+				return;
+			}
+
+			this.reconnectDelay = reconnectMinDelay;
+			this.log("info", "scanner.serial.opened", {
+				path: this.path,
+				baudRate: this.baudRate
+			});
+		});
+	}
+
+	handleData(data) {
+		const value = normalizeBarcode(data);
+
+		if (!value) {
+			this.log("info", "scanner.barcode.empty_ignored", {
+				byteLength: data.length
+			});
+			return;
+		}
+
+		this.log("info", "scanner.barcode.read", {
+			byteLength: data.length,
+			length: value.length,
+			...(this.logBarcodeValue ? {value} : {})
+		});
+
+		Promise.resolve(this.onBarcode?.(value, {
+			byteLength: data.length
+		})).catch(error => {
+			this.log("error", "scanner.barcode.handler_failed", {
+				error
+			});
+		});
+	}
+
+	scheduleReconnect() {
+		if (!this.shouldReconnect || this.reconnectTimer) {
+			return;
+		}
+
+		const delay = this.reconnectDelay;
+		this.reconnectDelay = Math.min(this.reconnectDelay * 2, reconnectMaxDelay);
+
+		this.log("info", "scanner.serial.reconnect_scheduled", {
+			path: this.path,
+			delay
+		});
+
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.open();
+		}, delay);
+	}
+
+	close() {
+		this.shouldReconnect = false;
+
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+
+		if (!this.port) {
+			return;
+		}
+
+		const port = this.port;
+		this.port = null;
+		this.parser = null;
+
+		if (port.isOpen) {
+			port.close();
+			return;
+		}
+
+		port.destroy?.();
+	}
+
+	log(level, event, data = {}) {
+		if (this.logger) {
+			this.logger[level]?.(event, data);
+			return;
+		}
+
+		const message = `${level.toUpperCase()} ${event}`;
+		if (level === "error") {
+			console.error(message, data);
+			return;
+		}
+
+		console.log(message, data);
+	}
+}
+
+export function normalizeBarcode(data) {
+	return data
+		.toString("utf8")
+		.replace(/\0/g, "")
+		.replace(/[\r\n]+$/g, "")
+		.trim();
+}

package/src/server.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import Worker from "./worker.js";
+import SerialScanner from "./serial-scanner.js";
+import JetForgeBridgeClient from "./jetforge-bridge-client.js";
+import Logger from "./logger.js";
+
+const httpBaseUrl = "https://my.jetforge.app";
+const wsUrl = "wss://my.jetforge.app/bridge-ws/";
+const defaultSerialBaudRate = 9600;
+const scanIdleMs = 75;
+const scanMaxBufferSize = 2048;
+const queueMaxSize = 500;
+const queueRetryMs = 5000;
+const logBarcodeValue = false;
+
+const args = process.argv.slice(2);
+
+if (args.includes("--list-ports")) {
+	const ports = await SerialScanner.listPorts();
+	console.log(JSON.stringify(ports, null, 2));
+	process.exit(0);
+}
+
+if (args.includes("--simulate")) {
+	const value = args[args.indexOf("--simulate") + 1];
+	if (!value) {
+		console.error("Usage: zebra-bridge --simulate <barcode-value>");
+		process.exit(1);
+	}
+
+	const settings = readSettings({requireSerial: false});
+	const logger = new Logger();
+	const bridge = new JetForgeBridgeClient({
+		token: settings.token,
+		httpBaseUrl: settings.httpBaseUrl,
+		wsUrl: settings.wsUrl,
+		logger
+	});
+
+	try {
+		const result = await bridge.sendBarcode(value);
+		logger.info("scanner.barcode.simulated", {
+			transport: result.transport
+		});
+	} finally {
+		bridge.close();
+	}
+
+	process.exit(0);
+}
+
+const worker = new Worker(readSettings());
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+	process.on(signal, () => {
+		worker.close();
+		process.exit(0);
+	});
+}
+
+function readSettings({requireSerial = true} = {}) {
+	const token = process.env.BRIDGE_TOKEN;
+	const serialPath = process.env.SERIAL_PATH || "";
+
+	if (requireSerial && !serialPath) {
+		throw new Error("SERIAL_PATH is required, for example SERIAL_PATH=COM11");
+	}
+
+	return {
+		httpBaseUrl,
+		wsUrl,
+		token,
+		serialPath,
+		serialBaudRate: readInteger("SERIAL_BAUD_RATE", defaultSerialBaudRate),
+		scanIdleMs,
+		scanMaxBufferSize,
+		queueMaxSize,
+		queueRetryMs,
+		logBarcodeValue
+	};
+}
+
+function readInteger(name, defaultValue) {
+	const rawValue = process.env[name];
+	if (rawValue === undefined || rawValue === "") {
+		return defaultValue;
+	}
+
+	const value = Number(rawValue);
+	if (!Number.isInteger(value) || value <= 0) {
+		throw new Error(`${name} must be a positive integer`);
+	}
+
+	return value;
+}

package/src/worker.js

@@ -0,0 +1,151 @@
+import JetForgeBridgeClient from "./jetforge-bridge-client.js";
+import Logger from "./logger.js";
+import SerialScanner from "./serial-scanner.js";
+
+export default class Worker {
+	constructor(settings) {
+		this.settings = settings;
+		this.logger = new Logger();
+		this.queue = [];
+		this.isFlushing = false;
+		this.retryTimer = null;
+
+		this.bridge = new JetForgeBridgeClient({
+			token: settings.token,
+			httpBaseUrl: settings.httpBaseUrl,
+			wsUrl: settings.wsUrl,
+			onCommand: message => this.handleCommand(message),
+			onReady: () => this.flushQueue(),
+			logger: this.logger
+		});
+
+		this.scanner = new SerialScanner({
+			path: settings.serialPath,
+			baudRate: settings.serialBaudRate,
+			idleMs: settings.scanIdleMs,
+			maxBufferSize: settings.scanMaxBufferSize,
+			logBarcodeValue: settings.logBarcodeValue,
+			onBarcode: value => this.handleBarcode(value),
+			logger: this.logger
+		});
+
+		this.logger.info("bridge.worker.started", {
+			httpBaseUrl: settings.httpBaseUrl,
+			wsUrl: settings.wsUrl,
+			serialPath: settings.serialPath,
+			serialBaudRate: settings.serialBaudRate,
+			scanIdleMs: settings.scanIdleMs,
+			scanMaxBufferSize: settings.scanMaxBufferSize
+		});
+
+		this.bridge.start();
+		this.scanner.start();
+
+		this.retryTimer = setInterval(() => {
+			this.flushQueue();
+		}, settings.queueRetryMs);
+	}
+
+	async handleCommand(message) {
+		const commandId = message.id;
+		const command = message.command;
+
+		this.logger.info("endpoint.command.received", {
+			command,
+			commandId
+		});
+
+		try {
+			await this.bridge.ackCommand(commandId);
+		} catch (error) {
+			this.logger.error("endpoint.command.ack_failed", {
+				command,
+				commandId,
+				error
+			});
+		}
+
+		const error = new Error(`Unsupported Zebra bridge command: ${command}`);
+		this.logger.error("endpoint.command.failed", {
+			command,
+			commandId,
+			error
+		});
+		await this.bridge.failCommand(commandId, error);
+	}
+
+	handleBarcode(value) {
+		const item = {
+			value,
+			time: Math.floor(Date.now() / 1000),
+			attempts: 0
+		};
+
+		if (this.queue.length >= this.settings.queueMaxSize) {
+			const dropped = this.queue.shift();
+			this.logger.error("scanner.barcode.queue_full_dropped_oldest", {
+				droppedLength: dropped?.value?.length ?? 0,
+				queueMaxSize: this.settings.queueMaxSize
+			});
+		}
+
+		this.queue.push(item);
+		this.logger.info("scanner.barcode.queued", {
+			length: value.length,
+			queueSize: this.queue.length,
+			...(this.settings.logBarcodeValue ? {value} : {})
+		});
+
+		this.flushQueue();
+	}
+
+	async flushQueue() {
+		if (this.isFlushing || this.queue.length === 0) {
+			return;
+		}
+
+		this.isFlushing = true;
+
+		try {
+			while (this.queue.length > 0) {
+				const item = this.queue[0];
+				item.attempts += 1;
+
+				try {
+					const result = await this.bridge.sendBarcode(item.value, {
+						time: item.time
+					});
+
+					this.queue.shift();
+					this.logger.info("scanner.barcode.sent", {
+						length: item.value.length,
+						attempts: item.attempts,
+						transport: result.transport,
+						queueSize: this.queue.length,
+						...(this.settings.logBarcodeValue ? {value: item.value} : {})
+					});
+				} catch (error) {
+					this.logger.error("scanner.barcode.send_failed", {
+						length: item.value.length,
+						attempts: item.attempts,
+						queueSize: this.queue.length,
+						error
+					});
+					break;
+				}
+			}
+		} finally {
+			this.isFlushing = false;
+		}
+	}
+
+	close() {
+		if (this.retryTimer) {
+			clearInterval(this.retryTimer);
+			this.retryTimer = null;
+		}
+
+		this.scanner.close();
+		this.bridge.close();
+	}
+}