matterbridge-lg-thinq-plugin 0.1.0

package/src/services/thinq/mqtt/thinqMqttListener.ts

@@ -0,0 +1,120 @@
+import { device as awsIotDevice } from 'aws-iot-device-sdk';
+import { AnsiLogger } from 'matterbridge/logger';
+
+import { ThinqSnapshot } from '../../../core/domain/value-objects/ThinqSnapshot.js';
+import { ThinqApiClient } from '../thinqApiClient.js';
+import { ThinqDeviceUpdateListener } from '../thinqDeviceService.js';
+import { certificateRequestBody, downloadRootCa, writeMqttCertificateFiles } from './mqttCertificate.js';
+import { MqttReconnectScheduler, MqttRuntimeDevice, wireMqttDeviceEvents } from './mqttConnectionEvents.js';
+import { MqttKeyRepository } from './mqttKeyRepository.js';
+import { retryMqttRegistration } from './mqttRetry.js';
+
+/**
+ * Orchestrates MQTT push updates for ThinQ2 AirConditioner devices, running concurrently alongside
+ * `ThinqDeviceService`'s polling loop. Never rejects from `start()` — graceful degradation is structural
+ * (bounded retries, then log-and-return), so polling can continue independently on total MQTT failure.
+ */
+export class ThinqMqttListener {
+	private stopped = false;
+	private device: MqttRuntimeDevice | undefined;
+	private reconnectTimer: NodeJS.Timeout | undefined;
+
+	constructor(
+		private readonly apiClient: ThinqApiClient,
+		private readonly keyRepository: MqttKeyRepository,
+		private readonly mqttDir: string,
+		private readonly logger: AnsiLogger,
+	) {}
+
+	public async start(onUpdate: ThinqDeviceUpdateListener): Promise<void> {
+		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.');
+		}
+	}
+
+	public stop(): void {
+		this.stopped = true;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = undefined;
+		}
+		this.device?.end();
+		this.device = undefined;
+	}
+
+	private async connect(onUpdate: ThinqDeviceUpdateListener): Promise<void> {
+		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,
+		}) as unknown as MqttRuntimeDevice;
+		this.device = device;
+
+		const reconnect = async (): Promise<void> => {
+			if (this.stopped) {
+				return;
+			}
+			await this.connect(onUpdate);
+		};
+
+		const scheduleReconnect: MqttReconnectScheduler = (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,
+		});
+	}
+
+	private handleMessage(payload: unknown, onUpdate: ThinqDeviceUpdateListener): void {
+		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 as { deviceId: unknown; data?: { state?: { reported?: unknown } } };
+		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 as Record<string, unknown>));
+	}
+}

package/src/services/thinq/serviceContainer.test.ts

