matterbridge-lg-thinq-plugin 0.1.0

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

@@ -0,0 +1,264 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ThinqFilterState } from '../../core/domain/value-objects/ThinqFilterState.js';
+import { asPartial, createMockLogger } from '../../tests/helpers/testUtils.js';
+import type { ThinqApiClient } from './thinqApiClient.js';
+import { ThinqFilterMonitoringService } from './thinqFilterMonitoringService.js';
+
+describe('ThinqFilterMonitoringService', () => {
+	let mockApiClient: ThinqApiClient;
+	let mockLogger: ReturnType<typeof createMockLogger>;
+	let service: ThinqFilterMonitoringService;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		vi.useFakeTimers();
+		mockLogger = createMockLogger();
+		mockApiClient = asPartial<ThinqApiClient>({
+			getFilterState: vi.fn(),
+		});
+		service = new ThinqFilterMonitoringService(mockApiClient, mockLogger);
+	});
+
+	afterEach(() => {
+		vi.clearAllTimers();
+		vi.useRealTimers();
+		vi.clearAllMocks();
+	});
+
+	describe('startPolling', () => {
+		it('should set interval and call onUpdate with filter state', async () => {
+			const deviceIds = ['device-1'];
+			const onUpdate = vi.fn();
+			const filterData = {
+				'airState.filterMngStates.useTime': 11,
+				'airState.filterMngStates.maxTime': 720,
+			};
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue(filterData);
+
+			service.startPolling(1000, deviceIds, onUpdate);
+
+			// Advance timer to trigger first poll
+			await vi.advanceTimersByTimeAsync(1000);
+
+			expect(onUpdate).toHaveBeenCalledTimes(1);
+			const filterState = onUpdate.mock.calls[0][1] as ThinqFilterState | undefined;
+			expect(filterState?.remainingPercent).toBe(98);
+		});
+
+		it('should not call onUpdate before interval elapses', async () => {
+			const deviceIds = ['device-1'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue({
+				'airState.filterMngStates.useTime': 11,
+				'airState.filterMngStates.maxTime': 720,
+			});
+
+			service.startPolling(1000, deviceIds, onUpdate);
+
+			// Do not advance timers
+			expect(onUpdate).not.toHaveBeenCalled();
+		});
+
+		it('should call getFilterState for each device in the list', async () => {
+			const deviceIds = ['device-1', 'device-2', 'device-3'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue({
+				'airState.filterMngStates.useTime': 11,
+				'airState.filterMngStates.maxTime': 720,
+			});
+
+			service.startPolling(1000, deviceIds, onUpdate);
+			await vi.advanceTimersByTimeAsync(1000);
+
+			expect(vi.mocked(mockApiClient.getFilterState)).toHaveBeenCalledTimes(3);
+			expect(vi.mocked(mockApiClient.getFilterState)).toHaveBeenCalledWith('device-1');
+			expect(vi.mocked(mockApiClient.getFilterState)).toHaveBeenCalledWith('device-2');
+			expect(vi.mocked(mockApiClient.getFilterState)).toHaveBeenCalledWith('device-3');
+		});
+
+		it('should handle per-device errors and continue with other devices', async () => {
+			const deviceIds = ['device-1', 'device-2', 'device-3'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState)
+				.mockResolvedValueOnce({ 'airState.filterMngStates.useTime': 11, 'airState.filterMngStates.maxTime': 720 })
+				.mockRejectedValueOnce(new Error('Device 2 failed'))
+				.mockResolvedValueOnce({ 'airState.filterMngStates.useTime': 5, 'airState.filterMngStates.maxTime': 600 });
+
+			service.startPolling(1000, deviceIds, onUpdate);
+			await vi.advanceTimersByTimeAsync(1000);
+
+			expect(onUpdate).toHaveBeenCalledTimes(3);
+			// device-1: success
+			expect(onUpdate.mock.calls[0][0]).toBe('device-1');
+			expect(onUpdate.mock.calls[0][1]).toBeDefined();
+			// device-2: error
+			expect(onUpdate.mock.calls[1][0]).toBe('device-2');
+			expect(onUpdate.mock.calls[1][1]).toBeUndefined();
+			// device-3: success
+			expect(onUpdate.mock.calls[2][0]).toBe('device-3');
+			expect(onUpdate.mock.calls[2][1]).toBeDefined();
+		});
+
+		it('should call onUpdate with undefined when device response is empty', async () => {
+			const deviceIds = ['device-1'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue(undefined);
+
+			service.startPolling(1000, deviceIds, onUpdate);
+			await vi.advanceTimersByTimeAsync(1000);
+
+			expect(onUpdate).toHaveBeenCalledWith('device-1', undefined);
+		});
+
+		it('should continue polling on interval', async () => {
+			const deviceIds = ['device-1'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue({
+				'airState.filterMngStates.useTime': 11,
+				'airState.filterMngStates.maxTime': 720,
+			});
+
+			service.startPolling(500, deviceIds, onUpdate);
+
+			await vi.advanceTimersByTimeAsync(500);
+			expect(onUpdate).toHaveBeenCalledTimes(1);
+
+			await vi.advanceTimersByTimeAsync(500);
+			expect(onUpdate).toHaveBeenCalledTimes(2);
+
+			await vi.advanceTimersByTimeAsync(500);
+			expect(onUpdate).toHaveBeenCalledTimes(3);
+
+			service.stopPolling();
+		});
+
+		it('should clear prior timer when startPolling called twice', async () => {
+			const deviceIds = ['device-1'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue({
+				'airState.filterMngStates.useTime': 11,
+				'airState.filterMngStates.maxTime': 720,
+			});
+
+			service.startPolling(1000, deviceIds, onUpdate);
+			service.startPolling(1000, deviceIds, onUpdate);
+
+			// Only one timer should be active
+			await vi.advanceTimersByTimeAsync(1000);
+
+			expect(onUpdate).toHaveBeenCalledTimes(1);
+		});
+
+		it('should log debug message when starting polling', async () => {
+			const deviceIds = ['device-1', 'device-2'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue(undefined);
+
+			service.startPolling(1000, deviceIds, onUpdate);
+
+			expect(mockLogger.debug).toHaveBeenCalledWith(
+				expect.stringContaining('starting with interval=1000ms, devices=2'),
+			);
+		});
+
+		it('should log per-device errors at debug level', async () => {
+			const deviceIds = ['device-1'];
+			const onUpdate = vi.fn();
+			const error = new Error('Network error');
+			vi.mocked(mockApiClient.getFilterState).mockRejectedValue(error);
+
+			service.startPolling(1000, deviceIds, onUpdate);
+			await vi.advanceTimersByTimeAsync(1000);
+
+			expect(mockLogger.debug).toHaveBeenCalledWith(
+				expect.stringContaining('ThinQ filter monitoring failed for device-1'),
+			);
+			expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining('Network error'));
+		});
+	});
+
+	describe('stopPolling', () => {
+		it('should clear timer and stop polling', async () => {
+			const deviceIds = ['device-1'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue({
+				'airState.filterMngStates.useTime': 11,
+				'airState.filterMngStates.maxTime': 720,
+			});
+
+			service.startPolling(1000, deviceIds, onUpdate);
+			await vi.advanceTimersByTimeAsync(1000);
+			expect(onUpdate).toHaveBeenCalledTimes(1);
+
+			service.stopPolling();
+			await vi.advanceTimersByTimeAsync(1000);
+
+			// Should not have been called again after stopPolling
+			expect(onUpdate).toHaveBeenCalledTimes(1);
+		});
+
+		it('should not throw when no timer is active', () => {
+			expect(() => service.stopPolling()).not.toThrow();
+		});
+
+		it('should log debug message when stopped', async () => {
+			const deviceIds = ['device-1'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue({
+				'airState.filterMngStates.useTime': 11,
+				'airState.filterMngStates.maxTime': 720,
+			});
+
+			service.startPolling(1000, deviceIds, onUpdate);
+			await vi.advanceTimersByTimeAsync(1000);
+
+			service.stopPolling();
+
+			expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining('stopped after 1 tick(s)'));
+		});
+
+		it('should reset tick count across start/stop cycles', async () => {
+			const deviceIds = ['device-1'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue({
+				'airState.filterMngStates.useTime': 11,
+				'airState.filterMngStates.maxTime': 720,
+			});
+
+			service.startPolling(500, deviceIds, onUpdate);
+			await vi.advanceTimersByTimeAsync(1000); // 2 ticks
+
+			service.stopPolling();
+
+			vi.mocked(mockLogger.debug).mockClear();
+
+			service.startPolling(500, deviceIds, onUpdate);
+			await vi.advanceTimersByTimeAsync(500); // 1 tick
+
+			service.stopPolling();
+
+			expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining('stopped after 1 tick(s)'));
+		});
+
+		it('should log tick number with timestamp', async () => {
+			const deviceIds = ['device-1'];
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getFilterState).mockResolvedValue({
+				'airState.filterMngStates.useTime': 11,
+				'airState.filterMngStates.maxTime': 720,
+			});
+
+			service.startPolling(100, deviceIds, onUpdate);
+
+			await vi.advanceTimersByTimeAsync(100);
+			await vi.advanceTimersByTimeAsync(100);
+
+			service.stopPolling();
+
+			const debugCalls = vi.mocked(mockLogger.debug).mock.calls.map((call) => call[0]);
+			expect(debugCalls.some((call) => call.includes('tick #1'))).toBe(true);
+			expect(debugCalls.some((call) => call.includes('tick #2'))).toBe(true);
+		});
+	});
+});

package/src/services/thinq/thinqFilterMonitoringService.ts

@@ -0,0 +1,53 @@
+import { AnsiLogger } from 'matterbridge/logger';
+
+import { ThinqFilterState } from '../../core/domain/value-objects/ThinqFilterState.js';
+import { ThinqApiClient } from './thinqApiClient.js';
+
+export type ThinqFilterUpdateListener = (deviceId: string, filterState: ThinqFilterState | undefined) => void;
+
+/**
+ * Dedicated low-frequency poll job for AC filter-life state. Separate from `ThinqDeviceService`'s
+ * snapshot polling because filter state is a different, per-device `Get` RPC on a much slower cadence.
+ */
+export class ThinqFilterMonitoringService {
+	private pollTimer: NodeJS.Timeout | undefined;
+	private pollTickCount = 0;
+
+	constructor(
+		private readonly apiClient: ThinqApiClient,
+		private readonly logger: AnsiLogger,
+	) {}
+
+	public startPolling(intervalMs: number, deviceIds: string[], onUpdate: ThinqFilterUpdateListener): void {
+		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);
+	}
+
+	public stopPolling(): void {
+		if (this.pollTimer) {
+			clearInterval(this.pollTimer);
+			this.pollTimer = undefined;
+			this.logger.debug(`ThinQ filter monitoring: stopped after ${this.pollTickCount} tick(s)`);
+		}
+	}
+
+	private async pollOnce(deviceIds: string[], onUpdate: ThinqFilterUpdateListener): Promise<void> {
+		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/src/settings.ts

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

package/src/tests/cli/commands/devices.test.ts

@@ -0,0 +1,293 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+let mockApiClient: any;
+
+vi.mock('../../../core/domain/entities/ThinqDevice.js', () => ({
+	toThinqDevice: vi.fn((raw: any) => ({
+		name: raw.alias,
+		id: raw.deviceId,
+		type: raw.deviceType,
+		platformType: raw.platformType,
+		modelName: raw.modelName,
+		online: raw.online,
+	})),
+}));
+
+vi.mock('../../../services/thinq/session.js', () => ({
+	ThinqSession: vi.fn(function () {
+		return {};
+	}),
+}));
+
+vi.mock('../../../services/thinq/thinqApiClient.js', () => ({
+	ThinqApiClient: vi.fn(function () {
+		if (!mockApiClient) {
+			mockApiClient = {
+				getListDevices: vi.fn(),
+				setUserNumber: vi.fn(),
+			};
+		}
+		return mockApiClient;
+	}),
+}));
+
+import { cmdDevices } from '../../../cli/commands/devices.js';
+import type { CliSession } from '../../../cli/types.js';
+import { toThinqDevice } from '../../../core/domain/entities/ThinqDevice.js';
+import { ThinqSession } from '../../../services/thinq/session.js';
+import { ThinqApiClient } from '../../../services/thinq/thinqApiClient.js';
+
+describe('cmdDevices', () => {
+	let consoleLogSpy: any;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockApiClient = {
+			getListDevices: vi.fn(),
+			setUserNumber: vi.fn(),
+		};
+		consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+		consoleLogSpy.mockRestore();
+	});
+
+	it('should call setUserNumber when userData.userNumber is set', async () => {
+		// Arrange
+		const session: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token',
+				refreshToken: 'refresh',
+				expiresAtEpochSeconds: 123,
+				country: 'US',
+				language: 'en-US',
+				userNumber: '12345',
+			},
+		};
+		mockApiClient.getListDevices.mockResolvedValue([]);
+
+		// Act
+		await cmdDevices(session, {} as any);
+
+		// Assert
+		expect(mockApiClient.setUserNumber).toHaveBeenCalledWith('12345');
+	});
+
+	it('should not call setUserNumber when userData.userNumber is undefined', async () => {
+		// Arrange
+		const session: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token',
+				refreshToken: 'refresh',
+				expiresAtEpochSeconds: 123,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+		mockApiClient.getListDevices.mockResolvedValue([]);
+
+		// Act
+		await cmdDevices(session, {} as any);
+
+		// Assert
+		expect(mockApiClient.setUserNumber).not.toHaveBeenCalled();
+	});
+
+	it('should print "No devices found." when getListDevices returns empty array', async () => {
+		// Arrange
+		const session: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token',
+				refreshToken: 'refresh',
+				expiresAtEpochSeconds: 123,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+		mockApiClient.getListDevices.mockResolvedValue([]);
+
+		// Act
+		await cmdDevices(session, {} as any);
+
+		// Assert
+		expect(consoleLogSpy).toHaveBeenCalledWith('No devices found.');
+	});
+
+	it('should print device count for multiple devices', async () => {
+		// Arrange
+		const session: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token',
+				refreshToken: 'refresh',
+				expiresAtEpochSeconds: 123,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+		const rawDevices = [
+			{ deviceId: '123', alias: 'Device1', deviceType: 401, platformType: 'THINQ', modelName: 'Model1', online: true },
+			{ deviceId: '456', alias: 'Device2', deviceType: 401, modelName: 'Model2', online: false },
+		];
+		mockApiClient.getListDevices.mockResolvedValue(rawDevices);
+
+		// Act
+		await cmdDevices(session, {} as any);
+
+		// Assert
+		expect(consoleLogSpy).toHaveBeenCalledWith('Found 2 device(s):\n');
+	});
+
+	it('should print device details with platformType when present', async () => {
+		// Arrange
+		const session: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token',
+				refreshToken: 'refresh',
+				expiresAtEpochSeconds: 123,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+		const rawDevices = [
+			{
+				deviceId: '123',
+				alias: 'Living Room AC',
+				deviceType: 401,
+				platformType: 'THINQ',
+				modelName: 'Model1',
+				online: true,
+			},
+		];
+		mockApiClient.getListDevices.mockResolvedValue(rawDevices);
+
+		// Act
+		await cmdDevices(session, {} as any);
+
+		// Assert
+		expect(consoleLogSpy).toHaveBeenCalledWith('1. Living Room AC');
+		expect(consoleLogSpy).toHaveBeenCalledWith('   Platform Type: THINQ');
+	});
+
+	it('should print "unknown" when platformType is undefined', async () => {
+		// Arrange
+		const session: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token',
+				refreshToken: 'refresh',
+				expiresAtEpochSeconds: 123,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+		const rawDevices = [{ deviceId: '123', alias: 'Device', deviceType: 401, modelName: 'Model1', online: true }];
+		mockApiClient.getListDevices.mockResolvedValue(rawDevices);
+
+		// Act
+		await cmdDevices(session, {} as any);
+
+		// Assert
+		expect(consoleLogSpy).toHaveBeenCalledWith('   Platform Type: unknown');
+	});
+
+	it('should call toThinqDevice for each raw device', async () => {
+		// Arrange
+		const session: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token',
+				refreshToken: 'refresh',
+				expiresAtEpochSeconds: 123,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+		const rawDevices = [
+			{ deviceId: '123', alias: 'Device1', deviceType: 401, modelName: 'Model1', online: true },
+			{ deviceId: '456', alias: 'Device2', deviceType: 402, modelName: 'Model2', online: false },
+		];
+		mockApiClient.getListDevices.mockResolvedValue(rawDevices);
+
+		// Act
+		await cmdDevices(session, {} as any);
+
+		// Assert
+		expect(toThinqDevice).toHaveBeenCalledTimes(2);
+	});
+
+	it('should construct ThinqApiClient with correct parameters', async () => {
+		// Arrange
+		const session: CliSession = {
+			loginType: 'account',
+			country: 'KR',
+			language: 'ko-KR',
+			userData: {
+				accessToken: 'access_token',
+				refreshToken: 'refresh_token',
+				expiresAtEpochSeconds: 123456,
+				country: 'KR',
+				language: 'ko-KR',
+			},
+		};
+		mockApiClient.getListDevices.mockResolvedValue([]);
+		const mockLogger = {} as any;
+
+		// Act
+		await cmdDevices(session, mockLogger);
+
+		// Assert
+		expect(ThinqSession).toHaveBeenCalledWith('access_token', 'refresh_token', 123456);
+		expect(ThinqApiClient).toHaveBeenCalledWith(expect.any(Object), 'KR', 'ko-KR', mockLogger);
+	});
+
+	it('should print device numbers starting from 1', async () => {
+		// Arrange
+		const session: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token',
+				refreshToken: 'refresh',
+				expiresAtEpochSeconds: 123,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+		const rawDevices = [
+			{ deviceId: '1', alias: 'Device1', deviceType: 401, modelName: 'Model1', online: true },
+			{ deviceId: '2', alias: 'Device2', deviceType: 402, modelName: 'Model2', online: false },
+			{ deviceId: '3', alias: 'Device3', deviceType: 403, modelName: 'Model3', online: true },
+		];
+		mockApiClient.getListDevices.mockResolvedValue(rawDevices);
+
+		// Act
+		await cmdDevices(session, {} as any);
+
+		// Assert
+		expect(consoleLogSpy).toHaveBeenCalledWith('1. Device1');
+		expect(consoleLogSpy).toHaveBeenCalledWith('2. Device2');
+		expect(consoleLogSpy).toHaveBeenCalledWith('3. Device3');
+	});
+});