matterbridge-lg-thinq-plugin 0.1.0

package/dist/services/thinq/mqtt/thinqMqttListener.js

@@ -0,0 +1,97 @@
+import { device as awsIotDevice } from 'aws-iot-device-sdk';
+import { ThinqSnapshot } from '../../../core/domain/value-objects/ThinqSnapshot.js';
+import { certificateRequestBody, downloadRootCa, writeMqttCertificateFiles } from './mqttCertificate.js';
+import { wireMqttDeviceEvents } from './mqttConnectionEvents.js';
+import { retryMqttRegistration } from './mqttRetry.js';
+export class ThinqMqttListener {
+    apiClient;
+    keyRepository;
+    mqttDir;
+    logger;
+    stopped = false;
+    device;
+    reconnectTimer;
+    constructor(apiClient, keyRepository, mqttDir, logger) {
+        this.apiClient = apiClient;
+        this.keyRepository = keyRepository;
+        this.mqttDir = mqttDir;
+        this.logger = logger;
+    }
+    async start(onUpdate) {
+        this.stop();
+        this.stopped = false;
+        const started = await retryMqttRegistration({
+            register: () => this.connect(onUpdate),
+            logger: this.logger,
+        });
+        if (!started) {
+            this.logger.error('ThinQ MQTT: unable to start after retries, continuing with polling only.');
+        }
+    }
+    stop() {
+        this.stopped = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        this.device?.end();
+        this.device = undefined;
+    }
+    async connect(onUpdate) {
+        const route = await this.apiClient.getMqttRouteInfo();
+        const hostname = new URL(route.mqttServer).hostname;
+        const rootCA = await downloadRootCa(hostname);
+        const keys = await this.keyRepository.getOrCreateKeyPair();
+        const csr = await this.keyRepository.getOrCreateCsr(keys);
+        await this.apiClient.registerMqttClient();
+        const certificate = await this.apiClient.requestMqttCertificate(certificateRequestBody(csr));
+        const paths = await writeMqttCertificateFiles({
+            mqttDir: this.mqttDir,
+            rootCA,
+            privateKey: keys.privateKey,
+            certificatePem: certificate.certificatePem,
+        });
+        this.logger.debug(`ThinQ MQTT: connecting to ${route.mqttServer}`);
+        const device = new awsIotDevice({
+            ...paths,
+            clientId: this.apiClient.getClientId(),
+            host: hostname,
+        });
+        this.device = device;
+        const reconnect = async () => {
+            if (this.stopped) {
+                return;
+            }
+            await this.connect(onUpdate);
+        };
+        const scheduleReconnect = (handler, delayMs) => {
+            if (this.stopped) {
+                return undefined;
+            }
+            this.reconnectTimer = setTimeout(handler, delayMs);
+            return this.reconnectTimer;
+        };
+        wireMqttDeviceEvents({
+            device,
+            logger: this.logger,
+            mqttServer: route.mqttServer,
+            subscriptions: certificate.subscriptions,
+            onMessage: (payload) => this.handleMessage(payload, onUpdate),
+            reconnect,
+            scheduleReconnect,
+        });
+    }
+    handleMessage(payload, onUpdate) {
+        if (typeof payload !== 'object' || payload === null || !('deviceId' in payload) || !('data' in payload)) {
+            this.logger.debug('ThinQ MQTT: received malformed message, skipping.');
+            return;
+        }
+        const message = payload;
+        const reported = message.data?.state?.reported;
+        if (typeof message.deviceId !== 'string' || typeof reported !== 'object' || reported === null) {
+            this.logger.debug('ThinQ MQTT: received message with missing deviceId/reported state, skipping.');
+            return;
+        }
+        onUpdate(message.deviceId, new ThinqSnapshot(reported));
+    }
+}

package/dist/services/thinq/serviceContainer.js

