@lumiastream/tapo-cove 0.0.1-alpha.1

package/dist/module/shared/utils.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuidv4 = exports.isNully = exports.isTruly = void 0;
+var checkHost = function (host) {
+    if (host && host.indexOf('http') === -1) {
+        return 'http://' + host;
+    }
+    else {
+        return host;
+    }
+};
+var isTruly = function (value) {
+    return value !== undefined && value !== null;
+};
+exports.isTruly = isTruly;
+var isNully = function (value) {
+    return value === undefined || value === null;
+};
+exports.isNully = isNully;
+var getRandomNumber = function (min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+};
+var createRandomRgb = function (min, max) {
+    return [getRandomNumber(min, max), getRandomNumber(min, max), getRandomNumber(min, max)];
+};
+var bigEndianToLilEndian = function (value, pad) {
+    var bigEndian = value.toString(16);
+    if (pad) {
+        bigEndian = bigEndian.padStart(pad, '0');
+    }
+    var lilEndian;
+    if (pad && pad === 4) {
+        lilEndian = Buffer.from(bigEndian, 'hex').readUInt16LE(0).toString(16);
+    }
+    else if (pad && pad === 8) {
+        lilEndian = Buffer.from(bigEndian, 'hex').readUInt32LE(0).toString(16);
+    }
+    else if (pad) {
+        lilEndian = Buffer.from(bigEndian, 'hex').readUIntLE(0, pad).toString(16);
+    }
+    else {
+        lilEndian = Buffer.from(bigEndian, 'hex').readUInt16LE(0).toString(16);
+    }
+    if (pad) {
+        lilEndian = lilEndian.padStart(pad, '0');
+    }
+    return lilEndian;
+};
+var rgbToHsb = function (rgbObj) {
+    var red = rgbObj.r / 255;
+    var green = rgbObj.g / 255;
+    var blue = rgbObj.b / 255;
+    var rgb = [red, green, blue];
+    var hsb = { h: 0, s: 0, b: 0 };
+    var max = maxNumberInArray(rgb);
+    var min = minNumberInArray(rgb);
+    var c = max - min;
+    var hue;
+    if (c === 0) {
+        hue = 0;
+    }
+    else if (max === red) {
+        hue = (green - blue) / c;
+        if (hue < 0) {
+            hue += 6;
+        }
+    }
+    else if (max === green) {
+        hue = 2 + (blue - red) / c;
+    }
+    else {
+        hue = 4 + (red - green) / c;
+    }
+    hsb.h = Math.round(60 * hue);
+    var lightness = max;
+    hsb.b = Math.round(lightness * 100);
+    var saturation;
+    if (c === 0) {
+        saturation = 0;
+    }
+    else {
+        saturation = c / lightness;
+    }
+    hsb.s = Math.round(saturation * 100);
+    return hsb;
+};
+var minNumberInArray = function (array) {
+    var sortedCopy = array.slice();
+    sortedCopy.sort(function (a, b) {
+        return a - b;
+    });
+    return sortedCopy[0];
+};
+var maxNumberInArray = function (array) {
+    var sortedCopy = array.slice();
+    sortedCopy.sort(function (a, b) {
+        return a - b;
+    });
+    return sortedCopy[sortedCopy.length - 1];
+};
+var encrypt = function (input, firstKey) {
+    if (firstKey === void 0) { firstKey = 0xab; }
+    var buf = Buffer.from(input);
+    var key = firstKey;
+    for (var i = 0; i < buf.length; i++) {
+        buf[i] = buf[i] ^ key;
+        key = buf[i];
+    }
+    return buf;
+};
+function encryptWithHeader(input, firstKey) {
+    if (firstKey === void 0) { firstKey = 0xab; }
+    var msgBuf = encrypt(input, firstKey);
+    var outBuf = Buffer.alloc(msgBuf.length + 4);
+    outBuf.writeUInt32BE(msgBuf.length, 0);
+    msgBuf.copy(outBuf, 4);
+    return outBuf;
+}
+function decrypt(input, firstKey) {
+    if (firstKey === void 0) { firstKey = 0xab; }
+    var buf = Buffer.from(input);
+    var key = firstKey;
+    var nextKey;
+    for (var i = 0; i < buf.length; i++) {
+        nextKey = buf[i];
+        buf[i] = buf[i] ^ key;
+        key = nextKey;
+    }
+    return buf;
+}
+function decryptWithHeader(input, firstKey) {
+    if (firstKey === void 0) { firstKey = 0xab; }
+    return decrypt(input.slice(4));
+}
+function uuidv4() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        var r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+exports.uuidv4 = uuidv4;
+exports.default = {
+    checkHost: checkHost,
+    createRandomRgb: createRandomRgb,
+    bigEndianToLilEndian: bigEndianToLilEndian,
+    rgbToHsb: rgbToHsb,
+    encrypt: encrypt,
+    encryptWithHeader: encryptWithHeader,
+    decrypt: decrypt,
+    decryptWithHeader: decryptWithHeader,
+    uuidv4: uuidv4,
+};

