homebridge-tuya-pool-heater 1.0.1

package/dist/settings.test.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const settings_1 = require("./settings");
+describe('Mode detection helpers', () => {
+    describe('isHeatingMode', () => {
+        it('should return true for Heating_Smart', () => {
+            expect((0, settings_1.isHeatingMode)(settings_1.TUYA_MODES.HEATING_SMART)).toBe(true);
+        });
+        it('should return true for Heating_Powerful', () => {
+            expect((0, settings_1.isHeatingMode)(settings_1.TUYA_MODES.HEATING_POWERFUL)).toBe(true);
+        });
+        it('should return true for Heating_Silent', () => {
+            expect((0, settings_1.isHeatingMode)(settings_1.TUYA_MODES.HEATING_SILENT)).toBe(true);
+        });
+        it('should return false for cooling modes', () => {
+            expect((0, settings_1.isHeatingMode)(settings_1.TUYA_MODES.COOLING_SMART)).toBe(false);
+            expect((0, settings_1.isHeatingMode)(settings_1.TUYA_MODES.COOLING_POWERFUL)).toBe(false);
+            expect((0, settings_1.isHeatingMode)(settings_1.TUYA_MODES.COOLING_SILENT)).toBe(false);
+        });
+        it('should return false for auto mode', () => {
+            expect((0, settings_1.isHeatingMode)(settings_1.TUYA_MODES.AUTO)).toBe(false);
+        });
+        it('should be case insensitive', () => {
+            expect((0, settings_1.isHeatingMode)('HEATING_SMART')).toBe(true);
+            expect((0, settings_1.isHeatingMode)('heating_smart')).toBe(true);
+        });
+    });
+    describe('isCoolingMode', () => {
+        it('should return true for Cooling_Smart', () => {
+            expect((0, settings_1.isCoolingMode)(settings_1.TUYA_MODES.COOLING_SMART)).toBe(true);
+        });
+        it('should return true for Cooling_Powerful', () => {
+            expect((0, settings_1.isCoolingMode)(settings_1.TUYA_MODES.COOLING_POWERFUL)).toBe(true);
+        });
+        it('should return true for Cooling_Silent', () => {
+            expect((0, settings_1.isCoolingMode)(settings_1.TUYA_MODES.COOLING_SILENT)).toBe(true);
+        });
+        it('should return false for heating modes', () => {
+            expect((0, settings_1.isCoolingMode)(settings_1.TUYA_MODES.HEATING_SMART)).toBe(false);
+            expect((0, settings_1.isCoolingMode)(settings_1.TUYA_MODES.HEATING_POWERFUL)).toBe(false);
+            expect((0, settings_1.isCoolingMode)(settings_1.TUYA_MODES.HEATING_SILENT)).toBe(false);
+        });
+        it('should return false for auto mode', () => {
+            expect((0, settings_1.isCoolingMode)(settings_1.TUYA_MODES.AUTO)).toBe(false);
+        });
+        it('should be case insensitive', () => {
+            expect((0, settings_1.isCoolingMode)('COOLING_SMART')).toBe(true);
+            expect((0, settings_1.isCoolingMode)('cooling_smart')).toBe(true);
+        });
+    });
+    describe('isAutoMode', () => {
+        it('should return true for Auto', () => {
+            expect((0, settings_1.isAutoMode)(settings_1.TUYA_MODES.AUTO)).toBe(true);
+        });
+        it('should return false for heating modes', () => {
+            expect((0, settings_1.isAutoMode)(settings_1.TUYA_MODES.HEATING_SMART)).toBe(false);
+        });
+        it('should return false for cooling modes', () => {
+            expect((0, settings_1.isAutoMode)(settings_1.TUYA_MODES.COOLING_SMART)).toBe(false);
+        });
+        it('should be case insensitive', () => {
+            expect((0, settings_1.isAutoMode)('AUTO')).toBe(true);
+            expect((0, settings_1.isAutoMode)('auto')).toBe(true);
+            expect((0, settings_1.isAutoMode)('Auto')).toBe(true);
+        });
+    });
+});
+describe('Temperature conversion helpers', () => {
+    describe('tuyaTempToCelsius', () => {
+        it('should divide by TEMP_SCALE (10)', () => {
+            expect((0, settings_1.tuyaTempToCelsius)(250)).toBe(25);
+            expect((0, settings_1.tuyaTempToCelsius)(200)).toBe(20);
+            expect((0, settings_1.tuyaTempToCelsius)(355)).toBe(35.5);
+        });
+        it('should handle zero', () => {
+            expect((0, settings_1.tuyaTempToCelsius)(0)).toBe(0);
+        });
+        it('should handle negative values', () => {
+            expect((0, settings_1.tuyaTempToCelsius)(-50)).toBe(-5);
+        });
+    });
+    describe('celsiusToTuyaTemp', () => {
+        it('should multiply by TEMP_SCALE (10)', () => {
+            expect((0, settings_1.celsiusToTuyaTemp)(25)).toBe(250);
+            expect((0, settings_1.celsiusToTuyaTemp)(20)).toBe(200);
+        });
+        it('should round to nearest integer', () => {
+            expect((0, settings_1.celsiusToTuyaTemp)(25.4)).toBe(254);
+            expect((0, settings_1.celsiusToTuyaTemp)(25.5)).toBe(255);
+            expect((0, settings_1.celsiusToTuyaTemp)(25.6)).toBe(256);
+        });
+        it('should handle zero', () => {
+            expect((0, settings_1.celsiusToTuyaTemp)(0)).toBe(0);
+        });
+        it('should handle negative values', () => {
+            expect((0, settings_1.celsiusToTuyaTemp)(-5)).toBe(-50);
+        });
+    });
+    describe('round-trip conversion', () => {
+        it('should preserve integer celsius values', () => {
+            const original = 28;
+            const tuya = (0, settings_1.celsiusToTuyaTemp)(original);
+            const back = (0, settings_1.tuyaTempToCelsius)(tuya);
+            expect(back).toBe(original);
+        });
+        it('should preserve values at 0.1 precision', () => {
+            const original = 28.5;
+            const tuya = (0, settings_1.celsiusToTuyaTemp)(original);
+            const back = (0, settings_1.tuyaTempToCelsius)(tuya);
+            expect(back).toBe(original);
+        });
+    });
+});
+describe('Constants', () => {
+    describe('TEMP_SCALE', () => {
+        it('should be 10', () => {
+            expect(settings_1.TEMP_SCALE).toBe(10);
+        });
+    });
+    describe('TEMP_RANGES', () => {
+        it('should have valid heating range', () => {
+            expect(settings_1.TEMP_RANGES.heating.min).toBeLessThan(settings_1.TEMP_RANGES.heating.max);
+        });
+        it('should have valid cooling range', () => {
+            expect(settings_1.TEMP_RANGES.cooling.min).toBeLessThan(settings_1.TEMP_RANGES.cooling.max);
+        });
+        it('should have valid auto range', () => {
+            expect(settings_1.TEMP_RANGES.auto.min).toBeLessThan(settings_1.TEMP_RANGES.auto.max);
+        });
+    });
+    describe('DP_CODES', () => {
+        it('should have all required codes', () => {
+            expect(settings_1.DP_CODES.SWITCH).toBe('switch');
+            expect(settings_1.DP_CODES.MODE).toBe('mode');
+            expect(settings_1.DP_CODES.TEMP_CURRENT).toBe('temp_current');
+            expect(settings_1.DP_CODES.SET_HEATING_TEMP).toBe('set_heating_temp');
+            expect(settings_1.DP_CODES.SET_COOLING_TEMP).toBe('set_cold_temp');
+            expect(settings_1.DP_CODES.SET_AUTO_TEMP).toBe('set_auto_temp');
+        });
+    });
+    describe('TUYA_MODES', () => {
+        it('should have all mode values', () => {
+            expect(settings_1.TUYA_MODES.AUTO).toBe('Auto');
+            expect(settings_1.TUYA_MODES.HEATING_SMART).toBe('Heating_Smart');
+            expect(settings_1.TUYA_MODES.HEATING_POWERFUL).toBe('Heating_Powerful');
+            expect(settings_1.TUYA_MODES.HEATING_SILENT).toBe('Heating_Silent');
+            expect(settings_1.TUYA_MODES.COOLING_SMART).toBe('Cooling_Smart');
+            expect(settings_1.TUYA_MODES.COOLING_POWERFUL).toBe('Cooling_Powerful');
+            expect(settings_1.TUYA_MODES.COOLING_SILENT).toBe('Cooling_Silent');
+        });
+    });
+});