@@ -0,0 +1,73 @@
+import { ThinqDeviceConfigurator } from '../../platform/thinq/thinqDeviceConfigurator.js';
+import { ThinqDeviceDiscovery } from '../../platform/thinq/thinqDeviceDiscovery.js';
+import { AccountAuthStrategy } from '../authentication/AccountAuthStrategy.js';
+import { AuthenticationCoordinator } from '../authentication/AuthenticationCoordinator.js';
+import { TokenAuthStrategy } from '../authentication/TokenAuthStrategy.js';
+import { UserDataRepository } from '../authentication/UserDataRepository.js';
+import { MqttKeyRepository } from './mqtt/mqttKeyRepository.js';
+import { ThinqMqttListener } from './mqtt/thinqMqttListener.js';
+import { ThinqSession } from './session.js';
+import { ThinqApiClient } from './thinqApiClient.js';
+import { ThinqDeviceService } from './thinqDeviceService.js';
+import { ThinqFilterMonitoringService } from './thinqFilterMonitoringService.js';
+export class ThinqServiceContainer {
+    logger;
+    persist;
+    configManager;
+    mqttCertDir;
+    apiClientInstance;
+    authenticationCoordinatorInstance;
+    deviceServiceInstance;
+    filterMonitoringServiceInstance;
+    deviceDiscoveryInstance;
+    deviceConfiguratorInstance;
+    userDataRepositoryInstance;
+    mqttKeyRepositoryInstance;
+    mqttListenerInstance;
+    constructor(logger, persist, configManager, mqttCertDir) {
+        this.logger = logger;
+        this.persist = persist;
+        this.configManager = configManager;
+        this.mqttCertDir = mqttCertDir;
+        this.apiClientInstance = new ThinqApiClient(new ThinqSession('', '', 0), this.configManager.country, this.configManager.language, this.logger);
+    }
+    get apiClient() {
+        return this.apiClientInstance;
+    }
+    getUserDataRepository() {
+        this.userDataRepositoryInstance ??= new UserDataRepository(this.persist, this.configManager, this.logger);
+        return this.userDataRepositoryInstance;
+    }
+    getAuthenticationCoordinator() {
+        if (!this.authenticationCoordinatorInstance) {
+            const accountStrategy = new AccountAuthStrategy(this.apiClientInstance, this.logger);
+            const tokenStrategy = new TokenAuthStrategy(this.apiClientInstance, this.logger);
+            this.authenticationCoordinatorInstance = new AuthenticationCoordinator(accountStrategy, tokenStrategy, this.apiClientInstance, this.logger);
+        }
+        return this.authenticationCoordinatorInstance;
+    }
+    getDeviceService() {
+        this.deviceServiceInstance ??= new ThinqDeviceService(this.apiClientInstance, this.logger);
+        return this.deviceServiceInstance;
+    }
+    getFilterMonitoringService() {
+        this.filterMonitoringServiceInstance ??= new ThinqFilterMonitoringService(this.apiClientInstance, this.logger);
+        return this.filterMonitoringServiceInstance;
+    }
+    getDeviceDiscovery() {
+        this.deviceDiscoveryInstance ??= new ThinqDeviceDiscovery(this.getDeviceService(), this.logger);
+        return this.deviceDiscoveryInstance;
+    }
+    getDeviceConfigurator() {
+        this.deviceConfiguratorInstance ??= new ThinqDeviceConfigurator(this.logger, this.apiClientInstance, this.configManager);
+        return this.deviceConfiguratorInstance;
+    }
+    getMqttListener() {
+        this.mqttListenerInstance ??= new ThinqMqttListener(this.apiClientInstance, this.getMqttKeyRepository(), this.mqttCertDir, this.logger);
+        return this.mqttListenerInstance;
+    }
+    getMqttKeyRepository() {
+        this.mqttKeyRepositoryInstance ??= new MqttKeyRepository(this.persist, this.logger);
+        return this.mqttKeyRepositoryInstance;
+    }
+}

package/dist/services/thinq/session.js