package/dist/module/tapo-api.d.ts

@@ -0,0 +1,48 @@
+import { LightState } from './lightstate';
+import { TapoDeviceKey } from './types/raw-types';
+export default class TapoApi {
+    _baseUrl: string;
+    _baseTapoCareUrl: string;
+    private axiosInstance;
+    private _config;
+    private _token;
+    private _devices;
+    constructor(config?: {
+        token?: string;
+        timeout?: number;
+        httpTimeout?: number;
+    });
+    auth: ({ email, password }: {
+        email: string;
+        password: string;
+    }) => Promise<string>;
+    setup: ({ email, password, devices }: {
+        email: string;
+        password: string;
+        devices: Array<{
+            id: string;
+            ip: string;
+        }>;
+    }) => Promise<Map<string, TapoDeviceKey>>;
+    getAllInfo: ({ host }: {
+        host: any;
+    }) => Promise<any>;
+    getInfo: ({ host }: {
+        host: any;
+    }) => Promise<any>;
+    sendState: (config: {
+        device: {
+            id: string;
+        };
+        state: LightState;
+        fetchConfig?: {
+            shouldWait: boolean;
+        };
+    }) => Promise<any>;
+    sendPower: (config: {
+        device: {
+            id: string;
+        };
+        power: boolean;
+    }) => void;
+}

