edilkamin 1.10.2 → 1.11.0

package/dist/cjs/src/bluetooth-protocol.test.js

@@ -0,0 +1,389 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const bluetooth_protocol_1 = require("./bluetooth-protocol");
+describe("bluetooth-protocol", () => {
+    describe("constants", () => {
+        it("exports SERVICE_UUID", () => {
+            assert_1.strict.equal(bluetooth_protocol_1.SERVICE_UUID, "0000abf0-0000-1000-8000-00805f9b34fb");
+        });
+        it("exports WRITE_CHARACTERISTIC_UUID", () => {
+            assert_1.strict.equal(bluetooth_protocol_1.WRITE_CHARACTERISTIC_UUID, "0000abf1-0000-1000-8000-00805f9b34fb");
+        });
+        it("exports NOTIFY_CHARACTERISTIC_UUID", () => {
+            assert_1.strict.equal(bluetooth_protocol_1.NOTIFY_CHARACTERISTIC_UUID, "0000abf2-0000-1000-8000-00805f9b34fb");
+        });
+    });
+    describe("crc16Modbus", () => {
+        it("calculates correct CRC for power-on command", () => {
+            const command = new Uint8Array([0x01, 0x06, 0x03, 0x1c, 0x00, 0x01]);
+            const crc = (0, bluetooth_protocol_1.crc16Modbus)(command);
+            assert_1.strict.equal(crc.length, 2);
+            // CRC is returned as [crcLo, crcHi]
+            assert_1.strict.ok(crc[0] >= 0 && crc[0] <= 255);
+            assert_1.strict.ok(crc[1] >= 0 && crc[1] <= 255);
+        });
+        it("returns 2 bytes for any input", () => {
+            const testCases = [
+                new Uint8Array([0x01, 0x03, 0x05, 0x25, 0x00, 0x01]),
+                new Uint8Array([0x01, 0x06, 0x04, 0x40, 0x00, 0x03]),
+                new Uint8Array([0x00]),
+                new Uint8Array([0xff, 0xff, 0xff]),
+            ];
+            for (const data of testCases) {
+                const crc = (0, bluetooth_protocol_1.crc16Modbus)(data);
+                assert_1.strict.equal(crc.length, 2, `CRC for ${data.toString()} should be 2 bytes`);
+            }
+        });
+        it("produces different CRCs for different data", () => {
+            const crc1 = (0, bluetooth_protocol_1.crc16Modbus)(new Uint8Array([0x01, 0x06, 0x03, 0x1c, 0x00, 0x01]));
+            const crc2 = (0, bluetooth_protocol_1.crc16Modbus)(new Uint8Array([0x01, 0x06, 0x03, 0x1c, 0x00, 0x00]));
+            // CRCs should be different for different data
+            assert_1.strict.ok(crc1[0] !== crc2[0] || crc1[1] !== crc2[1]);
+        });
+    });
+    describe("aesEncrypt/aesDecrypt", () => {
+        it("roundtrip returns original data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const original = new Uint8Array(32).fill(0x42);
+            const encrypted = yield (0, bluetooth_protocol_1.aesEncrypt)(original);
+            const decrypted = yield (0, bluetooth_protocol_1.aesDecrypt)(encrypted);
+            assert_1.strict.deepEqual(decrypted, original);
+        }));
+        it("produces 32-byte output for 32-byte input", () => __awaiter(void 0, void 0, void 0, function* () {
+            const input = new Uint8Array(32);
+            const encrypted = yield (0, bluetooth_protocol_1.aesEncrypt)(input);
+            assert_1.strict.equal(encrypted.length, 32);
+        }));
+        it("produces different output for different input", () => __awaiter(void 0, void 0, void 0, function* () {
+            const input1 = new Uint8Array(32).fill(0x00);
+            const input2 = new Uint8Array(32).fill(0xff);
+            const encrypted1 = yield (0, bluetooth_protocol_1.aesEncrypt)(input1);
+            const encrypted2 = yield (0, bluetooth_protocol_1.aesEncrypt)(input2);
+            // At least some bytes should be different
+            let different = false;
+            for (let i = 0; i < 32; i++) {
+                if (encrypted1[i] !== encrypted2[i]) {
+                    different = true;
+                    break;
+                }
+            }
+            assert_1.strict.ok(different, "Different inputs should produce different outputs");
+        }));
+        it("encrypted data is different from plaintext", () => __awaiter(void 0, void 0, void 0, function* () {
+            const original = new Uint8Array(32).fill(0xaa);
+            const encrypted = yield (0, bluetooth_protocol_1.aesEncrypt)(original);
+            // Encrypted should not equal original
+            let same = true;
+            for (let i = 0; i < 32; i++) {
+                if (encrypted[i] !== original[i]) {
+                    same = false;
+                    break;
+                }
+            }
+            assert_1.strict.ok(!same, "Encrypted data should differ from original");
+        }));
+    });
+    describe("createPacket", () => {
+        it("produces 32-byte encrypted packet", () => __awaiter(void 0, void 0, void 0, function* () {
+            const command = bluetooth_protocol_1.readCommands.power;
+            const packet = yield (0, bluetooth_protocol_1.createPacket)(command);
+            assert_1.strict.equal(packet.length, 32);
+        }));
+        it("rejects commands not exactly 6 bytes", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield assert_1.strict.rejects(() => (0, bluetooth_protocol_1.createPacket)(new Uint8Array([0x01, 0x02])), /must be exactly 6 bytes/);
+        }));
+        it("rejects empty commands", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield assert_1.strict.rejects(() => (0, bluetooth_protocol_1.createPacket)(new Uint8Array([])), /must be exactly 6 bytes/);
+        }));
+        it("rejects 7-byte commands", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield assert_1.strict.rejects(() => (0, bluetooth_protocol_1.createPacket)(new Uint8Array([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07])), /must be exactly 6 bytes/);
+        }));
+        it("produces different packets for different commands", () => __awaiter(void 0, void 0, void 0, function* () {
+            const packet1 = yield (0, bluetooth_protocol_1.createPacket)(bluetooth_protocol_1.writeCommands.setPower(true));
+            const packet2 = yield (0, bluetooth_protocol_1.createPacket)(bluetooth_protocol_1.writeCommands.setPower(false));
+            // Packets should be different (different command bytes)
+            let different = false;
+            for (let i = 0; i < 32; i++) {
+                if (packet1[i] !== packet2[i]) {
+                    different = true;
+                    break;
+                }
+            }
+            assert_1.strict.ok(different, "Different commands should produce different packets");
+        }));
+    });
+    describe("parseResponse", () => {
+        it("rejects responses not 32 bytes", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield assert_1.strict.rejects(() => (0, bluetooth_protocol_1.parseResponse)(new Uint8Array(16)), /must be exactly 32 bytes/);
+        }));
+        it("can decrypt and parse an encrypted packet", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Create a command packet and try to parse it
+            // This tests that encrypt/decrypt work together
+            const command = bluetooth_protocol_1.readCommands.power;
+            const encrypted = yield (0, bluetooth_protocol_1.createPacket)(command);
+            // Parse the response (it's not a valid response but should decrypt)
+            const parsed = yield (0, bluetooth_protocol_1.parseResponse)(encrypted);
+            // Should have parsed something
+            assert_1.strict.ok(typeof parsed.slaveAddress === "number");
+            assert_1.strict.ok(typeof parsed.functionCode === "number");
+            assert_1.strict.ok(typeof parsed.isError === "boolean");
+        }));
+    });
+    describe("readCommands", () => {
+        it("all commands are 6 bytes", () => {
+            Object.entries(bluetooth_protocol_1.readCommands).forEach(([name, cmd]) => {
+                assert_1.strict.equal(cmd.length, 6, `${name} command must be 6 bytes`);
+            });
+        });
+        it("all commands use slave address 0x01", () => {
+            Object.entries(bluetooth_protocol_1.readCommands).forEach(([name, cmd]) => {
+                assert_1.strict.equal(cmd[0], 0x01, `${name} should use slave address 0x01`);
+            });
+        });
+        it("all commands use function code 0x03", () => {
+            Object.entries(bluetooth_protocol_1.readCommands).forEach(([name, cmd]) => {
+                assert_1.strict.equal(cmd[1], 0x03, `${name} should use function code 0x03`);
+            });
+        });
+        it("power command has correct register address", () => {
+            assert_1.strict.equal(bluetooth_protocol_1.readCommands.power[2], 0x05);
+            assert_1.strict.equal(bluetooth_protocol_1.readCommands.power[3], 0x29);
+        });
+        it("temperature command has correct register address", () => {
+            assert_1.strict.equal(bluetooth_protocol_1.readCommands.temperature[2], 0x05);
+            assert_1.strict.equal(bluetooth_protocol_1.readCommands.temperature[3], 0x25);
+        });
+    });
+    describe("writeCommands", () => {
+        it("setPower(true) produces correct bytes", () => {
+            const cmd = bluetooth_protocol_1.writeCommands.setPower(true);
+            assert_1.strict.deepEqual(cmd, new Uint8Array([0x01, 0x06, 0x03, 0x1c, 0x00, 0x01]));
+        });
+        it("setPower(false) produces correct bytes", () => {
+            const cmd = bluetooth_protocol_1.writeCommands.setPower(false);
+            assert_1.strict.deepEqual(cmd, new Uint8Array([0x01, 0x06, 0x03, 0x1c, 0x00, 0x00]));
+        });
+        it("setTemperature encodes correctly", () => {
+            const cmd = bluetooth_protocol_1.writeCommands.setTemperature(21.5);
+            // 21.5 * 10 = 215 = 0x00D7
+            assert_1.strict.equal(cmd[0], 0x01); // slave address
+            assert_1.strict.equal(cmd[1], 0x06); // function code
+            assert_1.strict.equal(cmd[2], 0x05); // register hi
+            assert_1.strict.equal(cmd[3], 0x25); // register lo
+            assert_1.strict.equal(cmd[4], 0x00); // value hi
+            assert_1.strict.equal(cmd[5], 0xd7); // value lo
+        });
+        it("setTemperature handles whole numbers", () => {
+            const cmd = bluetooth_protocol_1.writeCommands.setTemperature(20);
+            // 20 * 10 = 200 = 0x00C8
+            assert_1.strict.equal(cmd[4], 0x00);
+            assert_1.strict.equal(cmd[5], 0xc8);
+        });
+        it("setTemperature handles high temperatures", () => {
+            const cmd = bluetooth_protocol_1.writeCommands.setTemperature(30);
+            // 30 * 10 = 300 = 0x012C
+            assert_1.strict.equal(cmd[4], 0x01);
+            assert_1.strict.equal(cmd[5], 0x2c);
+        });
+        it("setPowerLevel validates range", () => {
+            assert_1.strict.throws(() => bluetooth_protocol_1.writeCommands.setPowerLevel(0), /must be 1-5/);
+            assert_1.strict.throws(() => bluetooth_protocol_1.writeCommands.setPowerLevel(6), /must be 1-5/);
+            assert_1.strict.doesNotThrow(() => bluetooth_protocol_1.writeCommands.setPowerLevel(1));
+            assert_1.strict.doesNotThrow(() => bluetooth_protocol_1.writeCommands.setPowerLevel(3));
+            assert_1.strict.doesNotThrow(() => bluetooth_protocol_1.writeCommands.setPowerLevel(5));
+        });
+        it("setPowerLevel produces correct bytes", () => {
+            const cmd = bluetooth_protocol_1.writeCommands.setPowerLevel(3);
+            assert_1.strict.equal(cmd[0], 0x01);
+            assert_1.strict.equal(cmd[1], 0x06);
+            assert_1.strict.equal(cmd[2], 0x04);
+            assert_1.strict.equal(cmd[3], 0x40);
+            assert_1.strict.equal(cmd[4], 0x00);
+            assert_1.strict.equal(cmd[5], 0x03);
+        });
+        it("setFan1Speed validates range", () => {
+            assert_1.strict.throws(() => bluetooth_protocol_1.writeCommands.setFan1Speed(-1), /must be 0-5/);
+            assert_1.strict.throws(() => bluetooth_protocol_1.writeCommands.setFan1Speed(6), /must be 0-5/);
+            assert_1.strict.doesNotThrow(() => bluetooth_protocol_1.writeCommands.setFan1Speed(0)); // auto
+            assert_1.strict.doesNotThrow(() => bluetooth_protocol_1.writeCommands.setFan1Speed(5));
+        });
+        it("setFan2Speed validates range", () => {
+            assert_1.strict.throws(() => bluetooth_protocol_1.writeCommands.setFan2Speed(-1), /must be 0-5/);
+            assert_1.strict.throws(() => bluetooth_protocol_1.writeCommands.setFan2Speed(6), /must be 0-5/);
+            assert_1.strict.doesNotThrow(() => bluetooth_protocol_1.writeCommands.setFan2Speed(0));
+            assert_1.strict.doesNotThrow(() => bluetooth_protocol_1.writeCommands.setFan2Speed(5));
+        });
+        it("setAutoMode produces correct bytes", () => {
+            const cmdOn = bluetooth_protocol_1.writeCommands.setAutoMode(true);
+            assert_1.strict.equal(cmdOn[5], 0x01);
+            const cmdOff = bluetooth_protocol_1.writeCommands.setAutoMode(false);
+            assert_1.strict.equal(cmdOff[5], 0x00);
+        });
+        it("setStandby produces correct bytes", () => {
+            const cmdOn = bluetooth_protocol_1.writeCommands.setStandby(true);
+            assert_1.strict.equal(cmdOn[5], 0x01);
+            const cmdOff = bluetooth_protocol_1.writeCommands.setStandby(false);
+            assert_1.strict.equal(cmdOff[5], 0x00);
+        });
+        it("all write commands are 6 bytes", () => {
+            const commands = [
+                bluetooth_protocol_1.writeCommands.setPower(true),
+                bluetooth_protocol_1.writeCommands.setTemperature(21),
+                bluetooth_protocol_1.writeCommands.setPowerLevel(3),
+                bluetooth_protocol_1.writeCommands.setFan1Speed(2),
+                bluetooth_protocol_1.writeCommands.setFan2Speed(2),
+                bluetooth_protocol_1.writeCommands.setAutoMode(true),
+                bluetooth_protocol_1.writeCommands.setStandby(false),
+            ];
+            commands.forEach((cmd, i) => {
+                assert_1.strict.equal(cmd.length, 6, `Command ${i} should be 6 bytes`);
+            });
+        });
+        it("all write commands use function code 0x06", () => {
+            const commands = [
+                bluetooth_protocol_1.writeCommands.setPower(true),
+                bluetooth_protocol_1.writeCommands.setTemperature(21),
+                bluetooth_protocol_1.writeCommands.setPowerLevel(3),
+                bluetooth_protocol_1.writeCommands.setFan1Speed(2),
+                bluetooth_protocol_1.writeCommands.setFan2Speed(2),
+                bluetooth_protocol_1.writeCommands.setAutoMode(true),
+                bluetooth_protocol_1.writeCommands.setStandby(false),
+            ];
+            commands.forEach((cmd, i) => {
+                assert_1.strict.equal(cmd[1], 0x06, `Command ${i} should use function code 0x06`);
+            });
+        });
+    });
+    describe("parsers", () => {
+        it("boolean parser returns true for 0x01", () => {
+            const response = {
+                slaveAddress: 1,
+                functionCode: 0x03,
+                byteCount: 2,
+                data: new Uint8Array([0x00, 0x01]),
+                isError: false,
+            };
+            assert_1.strict.equal(bluetooth_protocol_1.parsers.boolean(response), true);
+        });
+        it("boolean parser returns false for 0x00", () => {
+            const response = {
+                slaveAddress: 1,
+                functionCode: 0x03,
+                byteCount: 2,
+                data: new Uint8Array([0x00, 0x00]),
+                isError: false,
+            };
+            assert_1.strict.equal(bluetooth_protocol_1.parsers.boolean(response), false);
+        });
+        it("temperature parser divides by 10", () => {
+            const response = {
+                slaveAddress: 1,
+                functionCode: 0x03,
+                byteCount: 2,
+                data: new Uint8Array([0x00, 0xd7]), // 215
+                isError: false,
+            };
+            assert_1.strict.equal(bluetooth_protocol_1.parsers.temperature(response), 21.5);
+        });
+        it("temperature parser handles high temperatures", () => {
+            const response = {
+                slaveAddress: 1,
+                functionCode: 0x03,
+                byteCount: 2,
+                data: new Uint8Array([0x01, 0x2c]), // 300
+                isError: false,
+            };
+            assert_1.strict.equal(bluetooth_protocol_1.parsers.temperature(response), 30);
+        });
+        it("number parser returns big-endian value", () => {
+            const response = {
+                slaveAddress: 1,
+                functionCode: 0x03,
+                byteCount: 2,
+                data: new Uint8Array([0x00, 0x03]), // power level 3
+                isError: false,
+            };
+            assert_1.strict.equal(bluetooth_protocol_1.parsers.number(response), 3);
+        });
+        it("number parser handles larger values", () => {
+            const response = {
+                slaveAddress: 1,
+                functionCode: 0x03,
+                byteCount: 2,
+                data: new Uint8Array([0x01, 0x00]), // 256
+                isError: false,
+            };
+            assert_1.strict.equal(bluetooth_protocol_1.parsers.number(response), 256);
+        });
+        it("boolean parser throws on error response", () => {
+            const errorResponse = {
+                slaveAddress: 1,
+                functionCode: 0x03,
+                data: new Uint8Array([0x02]), // error code
+                isError: true,
+            };
+            assert_1.strict.throws(() => bluetooth_protocol_1.parsers.boolean(errorResponse), /Modbus error: 2/);
+        });
+        it("temperature parser throws on error response", () => {
+            const errorResponse = {
+                slaveAddress: 1,
+                functionCode: 0x03,
+                data: new Uint8Array([0x03]),
+                isError: true,
+            };
+            assert_1.strict.throws(() => bluetooth_protocol_1.parsers.temperature(errorResponse), /Modbus error: 3/);
+        });
+        it("number parser throws on error response", () => {
+            const errorResponse = {
+                slaveAddress: 1,
+                functionCode: 0x03,
+                data: new Uint8Array([0x04]),
+                isError: true,
+            };
+            assert_1.strict.throws(() => bluetooth_protocol_1.parsers.number(errorResponse), /Modbus error: 4/);
+        });
+    });
+    describe("integration", () => {
+        it("full roundtrip: create packet, decrypt, check structure", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Create a power-on command
+            const command = bluetooth_protocol_1.writeCommands.setPower(true);
+            assert_1.strict.deepEqual(command, new Uint8Array([0x01, 0x06, 0x03, 0x1c, 0x00, 0x01]));
+            // Create encrypted packet
+            const packet = yield (0, bluetooth_protocol_1.createPacket)(command);
+            assert_1.strict.equal(packet.length, 32);
+            // Decrypt it back (as if we received it)
+            // Note: createPacket encrypts with padding, parseResponse expects response format
+            // This is not a true response but tests the encryption layer
+        }));
+        it("all read commands can create valid packets", () => __awaiter(void 0, void 0, void 0, function* () {
+            for (const [name, command] of Object.entries(bluetooth_protocol_1.readCommands)) {
+                const packet = yield (0, bluetooth_protocol_1.createPacket)(command);
+                assert_1.strict.equal(packet.length, 32, `${name} should create 32-byte packet`);
+            }
+        }));
+        it("all write commands can create valid packets", () => __awaiter(void 0, void 0, void 0, function* () {
+            const commands = [
+                { name: "setPower", cmd: bluetooth_protocol_1.writeCommands.setPower(true) },
+                { name: "setTemperature", cmd: bluetooth_protocol_1.writeCommands.setTemperature(21) },
+                { name: "setPowerLevel", cmd: bluetooth_protocol_1.writeCommands.setPowerLevel(3) },
+                { name: "setFan1Speed", cmd: bluetooth_protocol_1.writeCommands.setFan1Speed(2) },
+                { name: "setFan2Speed", cmd: bluetooth_protocol_1.writeCommands.setFan2Speed(2) },
+                { name: "setAutoMode", cmd: bluetooth_protocol_1.writeCommands.setAutoMode(true) },
+                { name: "setStandby", cmd: bluetooth_protocol_1.writeCommands.setStandby(false) },
+            ];
+            for (const { name, cmd } of commands) {
+                const packet = yield (0, bluetooth_protocol_1.createPacket)(cmd);
+                assert_1.strict.equal(packet.length, 32, `${name} should create 32-byte packet`);
+            }
+        }));
+    });
+});

