edilkamin 1.7.3 → 1.7.4

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/dist/cjs/package.json

@@ -0,0 +1,84 @@
+{
+    "name": "edilkamin",
+    "version": "1.7.4",
+    "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"
+            }
+        }
+    },
+    "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",
+        "@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": "^12.1.0"
+    }
+}

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;

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

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const pako_1 = __importDefault(require("pako"));
+const sinon_1 = __importDefault(require("sinon"));
+const buffer_utils_1 = require("./buffer-utils");
+/**
+ * Helper to create a gzip-compressed Buffer object for testing.
+ */
+const createGzippedBuffer = (data) => {
+    const json = JSON.stringify(data);
+    const compressed = pako_1.default.gzip(json);
+    return {
+        type: "Buffer",
+        data: Array.from(compressed),
+    };
+};
+describe("buffer-utils", () => {
+    afterEach(() => {
+        sinon_1.default.restore();
+    });
+    describe("isBuffer", () => {
+        it("should detect valid Buffer objects", () => {
+            const buffer = { type: "Buffer", data: [31, 139, 8, 0] };
+            assert_1.strict.ok((0, buffer_utils_1.isBuffer)(buffer));
+        });
+        it("should detect empty Buffer objects", () => {
+            const buffer = { type: "Buffer", data: [] };
+            assert_1.strict.ok((0, buffer_utils_1.isBuffer)(buffer));
+        });
+        it("should reject non-Buffer objects with wrong type", () => {
+            assert_1.strict.ok(!(0, buffer_utils_1.isBuffer)({ type: "NotBuffer", data: [] }));
+        });
+        it("should reject objects without type field", () => {
+            assert_1.strict.ok(!(0, buffer_utils_1.isBuffer)({ data: [1, 2, 3] }));
+        });
+        it("should reject objects without data field", () => {
+            assert_1.strict.ok(!(0, buffer_utils_1.isBuffer)({ type: "Buffer" }));
+        });
+        it("should reject objects with non-array data", () => {
+            assert_1.strict.ok(!(0, buffer_utils_1.isBuffer)({ type: "Buffer", data: "not an array" }));
+        });
+        it("should reject null", () => {
+            assert_1.strict.ok(!(0, buffer_utils_1.isBuffer)(null));
+        });
+        it("should reject undefined", () => {
+            assert_1.strict.ok(!(0, buffer_utils_1.isBuffer)(undefined));
+        });
+        it("should reject primitives", () => {
+            assert_1.strict.ok(!(0, buffer_utils_1.isBuffer)("string"));
+            assert_1.strict.ok(!(0, buffer_utils_1.isBuffer)(123));
+            assert_1.strict.ok(!(0, buffer_utils_1.isBuffer)(true));
+        });
+    });
+    describe("decompressBuffer", () => {
+        it("should decompress gzipped JSON buffer", () => {
+            const originalData = { test: "value", nested: { key: 123 } };
+            const bufferObj = createGzippedBuffer(originalData);
+            const result = (0, buffer_utils_1.decompressBuffer)(bufferObj);
+            assert_1.strict.deepEqual(result, originalData);
+        });
+        it("should handle gzipped arrays", () => {
+            const originalData = [1, 2, 3, "test"];
+            const bufferObj = createGzippedBuffer(originalData);
+            const result = (0, buffer_utils_1.decompressBuffer)(bufferObj);
+            assert_1.strict.deepEqual(result, originalData);
+        });
+        it("should handle gzipped strings", () => {
+            const originalData = "test string";
+            const bufferObj = createGzippedBuffer(originalData);
+            const result = (0, buffer_utils_1.decompressBuffer)(bufferObj);
+            assert_1.strict.equal(result, originalData);
+        });
+        it("should return original value if decompression fails", () => {
+            const consoleWarnStub = sinon_1.default.stub(console, "warn");
+            const invalidBuffer = { type: "Buffer", data: [1, 2, 3] };
+            const result = (0, buffer_utils_1.decompressBuffer)(invalidBuffer);
+            assert_1.strict.deepEqual(result, invalidBuffer);
+            assert_1.strict.ok(consoleWarnStub.calledOnce);
+        });
+        it("should return original value if JSON parsing fails", () => {
+            const consoleWarnStub = sinon_1.default.stub(console, "warn");
+            // Create valid gzip but invalid JSON
+            const invalidJson = "not valid json {";
+            const compressed = pako_1.default.gzip(invalidJson);
+            const bufferObj = {
+                type: "Buffer",
+                data: Array.from(compressed),
+            };
+            const result = (0, buffer_utils_1.decompressBuffer)(bufferObj);
+            assert_1.strict.deepEqual(result, bufferObj);
+            assert_1.strict.ok(consoleWarnStub.calledOnce);
+        });
+    });
+    describe("processResponse", () => {
+        it("should pass through null", () => {
+            assert_1.strict.equal((0, buffer_utils_1.processResponse)(null), null);
+        });
+        it("should pass through undefined", () => {
+            assert_1.strict.equal((0, buffer_utils_1.processResponse)(undefined), undefined);
+        });
+        it("should pass through primitives", () => {
+            assert_1.strict.equal((0, buffer_utils_1.processResponse)("string"), "string");
+            assert_1.strict.equal((0, buffer_utils_1.processResponse)(123), 123);
+            assert_1.strict.equal((0, buffer_utils_1.processResponse)(true), true);
+        });
+        it("should pass through plain objects", () => {
+            const obj = { key: "value", nested: { num: 42 } };
+            assert_1.strict.deepEqual((0, buffer_utils_1.processResponse)(obj), obj);
+        });
+        it("should pass through plain arrays", () => {
+            const arr = [1, "two", { three: 3 }];
+            assert_1.strict.deepEqual((0, buffer_utils_1.processResponse)(arr), arr);
+        });
+        it("should decompress Buffer at root level", () => {
+            const originalData = { decompressed: true };
+            const buffer = createGzippedBuffer(originalData);
+            const result = (0, buffer_utils_1.processResponse)(buffer);
+            assert_1.strict.deepEqual(result, originalData);
+        });
+        it("should decompress nested Buffer fields", () => {
+            const statusData = { commands: { power: true } };
+            const response = {
+                plain: "data",
+                status: createGzippedBuffer(statusData),
+            };
+            const result = (0, buffer_utils_1.processResponse)(response);
+            assert_1.strict.equal(result.plain, "data");
+            assert_1.strict.deepEqual(result.status, statusData);
+        });
+        it("should recursively decompress deeply nested Buffers", () => {
+            const innerData = { value: 42 };
+            const middleData = { inner: createGzippedBuffer(innerData) };
+            const response = {
+                outer: createGzippedBuffer(middleData),
+            };
+            const result = (0, buffer_utils_1.processResponse)(response);
+            assert_1.strict.deepEqual(result, { outer: { inner: { value: 42 } } });
+        });
+        it("should handle arrays containing Buffers", () => {
+            const itemData = { id: 1 };
+            const response = {
+                items: [createGzippedBuffer(itemData), { id: 2 }],
+            };
+            const result = (0, buffer_utils_1.processResponse)(response);
+            assert_1.strict.deepEqual(result.items, [{ id: 1 }, { id: 2 }]);
+        });
+        it("should handle mixed compressed and uncompressed fields", () => {
+            const compressedStatus = { commands: { power: true } };
+            const response = {
+                status: createGzippedBuffer(compressedStatus),
+                nvm: { user_parameters: { temperature: 22 } },
+                plain_field: "unchanged",
+            };
+            const result = (0, buffer_utils_1.processResponse)(response);
+            assert_1.strict.deepEqual(result.status, compressedStatus);
+            assert_1.strict.deepEqual(result.nvm, { user_parameters: { temperature: 22 } });
+            assert_1.strict.equal(result.plain_field, "unchanged");
+        });
+        it("should handle real-world DeviceInfo structure with compressed status", () => {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { board: 25, enviroment: 20 },
+            };
+            const nvmData = {
+                user_parameters: {
+                    enviroment_1_temperature: 22,
+                    enviroment_2_temperature: 0,
+                    enviroment_3_temperature: 0,
+                    is_auto: false,
+                    is_sound_active: true,
+                },
+            };
+            const response = {
+                status: createGzippedBuffer(statusData),
+                nvm: createGzippedBuffer(nvmData),
+            };
+            const result = (0, buffer_utils_1.processResponse)(response);
+            assert_1.strict.deepEqual(result.status, statusData);
+            assert_1.strict.deepEqual(result.nvm, nvmData);
+        });
+    });
+});