@@ -0,0 +1,48 @@
+export class ThinqSession {
+    accessTokenValue;
+    refreshTokenValue;
+    expiresAtEpochSecondsValue;
+    constructor(accessToken, refreshToken, expiresAtEpochSeconds) {
+        this.accessTokenValue = accessToken;
+        this.refreshTokenValue = refreshToken;
+        this.expiresAtEpochSecondsValue = expiresAtEpochSeconds;
+    }
+    get accessToken() {
+        return this.accessTokenValue;
+    }
+    get refreshToken() {
+        return this.refreshTokenValue;
+    }
+    get expiresAtEpochSeconds() {
+        return this.expiresAtEpochSecondsValue;
+    }
+    hasToken() {
+        return this.accessTokenValue !== '';
+    }
+    isExpired() {
+        return this.expiresAtEpochSecondsValue < ThinqSession.currentEpochSeconds();
+    }
+    hasValidToken() {
+        return this.hasToken() && !this.isExpired();
+    }
+    updateAccessToken(accessToken, expiresAtEpochSeconds) {
+        this.accessTokenValue = accessToken;
+        this.expiresAtEpochSecondsValue = expiresAtEpochSeconds;
+    }
+    static expiryFromExpiresIn(expiresInSeconds) {
+        return ThinqSession.currentEpochSeconds() + expiresInSeconds;
+    }
+    toData() {
+        return {
+            accessToken: this.accessTokenValue,
+            refreshToken: this.refreshTokenValue,
+            expiresAtEpochSeconds: this.expiresAtEpochSecondsValue,
+        };
+    }
+    static fromData(data) {
+        return new ThinqSession(data.accessToken, data.refreshToken, data.expiresAtEpochSeconds);
+    }
+    static currentEpochSeconds() {
+        return Math.round(Date.now() / 1000);
+    }
+}

package/dist/services/thinq/thinqApiClient.js

