@lumiastream/tapo-cove 0.0.1-alpha.1

package/lib/cjs/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/lib/cjs/types/interfaces.d.ts

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

package/lib/cjs/types/interfaces.js

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

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

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

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

@@ -0,0 +1,116 @@
+import { __awaiter, __generator } from "tslib";
+import { ILumiaDeviceBrands, ILumiaDeviceConnectionType, ILumiaDeviceType } from '@lumiastream/lumia-rgb-types';
+import Axios from 'axios';
+import findLocalDevices from 'local-devices';
+import { base64Decode } from './shared/cipher';
+import { throwErrorIfFound } from './shared/helpers';
+import TapoApi from './tapo-api';
+var discover = function (config) { return __awaiter(void 0, void 0, void 0, function () {
+    var api, token, getDeviceRequest, response, devices, localDevices;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                api = new TapoApi(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, Axios({
+                        method: 'post',
+                        url: "".concat(api._baseUrl, "?token=").concat(token),
+                        data: getDeviceRequest,
+                    })];
+            case 3:
+                response = _b.sent();
+                throwErrorIfFound(response.data);
+                devices = [];
+                return [4, findLocalDevices({ skipNameResolution: true })];
+            case 4:
+                localDevices = _b.sent();
+                (_a = response.data.result) === null || _a === void 0 ? void 0 : _a.deviceList.map(function (deviceInfo) { return __awaiter(void 0, void 0, void 0, function () {
+                    var findableMac_1, found, isTapo, alias, isTapo, alias;
+                    var _a, _b;
+                    return __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 !== ILumiaDeviceType.LIGHT) {
+                                    return [2];
+                                }
+                                isTapo = deviceInfo.deviceType === 'SMART.TAPOBULB';
+                                alias = (_a = (isTapo ? 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: ILumiaDeviceType.LIGHT,
+                                        zonable: false,
+                                        maxZones: 1,
+                                        zones: null,
+                                        rgb: true,
+                                        white: true,
+                                        connectionType: ILumiaDeviceConnectionType.WIFI,
+                                        brand: isTapo ? ILumiaDeviceBrands.TPLINK : ILumiaDeviceBrands.TPLINK,
+                                        product: deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.deviceModel,
+                                    },
+                                });
+                            }
+                            case 'IOT.SMARTPLUGSWITCH':
+                            case 'SMART.TAPOPLUG': {
+                                if (config.types && config.types !== ILumiaDeviceType.PLUG) {
+                                    return [2];
+                                }
+                                isTapo = deviceInfo.deviceType === 'SMART.TAPOPLUG';
+                                alias = (_b = (isTapo ? 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: ILumiaDeviceType.PLUG,
+                                        zonable: false,
+                                        maxZones: null,
+                                        zones: null,
+                                        rgb: false,
+                                        white: false,
+                                        connectionType: ILumiaDeviceConnectionType.WIFI,
+                                        brand: isTapo ? ILumiaDeviceBrands.TPLINK : ILumiaDeviceBrands.TPLINK,
+                                        product: deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.deviceModel,
+                                    },
+                                });
+                            }
+                        }
+                        return [2];
+                    });
+                }); });
+                return [2, devices];
+        }
+    });
+}); };
+export default discover;

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

@@ -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/esm/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 {};

package/lib/esm/lightstate.js

