edilkamin 1.6.1 → 1.7.2

package/dist/esm/serial-utils.test.js

@@ -0,0 +1,48 @@
+import { strict as assert } from "assert";
+import { serialNumberDisplay, serialNumberFromHex, serialNumberToHex, } from "./serial-utils";
+describe("serial-utils", () => {
+    describe("serialNumberToHex", () => {
+        it("should convert ASCII string to hex", () => {
+            assert.equal(serialNumberToHex("EDK123"), "45444b313233");
+        });
+        it("should handle empty string", () => {
+            assert.equal(serialNumberToHex(""), "");
+        });
+        it("should convert string with non-printable chars", () => {
+            const input = "EDK\x00123";
+            const hex = serialNumberToHex(input);
+            assert.equal(hex, "45444b00313233");
+        });
+    });
+    describe("serialNumberFromHex", () => {
+        it("should convert hex back to ASCII string", () => {
+            assert.equal(serialNumberFromHex("45444b313233"), "EDK123");
+        });
+        it("should handle empty string", () => {
+            assert.equal(serialNumberFromHex(""), "");
+        });
+        it("should round-trip with toHex", () => {
+            const original = "EDK\x00123\x1F";
+            const hex = serialNumberToHex(original);
+            const restored = serialNumberFromHex(hex);
+            assert.equal(restored, original);
+        });
+    });
+    describe("serialNumberDisplay", () => {
+        it("should remove non-printable characters", () => {
+            assert.equal(serialNumberDisplay("EDK\x00123\x1F"), "EDK123");
+        });
+        it("should collapse whitespace", () => {
+            assert.equal(serialNumberDisplay("EDK  123"), "EDK 123");
+        });
+        it("should trim leading and trailing whitespace", () => {
+            assert.equal(serialNumberDisplay("  EDK123  "), "EDK123");
+        });
+        it("should handle empty string", () => {
+            assert.equal(serialNumberDisplay(""), "");
+        });
+        it("should preserve normal serial numbers", () => {
+            assert.equal(serialNumberDisplay("EDK12345678"), "EDK12345678");
+        });
+    });
+});

package/dist/esm/token-storage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Custom storage adapter for AWS Amplify that persists to file system.
+ * Used for CLI to maintain sessions between invocations.
+ */
+export declare const createFileStorage: () => {
+    setItem: (key: string, value: string) => Promise<void>;
+    getItem: (key: string) => Promise<string | null>;
+    removeItem: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+};
+/**
+ * Clears all stored session data.
+ */
+export declare const clearSession: () => Promise<void>;

package/dist/esm/token-storage.js

@@ -0,0 +1,81 @@
+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());
+    });
+};
+import { promises as fs } from "fs";
+import * as os from "os";
+import * as path from "path";
+const TOKEN_DIR = path.join(os.homedir(), ".edilkamin");
+const TOKEN_FILE = path.join(TOKEN_DIR, "session.json");
+/**
+ * Custom storage adapter for AWS Amplify that persists to file system.
+ * Used for CLI to maintain sessions between invocations.
+ */
+export const createFileStorage = () => {
+    let cache = {};
+    let loaded = false;
+    const ensureDir = () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield fs.mkdir(TOKEN_DIR, { recursive: true, mode: 0o700 });
+        }
+        catch (_a) {
+            // Directory may already exist
+        }
+    });
+    const load = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (loaded)
+            return;
+        try {
+            const data = yield fs.readFile(TOKEN_FILE, "utf-8");
+            cache = JSON.parse(data);
+        }
+        catch (_a) {
+            cache = {};
+        }
+        loaded = true;
+    });
+    const save = () => __awaiter(void 0, void 0, void 0, function* () {
+        yield ensureDir();
+        yield fs.writeFile(TOKEN_FILE, JSON.stringify(cache), {
+            encoding: "utf-8",
+            mode: 0o600,
+        });
+    });
+    return {
+        setItem: (key, value) => __awaiter(void 0, void 0, void 0, function* () {
+            yield load();
+            cache[key] = value;
+            yield save();
+        }),
+        getItem: (key) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            yield load();
+            return (_a = cache[key]) !== null && _a !== void 0 ? _a : null;
+        }),
+        removeItem: (key) => __awaiter(void 0, void 0, void 0, function* () {
+            yield load();
+            delete cache[key];
+            yield save();
+        }),
+        clear: () => __awaiter(void 0, void 0, void 0, function* () {
+            cache = {};
+            yield save();
+        }),
+    };
+};
+/**
+ * Clears all stored session data.
+ */
+export const clearSession = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield fs.unlink(TOKEN_FILE);
+    }
+    catch (_a) {
+        // File may not exist
+    }
+});

package/dist/esm/types.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Represents a Node.js Buffer object serialized to JSON.
+ * This format is used by the Edilkamin API for gzip-compressed fields.
+ */
+interface BufferEncodedType {
+    type: "Buffer";
+    data: number[];
+}
 interface CommandsType {
     power: boolean;
 }
@@ -22,4 +30,44 @@ interface DeviceInfoType {
         user_parameters: UserParametersType;
     };
 }
