@lumiastream/tapo-cove 0.0.1-alpha.1

package/lib/esm/shared/helpers.js

@@ -0,0 +1,98 @@
+import { __awaiter, __generator } from "tslib";
+import axios from 'axios';
+import { decrypt, encrypt, generateKeyPair, readDeviceKey } from './cipher';
+export var throwErrorIfFound = function (responseData) {
+    var errorCode = responseData['error_code'];
+    if (errorCode) {
+        switch (errorCode) {
+            case 0:
+                return;
+            case -1010:
+                throw new Error('Invalid public key length');
+            case -1012:
+                throw new Error('Invalid terminal UUID');
+            case -1501:
+                throw new Error('Invalid request or credentials');
+            case -1002:
+                throw new Error('Incorrect request');
+            case -1003:
+                throw new Error('JSON format error');
+            case -20601:
+                throw new Error('Incorrect email or password');
+            case -20675:
+                throw new Error('Cloud token expired or invalid');
+            case 9999:
+                throw new Error('Device token expired or invalid');
+            default:
+                throw new Error("Unexpected Error Code: ".concat(errorCode, " (").concat(responseData['msg'], ")"));
+        }
+    }
+};
+export var throwTapoCareErrorIfFound = function (responseData) {
+    var errorCode = responseData === null || responseData === void 0 ? void 0 : responseData.code;
+    if (errorCode) {
+        throw new Error("Unexpected Error Code: ".concat(errorCode, " (").concat(responseData['message'], ")"));
+    }
+};
+export var handshake = function (deviceIp) { return __awaiter(void 0, void 0, void 0, function () {
+    var keyPair, handshakeRequest, response, setCookieHeader, sessionCookie, deviceKey;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4, generateKeyPair()];
+            case 1:
+                keyPair = _a.sent();
+                handshakeRequest = {
+                    method: 'handshake',
+                    params: {
+                        key: keyPair.publicKey,
+                    },
+                };
+                return [4, axios({
+                        method: 'post',
+                        url: "http://".concat(deviceIp, "/app"),
+                        data: handshakeRequest,
+                    })];
+            case 2:
+                response = _a.sent();
+                throwErrorIfFound(response.data);
+                setCookieHeader = response.headers['set-cookie'][0];
+                sessionCookie = setCookieHeader.substring(0, setCookieHeader.indexOf(';'));
+                deviceKey = readDeviceKey(response.data.result.key, keyPair.privateKey);
+                return [2, {
+                        key: deviceKey.subarray(0, 16),
+                        iv: deviceKey.subarray(16, 32),
+                        deviceIp: deviceIp,
+                        sessionCookie: sessionCookie,
+                    }];
+        }
+    });
+}); };
+export var securePassthrough = function (deviceRequest, deviceKey) { return __awaiter(void 0, void 0, void 0, function () {
+    var encryptedRequest, securePassthroughRequest, response, decryptedResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                encryptedRequest = encrypt(deviceRequest, deviceKey);
+                securePassthroughRequest = {
+                    method: 'securePassthrough',
+                    params: {
+                        request: encryptedRequest,
+                    },
+                };
+                return [4, axios({
+                        method: 'post',
+                        url: "http://".concat(deviceKey.deviceIp, "/app?token=").concat(deviceKey.token),
+                        data: securePassthroughRequest,
+                        headers: {
+                            Cookie: deviceKey.sessionCookie,
+                        },
+                    })];
+            case 1:
+                response = _a.sent();
+                throwErrorIfFound(response.data);
+                decryptedResponse = decrypt(response.data.result.response, deviceKey);
+                throwErrorIfFound(decryptedResponse);
+                return [2, decryptedResponse.result];
+        }
+    });
+}); };