@@ -0,0 +1,120 @@
+import { __extends } from "tslib";
+import ColorTransformer from './shared/color-transformer';
+import { isTruly } from './shared/utils';
+var isFunction = function (object) {
+    var getClass = {}.toString;
+    return object && getClass.call(object) === '[object Function]';
+};
+var SuperState = (function () {
+    function SuperState() {
+        var _this = this;
+        this._values = {};
+        this.transition = function (value) {
+            _this._values['transition_period'] = value;
+            return _this;
+        };
+        this.duration = this.transition;
+        this.getValues = function () {
+            return _this._values;
+        };
+    }
+    return SuperState;
+}());
+var LightState = (function (_super) {
+    __extends(LightState, _super);
+    function LightState(values) {
+        var _this = _super.call(this) || this;
+        _this.create = function (values) {
+            if (values) {
+                Object.keys(values).forEach(function (value) {
+                    var fn;
+                    if (_this.hasOwnProperty(value)) {
+                        fn = _this[value];
+                        if (isFunction(fn) && isTruly(values[value])) {
+                            fn.apply(_this, [values[value]]);
+                        }
+                    }
+                });
+            }
+            return _this;
+        };
+        _this.on = function (value) {
+            if (value === void 0) { value = true; }
+            _this._values['device_on'] = value;
+            return _this;
+        };
+        _this.turnOn = _this.on;
+        _this.off = function () {
+            _this.on(false);
+            return _this;
+        };
+        _this.turnOff = _this.off;
+        _this.mode = function (value) {
+            if (value === void 0) { value = 'normal'; }
+            if (value === 'normal') {
+                _this._values['color_temp'] = 0;
+            }
+            _this._values['mode'] = value;
+            return _this;
+        };
+        _this.hue = function (value) {
+            _this._values['hue'] = value;
+            _this._values['color_temp'] = 0;
+            return _this;
+        };
+        _this.bri = function (value) {
+            _this._values['brightness'] = value;
+            return _this;
+        };
+        _this.brightness = _this.bri;
+        _this.sat = function (value) {
+            _this._values['saturation'] = value;
+            return _this;
+        };
+        _this.saturation = _this.sat;
+        _this.temp = function (value) {
+            _this._values['color_temp'] = value;
+            return _this;
+        };
+        _this.colorTemperature = _this.temp;
+        _this.hsv = function (value) {
+            var convertedHsv = [];
+            if (Array.isArray(value)) {
+                convertedHsv = value;
+            }
+            else {
+                convertedHsv = [value.h, value.s, value.v];
+            }
+            _this.hue(convertedHsv[0]);
+            _this.sat(convertedHsv[1]);
+            _this.bri(convertedHsv[2]);
+            return _this;
+        };
+        _this.rgb = function (value) {
+            var hsv;
+            if (Array.isArray(value)) {
+                hsv = ColorTransformer.rgb2hsv(value);
+            }
+            else {
+                hsv = ColorTransformer.rgb2hsv([value.r, value.g, value.b]);
+            }
+            return _this.hsv(hsv);
+        };
+        _this.color = function (value) {
+            if (Array.isArray(value)) {
+                value = { r: value[0], g: value[1], b: value[2] };
+            }
+            if (value.ct) {
+                return _this.temp(value.ct);
+            }
+            else {
+                return _this.rgb({ r: value.r, g: value.g, b: value.b });
+            }
+        };
+        if (values)
+            _this.create(values);
+        return _this;
+    }
+    return LightState;
+}(SuperState));
+export { LightState };

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

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import crypto, { KeyObject } from 'crypto';
+import type { TapoDeviceKey } from '../types/raw-types';
+export declare const generateKeyPair: () => Promise<crypto.KeyPairKeyObjectResult>;
+export declare const encrypt: (data: any, deviceKey: TapoDeviceKey) => string;
+export declare const decrypt: (data: string, deviceKey: TapoDeviceKey) => any;
+export declare const readDeviceKey: (pemKey: string, privateKey: KeyObject) => Buffer;
+export declare const base64Encode: (data: string) => string;
+export declare const base64Decode: (data: string) => string;
+export declare const shaDigest: (data: string) => string;

package/lib/esm/shared/cipher.js

