edilkamin 1.7.3 → 1.8.0

package/.github/workflows/cli-tests.yml

@@ -18,3 +18,9 @@ jobs:
           node-version: ${{ matrix.node-version }}
       - run: yarn install --no-ignore-optional
       - run: yarn cli --help
+      - run: yarn build
+      - run: node dist/cjs/src/cli.js --help
+      - name: Verify CLI binary
+        run: |
+          test -f dist/cjs/src/cli.js
+          grep -q "#!/usr/bin/env node" dist/cjs/src/cli.js

package/README.md

@@ -115,6 +115,39 @@ const legacyApi = configure(OLD_API_URL);
 
 > **Note**: The legacy API uses AWS API Gateway and may be deprecated in the future.
 
+## Bluetooth Device Discovery
+
+For automatic device discovery in web browsers, use the `edilkamin/bluetooth` subpath export.
+
+### Quick Example (Web)
+
+```javascript
+import { scanForDevices } from "edilkamin/bluetooth";
+import { deviceInfo, signIn } from "edilkamin";
+
+// Scan for nearby stoves (requires user gesture)
+const devices = await scanForDevices();
+const { wifiMac } = devices[0];
+
+// Use discovered MAC for API calls
+const token = await signIn(username, password);
+const info = await deviceInfo(token, wifiMac);
+```
+
+### MAC Address Helper
+
+The core library includes a helper to convert BLE MAC to WiFi MAC:
+
+```javascript
+import { bleToWifiMac } from "edilkamin";
+
+// BLE MAC from Bluetooth scan
+const bleMac = "A8:03:2A:FE:D5:0A";
+
+// WiFi MAC for API calls (BLE - 2)
+const wifiMac = bleToWifiMac(bleMac); // "a8032afed508"
+```
+
 ## Motivations
 
 - providing an open source web alternative
@@ -132,6 +165,6 @@ const legacyApi = configure(OLD_API_URL);
 
 ## Limitations
 
-It seems like there's no endpoint to list stoves associated to a user.
-The way the official app seem to work is by probing the stove via bluetooth.
-Then cache the stove MAC address to a local database for later use.
+- **No server-side device listing**: The API doesn't provide an endpoint to list stoves associated to a user.
+- **Bluetooth discovery available**: Use `edilkamin/bluetooth` for web browser device discovery, similar to the official app.
+- **Manual MAC entry fallback**: For unsupported browsers or CLI, users can find the BLE MAC with different means and use `bleToWifiMac()` to calculate the WiFi MAC for API calls.

package/dist/cjs/package.json

