Fix shelly-ng type error, fromZigbee converter args, and platform TOCTOU

1. Fix shelly-ng CI blocker: resetReconnectInterval() doesn't exist on
   the RpcHandler type. Merged the method into the existing cast type
   and call via optional chaining. This was a pre-existing type error
   on main that blocked generate:openapi.

2. Fix fromZigbee converter call signature: convert() expects
   (model, msg, publish, options, meta) but was called with
   (herdsmanDevice, data, {}, meta, {}). Now passes:
   - model: discovered.definition (the device definition)
   - msg: full message object with data, cluster, type, device, endpoint
   - publish: no-op function (required callback, unused in our context)
   - options: empty object
   - meta: { state, logger, device, options }

3. Await converter.convert() result: fromZigbee converters may be async.
   Without await, the Promise object was spread into convertedState
   instead of the actual converted values, silently losing all data.

4. Add TOCTOU guard in platform processBatch: re-check isStarted()
   per device in the loop to detect asynchronous adapter disconnections
   between the initial check and actual command execution.

https://claude.ai/code/session_014bjB9Cn1WKASNLBeCuSbom

Author: claude

apps/backend/src/plugins/devices-shelly-ng/delegates/shelly-device.delegate.ts

@@ -244,11 +244,14 @@ export class ShellyDeviceDelegate extends EventEmitter2 {
 
 		// Access the protected socket to force-terminate it.
 		// TypeScript access modifiers are not enforced at runtime.
-		const rpcHandler = this.shelly.rpcHandler as unknown as { socket?: { terminate?: () => void } };
+		const rpcHandler = this.shelly.rpcHandler as unknown as {
+			socket?: { terminate?: () => void };
+			resetReconnectInterval?: () => void;
+		};
 
 		// Reset reconnect backoff so the library uses the shortest interval
 		// (first entry in reconnectInterval) instead of an escalated delay.
-		this.shelly.rpcHandler.resetReconnectInterval();
+		rpcHandler.resetReconnectInterval?.();
 
 		if (rpcHandler.socket?.terminate) {
 			rpcHandler.socket.terminate();

apps/backend/src/plugins/devices-zigbee-herdsman/platforms/zigbee-herdsman.device.platform.ts

@@ -84,6 +84,12 @@ export class ZigbeeHerdsmanDevicePlatform implements IDevicePlatform {
 		let success = true;
 
 		for (const [ieeeAddress, { payload }] of deviceUpdates) {
+			// Re-check adapter state per device — it may have disconnected asynchronously
+			if (!this.adapterService.isStarted()) {
+				this.logger.warn('Adapter disconnected during batch processing');
+				return false;
+			}
+
 			const discovered = this.adapterService.getDiscoveredDevice(ieeeAddress);
 			if (!discovered?.definition) {
 				this.logger.warn(`No device definition for ${ieeeAddress}, skipping command`);

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

@@ -215,6 +215,20 @@ export class ZigbeeHerdsmanService implements IManagedPluginService {
 			let convertedState: Record<string, unknown> = {};
 
 			const herdsmanDevice = this.adapterService.getHerdsmanDevice(ieeeAddress);
+
+			// Build the message object that fromZigbee converters expect:
+			// convert(model, msg, publish, options, meta)
+			const msg = {
+				data,
+				cluster,
+				type: 'attributeReport',
+				device: herdsmanDevice,
+				endpoint: herdsmanDevice?.getEndpoint?.(1) ?? null,
+				linkquality: linkquality ?? 0,
+			};
+
+			const publish = () => {};
+
 			for (const converter of discovered.definition.fromZigbee as any[]) {
 				try {
 					if (!converter.cluster || (converter.cluster !== cluster && converter.cluster !== '*')) {
@@ -224,15 +238,17 @@ export class ZigbeeHerdsmanService implements IManagedPluginService {
 						continue;
 					}
 
-					const result = converter.convert(
-						herdsmanDevice,
-						data,
-						{},
-						{ state: convertedState, logger: this.logger, device: herdsmanDevice },
-						{},
-					);
+					const meta = {
+						state: convertedState,
+						logger: this.logger,
+						device: herdsmanDevice,
+						options: {},
+					};
+
+					// fromZigbee converters may be sync or async
+					const result = await converter.convert(discovered.definition, msg, publish, {}, meta);
 
-					if (result && typeof result === 'object') {
+					if (result && typeof result === 'object' && !(result instanceof Promise)) {
 						convertedState = { ...convertedState, ...(result as Record<string, unknown>) };
 					}
 				} catch {