@@ -0,0 +1,203 @@
+import type { LocalStorage } from 'node-persist';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { PlatformConfigManager } from '../../platform/platformConfigManager.js';
+import { asPartial, createMockLogger } from '../../tests/helpers/testUtils.js';
+import { ThinqServiceContainer } from './serviceContainer.js';
+
+describe('ThinqServiceContainer', () => {
+	let mockLogger: ReturnType<typeof createMockLogger>;
+	let mockPersist: LocalStorage;
+	let mockConfigManager: PlatformConfigManager;
+	let container: ThinqServiceContainer;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockLogger = createMockLogger();
+		mockPersist = asPartial<LocalStorage>({
+			getItem: vi.fn(),
+			setItem: vi.fn(),
+		});
+		mockConfigManager = asPartial<PlatformConfigManager>({
+			country: 'US',
+			language: 'en',
+		});
+		container = new ThinqServiceContainer(mockLogger, mockPersist, mockConfigManager, '/tmp/mqtt');
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	describe('apiClient', () => {
+		it('should return a ThinqApiClient instance', () => {
+			const apiClient = container.apiClient;
+
+			expect(apiClient).toBeDefined();
+		});
+
+		it('should return the same instance on repeated access', () => {
+			const apiClient1 = container.apiClient;
+			const apiClient2 = container.apiClient;
+
+			expect(apiClient1).toBe(apiClient2);
+		});
+	});
+
+	describe('getUserDataRepository', () => {
+		it('should return a UserDataRepository instance', () => {
+			const repo = container.getUserDataRepository();
+
+			expect(repo).toBeDefined();
+		});
+
+		it('should return the same instance on repeated calls (singleton)', () => {
+			const repo1 = container.getUserDataRepository();
+			const repo2 = container.getUserDataRepository();
+
+			expect(repo1).toBe(repo2);
+		});
+	});
+
+	describe('getAuthenticationCoordinator', () => {
+		it('should return an AuthenticationCoordinator instance', () => {
+			const coordinator = container.getAuthenticationCoordinator();
+
+			expect(coordinator).toBeDefined();
+		});
+
+		it('should return the same instance on repeated calls (singleton)', () => {
+			const coordinator1 = container.getAuthenticationCoordinator();
+			const coordinator2 = container.getAuthenticationCoordinator();
+
+			expect(coordinator1).toBe(coordinator2);
+		});
+
+		it('should construct coordinator with apiClient instance', () => {
+			const coordinator = container.getAuthenticationCoordinator();
+
+			expect(coordinator['apiClient']).toBe(container.apiClient);
+		});
+	});
+
+	describe('getDeviceService', () => {
+		it('should return a ThinqDeviceService instance', () => {
+			const service = container.getDeviceService();
+
+			expect(service).toBeDefined();
+		});
+
+		it('should return the same instance on repeated calls (singleton)', () => {
+			const service1 = container.getDeviceService();
+			const service2 = container.getDeviceService();
+
+			expect(service1).toBe(service2);
+		});
+	});
+
+	describe('getDeviceDiscovery', () => {
+		it('should return a ThinqDeviceDiscovery instance', () => {
+			const discovery = container.getDeviceDiscovery();
+
+			expect(discovery).toBeDefined();
+		});
+
+		it('should return the same instance on repeated calls (singleton)', () => {
+			const discovery1 = container.getDeviceDiscovery();
+			const discovery2 = container.getDeviceDiscovery();
+
+			expect(discovery1).toBe(discovery2);
+		});
+
+		it('should reuse the same ThinqDeviceService instance', () => {
+			const deviceService = container.getDeviceService();
+			const discovery = container.getDeviceDiscovery();
+
+			expect(discovery['deviceService']).toBe(deviceService);
+		});
+	});
+
+	describe('getDeviceConfigurator', () => {
+		it('should return a ThinqDeviceConfigurator instance', () => {
+			const configurator = container.getDeviceConfigurator();
+
+			expect(configurator).toBeDefined();
+		});
+
+		it('should return the same instance on repeated calls (singleton)', () => {
+			const configurator1 = container.getDeviceConfigurator();
+			const configurator2 = container.getDeviceConfigurator();
+
+			expect(configurator1).toBe(configurator2);
+		});
+	});
+
+	describe('getMqttListener', () => {
+		it('should return a ThinqMqttListener instance', () => {
+			const listener = container.getMqttListener();
+
+			expect(listener).toBeDefined();
+			expect(listener).toHaveProperty('start');
+			expect(listener).toHaveProperty('stop');
+		});
+
+		it('should return the same instance on repeated calls (singleton)', () => {
+			const listener1 = container.getMqttListener();
+			const listener2 = container.getMqttListener();
+
+			expect(listener1).toBe(listener2);
+		});
+
+		it('should pass the mqttCertDir to the listener instance', () => {
+			const mqttDir = '/custom/mqtt/dir';
+			const customContainer = new ThinqServiceContainer(mockLogger, mockPersist, mockConfigManager, mqttDir);
+
+			const listener = customContainer.getMqttListener();
+
+			expect(listener).toBeDefined();
+			// Verify by checking the private mqttDir field (if accessible, or through behavior)
+			expect(listener['mqttDir']).toBe(mqttDir);
+		});
+
+		it('should use the apiClient instance for the listener', () => {
+			const listener = container.getMqttListener();
+
+			expect(listener['apiClient']).toBe(container.apiClient);
+		});
+
+		it('should use the correct logger for the listener', () => {
+			const listener = container.getMqttListener();
+
+			expect(listener['logger']).toBe(mockLogger);
+		});
+	});
+
+	describe('getFilterMonitoringService', () => {
+		it('should return a ThinqFilterMonitoringService instance', () => {
+			const service = container.getFilterMonitoringService();
+
+			expect(service).toBeDefined();
+			expect(service).toHaveProperty('startPolling');
+			expect(service).toHaveProperty('stopPolling');
+		});
+
+		it('should return the same instance on repeated calls (singleton)', () => {
+			const service1 = container.getFilterMonitoringService();
+			const service2 = container.getFilterMonitoringService();
+
+			expect(service1).toBe(service2);
+		});
+
+		it('should use the apiClient instance', () => {
+			const service = container.getFilterMonitoringService();
+
+			expect(service['apiClient']).toBe(container.apiClient);
+		});
+
+		it('should use the correct logger', () => {
+			const service = container.getFilterMonitoringService();
+
+			expect(service['logger']).toBe(mockLogger);
+		});
+	});
+});