@@ -0,0 +1,95 @@
+{
+    "name": "edilkamin",
+    "version": "1.8.0",
+    "description": "",
+    "main": "dist/cjs/src/index.js",
+    "module": "dist/esm/src/index.js",
+    "types": "dist/esm/src/index.d.ts",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./dist/esm/src/index.d.ts",
+                "default": "./dist/esm/src/index.js"
+            },
+            "require": {
+                "types": "./dist/cjs/src/index.d.ts",
+                "default": "./dist/cjs/src/index.js"
+            }
+        },
+        "./bluetooth": {
+            "import": {
+                "types": "./dist/esm/src/bluetooth.d.ts",
+                "default": "./dist/esm/src/bluetooth.js"
+            },
+            "require": {
+                "types": "./dist/cjs/src/bluetooth.d.ts",
+                "default": "./dist/cjs/src/bluetooth.js"
+            }
+        }
+    },
+    "scripts": {
+        "cli": "ts-node src/cli.ts",
+        "cli:debug": "node --inspect --require ts-node/register/transpile-only src/cli.ts",
+        "test": "nyc mocha --require ts-node/register src/*.test.ts",
+        "test:debug": "nyc mocha --require ts-node/register/transpile-only --inspect src/*.test.ts",
+        "lint:prettier": "prettier --check src docs .github *.json *.md *.mjs",
+        "format:prettier": "prettier --write src docs .github *.json *.md *.mjs",
+        "lint:eslint": "eslint src",
+        "format:eslint": "eslint --fix src",
+        "lint": "yarn lint:prettier && yarn lint:eslint",
+        "format": "yarn format:prettier && yarn format:eslint",
+        "build:cjs": "tsc -p tsconfig.cjs.json",
+        "build:esm": "tsc -p tsconfig.esm.json",
+        "build": "npm run build:cjs && npm run build:esm"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/AndreMiras/edilkamin.js.git"
+    },
+    "author": "Andre Miras",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/AndreMiras/edilkamin.js/issues"
+    },
+    "homepage": "https://github.com/AndreMiras/edilkamin.js#readme",
+    "bin": {
+        "edilkamin": "dist/cjs/src/cli.js"
+    },
+    "nyc": {
+        "reporter": [
+            "html",
+            "lcov",
+            "text"
+        ]
+    },
+    "dependencies": {
+        "aws-amplify": "^6.10.0",
+        "pako": "^2.1.0"
+    },
+    "devDependencies": {
+        "@eslint/eslintrc": "^3.2.0",
+        "@eslint/js": "^9.16.0",
+        "@types/mocha": "^10.0.10",
+        "@types/node": "^25.0.2",
+        "@types/pako": "^2.0.4",
+        "@types/sinon": "^17.0.3",
+        "@types/web-bluetooth": "^0.0.21",
+        "@typescript-eslint/eslint-plugin": "^8.17.0",
+        "@typescript-eslint/parser": "^8.17.0",
+        "esbuild": "^0.27.1",
+        "eslint": "^9.16.0",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-prettier": "^5.2.1",
+        "eslint-plugin-simple-import-sort": "^12.1.1",
+        "mocha": "^11.7.5",
+        "nyc": "^17.1.0",
+        "prettier": "^3.7.4",
+        "sinon": "^19.0.2",
+        "ts-node": "^10.9.1",
+        "typedoc": "^0.28.15",
+        "typescript": "^5.7.2"
+    },
+    "optionalDependencies": {
+        "commander": "^14.0.2"
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Converts a BLE MAC address to WiFi MAC address.
+ * The WiFi MAC is the BLE MAC minus 2 in hexadecimal.
+ *
+ * @param bleMac - BLE MAC address (with or without colons/dashes)
+ * @returns WiFi MAC address in lowercase without separators
+ *
+ * @example
+ * bleToWifiMac("A8:03:2A:FE:D5:0A") // returns "a8032afed508"
+ * bleToWifiMac("a8032afed50a")      // returns "a8032afed508"
+ */
+declare const bleToWifiMac: (bleMac: string) => string;
+export { bleToWifiMac };

package/dist/cjs/src/bluetooth-utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bleToWifiMac = void 0;
+/**
+ * Converts a BLE MAC address to WiFi MAC address.
+ * The WiFi MAC is the BLE MAC minus 2 in hexadecimal.
+ *
+ * @param bleMac - BLE MAC address (with or without colons/dashes)
+ * @returns WiFi MAC address in lowercase without separators
+ *
+ * @example
+ * bleToWifiMac("A8:03:2A:FE:D5:0A") // returns "a8032afed508"
+ * bleToWifiMac("a8032afed50a")      // returns "a8032afed508"
+ */
+const bleToWifiMac = (bleMac) => {
+    // Remove colons, dashes, and convert to lowercase
+    const normalized = bleMac.replace(/[:-]/g, "").toLowerCase();
+    // Validate MAC address format (12 hex characters)
+    if (!/^[0-9a-f]{12}$/.test(normalized)) {
+        throw new Error(`Invalid MAC address format: ${bleMac}`);
+    }
+    // Convert to number, subtract 2, convert back to hex
+    const bleValue = BigInt(`0x${normalized}`);
+    const wifiValue = bleValue - BigInt(2);
+    // Pad to 12 characters and return lowercase
+    return wifiValue.toString(16).padStart(12, "0");
+};
+exports.bleToWifiMac = bleToWifiMac;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const bluetooth_utils_1 = require("./bluetooth-utils");
+describe("bleToWifiMac", () => {
+    it("converts BLE MAC with colons to WiFi MAC", () => {
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("A8:03:2A:FE:D5:0A"), "a8032afed508");
+    });
+    it("converts BLE MAC without separators", () => {
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("a8032afed50a"), "a8032afed508");
+    });
+    it("converts BLE MAC with dashes", () => {
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("A8-03-2A-FE-D5-0A"), "a8032afed508");
+    });
+    it("handles lowercase input", () => {
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("a8:03:2a:fe:d5:0a"), "a8032afed508");
+    });
+    it("handles edge case where subtraction crosses byte boundary", () => {
+        // FF:FF:FF:FF:FF:01 - 2 = FF:FF:FF:FF:FE:FF
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("FF:FF:FF:FF:FF:01"), "fffffffffeff");
+    });
+    it("handles minimum value edge case", () => {
+        // 00:00:00:00:00:02 - 2 = 00:00:00:00:00:00
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("00:00:00:00:00:02"), "000000000000");
+    });
+    it("throws on invalid MAC format - too short", () => {
+        assert_1.strict.throws(() => (0, bluetooth_utils_1.bleToWifiMac)("A8:03:2A"), /Invalid MAC address format/);
+    });
+    it("throws on invalid MAC format - invalid characters", () => {
+        assert_1.strict.throws(() => (0, bluetooth_utils_1.bleToWifiMac)("G8:03:2A:FE:D5:0A"), /Invalid MAC address format/);
+    });
+    it("throws on empty string", () => {
+        assert_1.strict.throws(() => (0, bluetooth_utils_1.bleToWifiMac)(""), /Invalid MAC address format/);
+    });
+});

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

