@lumiastream/tapo-cove 0.0.1-alpha.2 → 3.0.1

package/dist/index.d.ts

@@ -0,0 +1,146 @@
+import { ILumiaDeviceType } from '@lumiastream/lumia-rgb-types';
+
+declare const discover: (config: {
+    token?: string;
+    email?: string;
+    password?: string;
+    types?: ILumiaDeviceType;
+}) => Promise<any>;
+
+declare class SuperState {
+    protected _values: Record<string, boolean | string | number>;
+    transition: (value: number) => this;
+    duration: (value: number) => this;
+    getValues: () => Record<string, string | number | boolean>;
+}
+declare class LightState extends SuperState {
+    constructor(values?: {
+        on: boolean;
+    });
+    create: (values?: {
+        [x: string]: any;
+    } | undefined) => 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;
+}
+
+type TapoDeviceKey = {
+    key: string | Buffer;
+    iv: string | Buffer;
+    deviceIp: string;
+    sessionCookie: string;
+    token?: string;
+};
+
+declare 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>>;
+    sendState: (config: {
+        device: {
+            id: string;
+        };
+        state: LightState;
+        fetchConfig?: {
+            shouldWait: boolean;
+        };
+    }) => Promise<any>;
+    sendPower: (config: {
+        device: {
+            id: string;
+        };
+        power: boolean;
+    }) => void;
+}
+
+declare const TapoDeviceTypes: {
+    ALL: string;
+    BULBS: string;
+    LIGHTSTRIPS: string;
+    PLUGS: string;
+};
+declare enum ETapoDeviceTypes {
+    ALL = "all",
+    BULBS = "bulb",
+    LIGHTSTRIPS = "lightstrip",
+    PLUGS = "plug"
+}
+declare const DeviceResTypes: {
+    BULB: string;
+    PLUG: string;
+};
+declare const DeviceSendValues: {
+    BULB: string;
+    LIGHTSTRIP: string;
+    PLUG: string;
+};
+
+declare const tapo_constants_DeviceResTypes: typeof DeviceResTypes;
+declare const tapo_constants_DeviceSendValues: typeof DeviceSendValues;
+type tapo_constants_ETapoDeviceTypes = ETapoDeviceTypes;
+declare const tapo_constants_ETapoDeviceTypes: typeof ETapoDeviceTypes;
+declare const tapo_constants_TapoDeviceTypes: typeof TapoDeviceTypes;
+declare namespace tapo_constants {
+  export {
+    tapo_constants_DeviceResTypes as DeviceResTypes,
+    tapo_constants_DeviceSendValues as DeviceSendValues,
+    tapo_constants_ETapoDeviceTypes as ETapoDeviceTypes,
+    tapo_constants_TapoDeviceTypes as TapoDeviceTypes,
+  };
+}
+
+export { LightState, TapoApi, tapo_constants as TapoConstants, discover };

package/dist/index.js