package/dist/cjs/src/bluetooth.d.ts

@@ -38,3 +38,5 @@ declare const scanForDevices: () => Promise<DiscoveredDevice[]>;
 declare const scanWithOptions: (options: RequestDeviceOptions) => Promise<BluetoothDevice>;
 export { EDILKAMIN_DEVICE_NAME, EDILKAMIN_SERVICE_UUID, isWebBluetoothSupported, scanForDevices, scanWithOptions, };
 export type { DiscoveredDevice } from "./types";
+export { aesDecrypt, aesEncrypt, crc16Modbus, createPacket, NOTIFY_CHARACTERISTIC_UUID, parseResponse, parsers, readCommands, SERVICE_UUID, WRITE_CHARACTERISTIC_UUID, writeCommands, } from "./bluetooth-protocol";
+export type { ModbusResponse } from "./bluetooth-protocol";

package/dist/cjs/src/bluetooth.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scanWithOptions = exports.scanForDevices = exports.isWebBluetoothSupported = exports.EDILKAMIN_SERVICE_UUID = exports.EDILKAMIN_DEVICE_NAME = void 0;
+exports.writeCommands = exports.WRITE_CHARACTERISTIC_UUID = exports.SERVICE_UUID = exports.readCommands = exports.parsers = exports.parseResponse = exports.NOTIFY_CHARACTERISTIC_UUID = exports.createPacket = exports.crc16Modbus = exports.aesEncrypt = exports.aesDecrypt = exports.scanWithOptions = exports.scanForDevices = exports.isWebBluetoothSupported = exports.EDILKAMIN_SERVICE_UUID = exports.EDILKAMIN_DEVICE_NAME = void 0;
 const bluetooth_utils_1 = require("./bluetooth-utils");
 /** Device name broadcast by Edilkamin stoves */
 const EDILKAMIN_DEVICE_NAME = "EDILKAMIN_EP";