@@ -0,0 +1,40 @@
+import { DiscoveredDevice } from "./types";
+/** Device name broadcast by Edilkamin stoves */
+declare const EDILKAMIN_DEVICE_NAME = "EDILKAMIN_EP";
+/** GATT Service UUID for Edilkamin devices (0xABF0) */
+declare const EDILKAMIN_SERVICE_UUID = 44016;
+/**
+ * Check if Web Bluetooth API is available in the current browser.
+ *
+ * @returns true if Web Bluetooth is supported
+ */
+declare const isWebBluetoothSupported: () => boolean;
+/**
+ * Scan for nearby Edilkamin stoves using the Web Bluetooth API.
+ *
+ * This function triggers the browser's Bluetooth device picker dialog,
+ * filtered to show only devices named "EDILKAMIN_EP".
+ *
+ * Note: Web Bluetooth requires:
+ * - HTTPS or localhost
+ * - User gesture (button click)
+ * - Chrome/Edge/Opera (not Firefox/Safari)
+ *
+ * @returns Promise resolving to array of discovered devices
+ * @throws Error if Web Bluetooth is not supported or user cancels
+ *
+ * @example
+ * const devices = await scanForDevices();
+ * console.log(devices[0].wifiMac); // Use this for API calls
+ */
+declare const scanForDevices: () => Promise<DiscoveredDevice[]>;
+/**
+ * Scan for devices with a custom filter.
+ * Advanced function for users who need more control over device selection.
+ *
+ * @param options - Web Bluetooth requestDevice options
+ * @returns Promise resolving to the selected BluetoothDevice
+ */
+declare const scanWithOptions: (options: RequestDeviceOptions) => Promise<BluetoothDevice>;
+export { EDILKAMIN_DEVICE_NAME, EDILKAMIN_SERVICE_UUID, isWebBluetoothSupported, scanForDevices, scanWithOptions, };
+export type { DiscoveredDevice } from "./types";

package/dist/cjs/src/bluetooth.js

@@ -0,0 +1,107 @@
+"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 });
+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";
+exports.EDILKAMIN_DEVICE_NAME = EDILKAMIN_DEVICE_NAME;
+/** GATT Service UUID for Edilkamin devices (0xABF0) */
+const EDILKAMIN_SERVICE_UUID = 0xabf0;
+exports.EDILKAMIN_SERVICE_UUID = EDILKAMIN_SERVICE_UUID;
+/**
+ * Check if Web Bluetooth API is available in the current browser.
+ *
+ * @returns true if Web Bluetooth is supported
+ */
+const isWebBluetoothSupported = () => {
+    return typeof navigator !== "undefined" && "bluetooth" in navigator;
+};
+exports.isWebBluetoothSupported = isWebBluetoothSupported;
+/**
+ * Scan for nearby Edilkamin stoves using the Web Bluetooth API.
+ *
+ * This function triggers the browser's Bluetooth device picker dialog,
+ * filtered to show only devices named "EDILKAMIN_EP".
+ *
+ * Note: Web Bluetooth requires:
+ * - HTTPS or localhost
+ * - User gesture (button click)
+ * - Chrome/Edge/Opera (not Firefox/Safari)
+ *
+ * @returns Promise resolving to array of discovered devices
+ * @throws Error if Web Bluetooth is not supported or user cancels
+ *
+ * @example
+ * const devices = await scanForDevices();
+ * console.log(devices[0].wifiMac); // Use this for API calls
+ */
+const scanForDevices = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (!isWebBluetoothSupported()) {
+        throw new Error("Web Bluetooth API is not supported in this browser. " +
+            "Use Chrome, Edge, or Opera on desktop/Android. " +
+            "On iOS, use the Bluefy browser app.");
+    }
+    try {
+        // Request device - this opens the browser's device picker
+        const device = yield navigator.bluetooth.requestDevice({
+            filters: [{ name: EDILKAMIN_DEVICE_NAME }],
+            optionalServices: [EDILKAMIN_SERVICE_UUID],
+        });
+        // Extract BLE MAC from device ID if available
+        // Note: device.id format varies by platform, may need adjustment
+        const bleMac = device.id || "";
+        const name = device.name || EDILKAMIN_DEVICE_NAME;
+        // Calculate WiFi MAC for API calls
+        let wifiMac = "";
+        if (bleMac && /^[0-9a-f:-]{12,17}$/i.test(bleMac)) {
+            try {
+                wifiMac = (0, bluetooth_utils_1.bleToWifiMac)(bleMac);
+            }
+            catch (_a) {
+                // device.id may not be a valid MAC format on all platforms
+                wifiMac = "";
+            }
+        }
+        const discoveredDevice = {
+            bleMac,
+            wifiMac,
+            name,
+            // RSSI not directly available from requestDevice
+        };
+        return [discoveredDevice];
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === "NotFoundError") {
+                // User cancelled the device picker
+                return [];
+            }
+            throw error;
+        }
+        throw new Error("Unknown error during Bluetooth scan");
+    }
+});
+exports.scanForDevices = scanForDevices;
+/**
+ * Scan for devices with a custom filter.
+ * Advanced function for users who need more control over device selection.
+ *
+ * @param options - Web Bluetooth requestDevice options
+ * @returns Promise resolving to the selected BluetoothDevice
+ */
+const scanWithOptions = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!isWebBluetoothSupported()) {
+        throw new Error("Web Bluetooth API is not supported in this browser.");
+    }
+    return navigator.bluetooth.requestDevice(options);
+});
+exports.scanWithOptions = scanWithOptions;