package/lib/esm/shared/tapo-ca-cert.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "-----BEGIN CERTIFICATE-----\n\nMIIDBzCCAe+gAwIBAgIQT5x0ma7QnINHCQvhnmzR9zANBgkqhkiG9w0BAQsFADAV\n \nMRMwEQYDVQQDEwp0cC1saW5rLUNBMCAXDTE4MDExOTA4Mjc1MloYDzIwNjgwMTE5\n \nMDgzNzUyWjAVMRMwEQYDVQQDEwp0cC1saW5rLUNBMIIBIjANBgkqhkiG9w0BAQEF\n \nAAOCAQ8AMIIBCgKCAQEAuGG8n5zEUN1j5wuvUz4pAIMurhKHbpfUUu+b2acFHKS6\n \niU9hNJWvDyhXcihY5Wz6aq9m4D5SZcgW3k31YoNNtrztDjdg2qw7AaX85S99/G0B\n \nVbIXktrhs34OW19WA/haDwut3dFhLem+gCRRKUXcmuqchZc84dY7JFVfhPcJci4m\n \nsRjLCFNO0ho9OX+MZwfO4BLaeAqKVoAor6rf4BXVtO0xjYHDKO0fb3AWLLJ4EjGe\n \nq6YieqPiYlPFEqRm5PrvBXTm0IuQogygyVpK4LHr/K207ZLyV33DxLLbsUgSEJVn\n \npZUv/WUujXjlIDgxIvyZZCYiXO3dle2/MEvpmZk6JQIDAQABo1EwTzALBgNVHQ8E\n \nBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxu2iBRTsef5iNnsADVhM\n \nJDQWi6kwEAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQELBQADggEBAB52Majd\n \n+wo3cb5BsTo63z2Psbbyl4ACMUaw68NxUMy61Oihx3mcLzLJqiIZcKePiHskLqLJ\n \nF7QfT9TqjvizMjFJVgsLuVubUBXKBzqyN+3KKlQci0PO3mH+ObhyaE7BzV+qrS3P\n \ndVTgsCWFv8DkgLTRudSWxL7VwVoedc7lRz5EroGgJ33nRGCR0ngcW919tLTARDQO\n \npULmzulcdWeZgG+0PLX0xjJQIjFEvbOxR1Z+gxMupBz0rWFokmWYrcga8eWiWzjQ\n \nIa3/ASBVJ69srV77trWlfLumkChbXk9i64NXBKnce0Jmll0Y9OC1nMPqrbQKnzcn\n \ndSAA4fejD/qMQn0=\n\n-----END CERTIFICATE-----";
+export default _default;

package/lib/esm/shared/tapo-ca-cert.js

@@ -0,0 +1 @@
+export default "-----BEGIN CERTIFICATE-----\n\nMIIDBzCCAe+gAwIBAgIQT5x0ma7QnINHCQvhnmzR9zANBgkqhkiG9w0BAQsFADAV\n \nMRMwEQYDVQQDEwp0cC1saW5rLUNBMCAXDTE4MDExOTA4Mjc1MloYDzIwNjgwMTE5\n \nMDgzNzUyWjAVMRMwEQYDVQQDEwp0cC1saW5rLUNBMIIBIjANBgkqhkiG9w0BAQEF\n \nAAOCAQ8AMIIBCgKCAQEAuGG8n5zEUN1j5wuvUz4pAIMurhKHbpfUUu+b2acFHKS6\n \niU9hNJWvDyhXcihY5Wz6aq9m4D5SZcgW3k31YoNNtrztDjdg2qw7AaX85S99/G0B\n \nVbIXktrhs34OW19WA/haDwut3dFhLem+gCRRKUXcmuqchZc84dY7JFVfhPcJci4m\n \nsRjLCFNO0ho9OX+MZwfO4BLaeAqKVoAor6rf4BXVtO0xjYHDKO0fb3AWLLJ4EjGe\n \nq6YieqPiYlPFEqRm5PrvBXTm0IuQogygyVpK4LHr/K207ZLyV33DxLLbsUgSEJVn\n \npZUv/WUujXjlIDgxIvyZZCYiXO3dle2/MEvpmZk6JQIDAQABo1EwTzALBgNVHQ8E\n \nBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUxu2iBRTsef5iNnsADVhM\n \nJDQWi6kwEAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQELBQADggEBAB52Majd\n \n+wo3cb5BsTo63z2Psbbyl4ACMUaw68NxUMy61Oihx3mcLzLJqiIZcKePiHskLqLJ\n \nF7QfT9TqjvizMjFJVgsLuVubUBXKBzqyN+3KKlQci0PO3mH+ObhyaE7BzV+qrS3P\n \ndVTgsCWFv8DkgLTRudSWxL7VwVoedc7lRz5EroGgJ33nRGCR0ngcW919tLTARDQO\n \npULmzulcdWeZgG+0PLX0xjJQIjFEvbOxR1Z+gxMupBz0rWFokmWYrcga8eWiWzjQ\n \nIa3/ASBVJ69srV77trWlfLumkChbXk9i64NXBKnce0Jmll0Y9OC1nMPqrbQKnzcn\n \ndSAA4fejD/qMQn0=\n\n-----END CERTIFICATE-----";