@@ -0,0 +1,554 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  LightState: () => LightState,
+  TapoApi: () => TapoApi,
+  TapoConstants: () => tapo_constants_exports,
+  discover: () => discovery_default
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/discovery.ts
+var import_lumia_rgb_types = require("@lumiastream/lumia-rgb-types");
+var import_axios3 = __toESM(require("axios"));
+var import_local_devices = __toESM(require("local-devices"));
+
+// src/shared/cipher.ts
+var import_crypto = __toESM(require("crypto"));
+var import_util = __toESM(require("util"));
+var RSA_CIPHER_ALGORITHM = "rsa";
+var AES_CIPHER_ALGORITHM = "aes-128-cbc";
+var PASSPHRASE = "top secret";
+var generateKeyPair = () => __async(void 0, null, function* () {
+  const RSA_OPTIONS = {
+    modulusLength: 1024,
+    publicKeyEncoding: {
+      type: "spki",
+      format: "pem"
+    },
+    privateKeyEncoding: {
+      type: "pkcs1",
+      format: "pem",
+      cipher: "aes-256-cbc",
+      passphrase: PASSPHRASE
+    }
+  };
+  const generateKeyPair2 = import_util.default.promisify(import_crypto.default.generateKeyPair);
+  return generateKeyPair2(RSA_CIPHER_ALGORITHM, RSA_OPTIONS);
+});
+var encrypt = (data, deviceKey) => {
+  var cipher = import_crypto.default.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");
+};
+var decrypt = (data, deviceKey) => {
+  var cipher = import_crypto.default.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());
+};
+var readDeviceKey = (pemKey, privateKey) => {
+  const keyBytes = Buffer.from(pemKey, "base64");
+  const deviceKey = import_crypto.default.privateDecrypt(
+    {
+      key: privateKey,
+      padding: import_crypto.default.constants.RSA_PKCS1_PADDING,
+      passphrase: PASSPHRASE
+    },
+    keyBytes
+  );
+  return deviceKey;
+};
+var base64Encode = (data) => {
+  return Buffer.from(data).toString("base64");
+};
+var base64Decode = (data) => {
+  return Buffer.from(data, "base64").toString();
+};
+var shaDigest = (data) => {
+  var shasum = import_crypto.default.createHash("sha1");
+  shasum.update(data);
+  return shasum.digest("hex");
+};
+
+// src/shared/helpers.ts
+var import_axios = __toESM(require("axios"));
+var throwErrorIfFound = (responseData) => {
+  const 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: ${errorCode} (${responseData["msg"]})`);
+    }
+  }
+};
+var handshake = (deviceIp) => __async(void 0, null, function* () {
+  const keyPair = yield generateKeyPair();
+  const handshakeRequest = {
+    method: "handshake",
+    params: {
+      key: keyPair.publicKey
+    }
+  };
+  const response = yield (0, import_axios.default)({
+    method: "post",
+    url: `http://${deviceIp}/app`,
+    data: handshakeRequest
+  });
+  throwErrorIfFound(response.data);
+  const setCookieHeader = response.headers["set-cookie"][0];
+  const sessionCookie = setCookieHeader.substring(0, setCookieHeader.indexOf(";"));
+  const deviceKey = readDeviceKey(response.data.result.key, keyPair.privateKey);
+  return {
+    key: deviceKey.subarray(0, 16),
+    iv: deviceKey.subarray(16, 32),
+    deviceIp,
+    sessionCookie
+  };
+});
+var securePassthrough = (deviceRequest, deviceKey) => __async(void 0, null, function* () {
+  const encryptedRequest = encrypt(deviceRequest, deviceKey);
+  const securePassthroughRequest = {
+    method: "securePassthrough",
+    params: {
+      request: encryptedRequest
+    }
+  };
+  const response = yield (0, import_axios.default)({
+    method: "post",
+    url: `http://${deviceKey.deviceIp}/app?token=${deviceKey.token}`,
+    data: securePassthroughRequest,
+    headers: {
+      Cookie: deviceKey.sessionCookie
+    }
+  });
+  throwErrorIfFound(response.data);
+  const decryptedResponse = decrypt(response.data.result.response, deviceKey);
+  throwErrorIfFound(decryptedResponse);
+  return decryptedResponse.result;
+});
+
+// src/tapo-api.ts
+var import_axios2 = __toESM(require("axios"));
+
+// src/lightstate.ts
+var import_lumia_rgb_utils = require("@lumiastream/lumia-rgb-utils");
+var SuperState = class {
+  constructor() {
+    this._values = {};
+    // In Milliseconds
+    // 0.0 – infinity seconds
+    this.transition = (value) => {
+      this._values["transition_period"] = value;
+      return this;
+    };
+    this.duration = this.transition;
+    this.getValues = () => {
+      return this._values;
+    };
+  }
+};
+var LightState = class extends SuperState {
+  constructor(values) {
+    super();
+    this.create = (values) => {
+      if (values) {
+        Object.keys(values).forEach((value) => {
+          let fn;
+          if (this.hasOwnProperty(value)) {
+            fn = this[value];
+            if ((0, import_lumia_rgb_utils.isFunction)(fn) && (0, import_lumia_rgb_utils.isTruly)(values[value])) {
+              fn.apply(this, [values[value]]);
+            }
+          }
+        });
+      }
+      return this;
+    };
+    this.on = (value = true) => {
+      this._values["device_on"] = value;
+      return this;
+    };
+    this.turnOn = this.on;
+    this.off = () => {
+      this.on(false);
+      return this;
+    };
+    this.turnOff = this.off;
+    this.mode = (value = "normal") => {
+      if (value === "normal") {
+        this._values["color_temp"] = 0;
+      }
+      this._values["mode"] = value;
+      return this;
+    };
+    // 0 - 360
+    this.hue = (value) => {
+      this._values["hue"] = value;
+      this._values["color_temp"] = 0;
+      return this;
+    };
+    // Bri 0-100
+    this.bri = (value) => {
+      this._values["brightness"] = value;
+      return this;
+    };
+    this.brightness = this.bri;
+    this.sat = (value) => {
+      this._values["saturation"] = value;
+      return this;
+    };
+    this.saturation = this.sat;
+    // Color Temperature 2500 - 9000 in kelvin
+    // Will override hue if passed
+    this.temp = (value) => {
+      this._values["color_temp"] = value;
+      return this;
+    };
+    this.colorTemperature = this.temp;
+    // Can take in an array or object
+    this.hsv = (value) => {
+      let 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;
+    };
+    // Can take in an array or object
+    this.rgb = (value) => {
+      let hsv;
+      if (Array.isArray(value)) {
+        hsv = (0, import_lumia_rgb_utils.rgb2hsv)(value);
+      } else {
+        hsv = (0, import_lumia_rgb_utils.rgb2hsv)([value.r, value.g, value.b]);
+      }
+      return this.hsv(hsv);
+    };
+    // Can take in an object will first check for ct and if it exists and the light will worki with it it'll use color temp
+    this.color = (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);
+  }
+};
+
+// src/tapo-api.ts
+var import_fetch_cove = require("@lumiastream/fetch-cove");
+var import_lumia_rgb_utils2 = require("@lumiastream/lumia-rgb-utils");
+var TapoApi = class {
+  constructor(config) {
+    this._baseUrl = "https://eu-wap.tplinkcloud.com/";
+    // https://n-euw1-wap-gw.tplinkcloud.com
+    this._baseTapoCareUrl = "https://euw1-app-tapo-care.i.tplinknbu.com";
+    this._config = {
+      authToken: null,
+      timeout: 1e4,
+      httpTimeout: 4e3
+    };
+    this._token = "";
+    this._devices = /* @__PURE__ */ new Map();
+    this.auth = (_0) => __async(this, [_0], function* ({ email, password }) {
+      const loginRequest = {
+        method: "login",
+        params: {
+          appType: "Tapo_Android",
+          cloudPassword: password,
+          cloudUserName: email,
+          terminalUUID: (0, import_lumia_rgb_utils2.uuidv4)()
+        }
+      };
+      const response = yield (0, import_axios2.default)({
+        method: "post",
+        url: this._baseUrl,
+        data: loginRequest
+      });
+      throwErrorIfFound(response.data);
+      this._token = response.data.result.token;
+      return this._token;
+    });
+    this.setup = (_0) => __async(this, [_0], function* ({ email, password, devices }) {
+      const promises = devices.map((device) => __async(this, null, function* () {
+        const deviceKey = yield handshake(device.ip);
+        const loginDeviceRequest = {
+          method: "login_device",
+          params: {
+            username: base64Encode(shaDigest(email)),
+            password: base64Encode(password)
+          },
+          requestTimeMils: 0
+        };
+        const loginDeviceResponse = yield securePassthrough(loginDeviceRequest, deviceKey);
+        deviceKey.token = loginDeviceResponse.token;
+        this._devices.set(device.id, deviceKey);
+        return;
+      }));
+      yield Promise.all(promises);
+      return this._devices;
+    });
+    // Change state using lightstate
+    this.sendState = (config) => {
+      const deviceKey = this._devices.get(config.device.id);
+      let shouldWait = false;
+      if (config.fetchConfig && config.fetchConfig.shouldWait) {
+        shouldWait = true;
+      }
+      if (!deviceKey) {
+        return Promise.resolve(false);
+      }
+      const values = config.state.getValues();
+      const deviceRequest = {
+        method: "set_device_info",
+        params: values,
+        terminalUUID: (0, import_lumia_rgb_utils2.uuidv4)()
+      };
+      const encryptedRequest = encrypt(deviceRequest, deviceKey);
+      const securePassthroughRequest = {
+        method: "securePassthrough",
+        params: {
+          request: encryptedRequest
+        }
+      };
+      return (0, import_fetch_cove.fetchWork)({
+        url: `http://${deviceKey.deviceIp}/app?token=${deviceKey.token}`,
+        data: {
+          method: "POST",
+          body: securePassthroughRequest,
+          headers: {
+            Cookie: deviceKey.sessionCookie
+          }
+        },
+        shouldWait
+      });
+    };
+    this.sendPower = (config) => {
+      this.sendState({ device: config.device, state: new LightState({ on: config.power }) });
+    };
+    this.axiosInstance = import_axios2.default.create();
+    this.axiosInstance.defaults.timeout = (config == null ? void 0 : config.httpTimeout) || 4e3;
+    this._config = __spreadValues(__spreadValues({}, this._config), config);
+  }
+};
+
+// src/discovery.ts
+var discover = (config) => __async(void 0, null, function* () {
+  var _a;
+  const api = new TapoApi(config);
+  let token = config.token;
+  if (!token && config.email && config.password) {
+    token = yield api.auth({ email: config.email, password: config.password });
+  }
+  const getDeviceRequest = {
+    method: "getDeviceList"
+  };
+  const response = yield (0, import_axios3.default)({
+    method: "post",
+    url: `${api._baseUrl}?token=${token}`,
+    data: getDeviceRequest
+  });
+  throwErrorIfFound(response.data);
+  const devices = [];
+  const localDevices = yield (0, import_local_devices.default)({ skipNameResolution: true });
+  (_a = response.data.result) == null ? void 0 : _a.deviceList.map((deviceInfo) => __async(void 0, null, function* () {
+    var _a2, _b;
+    if (!deviceInfo.ip) {
+      const findableMac = deviceInfo.deviceMac.replace(/:/g, "").toUpperCase();
+      const found = localDevices.find((device) => findableMac == device.mac.replace(/:/g, "").toUpperCase());
+      if (found) {
+        deviceInfo.ip = found.ip;
+      } else {
+        return;
+      }
+    }
+    switch (deviceInfo.deviceType) {
+      case "IOT.SMARTBULB":
+      case "SMART.TAPOBULB": {
+        if (config.types && config.types !== import_lumia_rgb_types.ILumiaDeviceType.LIGHT) {
+          return;
+        }
+        const isTapo = deviceInfo.deviceType === "SMART.TAPOBULB";
+        const alias = (_a2 = isTapo ? base64Decode(deviceInfo.alias) : deviceInfo.alias) != null ? _a2 : deviceInfo.deviceName;
+        devices.push({
+          name: alias,
+          id: deviceInfo.deviceMac,
+          address: `http://${deviceInfo.ip}`,
+          host: deviceInfo.ip,
+          lumiaInfo: {
+            alias,
+            identifier: deviceInfo.deviceMac,
+            serial: deviceInfo.hwId,
+            lumiaType: import_lumia_rgb_types.ILumiaDeviceType.LIGHT,
+            zonable: false,
+            maxZones: 1,
+            zones: [],
+            rgb: true,
+            white: true,
+            connectionType: import_lumia_rgb_types.ILumiaDeviceConnectionType.WIFI,
+            brand: isTapo ? import_lumia_rgb_types.ILumiaDeviceBrands.TPLINK : import_lumia_rgb_types.ILumiaDeviceBrands.TPLINK,
+            product: deviceInfo == null ? void 0 : deviceInfo.deviceModel
+          }
+        });
+      }
+      case "IOT.SMARTPLUGSWITCH":
+      case "SMART.TAPOPLUG": {
+        if (config.types && config.types !== import_lumia_rgb_types.ILumiaDeviceType.PLUG) {
+          return;
+        }
+        const isTapo = deviceInfo.deviceType === "SMART.TAPOPLUG";
+        const alias = (_b = isTapo ? base64Decode(deviceInfo.alias) : deviceInfo.alias) != null ? _b : deviceInfo.deviceName;
+        devices.push({
+          name: alias,
+          id: deviceInfo.deviceMac,
+          address: `http://${deviceInfo.ip}`,
+          host: deviceInfo.ip,
+          lumiaInfo: {
+            alias,
+            identifier: deviceInfo.deviceMac,
+            serial: deviceInfo.hwId,
+            lumiaType: import_lumia_rgb_types.ILumiaDeviceType.PLUG,
+            zonable: false,
+            maxZones: 0,
+            zones: [],
+            rgb: false,
+            white: false,
+            connectionType: import_lumia_rgb_types.ILumiaDeviceConnectionType.WIFI,
+            brand: isTapo ? import_lumia_rgb_types.ILumiaDeviceBrands.TPLINK : import_lumia_rgb_types.ILumiaDeviceBrands.TPLINK,
+            product: deviceInfo == null ? void 0 : deviceInfo.deviceModel
+          }
+        });
+      }
+    }
+  }));
+  return devices;
+});
+var discovery_default = discover;
+
+// src/types/tapo.constants.ts
+var tapo_constants_exports = {};
+__export(tapo_constants_exports, {
+  DeviceResTypes: () => DeviceResTypes,
+  DeviceSendValues: () => DeviceSendValues,
+  ETapoDeviceTypes: () => ETapoDeviceTypes,
+  TapoDeviceTypes: () => TapoDeviceTypes
+});
+var TapoDeviceTypes = {
+  ALL: "all",
+  BULBS: "bulb",
+  LIGHTSTRIPS: "lightstrip",
+  PLUGS: "plug"
+};
+var ETapoDeviceTypes = /* @__PURE__ */ ((ETapoDeviceTypes2) => {
+  ETapoDeviceTypes2["ALL"] = "all";
+  ETapoDeviceTypes2["BULBS"] = "bulb";
+  ETapoDeviceTypes2["LIGHTSTRIPS"] = "lightstrip";
+  ETapoDeviceTypes2["PLUGS"] = "plug";
+  return ETapoDeviceTypes2;
+})(ETapoDeviceTypes || {});
+var DeviceResTypes = {
+  BULB: "IOT.SMARTPLUGSWITCH",
+  PLUG: "IOT.SMARTPLUGSWITCH"
+};
+var DeviceSendValues = {
+  BULB: "smartlife.iot.smartbulb.lightingservice",
+  LIGHTSTRIP: "smartlife.iot.lightStrip",
+  PLUG: "system"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LightState,
+  TapoApi,
+  TapoConstants,
+  discover
+});