package/dist/cjs/src/browser-bundle.test.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 esbuild = __importStar(require("esbuild"));
+describe("browser-bundle", () => {
+    it("should bundle for browser without Node.js built-ins", () => __awaiter(void 0, void 0, void 0, function* () {
+        // This test verifies that the library can be bundled for browser environments
+        // without requiring Node.js built-in modules (fs, os, path).
+        // If this test fails, it means Node.js-only code has leaked into the main exports.
+        const result = yield esbuild.build({
+            entryPoints: ["dist/esm/src/index.js"],
+            platform: "browser",
+            bundle: true,
+            write: false,
+            // External dependencies that are expected (real deps + assert which is used for validation)
+            external: ["aws-amplify", "aws-amplify/*", "pako", "assert"],
+            logLevel: "silent",
+        });
+        // If we get here without error, the bundle succeeded
+        assert_1.strict.ok(result.outputFiles.length > 0, "Bundle should produce output");
+    }));
+});

package/dist/cjs/src/buffer-utils.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processResponse = exports.isBuffer = exports.decompressBuffer = void 0;
+const pako_1 = __importDefault(require("pako"));
+/**
+ * Type guard to check if a value is a serialized Node.js Buffer.
+ * Node.js Buffers serialize to JSON as: {type: "Buffer", data: [...]}
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Buffer-encoded object
+ */
+const isBuffer = (value) => {
+    return (typeof value === "object" &&
+        value !== null &&
+        "type" in value &&
+        value.type === "Buffer" &&
+        "data" in value &&
+        Array.isArray(value.data));
+};
+exports.isBuffer = isBuffer;
+/**
+ * Decompresses a Buffer-encoded gzip object and parses the resulting JSON.
+ *
+ * @param bufferObj - A serialized Buffer object containing gzip data
+ * @returns The decompressed and parsed JSON data, or the original object on failure
+ */
+const decompressBuffer = (bufferObj) => {
+    try {
+        // Convert data array to Uint8Array for pako
+        const compressed = new Uint8Array(bufferObj.data);
+        // Decompress with gzip
+        const decompressed = pako_1.default.ungzip(compressed, { to: "string" });
+        // Parse JSON
+        return JSON.parse(decompressed);
+    }
+    catch (error) {
+        // Log warning but return original to maintain backward compatibility
+        console.warn("Failed to decompress buffer:", error);
+        return bufferObj;
+    }
+};
+exports.decompressBuffer = decompressBuffer;
+/**
+ * Recursively processes an API response to decompress any Buffer-encoded fields.
+ * Handles nested objects and arrays, preserving structure while decompressing.
+ *
+ * @param data - The API response data to process
+ * @returns The processed data with all Buffer fields decompressed
+ */
+const processResponse = (data) => {
+    if (data === null || data === undefined) {
+        return data;
+    }
+    // Check if this is a Buffer object
+    if (isBuffer(data)) {
+        const decompressed = decompressBuffer(data);
+        // Recursively process the decompressed result (may contain nested buffers)
+        return processResponse(decompressed);
+    }
+    // Recursively process arrays
+    if (Array.isArray(data)) {
+        return data.map((item) => processResponse(item));
+    }
+    // Recursively process objects
+    if (typeof data === "object") {
+        const processed = {};
+        for (const [key, value] of Object.entries(data)) {
+            processed[key] = processResponse(value);
+        }
+        return processed;
+    }
+    // Primitive value, return as-is
+    return data;
+};
+exports.processResponse = processResponse;