flaks-node-hon 1.0.0

package/src/connection.js

@@ -0,0 +1,73 @@
+const constants = require("./constants");
+const { HonAuthError } = require("./errors");
+
+class HonConnection {
+  constructor(auth, fetchImpl = globalThis.fetch) {
+    this.auth = auth;
+    this.fetch = fetchImpl;
+  }
+
+  async get(url, options = {}) {
+    return this.request("GET", url, options);
+  }
+
+  async post(url, options = {}) {
+    return this.request("POST", url, options);
+  }
+
+  async request(method, url, options = {}, loop = 0) {
+    const headers = {
+      "user-agent": constants.USER_AGENT,
+      "Content-Type": "application/json",
+      ...(options.headers || {})
+    };
+    if (this.auth.refreshToken && this.auth.tokenExpiresSoon() && loop === 0) {
+      await this.auth.refresh();
+    }
+    if (!this.auth.sessionToken || !this.auth.idToken) {
+      await this.auth.initialize();
+    }
+    headers["cognito-token"] = this.auth.sessionToken;
+    headers["id-token"] = this.auth.idToken;
+
+    const response = await this.fetch(url, { ...options, method, headers });
+    if ((this.auth.tokenExpiresSoon() || response.status === 401 || response.status === 403) && loop === 0) {
+      await this.auth.refresh();
+      return this.request(method, url, options, loop + 1);
+    }
+    if ((this.auth.tokenIsExpired() || response.status === 401 || response.status === 403) && loop === 1) {
+      await this.auth.authenticate();
+      return this.request(method, url, options, loop + 1);
+    }
+    if (loop >= 2 && (response.status === 401 || response.status === 403)) {
+      throw new HonAuthError("Login failure", { status: response.status, url });
+    }
+    return response;
+  }
+}
+
+class HonAnonymousConnection {
+  constructor(fetchImpl = globalThis.fetch) {
+    this.fetch = fetchImpl;
+  }
+
+  async get(url, options = {}) {
+    return this.request("GET", url, options);
+  }
+
+  async post(url, options = {}) {
+    return this.request("POST", url, options);
+  }
+
+  async request(method, url, options = {}) {
+    const headers = {
+      "user-agent": constants.USER_AGENT,
+      "Content-Type": "application/json",
+      "x-api-key": constants.API_KEY,
+      ...(options.headers || {})
+    };
+    return this.fetch(url, { ...options, method, headers });
+  }
+}
+
+module.exports = { HonConnection, HonAnonymousConnection };

package/src/constants.js

@@ -0,0 +1,17 @@
+module.exports = {
+  AUTH_API: "https://account2.hon-smarthome.com",
+  API_URL: "https://api-iot.he.services",
+  API_KEY: "GRCqFhC6Gk@ikWXm1RmnSmX1cm,MxY-configuration",
+  AWS_ENDPOINT: "a30f6tqw0oh1x0-ats.iot.eu-west-1.amazonaws.com",
+  AWS_AUTHORIZER: "candy-iot-authorizer",
+  APP: "hon",
+  CLIENT_ID:
+    "3MVG9QDx8IX8nP5T2Ha8ofvlmjLZl5L_gvfbT9." +
+    "HJvpHGKoAS_dcMN8LYpTSYeVFCraUnV.2Ag1Ki7m4znVO6",
+  APP_VERSION: "2.6.5",
+  OS_VERSION: 999,
+  OS: "android",
+  DEVICE_MODEL: "pyhOn",
+  USER_AGENT: "Chrome/999.999.999.999",
+  MOBILE_ID: "pyhOn"
+};

package/src/device.js

@@ -0,0 +1,29 @@
+const constants = require("./constants");
+
+class HonDevice {
+  constructor(mobileId = "") {
+    this.appVersion = constants.APP_VERSION;
+    this.osVersion = constants.OS_VERSION;
+    this.os = constants.OS;
+    this.deviceModel = constants.DEVICE_MODEL;
+    this.mobileId = mobileId || constants.MOBILE_ID;
+  }
+
+  get(mobile = false) {
+    /** @type {{ appVersion: string | number, mobileId: string, os?: string, osVersion: string | number, deviceModel: string, mobileOs?: string }} */
+    const result = {
+      appVersion: this.appVersion,
+      mobileId: this.mobileId,
+      os: this.os,
+      osVersion: this.osVersion,
+      deviceModel: this.deviceModel
+    };
+    if (mobile) {
+      result.mobileOs = result.os;
+      delete result.os;
+    }
+    return result;
+  }
+}
+
+module.exports = { HonDevice };

