tsvesync 1.0.11

package/dist/test/testSpecial.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Special test for VeSync API
+ * Uses credentials from .env file in test directory
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// Load environment variables first
+const dotenv = __importStar(require("dotenv"));
+// Load .env file from test directory before any other imports
+dotenv.config({ path: '.env' });
+// Now import the rest of the modules
+const vesync_1 = require("../src/lib/vesync");
+const helpers_1 = require("../src/lib/helpers");
+const helpers_2 = require("../src/lib/helpers");
+/**
+ * Print detailed device status
+ */
+async function printDeviceStatus(device) {
+    console.log(`\n${device.deviceName} Status:`);
+    console.log('-'.repeat(device.deviceName.length + 8));
+    console.log('Device Name:', device.deviceName);
+    console.log('Device Type:', device.deviceType);
+    console.log('Config Module:', device.configModule);
+    console.log('Device Status:', device.deviceStatus);
+    console.log('UUID:', device.uuid);
+    console.log('MAC ID:', device.macId || 'Not available');
+    // Get latest device details
+    await device.update();
+    // Handle power devices (outlets and switches)
+    if (['ESO15-TB', 'ESW03-USA', 'wifi-switch-1.3'].includes(device.deviceType)) {
+        try {
+            // Get device details based on type
+            if (device.deviceType === 'wifi-switch-1.3') {
+                const [response] = await helpers_2.Helpers.callApi(`/v1/device/${device.cid}/detail`, 'get', null, helpers_2.Helpers.reqHeaders(device.manager));
+                if (response?.code === 0) {
+                    console.log('Power:', response.power ? `${response.power} W` : 'Not available');
+                    console.log('Voltage:', response.voltage ? `${response.voltage} V` : 'Not available');
+                    console.log('Today\'s Energy:', response.energy ? `${response.energy} kWh` : 'Not available');
+                    console.log('Active Time:', response.activeTime ? `${response.activeTime} minutes` : 'Not available');
+                }
+            }
+            else {
+                // For 10A and 15A outlets
+                const body = {
+                    ...helpers_2.Helpers.reqBody(device.manager, 'devicedetail'),
+                    uuid: device.uuid
+                };
+                const endpoint = device.deviceType === 'ESW03-USA' ? '/10a/v1/device/devicedetail' : '/15a/v1/device/devicedetail';
+                const [response] = await helpers_2.Helpers.callApi(endpoint, 'post', body, helpers_2.Helpers.reqHeaders(device.manager));
+                if (response?.code === 0) {
+                    console.log('Power:', response.power ? `${response.power} W` : 'Not available');
+                    console.log('Voltage:', response.voltage ? `${response.voltage} V` : 'Not available');
+                    console.log('Today\'s Energy:', response.energy ? `${response.energy} kWh` : 'Not available');
+                    console.log('Active Time:', response.activeTime ? `${response.activeTime} minutes` : 'Not available');
+                }
+            }
+            // Get energy history
+            console.log('Energy Usage:');
+            // Weekly energy
+            const weekBody = {
+                ...helpers_2.Helpers.reqBody(device.manager, 'energy_week'),
+                uuid: device.uuid
+            };
+            const weekEndpoint = device.deviceType === 'ESW03-USA' ? '/10a/v1/device/energyweek' : '/15a/v1/device/energyweek';
+            const [weekResponse] = await helpers_2.Helpers.callApi(weekEndpoint, 'post', weekBody, helpers_2.Helpers.reqHeaders(device.manager));
+            console.log('  Week:', weekResponse?.code === 0 ? `${weekResponse.totalEnergy} kWh` : 'Not available');
+            // Monthly energy
+            const monthBody = {
+                ...helpers_2.Helpers.reqBody(device.manager, 'energy_month'),
+                uuid: device.uuid
+            };
+            const monthEndpoint = device.deviceType === 'ESW03-USA' ? '/10a/v1/device/energymonth' : '/15a/v1/device/energymonth';
+            const [monthResponse] = await helpers_2.Helpers.callApi(monthEndpoint, 'post', monthBody, helpers_2.Helpers.reqHeaders(device.manager));
+            console.log('  Month:', monthResponse?.code === 0 ? `${monthResponse.totalEnergy} kWh` : 'Not available');
+            // Yearly energy
+            const yearBody = {
+                ...helpers_2.Helpers.reqBody(device.manager, 'energy_year'),
+                uuid: device.uuid
+            };
+            const yearEndpoint = device.deviceType === 'ESW03-USA' ? '/10a/v1/device/energyyear' : '/15a/v1/device/energyyear';
+            const [yearResponse] = await helpers_2.Helpers.callApi(yearEndpoint, 'post', yearBody, helpers_2.Helpers.reqHeaders(device.manager));
+            console.log('  Year:', yearResponse?.code === 0 ? `${yearResponse.totalEnergy} kWh` : 'Not available');
+        }
+        catch (error) {
+            console.log('Power: Error retrieving data');
+            console.log('Voltage: Error retrieving data');
+            console.log('Energy Usage:');
+            console.log('  Week: Error retrieving data');
+            console.log('  Month: Error retrieving data');
+            console.log('  Year: Error retrieving data');
+            console.log('Error details:', error);
+        }
+    }
+    // Print fan-specific details if available
+    if (device.deviceType.toLowerCase().includes('core')) {
+        try {
+            console.log('Fan Details:');
+            console.log('  Mode:', device.details?.mode || 'Not available');
+            console.log('  Fan Speed:', device.details?.speed || 'Not available');
+            console.log('  Filter Life:', device.details?.filterLife ? `${device.details.filterLife}%` : 'Not available');
+            console.log('  Screen Status:', device.details?.screenStatus !== undefined ? device.details.screenStatus : 'Not available');
+            console.log('  Child Lock:', device.details?.childLock !== undefined ? device.details.childLock : 'Not available');
+            if (device.deviceType === 'Core300S') {
+                console.log('  Air Quality:', device.details?.airQuality !== undefined ? device.details.airQuality : 'Not available');
+            }
+        }
+        catch (error) {
+            console.log('  Error getting fan details');
+        }
+    }
+}
+async function runTest() {
+    // Get credentials from .env
+    const username = process.env.VESYNC_USERNAME;
+    const password = process.env.VESYNC_PASSWORD;
+    const apiUrl = process.env.VESYNC_API_URL || 'https://smartapi.vesync.com';
+    if (!username || !password) {
+        console.error('Error: VESYNC_USERNAME and VESYNC_PASSWORD must be set in .env file');
+        process.exit(1);
+    }
+    console.log('Using credentials from .env');
+    console.log(`Username: ${username}`);
+    console.log(`Password: ${password.replace(/./g, '*')}`);
+    // Set API URL
+    (0, helpers_1.setApiBaseUrl)(apiUrl);
+    console.log(`Using API URL: ${apiUrl}`);
+    // Create VeSync manager
+    const manager = new vesync_1.VeSync(username, password);
+    // Attempt login
+    console.log('\nAttempting login...');
+    if (!await manager.login()) {
+        console.error('Login failed');
+        process.exit(1);
+    }
+    console.log('Login successful');
+    // Get devices
+    console.log('\nGetting device list...');
+    await manager.getDevices();
+    if (!manager.devices || manager.devices.length === 0) {
+        console.log('No devices found');
+        process.exit(0);
+    }
+    // Print device discovery summary
+    console.log('\n=== Device Discovery Summary ===');
+    console.log('Total devices processed:', manager.devices.length);
+    // Get unique device types
+    const deviceTypes = [...new Set(manager.devices.map(d => d.deviceType))];
+    console.log('\nDevice types found:', JSON.stringify(deviceTypes, null, 2));
+    // Group devices by category
+    console.log('\nDevices by Category:');
+    console.log('---------------------\n');
+    // Fans
+    const fans = manager.devices.filter(d => d.deviceType.toLowerCase().includes('core'));
+    if (fans.length > 0) {
+        console.log('FANS (' + fans.length + ' devices):');
+        fans.forEach(d => {
+            console.log(`  • ${d.deviceName}`);
+            console.log(`    Type: ${d.deviceType}`);
+            console.log(`    Status: ${d.deviceStatus}`);
+            console.log(`    ID: ${d.cid}`);
+        });
+    }
+    // Outlets
+    const outlets = manager.devices.filter(d => ['ESO15-TB', 'ESW03-USA', 'wifi-switch-1.3'].includes(d.deviceType));
+    if (outlets.length > 0) {
+        console.log('\nOUTLETS (' + outlets.length + ' devices):');
+        outlets.forEach(d => {
+            console.log(`  • ${d.deviceName}`);
+            console.log(`    Type: ${d.deviceType}`);
+            console.log(`    Status: ${d.deviceStatus}`);
+            console.log(`    ID: ${d.cid}`);
+        });
+    }
+    // Print summary statistics
+    console.log('\nSummary Statistics:');
+    console.log('-------------------');
+    console.log('Total Devices:', manager.devices.length);
+    console.log('fans:', fans.length, 'devices');
+    console.log('outlets:', outlets.length, 'devices');
+    console.log('switches:', manager.devices.filter(d => d.deviceType.toLowerCase().includes('switch')).length, 'devices');
+    console.log('bulbs:', manager.devices.filter(d => d.deviceType.toLowerCase().includes('bulb')).length, 'devices');
+    console.log('\n=== End of Device Discovery ===\n');
+    // Print detailed status for all devices
+    console.log('\n=== Device Status Summary ===');
+    for (const device of manager.devices) {
+        await printDeviceStatus(device);
+    }
+    console.log('\nTest complete');
+}
+// Run the test
+runTest().catch(error => {
+    console.error('Test failed:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "tsvesync",
+  "version": "1.0.11",
+  "description": "A TypeScript library for interacting with VeSync smart home devices",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepare": "npm run build",
+    "version": "git add -A src",
+    "postversion": "git push && git push --tags"
+  },
+  "keywords": [
+    "vesync",
+    "iot",
+    "smart-home",
+    "typescript",
+    "air-purifier",
+    "humidifier",
+    "smart-plug",
+    "smart-bulb"
+  ],
+  "author": "Mick Giles",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mickgiles/tsvesync.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mickgiles/tsvesync/issues"
+  },
+  "homepage": "https://github.com/mickgiles/tsvesync#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.7.9",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.10.2",
+    "dotenv": "^16.4.7",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.2"
+  },
+  "files": [
+    "dist/**/*",
+    "src/**/*",
+    "api/**/*"
+  ]
+}