@@ -0,0 +1,258 @@
+import crypto from 'node:crypto';
+import axios from 'axios';
+import { AuthenticationError, TokenExpiredError } from '../../errors/index.js';
+import { maskSensitiveFields } from '../../utils/mask.js';
+import { formatRfc2822Utc, Gateway, signThinqMessage, THINQ_APPLICATION_KEY, THINQ_CLIENT_ID, THINQ_OAUTH_SECRET_KEY, } from './gateway.js';
+import { ThinqSession } from './session.js';
+const GATEWAY_URL = 'https://route.lgthinq.com:46030/v1/service/application/gateway-uri';
+export const MQTT_ROUTE_URL = 'https://common.lgthinq.com/route';
+const API_KEY = 'VGhpblEyLjAgU0VSVklDRQ==';
+const API_CLIENT_ID = 'c713ea8e50f657534ff8b9d373dfebfc2ed70b88285c26b8ade49868c0b164d9';
+const THINQ_TOKEN_EXPIRED_RESULT_CODE = '0102';
+function randomMessageId(length = 22) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+export class ThinqApiClient {
+    session;
+    country;
+    language;
+    logger;
+    gateway;
+    homesCache;
+    userNumber;
+    clientId;
+    constructor(session, country, language, logger) {
+        this.session = session;
+        this.country = country;
+        this.language = language;
+        this.logger = logger;
+    }
+    setSession(session) {
+        this.session = session;
+    }
+    setUserNumber(userNumber) {
+        this.userNumber = userNumber;
+        this.clientId = crypto.createHash('sha256').update(`${userNumber}${Date.now()}`).digest('hex');
+    }
+    async getGateway() {
+        if (!this.gateway) {
+            const headers = this.defaultHeaders;
+            this.logger.debug(`ThinQ getGateway request -> GET ${GATEWAY_URL} headers=${JSON.stringify(maskSensitiveFields(headers))}`);
+            const response = await axios.get(GATEWAY_URL, { headers });
+            this.gateway = new Gateway(response.data.result);
+        }
+        return this.gateway.data;
+    }
+    async getDeviceModel(modelJsonUri) {
+        this.logger.debug(`ThinQ getDeviceModel request -> GET ${modelJsonUri}`);
+        const response = await axios.get(modelJsonUri);
+        return response.data;
+    }
+    async getListHomes() {
+        if (!this.homesCache) {
+            const data = await this.request('get', 'service/homes');
+            this.homesCache = data.result?.item ?? [];
+        }
+        return this.homesCache;
+    }
+    async getListDevices() {
+        const homes = await this.getListHomes();
+        const devices = [];
+        for (const home of homes) {
+            const data = await this.request('get', `service/homes/${home.homeId}`);
+            devices.push(...(data.result?.devices ?? []));
+        }
+        return devices;
+    }
+    async sendCommand(deviceId, payload) {
+        if (!deviceId.trim()) {
+            throw new Error('Invalid deviceId: must be a non-empty string.');
+        }
+        await this.request('post', `service/devices/${deviceId}/control-sync`, {
+            ctrlKey: 'basicCtrl',
+            command: 'Set',
+            ...payload,
+        });
+    }
+    async sendCommandAndGetResponse(deviceId, payload) {
+        if (!deviceId.trim()) {
+            throw new Error('Invalid deviceId: must be a non-empty string.');
+        }
+        return this.request('post', `service/devices/${deviceId}/control-sync`, {
+            ctrlKey: 'basicCtrl',
+            command: 'Set',
+            ...payload,
+        });
+    }
+    async getFilterState(deviceId) {
+        if (!deviceId.trim()) {
+            throw new Error('Invalid deviceId: must be a non-empty string.');
+        }
+        const response = await this.sendCommandAndGetResponse(deviceId, {
+            ctrlKey: 'filterMngStateCtrl',
+            command: 'Get',
+            dataGetList: [
+                'airState.filterMngState.useTime',
+                'airState.filterMngState.remainTime',
+                'airState.filterMngState.maxTime',
+                'airState.filterMngState.changeDate',
+                'airState.filterMngState.type',
+            ],
+        });
+        return response.result?.data;
+    }
+    async sendKeepAlive(deviceId) {
+        if (!deviceId.trim()) {
+            throw new Error('Invalid deviceId: must be a non-empty string.');
+        }
+        await this.request('post', `service/devices/${deviceId}/control`, {
+            ctrlKey: 'allEventEnable',
+            command: 'Set',
+            dataKey: 'airState.mon.timeout',
+            dataValue: '70',
+        });
+    }
+    async refreshToken(session) {
+        const tokenUrl = `https://${this.country.toLowerCase()}.lgeapi.com/oauth/1.0/oauth2/token`;
+        const data = new URLSearchParams({ grant_type: 'refresh_token', refresh_token: session.refreshToken });
+        const timestamp = formatRfc2822Utc(new Date());
+        const requestUrl = `/oauth/1.0/oauth2/token?${data.toString()}`;
+        const signature = signThinqMessage(`${requestUrl}\n${timestamp}`, THINQ_OAUTH_SECRET_KEY);
+        const headers = {
+            'x-lge-app-os': 'ADR',
+            'x-lge-appkey': THINQ_CLIENT_ID,
+            'x-lge-oauth-signature': signature,
+            'x-lge-oauth-date': timestamp,
+            Accept: 'application/json',
+            'Content-Type': 'application/x-www-form-urlencoded',
+        };
+        this.logger.debug(`ThinQ refreshToken request -> POST ${tokenUrl} headers=${JSON.stringify(maskSensitiveFields(headers))} body=${JSON.stringify(maskSensitiveFields(Object.fromEntries(data.entries())))}`);
+        try {
+            const response = await axios.post(tokenUrl, data.toString(), {
+                headers,
+            });
+            session.updateAccessToken(response.data.access_token, ThinqSession.expiryFromExpiresIn(Number.parseInt(response.data.expires_in, 10)));
+            this.session = session;
+            return session;
+        }
+        catch (error) {
+            this.logger.error(`ThinQ token refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw new TokenExpiredError();
+        }
+    }
+    async getUserNumber(accessToken) {
+        const profileUrl = `https://${this.country.toLowerCase()}.lgeapi.com/users/profile`;
+        const timestamp = formatRfc2822Utc(new Date());
+        const signature = signThinqMessage(`/users/profile\n${timestamp}`, THINQ_OAUTH_SECRET_KEY);
+        const headers = {
+            Accept: 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+            'X-Lge-Svccode': 'SVC202',
+            'X-Application-Key': THINQ_APPLICATION_KEY,
+            'lgemp-x-app-key': THINQ_CLIENT_ID,
+            'X-Device-Type': 'M01',
+            'X-Device-Platform': 'ADR',
+            'x-lge-oauth-date': timestamp,
+            'x-lge-oauth-signature': signature,
+        };
+        this.logger.debug(`ThinQ getUserNumber request -> GET ${profileUrl} headers=${JSON.stringify(maskSensitiveFields(headers))}`);
+        try {
+            const response = await axios.get(profileUrl, {
+                headers,
+            });
+            if (response.data.status === 2) {
+                throw new AuthenticationError(response.data.message ?? 'LG user profile lookup failed.');
+            }
+            return response.data.account.userNo;
+        }
+        catch (error) {
+            this.logger.error(`ThinQ getUserNumber failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    }
+    async getMqttRouteInfo() {
+        const data = await this.request('get', MQTT_ROUTE_URL);
+        return data.result;
+    }
+    async registerMqttClient() {
+        await this.request('post', 'service/users/client', {});
+    }
+    async requestMqttCertificate(csrBody) {
+        const data = await this.request('post', 'service/users/client/certificate', { csr: csrBody });
+        return data.result;
+    }
+    getClientId() {
+        return this.clientId ?? API_CLIENT_ID;
+    }
+    get defaultHeaders() {
+        const authHeaders = {};
+        if (this.session.accessToken) {
+            authHeaders['x-emp-token'] = this.session.accessToken;
+        }
+        if (this.userNumber) {
+            authHeaders['x-user-no'] = this.userNumber;
+        }
+        authHeaders['x-client-id'] = this.clientId ?? API_CLIENT_ID;
+        return {
+            'x-api-key': API_KEY,
+            'x-thinq-app-ver': '3.6.1200',
+            'x-thinq-app-type': 'NUTS',
+            'x-thinq-app-level': 'PRD',
+            'x-thinq-app-os': 'ANDROID',
+            'x-thinq-app-logintype': 'LGE',
+            'x-service-code': 'SVC202',
+            'x-country-code': this.country,
+            'x-language-code': this.language,
+            'x-service-phase': 'OP',
+            'x-origin': 'app-native',
+            'x-model-name': 'samsung/SM-G930L',
+            'x-os-version': 'AOS/7.1.2',
+            'x-app-version': 'LG ThinQ/3.6.12110',
+            'x-message-id': randomMessageId(),
+            'user-agent': 'okhttp/3.14.9',
+            ...authHeaders,
+        };
+    }
+    isTokenExpiredError(error) {
+        if (!axios.isAxiosError(error)) {
+            return false;
+        }
+        if (error.response?.status === 401) {
+            return true;
+        }
+        const data = error.response?.data;
+        return typeof data?.resultCode === 'string' && data.resultCode === THINQ_TOKEN_EXPIRED_RESULT_CODE;
+    }
+    async request(method, uri, data, retry = false) {
+        await this.getGateway();
+        const gateway = this.gateway;
+        if (!gateway) {
+            throw new Error('ThinQ gateway is unavailable.');
+        }
+        const url = new URL(uri, gateway.thinq2Url).href;
+        const headers = this.defaultHeaders;
+        this.logger.debug(`ThinQ request -> ${method.toUpperCase()} ${url} headers=${JSON.stringify(maskSensitiveFields(headers))} data=${JSON.stringify(maskSensitiveFields(data))}`);
+        try {
+            const response = await axios.request({ method, url, data, headers });
+            return response.data;
+        }
+        catch (error) {
+            if (this.isTokenExpiredError(error)) {
+                if (retry) {
+                    throw new TokenExpiredError();
+                }
+                await this.refreshToken(this.session);
+                return this.request(method, uri, data, true);
+            }
+            if (axios.isAxiosError(error)) {
+                this.logger.debug(`ThinQ request failed <- ${method.toUpperCase()} ${url} status=${error.response?.status} data=${JSON.stringify(error.response?.data)}`);
+            }
+            throw error;
+        }
+    }
+}

package/dist/services/thinq/thinqDeviceService.js

@@ -0,0 +1,75 @@
+import { isAirConditionerDevice, isValidThinqDeviceId, toThinqDevice, } from '../../core/domain/entities/ThinqDevice.js';
+export const THINQ_KEEP_ALIVE_INTERVAL_MS = 60000;
+export class ThinqDeviceService {
+    apiClient;
+    logger;
+    pollTimer;
+    pollTickCount = 0;
+    keepAliveTimer;
+    airConditionerOnlineStatus = new Map();
+    constructor(apiClient, logger) {
+        this.apiClient = apiClient;
+        this.logger = logger;
+    }
+    async discoverDevices() {
+        const rawDevices = await this.apiClient.getListDevices();
+        return rawDevices.filter((device) => isValidThinqDeviceId(device.deviceId)).map((device) => toThinqDevice(device));
+    }
+    startPolling(intervalMs, onUpdate) {
+        this.stopPolling();
+        this.pollTickCount = 0;
+        this.logger.debug(`ThinQ polling: starting with interval=${intervalMs}ms`);
+        this.pollTimer = setInterval(() => {
+            void this.pollOnce(onUpdate);
+        }, intervalMs);
+    }
+    stopPolling() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = undefined;
+            this.logger.debug(`ThinQ polling: stopped after ${this.pollTickCount} tick(s)`);
+        }
+    }
+    startKeepAlive(intervalMs = THINQ_KEEP_ALIVE_INTERVAL_MS) {
+        this.stopKeepAlive();
+        this.logger.debug(`ThinQ keep-alive: starting with interval=${intervalMs}ms`);
+        this.keepAliveTimer = setInterval(() => {
+            void this.keepAliveOnce();
+        }, intervalMs);
+    }
+    stopKeepAlive() {
+        if (this.keepAliveTimer) {
+            clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = undefined;
+            this.logger.debug(`ThinQ keep-alive: stopped`);
+        }
+    }
+    async keepAliveOnce() {
+        this.logger.debug(`ThinQ keep-alive: tick at ${new Date().toISOString()}`);
+        for (const [deviceId, online] of this.airConditionerOnlineStatus.entries()) {
+            if (!online) {
+                continue;
+            }
+            try {
+                await this.apiClient.sendKeepAlive(deviceId);
+            }
+            catch (error) {
+                this.logger.debug(`ThinQ keep-alive failed for ${deviceId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async pollOnce(onUpdate) {
+        this.pollTickCount += 1;
+        this.logger.debug(`ThinQ polling: tick #${this.pollTickCount} at ${new Date().toISOString()}`);
+        try {
+            const devices = await this.discoverDevices();
+            this.airConditionerOnlineStatus = new Map(devices.filter(isAirConditionerDevice).map((d) => [d.id, d.online]));
+            for (const device of devices) {
+                onUpdate(device.id, device.snapshot);
+            }
+        }
+        catch (error) {
+            this.logger.error(`ThinQ polling tick failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/services/thinq/thinqFilterMonitoringService.js

@@ -0,0 +1,40 @@
+import { ThinqFilterState } from '../../core/domain/value-objects/ThinqFilterState.js';
+export class ThinqFilterMonitoringService {
+    apiClient;
+    logger;
+    pollTimer;
+    pollTickCount = 0;
+    constructor(apiClient, logger) {
+        this.apiClient = apiClient;
+        this.logger = logger;
+    }
+    startPolling(intervalMs, deviceIds, onUpdate) {
+        this.stopPolling();
+        this.pollTickCount = 0;
+        this.logger.debug(`ThinQ filter monitoring: starting with interval=${intervalMs}ms, devices=${deviceIds.length}`);
+        this.pollTimer = setInterval(() => {
+            void this.pollOnce(deviceIds, onUpdate);
+        }, intervalMs);
+    }
+    stopPolling() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = undefined;
+            this.logger.debug(`ThinQ filter monitoring: stopped after ${this.pollTickCount} tick(s)`);
+        }
+    }
+    async pollOnce(deviceIds, onUpdate) {
+        this.pollTickCount += 1;
+        this.logger.debug(`ThinQ filter monitoring: tick #${this.pollTickCount} at ${new Date().toISOString()}`);
+        for (const deviceId of deviceIds) {
+            try {
+                const data = await this.apiClient.getFilterState(deviceId);
+                onUpdate(deviceId, ThinqFilterState.fromRaw(data));
+            }
+            catch (error) {
+                this.logger.debug(`ThinQ filter monitoring failed for ${deviceId}: ${error instanceof Error ? error.message : String(error)}`);
+                onUpdate(deviceId, undefined);
+            }
+        }
+    }
+}

package/dist/settings.js

@@ -0,0 +1,9 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const PACKAGE_JSON = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+const PACKAGE = JSON.parse(readFileSync(PACKAGE_JSON, 'utf-8'));
+export const ENGINES = PACKAGE.engines;
+export const PLUGIN_NAME = PACKAGE.name;
+export const PLUGIN_VERSION = PACKAGE.version;
+export const PLUGIN_URL = PACKAGE.homepage;