package/dist/cjs/src/cli.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+const commander_1 = require("commander");
+const readline_1 = __importDefault(require("readline"));
+const package_json_1 = require("../package.json");
+const constants_1 = require("./constants");
+const library_1 = require("./library");
+const token_storage_1 = require("./token-storage");
+const promptPassword = () => {
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+    });
+    return new Promise((resolve) => {
+        rl.question("Enter password: ", (password) => {
+            // Hide the password input
+            readline_1.default.moveCursor(process.stdout, 0, -1);
+            readline_1.default.clearLine(process.stdout, 0);
+            rl.close();
+            resolve(password);
+        });
+        // Disable input echoing for password
+        process.stdin.on("data", (char) => {
+            if (char.toString("hex") === "0d0a")
+                return; // Enter key
+            process.stdout.write("*");
+        });
+    });
+};
+/**
+ * Adds common options (username and password) to a command.
+ * Username is optional if a session already exists.
+ * @param command The command to which options should be added.
+ * @returns The command with options added.
+ */
+const addAuthOptions = (command) => command
+    .option("-u, --username <username>", "Username (optional if session exists)")
+    .option("-p, --password <password>", "Password");
+/**
+ * Adds MAC address option to a command.
+ * @param command The command to which the MAC address option should be added.
+ * @returns The command with the MAC address option added.
+ */
+const addMacOption = (command) => command.requiredOption("-m, --mac <macAddress>", "MAC address of the device");
+/**
+ * Adds legacy API option to a command.
+ * @param command The command to which the legacy option should be added.
+ * @returns The command with the legacy option added.
+ */
+const addLegacyOption = (command) => command.option("--legacy", "Use legacy API endpoint (old AWS Gateway)");
+/**
+ * Handles common authentication and API initialization logic.
+ * Tries to use existing session first, falls back to sign-in if needed.
+ * @param options The options passed from the CLI command.
+ * @returns An object containing the normalized MAC, JWT token, and configured API instance.
+ */
+const initializeCommand = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { username, password, mac, legacy = false } = options;
+    const normalizedMac = mac.replace(/:/g, "");
+    // Initialize file storage for session persistence
+    const storage = (0, token_storage_1.createFileStorage)();
+    (0, library_1.configureAmplify)(storage);
+    let jwtToken;
+    try {
+        // Try to get existing session first
+        jwtToken = yield (0, library_1.getSession)(false, legacy);
+    }
+    catch (_a) {
+        // No session, need to sign in
+        if (!username) {
+            throw new Error("No session found. Please provide --username to sign in.");
+        }
+        const pwd = password || (yield promptPassword());
+        jwtToken = yield (0, library_1.signIn)(username, pwd, legacy);
+    }
+    const apiUrl = legacy ? constants_1.OLD_API_URL : constants_1.NEW_API_URL;
+    const api = (0, library_1.configure)(apiUrl);
+    return { normalizedMac, jwtToken, api };
+});
+/**
+ * Executes a getter command by handling common steps (authentication, API initialization).
+ * @param options The options passed from the CLI command.
+ * @param getter A function to call on the configured API object.
+ */
+const executeGetter = (options, getter) => __awaiter(void 0, void 0, void 0, function* () {
+    const { normalizedMac, jwtToken, api } = yield initializeCommand(options);
+    const result = yield getter(api, jwtToken, normalizedMac);
+    console.log(result);
+});
+/**
+ * Executes a setter command by handling common steps (authentication, API initialization).
+ * @param options The options passed from the CLI command.
+ * @param setter A function to call on the configured API object.
+ */
+const executeSetter = (options, setter) => __awaiter(void 0, void 0, void 0, function* () {
+    const { normalizedMac, jwtToken, api } = yield initializeCommand(options);
+    const result = yield setter(api, jwtToken, normalizedMac, options.value);
+    console.log(result);
+});
+const createProgram = () => {
+    const program = new commander_1.Command();
+    program
+        .name("edilkamin-cli")
+        .description("CLI tool for interacting with the Edilkamin API")
+        .version(package_json_1.version);
+    // Command: signIn
+    program
+        .command("signIn")
+        .description("Sign in and retrieve a JWT token")
+        .requiredOption("-u, --username <username>", "Username")
+        .option("-p, --password <password>", "Password")
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        const { username, password } = options;
+        // Initialize file storage for session persistence
+        const storage = (0, token_storage_1.createFileStorage)();
+        (0, library_1.configureAmplify)(storage);
+        const pwd = password || (yield promptPassword());
+        const jwtToken = yield (0, library_1.signIn)(username, pwd);
+        console.log("JWT Token:", jwtToken);
+    }));
+    // Command: logout
+    program
+        .command("logout")
+        .description("Clear stored session")
+        .action(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, token_storage_1.clearSession)();
+        console.log("Session cleared successfully");
+    }));
+    // Generic getter commands
+    [
+        {
+            commandName: "deviceInfo",
+            description: "Retrieve device info for a specific MAC address",
+            getter: (api, jwtToken, mac) => api.deviceInfo(jwtToken, mac),
+        },
+        {
+            commandName: "getPower",
+            description: "Retrieve device power status",
+            getter: (api, jwtToken, mac) => api.getPower(jwtToken, mac),
+        },
+        {
+            commandName: "getEnvironmentTemperature",
+            description: "Retrieve environment temperature",
+            getter: (api, jwtToken, mac) => api.getEnvironmentTemperature(jwtToken, mac),
+        },
+        {
+            commandName: "getTargetTemperature",
+            description: "Retrieve target temperature",
+            getter: (api, jwtToken, mac) => api.getTargetTemperature(jwtToken, mac),
+        },
+    ].forEach(({ commandName, description, getter }) => {
+        addLegacyOption(addMacOption(addAuthOptions(program.command(commandName).description(description)))).action((options) => executeGetter(options, getter));
+    });
+    // Generic setter commands
+    [
+        {
+            commandName: "setPower",
+            description: "Set the power state of the device (1 for ON, 0 for OFF)",
+            setter: (api, jwtToken, mac, value) => api.setPower(jwtToken, mac, value),
+        },
+        {
+            commandName: "setTargetTemperature",
+            description: "Set the target temperature (degree celsius) for a device",
+            setter: (api, jwtToken, mac, value) => api.setTargetTemperature(jwtToken, mac, value),
+        },
+    ].forEach(({ commandName, description, setter }) => {
+        addLegacyOption(addMacOption(addAuthOptions(program.command(commandName).description(description)).requiredOption("-v, --value <number>", "Value to set", parseFloat))).action((options) => executeSetter(options, setter));
+    });
+    // Command: register
+    addLegacyOption(addAuthOptions(program
+        .command("register")
+        .description("Register a device with your account")))
+        .requiredOption("-m, --mac <macAddress>", "MAC address of the device")
+        .requiredOption("-s, --serial <serialNumber>", "Device serial number")
+        .requiredOption("-n, --name <deviceName>", "Device name")
+        .requiredOption("-r, --room <deviceRoom>", "Room name")
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        const { username, password, mac, serial, name, room, legacy = false, } = options;
+        const normalizedMac = mac.replace(/:/g, "");
+        // Initialize file storage for session persistence
+        const storage = (0, token_storage_1.createFileStorage)();
+        (0, library_1.configureAmplify)(storage);
+        let jwtToken;
+        try {
+            jwtToken = yield (0, library_1.getSession)(false, legacy);
+        }
+        catch (_a) {
+            if (!username) {
+                throw new Error("No session found. Please provide --username to sign in.");
+            }
+            const pwd = password || (yield promptPassword());
+            jwtToken = yield (0, library_1.signIn)(username, pwd, legacy);
+        }
+        const apiUrl = legacy ? constants_1.OLD_API_URL : constants_1.NEW_API_URL;
+        const api = (0, library_1.configure)(apiUrl);
+        const result = yield api.registerDevice(jwtToken, normalizedMac, serial, name, room);
+        console.log("Device registered successfully:");
+        console.log(JSON.stringify(result, null, 2));
+    }));
+    // Command: editDevice
+    addLegacyOption(addMacOption(addAuthOptions(program
+        .command("editDevice")
+        .description("Update device name and room"))))
+        .requiredOption("-n, --name <deviceName>", "Device name")
+        .requiredOption("-r, --room <deviceRoom>", "Room name")
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        const { username, password, mac, name, room, legacy = false } = options;
+        const normalizedMac = mac.replace(/:/g, "");
+        // Initialize file storage for session persistence
+        const storage = (0, token_storage_1.createFileStorage)();
+        (0, library_1.configureAmplify)(storage);
+        let jwtToken;
+        try {
+            jwtToken = yield (0, library_1.getSession)(false, legacy);
+        }
+        catch (_a) {
+            if (!username) {
+                throw new Error("No session found. Please provide --username to sign in.");
+            }
+            const pwd = password || (yield promptPassword());
+            jwtToken = yield (0, library_1.signIn)(username, pwd, legacy);
+        }
+        const apiUrl = legacy ? constants_1.OLD_API_URL : constants_1.NEW_API_URL;
+        const api = (0, library_1.configure)(apiUrl);
+        const result = yield api.editDevice(jwtToken, normalizedMac, name, room);
+        console.log("Device updated successfully:");
+        console.log(JSON.stringify(result, null, 2));
+    }));
+    return program;
+};
+const main = () => {
+    const program = createProgram();
+    program.parse(process.argv);
+};
+exports.main = main;
+if (require.main === module) {
+    main();
+}