-export type { CommandsType, DeviceInfoType, StatusType, TemperaturesType, UserParametersType, };
+/**
+ * Raw device info response that may contain Buffer-encoded compressed fields.
+ * Used internally before processing; external callers receive DeviceInfoType.
+ */
+interface DeviceInfoRawType {
+    status: StatusType | BufferEncodedType;
+    nvm: {
+        user_parameters: UserParametersType;
+    } | BufferEncodedType;
+    component_info?: BufferEncodedType | Record<string, unknown>;
+}
+/**
+ * Request body for registering a device with a user account.
+ * All fields are required by the API.
+ */
+interface DeviceAssociationBody {
+    macAddress: string;
+    deviceName: string;
+    deviceRoom: string;
+    serialNumber: string;
+}
+/**
+ * Request body for editing a device's name and room.
+ * MAC address is specified in the URL path, not the body.
+ * Serial number cannot be changed after registration.
+ */
+interface EditDeviceAssociationBody {
+    deviceName: string;
+    deviceRoom: string;
+}
+/**
+ * Response from device registration endpoint.
+ * Structure based on Android app behavior - may need adjustment after testing.
+ */
+interface DeviceAssociationResponse {
+    macAddress: string;
+    deviceName: string;
+    deviceRoom: string;
+    serialNumber: string;
+}
+export type { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, EditDeviceAssociationBody, StatusType, TemperaturesType, UserParametersType, };

package/eslint.config.mjs

@@ -1,4 +1,6 @@
 import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import prettierConfig from "eslint-config-prettier";
+import prettierPlugin from "eslint-plugin-prettier";
 import simpleImportSort from "eslint-plugin-simple-import-sort";
 import globals from "globals";
 import tsParser from "@typescript-eslint/parser";
