homebridge-tuya-without-developer-account 1.0.0

package/config.schema.json

@@ -0,0 +1,131 @@
+{
+  "pluginAlias": "TuyaNoDeveloperAccount",
+  "pluginType": "platform",
+  "singular": true,
+  "headerDisplay": "<p align='center'><strong>Tuya without developer account for Homebridge</strong></p><p>This plugin uses Home Assistant-style Tuya QR Cloud Authentication. It does not ask for Tuya IoT Access ID, Access Secret, cloud project, username, or password. Open the plugin settings, enter your Tuya User Code, generate the QR code, scan it with the Tuya Smart or Smart Life app, then save.</p>",
+  "footerDisplay": "<p><strong>Note:</strong> If authentication is cleared or expires, generate a new QR code from this settings screen.</p>",
+  "customUi": true,
+  "schema": {
+    "type": "object",
+    "required": [
+      "options"
+    ],
+    "properties": {
+      "name": {
+        "type": "string",
+        "title": "Name",
+        "default": "Tuya without developer account"
+      },
+      "options": {
+        "type": "object",
+        "title": "QR Cloud Authentication",
+        "required": [
+          "userCode"
+        ],
+        "properties": {
+          "userCode": {
+            "type": "string",
+            "title": "Tuya User Code",
+            "description": "The User Code from the Tuya Smart or Smart Life mobile app. This is the only required cloud authentication value."
+          },
+          "homeWhitelist": {
+            "type": "array",
+            "title": "Home Whitelist",
+            "description": "Optional. Restrict discovery to specific Tuya home IDs after authentication.",
+            "items": {
+              "type": "string"
+            }
+          },
+          "deviceOverrides": {
+            "type": "array",
+            "title": "Device Overrides",
+            "description": "Optional advanced overrides. Use this only if a discovered device needs a custom category, schema mapping, or to be hidden/unbridged.",
+            "items": {
+              "type": "object",
+              "properties": {
+                "id": {
+                  "type": "string",
+                  "title": "Device ID / Product ID / global"
+                },
+                "category": {
+                  "type": "string",
+                  "title": "Category Override"
+                },
+                "unbridged": {
+                  "type": "boolean",
+                  "title": "Expose as external accessory",
+                  "default": false
+                },
+                "adaptiveLighting": {
+                  "type": "boolean",
+                  "title": "Enable Adaptive Lighting",
+                  "default": false
+                },
+                "schema": {
+                  "type": "array",
+                  "title": "Schema Overrides",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "code": {
+                        "type": "string"
+                      },
+                      "newCode": {
+                        "type": "string"
+                      },
+                      "type": {
+                        "type": "string"
+                      },
+                      "property": {
+                        "type": "object"
+                      }
+                    }
+                  }
+                }
+              },
+              "required": [
+                "id"
+              ]
+            }
+          },
+          "debug": {
+            "type": "boolean",
+            "title": "Enable debug logging",
+            "default": false
+          },
+          "debugLevel": {
+            "type": "array",
+            "title": "Debug level",
+            "items": {
+              "type": "string",
+              "enum": [
+                "api",
+                "mqtt"
+              ]
+            }
+          }
+        }
+      }
+    }
+  },
+  "layout": [
+    {
+      "key": "name"
+    },
+    {
+      "key": "options.userCode"
+    },
+    {
+      "type": "fieldset",
+      "title": "Advanced",
+      "expandable": true,
+      "expanded": false,
+      "items": [
+        "options.homeWhitelist",
+        "options.deviceOverrides",
+        "options.debug",
+        "options.debugLevel"
+      ]
+    }
+  ]
+}

package/dist/cloud/api/TuyaHACloudAPI.js