package/dist/thermostatAccessory.d.ts

@@ -0,0 +1,27 @@
+import { PlatformAccessory, CharacteristicValue } from 'homebridge';
+import { TuyaPoolHeatPumpPlatform } from './platform';
+import { DeviceConfig } from './settings';
+export declare class ThermostatAccessory {
+    private service;
+    private readonly platform;
+    private readonly accessory;
+    private readonly deviceConfig;
+    private currentTemperature;
+    private targetTemperature;
+    private currentHeatingCoolingState;
+    private targetHeatingCoolingState;
+    private lastCommandTime;
+    private readonly commandDebounceMs;
+    constructor(platform: TuyaPoolHeatPumpPlatform, accessory: PlatformAccessory, deviceConfig: DeviceConfig);
+    private fetchInitialStatus;
+    private updateState;
+    private currentModeString;
+    private getTempRange;
+    private updateModeFromTuya;
+    getCurrentTemperature(): Promise<CharacteristicValue>;
+    getTargetTemperature(): Promise<CharacteristicValue>;
+    setTargetTemperature(value: CharacteristicValue): Promise<void>;
+    getCurrentHeatingCoolingState(): Promise<CharacteristicValue>;
+    getTargetHeatingCoolingState(): Promise<CharacteristicValue>;
+    setTargetHeatingCoolingState(value: CharacteristicValue): Promise<void>;
+}

