@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/dist_ts/integrations/tuya/tuya.classes.integration.js

@@ -1,30 +1,141 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
-export class HomeAssistantTuyaIntegration extends DescriptorOnlyIntegration {
-    constructor() {
-        super({
-            domain: "tuya",
-            displayName: "Tuya",
-            status: 'descriptor-only',
-            metadata: {
-                "source": "home-assistant/core",
-                "upstreamPath": "homeassistant/components/tuya",
-                "upstreamDomain": "tuya",
-                "integrationType": "hub",
-                "iotClass": "cloud_push",
-                "requirements": [
-                    "tuya-device-handlers==0.0.18",
-                    "tuya-device-sharing-sdk==0.2.8"
-                ],
-                "dependencies": [
-                    "ffmpeg"
-                ],
-                "afterDependencies": [],
-                "codeowners": [
-                    "@Tuya",
-                    "@zlinoliver"
-                ]
-            },
-        });
+import * as plugins from '../../plugins.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import { TuyaRuntime } from './tuya.classes.runtime.js';
+import { normalizeTuyaConfig, scopedTuyaStore, tuyaCredentialId, tuyaKeys, tuyaRecord } from './tuya.validation.js';
+export class TuyaIntegration extends BaseIntegration {
+    domain = 'tuya';
+    displayName = 'Tuya';
+    status = 'control-runtime';
+    discoveryDescriptor = new DiscoveryDescriptor({ integrationDomain: 'tuya', displayName: 'Tuya 3.4 local device' });
+    metadata = Object.freeze({ source: 'native-typescript', integrationType: 'device', iotClass: 'local_push', protocolVersion: '3.4' });
+    #setups = new Set();
+    #controllers = new Set();
+    #runtimes = new Set();
+    #destroyed = false;
+    #destroy;
+    provisionLocalKey(configArg, localKeyArg, contextArg) {
+        this.#assertOpen();
+        this.#assertCapacity();
+        const config = normalizeTuyaConfig(configArg);
+        const store = scopedTuyaStore(config, contextArg);
+        if (!(localKeyArg instanceof Uint8Array) || localKeyArg.byteLength !== 16)
+            throw new TypeError('Tuya local key must contain exactly 16 opaque bytes.');
+        const copy = Buffer.from(localKeyArg);
+        const controller = new AbortController();
+        this.#controllers.add(controller);
+        const signal = contextArg.abortSignal ? AbortSignal.any([controller.signal, contextArg.abortSignal]) : controller.signal;
+        const operation = (async () => {
+            try {
+                signal.throwIfAborted();
+                await store.initialize({ signal });
+                this.#assertOpen();
+                signal.throwIfAborted();
+                await store.set(tuyaCredentialId(config.deviceId), { version: 1, config, localKey: copy.toString('base64') });
+                this.#assertOpen();
+                signal.throwIfAborted();
+            }
+            finally {
+                copy.fill(0);
+                this.#controllers.delete(controller);
+            }
+        })();
+        return this.#track(operation);
     }
+    setup(configArg, contextArg) {
+        this.#assertOpen();
+        this.#assertCapacity();
+        const config = normalizeTuyaConfig(configArg);
+        const store = scopedTuyaStore(config, contextArg);
+        const controller = new AbortController();
+        this.#controllers.add(controller);
+        const signal = contextArg.abortSignal ? AbortSignal.any([controller.signal, contextArg.abortSignal]) : controller.signal;
+        const operation = (async () => {
+            let protocol;
+            let unsubscribeAdmission;
+            try {
+                signal.throwIfAborted();
+                await store.initialize({ signal });
+                signal.throwIfAborted();
+                const stored = tuyaRecord(await store.get(tuyaCredentialId(config.deviceId)), 'stored configuration');
+                tuyaKeys(stored, ['version', 'config', 'localKey']);
+                if (stored.version !== 1 || JSON.stringify(normalizeTuyaConfig(stored.config)) !== JSON.stringify(config)) {
+                    throw new TypeError('Tuya configuration does not match its encrypted provisioned configuration.');
+                }
+                if (typeof stored.localKey !== 'string' || stored.localKey.length !== 24)
+                    throw new TypeError('Tuya stored local key is invalid.');
+                const key = Buffer.from(stored.localKey, 'base64');
+                try {
+                    if (key.byteLength !== 16 || key.toString('base64') !== stored.localKey)
+                        throw new TypeError('Tuya stored local key is invalid.');
+                    signal.throwIfAborted();
+                    protocol = new plugins.ecobridgeDeviceManager.TuyaProtocol({
+                        deviceId: config.deviceId, localKey: key, host: config.host, port: config.port, version: config.version,
+                        connectTimeoutMs: config.connectTimeoutMs, requestTimeoutMs: config.requestTimeoutMs,
+                        heartbeatIntervalMs: config.heartbeatIntervalMs, abortSignal: signal,
+                    });
+                }
+                finally {
+                    key.fill(0);
+                }
+                const reports = [];
+                let admissionOverflow = false;
+                unsubscribeAdmission = protocol.subscribe((reportArg) => {
+                    if (reports.length >= 128) {
+                        admissionOverflow = true;
+                        controller.abort();
+                    }
+                    else
+                        reports.push(reportArg);
+                });
+                await protocol.connect(signal);
+                await protocol.queryDatapoints(signal);
+                if (admissionOverflow)
+                    throw new Error('Tuya admission report capacity exceeded.');
+                signal.throwIfAborted();
+                this.#assertOpen();
+                unsubscribeAdmission();
+                unsubscribeAdmission = undefined;
+                const runtime = new TuyaRuntime(config, protocol, reports, () => {
+                    this.#runtimes.delete(runtime);
+                    this.#controllers.delete(controller);
+                }, contextArg.logger);
+                this.#runtimes.add(runtime);
+                return runtime;
+            }
+            catch (errorArg) {
+                controller.abort();
+                unsubscribeAdmission?.();
+                await protocol?.close();
+                this.#controllers.delete(controller);
+                throw errorArg;
+            }
+        })();
+        return this.#track(operation);
+    }
+    destroy() {
+        if (this.#destroy)
+            return this.#destroy;
+        this.#destroyed = true;
+        for (const controller of this.#controllers)
+            controller.abort();
+        this.#destroy = (async () => {
+            await Promise.allSettled([...this.#setups]);
+            await Promise.all([...this.#runtimes].map((runtimeArg) => runtimeArg.destroy()));
+            this.#controllers.clear();
+        })();
+        return this.#destroy;
+    }
+    #assertOpen() { if (this.#destroyed)
+        throw new Error('Tuya integration is permanently destroyed.'); }
+    #assertCapacity() { if (this.#controllers.size >= 32)
+        throw new Error('Tuya integration lifetime capacity reached.'); }
+    #track(operationArg) {
+        this.#setups.add(operationArg);
+        void operationArg.then(() => this.#setups.delete(operationArg), () => this.#setups.delete(operationArg));
+        return operationArg;
+    }
+}
+export class HomeAssistantTuyaIntegration extends TuyaIntegration {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHV5YS5jbGFzc2VzLmludGVncmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL3R1eWEvdHV5YS5jbGFzc2VzLmludGVncmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGlEQUFpRCxDQUFDO0FBRTVGLE1BQU0sT0FBTyw0QkFBNkIsU0FBUSx5QkFBeUI7SUFDekU7UUFDRSxLQUFLLENBQUM7WUFDSixNQUFNLEVBQUUsTUFBTTtZQUNkLFdBQVcsRUFBRSxNQUFNO1lBQ25CLE1BQU0sRUFBRSxpQkFBaUI7WUFDekIsUUFBUSxFQUFFO2dCQUNkLFFBQVEsRUFBRSxxQkFBcUI7Z0JBQy9CLGNBQWMsRUFBRSwrQkFBK0I7Z0JBQy9DLGdCQUFnQixFQUFFLE1BQU07Z0JBQ3hCLGlCQUFpQixFQUFFLEtBQUs7Z0JBQ3hCLFVBQVUsRUFBRSxZQUFZO2dCQUN4QixjQUFjLEVBQUU7b0JBQ2QsOEJBQThCO29CQUM5QixnQ0FBZ0M7aUJBQ2pDO2dCQUNELGNBQWMsRUFBRTtvQkFDZCxRQUFRO2lCQUNUO2dCQUNELG1CQUFtQixFQUFFLEVBQUU7Z0JBQ3ZCLFlBQVksRUFBRTtvQkFDWixPQUFPO29CQUNQLGFBQWE7aUJBQ2Q7YUFDRjtTQUNJLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tuya.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/tuya/tuya.classes.integration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAEhF,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,gBAAgB,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEpH,MAAM,OAAO,eAAgB,SAAQ,eAAyC;IAC5D,MAAM,GAAG,MAAM,CAAC;IAChB,WAAW,GAAG,MAAM,CAAC;IACrB,MAAM,GAAG,iBAA0B,CAAC;IACpC,mBAAmB,GAAG,IAAI,mBAAmB,CAAC,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAE,uBAAuB,EAAE,CAAC,CAAC;IACnH,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,mBAAmB,EAAE,eAAe,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5I,OAAO,GAAG,IAAI,GAAG,EAAoB,CAAC;IACtC,YAAY,GAAG,IAAI,GAAG,EAAmB,CAAC;IAC1C,SAAS,GAAG,IAAI,GAAG,EAAe,CAAC;IAC5C,UAAU,GAAG,KAAK,CAAC;IACnB,QAAQ,CAAiB;IAElB,iBAAiB,CAAC,SAAmC,EAAE,WAAuB,EAAE,UAAoC;QACzH,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,MAAM,MAAM,GAAG,mBAAmB,CAAC,SAAS,CAAC,CAAC;QAC9C,MAAM,KAAK,GAAG,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAClD,IAAI,CAAC,CAAC,WAAW,YAAY,UAAU,CAAC,IAAI,WAAW,CAAC,UAAU,KAAK,EAAE;YAAE,MAAM,IAAI,SAAS,CAAC,sDAAsD,CAAC,CAAC;QACvJ,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACtC,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;QACzH,MAAM,SAAS,GAAG,CAAC,KAAK,IAAI,EAAE;YAC5B,IAAI,CAAC;gBACH,MAAM,CAAC,cAAc,EAAE,CAAC;gBACxB,MAAM,KAAK,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;gBACnC,IAAI,CAAC,WAAW,EAAE,CAAC;gBACnB,MAAM,CAAC,cAAc,EAAE,CAAC;gBACxB,MAAM,KAAK,CAAC,GAAG,CAA2B,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;gBACxI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACnB,MAAM,CAAC,cAAc,EAAE,CAAC;YAC1B,CAAC;oBAAS,CAAC;gBAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAAC,CAAC;QACnE,CAAC,CAAC,EAAE,CAAC;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAChC,CAAC;IAEM,KAAK,CAAC,SAAmC,EAAE,UAAoC;QACpF,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,MAAM,MAAM,GAAG,mBAAmB,CAAC,SAAS,CAAC,CAAC;QAC9C,MAAM,KAAK,GAAG,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAClD,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;QACzH,MAAM,SAAS,GAAG,CAAC,KAAK,IAAI,EAAE;YAC5B,IAAI,QAAiE,CAAC;YACtE,IAAI,oBAA8C,CAAC;YACnD,IAAI,CAAC;gBACH,MAAM,CAAC,cAAc,EAAE,CAAC;gBACxB,MAAM,KAAK,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;gBACnC,MAAM,CAAC,cAAc,EAAE,CAAC;gBACxB,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,KAAK,CAAC,GAAG,CAAU,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,sBAAsB,CAAC,CAAC;gBAC/G,QAAQ,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC;gBACpD,IAAI,MAAM,CAAC,OAAO,KAAK,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;oBAC1G,MAAM,IAAI,SAAS,CAAC,4EAA4E,CAAC,CAAC;gBACpG,CAAC;gBACD,IAAI,OAAO,MAAM,CAAC,QAAQ,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,KAAK,EAAE;oBAAE,MAAM,IAAI,SAAS,CAAC,mCAAmC,CAAC,CAAC;gBACnI,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;gBACnD,IAAI,CAAC;oBACH,IAAI,GAAG,CAAC,UAAU,KAAK,EAAE,IAAI,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,QAAQ;wBAAE,MAAM,IAAI,SAAS,CAAC,mCAAmC,CAAC,CAAC;oBAClI,MAAM,CAAC,cAAc,EAAE,CAAC;oBACxB,QAAQ,GAAG,IAAI,OAAO,CAAC,sBAAsB,CAAC,YAAY,CAAC;wBACzD,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO;wBACvG,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;wBACpF,mBAAmB,EAAE,MAAM,CAAC,mBAAmB,EAAE,WAAW,EAAE,MAAM;qBACrE,CAAC,CAAC;gBACL,CAAC;wBAAS,CAAC;oBAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAAC,CAAC;gBAC1B,MAAM,OAAO,GAA0D,EAAE,CAAC;gBAC1E,IAAI,iBAAiB,GAAG,KAAK,CAAC;gBAC9B,oBAAoB,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,SAAS,EAAE,EAAE;oBACtD,IAAI,OAAO,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;wBAAC,iBAAiB,GAAG,IAAI,CAAC;wBAAC,UAAU,CAAC,KAAK,EAAE,CAAC;oBAAC,CAAC;;wBACvE,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBAC/B,CAAC,CAAC,CAAC;gBACH,MAAM,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;gBAC/B,MAAM,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;gBACvC,IAAI,iBAAiB;oBAAE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;gBACnF,MAAM,CAAC,cAAc,EAAE,CAAC;gBACxB,IAAI,CAAC,WAAW,EAAE,CAAC;gBACnB,oBAAoB,EAAE,CAAC;gBACvB,oBAAoB,GAAG,SAAS,CAAC;gBACjC,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE;oBAC9D,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;oBAC/B,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBACvC,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;gBACtB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAC5B,OAAO,OAAO,CAAC;YACjB,CAAC;YAAC,OAAO,QAAQ,EAAE,CAAC;gBAClB,UAAU,CAAC,KAAK,EAAE,CAAC;gBACnB,oBAAoB,EAAE,EAAE,CAAC;gBACzB,MAAM,QAAQ,EAAE,KAAK,EAAE,CAAC;gBACxB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBACrC,MAAM,QAAQ,CAAC;YACjB,CAAC;QACH,CAAC,CAAC,EAAE,CAAC;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAChC,CAAC;IAEM,OAAO;QACZ,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC,QAAQ,CAAC;QACxC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,YAAY;YAAE,UAAU,CAAC,KAAK,EAAE,CAAC;QAC/D,IAAI,CAAC,QAAQ,GAAG,CAAC,KAAK,IAAI,EAAE;YAC1B,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YAC5C,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;YACjF,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAC5B,CAAC,CAAC,EAAE,CAAC;QACL,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,WAAW,KAAW,IAAI,IAAI,CAAC,UAAU;QAAE,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC,CAAC,CAAC;IAE3G,eAAe,KAAW,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,IAAI,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC,CAAC,CAAC;IAE7H,MAAM,CAAU,YAA8B;QAC5C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAC/B,KAAK,YAAY,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;QACzG,OAAO,YAAY,CAAC;IACtB,CAAC;CACF;AAED,MAAM,OAAO,4BAA6B,SAAQ,eAAe;CAAG"}

package/dist_ts/integrations/tuya/tuya.classes.runtime.d.ts

@@ -0,0 +1,15 @@
+import * as plugins from '../../plugins.js';
+import type { IDeviceFeatureWriteRequest, IIntegrationEntity, IIntegrationEvent, IIntegrationRuntime, ILogger, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
+import type { IHomeAssistantTuyaConfig } from './tuya.types.js';
+export declare class TuyaRuntime implements IIntegrationRuntime {
+    #private;
+    readonly domain = "tuya";
+    constructor(configArg: IHomeAssistantTuyaConfig, protocolArg: plugins.ecobridgeDeviceManager.TuyaProtocol, reportsArg: readonly plugins.ecobridgeDeviceManager.ITuyaDatapointReport[], onDestroyedArg: () => void, loggerArg?: ILogger);
+    isHealthy(): boolean;
+    devices(signalArg?: AbortSignal): Promise<plugins.shxInterfaces.data.IDeviceDefinition[]>;
+    entities(): Promise<IIntegrationEntity[]>;
+    subscribe(handlerArg: (eventArg: IIntegrationEvent) => void, signalArg?: AbortSignal): Promise<() => Promise<void>>;
+    writeFeature(requestArg: IDeviceFeatureWriteRequest, signalArg?: AbortSignal): Promise<IServiceCallResult>;
+    callService(requestArg: IServiceCallRequest): Promise<IServiceCallResult>;
+    destroy(): Promise<void>;
+}

package/dist_ts/integrations/tuya/tuya.classes.runtime.js

@@ -0,0 +1,189 @@
+import * as plugins from '../../plugins.js';
+import { tuyaDeviceId, tuyaDevices, tuyaEntities, tuyaEntityId, tuyaFeatureId } from './tuya.mapper.js';
+import { tuyaKeys, tuyaRecord, tuyaValueMatches } from './tuya.validation.js';
+export class TuyaRuntime {
+    domain = 'tuya';
+    #config;
+    #protocol;
+    #onDestroyed;
+    #logger;
+    #observed = new Map();
+    #subscriptions = new Set();
+    #subscriptionCleanup = new Set();
+    #unsubscribe;
+    #unsubscribeErrors;
+    #closed = false;
+    #destroy;
+    constructor(configArg, protocolArg, reportsArg, onDestroyedArg, loggerArg) {
+        this.#config = configArg;
+        this.#protocol = protocolArg;
+        this.#onDestroyed = onDestroyedArg;
+        this.#logger = loggerArg;
+        for (const report of reportsArg)
+            this.#accept(report);
+        if (this.#observed.size === 0)
+            throw new Error('Tuya device reported none of the configured product datapoints.');
+        this.#unsubscribe = this.#protocol.subscribe((report) => {
+            try {
+                this.#accept(report);
+            }
+            catch {
+                this.#closed = true;
+                this.#emit({ type: 'error', data: { code: 'schema-mismatch', message: 'Tuya reported data no longer matches the configured product schema.' } });
+                this.#emit({ type: 'availability_changed', data: { available: false } });
+                void this.destroy();
+            }
+        });
+        this.#unsubscribeErrors = this.#protocol.subscribeErrors((error) => {
+            this.#emit({ type: 'error', data: { code: error.code, effectOutcome: error.effectOutcome } });
+            if (!this.#protocol.connected)
+                this.#emit({ type: 'availability_changed', data: { available: false } });
+        });
+    }
+    isHealthy() { return !this.#closed && this.#protocol.connected; }
+    async devices(signalArg) {
+        signalArg?.throwIfAborted();
+        return tuyaDevices(this.#config, [...this.#observed.values()], this.isHealthy());
+    }
+    async entities() {
+        return tuyaEntities(this.#config, [...this.#observed.values()], this.isHealthy());
+    }
+    async subscribe(handlerArg, signalArg) {
+        if (this.#closed)
+            throw new Error('Tuya runtime is permanently closed.');
+        if (typeof handlerArg !== 'function')
+            throw new TypeError('Tuya subscription handler must be a function.');
+        signalArg?.throwIfAborted();
+        if (this.#subscriptions.size >= 128)
+            throw new Error('Tuya subscription capacity reached.');
+        const subscriber = (eventArg) => handlerArg(eventArg);
+        const cleanup = () => {
+            this.#subscriptions.delete(subscriber);
+            this.#subscriptionCleanup.delete(cleanup);
+            signalArg?.removeEventListener('abort', cleanup);
+        };
+        this.#subscriptions.add(subscriber);
+        this.#subscriptionCleanup.add(cleanup);
+        signalArg?.addEventListener('abort', cleanup, { once: true });
+        if (signalArg?.aborted)
+            cleanup();
+        return async () => cleanup();
+    }
+    async writeFeature(requestArg, signalArg) {
+        try {
+            const request = tuyaRecord(requestArg, 'feature write');
+            tuyaKeys(request, ['device', 'feature', 'value']);
+            const device = tuyaRecord(request.device, 'feature device');
+            const feature = tuyaRecord(request.feature, 'feature');
+            if (device.id !== tuyaDeviceId(this.#config) || device.integrationDomain !== 'tuya')
+                throw new Error('Tuya feature target is outside the runtime home/device scope.');
+            const observed = [...this.#observed.values()].find(({ mapping }) => tuyaFeatureId(mapping) === feature.id);
+            if (!observed)
+                throw new Error('Tuya feature has not been observed on the configured device.');
+            return await this.#write(observed.mapping, request.value, signalArg);
+        }
+        catch (errorArg) {
+            return this.#failure(errorArg);
+        }
+    }
+    async callService(requestArg) {
+        try {
+            const request = tuyaRecord(requestArg, 'service request');
+            tuyaKeys(request, ['domain', 'service', 'target', 'data']);
+            const target = tuyaRecord(request.target, 'service target');
+            tuyaKeys(target, ['deviceId', 'entityId']);
+            if (target.deviceId !== undefined && target.deviceId !== tuyaDeviceId(this.#config))
+                throw new Error('Tuya service device is outside the runtime home/device scope.');
+            if (typeof target.entityId !== 'string')
+                throw new Error('Tuya service requires an exact owned datapoint entity.');
+            const observed = [...this.#observed.values()].find(({ mapping }) => tuyaEntityId(this.#config, mapping) === target.entityId);
+            if (!observed)
+                throw new Error('Tuya service entity is outside the observed product schema.');
+            const data = request.data === undefined ? {} : tuyaRecord(request.data, 'service data');
+            let value;
+            if (observed.mapping.kind === 'switch' && request.domain === 'switch' && (request.service === 'turn_on' || request.service === 'turn_off')) {
+                tuyaKeys(data, []);
+                value = request.service === 'turn_on';
+            }
+            else if (observed.mapping.kind === 'brightness' && request.domain === 'number' && request.service === 'set_value') {
+                tuyaKeys(data, ['value']);
+                value = data.value;
+            }
+            else
+                throw new Error('Tuya service is outside the supported scoped switch/brightness controls.');
+            return await this.#write(observed.mapping, value);
+        }
+        catch (errorArg) {
+            return this.#failure(errorArg);
+        }
+    }
+    destroy() {
+        if (this.#destroy)
+            return this.#destroy;
+        this.#closed = true;
+        this.#unsubscribe();
+        this.#unsubscribeErrors();
+        for (const cleanup of [...this.#subscriptionCleanup])
+            cleanup();
+        this.#destroy = this.#protocol.close().then(() => this.#onDestroyed());
+        return this.#destroy;
+    }
+    #accept(reportArg) {
+        const changes = [];
+        for (const mapping of this.#config.datapoints) {
+            const value = reportArg.datapoints[String(mapping.id)];
+            if (value === undefined)
+                continue;
+            if (!tuyaValueMatches(mapping, value))
+                throw new Error('Tuya reported datapoint violates its configured product schema.');
+            changes.push(Object.freeze({ mapping, value, receivedAt: reportArg.receivedAt }));
+        }
+        const previous = new Map(this.#observed);
+        for (const observed of changes)
+            this.#observed.set(observed.mapping.id, observed);
+        for (const observed of changes) {
+            const prior = previous.get(observed.mapping.id);
+            if (!prior || prior.value !== observed.value)
+                this.#emit({ type: prior ? 'state_changed' : 'entity_added',
+                    entityId: tuyaEntityId(this.#config, observed.mapping), data: { entity: tuyaEntities(this.#config, [observed], this.isHealthy())[0] } });
+        }
+    }
+    async #write(mappingArg, valueArg, signalArg) {
+        if (!this.isHealthy())
+            throw new Error('Tuya session is unavailable; no automatic reconnect or retry is performed.');
+        if (mappingArg.kind === 'sensor' || mappingArg.access !== 'read-write')
+            throw new Error('Tuya datapoint is read-only.');
+        if (!tuyaValueMatches(mappingArg, valueArg))
+            throw new TypeError('Tuya write value does not match its configured type/range/step.');
+        const receipt = await this.#protocol.setDatapoints({ [mappingArg.id]: valueArg }, signalArg);
+        return { success: true, data: { ...receipt, physicalCompletion: 'unconfirmed', state: 'observe-authenticated-reports' } };
+    }
+    #failure(errorArg) {
+        if (errorArg instanceof plugins.ecobridgeDeviceManager.TuyaProtocolError)
+            return {
+                success: false, error: errorArg.message,
+                data: { code: errorArg.code, effectOutcome: errorArg.effectOutcome, ...(errorArg.sequence === undefined ? {} : { sequence: errorArg.sequence }) },
+            };
+        return { success: false, error: errorArg instanceof Error ? errorArg.message : 'Tuya operation failed.', data: { effectOutcome: 'not-sent' } };
+    }
+    #emit(eventArg) {
+        for (const handler of [...this.#subscriptions]) {
+            if (this.#destroy)
+                return;
+            try {
+                const result = handler({ ...structuredClone(eventArg), integrationDomain: 'tuya', deviceId: tuyaDeviceId(this.#config), timestamp: Date.now() });
+                if (result instanceof Promise)
+                    void result.catch(() => this.#subscriberFailed());
+            }
+            catch {
+                this.#subscriberFailed();
+            }
+        }
+    }
+    #subscriberFailed() {
+        if (this.#destroy)
+            return;
+        this.#logger?.log('error', 'Tuya event subscriber failed.', { code: 'subscriber-error' });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tuya.classes.runtime.js","sourceRoot":"","sources":["../../../ts/integrations/tuya/tuya.classes.runtime.ts"],"names":[],"mappings":"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"}

package/dist_ts/integrations/tuya/tuya.mapper.d.ts

@@ -0,0 +1,13 @@
+import * as plugins from '../../plugins.js';
+import type { IIntegrationEntity } from '../../core/types.js';
+import type { IHomeAssistantTuyaConfig, TTuyaDatapointMapping } from './tuya.types.js';
+export interface ITuyaObservedDatapoint {
+    readonly mapping: TTuyaDatapointMapping;
+    readonly value: plugins.ecobridgeDeviceManager.TTuyaDatapointValue;
+    readonly receivedAt: number;
+}
+export declare const tuyaDeviceId: (configArg: IHomeAssistantTuyaConfig) => string;
+export declare const tuyaFeatureId: (mappingArg: TTuyaDatapointMapping) => string;
+export declare const tuyaEntityId: (configArg: IHomeAssistantTuyaConfig, mappingArg: TTuyaDatapointMapping) => string;
+export declare const tuyaDevices: (configArg: IHomeAssistantTuyaConfig, observedArg: readonly ITuyaObservedDatapoint[], availableArg: boolean) => plugins.shxInterfaces.data.IDeviceDefinition[];
+export declare const tuyaEntities: (configArg: IHomeAssistantTuyaConfig, observedArg: readonly ITuyaObservedDatapoint[], availableArg: boolean) => IIntegrationEntity[];

package/dist_ts/integrations/tuya/tuya.mapper.js

@@ -0,0 +1,30 @@
+import * as plugins from '../../plugins.js';
+export const tuyaDeviceId = (configArg) => `tuya:${encodeURIComponent(configArg.homeId)}:${configArg.deviceId}`;
+export const tuyaFeatureId = (mappingArg) => `dp_${mappingArg.id}`;
+export const tuyaEntityId = (configArg, mappingArg) => `${tuyaDeviceId(configArg)}:dp:${mappingArg.id}`;
+const displayValue = (observedArg) => observedArg.mapping.kind === 'sensor' && observedArg.mapping.valueType === 'integer' && typeof observedArg.value === 'number'
+    ? observedArg.value / 10 ** (observedArg.mapping.scale ?? 0) : observedArg.value;
+export const tuyaDevices = (configArg, observedArg, availableArg) => [{
+        id: tuyaDeviceId(configArg), integrationDomain: 'tuya', name: configArg.name ?? `Tuya ${configArg.deviceId}`,
+        protocol: 'unknown', manufacturer: 'Tuya', online: availableArg,
+        features: observedArg.map(({ mapping }) => ({
+            id: tuyaFeatureId(mapping), name: mapping.name, readable: true,
+            writable: mapping.kind !== 'sensor' && mapping.access === 'read-write',
+            capability: mapping.kind === 'switch' ? 'switch' : mapping.kind === 'brightness' ? 'light' : 'sensor',
+            ...(mapping.kind === 'sensor' && mapping.unit !== undefined ? { unit: mapping.unit } : {}),
+        })),
+        state: observedArg.map((observed) => ({ featureId: tuyaFeatureId(observed.mapping), value: displayValue(observed), updatedAt: new Date(observed.receivedAt).toISOString() })),
+        metadata: {
+            homeId: configArg.homeId, deviceId: configArg.deviceId, transport: 'tuya-3.4',
+            datapoints: observedArg.map(({ mapping }) => ({ ...mapping })),
+        },
+    }];
+export const tuyaEntities = (configArg, observedArg, availableArg) => observedArg.map((observed) => ({
+    id: tuyaEntityId(configArg, observed.mapping), uniqueId: tuyaEntityId(configArg, observed.mapping),
+    integrationDomain: 'tuya', deviceId: tuyaDeviceId(configArg), name: observed.mapping.name,
+    platform: observed.mapping.kind === 'switch' ? 'switch' : observed.mapping.kind === 'brightness' ? 'number' :
+        observed.mapping.valueType === 'boolean' ? 'binary_sensor' : 'sensor',
+    state: displayValue(observed), available: availableArg,
+    attributes: { ...observed.mapping, homeId: configArg.homeId, updatedAt: new Date(observed.receivedAt).toISOString() },
+}));
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/tuya/tuya.types.d.ts

@@ -1,3 +1,42 @@
+export type TTuyaDatapointAccess = 'read' | 'read-write';
+export interface ITuyaDatapointIdentity {
+    readonly id: number;
+    readonly name: string;
+}
+export interface ITuyaSwitchDatapoint extends ITuyaDatapointIdentity {
+    readonly kind: 'switch';
+    readonly access: TTuyaDatapointAccess;
+}
+export interface ITuyaBrightnessDatapoint extends ITuyaDatapointIdentity {
+    readonly kind: 'brightness';
+    readonly access: TTuyaDatapointAccess;
+    readonly min: number;
+    readonly max: number;
+    readonly step: number;
+}
+export interface ITuyaSensorDatapoint extends ITuyaDatapointIdentity {
+    readonly kind: 'sensor';
+    readonly valueType: 'boolean' | 'integer' | 'string';
+    /** Number of decimal places in a Tuya integer value; sensor display only. */
+    readonly scale?: number;
+    readonly unit?: string;
+}
+export type TTuyaDatapointMapping = ITuyaSwitchDatapoint | ITuyaBrightnessDatapoint | ITuyaSensorDatapoint;
+/** Non-secret product configuration. Credentials are provisioned into NoSqlConfigStore. */
 export interface IHomeAssistantTuyaConfig {
-    [key: string]: unknown;
+    readonly homeId: string;
+    readonly deviceId: string;
+    readonly host: string;
+    readonly version: '3.4';
+    readonly port?: number;
+    readonly name?: string;
+    readonly datapoints: readonly TTuyaDatapointMapping[];
+    readonly connectTimeoutMs?: number;
+    readonly requestTimeoutMs?: number;
+    readonly heartbeatIntervalMs?: number;
+}
+export interface ITuyaStoredConfiguration {
+    readonly version: 1;
+    readonly config: IHomeAssistantTuyaConfig;
+    readonly localKey: string;
 }

package/dist_ts/integrations/tuya/tuya.validation.d.ts

@@ -0,0 +1,10 @@
+import * as plugins from '../../plugins.js';
+import { NoSqlConfigStore } from '../../core/classes.configstore.js';
+import type { IIntegrationSetupContext } from '../../core/types.js';
+import type { IHomeAssistantTuyaConfig, TTuyaDatapointMapping } from './tuya.types.js';
+export declare const tuyaRecord: (valueArg: unknown, labelArg: string) => Record<string, unknown>;
+export declare const tuyaKeys: (recordArg: Record<string, unknown>, allowedArg: readonly string[]) => void;
+export declare const normalizeTuyaConfig: (valueArg: unknown) => IHomeAssistantTuyaConfig;
+export declare const scopedTuyaStore: (configArg: IHomeAssistantTuyaConfig, contextArg: IIntegrationSetupContext) => NoSqlConfigStore;
+export declare const tuyaCredentialId: (deviceIdArg: string) => string;
+export declare const tuyaValueMatches: (mappingArg: TTuyaDatapointMapping, valueArg: unknown) => valueArg is plugins.ecobridgeDeviceManager.TTuyaDatapointValue;