package/src/errors.js

@@ -0,0 +1,38 @@
+class HonAuthError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "HonAuthError";
+    this.details = details;
+  }
+}
+
+class HonApiError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "HonApiError";
+    this.details = details;
+  }
+}
+
+class UnsupportedControlError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "UnsupportedControlError";
+    this.details = details;
+  }
+}
+
+class ApplianceNotFoundError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "ApplianceNotFoundError";
+    this.details = details;
+  }
+}
+
+module.exports = {
+  HonAuthError,
+  HonApiError,
+  UnsupportedControlError,
+  ApplianceNotFoundError
+};

package/src/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const { HonClient } = require("./client");
+const { HonAppliance } = require("./appliance");
+const { HonCommand } = require("./command");
+const { HonAirConditioner } = require("./ac");
+const presetGenerator = require("./preset-generator");
+const {
+  HonAuthError,
+  HonApiError,
+  UnsupportedControlError,
+  ApplianceNotFoundError,
+} = require("./errors");
+
+module.exports = {
+  HonClient,
+  HonAppliance,
+  HonCommand,
+  HonAirConditioner,
+  presetGenerator,
+  HonAuthError,
+  HonApiError,
+  UnsupportedControlError,
+  ApplianceNotFoundError,
+};

package/src/lib/config.js

@@ -0,0 +1,22 @@
+const path = require("node:path");
+
+function loadConfig(configPath = path.resolve(__dirname, "..", "config.js")) {
+  const resolved = path.resolve(configPath);
+  const config = require(resolved);
+  validateConfig(config, resolved);
+  return config;
+}
+
+function validateConfig(config, source = "config") {
+  if (!config || typeof config !== "object") {
+    throw new TypeError(`${source} must export a config object`);
+  }
+  for (const key of ["email", "password", "sessionFile"]) {
+    if (!config[key] || typeof config[key] !== "string") {
+      throw new TypeError(`${source} must define string ${key}`);
+    }
+  }
+  return true;
+}
+
+module.exports = { loadConfig, validateConfig };

package/src/lib/cookie-jar.js

@@ -0,0 +1,36 @@
+class CookieJar {
+  constructor() {
+    this.cookies = new Map();
+  }
+
+  addFromResponse(headers) {
+    const values =
+      typeof headers.getSetCookie === "function"
+        ? headers.getSetCookie()
+        : splitSetCookie(headers.get("set-cookie"));
+    for (const value of values) {
+      const cookie = value.split(";")[0];
+      const index = cookie.indexOf("=");
+      if (index > 0) {
+        this.cookies.set(cookie.slice(0, index), cookie.slice(index + 1));
+      }
+    }
+  }
+
+  header() {
+    return [...this.cookies.entries()].map(([key, value]) => `${key}=${value}`).join("; ");
+  }
+
+  clear() {
+    this.cookies.clear();
+  }
+}
+
+function splitSetCookie(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(/,(?=\s*[^;,=\s]+=[^;,]+)/g);
+}
+
+module.exports = { CookieJar };

package/src/lib/logger.js