package/lib/esm/shared/tapo.constants.d.ts

@@ -0,0 +1,21 @@
+export declare const TapoDeviceTypes: {
+    ALL: string;
+    BULBS: string;
+    LIGHTSTRIPS: string;
+    PLUGS: string;
+};
+export declare enum ETapoDeviceTypes {
+    ALL = "all",
+    BULBS = "bulb",
+    LIGHTSTRIPS = "lightstrip",
+    PLUGS = "plug"
+}
+export declare const DeviceResTypes: {
+    BULB: string;
+    PLUG: string;
+};
+export declare const DeviceSendValues: {
+    BULB: string;
+    LIGHTSTRIP: string;
+    PLUG: string;
+};

package/lib/esm/shared/tapo.constants.js

@@ -0,0 +1,22 @@
+export var TapoDeviceTypes = {
+    ALL: 'all',
+    BULBS: 'bulb',
+    LIGHTSTRIPS: 'lightstrip',
+    PLUGS: 'plug',
+};
+export var ETapoDeviceTypes;
+(function (ETapoDeviceTypes) {
+    ETapoDeviceTypes["ALL"] = "all";
+    ETapoDeviceTypes["BULBS"] = "bulb";
+    ETapoDeviceTypes["LIGHTSTRIPS"] = "lightstrip";
+    ETapoDeviceTypes["PLUGS"] = "plug";
+})(ETapoDeviceTypes || (ETapoDeviceTypes = {}));
+export var DeviceResTypes = {
+    BULB: 'IOT.SMARTPLUGSWITCH',
+    PLUG: 'IOT.SMARTPLUGSWITCH',
+};
+export var DeviceSendValues = {
+    BULB: 'smartlife.iot.smartbulb.lightingservice',
+    LIGHTSTRIP: 'smartlife.iot.lightStrip',
+    PLUG: 'system',
+};

package/lib/esm/shared/utils.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+export declare const isTruly: (value: any) => boolean;
+export declare const isNully: (value: any) => boolean;
+declare function encryptWithHeader(input: any, firstKey?: number): Buffer;
+declare function decrypt(input: any, firstKey?: number): Buffer;
+declare function decryptWithHeader(input: any, firstKey?: number): Buffer;
+export declare function uuidv4(): string;
+declare const _default: {
+    checkHost: (host: any) => any;
+    createRandomRgb: (min: any, max: any) => [number, number, number];
+    bigEndianToLilEndian: (value: any, pad?: any) => any;
+    rgbToHsb: (rgbObj: any) => {
+        h: number;
+        s: number;
+        b: number;
+    };
+    encrypt: (input: any, firstKey?: number) => Buffer;
+    encryptWithHeader: typeof encryptWithHeader;
+    decrypt: typeof decrypt;
+    decryptWithHeader: typeof decryptWithHeader;
+    uuidv4: typeof uuidv4;
+};
+export default _default;

package/lib/esm/shared/utils.js

@@ -0,0 +1,146 @@
+var checkHost = function (host) {
+    if (host && host.indexOf('http') === -1) {
+        return 'http://' + host;
+    }
+    else {
+        return host;
+    }
+};
+export var isTruly = function (value) {
+    return value !== undefined && value !== null;
+};
+export var isNully = function (value) {
+    return value === undefined || value === null;
+};
+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));
+}
+export 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);
+    });
+}
+export default {
+    checkHost: checkHost,
+    createRandomRgb: createRandomRgb,
+    bigEndianToLilEndian: bigEndianToLilEndian,
+    rgbToHsb: rgbToHsb,
+    encrypt: encrypt,
+    encryptWithHeader: encryptWithHeader,
+    decrypt: decrypt,
+    decryptWithHeader: decryptWithHeader,
+    uuidv4: uuidv4,
+};

package/lib/esm/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/lib/esm/tapo-api.js