@@ -105,3 +105,19 @@ const scanWithOptions = (options) => __awaiter(void 0, void 0, void 0, function*
     return navigator.bluetooth.requestDevice(options);
 });
 exports.scanWithOptions = scanWithOptions;
+// Protocol functions
+var bluetooth_protocol_1 = require("./bluetooth-protocol");
+Object.defineProperty(exports, "aesDecrypt", { enumerable: true, get: function () { return bluetooth_protocol_1.aesDecrypt; } });
+Object.defineProperty(exports, "aesEncrypt", { enumerable: true, get: function () { return bluetooth_protocol_1.aesEncrypt; } });
+Object.defineProperty(exports, "crc16Modbus", { enumerable: true, get: function () { return bluetooth_protocol_1.crc16Modbus; } });
+Object.defineProperty(exports, "createPacket", { enumerable: true, get: function () { return bluetooth_protocol_1.createPacket; } });
+// Constants
+Object.defineProperty(exports, "NOTIFY_CHARACTERISTIC_UUID", { enumerable: true, get: function () { return bluetooth_protocol_1.NOTIFY_CHARACTERISTIC_UUID; } });
+Object.defineProperty(exports, "parseResponse", { enumerable: true, get: function () { return bluetooth_protocol_1.parseResponse; } });
+// Commands
+Object.defineProperty(exports, "parsers", { enumerable: true, get: function () { return bluetooth_protocol_1.parsers; } });
+Object.defineProperty(exports, "readCommands", { enumerable: true, get: function () { return bluetooth_protocol_1.readCommands; } });
+Object.defineProperty(exports, "SERVICE_UUID", { enumerable: true, get: function () { return bluetooth_protocol_1.SERVICE_UUID; } });
+Object.defineProperty(exports, "WRITE_CHARACTERISTIC_UUID", { enumerable: true, get: function () { return bluetooth_protocol_1.WRITE_CHARACTERISTIC_UUID; } });
+// Parsers
+Object.defineProperty(exports, "writeCommands", { enumerable: true, get: function () { return bluetooth_protocol_1.writeCommands; } });