@@ -0,0 +1,56 @@
+class DebugLogger {
+  /**
+   * @param {{ enabled?: boolean, sink?: (line: string) => void, now?: () => Date }} [options]
+   */
+  constructor({ enabled = false, sink = console.log, now = () => new Date() } = {}) {
+    this.enabled = Boolean(enabled);
+    this.sink = sink;
+    this.now = now;
+  }
+
+  log(message) {
+    this.write(message, this.now());
+  }
+
+  write(message, date) {
+    if (!this.enabled) {
+      return;
+    }
+    this.sink(`${formatTimestamp(date)}: ${message}`);
+  }
+
+  start(message) {
+    const startedAt = this.now();
+    this.write(message, startedAt);
+    return {
+      success: (message) => {
+        const endedAt = this.now();
+        this.write(`${message} (${formatElapsed(startedAt, endedAt)})`, endedAt);
+      },
+      failure: (message) => {
+        const endedAt = this.now();
+        this.write(`${message} (${formatElapsed(startedAt, endedAt)})`, endedAt);
+      }
+    };
+  }
+}
+
+function formatTimestamp(date) {
+  const pad = (value) => String(value).padStart(2, "0");
+  return [
+    date.getFullYear(),
+    pad(date.getMonth() + 1),
+    pad(date.getDate())
+  ].join("-") + " " + [
+    pad(date.getHours()),
+    pad(date.getMinutes()),
+    pad(date.getSeconds())
+  ].join(":");
+}
+
+function formatElapsed(startedAt, endedAt) {
+  const seconds = Math.max(0, Math.round((endedAt.getTime() - startedAt.getTime()) / 1000));
+  return `${seconds}secs`;
+}
+
+module.exports = { DebugLogger, formatTimestamp, formatElapsed };

package/src/lib-cli/_format.js

@@ -0,0 +1,33 @@
+"use strict";
+
+function formatAc(ac) {
+  return `${ac.nickName} (${ac.macAddress})`;
+}
+
+function formatAcIdentifiers(ac) {
+  return `macAddress=${ac.macAddress} uniqueId=${ac.uniqueId} nickName=${ac.nickName}`;
+}
+
+function printAcList(airConditioners, writer = console.log) {
+  if (!airConditioners.length) {
+    writer("No air conditioners found.");
+    return false;
+  }
+  writer("Available air conditioners:");
+  for (const ac of airConditioners) {
+    writer(`- ${formatAcIdentifiers(ac)}`);
+  }
+  return true;
+}
+
+function printSkipped(skipped, writer = console.log) {
+  if (!skipped.length) {
+    return;
+  }
+  writer("Skipped fields:");
+  for (const item of skipped) {
+    writer(`- ${item.name}: ${item.reason}`);
+  }
+}
+
+module.exports = { formatAc, formatAcIdentifiers, printAcList, printSkipped };

package/src/lib-cli/_get-ac-client.js

@@ -0,0 +1,29 @@
+const { ApplianceNotFoundError } = require("..");
+const getClient = require("./_get-client");
+
+async function getAcClient(options = {}) {
+  const client = await getClient(options);
+  const acId = options.acId || process.env.AC_ID;
+  if (!acId) {
+    await printAvailable(client);
+    throw new ApplianceNotFoundError(
+      "Set AC_ID to one of the listed identifiers",
+    );
+  }
+
+  const ac = await client.getAirConditionerByIdCached(acId);
+
+  return { client, ac };
+}
+
+async function printAvailable(client) {
+  const airConditioners = await client.getAirConditioners();
+  console.log("Available air conditioners:");
+  for (const ac of airConditioners) {
+    console.log(
+      `- macAddress=${ac.macAddress} uniqueId=${ac.uniqueId} nickName=${ac.nickName}`,
+    );
+  }
+}
+
+module.exports = getAcClient;

package/src/lib-cli/_get-client.js

@@ -0,0 +1,25 @@
+const { HonClient } = require("..");
+const { loadConfig } = require("../lib/config");
+const path = require("node:path");
+
+async function getClient(options = {}) {
+  const baseDir = options.baseDir || path.resolve(__dirname, "..", "..");
+  const configPath = options.configPath || path.resolve(baseDir, "config.js");
+  const config = loadConfig(configPath);
+  if (config.sessionFile && !path.isAbsolute(config.sessionFile)) {
+    config.sessionFile = path.resolve(baseDir, config.sessionFile);
+  }
+  if (config.applianceCacheFile && !path.isAbsolute(config.applianceCacheFile)) {
+    config.applianceCacheFile = path.resolve(baseDir, config.applianceCacheFile);
+  }
+  if (!config.applianceCacheFile) {
+    config.applianceCacheFile = path.resolve(baseDir, "cache", ".hon-appliance-cache.json");
+  }
+  const client = new HonClient(config);
+
+  await client.create();
+
+  return client;
+}
+
+module.exports = getClient;