@@ -0,0 +1,56 @@
+import { __awaiter, __generator } from "tslib";
+import crypto from 'crypto';
+import util from 'util';
+var RSA_CIPHER_ALGORITHM = 'rsa';
+var AES_CIPHER_ALGORITHM = 'aes-128-cbc';
+var PASSPHRASE = 'top secret';
+export var generateKeyPair = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var RSA_OPTIONS, generateKeyPair;
+    return __generator(this, function (_a) {
+        RSA_OPTIONS = {
+            modulusLength: 1024,
+            publicKeyEncoding: {
+                type: 'spki',
+                format: 'pem',
+            },
+            privateKeyEncoding: {
+                type: 'pkcs1',
+                format: 'pem',
+                cipher: 'aes-256-cbc',
+                passphrase: PASSPHRASE,
+            },
+        };
+        generateKeyPair = util.promisify(crypto.generateKeyPair);
+        return [2, generateKeyPair(RSA_CIPHER_ALGORITHM, RSA_OPTIONS)];
+    });
+}); };
+export var encrypt = function (data, deviceKey) {
+    var cipher = crypto.createCipheriv(AES_CIPHER_ALGORITHM, deviceKey.key, deviceKey.iv);
+    var ciphertext = cipher.update(Buffer.from(JSON.stringify(data)));
+    return Buffer.concat([ciphertext, cipher.final()]).toString('base64');
+};
+export var decrypt = function (data, deviceKey) {
+    var cipher = crypto.createDecipheriv(AES_CIPHER_ALGORITHM, deviceKey.key, deviceKey.iv);
+    var ciphertext = cipher.update(Buffer.from(data, 'base64'));
+    return JSON.parse(Buffer.concat([ciphertext, cipher.final()]).toString());
+};
+export var readDeviceKey = function (pemKey, privateKey) {
+    var keyBytes = Buffer.from(pemKey, 'base64');
+    var deviceKey = crypto.privateDecrypt({
+        key: privateKey,
+        padding: crypto.constants.RSA_PKCS1_PADDING,
+        passphrase: PASSPHRASE,
+    }, keyBytes);
+    return deviceKey;
+};
+export var base64Encode = function (data) {
+    return Buffer.from(data).toString('base64');
+};
+export var base64Decode = function (data) {
+    return Buffer.from(data, 'base64').toString();
+};
+export var shaDigest = function (data) {
+    var shasum = crypto.createHash('sha1');
+    shasum.update(data);
+    return shasum.digest('hex');
+};

package/lib/esm/shared/color-transformer.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    rgb2hsv: ([r, g, b]: [number, number, number]) => {
+        h: number;
+        s: number;
+        v: number;
+    };
+};
+export default _default;

package/lib/esm/shared/color-transformer.js

@@ -0,0 +1,40 @@
+var rgb2hsv = function (_a) {
+    var r = _a[0], g = _a[1], b = _a[2];
+    var rr, gg, bb;
+    r = r / 255;
+    g = g / 255;
+    b = b / 255;
+    var h, s, v = Math.max(r, g, b), diff = v - Math.min(r, g, b), diffc = function (c) {
+        return (v - c) / 6 / diff + 1 / 2;
+    };
+    if (diff == 0) {
+        h = s = 0;
+    }
+    else {
+        s = diff / v;
+        rr = diffc(r);
+        gg = diffc(g);
+        bb = diffc(b);
+        if (r === v) {
+            h = bb - gg;
+        }
+        else if (g === v) {
+            h = (1 / 3) + rr - bb;
+        }
+        else if (b === v) {
+            h = (2 / 3) + gg - rr;
+        }
+        if (h < 0) {
+            h += 1;
+        }
+        else if (h > 1) {
+            h -= 1;
+        }
+    }
+    return {
+        h: Math.round(h * 360),
+        s: Math.round(s * 100),
+        v: Math.round(v * 100)
+    };
+};
+export default { rgb2hsv: rgb2hsv };

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

@@ -0,0 +1,5 @@
+import { TapoDeviceKey } from '../types/raw-types';
+export declare const throwErrorIfFound: (responseData: any) => void;
+export declare const throwTapoCareErrorIfFound: (responseData: any) => void;
+export declare const handshake: (deviceIp: string) => Promise<TapoDeviceKey>;
+export declare const securePassthrough: (deviceRequest: any, deviceKey: TapoDeviceKey) => Promise<any>;