Implement fromZigbee converter processing for real-time state updates

processIncomingMessage was receiving ZCL attribute data from device
messages but discarding everything except a debug log of link quality.
Adopted devices never reflected real-time state changes, making the
integration effectively write-only.

Now implements the full fromZigbee pipeline:
1. Iterates fromZigbee converters from the device definition, matching
   by cluster name (same pattern as zigbee-herdsman-converters expects)
2. Each converter's convert() translates raw ZCL data into a state
   object (e.g. { temperature: 22.5, humidity: 65.3 })
3. Adds linkquality to the state if present in the message
4. Fetches all channel properties for the adopted device
5. Matches state keys to property identifiers (set to zigbee expose
   names during adoption) and writes values via PropertyValueService
6. PropertyValueService handles persistence, change detection, and
   WebSocket broadcast

The CI failure (devices-shelly-ng resetReconnectInterval) is a
pre-existing issue on main, not related to this plugin.

https://claude.ai/code/session_014bjB9Cn1WKASNLBeCuSbom

Author: claude

apps/backend/src/plugins/devices-zigbee-herdsman/services/zigbee-herdsman.service.ts

@@ -1,11 +1,14 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-assignment */
 import { Injectable } from '@nestjs/common';
 
 import { ExtensionLoggerService, createExtensionLogger } from '../../../common/logger';
 import { ConfigService } from '../../../modules/config/services/config.service';
 import { ConnectionState } from '../../../modules/devices/devices.constants';
+import { ChannelPropertyEntity } from '../../../modules/devices/entities/devices.entity';
+import { ChannelsPropertiesService } from '../../../modules/devices/services/channels.properties.service';
 import { DeviceConnectivityService } from '../../../modules/devices/services/device-connectivity.service';
 import { DevicesService } from '../../../modules/devices/services/devices.service';
+import { PropertyValueService } from '../../../modules/devices/services/property-value.service';
 import {
 	ConfigChangeResult,
 	IManagedPluginService,
@@ -40,6 +43,8 @@ export class ZigbeeHerdsmanService implements IManagedPluginService {
 		private readonly configService: ConfigService,
 		private readonly configValidator: ZigbeeHerdsmanConfigValidatorService,
 		private readonly devicesService: DevicesService,
+		private readonly channelsPropertiesService: ChannelsPropertiesService,
+		private readonly propertyValueService: PropertyValueService,
 		private readonly deviceConnectivityService: DeviceConnectivityService,
 		private readonly zhConnectivityService: ZhDeviceConnectivityService,
 	) {}
@@ -187,8 +192,8 @@ export class ZigbeeHerdsmanService implements IManagedPluginService {
 
 	private async processIncomingMessage(
 		ieeeAddress: string,
-		_cluster: string,
-		_data: Record<string, unknown>,
+		cluster: string,
+		data: Record<string, unknown>,
 		linkquality?: number,
 	): Promise<void> {
 		try {
@@ -200,16 +205,81 @@ export class ZigbeeHerdsmanService implements IManagedPluginService {
 				return; // Device not adopted yet
 			}
 
-			// Process fromZigbee converters via discovered device definition
 			const discovered = this.adapterService.getDiscoveredDevice(ieeeAddress);
 			if (!discovered?.definition) {
 				return;
 			}
 
-			// Link quality update is the primary use case for now
-			// Full fromZigbee converter integration requires property value write service
+			// Run fromZigbee converters to translate raw ZCL data into a state object
+			// (e.g. { temperature: 22.5, humidity: 65.3 })
+			let convertedState: Record<string, unknown> = {};
+
+			const herdsmanDevice = this.adapterService.getHerdsmanDevice(ieeeAddress);
+			for (const converter of discovered.definition.fromZigbee as any[]) {
+				try {
+					if (!converter.cluster || (converter.cluster !== cluster && converter.cluster !== '*')) {
+						continue;
+					}
+					if (typeof converter.convert !== 'function') {
+						continue;
+					}
+
+					const result = converter.convert(
+						herdsmanDevice,
+						data,
+						{},
+						{ state: convertedState, logger: this.logger, device: herdsmanDevice },
+						{},
+					);
+
+					if (result && typeof result === 'object') {
+						convertedState = { ...convertedState, ...(result as Record<string, unknown>) };
+					}
+				} catch {
+					// Individual converter failure is not critical
+				}
+			}
+
+			// Add linkquality to the state if present
 			if (linkquality !== undefined) {
-				this.logger.debug(`Device ${ieeeAddress} LQI: ${linkquality}`);
+				convertedState['linkquality'] = linkquality;
+			}
+
+			if (Object.keys(convertedState).length === 0) {
+				return;
+			}
+
+			// Write converted values to matching channel properties
+			// Property identifiers are set to zigbee expose names during adoption
+			const allProperties = await this.channelsPropertiesService.findAll<ChannelPropertyEntity>(
+				undefined,
+				DEVICES_ZIGBEE_HERDSMAN_TYPE,
+			);
+
+			// Filter to properties belonging to this device's channels
+			const deviceChannelIds = new Set(device.channels?.map((c) => c.id) ?? []);
+			const deviceProperties = allProperties.filter((p) => {
+				const channelId = typeof p.channel === 'string' ? p.channel : p.channel?.id;
+				return channelId && deviceChannelIds.has(channelId);
+			});
+
+			for (const property of deviceProperties) {
+				const stateKey = property.identifier;
+				if (!stateKey || !(stateKey in convertedState)) {
+					continue;
+				}
+
+				const value = convertedState[stateKey];
+				if (value === undefined || value === null) {
+					continue;
+				}
+
+				try {
+					const writeValue = typeof value === 'object' ? JSON.stringify(value) : (value as string | number | boolean);
+					await this.propertyValueService.write(property, writeValue);
+				} catch {
+					// Non-critical — individual property write failures are logged by PropertyValueService
+				}
 			}
 		} catch (error) {
 			const err = error as Error;