package/src/services/thinq/serviceContainer.ts

@@ -0,0 +1,105 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import { LocalStorage } from 'node-persist';
+
+import { PlatformConfigManager } from '../../platform/platformConfigManager.js';
+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';
+
+/** DI container wiring together ThinQ authentication, discovery, polling, and MQTT push services (singletons). */
+export class ThinqServiceContainer {
+	private readonly apiClientInstance: ThinqApiClient;
+	private authenticationCoordinatorInstance: AuthenticationCoordinator | undefined;
+	private deviceServiceInstance: ThinqDeviceService | undefined;
+	private filterMonitoringServiceInstance: ThinqFilterMonitoringService | undefined;
+	private deviceDiscoveryInstance: ThinqDeviceDiscovery | undefined;
+	private deviceConfiguratorInstance: ThinqDeviceConfigurator | undefined;
+	private userDataRepositoryInstance: UserDataRepository | undefined;
+	private mqttKeyRepositoryInstance: MqttKeyRepository | undefined;
+	private mqttListenerInstance: ThinqMqttListener | undefined;
+
+	constructor(
+		private readonly logger: AnsiLogger,
+		private readonly persist: LocalStorage,
+		private readonly configManager: PlatformConfigManager,
+		private readonly mqttCertDir: string,
+	) {
+		this.apiClientInstance = new ThinqApiClient(
+			new ThinqSession('', '', 0),
+			this.configManager.country,
+			this.configManager.language,
+			this.logger,
+		);
+	}
+
+	public get apiClient(): ThinqApiClient {
+		return this.apiClientInstance;
+	}
+
+	public getUserDataRepository(): UserDataRepository {
+		this.userDataRepositoryInstance ??= new UserDataRepository(this.persist, this.configManager, this.logger);
+		return this.userDataRepositoryInstance;
+	}
+
+	public getAuthenticationCoordinator(): AuthenticationCoordinator {
+		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;
+	}
+
+	public getDeviceService(): ThinqDeviceService {
+		this.deviceServiceInstance ??= new ThinqDeviceService(this.apiClientInstance, this.logger);
+		return this.deviceServiceInstance;
+	}
+
+	public getFilterMonitoringService(): ThinqFilterMonitoringService {
+		this.filterMonitoringServiceInstance ??= new ThinqFilterMonitoringService(this.apiClientInstance, this.logger);
+		return this.filterMonitoringServiceInstance;
+	}
+
+	public getDeviceDiscovery(): ThinqDeviceDiscovery {
+		this.deviceDiscoveryInstance ??= new ThinqDeviceDiscovery(this.getDeviceService(), this.logger);
+		return this.deviceDiscoveryInstance;
+	}
+
+	public getDeviceConfigurator(): ThinqDeviceConfigurator {
+		this.deviceConfiguratorInstance ??= new ThinqDeviceConfigurator(
+			this.logger,
+			this.apiClientInstance,
+			this.configManager,
+		);
+		return this.deviceConfiguratorInstance;
+	}
+
+	public getMqttListener(): ThinqMqttListener {
+		this.mqttListenerInstance ??= new ThinqMqttListener(
+			this.apiClientInstance,
+			this.getMqttKeyRepository(),
+			this.mqttCertDir,
+			this.logger,
+		);
+		return this.mqttListenerInstance;
+	}
+
+	private getMqttKeyRepository(): MqttKeyRepository {
+		this.mqttKeyRepositoryInstance ??= new MqttKeyRepository(this.persist, this.logger);
+		return this.mqttKeyRepositoryInstance;
+	}
+}