package/src/lib/helpers.ts

@@ -0,0 +1,290 @@
+/**
+ * Helper functions for VeSync API
+ */
+
+import axios from 'axios';
+import crypto from 'crypto';
+import { VeSync } from './vesync';
+
+// API configuration
+let _apiBaseUrl = 'https://smartapi.vesync.com';
+
+export function getApiBaseUrl(): string {
+    return _apiBaseUrl;
+}
+
+export function setApiBaseUrl(url: string): void {
+    _apiBaseUrl = url;
+}
+
+export const API_RATE_LIMIT = 30;
+export const API_TIMEOUT = 5000;
+
+export const APP_VERSION = '2.8.6';
+export const PHONE_BRAND = 'SM N9005';
+export const PHONE_OS = 'Android';
+export const USER_TYPE = '1';
+export const DEFAULT_TZ = 'America/New_York';
+export const DEFAULT_REGION = 'US';
+export const MOBILE_ID = '1234567890123456';
+export const BYPASS_HEADER_UA = 'okhttp/3.12.1';
+
+export interface RequestBody {
+    acceptLanguage?: string;
+    accountID?: string;
+    appVersion?: string;
+    cid?: string;
+    configModule?: string;
+    debugMode?: boolean;
+    deviceRegion?: string;
+    email?: string;
+    method?: string;
+    password?: string;
+    phoneBrand?: string;
+    phoneOS?: string;
+    timeZone?: string;
+    token?: string;
+    traceId?: string;
+    userType?: string;
+    uuid?: string;
+    status?: string;
+    [key: string]: any;
+}
+
+export class Helpers {
+    static shouldRedact = true;
+
+    /**
+     * Calculate MD5 hash
+     */
+    static md5(text: string): string {
+        return crypto.createHash('md5').update(text).digest('hex');
+    }
+
+    /**
+     * Build header for legacy api GET requests
+     */
+    static reqHeaders(manager: VeSync): Record<string, string> {
+        if (!manager.accountId || !manager.token) {
+            throw new Error('Manager accountId and token must be set');
+        }
+        return {
+            'accept-language': 'en',
+            'accountId': manager.accountId,
+            'appVersion': APP_VERSION,
+            'content-type': 'application/json',
+            'tk': manager.token,
+            'tz': manager.timeZone
+        };
+    }
+
+    /**
+     * Build header for api requests on 'bypass' endpoint
+     */
+    static reqHeaderBypass(): Record<string, string> {
+        return {
+            'Content-Type': 'application/json; charset=UTF-8',
+            'User-Agent': BYPASS_HEADER_UA
+        };
+    }
+
+    /**
+     * Return universal keys for body of api requests
+     */
+    static reqBodyBase(manager: VeSync): Record<string, string> {
+        return {
+            'timeZone': manager.timeZone,
+            'acceptLanguage': 'en'
+        };
+    }
+
+    /**
+     * Keys for authenticating api requests
+     */
+    static reqBodyAuth(manager: VeSync): Record<string, any> {
+        if (!manager.accountId || !manager.token) {
+            throw new Error('Manager accountId and token must be set');
+        }
+        return {
+            'accountID': manager.accountId,
+            'token': manager.token
+        };
+    }
+
+    /**
+     * Detail keys for api requests
+     */
+    static reqBodyDetails(): Record<string, string> {
+        return {
+            'appVersion': APP_VERSION,
+            'phoneBrand': PHONE_BRAND,
+            'phoneOS': PHONE_OS,
+            'traceId': Date.now().toString()
+        };
+    }
+
+    /**
+     * Builder for body of api requests
+     */
+    static reqBody(manager: VeSync, type: string): Record<string, any> {
+        const body = {
+            ...this.reqBodyBase(manager)
+        };
+
+        if (type === 'login') {
+            return {
+                ...body,
+                ...this.reqBodyDetails(),
+                email: manager.username,
+                password: this.hashPassword(manager.password),
+                devToken: '',
+                userType: USER_TYPE,
+                method: 'login'
+            };
+        }
+
+        const authBody = {
+            ...body,
+            ...this.reqBodyAuth(manager)
+        };
+
+        if (type === 'devicestatus') {
+            return authBody;
+        }
+
+        const fullBody = {
+            ...authBody,
+            ...this.reqBodyDetails()
+        };
+
+        switch (type) {
+            case 'devicelist':
+                return {
+                    ...fullBody,
+                    method: 'devices',
+                    pageNo: '1',
+                    pageSize: '100'
+                };
+            case 'devicedetail':
+                return {
+                    ...fullBody,
+                    method: 'devicedetail',
+                    mobileId: MOBILE_ID
+                };
+            case 'bypass':
+                return {
+                    ...fullBody,
+                    method: 'bypass'
+                };
+            case 'bypassV2':
+                return {
+                    ...fullBody,
+                    deviceRegion: DEFAULT_REGION,
+                    method: 'bypassV2'
+                };
+            case 'bypass_config':
+                return {
+                    ...fullBody,
+                    method: 'firmwareUpdateInfo'
+                };
+            default:
+                return fullBody;
+        }
+    }
+
+    /**
+     * Call VeSync API
+     */
+    static async callApi(
+        endpoint: string,
+        method: string,
+        data: any = null,
+        headers: Record<string, string> = {}
+    ): Promise<[any, number]> {
+        try {
+            const url = _apiBaseUrl + endpoint;
+            const response = await axios({
+                method,
+                url,
+                data,
+                headers,
+                timeout: API_TIMEOUT
+            });
+
+            return [response.data, response.status];
+        } catch (error: any) {
+            if (error.response) {
+                return [error.response.data, error.response.status];
+            }
+            console.error('API call failed:', error.message);
+            return [null, 0];
+        }
+    }
+
+    /**
+     * Calculate hex value from energy response
+     */
+    static calculateHex(hexStr: string): string {
+        if (!hexStr || !hexStr.includes(':')) {
+            return '0';
+        }
+
+        const [prefix, value] = hexStr.split(':');
+        if (!prefix || !value) {
+            return '0';
+        }
+
+        try {
+            const decoded = Buffer.from(value, 'hex');
+            return decoded.readFloatBE(0).toString();
+        } catch (error) {
+            console.debug('Error decoding hex value:', error);
+            return '0';
+        }
+    }
+
+    /**
+     * Build energy dictionary from API response
+     */
+    static buildEnergyDict(result: any): Record<string, any> {
+        if (!result) {
+            return {};
+        }
+
+        return {
+            energy_consumption_of_today: result.energyConsumptionOfToday || 0,
+            cost_per_kwh: result.costPerKWH || 0,
+            max_energy: result.maxEnergy || 0,
+            total_energy: result.totalEnergy || 0,
+            data: result.data || [],
+            energy_consumption: result.energy || 0,
+            start_time: result.startTime || '',
+            end_time: result.endTime || ''
+        };
+    }
+
+    /**
+     * Build configuration dictionary from API response
+     */
+    static buildConfigDict(result: any): Record<string, any> {
+        if (!result) {
+            return {};
+        }
+
+        return {
+            configModule: result.configModule || '',
+            firmwareVersion: result.currentFirmVersion || '',
+            deviceRegion: result.deviceRegion || '',
+            debugMode: result.debugMode || false,
+            deviceTimezone: result.deviceTimezone || DEFAULT_TZ,
+            ...result
+        };
+    }
+
+    /**
+     * Calculate MD5 hash
+     */
+    static hashPassword(text: string): string {
+        return crypto.createHash('md5').update(text).digest('hex');
+    }
+}