homebridge-bestway 1.0.0

package/README.md

@@ -0,0 +1,85 @@
+<p align="center">
+  <a href="https://github.com/homebridge/homebridge"><img src="https://raw.githubusercontent.com/homebridge/branding/master/logos/homebridge-wordmark-logo-vertical.png" height="150"></a>
+</p>
+
+# homebridge-bestway
+
+[![NPM Version](https://img.shields.io/npm/v/homebridge-bestway.svg)](https://www.npmjs.com/package/homebridge-bestway)
+[![Downloads](https://img.shields.io/npm/dt/homebridge-bestway.svg)](https://www.npmjs.com/package/homebridge-bestway)
+[![verified-by-homebridge](https://badgen.net/badge/homebridge/verified/purple)](https://github.com/homebridge/homebridge/wiki/Verified-Plugins)
+
+A Homebridge plugin for controlling **Bestway** and **Lay-Z-Spa** Wi-Fi enabled hot tubs.
+
+This plugin allows you to expose your spa to Apple HomeKit, giving you control over the heater, filter, and massage bubbles.
+
+## Features
+
+*   **Thermostat Control**: Set target temperature and toggle heating.
+*   **Filter Control**: Turn the water filter pump on or off (exposed as a Switch).
+*   **Bubbles Control**: Control the massage system (exposed as a Fan/Speed Control for spas that support variable speeds, or a simple Switch for others).
+*   **Temperature Units**: Supports both Celsius and Fahrenheit (based on your region settings).
+
+## Installation
+
+### Graphical Install (Recommended)
+
+1.  Open the Homebridge UI.
+2.  Navigate to the **Plugins** tab.
+3.  Search for `Bestway` or `homebridge-bestway`.
+4.  Click **Install**.
+
+### Manual Install
+
+If you prefer the command line:
+
+```bash
+npm install -g homebridge-bestway
+```
+
+## Configuration
+
+This plugin comes with a schema definition for the Homebridge UI.
+
+1.  In the Homebridge UI, go to the **Plugins** tab.
+2.  Find `homebridge-bestway`.
+3.  Click **Settings**.
+4.  Enter your Bestway account email and password.
+5.  Select your Region (EU or US).
+6.  Save and restart Homebridge.
+
+### Configuration Fields (Manual)
+
+If you are editing `config.json` manually, here are the available fields:
+*   `email` (Required): Your Bestway account email address.
+*   `password` (Required): Your Bestway account password.
+*   `region` (Optional): The region for your account (`EU` or `US`). Defaults to `EU`.
+*   `minTempC` / `maxTempC` (Optional): Override the logic minimum/maximum temperature in Celsius (for EU users).
+*   `minTempF` / `maxTempF` (Optional): Override the logic minimum/maximum temperature in Fahrenheit (for US users).
+
+### Example `config.json`
+
+```json
+{
+  "platforms": [
+    {
+      "platform": "Bestway",
+      "email": "your-email@example.com",
+      "password": "your-password",
+      "region": "EU"
+    }
+  ]
+}
+```
+
+## Temperature Units & Region
+
+The plugin attempts to handle temperature conversions automatically:
+
+*   **EU Region**: Input and output generally expected in Celsius.
+*   **US Region**: Input and output generally expected in Fahrenheit.
+
+HomeKit natively uses Celsius, so the plugin performs necessary conversions behind the scenes if you are in a US region using Fahrenheit.
+
+## Disclaimer
+
+This plugin is a volunteer effort and is **not** officially affiliated with, endorsed by, or supported by Bestway or Lay-Z-Spa.

package/config.schema.json

@@ -0,0 +1,99 @@
+{
+  "pluginAlias": "Bestway",
+  "pluginType": "platform",
+  "singular": true,
+  "schema": {
+    "type": "object",
+    "properties": {
+      "email": {
+        "title": "Email",
+        "type": "string",
+        "required": true,
+        "format": "email"
+      },
+      "password": {
+        "title": "Password",
+        "type": "string",
+        "required": true,
+        "format": "password"
+      },
+      "region": {
+        "title": "Region",
+        "type": "string",
+        "default": "EU",
+        "enum": [
+          "EU",
+          "US"
+        ],
+        "description": "Select your Bestway account region (EU or US)."
+      },
+      "minTempC": {
+        "title": "Minimum Temperature (°C)",
+        "type": "integer",
+        "default": 38,
+        "minimum": 37,
+        "maximum": 40,
+        "description": "Logic minimum temperature (default 20°C)."
+      },
+      "maxTempC": {
+        "title": "Maximum Temperature (°C)",
+        "type": "integer",
+        "default": 40,
+        "minimum": 39,
+        "maximum": 41,
+        "description": "Logic maximum temperature (default 40°C)."
+      },
+      "minTempF": {
+        "title": "Minimum Temperature (°F)",
+        "type": "integer",
+        "default": 100,
+        "minimum": 98,
+        "maximum": 104,
+        "description": "Logic minimum temperature (default 68°F)."
+      },
+      "maxTempF": {
+        "title": "Maximum Temperature (°F)",
+        "type": "integer",
+        "default": 104,
+        "minimum": 98,
+        "maximum": 106,
+        "description": "Logic maximum temperature (default 104°F)."
+      }
+    }
+  },
+  "layout": [
+    {
+      "type": "flex",
+      "flex-flow": "row wrap",
+      "items": [
+        "email",
+        "password"
+      ]
+    },
+    "region",
+    {
+      "key": "minTempC",
+      "condition": {
+        "functionBody": "return model.region !== 'US';"
+      }
+    },
+    {
+      "key": "maxTempC",
+      "condition": {
+        "functionBody": "return model.region !== 'US';"
+      }
+    },
+    {
+      "key": "minTempF",
+      "condition": {
+        "functionBody": "return model.region === 'US';"
+      }
+    },
+    {
+      "key": "maxTempF",
+      "condition": {
+        "functionBody": "return model.region === 'US';"
+      }
+    }
+  ]
+}

package/index.js

@@ -0,0 +1,7 @@
+const { BestwayPlatform } = require('./lib/platform');
+const { PLATFORM_NAME, PLUGIN_NAME } = require('./lib/constants');
+
+module.exports = (api) => {
+  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, BestwayPlatform);
+  console.log('Homebridge-Bestway: Platform registered.');
+};

package/lib/accessory.js

@@ -0,0 +1,274 @@
+const { DeviceTypes } = require('./constants');
+
+class BestwayAccessory {
+  constructor(platform, accessory, device) {
+    this.platform = platform;
+    this.accessory = accessory;
+    this.device = device;
+    this.client = platform.client;
+    this.log = platform.log;
+
+    this.Service = platform.api.hap.Service;
+    this.Characteristic = platform.api.hap.Characteristic;
+
+    // device info
+    this.accessory.getService(this.Service.AccessoryInformation)
+      .setCharacteristic(this.Characteristic.Manufacturer, 'Bestway')
+      .setCharacteristic(this.Characteristic.Model, device.product_name || 'Spa')
+      .setCharacteristic(this.Characteristic.SerialNumber, device.did);
+
+    // Setup services based on device type
+    this.setupThermostat();
+    this.setupFilter();
+
+    // Bubble setup differs by model
+    if ([DeviceTypes.AIRJET_V01_SPA, DeviceTypes.HYDROJET_SPA, DeviceTypes.HYDROJET_PRO_SPA].includes(device.type)) {
+      this.setupBubblesFan();
+    } else {
+      this.setupBubblesSwitch();
+    }
+
+    // Start polling
+    this.poll();
+    setInterval(() => this.poll(), 30000); // Poll every 30s
+  }
+
+  async poll() {
+    try {
+      const attrs = await this.client.getDeviceState(this.device.did);
+      this.updateState(attrs);
+    } catch (error) {
+      this.log.debug('Poll failed:', error.message);
+    }
+  }
+
+  updateState(attrs) {
+    if (!attrs) return;
+
+
+
+    // Thermostat
+    const tempNow = parseInt(attrs.temp_now || attrs.Tnow || 0);
+    const tempSet = parseInt(attrs.temp_set || attrs.Tset || 0);
+    // Heat power: 0=Off, 1=On (Airjet), 3=On (Hydrojet)
+    const heatPower = attrs.heat_power || attrs.heat || 0;
+    const isHeating = heatPower > 0;
+
+    const thermostatService = this.accessory.getService(this.Service.Thermostat);
+    if (thermostatService) {
+      // The Gizwitz API returns `Tunit`: 0=Fahrenheit, 1=Celsius
+      // THe HomeKit API requires Celsius
+      const isFahrenheit = (attrs.Tunit === 0 || attrs.temp_set_unit === '华氏');
+
+      const toCelsius = (val) => {
+        const c = isFahrenheit ? (val - 32) * 5 / 9 : val;
+        return Math.round(c * 10) / 10;
+      };
+
+      const currentC = toCelsius(tempNow);
+      const targetC = toCelsius(tempSet);
+
+      if (tempNow !== 0) {
+        thermostatService.updateCharacteristic(this.Characteristic.CurrentTemperature, currentC);
+      }
+      thermostatService.updateCharacteristic(this.Characteristic.TargetTemperature, targetC);
+      thermostatService.updateCharacteristic(this.Characteristic.CurrentHeatingCoolingState, isHeating ? 1 : 0);
+      thermostatService.updateCharacteristic(this.Characteristic.TargetHeatingCoolingState, isHeating ? 1 : 0);
+
+      // Update display units
+      thermostatService.updateCharacteristic(this.Characteristic.TemperatureDisplayUnits, isFahrenheit ? 1 : 0);
+    }
+
+    // Filter (exposed as a switch)
+    const filterPower = attrs.filter_power || attrs.filter || 0;
+    const filterService = this.accessory.getService('Filter');
+    if (filterService) {
+      filterService.updateCharacteristic(this.Characteristic.On, !!filterPower);
+    }
+
+
+    // Bubbles
+    // Fan Service (Multi-speed bubbles)
+    const wavePower = attrs.wave_power || attrs.wave || 0;
+    const fanService = this.accessory.getService(this.Service.Fan);
+    if (fanService) {
+      fanService.updateCharacteristic(this.Characteristic.On, wavePower > 0);
+
+      // Bestway API: 50/51=Medium, 100=High
+      let speed = 0;
+      if (wavePower >= 100) speed = 100;
+      else if (wavePower >= 40) speed = 50;
+
+      fanService.updateCharacteristic(this.Characteristic.RotationSpeed, speed);
+    }
+
+    // Switch Service (Single-speed Fallback bubbles)
+    const bubbleSwitch = this.accessory.getService('Bubbles');
+    if (bubbleSwitch) {
+      bubbleSwitch.updateCharacteristic(this.Characteristic.On, !!wavePower);
+    }
+  }
+
+  setupThermostat() {
+    const service = this.accessory.getService(this.Service.Thermostat) || this.accessory.addService(this.Service.Thermostat);
+
+    // Set props for CurrentTemperature to ensure it accepts our range
+    service.getCharacteristic(this.Characteristic.CurrentTemperature)
+      .setProps({
+        minValue: -30,
+        maxValue: 100,
+        minStep: 0.1
+      });
+
+    // Ensure TargetHeatingCoolingState is configured correctly
+
+    service.getCharacteristic(this.Characteristic.TargetHeatingCoolingState)
+      .setProps({
+        validValues: [
+          0, // OFF
+          1  // HEAT
+        ],
+        maxValue: 1,
+        minValue: 0
+
+      })
+      .onSet(async (value) => {
+        // Hardware supports Off (0) or Heat (1)
+        const shouldHeat = value !== 0; // 0=OFF, 1=HEAT
+        this.log.debug(`[Thermostat] Setting TargetHeatingCoolingState to ${value} (Heat: ${shouldHeat})`);
+        if ([DeviceTypes.HYDROJET_SPA, DeviceTypes.HYDROJET_PRO_SPA, DeviceTypes.AIRJET_V01_SPA].includes(this.device.type)) {
+          // Hydrojet/V01: heat=3 (On), heat=0 (Off)
+          await this.client.sendCommand(this.device.did, { heat: shouldHeat ? 3 : 0 });
+        } else {
+          // Airjet: heat_power=1 (On), heat_power=0 (Off)
+          await this.client.sendCommand(this.device.did, { heat_power: shouldHeat ? 1 : 0 });
+        }
+        // Specific update required for optimistic state
+        this.poll();
+      });
+
+    // We need to figure out what the min/max temps are for this spa.
+    // HomeKit always needs Celsius internally, so if the user set their region to 'US' (implying F input),
+    // we need to convert those values before passing them along.
+    let minTemp, maxTemp;
+    const isUsRegion = this.platform.config.region === 'US';
+
+    if (isUsRegion) {
+      // Config is in F, must convert to C for HomeKit props
+      const minF = this.platform.config.minTempF || 68;
+      const maxF = this.platform.config.maxTempF || 104;
+      minTemp = Math.round((minF - 32) * 5 / 9);
+      maxTemp = Math.round((maxF - 32) * 5 / 9);
+    } else {
+      // Config is in C
+      minTemp = this.platform.config.minTempC || 20;
+      maxTemp = this.platform.config.maxTempC || 40;
+    }
+
+    this.log.info(`[Thermostat Debug] Calculated minTemp: ${minTemp}, maxTemp: ${maxTemp}`);
+
+    // Fallback/Legacy check
+    if (!this.platform.config.minTempC && !this.platform.config.minTempF && this.platform.config.minTemp) {
+      minTemp = this.platform.config.minTemp;
+    }
+    if (!this.platform.config.maxTempC && !this.platform.config.maxTempF && this.platform.config.maxTemp) {
+      maxTemp = this.platform.config.maxTemp;
+    }
+
+    service.getCharacteristic(this.Characteristic.TargetTemperature)
+      .setProps({
+        minValue: minTemp,
+        maxValue: maxTemp,
+        minStep: 0.5
+      });
+
+    // Enforce initial value is within bounds
+    const currentTarget = service.getCharacteristic(this.Characteristic.TargetTemperature).value;
+    if (currentTarget < minTemp) {
+      this.log.warn(`[Thermostat Debug] Current TargetTemp ${currentTarget} is below min ${minTemp}. Updating to ${minTemp}.`);
+      service.updateCharacteristic(this.Characteristic.TargetTemperature, minTemp);
+    }
+
+    service.getCharacteristic(this.Characteristic.TargetTemperature)
+      .onSet(async (value) => {
+        // Convert HomeKit Celsius to device unit if necessary
+        const currentAttrs = this.platform.client.stateCache[this.device.did]?.attrs || {};
+        const isFahrenheit = (currentAttrs.Tunit === 0 || currentAttrs.temp_set_unit === '华氏');
+
+        let targetVal = parseInt(value);
+        if (isFahrenheit) {
+          targetVal = Math.round((value * 9 / 5) + 32);
+        }
+
+        if ([DeviceTypes.HYDROJET_SPA, DeviceTypes.HYDROJET_PRO_SPA, DeviceTypes.AIRJET_V01_SPA].includes(this.device.type)) {
+          await this.client.sendCommand(this.device.did, { Tset: targetVal });
+        } else {
+          await this.client.sendCommand(this.device.did, { temp_set: targetVal });
+        }
+        this.poll();
+      });
+  }
+
+  setupFilter() {
+    const service = this.accessory.getService('Filter') || this.accessory.addService(this.Service.Switch, 'Filter', 'filter');
+
+    service.getCharacteristic(this.Characteristic.On)
+      .onSet(async (value) => {
+        if ([DeviceTypes.HYDROJET_SPA, DeviceTypes.HYDROJET_PRO_SPA, DeviceTypes.AIRJET_V01_SPA].includes(this.device.type)) {
+          // Hydrojet/V01 uses 'filter'=2 for ON
+          await this.client.sendCommand(this.device.did, { filter: value ? 2 : 0 });
+        } else {
+          // Standard Airjet
+          await this.client.sendCommand(this.device.did, { filter_power: value ? 1 : 0 });
+        }
+        this.poll();
+      });
+  }
+
+  setupBubblesSwitch() {
+    const service = this.accessory.getService('Bubbles') || this.accessory.addService(this.Service.Switch, 'Bubbles', 'bubbles');
+
+    service.getCharacteristic(this.Characteristic.On)
+      .onSet(async (value) => {
+        await this.client.sendCommand(this.device.did, { wave_power: value ? 1 : 0 });
+        this.poll();
+      });
+  }
+
+  setupBubblesFan() {
+    const service = this.accessory.getService(this.Service.Fan) || this.accessory.addService(this.Service.Fan, 'Bubbles', 'bubbles');
+
+    service.getCharacteristic(this.Characteristic.On)
+      .onSet(async (value) => {
+        if (!value) {
+          await this.client.sendCommand(this.device.did, { wave: 0 });
+        } else {
+          // Default to Max Intensity (100)
+          await this.client.sendCommand(this.device.did, { wave: 100 });
+        }
+        this.poll();
+      });
+
+    service.getCharacteristic(this.Characteristic.RotationSpeed)
+      .setProps({
+        minValue: 0,
+        maxValue: 100,
+        minStep: 50 // 0, 50, 100
+      })
+      .onSet(async (value) => {
+        let apiValue = 0;
+        if (value >= 90) apiValue = 100; // High
+        else if (value >= 10) apiValue = 50; // Medium
+
+        if (this.device.type === DeviceTypes.HYDROJET_SPA || this.device.type === DeviceTypes.HYDROJET_PRO_SPA) {
+          if (value >= 90) apiValue = 100;
+          else if (value >= 10) apiValue = 40;
+        }
+
+        await this.client.sendCommand(this.device.did, { wave: apiValue });
+        this.poll();
+      });
+  }
+}
+
+module.exports = { BestwayAccessory };

package/lib/api.js

@@ -0,0 +1,155 @@
+const axios = require('axios');
+const { HEADERS, APP_ID, DeviceTypes } = require('./constants');
+
+class BestwayApi {
+  constructor(apiUrl, username, password) {
+    this.apiUrl = apiUrl;
+    this.username = username;
+    this.password = password;
+    this.userToken = null;
+    this.userId = null;
+    this.devices = {};
+    this.stateCache = {};
+  }
+
+  async login() {
+    try {
+      const response = await axios.post(`${this.apiUrl}/app/login`, {
+        username: this.username,
+        password: this.password,
+        lang: 'en',
+      }, {
+        headers: HEADERS,
+      });
+
+      this.userId = response.data.uid;
+      this.userToken = response.data.token;
+      this.tokenExpiry = response.data.expire_at;
+      return true;
+    } catch (error) {
+      console.error('Login failed:', error.response ? error.response.data : error.message);
+      throw new Error('Failed to login to Bestway API');
+    }
+  }
+
+  getHeaders() {
+    return {
+      ...HEADERS,
+      'X-Gizwits-User-token': this.userToken,
+    };
+  }
+
+  async getDevices() {
+    if (!this.userToken) await this.login();
+
+    try {
+      const response = await axios.get(`${this.apiUrl}/app/bindings`, {
+        headers: this.getHeaders(),
+      });
+
+      const devices = response.data.devices || [];
+      this.devices = {};
+
+      return devices.map(d => {
+        const device = {
+          did: d.did,
+          product_name: d.product_name,
+          dev_alias: d.dev_alias,
+          is_online: d.is_online,
+          type: this.getDeviceType(d.product_name)
+        };
+        this.devices[d.did] = device;
+        return device;
+      });
+    } catch (error) {
+      if (this.isAuthError(error)) {
+        await this.login();
+        return this.getDevices();
+      }
+      throw error;
+    }
+  }
+
+  getDeviceType(productName) {
+    if (productName === 'Airjet') return DeviceTypes.AIRJET_SPA;
+    if (productName === 'Airjet_V01') return DeviceTypes.AIRJET_V01_SPA;
+    if (productName === 'Hydrojet') return DeviceTypes.HYDROJET_SPA;
+    if (productName === 'Hydrojet_Pro') return DeviceTypes.HYDROJET_PRO_SPA;
+    if (productName === '泳池过滤器') return DeviceTypes.POOL_FILTER;
+    return DeviceTypes.UNKNOWN;
+  }
+
+  async getDeviceState(deviceId) {
+    if (!this.userToken) await this.login();
+
+    try {
+      const response = await axios.get(`${this.apiUrl}/app/devdata/${deviceId}/latest`, {
+        headers: this.getHeaders(),
+      });
+
+      const data = response.data;
+      const apiTimestamp = data.updated_at;
+
+      // Check cache validity (optimistic updates)
+      // When we send a command, we update the local cache with a new timestamp.
+      // If the API returns a state with an older timestamp (due to cloud latency),
+      // we prefer our newer local state to prevent the UI from temporarily reverting.
+      if (this.stateCache[deviceId] && this.stateCache[deviceId].timestamp > apiTimestamp) {
+        return this.stateCache[deviceId].attrs;
+      }
+
+      // Update cache
+      this.stateCache[deviceId] = {
+        timestamp: apiTimestamp,
+        attrs: data.attr
+      };
+
+      return data.attr;
+    } catch (error) {
+      if (this.isAuthError(error)) {
+        await this.login();
+        return this.getDeviceState(deviceId);
+      }
+      // If 404/500 or offline, might return null or throw
+      throw error;
+    }
+  }
+
+  async sendCommand(deviceId, attrs) {
+    if (!this.userToken) await this.login();
+
+    try {
+      await axios.post(`${this.apiUrl}/app/control/${deviceId}`, {
+        attrs: attrs
+      }, {
+        headers: this.getHeaders(),
+      });
+
+      // Optimistic update
+      const now = Math.floor(Date.now() / 1000);
+      if (!this.stateCache[deviceId]) {
+        this.stateCache[deviceId] = { timestamp: 0, attrs: {} };
+      }
+
+      this.stateCache[deviceId].timestamp = now;
+      Object.assign(this.stateCache[deviceId].attrs, attrs);
+
+    } catch (error) {
+      if (this.isAuthError(error)) {
+        await this.login();
+        return this.sendCommand(deviceId, attrs);
+      }
+      throw error;
+    }
+  }
+
+  isAuthError(error) {
+    // Check for specific error codes: 9004 (Token Invalid)
+    if (error.response && error.response.data && error.response.data.error_code === 9004) {
+      return true;
+    }
+    return false;
+  }
+}
+
+module.exports = BestwayApi;

package/lib/constants.js

@@ -0,0 +1,19 @@
+module.exports = {
+  PLATFORM_NAME: 'Bestway',
+  PLUGIN_NAME: 'homebridge-bestway',
+  API_URL_EU: 'https://euapi.gizwits.com',
+  API_URL_US: 'https://usapi.gizwits.com',
+  APP_ID: '98754e684ec045528b073876c34c7348',
+  HEADERS: {
+    'Content-type': 'application/json; charset=UTF-8',
+    'X-Gizwits-Application-Id': '98754e684ec045528b073876c34c7348',
+  },
+  DeviceTypes: {
+    AIRJET_SPA: 'Airjet',
+    AIRJET_V01_SPA: 'Airjet V01',
+    HYDROJET_SPA: 'Hydrojet',
+    HYDROJET_PRO_SPA: 'Hydrojet Pro',
+    POOL_FILTER: 'Pool Filter',
+    UNKNOWN: 'Unknown'
+  }
+};

package/lib/platform.js

@@ -0,0 +1,61 @@
+const { API_URL_EU, API_URL_US, PLUGIN_NAME, PLATFORM_NAME } = require('./constants');
+const BestwayApi = require('./api');
+const { BestwayAccessory } = require('./accessory');
+
+class BestwayPlatform {
+  constructor(log, config, api) {
+    this.log = log;
+    this.config = config;
+    this.api = api;
+    this.accessories = [];
+
+    if (!config || !config.email || !config.password) {
+      this.log.error('email and password required to be added in config.json');
+      return;
+    }
+
+    const apiUrl = config.api_url || (config.region === 'US' ? API_URL_US : API_URL_EU);
+
+    this.client = new BestwayApi(
+      apiUrl,
+      config.email,
+      config.password
+    );
+
+    this.api.on('didFinishLaunching', () => {
+      this.discoverDevices();
+    });
+  }
+
+  configureAccessory(accessory) {
+    this.accessories.push(accessory);
+  }
+
+  async discoverDevices() {
+    try {
+      this.log.info('Discovering devices...');
+      const devices = await this.client.getDevices();
+
+      // Loop through discovered devices
+      for (const device of devices) {
+        const uuid = this.api.hap.uuid.generate(device.did);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
+
+        if (existingAccessory) {
+          this.log.info('Restoring existing accessory from cache:', existingAccessory.displayName);
+          new BestwayAccessory(this, existingAccessory, device);
+        } else {
+          this.log.info('Adding new accessory:', device.dev_alias);
+          const accessory = new this.api.platformAccessory(device.dev_alias || device.product_name, uuid);
+          accessory.context.device = device;
+          new BestwayAccessory(this, accessory, device);
+          this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+        }
+      }
+    } catch (error) {
+      this.log.error('Failed to discover devices:', error.message);
+    }
+  }
+}
+
+module.exports = { BestwayPlatform };

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "homebridge-bestway",
+  "version": "1.0.0",
+  "description": "Homebridge plugin for Bestway / Lay-Z-Spa hot tubs",
+  "main": "index.js",
+  "engines": {
+    "node": ">=18",
+    "homebridge": ">=1.6.0"
+  },
+  "keywords": [
+    "homebridge-plugin",
+    "homebridge",
+    "bestway",
+    "lay-z-spa"
+  ],
+  "dependencies": {
+    "axios": "^1.6.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}