edilkamin 1.6.0 → 1.6.2

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 };

package/src/cli.ts

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import readline from "readline";
 
 import { version } from "../package.json";
+import { NEW_API_URL, OLD_API_URL } from "./constants";
 import { configure, signIn } from "./library";
 
 const promptPassword = (): Promise<string> => {
@@ -45,6 +46,14 @@ const addAuthOptions = (command: Command): Command =>
 const addMacOption = (command: Command): 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): Command =>
+  command.option("--legacy", "Use legacy API endpoint (old AWS Gateway)");
+
 /**
  * Handles common authentication and API initialization logic.
  * @param options The options passed from the CLI command.
@@ -54,16 +63,18 @@ const initializeCommand = async (options: {
   username: string;
   password?: string;
   mac: string;
+  legacy?: boolean;
 }): Promise<{
   normalizedMac: string;
   jwtToken: string;
   api: ReturnType<typeof configure>;
 }> => {
-  const { username, password, mac } = options;
+  const { username, password, mac, legacy = false } = options;
   const normalizedMac = mac.replace(/:/g, "");
   const pwd = password || (await promptPassword());
-  const jwtToken = await signIn(username, pwd);
-  const api = configure();
+  const jwtToken = await signIn(username, pwd, legacy);
+  const apiUrl = legacy ? OLD_API_URL : NEW_API_URL;
+  const api = configure(apiUrl);
   return { normalizedMac, jwtToken, api };
 };
 
@@ -73,7 +84,12 @@ const initializeCommand = async (options: {
  * @param getter A function to call on the configured API object.
  */
 const executeGetter = async (
-  options: { username: string; password?: string; mac: string },
+  options: {
+    username: string;
+    password?: string;
+    mac: string;
+    legacy?: boolean;
+  },
   getter: (
     api: ReturnType<typeof configure>,
     jwtToken: string,
@@ -91,7 +107,13 @@ const executeGetter = async (
  * @param setter A function to call on the configured API object.
  */
 const executeSetter = async (
-  options: { username: string; password?: string; mac: string; value: number },
+  options: {
+    username: string;
+    password?: string;
+    mac: string;
+    value: number;
+    legacy?: boolean;
+  },
   setter: (
     api: ReturnType<typeof configure>,
     jwtToken: string,
@@ -158,8 +180,10 @@ const createProgram = (): Command => {
       ) => api.getTargetTemperature(jwtToken, mac),
     },
   ].forEach(({ commandName, description, getter }) => {
-    addMacOption(
-      addAuthOptions(program.command(commandName).description(description))
+    addLegacyOption(
+      addMacOption(
+        addAuthOptions(program.command(commandName).description(description))
+      )
     ).action((options) => executeGetter(options, getter));
   });
   // Generic setter commands
@@ -185,13 +209,75 @@ const createProgram = (): Command => {
       ) => api.setTargetTemperature(jwtToken, mac, value),
     },
   ].forEach(({ commandName, description, setter }) => {
-    addMacOption(
-      addAuthOptions(
-        program.command(commandName).description(description)
-      ).requiredOption("-v, --value <number>", "Value to set", parseFloat)
+    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(async (options) => {
+      const {
+        username,
+        password,
+        mac,
+        serial,
+        name,
+        room,
+        legacy = false,
+      } = options;
+      const normalizedMac = mac.replace(/:/g, "");
+      const pwd = password || (await promptPassword());
+      const jwtToken = await signIn(username, pwd, legacy);
+      const apiUrl = legacy ? OLD_API_URL : NEW_API_URL;
+      const api = configure(apiUrl);
+      const result = await 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(async (options) => {
+      const { username, password, mac, name, room, legacy = false } = options;
+      const normalizedMac = mac.replace(/:/g, "");
+      const pwd = password || (await promptPassword());
+      const jwtToken = await signIn(username, pwd, legacy);
+      const apiUrl = legacy ? OLD_API_URL : NEW_API_URL;
+      const api = configure(apiUrl);
+      const result = await api.editDevice(jwtToken, normalizedMac, name, room);
+      console.log("Device updated successfully:");
+      console.log(JSON.stringify(result, null, 2));
+    });
+
   return program;
 };
 

package/src/constants.ts

@@ -1,3 +1,6 @@
-const API_URL = "https://the-mind-api.edilkamin.com/";
+const OLD_API_URL =
+  "https://fxtj7xkgc6.execute-api.eu-central-1.amazonaws.com/prod/";
+const NEW_API_URL = "https://the-mind-api.edilkamin.com/";
+const API_URL = NEW_API_URL;
 
-export { API_URL };
+export { API_URL, NEW_API_URL, OLD_API_URL };

package/src/index.ts

@@ -1,10 +1,21 @@
 import { configure } from "./library";
 
-export { API_URL } from "./constants";
+export { decompressBuffer, isBuffer, processResponse } from "./buffer-utils";
+export { API_URL, NEW_API_URL, OLD_API_URL } from "./constants";
 export { configure, signIn } from "./library";
 export {
+  serialNumberDisplay,
+  serialNumberFromHex,
+  serialNumberToHex,
+} from "./serial-utils";
+export {
+  BufferEncodedType,
   CommandsType,
+  DeviceAssociationBody,
+  DeviceAssociationResponse,
+  DeviceInfoRawType,
   DeviceInfoType,
+  EditDeviceAssociationBody,
   StatusType,
   TemperaturesType,
   UserParametersType,
@@ -12,6 +23,8 @@ export {
 
 export const {
   deviceInfo,
+  registerDevice,
+  editDevice,
   setPower,
   setPowerOff,
   setPowerOn,