@@ -19,7 +21,7 @@ const compat = new FlatCompat({
 export default [
   ...compat.extends(
     "eslint:recommended",
-    "plugin:@typescript-eslint/recommended"
+    "plugin:@typescript-eslint/recommended",
   ),
   {
     plugins: {
@@ -32,4 +34,13 @@ export default [
       "simple-import-sort/exports": "error",
     },
   },
+  prettierConfig,
+  {
+    plugins: {
+      prettier: prettierPlugin,
+    },
+    rules: {
+      "prettier/prettier": "error",
+    },
+  },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edilkamin",
-  "version": "1.6.1",
+  "version": "1.7.2",
   "description": "",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -42,13 +42,15 @@
   },
   "dependencies": {
     "aws-amplify": "^6.10.0",
-    "axios": "^1.13.2"
+    "axios": "^1.13.2",
+    "pako": "^2.1.0"
   },
   "devDependencies": {
     "@aws-amplify/cli": "^7.6.21",
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.16.0",
     "@types/mocha": "^10.0.10",
+    "@types/pako": "^2.0.4",
     "@types/sinon": "^17.0.3",
     "@typescript-eslint/eslint-plugin": "^8.17.0",
     "@typescript-eslint/parser": "^8.17.0",
@@ -58,7 +60,7 @@
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "mocha": "^11.7.5",
     "nyc": "^17.1.0",
-    "prettier": "^2.5.1",
+    "prettier": "^3.7.4",
     "sinon": "^19.0.2",
     "ts-node": "^10.9.1",
     "typedoc": "^0.28.15",

package/src/buffer-utils.test.ts

@@ -0,0 +1,225 @@
+import { strict as assert } from "assert";
+import pako from "pako";
+import sinon from "sinon";
+
+import { decompressBuffer, isBuffer, processResponse } from "./buffer-utils";
+
+/**
+ * Helper to create a gzip-compressed Buffer object for testing.
+ */
+const createGzippedBuffer = (
+  data: unknown,
+): { type: "Buffer"; data: number[] } => {
+  const json = JSON.stringify(data);
+  const compressed = pako.gzip(json);
+  return {
+    type: "Buffer",
+    data: Array.from(compressed),
+  };
+};
+
+describe("buffer-utils", () => {
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe("isBuffer", () => {
+    it("should detect valid Buffer objects", () => {
+      const buffer = { type: "Buffer", data: [31, 139, 8, 0] };
+      assert.ok(isBuffer(buffer));
+    });
+
+    it("should detect empty Buffer objects", () => {
+      const buffer = { type: "Buffer", data: [] };
+      assert.ok(isBuffer(buffer));
+    });
+
+    it("should reject non-Buffer objects with wrong type", () => {
+      assert.ok(!isBuffer({ type: "NotBuffer", data: [] }));
+    });
+
+    it("should reject objects without type field", () => {
+      assert.ok(!isBuffer({ data: [1, 2, 3] }));
+    });
+
+    it("should reject objects without data field", () => {
+      assert.ok(!isBuffer({ type: "Buffer" }));
+    });
+
+    it("should reject objects with non-array data", () => {
+      assert.ok(!isBuffer({ type: "Buffer", data: "not an array" }));
+    });
+
+    it("should reject null", () => {
+      assert.ok(!isBuffer(null));
+    });
+
+    it("should reject undefined", () => {
+      assert.ok(!isBuffer(undefined));
+    });
+
+    it("should reject primitives", () => {
+      assert.ok(!isBuffer("string"));
+      assert.ok(!isBuffer(123));
+      assert.ok(!isBuffer(true));
+    });
+  });
+
+  describe("decompressBuffer", () => {
+    it("should decompress gzipped JSON buffer", () => {
+      const originalData = { test: "value", nested: { key: 123 } };
+      const bufferObj = createGzippedBuffer(originalData);
+
+      const result = decompressBuffer(bufferObj);
+      assert.deepEqual(result, originalData);
+    });
+
+    it("should handle gzipped arrays", () => {
+      const originalData = [1, 2, 3, "test"];
+      const bufferObj = createGzippedBuffer(originalData);
+
+      const result = decompressBuffer(bufferObj);
+      assert.deepEqual(result, originalData);
+    });
+
+    it("should handle gzipped strings", () => {
+      const originalData = "test string";
+      const bufferObj = createGzippedBuffer(originalData);
+
+      const result = decompressBuffer(bufferObj);
+      assert.equal(result, originalData);
+    });
+
+    it("should return original value if decompression fails", () => {
+      const consoleWarnStub = sinon.stub(console, "warn");
+      const invalidBuffer = { type: "Buffer" as const, data: [1, 2, 3] };
+
+      const result = decompressBuffer(invalidBuffer);
+
+      assert.deepEqual(result, invalidBuffer);
+      assert.ok(consoleWarnStub.calledOnce);
+    });
+
+    it("should return original value if JSON parsing fails", () => {
+      const consoleWarnStub = sinon.stub(console, "warn");
+      // Create valid gzip but invalid JSON
+      const invalidJson = "not valid json {";
+      const compressed = pako.gzip(invalidJson);
+      const bufferObj = {
+        type: "Buffer" as const,
+        data: Array.from(compressed),
+      };
+
+      const result = decompressBuffer(bufferObj);
+
+      assert.deepEqual(result, bufferObj);
+      assert.ok(consoleWarnStub.calledOnce);
+    });
+  });
+
+  describe("processResponse", () => {
+    it("should pass through null", () => {
+      assert.equal(processResponse(null), null);
+    });
+
+    it("should pass through undefined", () => {
+      assert.equal(processResponse(undefined), undefined);
+    });
+
+    it("should pass through primitives", () => {
+      assert.equal(processResponse("string"), "string");
+      assert.equal(processResponse(123), 123);
+      assert.equal(processResponse(true), true);
+    });
+
+    it("should pass through plain objects", () => {
+      const obj = { key: "value", nested: { num: 42 } };
+      assert.deepEqual(processResponse(obj), obj);
+    });
+
+    it("should pass through plain arrays", () => {
+      const arr = [1, "two", { three: 3 }];
+      assert.deepEqual(processResponse(arr), arr);
+    });
+
+    it("should decompress Buffer at root level", () => {
+      const originalData = { decompressed: true };
+      const buffer = createGzippedBuffer(originalData);
+
+      const result = processResponse(buffer);
+      assert.deepEqual(result, originalData);
+    });
+
+    it("should decompress nested Buffer fields", () => {
+      const statusData = { commands: { power: true } };
+      const response = {
+        plain: "data",
+        status: createGzippedBuffer(statusData),
+      };
+
+      const result = processResponse(response);
+      assert.equal(result.plain, "data");
+      assert.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 = processResponse(response);
+      assert.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 = processResponse(response);
+      assert.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 = processResponse(response);
+      assert.deepEqual(result.status, compressedStatus);
+      assert.deepEqual(result.nvm, { user_parameters: { temperature: 22 } });
+      assert.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 = processResponse(response);
+      assert.deepEqual(result.status, statusData);
+      assert.deepEqual(result.nvm, nvmData);
+    });
+  });
+});

package/src/buffer-utils.ts

@@ -0,0 +1,83 @@
+import pako from "pako";
+
+import { BufferEncodedType } from "./types";
+
+/**
+ * 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: unknown): value is BufferEncodedType => {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "type" in value &&
+    (value as Record<string, unknown>).type === "Buffer" &&
+    "data" in value &&
+    Array.isArray((value as Record<string, unknown>).data)
+  );
+};
+
+/**
+ * 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: BufferEncodedType): unknown => {
+  try {
+    // Convert data array to Uint8Array for pako
+    const compressed = new Uint8Array(bufferObj.data);
+
+    // Decompress with gzip
+    const decompressed = pako.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;
+  }
+};
+
+/**
+ * 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 = <T>(data: T): T => {
+  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) as T;
+  }
+
+  // Recursively process arrays
+  if (Array.isArray(data)) {
+    return data.map((item) => processResponse(item)) as T;
+  }
+
+  // Recursively process objects
+  if (typeof data === "object") {
+    const processed: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(data)) {
+      processed[key] = processResponse(value);
+    }
+    return processed as T;
+  }
+
+  // Primitive value, return as-is
+  return data;
+};
+
+export { decompressBuffer, isBuffer, processResponse };