package/dist/thermostatAccessory.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThermostatAccessory = void 0;
+const settings_1 = require("./settings");
+class ThermostatAccessory {
+    service;
+    platform;
+    accessory;
+    deviceConfig;
+    // Cached state
+    currentTemperature = 20;
+    targetTemperature = 25;
+    currentHeatingCoolingState = 0; // OFF
+    targetHeatingCoolingState = 0; // OFF
+    // Debounce polling after commands
+    lastCommandTime = 0;
+    commandDebounceMs = 10000; // Ignore polls for 10 seconds after command
+    constructor(platform, accessory, deviceConfig) {
+        this.platform = platform;
+        this.accessory = accessory;
+        this.deviceConfig = deviceConfig;
+        // Set accessory information
+        this.accessory.getService(this.platform.Service.AccessoryInformation)
+            .setCharacteristic(this.platform.Characteristic.Manufacturer, 'Tuya')
+            .setCharacteristic(this.platform.Characteristic.Model, 'Pool Heat Pump')
+            .setCharacteristic(this.platform.Characteristic.SerialNumber, deviceConfig.id);
+        // Get or create Thermostat service
+        this.service = this.accessory.getService(this.platform.Service.Thermostat)
+            || this.accessory.addService(this.platform.Service.Thermostat);
+        this.service.setCharacteristic(this.platform.Characteristic.Name, deviceConfig.name);
+        // Set temperature display units to Celsius
+        this.service.setCharacteristic(this.platform.Characteristic.TemperatureDisplayUnits, this.platform.Characteristic.TemperatureDisplayUnits.CELSIUS);
+        // Configure CurrentTemperature
+        this.service.getCharacteristic(this.platform.Characteristic.CurrentTemperature)
+            .setProps({
+            minValue: -10,
+            maxValue: 60,
+            minStep: 0.1,
+        })
+            .onGet(this.getCurrentTemperature.bind(this));
+        // Configure TargetTemperature
+        this.service.getCharacteristic(this.platform.Characteristic.TargetTemperature)
+            .setProps({
+            minValue: 5,
+            maxValue: 55,
+            minStep: 1,
+        })
+            .onGet(this.getTargetTemperature.bind(this))
+            .onSet(this.setTargetTemperature.bind(this));
+        // Configure CurrentHeatingCoolingState (read-only)
+        this.service.getCharacteristic(this.platform.Characteristic.CurrentHeatingCoolingState)
+            .onGet(this.getCurrentHeatingCoolingState.bind(this));
+        // Configure TargetHeatingCoolingState
+        this.service.getCharacteristic(this.platform.Characteristic.TargetHeatingCoolingState)
+            .onGet(this.getTargetHeatingCoolingState.bind(this))
+            .onSet(this.setTargetHeatingCoolingState.bind(this));
+        // Register for status updates
+        this.platform.registerStatusCallback(this.deviceConfig.id, (status) => {
+            this.updateState(status);
+        });
+        // Log configured temperature ranges
+        this.platform.log.info(`Device ${deviceConfig.name} temperature ranges:`);
+        this.platform.log.info(`  Heating: ${JSON.stringify(deviceConfig.heatingRange ?? 'using default')}`);
+        this.platform.log.info(`  Cooling: ${JSON.stringify(deviceConfig.coolingRange ?? 'using default')}`);
+        this.platform.log.info(`  Auto: ${JSON.stringify(deviceConfig.autoRange ?? 'using default')}`);
+        // Initial status fetch
+        this.fetchInitialStatus();
+    }
+    async fetchInitialStatus() {
+        try {
+            const status = await this.platform.tuyaApi.getDeviceStatus(this.deviceConfig.id);
+            this.updateState(status);
+        }
+        catch (error) {
+            this.platform.log.error('Failed to fetch initial status:', error);
+        }
+    }
+    updateState(status) {
+        // Ignore polled updates briefly after sending a command to avoid race conditions
+        if (Date.now() - this.lastCommandTime < this.commandDebounceMs) {
+            this.platform.log.debug('Ignoring polled state update (recent command sent)');
+            return;
+        }
+        // Process MODE first so temperature updates use correct mode
+        const modeDP = status.find(dp => dp.code === settings_1.DP_CODES.MODE);
+        if (modeDP) {
+            this.updateModeFromTuya(modeDP.value);
+        }
+        for (const dp of status) {
+            switch (dp.code) {
+                case settings_1.DP_CODES.SWITCH:
+                    if (!dp.value) {
+                        this.currentHeatingCoolingState = this.platform.Characteristic.CurrentHeatingCoolingState.OFF;
+                        this.targetHeatingCoolingState = this.platform.Characteristic.TargetHeatingCoolingState.OFF;
+                        this.service.updateCharacteristic(this.platform.Characteristic.CurrentHeatingCoolingState, this.currentHeatingCoolingState);
+                        this.service.updateCharacteristic(this.platform.Characteristic.TargetHeatingCoolingState, this.targetHeatingCoolingState);
+                    }
+                    break;
+                case settings_1.DP_CODES.TEMP_CURRENT:
+                    this.currentTemperature = (0, settings_1.tuyaTempToCelsius)(dp.value);
+                    this.service.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, this.currentTemperature);
+                    break;
+                case settings_1.DP_CODES.SET_HEATING_TEMP:
+                    if ((0, settings_1.isHeatingMode)(this.currentModeString)) {
+                        this.targetTemperature = (0, settings_1.tuyaTempToCelsius)(dp.value);
+                        this.service.updateCharacteristic(this.platform.Characteristic.TargetTemperature, this.targetTemperature);
+                    }
+                    break;
+                case settings_1.DP_CODES.SET_COOLING_TEMP:
+                    if ((0, settings_1.isCoolingMode)(this.currentModeString)) {
+                        this.targetTemperature = (0, settings_1.tuyaTempToCelsius)(dp.value);
+                        this.service.updateCharacteristic(this.platform.Characteristic.TargetTemperature, this.targetTemperature);
+                    }
+                    break;
+                case settings_1.DP_CODES.SET_AUTO_TEMP:
+                    if (this.currentModeString === settings_1.TUYA_MODES.AUTO) {
+                        this.targetTemperature = (0, settings_1.tuyaTempToCelsius)(dp.value);
+                        this.service.updateCharacteristic(this.platform.Characteristic.TargetTemperature, this.targetTemperature);
+                    }
+                    break;
+                case settings_1.DP_CODES.MODE:
+                    // Already processed above
+                    break;
+            }
+        }
+    }
+    currentModeString = 'Auto';
+    getTempRange() {
+        if ((0, settings_1.isHeatingMode)(this.currentModeString)) {
+            return this.deviceConfig.heatingRange ?? settings_1.TEMP_RANGES.heating;
+        }
+        else if ((0, settings_1.isCoolingMode)(this.currentModeString)) {
+            return this.deviceConfig.coolingRange ?? settings_1.TEMP_RANGES.cooling;
+        }
+        return this.deviceConfig.autoRange ?? settings_1.TEMP_RANGES.auto;
+    }
+    updateModeFromTuya(mode) {
+        this.currentModeString = mode;
+        if ((0, settings_1.isHeatingMode)(mode)) {
+            this.currentHeatingCoolingState = this.platform.Characteristic.CurrentHeatingCoolingState.HEAT;
+            this.targetHeatingCoolingState = this.platform.Characteristic.TargetHeatingCoolingState.HEAT;
+        }
+        else if ((0, settings_1.isCoolingMode)(mode)) {
+            this.currentHeatingCoolingState = this.platform.Characteristic.CurrentHeatingCoolingState.COOL;
+            this.targetHeatingCoolingState = this.platform.Characteristic.TargetHeatingCoolingState.COOL;
+        }
+        else {
+            this.currentHeatingCoolingState = this.platform.Characteristic.CurrentHeatingCoolingState.HEAT;
+            this.targetHeatingCoolingState = this.platform.Characteristic.TargetHeatingCoolingState.AUTO;
+        }
+        // Update temperature range based on mode
+        const range = this.getTempRange();
+        this.service.getCharacteristic(this.platform.Characteristic.TargetTemperature)
+            .setProps({
+            minValue: range.min,
+            maxValue: range.max,
+            minStep: 1,
+        });
+        // Clamp current target temp to new range
+        if (this.targetTemperature > range.max) {
+            this.targetTemperature = range.max;
+            this.service.updateCharacteristic(this.platform.Characteristic.TargetTemperature, this.targetTemperature);
+        }
+        else if (this.targetTemperature < range.min) {
+            this.targetTemperature = range.min;
+            this.service.updateCharacteristic(this.platform.Characteristic.TargetTemperature, this.targetTemperature);
+        }
+        this.service.updateCharacteristic(this.platform.Characteristic.CurrentHeatingCoolingState, this.currentHeatingCoolingState);
+        this.service.updateCharacteristic(this.platform.Characteristic.TargetHeatingCoolingState, this.targetHeatingCoolingState);
+    }
+    // Handlers
+    async getCurrentTemperature() {
+        return this.currentTemperature;
+    }
+    async getTargetTemperature() {
+        return this.targetTemperature;
+    }
+    async setTargetTemperature(value) {
+        const originalTemp = value;
+        // Clamp to valid range for current mode
+        const range = this.getTempRange();
+        const temp = Math.max(range.min, Math.min(range.max, originalTemp));
+        this.platform.log.info(`Setting target temperature: requested ${originalTemp}°C, clamped to ${temp}°C (range: ${range.min}-${range.max}, mode: ${this.currentModeString})`);
+        const tuyaTemp = (0, settings_1.celsiusToTuyaTemp)(temp);
+        // Determine which DP to use based on current mode
+        let dpCode = settings_1.DP_CODES.SET_HEATING_TEMP;
+        if ((0, settings_1.isCoolingMode)(this.currentModeString)) {
+            dpCode = settings_1.DP_CODES.SET_COOLING_TEMP;
+        }
+        else if (!(0, settings_1.isHeatingMode)(this.currentModeString)) {
+            // Auto mode (not heating and not cooling)
+            dpCode = settings_1.DP_CODES.SET_AUTO_TEMP;
+        }
+        this.lastCommandTime = Date.now();
+        const success = await this.platform.tuyaApi.sendCommand(this.deviceConfig.id, dpCode, tuyaTemp);
+        if (success) {
+            this.targetTemperature = temp;
+        }
+    }
+    async getCurrentHeatingCoolingState() {
+        return this.currentHeatingCoolingState;
+    }
+    async getTargetHeatingCoolingState() {
+        return this.targetHeatingCoolingState;
+    }
+    async setTargetHeatingCoolingState(value) {
+        const state = value;
+        this.platform.log.info(`Setting target heating/cooling state to ${state}`);
+        this.lastCommandTime = Date.now();
+        if (state === this.platform.Characteristic.TargetHeatingCoolingState.OFF) {
+            // Turn off
+            await this.platform.tuyaApi.sendCommand(this.deviceConfig.id, settings_1.DP_CODES.SWITCH, false);
+            this.targetHeatingCoolingState = state;
+            this.currentHeatingCoolingState = this.platform.Characteristic.CurrentHeatingCoolingState.OFF;
+            return;
+        }
+        // Turn on if needed
+        await this.platform.tuyaApi.sendCommand(this.deviceConfig.id, settings_1.DP_CODES.SWITCH, true);
+        // Set mode
+        let mode;
+        switch (state) {
+            case this.platform.Characteristic.TargetHeatingCoolingState.HEAT:
+                mode = settings_1.TUYA_MODES.HEATING_SMART;
+                break;
+            case this.platform.Characteristic.TargetHeatingCoolingState.COOL:
+                mode = settings_1.TUYA_MODES.COOLING_SMART;
+                break;
+            case this.platform.Characteristic.TargetHeatingCoolingState.AUTO:
+            default:
+                mode = settings_1.TUYA_MODES.AUTO;
+                break;
+        }
+        await this.platform.tuyaApi.sendCommand(this.deviceConfig.id, settings_1.DP_CODES.MODE, mode);
+        this.targetHeatingCoolingState = state;
+        this.currentModeString = mode; // Update immediately so temperature commands use correct DP
+    }
+}
+exports.ThermostatAccessory = ThermostatAccessory;