package/dist/esm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "edilkamin",
-    "version": "1.10.2",
+    "version": "1.11.0",
     "description": "",
     "main": "dist/cjs/src/index.js",
     "module": "dist/esm/src/index.js",

package/dist/esm/src/bluetooth-protocol.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Edilkamin BLE Protocol Implementation
+ *
+ * Transport-agnostic protocol layer for communicating with Edilkamin stoves via BLE.
+ * Handles AES-128-CBC encryption, CRC16-Modbus checksums, and Modbus packet building/parsing.
+ *
+ * The consuming application is responsible for:
+ * - BLE device scanning and connection
+ * - Writing to BLE characteristics
+ * - Subscribing to BLE notifications
+ *
+ * Protocol details derived from: https://github.com/netmb/Edilkamin_BT
+ */
+/** Edilkamin GATT service UUID */
+export declare const SERVICE_UUID = "0000abf0-0000-1000-8000-00805f9b34fb";
+/** Write characteristic UUID (WRITE NO RESPONSE) */
+export declare const WRITE_CHARACTERISTIC_UUID = "0000abf1-0000-1000-8000-00805f9b34fb";
+/** Notify characteristic UUID (NOTIFY) */
+export declare const NOTIFY_CHARACTERISTIC_UUID = "0000abf2-0000-1000-8000-00805f9b34fb";
+/**
+ * Parsed Modbus response from the device.
+ */
+export interface ModbusResponse {
+    /** Slave address (always 0x01 for Edilkamin) */
+    slaveAddress: number;
+    /** Function code (0x03 for read, 0x06 for write) */
+    functionCode: number;
+    /** Byte count (for read responses) */
+    byteCount?: number;
+    /** Response data */
+    data: Uint8Array;
+    /** Whether the response indicates an error */
+    isError: boolean;
+}
+/**
+ * Calculate CRC16-Modbus checksum.
+ *
+ * @param data - Data to calculate CRC for
+ * @returns 2-byte CRC in little-endian order [crcLo, crcHi]
+ */
+export declare const crc16Modbus: (data: Uint8Array) => Uint8Array;
+/**
+ * Encrypt data using AES-128-CBC (raw, without PKCS7 padding).
+ *
+ * This manually applies PKCS7 padding to make input a multiple of 16 bytes,
+ * encrypts with Web Crypto, then strips the extra padding block from output.
+ *
+ * @param plaintext - Data to encrypt (must be 32 bytes)
+ * @returns Encrypted data (32 bytes)
+ */
+export declare const aesEncrypt: (plaintext: Uint8Array) => Promise<Uint8Array>;
+/**
+ * Decrypt data using AES-128-CBC (raw, handling PKCS7 padding).
+ *
+ * @param ciphertext - Data to decrypt (must be 32 bytes)
+ * @returns Decrypted data (32 bytes)
+ */
+export declare const aesDecrypt: (ciphertext: Uint8Array) => Promise<Uint8Array>;
+/**
+ * Build and encrypt a command packet to send to the device.
+ *
+ * Packet structure (32 bytes before encryption):
+ * - Bytes 0-3: Unix timestamp (big-endian)
+ * - Bytes 4-19: Fixed key
+ * - Bytes 20-25: Modbus command (6 bytes)
+ * - Bytes 26-27: CRC16-Modbus of command
+ * - Bytes 28-31: Padding [0x04, 0x04, 0x04, 0x04]
+ *
+ * @param modbusCommand - 6-byte Modbus RTU command
+ * @returns 32-byte encrypted packet ready to send via BLE
+ */
+export declare const createPacket: (modbusCommand: Uint8Array) => Promise<Uint8Array>;
+/**
+ * Decrypt and parse a response packet from the device.
+ *
+ * Response structure (32 bytes before decryption):
+ * - Bytes 0-3: Unix timestamp
+ * - Bytes 4-19: Fixed key
+ * - Bytes 20-26: Modbus response (7 bytes)
+ * - Bytes 27-28: CRC16-Modbus
+ * - Bytes 29-31: Padding [0x03, 0x03, 0x03]
+ *
+ * @param encrypted - 32-byte encrypted response from BLE notification
+ * @returns Parsed Modbus response
+ */
+export declare const parseResponse: (encrypted: Uint8Array) => Promise<ModbusResponse>;
+/**
+ * Pre-built Modbus read commands for querying device state.
+ * Each command is 6 bytes: [SlaveAddr, FuncCode, RegHi, RegLo, CountHi, CountLo]
+ */
+export declare const readCommands: {
+    /** Power state (0=off, 1=on) */
+    power: Uint8Array<ArrayBuffer>;
+    /** Current ambient temperature (value / 10 = °C) */
+    temperature: Uint8Array<ArrayBuffer>;
+    /** Target temperature (value / 10 = °C) */
+    targetTemperature: Uint8Array<ArrayBuffer>;
+    /** Power level (1-5) */
+    powerLevel: Uint8Array<ArrayBuffer>;
+    /** Fan 1 speed (0=auto, 1-5=speed) */
+    fan1Speed: Uint8Array<ArrayBuffer>;
+    /** Fan 2 speed (0=auto, 1-5=speed) */
+    fan2Speed: Uint8Array<ArrayBuffer>;
+    /** Device state code */
+    state: Uint8Array<ArrayBuffer>;
+    /** Alarm status code */
+    alarm: Uint8Array<ArrayBuffer>;
+    /** Pellet warning status */
+    pelletAlarm: Uint8Array<ArrayBuffer>;
+    /** Auto mode (0=manual, 1=auto) */
+    autoMode: Uint8Array<ArrayBuffer>;
+    /** Standby mode status */
+    standby: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Builder functions for Modbus write commands.
+ * Each function returns a 6-byte command: [SlaveAddr, FuncCode, RegHi, RegLo, ValHi, ValLo]
+ */
+export declare const writeCommands: {
+    /**
+     * Turn power on or off.
+     * @param on - true to turn on, false to turn off
+     */
+    setPower: (on: boolean) => Uint8Array;
+    /**
+     * Set target temperature.
+     * @param tempCelsius - Temperature in Celsius (e.g., 21.5)
+     */
+    setTemperature: (tempCelsius: number) => Uint8Array;
+    /**
+     * Set power level.
+     * @param level - Power level (1-5)
+     */
+    setPowerLevel: (level: number) => Uint8Array;
+    /**
+     * Set fan 1 speed.
+     * @param speed - Fan speed (0=auto, 1-5=manual speed)
+     */
+    setFan1Speed: (speed: number) => Uint8Array;
+    /**
+     * Set fan 2 speed.
+     * @param speed - Fan speed (0=auto, 1-5=manual speed)
+     */
+    setFan2Speed: (speed: number) => Uint8Array;
+    /**
+     * Enable or disable auto mode.
+     * @param enabled - true to enable auto mode
+     */
+    setAutoMode: (enabled: boolean) => Uint8Array;
+    /**
+     * Enable or disable standby mode.
+     * @param enabled - true to enable standby mode
+     */
+    setStandby: (enabled: boolean) => Uint8Array;
+};
+/**
+ * Parser functions to extract meaningful values from Modbus responses.
+ */
+export declare const parsers: {
+    /**
+     * Parse boolean response (power state, auto mode, etc.).
+     * @param response - Parsed Modbus response
+     * @returns true if value is 0x01, false if 0x00
+     */
+    boolean: (response: ModbusResponse) => boolean;
+    /**
+     * Parse temperature response.
+     * @param response - Parsed Modbus response
+     * @returns Temperature in Celsius
+     */
+    temperature: (response: ModbusResponse) => number;
+    /**
+     * Parse numeric value (power level, fan speed, state code, etc.).
+     * @param response - Parsed Modbus response
+     * @returns Numeric value
+     */
+    number: (response: ModbusResponse) => number;
+};