package/dist/module/tapo-api.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var axios_1 = tslib_1.__importDefault(require("axios"));
+var lightstate_1 = require("./lightstate");
+var fetch_cove_1 = require("@lumiastream/fetch-cove");
+var utils_1 = require("./shared/utils");
+var helpers_1 = require("./shared/helpers");
+var cipher_1 = require("./shared/cipher");
+var TapoApi = (function () {
+    function TapoApi(config) {
+        var _this = this;
+        this._baseUrl = 'https://eu-wap.tplinkcloud.com/';
+        this._baseTapoCareUrl = 'https://euw1-app-tapo-care.i.tplinknbu.com';
+        this._config = {
+            authToken: null,
+            timeout: 10000,
+            httpTimeout: 4000,
+        };
+        this._devices = new Map();
+        this.auth = function (_a) {
+            var email = _a.email, password = _a.password;
+            return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var loginRequest, response;
+                return tslib_1.__generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            loginRequest = {
+                                method: 'login',
+                                params: {
+                                    appType: 'Tapo_Android',
+                                    cloudPassword: password,
+                                    cloudUserName: email,
+                                    terminalUUID: (0, utils_1.uuidv4)(),
+                                },
+                            };
+                            return [4, (0, axios_1.default)({
+                                    method: 'post',
+                                    url: this._baseUrl,
+                                    data: loginRequest,
+                                })];
+                        case 1:
+                            response = _b.sent();
+                            (0, helpers_1.throwErrorIfFound)(response.data);
+                            this._token = response.data.result.token;
+                            return [2, this._token];
+                    }
+                });
+            });
+        };
+        this.setup = function (_a) {
+            var email = _a.email, password = _a.password, devices = _a.devices;
+            return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var promises;
+                var _this = this;
+                return tslib_1.__generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            promises = devices.map(function (device) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var deviceKey, loginDeviceRequest, loginDeviceResponse;
+                                return tslib_1.__generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4, (0, helpers_1.handshake)(device.ip)];
+                                        case 1:
+                                            deviceKey = _a.sent();
+                                            loginDeviceRequest = {
+                                                method: 'login_device',
+                                                params: {
+                                                    username: (0, cipher_1.base64Encode)((0, cipher_1.shaDigest)(email)),
+                                                    password: (0, cipher_1.base64Encode)(password),
+                                                },
+                                                requestTimeMils: 0,
+                                            };
+                                            return [4, (0, helpers_1.securePassthrough)(loginDeviceRequest, deviceKey)];
+                                        case 2:
+                                            loginDeviceResponse = _a.sent();
+                                            deviceKey.token = loginDeviceResponse.token;
+                                            this._devices.set(device.id, deviceKey);
+                                            return [2];
+                                    }
+                                });
+                            }); });
+                            return [4, Promise.all(promises)];
+                        case 1:
+                            _b.sent();
+                            return [2, this._devices];
+                    }
+                });
+            });
+        };
+        this.getAllInfo = function (_a) {
+            var _this = this;
+            var host = _a.host;
+            return new Promise(function (resolve, reject) {
+                return _this.axiosInstance
+                    .get(host + '/json')
+                    .then(function (res) { return resolve(res.data); })
+                    .catch(function (err) { return reject(err); });
+            });
+        };
+        this.getInfo = this.getAllInfo;
+        this.sendState = function (config) {
+            var deviceKey = _this._devices.get(config.device.id);
+            var shouldWait = false;
+            if (config.fetchConfig && config.fetchConfig.shouldWait) {
+                shouldWait = true;
+            }
+            var values = config.state.getValues();
+            var deviceRequest = {
+                method: 'set_device_info',
+                params: values,
+                terminalUUID: (0, utils_1.uuidv4)(),
+            };
+            var encryptedRequest = (0, cipher_1.encrypt)(deviceRequest, deviceKey);
+            var securePassthroughRequest = {
+                method: 'securePassthrough',
+                params: {
+                    request: encryptedRequest,
+                },
+            };
+            return (0, fetch_cove_1.fetchWork)({
+                url: "http://".concat(deviceKey.deviceIp, "/app?token=").concat(deviceKey.token),
+                data: {
+                    method: 'POST',
+                    body: securePassthroughRequest,
+                    headers: {
+                        Cookie: deviceKey.sessionCookie,
+                    },
+                },
+                shouldWait: shouldWait,
+            });
+        };
+        this.sendPower = function (config) {
+            _this.sendState({ device: config.device, state: new lightstate_1.LightState({ on: config.power }) });
+        };
+        this.axiosInstance = axios_1.default.create();
+        this.axiosInstance.defaults.timeout = (config === null || config === void 0 ? void 0 : config.httpTimeout) || 4000;
+        this._config = tslib_1.__assign(tslib_1.__assign({}, this._config), config);
+    }
+    return TapoApi;
+}());
+exports.default = TapoApi;

package/dist/module/types/interfaces.d.ts

@@ -0,0 +1,3 @@
+import { ILumiaDeviceGenericRoot } from '@lumiastream/lumia-rgb-types';
+export interface ITapo extends ILumiaDeviceGenericRoot {
+}

package/dist/module/types/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/module/types/raw-types.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+export type RawDeviceTypes = 'SMART.TAPOBULB' | 'SMART.IPCAMERA' | 'SMART.TAPOPLUG' | 'IOT.SMARTBULB' | 'IOT.IPCAMERA' | 'IOT.SMARTPLUGSWITCH';
+export type RawTapoDevice = {
+    deviceType: RawDeviceTypes;
+    fwVer: string;
+    appServerUrl: string;
+    deviceRegion: string;
+    deviceId: string;
+    deviceName: string;
+    deviceHwVer: string;
+    alias: string;
+    deviceMac: string;
+    oemId: string;
+    deviceModel: string;
+    hwId: string;
+    fwId: string;
+    isSameRegion: boolean;
+    status: number;
+    ip?: string;
+};
+export type RawTapoDeviceInfo = {
+    device_id: string;
+    fw_ver: string;
+    hw_ver: string;
+    type: string;
+    model: string;
+    mac: string;
+    hw_id: string;
+    fw_id: string;
+    oem_id: string;
+    specs: string;
+    device_on: boolean;
+    on_time: number;
+    overheated: boolean;
+    nickname: string;
+    location: string;
+    avatar: string;
+    time_usage_today: string;
+    time_usage_past7: string;
+    time_usage_past30: string;
+    longitude: string;
+    latitude: string;
+    has_set_location_info: boolean;
+    ip: string;
+    ssid: string;
+    signal_level: number;
+    rssi: number;
+    region: string;
+    time_diff: number;
+    lang: string;
+};
+export type TapoDeviceKey = {
+    key: string | Buffer;
+    iv: string | Buffer;
+    deviceIp: string;
+    sessionCookie: string;
+    token?: string;
+};
+export type TapoVideoImage = {
+    uri: string;
+    length: number;
+    uriExpiresAt: number;
+};
+export type TapoVideo = {
+    uri: string;
+    duration: number;
+    m3u8: string;
+    startTimestamp: number;
+    uriExpiresAt: number;
+};
+export type TapoVideoPageItem = {
+    uuid: string;
+    video: TapoVideo[];
+    image: TapoVideoImage[];
+    createdTime: number;
+    eventLocalTime: string;
+};
+export type TapoVideoList = {
+    deviceId: string;
+    total: number;
+    page: number;
+    pageSize: number;
+    index: TapoVideoPageItem[];
+};