package/dist/tuyaApi.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from 'homebridge';
+import { PluginOptions, TuyaDeviceStatus } from './settings';
+export declare class TuyaApi {
+    private readonly client;
+    private tokenInfo;
+    private readonly options;
+    private readonly log;
+    constructor(options: PluginOptions, log: Logger);
+    private sign;
+    private request;
+    authenticate(): Promise<void>;
+    private ensureToken;
+    getDeviceStatus(deviceId: string): Promise<TuyaDeviceStatus[]>;
+    sendCommand(deviceId: string, code: string, value: boolean | number | string): Promise<boolean>;
+    sendCommands(deviceId: string, commands: Array<{
+        code: string;
+        value: boolean | number | string;
+    }>): Promise<boolean>;
+}

package/dist/tuyaApi.js

@@ -0,0 +1,233 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TuyaApi = void 0;
+const axios_1 = __importDefault(require("axios"));
+const crypto_1 = __importDefault(require("crypto"));
+class TuyaApi {
+    client;
+    tokenInfo = null;
+    options;
+    log;
+    constructor(options, log) {
+        this.options = options;
+        this.log = log;
+        this.client = axios_1.default.create({
+            baseURL: options.endpoint,
+            timeout: 10000,
+        });
+    }
+    // Generate HMAC-SHA256 signature
+    sign(method, path, query = {}, body = '', timestamp, accessToken = '') {
+        // Parse path and query if query is in path
+        let basePath = path;
+        const mergedQuery = { ...query };
+        if (path.includes('?')) {
+            const [p, q] = path.split('?');
+            basePath = p;
+            if (q) {
+                q.split('&').forEach(param => {
+                    const [key, value] = param.split('=');
+                    if (key && value !== undefined) {
+                        mergedQuery[key] = value;
+                    }
+                });
+            }
+        }
+        const contentHash = crypto_1.default.createHash('sha256').update(body).digest('hex');
+        const queryString = Object.keys(mergedQuery)
+            .sort()
+            .map(key => `${key}=${mergedQuery[key]}`)
+            .join('&');
+        const url = queryString ? `${basePath}?${queryString}` : basePath;
+        const stringToSign = [
+            method.toUpperCase(),
+            contentHash,
+            '',
+            url,
+        ].join('\n');
+        const signStr = this.options.accessId + accessToken + timestamp + stringToSign;
+        return crypto_1.default
+            .createHmac('sha256', this.options.accessKey)
+            .update(signStr)
+            .digest('hex')
+            .toUpperCase();
+    }
+    // Make authenticated API request
+    async request(method, path, query = {}, body = {}) {
+        const timestamp = Date.now().toString();
+        const bodyStr = Object.keys(body).length > 0 ? JSON.stringify(body) : '';
+        const accessToken = this.tokenInfo?.accessToken || '';
+        const sign = this.sign(method, path, query, bodyStr, timestamp, accessToken);
+        const headers = {
+            't': timestamp,
+            'client_id': this.options.accessId,
+            'sign': sign,
+            'sign_method': 'HMAC-SHA256',
+        };
+        if (accessToken) {
+            headers['access_token'] = accessToken;
+        }
+        if (bodyStr) {
+            headers['Content-Type'] = 'application/json';
+        }
+        const queryString = Object.keys(query)
+            .sort()
+            .map(key => `${key}=${query[key]}`)
+            .join('&');
+        const url = queryString ? `${path}?${queryString}` : path;
+        try {
+            const response = await this.client.request({
+                method,
+                url,
+                headers,
+                data: bodyStr || undefined,
+            });
+            if (!response.data.success) {
+                throw new Error(`Tuya API error: ${response.data.code} - ${response.data.msg}`);
+            }
+            return response.data.result;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                const status = error.response?.status || 'unknown';
+                const data = error.response?.data;
+                const errorMsg = data?.msg || error.message || 'Unknown error';
+                this.log.error(`Tuya API request failed: [${status}] ${errorMsg}`);
+                if (data) {
+                    this.log.debug('Response data:', JSON.stringify(data));
+                }
+                throw new Error(`Tuya API request failed: [${status}] ${errorMsg}`);
+            }
+            const errMsg = error instanceof Error ? error.message : String(error);
+            this.log.error('Tuya API request failed:', errMsg);
+            throw new Error(`Tuya API request failed: ${errMsg}`);
+        }
+    }
+    // Get access token using user credentials
+    async authenticate() {
+        this.log.info('Authenticating with Tuya API...');
+        try {
+            // First, get a token using client credentials
+            const timestamp = Date.now().toString();
+            const path = '/v1.0/token?grant_type=1';
+            const sign = this.sign('GET', path, {}, '', timestamp);
+            const tokenResponse = await this.client.get(path, {
+                headers: {
+                    't': timestamp,
+                    'client_id': this.options.accessId,
+                    'sign': sign,
+                    'sign_method': 'HMAC-SHA256',
+                },
+            });
+            if (!tokenResponse.data.success) {
+                throw new Error(`Token request failed: ${tokenResponse.data.msg}`);
+            }
+            const tempToken = tokenResponse.data.result.access_token;
+            // Hash password
+            const passwordHash = crypto_1.default
+                .createHash('md5')
+                .update(this.options.password)
+                .digest('hex');
+            // Now authenticate with user credentials
+            const authBody = {
+                username: this.options.username,
+                password: passwordHash,
+                country_code: this.options.countryCode.toString(),
+                schema: 'smartlife',
+            };
+            const authTimestamp = Date.now().toString();
+            const authPath = '/v1.0/iot-01/associated-users/actions/authorized-login';
+            const authBodyStr = JSON.stringify(authBody);
+            const authSign = this.sign('POST', authPath, {}, authBodyStr, authTimestamp, tempToken);
+            const authResponse = await this.client.post(authPath, authBody, {
+                headers: {
+                    't': authTimestamp,
+                    'client_id': this.options.accessId,
+                    'sign': authSign,
+                    'sign_method': 'HMAC-SHA256',
+                    'access_token': tempToken,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!authResponse.data.success) {
+                throw new Error(`Authentication failed: ${authResponse.data.msg}`);
+            }
+            this.tokenInfo = {
+                accessToken: authResponse.data.result.access_token,
+                refreshToken: authResponse.data.result.refresh_token,
+                expireTime: Date.now() + (authResponse.data.result.expire_time * 1000),
+                uid: authResponse.data.result.uid,
+            };
+            this.log.info('Successfully authenticated with Tuya API');
+        }
+        catch (error) {
+            this.log.error('Authentication failed:', error);
+            throw error;
+        }
+    }
+    // Check and refresh token if needed
+    async ensureToken() {
+        if (!this.tokenInfo) {
+            await this.authenticate();
+            return;
+        }
+        // Refresh if token expires in less than 5 minutes
+        if (Date.now() > this.tokenInfo.expireTime - 300000) {
+            this.log.info('Refreshing Tuya API token...');
+            try {
+                const result = await this.request('GET', `/v1.0/token/${this.tokenInfo.refreshToken}`);
+                this.tokenInfo = {
+                    accessToken: result.access_token,
+                    refreshToken: result.refresh_token,
+                    expireTime: Date.now() + (result.expire_time * 1000),
+                    uid: result.uid,
+                };
+                this.log.info('Token refreshed successfully');
+            }
+            catch {
+                // If refresh fails, re-authenticate
+                this.log.warn('Token refresh failed, re-authenticating...');
+                this.tokenInfo = null;
+                await this.authenticate();
+            }
+        }
+    }
+    // Get device status
+    async getDeviceStatus(deviceId) {
+        await this.ensureToken();
+        const result = await this.request('GET', `/v1.0/devices/${deviceId}/status`);
+        return result;
+    }
+    // Send command to device
+    async sendCommand(deviceId, code, value) {
+        await this.ensureToken();
+        try {
+            await this.request('POST', `/v1.0/devices/${deviceId}/commands`, {}, {
+                commands: [{ code, value }],
+            });
+            this.log.debug(`Command sent: ${code} = ${value}`);
+            return true;
+        }
+        catch (error) {
+            this.log.error(`Failed to send command ${code}:`, error);
+            return false;
+        }
+    }
+    // Send multiple commands at once
+    async sendCommands(deviceId, commands) {
+        await this.ensureToken();
+        try {
+            await this.request('POST', `/v1.0/devices/${deviceId}/commands`, {}, { commands });
+            this.log.debug(`Commands sent: ${JSON.stringify(commands)}`);
+            return true;
+        }
+        catch (error) {
+            this.log.error('Failed to send commands:', error);
+            return false;
+        }
+    }
+}
+exports.TuyaApi = TuyaApi;

package/dist/tuyaApi.test.d.ts

@@ -0,0 +1 @@
+export {};