@@ -0,0 +1,286 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TUYA_HA_QR_ENDPOINT = exports.TUYA_HA_SCHEMA = exports.TUYA_HA_CLIENT_ID = void 0;
+/* eslint-disable max-len */
+const https_1 = __importDefault(require("https"));
+const crypto_1 = __importDefault(require("crypto"));
+const util_1 = require("../../shared/util/util");
+const Logger_1 = require("../../shared/util/Logger");
+exports.TUYA_HA_CLIENT_ID = 'HA_3y9q4ak7g4ephrvke';
+exports.TUYA_HA_SCHEMA = 'haauthorize';
+exports.TUYA_HA_QR_ENDPOINT = 'https://apigw.iotbing.com';
+class TuyaHACloudAPI {
+    constructor(userCode, terminalId, endpoint, tokenInfo, log = console, debug = false) {
+        this.userCode = userCode;
+        this.terminalId = terminalId;
+        this.endpoint = endpoint;
+        this.log = log;
+        this.debug = debug;
+        this.tokenInfo = {
+            access_token: '',
+            refresh_token: '',
+            uid: '',
+            expire: 0,
+        };
+        this.refreshTokenInProgress = false;
+        this.log = new Logger_1.PrefixLogger(log, TuyaHACloudAPI.name, debug);
+        if (tokenInfo) {
+            this.setTokenInfo(tokenInfo);
+        }
+    }
+    setTokenInfo(tokenInfo) {
+        this.tokenInfo = {
+            access_token: tokenInfo.access_token,
+            refresh_token: tokenInfo.refresh_token,
+            uid: tokenInfo.uid,
+            expire: (tokenInfo.t || Date.now()) + (tokenInfo.expire_time || 0) * 1000,
+        };
+    }
+    exportTokenInfo() {
+        return {
+            t: Date.now(),
+            uid: this.tokenInfo.uid,
+            expire_time: Math.max(0, Math.floor((this.tokenInfo.expire - Date.now()) / 1000)),
+            access_token: this.tokenInfo.access_token,
+            refresh_token: this.tokenInfo.refresh_token,
+        };
+    }
+    isLogin() {
+        return this.tokenInfo.access_token.length > 0;
+    }
+    isTokenExpired() {
+        return (this.tokenInfo.expire - 60 * 1000 <= Date.now());
+    }
+    async getQRCodeToken() {
+        const path = `/v1.0/m/life/home-assistant/qrcode/tokens?clientid=${encodeURIComponent(exports.TUYA_HA_CLIENT_ID)}&usercode=${encodeURIComponent(this.userCode)}&schema=${encodeURIComponent(exports.TUYA_HA_SCHEMA)}`;
+        return this.rawRequest('POST', exports.TUYA_HA_QR_ENDPOINT, path);
+    }
+    async getQRCodeLoginResult(token) {
+        const path = `/v1.0/m/life/home-assistant/qrcode/tokens/${encodeURIComponent(token)}?clientid=${encodeURIComponent(exports.TUYA_HA_CLIENT_ID)}&usercode=${encodeURIComponent(this.userCode)}`;
+        return this.rawRequest('GET', exports.TUYA_HA_QR_ENDPOINT, path);
+    }
+    async rawRequest(method, endpoint, path, body) {
+        this.log.debug('HA raw request: %s %s%s', method, endpoint, path);
+        const res = await (0, util_1.retry)(async () => new Promise((resolve, reject) => {
+            const req = https_1.default.request({
+                host: new URL(endpoint).host,
+                method,
+                path,
+                headers: body ? { 'Content-Type': 'application/json' } : undefined,
+            }, response => {
+                response.setEncoding('utf8');
+                let rawData = '';
+                response.on('data', chunk => rawData += chunk);
+                response.on('end', () => {
+                    try {
+                        const parsed = rawData ? JSON.parse(rawData) : {};
+                        resolve(parsed);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+            req.on('error', reject);
+            if (body) {
+                req.write(JSON.stringify(body));
+            }
+            req.end();
+        }), { retriesMax: 3, interval: 500, exponential: true, factor: 2, jitter: 100 });
+        this.log.debug('HA raw response: %s', JSON.stringify(res));
+        return res;
+    }
+    async refreshAccessTokenIfNeed() {
+        if (!this.isLogin()) {
+            return;
+        }
+        if (!this.isTokenExpired()) {
+            return;
+        }
+        if (this.refreshTokenInProgress) {
+            return;
+        }
+        this.refreshTokenInProgress = true;
+        try {
+            this.log.info('Refreshing Tuya Home Assistant QR access token.');
+            const response = await this.get(`/v1.0/m/token/${this.tokenInfo.refresh_token}`);
+            if (response && response.success) {
+                const result = response.result || {};
+                const tokenInfo = {
+                    t: response.t || Date.now(),
+                    expire_time: result.expireTime || result.expire_time || 0,
+                    uid: result.uid,
+                    access_token: result.accessToken || result.access_token,
+                    refresh_token: result.refreshToken || result.refresh_token,
+                };
+                this.setTokenInfo(tokenInfo);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.log.error('Failed to refresh Tuya access token: %s', msg);
+        }
+        finally {
+            this.refreshTokenInProgress = false;
+        }
+    }
+    async request(method, path, params, body) {
+        if (!this.refreshTokenInProgress) {
+            await this.refreshAccessTokenIfNeed();
+        }
+        const rid = (0, util_1.generateUUID)();
+        const sid = '';
+        const hashKey = crypto_1.default.createHash('md5').update(rid + this.tokenInfo.refresh_token).digest('hex');
+        const secret = this.secretGenerating(rid, sid, hashKey);
+        let queryEncData = '';
+        let finalParams;
+        if (params && Object.keys(params).length > 0) {
+            queryEncData = this.aesGcmEncrypt(this.formToJson(params), secret);
+            finalParams = { encdata: queryEncData };
+        }
+        let bodyEncData = '';
+        let finalBody;
+        if (body && Object.keys(body).length > 0) {
+            bodyEncData = this.aesGcmEncrypt(this.formToJson(body), secret);
+            finalBody = { encdata: bodyEncData };
+        }
+        const t = Date.now();
+        const headers = {
+            'X-appKey': exports.TUYA_HA_CLIENT_ID,
+            'X-requestId': rid,
+            'X-sid': sid,
+            'X-time': String(t),
+        };
+        if (this.tokenInfo.access_token) {
+            headers['X-token'] = this.tokenInfo.access_token;
+        }
+        headers['X-sign'] = this.restfulSign(hashKey, queryEncData, bodyEncData, headers);
+        let requestPath = path;
+        if (finalParams) {
+            requestPath += '?' + new URLSearchParams(finalParams).toString();
+        }
+        this.log.debug('HA encrypted request:\nmethod = %s\nendpoint = %s\npath = %s\nbody = %s', method, this.endpoint, requestPath, JSON.stringify(finalBody));
+        const res = await (0, util_1.retry)(async () => new Promise((resolve, reject) => {
+            const req = https_1.default.request({
+                host: new URL(this.endpoint).host,
+                method,
+                path: requestPath,
+                headers,
+            }, response => {
+                response.setEncoding('utf8');
+                let rawData = '';
+                response.on('data', chunk => rawData += chunk);
+                response.on('end', () => {
+                    try {
+                        const parsed = rawData ? JSON.parse(rawData) : {};
+                        if (parsed && parsed.success && parsed.result && typeof parsed.result === 'string') {
+                            const decrypted = this.aesGcmDecrypt(parsed.result, secret);
+                            try {
+                                parsed.result = JSON.parse(decrypted);
+                            }
+                            catch {
+                                parsed.result = decrypted;
+                            }
+                        }
+                        resolve(parsed);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+            req.on('error', reject);
+            if (finalBody) {
+                req.write(JSON.stringify(finalBody));
+            }
+            req.end();
+        }), { retriesMax: 5, interval: 300, exponential: true, factor: 2, jitter: 100 });
+        this.log.debug('HA encrypted response: %s', JSON.stringify(res));
+        return res;
+    }
+    async get(path, params) {
+        return this.request('GET', path, params || null, null);
+    }
+    async post(path, params, body) {
+        // Keep compatibility with the old plugin style where post(path, body) is common.
+        if (body === undefined) {
+            body = params || null;
+            params = null;
+        }
+        return this.request('POST', path, params || null, body || null);
+    }
+    async put(path, body) {
+        return this.request('PUT', path, null, body || null);
+    }
+    async delete(path, params) {
+        return this.request('DELETE', path, params || null, null);
+    }
+    async getDeviceDetails(deviceId) {
+        return this.get('/v1.0/m/life/ha/devices/detail', { devIds: deviceId });
+    }
+    formToJson(content) {
+        return JSON.stringify(content);
+    }
+    randomNonce(length = 12) {
+        const chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';
+        let value = '';
+        for (let i = 0; i < length; i++) {
+            value += chars[Math.floor(Math.random() * chars.length)];
+        }
+        return value;
+    }
+    aesGcmEncrypt(rawData, secret) {
+        const nonce = this.randomNonce(12);
+        const cipher = crypto_1.default.createCipheriv('aes-128-gcm', Buffer.from(secret, 'utf8'), Buffer.from(nonce, 'utf8'));
+        const encrypted = Buffer.concat([cipher.update(rawData, 'utf8'), cipher.final(), cipher.getAuthTag()]);
+        return Buffer.from(nonce, 'utf8').toString('base64') + encrypted.toString('base64');
+    }
+    aesGcmDecrypt(cipherData, secret) {
+        const data = Buffer.from(cipherData, 'base64');
+        const nonce = data.subarray(0, 12);
+        const cipherTextWithTag = data.subarray(12);
+        const authTag = cipherTextWithTag.subarray(cipherTextWithTag.length - 16);
+        const cipherText = cipherTextWithTag.subarray(0, cipherTextWithTag.length - 16);
+        const decipher = crypto_1.default.createDecipheriv('aes-128-gcm', Buffer.from(secret, 'utf8'), nonce);
+        decipher.setAuthTag(authTag);
+        return Buffer.concat([decipher.update(cipherText), decipher.final()]).toString('utf8');
+    }
+    secretGenerating(rid, sid, hashKey) {
+        let message = hashKey;
+        const mod = 16;
+        if (sid !== '') {
+            const sidLength = sid.length;
+            const length = sidLength < mod ? sidLength : mod;
+            let ecode = '';
+            for (let i = 0; i < length; i++) {
+                const idx = sid.charCodeAt(i) % mod;
+                ecode += sid[idx];
+            }
+            message += '_' + ecode;
+        }
+        return crypto_1.default.createHmac('sha256', Buffer.from(rid, 'utf8')).update(Buffer.from(message, 'utf8')).digest('hex').slice(0, 16);
+    }
+    restfulSign(hashKey, queryEncData, bodyEncData, data) {
+        const headers = ['X-appKey', 'X-requestId', 'X-sid', 'X-time', 'X-token'];
+        const headerParts = [];
+        for (const item of headers) {
+            const val = data[item] || '';
+            if (val !== '') {
+                headerParts.push(`${item}=${val}`);
+            }
+        }
+        let signStr = headerParts.join('||');
+        if (queryEncData) {
+            signStr += queryEncData;
+        }
+        if (bodyEncData) {
+            signStr += bodyEncData;
+        }
+        return crypto_1.default.createHmac('sha256', Buffer.from(hashKey, 'utf8')).update(Buffer.from(signStr, 'utf8')).digest('hex');
+    }
+}
+exports.default = TuyaHACloudAPI;
+//# sourceMappingURL=TuyaHACloudAPI.js.map

package/dist/cloud/api/TuyaHASharingMQ.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const mqtt_1 = __importDefault(require("mqtt"));
+const url_1 = require("url");
+const util_1 = require("../../shared/util/util");
+const Logger_1 = require("../../shared/util/Logger");
+class TuyaHASharingMQ {
+    constructor(api, ownerIds, devices, log = console, debug = false) {
+        this.api = api;
+        this.ownerIds = ownerIds;
+        this.devices = devices;
+        this.log = log;
+        this.debug = debug;
+        this.messageListeners = new Set();
+        this.log = new Logger_1.PrefixLogger(log, TuyaHASharingMQ.name, debug);
+    }
+    async start() {
+        await this.connect();
+    }
+    stop() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        if (this.client) {
+            this.client.removeAllListeners();
+            this.client.end(true);
+            this.client = undefined;
+        }
+    }
+    addMessageListener(listener) {
+        this.messageListeners.add(listener);
+    }
+    removeMessageListener(listener) {
+        this.messageListeners.delete(listener);
+    }
+    subscribeDevice(deviceId, supportLocal = false) {
+        if (!this.client || !this.config) {
+            return;
+        }
+        this.client.subscribe(this.subscribeTopic(deviceId, supportLocal));
+    }
+    unSubscribeDevice(deviceId, supportLocal = false) {
+        if (!this.client || !this.config) {
+            return;
+        }
+        this.client.unsubscribe(this.subscribeTopic(deviceId, supportLocal));
+    }
+    async connect() {
+        this.stop();
+        const res = await this.api.post('/v1.0/m/life/ha/access/config', null, { linkId: `homebridge-tuya-ha.${(0, util_1.generateUUID)()}` });
+        if (!res || !res.success) {
+            this.log.warn('Get Tuya HA MQTT config failed. code = %s, msg = %s', res?.code, res?.msg);
+            return;
+        }
+        this.config = res.result;
+        const url = new url_1.URL(this.config.url);
+        const protocol = url.protocol === 'ssl:' ? 'mqtts' : url.protocol.replace(':', '') || 'mqtt';
+        const connectUrl = `${protocol}://${url.hostname}:${url.port}`;
+        this.log.debug('Connecting to Tuya HA MQTT: %s', connectUrl);
+        const client = mqtt_1.default.connect(connectUrl, {
+            clientId: this.config.clientId,
+            username: this.config.username,
+            password: this.config.password,
+        });
+        client.on('connect', this.onConnect.bind(this));
+        client.on('error', error => this.log.error('Tuya HA MQTT error: %s', error.message));
+        client.on('end', () => this.log.debug('Tuya HA MQTT end'));
+        client.on('message', this.onMessage.bind(this));
+        this.client = client;
+        const timeout = Math.max(60, (this.config.expireTime || 7200) - 60);
+        this.reconnectTimer = setTimeout(() => this.connect().catch(error => this.log.error('Tuya HA MQTT reconnect failed: %s', error.message)), timeout * 1000);
+    }
+    onConnect() {
+        this.log.debug('Tuya HA MQTT connected');
+        if (!this.client || !this.config) {
+            return;
+        }
+        for (const ownerId of this.ownerIds) {
+            this.client.subscribe(this.config.topic.ownerId.sub.replace('{ownerId}', ownerId));
+        }
+        const topics = this.devices.map(device => this.subscribeTopic(device.id, device.support_local || device.supportLocal || false));
+        if (topics.length > 0) {
+            this.client.subscribe(topics);
+        }
+    }
+    subscribeTopic(deviceId, supportLocal = false) {
+        if (!this.config) {
+            return '';
+        }
+        let topic = this.config.topic.devId.sub.replace('{devId}', deviceId);
+        topic += supportLocal ? '/pen' : '/sta';
+        return topic;
+    }
+    onMessage(_topic, payload) {
+        try {
+            const message = JSON.parse(payload.toString('utf8'));
+            this.log.debug('Tuya HA MQTT message: %s', JSON.stringify(message));
+            for (const listener of this.messageListeners) {
+                listener(message);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.log.warn('Could not parse Tuya HA MQTT message: %s', msg);
+        }
+    }
+}
+exports.default = TuyaHASharingMQ;
+//# sourceMappingURL=TuyaHASharingMQ.js.map

package/dist/cloud/device/TuyaDevice.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TuyaDeviceSchemaType = exports.TuyaDeviceSchemaMode = void 0;
+var TuyaDeviceSchemaMode;
+(function (TuyaDeviceSchemaMode) {
+    TuyaDeviceSchemaMode["UNKNOWN"] = "";
+    TuyaDeviceSchemaMode["READ_WRITE"] = "rw";
+    TuyaDeviceSchemaMode["READ_ONLY"] = "ro";
+    TuyaDeviceSchemaMode["WRITE_ONLY"] = "wo";
+})(TuyaDeviceSchemaMode || (exports.TuyaDeviceSchemaMode = TuyaDeviceSchemaMode = {}));
+var TuyaDeviceSchemaType;
+(function (TuyaDeviceSchemaType) {
+    TuyaDeviceSchemaType["Boolean"] = "Boolean";
+    TuyaDeviceSchemaType["Integer"] = "Integer";
+    TuyaDeviceSchemaType["Enum"] = "Enum";
+    TuyaDeviceSchemaType["String"] = "String";
+    TuyaDeviceSchemaType["Json"] = "Json";
+    TuyaDeviceSchemaType["Raw"] = "Raw";
+})(TuyaDeviceSchemaType || (exports.TuyaDeviceSchemaType = TuyaDeviceSchemaType = {}));
+class TuyaDevice {
+    constructor(obj) {
+        Object.assign(this, obj);
+        // Deep copy status array to ensure independence between instances
+        if (Array.isArray(this.status)) {
+            this.status = this.status.map(s => ({ ...s }));
+        }
+        else {
+            this.status = [];
+        }
+        // Deep copy schema array to ensure independence between instances
+        if (Array.isArray(this.schema)) {
+            this.schema = this.schema.map(s => ({ ...s }));
+        }
+        else {
+            this.schema = [];
+        }
+    }
+    isVirtualDevice() {
+        return this.id.startsWith('vdevo');
+    }
+    isIRControlHub() {
+        return ['wnykq', 'hwktwkq', 'wsdykq']
+            .includes(this.category);
+    }
+    isIRRemoteControl() {
+        return this.remote_keys !== undefined || this.category.startsWith('infrared_');
+    }
+}
+exports.default = TuyaDevice;
+//# sourceMappingURL=TuyaDevice.js.map