package/dist/module/types/raw-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/discovery.d.ts

@@ -0,0 +1,8 @@
+import { ILumiaDeviceType } from '@lumiastream/lumia-rgb-types';
+declare const discover: (config: {
+    token?: string;
+    email?: string;
+    password?: string;
+    types?: ILumiaDeviceType;
+}) => Promise<any>;
+export default discover;

package/lib/cjs/discovery.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var lumia_rgb_types_1 = require("@lumiastream/lumia-rgb-types");
+var axios_1 = tslib_1.__importDefault(require("axios"));
+var local_devices_1 = tslib_1.__importDefault(require("local-devices"));
+var cipher_1 = require("./shared/cipher");
+var helpers_1 = require("./shared/helpers");
+var tapo_api_1 = tslib_1.__importDefault(require("./tapo-api"));
+var discover = function (config) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var api, token, getDeviceRequest, response, devices, localDevices;
+    var _a;
+    return tslib_1.__generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                api = new tapo_api_1.default(config);
+                token = config.token;
+                if (!!token) return [3, 2];
+                return [4, api.auth({ email: config.email, password: config.password })];
+            case 1:
+                token = _b.sent();
+                _b.label = 2;
+            case 2:
+                getDeviceRequest = {
+                    method: 'getDeviceList',
+                };
+                return [4, (0, axios_1.default)({
+                        method: 'post',
+                        url: "".concat(api._baseUrl, "?token=").concat(token),
+                        data: getDeviceRequest,
+                    })];
+            case 3:
+                response = _b.sent();
+                (0, helpers_1.throwErrorIfFound)(response.data);
+                devices = [];
+                return [4, (0, local_devices_1.default)({ skipNameResolution: true })];
+            case 4:
+                localDevices = _b.sent();
+                (_a = response.data.result) === null || _a === void 0 ? void 0 : _a.deviceList.map(function (deviceInfo) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                    var findableMac_1, found, isTapo, alias, isTapo, alias;
+                    var _a, _b;
+                    return tslib_1.__generator(this, function (_c) {
+                        if (!deviceInfo.ip) {
+                            findableMac_1 = deviceInfo.deviceMac.replace(/:/g, '').toUpperCase();
+                            found = localDevices.find(function (device) { return findableMac_1 == device.mac.replace(/:/g, '').toUpperCase(); });
+                            if (found) {
+                                deviceInfo.ip = found.ip;
+                            }
+                            else {
+                                return [2];
+                            }
+                        }
+                        switch (deviceInfo.deviceType) {
+                            case 'IOT.SMARTBULB':
+                            case 'SMART.TAPOBULB': {
+                                if (config.types && config.types !== lumia_rgb_types_1.ILumiaDeviceType.LIGHT) {
+                                    return [2];
+                                }
+                                isTapo = deviceInfo.deviceType === 'SMART.TAPOBULB';
+                                alias = (_a = (isTapo ? (0, cipher_1.base64Decode)(deviceInfo.alias) : deviceInfo.alias)) !== null && _a !== void 0 ? _a : deviceInfo.deviceName;
+                                devices.push({
+                                    name: alias,
+                                    id: deviceInfo.deviceMac,
+                                    address: "http://".concat(deviceInfo.ip),
+                                    host: deviceInfo.ip,
+                                    lumiaInfo: {
+                                        alias: alias,
+                                        identifier: deviceInfo.deviceMac,
+                                        serial: deviceInfo.hwId,
+                                        lumiaType: lumia_rgb_types_1.ILumiaDeviceType.LIGHT,
+                                        zonable: false,
+                                        maxZones: 1,
+                                        zones: null,
+                                        rgb: true,
+                                        white: true,
+                                        connectionType: lumia_rgb_types_1.ILumiaDeviceConnectionType.WIFI,
+                                        brand: isTapo ? lumia_rgb_types_1.ILumiaDeviceBrands.TPLINK : lumia_rgb_types_1.ILumiaDeviceBrands.TPLINK,
+                                        product: deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.deviceModel,
+                                    },
+                                });
+                            }
+                            case 'IOT.SMARTPLUGSWITCH':
+                            case 'SMART.TAPOPLUG': {
+                                if (config.types && config.types !== lumia_rgb_types_1.ILumiaDeviceType.PLUG) {
+                                    return [2];
+                                }
+                                isTapo = deviceInfo.deviceType === 'SMART.TAPOPLUG';
+                                alias = (_b = (isTapo ? (0, cipher_1.base64Decode)(deviceInfo.alias) : deviceInfo.alias)) !== null && _b !== void 0 ? _b : deviceInfo.deviceName;
+                                devices.push({
+                                    name: alias,
+                                    id: deviceInfo.deviceMac,
+                                    address: "http://".concat(deviceInfo.ip),
+                                    host: deviceInfo.ip,
+                                    lumiaInfo: {
+                                        alias: alias,
+                                        identifier: deviceInfo.deviceMac,
+                                        serial: deviceInfo.hwId,
+                                        lumiaType: lumia_rgb_types_1.ILumiaDeviceType.PLUG,
+                                        zonable: false,
+                                        maxZones: null,
+                                        zones: null,
+                                        rgb: false,
+                                        white: false,
+                                        connectionType: lumia_rgb_types_1.ILumiaDeviceConnectionType.WIFI,
+                                        brand: isTapo ? lumia_rgb_types_1.ILumiaDeviceBrands.TPLINK : lumia_rgb_types_1.ILumiaDeviceBrands.TPLINK,
+                                        product: deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.deviceModel,
+                                    },
+                                });
+                            }
+                        }
+                        return [2];
+                    });
+                }); });
+                return [2, devices];
+        }
+    });
+}); };
+exports.default = discover;

