homebridge-melcloud-control 4.10.1-beta.1 → 4.10.1

package/CHANGELOG.md

@@ -24,6 +24,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - For plugin < v4.6.0 use Homebridge UI <= v5.5.0
 - For plugin >= v4.6.0 use Homebridge UI >= v5.13.0
 
+# [4.10.1] - (17.04.2026)
+
+## Changes
+
+- fix RESTFul port assigned
+- stability and performance improvements
+- cleanup
+
 # [4.10.0] - (16.04.2026)
 
 ## Changes

package/index.js

@@ -26,16 +26,18 @@ class MelCloudPlatform {
 		}
 
 		api.on('didFinishLaunching', () => {
+			const accountsName = [];
+
 			// Each account is set up independently — a failure in one does not
 			// block the others. Promise.allSettled runs all in parallel.
-			const accountsName = [];
-			const tasks = config.accounts.map(account =>
-				this.setupAccount(account, accountsName, prefDir, log, api)
-			);
-			Promise.allSettled(tasks).then(results => {
+			Promise.allSettled(
+				config.accounts.map(account =>
+					this.setupAccount(account, accountsName, prefDir, log, api)
+				)
+			).then(results => {
 				results.forEach((result, i) => {
 					if (result.status === 'rejected') {
-						log.error(`Account[${i}] setup rejected: ${result.reason?.message ?? result.reason}`);
+						log.error(`Account[${i}] setup error: ${result.reason?.message ?? result.reason}`);
 					}
 				});
 			});
@@ -47,17 +49,15 @@ class MelCloudPlatform {
 	async setupAccount(account, accountsName, prefDir, log, api) {
 		const { name, user, passwd, language, type } = account;
 
-		// Skip disabled accounts silently
 		if (type === 'disabled') return;
 
-		// Validate required fields
-		if (!name || !user || !passwd || !language || accountsName.includes(name)) {
+		if (!name || accountsName.includes(name) || !user || !passwd || !language) {
 			const reason = !name ? 'name missing'
 				: accountsName.includes(name) ? 'name duplicated'
 					: !user ? 'user missing'
 						: !passwd ? 'password missing'
 							: 'language missing';
-			log.warn(`Account ${name ?? '(unnamed)'}: ${reason} — will not be published`);
+			log.warn(`Account ${name ?? '(unnamed)'}: ${reason} — will not be published in the Home app`);
 			return;
 		}
 		accountsName.push(name);
@@ -105,11 +105,11 @@ class MelCloudPlatform {
 						log, api, impulseGenerator
 					);
 				} catch (error) {
-					if (logLevel.error) log.error(`${name}, start error: ${error.message ?? error}, trying again in 120 s`);
+					if (logLevel.error) log.error(`${name}, Start impulse generator error, ${error.message ?? error}, trying again.`);
 				}
 			})
 			.on('state', (state) => {
-				if (logLevel.debug) log.info(`${name}, start impulse generator ${state ? 'started' : 'stopped'}`);
+				if (logLevel.debug) log.info(`${name}, Start impulse generator ${state ? 'started' : 'stopped'}.`);
 			});
 
 		await impulseGenerator.state(true, [{ name: 'start', sampling: 120_000 }]);
@@ -118,7 +118,6 @@ class MelCloudPlatform {
 	// ── Connect, discover and register accessories for one account ────────────
 
 	async startAccount(account, name, type, accountMelcloud, accountRefreshInterval, prefDir, logLevel, log, api, impulseGenerator) {
-		// Determine timers and create the appropriate cloud class
 		let timers;
 		let melCloudClass;
 
@@ -128,145 +127,134 @@ class MelCloudPlatform {
 				melCloudClass = new MelCloud(account, true);
 				break;
 			case 'melcloudhome':
-				timers = [{ name: 'checkDevicesList', sampling: accountRefreshInterval }];
+				timers = [{ name: 'checkDevicesList', sampling: 10_000 }]; // fixed 100s interval for MELCloud Home, as it has its own internal timer
 				melCloudClass = new MelCloudHome(account, true);
 				break;
 			default:
-				if (logLevel.warn) log.warn(`${name}, unknown account type: ${type}`);
+				if (logLevel.warn) log.warn(`Unknown account type: ${type}.`);
 				return;
 		}
 
 		melCloudClass
-			.on('success', msg => log.success(`${name}, ${msg}`))
-			.on('info', msg => log.info(`${name}, ${msg}`))
-			.on('debug', msg => log.info(`${name}, debug: ${msg}`))
-			.on('warn', msg => log.warn(`${name}, ${msg}`))
-			.on('error', msg => log.error(`${name}, ${msg}`));
-
-		// Connect (OAuth / token exchange)
-		const connectData = await melCloudClass.connect();
-		if (!connectData?.State) {
-			if (logLevel.warn) log.warn(`${name}, ${connectData?.Status ?? 'connect failed'}`);
+			.on('success', (msg) => log.success(`${name}, ${msg}`))
+			.on('info', (msg) => log.info(`${name}, ${msg}`))
+			.on('debug', (msg) => log.info(`${name}, debug: ${msg}`))
+			.on('warn', (msg) => log.warn(`${name}, ${msg}`))
+			.on('error', (msg) => log.error(`${name}, ${msg}`));
+
+		// Connect
+		const melCloudAccountData = await melCloudClass.connect();
+		if (!melCloudAccountData?.State) {
+			if (logLevel.warn) log.warn(`${name}, ${melCloudAccountData?.Status ?? 'connect failed'}`);
 			return;
 		}
-		if (logLevel.success) log.success(`${name}, ${connectData.Status}`);
+		if (logLevel.success) log.success(`${name}, ${melCloudAccountData.Status}`);
 
 		// Discover devices
-		const devicesData = await melCloudClass.checkDevicesList();
-		if (!devicesData.State) {
-			if (logLevel.warn) log.warn(`${name}, ${devicesData.Status}`);
+		const melCloudDevicesData = await melCloudClass.checkDevicesList();
+		if (!melCloudDevicesData.State) {
+			if (logLevel.warn) log.warn(`${name}, ${melCloudDevicesData.Status}`);
 			return;
 		}
-		if (logLevel.debug) log.info(`${name}, ${devicesData.Status}`);
-
-		// Filter to only the devices explicitly configured in the plugin config
-		// and present in the API response. d.id is kept as string throughout.
-		const apiDeviceIds = (devicesData.Devices ?? []).map(d => String(d.DeviceID));
+		if (logLevel.debug) log.info(`${name}, ${melCloudDevicesData.Status}`);
 
-		const configuredDevices = [
-			...(account.ataDevices || []).filter(d => (d.displayType ?? 0) > 0 && apiDeviceIds.includes(String(d.id))),
-			...(account.atwDevices || []).filter(d => (d.displayType ?? 0) > 0 && apiDeviceIds.includes(String(d.id))),
-			...(account.ervDevices || []).filter(d => (d.displayType ?? 0) > 0 && apiDeviceIds.includes(String(d.id))),
-		];
+		// Filter configured devices — both sides coerced to string to avoid type mismatch
+		const devicesIds = (melCloudDevicesData.Devices ?? []).map(d => String(d.DeviceID));
+		const ataDevices = (account.ataDevices || []).filter(d => (d.displayType ?? 0) > 0 && devicesIds.includes(String(d.id)));
+		const atwDevices = (account.atwDevices || []).filter(d => (d.displayType ?? 0) > 0 && devicesIds.includes(String(d.id)));
+		const ervDevices = (account.ervDevices || []).filter(d => (d.displayType ?? 0) > 0 && devicesIds.includes(String(d.id)));
+		const devices = [...ataDevices, ...atwDevices, ...ervDevices];
 
-		if (logLevel.debug) {
-			const ata = (account.ataDevices || []).filter(d => (d.displayType ?? 0) > 0 && apiDeviceIds.includes(String(d.id))).length;
-			const atw = (account.atwDevices || []).filter(d => (d.displayType ?? 0) > 0 && apiDeviceIds.includes(String(d.id))).length;
-			const erv = (account.ervDevices || []).filter(d => (d.displayType ?? 0) > 0 && apiDeviceIds.includes(String(d.id))).length;
-			log.info(`${name}, configured devices — ATA: ${ata}, ATW: ${atw}, ERV: ${erv}`);
-		}
+		if (logLevel.debug) log.info(`${name}, found configured devices ATA: ${ataDevices.length}, ATW: ${atwDevices.length}, ERV: ${ervDevices.length}.`);
 
-		// Register each configured device as a Homebridge accessory
-		for (const [index, device] of configuredDevices.entries()) {
+		// Register each device as a Homebridge accessory
+		for (const [index, device] of devices.entries()) {
 			await this.registerDevice({
-				device, index, name, type, accountMelcloud,
+				account, device, index, name, type, accountMelcloud,
 				prefDir, logLevel, log, api,
-				melCloudClass, connectData, devicesData,
+				melCloudClass, melCloudAccountData, melCloudDevicesData,
 			});
 		}
 
-		// Hand off periodic polling to the melcloud class and stop the startup generator
+		// Stop startup generator and hand off to the melcloud class generator
 		await impulseGenerator.state(false);
 		await melCloudClass.impulseGenerator.state(true, timers, false);
 	}
 
 	// ── Register a single device as a Homebridge accessory ───────────────────
 
-	async registerDevice({ device, index, name, type, accountMelcloud, prefDir, logLevel, log, api, melCloudClass, connectData, devicesData }) {
-		const deviceId = String(device.id);
+	async registerDevice({ account, device, index, name, type, accountMelcloud, prefDir, logLevel, log, api, melCloudClass, melCloudAccountData, melCloudDevicesData }) {
+		device.id = String(device.id);
+
 		const deviceName = device.name;
 		const deviceType = device.type;
 		const deviceTypeString = DeviceType[deviceType] ?? `type${deviceType}`;
-		const defaultTempsFile = join(prefDir, `${name}_${deviceId}_Temps`);
+		const defaultTempsFile = `${prefDir}/${name}_${device.id}_Temps`;
 
 		// Find the matching API device — both sides coerced to string
-		const apiDevice = devicesData.Devices.find(d => String(d.DeviceID) === deviceId);
-		if (!apiDevice) {
-			log.warn(`${name}, device ${deviceId} not found in API response — skipping`);
+		const melCloudDeviceData = melCloudDevicesData.Devices.find(d => String(d.DeviceID) === device.id);
+		if (!melCloudDeviceData) {
+			log.warn(`${name}, device ${device.id} not found in API response, skipping`);
 			return;
 		}
 
-		apiDevice.Scenes = devicesData.Scenes ?? [];
+		melCloudDeviceData.Scenes = melCloudDevicesData.Scenes ?? [];
 
-		// Presets, schedules and scenes are filtered to only IDs that exist in the API
-		const presetIds = (apiDevice.Presets ?? []).map(p => String(p.ID));
-		const scheduleIds = (apiDevice.Schedule ?? []).map(s => String(s.Id));
-		const sceneIds = (devicesData.Scenes ?? []).map(s => String(s.Id));
+		// Presets, schedules, scenes — filtered to IDs present in the API response
+		const presetIds = (melCloudDeviceData.Presets ?? []).map(p => String(p.ID));
+		const schedulesIds = (melCloudDeviceData.Schedule ?? []).map(s => String(s.Id));
+		const scenesIds = (melCloudDevicesData.Scenes ?? []).map(s => String(s.Id));
 
 		const presets = accountMelcloud ? (device.presets || []).filter(p => (p.displayType ?? 0) > 0 && presetIds.includes(String(p.id))) : [];
-		const schedules = !accountMelcloud ? (device.schedules || []).filter(s => (s.displayType ?? 0) > 0 && scheduleIds.includes(String(s.id))) : [];
-		const scenes = !accountMelcloud ? (device.scenes || []).filter(s => (s.displayType ?? 0) > 0 && sceneIds.includes(String(s.id))) : [];
+		const schedules = !accountMelcloud ? (device.schedules || []).filter(s => (s.displayType ?? 0) > 0 && schedulesIds.includes(String(s.id))) : [];
+		const scenes = !accountMelcloud ? (device.scenes || []).filter(s => (s.displayType ?? 0) > 0 && scenesIds.includes(String(s.id))) : [];
 		const buttons = (device.buttonsSensors || []).filter(b => (b.displayType ?? 0) > 0);
 
-		// REST port is stored on the device copy, not on the shared account object,
-		// to prevent later iterations overwriting earlier devices' port values.
-		device.id = deviceId;
-		device.restFulPort = type === 'melcloudhome'
+		// Store port on device — never mutate the shared account object
+		account.restFul.port = type === 'melcloudhome'
 			? `${3000}${index}`
-			: deviceId.slice(-4).replace(/^0/, '9');
+			: (device.id).slice(-4).replace(/^0/, '9');
 
-		// Write default temperature file for melcloudhome devices if not yet present
 		if (type === 'melcloudhome') {
 			try {
+				const temps = {
+					defaultCoolingSetTemperature: 24,
+					defaultHeatingSetTemperature: 20,
+				};
 				if (!existsSync(defaultTempsFile)) {
-					writeFileSync(defaultTempsFile, JSON.stringify({
-						defaultCoolingSetTemperature: 24,
-						defaultHeatingSetTemperature: 20,
-					}, null, 2));
+					writeFileSync(defaultTempsFile, JSON.stringify(temps, null, 2));
 					if (logLevel.debug) log.info(`${name}, default temperature file created: ${defaultTempsFile}`);
 				}
 			} catch (error) {
-				if (logLevel.error) log.error(`${name}, ${deviceTypeString}, ${deviceName}, file init error: ${error.message}`);
-				return; // skip this device — cannot proceed without the temps file
+				if (logLevel.error) log.error(`${name}, ${deviceTypeString}, ${deviceName}, File init error: ${error.message}`);
+				return;
 			}
 		}
 
-		// Construct the device class
-		const args = [api, device, presets, schedules, scenes, buttons, defaultTempsFile, melCloudClass, connectData, apiDevice];
+		// Construct the device class — original arg order preserved
 		let deviceClass;
-
 		switch (deviceType) {
-			case 0: deviceClass = new DeviceAta(...args); break; // ATA
-			case 1: deviceClass = new DeviceAtw(...args); break; // ATW
-			case 2: return;                                       // reserved — not implemented
-			case 3: deviceClass = new DeviceErv(...args); break; // ERV
+			case 0: deviceClass = new DeviceAta(api, account, device, presets, schedules, scenes, buttons, defaultTempsFile, melCloudClass, melCloudAccountData, melCloudDeviceData); break; // ATA
+			case 1: deviceClass = new DeviceAtw(api, account, device, presets, schedules, scenes, buttons, defaultTempsFile, melCloudClass, melCloudAccountData, melCloudDeviceData); break; // ATW
+			case 2: return;                                                                                                                                                                   // reserved
+			case 3: deviceClass = new DeviceErv(api, account, device, presets, schedules, scenes, buttons, defaultTempsFile, melCloudClass, melCloudAccountData, melCloudDeviceData); break; // ERV
 			default:
-				if (logLevel.warn) log.warn(`${name}, ${deviceTypeString}, ${deviceName}, unknown device type: ${deviceType}`);
+				if (logLevel.warn) log.warn(`${name}, ${deviceTypeString}, ${deviceName}, received unknown device type: ${deviceType}.`);
 				return;
 		}
 
 		deviceClass
-			.on('devInfo', info => log.info(info))
-			.on('success', msg => log.success(`${name}, ${deviceTypeString}, ${deviceName}, ${msg}`))
-			.on('info', msg => log.info(`${name}, ${deviceTypeString}, ${deviceName}, ${msg}`))
-			.on('debug', msg => log.info(`${name}, ${deviceTypeString}, ${deviceName}, debug: ${msg}`))
-			.on('warn', msg => log.warn(`${name}, ${deviceTypeString}, ${deviceName}, ${msg}`))
-			.on('error', msg => log.error(`${name}, ${deviceTypeString}, ${deviceName}, ${msg}`));
+			.on('devInfo', (info) => log.info(info))
+			.on('success', (msg) => log.success(`${name}, ${deviceTypeString}, ${deviceName}, ${msg}`))
+			.on('info', (msg) => log.info(`${name}, ${deviceTypeString}, ${deviceName}, ${msg}`))
+			.on('debug', (msg) => log.info(`${name}, ${deviceTypeString}, ${deviceName}, debug: ${msg}`))
+			.on('warn', (msg) => log.warn(`${name}, ${deviceTypeString}, ${deviceName}, ${msg}`))
+			.on('error', (msg) => log.error(`${name}, ${deviceTypeString}, ${deviceName}, ${msg}`));
 
 		const accessory = await deviceClass.start();
 		if (accessory) {
 			api.publishExternalAccessories(PluginName, [accessory]);
-			if (logLevel.success) log.success(`${name}, ${deviceTypeString}, ${deviceName}, published as external accessory`);
+			if (logLevel.success) log.success(`${name}, ${deviceTypeString}, ${deviceName}, Published as external accessory.`);
 		}
 	}
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "MELCloud Control",
   "name": "homebridge-melcloud-control",
-  "version": "4.10.1-beta.1",
+  "version": "4.10.1",
   "description": "Homebridge plugin to control Mitsubishi Air Conditioner, Heat Pump and Energy Recovery Ventilation.",
   "license": "MIT",
   "author": "grzegorz914",