package/src/lib-cli/_prompt.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const readline = require("node:readline/promises");
+const { stdin: input, stdout: output } = require("node:process");
+
+function createAsk() {
+  const rl = readline.createInterface({ input, output });
+  return {
+    question: (text) => rl.question(text),
+    close: () => rl.close()
+  };
+}
+
+async function askText(ask, label, fallback, existingSecret = "") {
+  const suffix = fallback ? ` [${fallback}]` : existingSecret ? " [keep existing]" : "";
+  const answer = (await ask.question(`${label}${suffix}: `)).trim();
+  if (answer) {
+    return answer;
+  }
+  return existingSecret || fallback;
+}
+
+async function askBoolean(ask, label, fallback, writer = output.write.bind(output)) {
+  const suffix = fallback ? "Y/n" : "y/N";
+  for (;;) {
+    const answer = (await ask.question(`${label} [${suffix}]: `)).trim().toLowerCase();
+    if (!answer) {
+      return fallback;
+    }
+    if (["y", "yes", "true", "1"].includes(answer)) {
+      return true;
+    }
+    if (["n", "no", "false", "0"].includes(answer)) {
+      return false;
+    }
+    writer("Enter yes or no.\n");
+  }
+}
+
+async function promptChoice(ask, label, choices, fallback, writer = console.log) {
+  for (;;) {
+    writer(`${label}:`);
+    choices.forEach((choice, index) => {
+      writer(`  ${index + 1}. ${choice}`);
+    });
+    const answer = (await ask.question(`${label} [${fallback}]: `)).trim();
+    if (!answer) {
+      return fallback;
+    }
+    const index = Number(answer);
+    if (Number.isInteger(index) && index >= 1 && index <= choices.length) {
+      return choices[index - 1];
+    }
+    if (choices.includes(answer)) {
+      return answer;
+    }
+    writer(`Choose a number from 1 to ${choices.length}, or enter an exact value.`);
+  }
+}
+
+module.exports = { askBoolean, askText, createAsk, promptChoice };

package/src/lib-cli/_run.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const { ApplianceNotFoundError } = require("..");
+const { formatAcIdentifiers } = require("./_format");
+
+function handleCliError(error) {
+  if (error instanceof ApplianceNotFoundError && error.details?.available) {
+    console.error(error.message);
+    for (const ac of error.details.available) {
+      console.error(`- ${formatAcIdentifiers(ac)}`);
+    }
+  } else {
+    console.error(error);
+  }
+  process.exitCode = 1;
+}
+
+module.exports = { handleCliError };

package/src/lib-cli/_select-ac.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const { ApplianceNotFoundError } = require("..");
+const { findApplianceIdentifierMatches } = require("../appliance-identity");
+const { formatAc } = require("./_format");
+const { promptChoice } = require("./_prompt");
+
+async function selectAirConditioner(ask, airConditioners, acId = "") {
+  const selectedId = acId || process.env.AC_ID;
+  if (selectedId) {
+    const matches = findApplianceIdentifierMatches(airConditioners, selectedId);
+    if (matches.length === 1) {
+      return matches[0].item;
+    }
+    if (matches.length > 1) {
+      throw new ApplianceNotFoundError(`AC_ID matches multiple air conditioners: ${selectedId}`, {
+        id: selectedId,
+        matches: matches.map(({ item }) => item.identifiers)
+      });
+    }
+    throw new ApplianceNotFoundError(`No air conditioner found for AC_ID: ${selectedId}`, {
+      id: selectedId,
+      available: airConditioners.map((ac) => ac.identifiers)
+    });
+  }
+  if (airConditioners.length === 1) {
+    const ac = airConditioners[0];
+    console.log(`Selected AC: ${formatAc(ac)}`);
+    return ac;
+  }
+  const choices = airConditioners.map(formatAc);
+  const selected = await promptChoice(ask, "Air conditioner", choices, choices[0]);
+  return airConditioners[choices.indexOf(selected)];
+}
+
+module.exports = { selectAirConditioner };