package/lib/cjs/index.d.ts

@@ -0,0 +1,5 @@
+import discover from './discovery';
+import { LightState } from './lightstate';
+import TapoApi from './tapo-api';
+import * as TapoConstants from './shared/tapo.constants';
+export { LightState, discover, TapoApi, TapoConstants, };

package/lib/cjs/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TapoConstants = exports.TapoApi = exports.discover = exports.LightState = void 0;
+var tslib_1 = require("tslib");
+var discovery_1 = tslib_1.__importDefault(require("./discovery"));
+exports.discover = discovery_1.default;
+var lightstate_1 = require("./lightstate");
+Object.defineProperty(exports, "LightState", { enumerable: true, get: function () { return lightstate_1.LightState; } });
+var tapo_api_1 = tslib_1.__importDefault(require("./tapo-api"));
+exports.TapoApi = tapo_api_1.default;
+var TapoConstants = tslib_1.__importStar(require("./shared/tapo.constants"));
+exports.TapoConstants = TapoConstants;

package/lib/cjs/lightstate.d.ts

@@ -0,0 +1,39 @@
+declare class SuperState {
+    protected _values: {};
+    transition: (value: number) => this;
+    duration: (value: number) => this;
+    getValues: () => {};
+}
+export declare class LightState extends SuperState {
+    constructor(values?: any);
+    create: (values?: any) => this;
+    on: (value?: boolean) => this;
+    turnOn: (value?: boolean) => this;
+    off: () => this;
+    turnOff: () => this;
+    mode: (value?: string) => this;
+    hue: (value: number) => this;
+    bri: (value: number) => this;
+    brightness: (value: number) => this;
+    sat: (value: number) => this;
+    saturation: (value: number) => this;
+    temp: (value: number) => this;
+    colorTemperature: (value: number) => this;
+    hsv: (value: [number, number, number] | {
+        h: number;
+        s: number;
+        v: number;
+    }) => this;
+    rgb: (value: [number, number, number] | {
+        r: number;
+        g: number;
+        b: number;
+    }) => this;
+    color: (value: {
+        ct?: number;
+        r?: number;
+        g?: number;
+        b?: number;
+    }) => this;
+}
+export {};