@@ -0,0 +1,140 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import axios from 'axios';
+import { LightState } from './lightstate';
+import { fetchWork } from '@lumiastream/fetch-cove';
+import { uuidv4 } from './shared/utils';
+import { handshake, securePassthrough, throwErrorIfFound } from './shared/helpers';
+import { base64Encode, encrypt, shaDigest } from './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 __awaiter(_this, void 0, void 0, function () {
+                var loginRequest, response;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            loginRequest = {
+                                method: 'login',
+                                params: {
+                                    appType: 'Tapo_Android',
+                                    cloudPassword: password,
+                                    cloudUserName: email,
+                                    terminalUUID: uuidv4(),
+                                },
+                            };
+                            return [4, axios({
+                                    method: 'post',
+                                    url: this._baseUrl,
+                                    data: loginRequest,
+                                })];
+                        case 1:
+                            response = _b.sent();
+                            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 __awaiter(_this, void 0, void 0, function () {
+                var promises;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            promises = devices.map(function (device) { return __awaiter(_this, void 0, void 0, function () {
+                                var deviceKey, loginDeviceRequest, loginDeviceResponse;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4, handshake(device.ip)];
+                                        case 1:
+                                            deviceKey = _a.sent();
+                                            loginDeviceRequest = {
+                                                method: 'login_device',
+                                                params: {
+                                                    username: base64Encode(shaDigest(email)),
+                                                    password: base64Encode(password),
+                                                },
+                                                requestTimeMils: 0,
+                                            };
+                                            return [4, 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: uuidv4(),
+            };
+            var encryptedRequest = encrypt(deviceRequest, deviceKey);
+            var securePassthroughRequest = {
+                method: 'securePassthrough',
+                params: {
+                    request: encryptedRequest,
+                },
+            };
+            return 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({ on: config.power }) });
+        };
+        this.axiosInstance = axios.create();
+        this.axiosInstance.defaults.timeout = (config === null || config === void 0 ? void 0 : config.httpTimeout) || 4000;
+        this._config = __assign(__assign({}, this._config), config);
+    }
+    return TapoApi;
+}());
+export default TapoApi;

package/lib/esm/types/interfaces.d.ts

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

package/lib/esm/types/interfaces.js

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

package/lib/esm/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/lib/esm/types/raw-types.js

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

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@lumiastream/tapo-cove",
+  "version": "0.0.1-alpha.1",
+  "private": false,
+  "description": "",
+  "main": "./lib/cjs/index.js",
+  "directories": {
+    "test": "test"
+  },
+  "author": "",
+  "license": "ISC",
+  "scripts": {
+    "build": "npm run clean && tsc && tsc --module commonjs --outDir lib/cjs && tsc --module es6 --outDir lib/esm",
+    "prepublishOnly": "npm run build",
+    "lint": "tslint --project tsconfig.json \"src/**/*.ts\"",
+    "lint:fix": "tslint --project tsconfig.json --fix \"src/**/*.ts\"",
+    "clean": "rm -rf lib lib/esm lib/cjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lumiastream/tapo-cove.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lumiastream/tapo-cove/issues"
+  },
+  "homepage": "https://github.com/lumiastream/tapo-cove#readme",
+  "dependencies": {
+    "@lumiastream/lumia-rgb-types": "^0.0.4",
+    "axios": "^1.3.3",
+    "local-devices": "^4.0.0",
+    "network-cove": "0.1.3"
+  },
+  "devDependencies": {
+    "@types/node": "^18.14.0",
+    "tslib": "^2.3.0",
+    "typescript": "^4.0.5"
+  }
+}

package/test/auth.test.ts

@@ -0,0 +1,22 @@
+import { discover, TapoApi } from '../src';
+
+const email = '';
+const password = '';
+const deviceId = '';
+const deviceIp = '';
+const token = '';
+
+(async () => {
+	const api = new TapoApi({ token });
+	// const token = await api.auth({ email, password });
+	// console.log('token: ', token);
+
+	const devices = await discover({ token });
+	console.log('devices: ', devices);
+
+	// const deviceKey = await TapoApi.loginDevice(email, password, '192.168.5.204');
+	// const devices = await api.setup({ email, password, devices: [{ id: deviceId, ip: deviceIp }] });
+	// console.log('devices: ', devices);
+
+	// await api.sendPower({ device: { id: deviceId }, power: false });
+})();

package/test/discover.test.ts

@@ -0,0 +1,9 @@
+import { discover } from '../src';
+
+discover({ email: '', password: '' })
+	.then((res) => {
+		console.log('Devices found: ', res);
+	})
+	.catch((err) => {
+		console.log('Discovery Err', err);
+	});