homebridge-cync-app 0.1.5 → 0.1.7

package/src/platform.ts

@@ -13,6 +13,24 @@ import { ConfigClient } from './cync/config-client.js';
 import type { CyncCloudConfig, CyncDevice, CyncDeviceMesh } from './cync/config-client.js';
 import { TcpClient } from './cync/tcp-client.js';
 import type { CyncLogger } from './cync/config-client.js';
+import { lookupDeviceModel } from './cync/device-catalog.js';
+
+// Narrowed view of the Cync device properties returned by getDeviceProperties()
+type CyncDeviceRaw = {
+	displayName?: string;
+	firmwareVersion?: string;
+	mac?: string;
+	wifiMac?: string;
+	deviceType?: number;
+	deviceID?: number;
+	commissionedDate?: string;
+	[key: string]: unknown;
+};
+
+// CyncDevice as seen by the platform, possibly enriched with a `raw` block
+type CyncDeviceWithRaw = CyncDevice & {
+	raw?: CyncDeviceRaw;
+};
 
 const toCyncLogger = (log: Logger): CyncLogger => ({
 	debug: log.debug.bind(log),
@@ -26,19 +44,106 @@ interface CyncAccessoryContext {
 		meshId: string;
 		deviceId: string;
 		productId?: string;
+
 		on?: boolean;
+		brightness?: number; // 0–100 (LAN "level")
+
+		// Color state (local cache, not yet read from LAN frames)
+		hue?: number;          // 0–360
+		saturation?: number;   // 0–100
+		rgb?: { r: number; g: number; b: number };
+		colorActive?: boolean; // true if we last set RGB color
 	};
 	[key: string]: unknown;
 }
 
-/**
- * CyncAppPlatform
- *
- * Homebridge platform class responsible for:
- * - Initializing the Cync client
- * - Managing cached accessories
- * - Kicking off device discovery from Cync cloud
- */
+function hsvToRgb(hue: number, saturation: number, value: number): { r: number; g: number; b: number } {
+	const h = ((hue % 360) + 360) % 360;
+	const s = Math.max(0, Math.min(100, saturation)) / 100;
+	const v = Math.max(0, Math.min(100, value)) / 100;
+
+	if (s === 0) {
+		const grey = Math.round(v * 255);
+		return { r: grey, g: grey, b: grey };
+	}
+
+	const sector = h / 60;
+	const i = Math.floor(sector);
+	const f = sector - i;
+
+	const p = v * (1 - s);
+	const q = v * (1 - s * f);
+	const t = v * (1 - s * (1 - f));
+
+	let r = 0;
+	let g = 0;
+	let b = 0;
+
+	switch (i) {
+	case 0:
+		r = v;
+		g = t;
+		b = p;
+		break;
+	case 1:
+		r = q;
+		g = v;
+		b = p;
+		break;
+	case 2:
+		r = p;
+		g = v;
+		b = t;
+		break;
+	case 3:
+		r = p;
+		g = q;
+		b = v;
+		break;
+	case 4:
+		r = t;
+		g = p;
+		b = v;
+		break;
+	default:
+		r = v;
+		g = p;
+		b = q;
+		break;
+	}
+
+	return {
+		r: Math.round(r * 255),
+		g: Math.round(g * 255),
+		b: Math.round(b * 255),
+	};
+}
+
+function resolveDeviceType(device: CyncDevice): number | undefined {
+	const typedDevice = device as unknown as {
+		device_type?: number;
+		raw?: { deviceType?: number | string };
+	};
+
+	if (typeof typedDevice.device_type === 'number') {
+		return typedDevice.device_type;
+	}
+
+	const rawType = typedDevice.raw?.deviceType;
+	if (typeof rawType === 'number') {
+		return rawType;
+	}
+
+	if (typeof rawType === 'string' && rawType.trim() !== '') {
+		const parsed = Number(rawType.trim());
+		if (!Number.isNaN(parsed)) {
+			return parsed;
+		}
+	}
+
+	return undefined;
+}
+
 export class CyncAppPlatform implements DynamicPlatformPlugin {
 	public readonly accessories: PlatformAccessory[] = [];
 	public configureAccessory(accessory: PlatformAccessory): void {
@@ -53,16 +158,58 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 
 	private cloudConfig: CyncCloudConfig | null = null;
 	private readonly deviceIdToAccessory = new Map<string, PlatformAccessory>();
+	private readonly deviceLastSeen = new Map<string, number>();
+	private readonly devicePollTimers = new Map<string, NodeJS.Timeout>();
+
+	private readonly offlineTimeoutMs = 5 * 60 * 1000; // 5 minutes
+	private readonly pollIntervalMs = 60_000; // 60 seconds
+
+	private markDeviceSeen(deviceId: string): void {
+		this.deviceLastSeen.set(deviceId, Date.now());
+	}
+
+	private isDeviceProbablyOffline(deviceId: string): boolean {
+		const last = this.deviceLastSeen.get(deviceId);
+		if (!last) {
+			// No data yet; treat as online until we know better
+			return false;
+		}
+		return Date.now() - last > this.offlineTimeoutMs;
+	}
+
+	private startPollingDevice(deviceId: string): void {
+		// For now this is just a placeholder hook. We keep a timer per device so
+		// you can later add a real poll (e.g. TCP “ping” or cloud get) here if you want.
+		const existing = this.devicePollTimers.get(deviceId);
+		if (existing) {
+			clearInterval(existing);
+		}
+
+		const timer = setInterval(() => {
+			// Optional future hook:
+			// - Call a "getDeviceState" or similar on tcpClient/client
+			// - On success, call this.markDeviceSeen(deviceId)
+			// - On failure, optionally log or mark offline
+		}, this.pollIntervalMs);
+
+		this.devicePollTimers.set(deviceId, timer);
+	}
+
 	private handleLanUpdate(update: unknown): void {
-		// We only care about parsed 0x83 frames that look like:
-		// { controllerId: number, on: boolean, level: number, deviceId?: string }
-		const payload = update as { deviceId?: string; on?: boolean };
+		// Parsed 0x83 frames from TcpClient.parseLanSwitchUpdate look like:
+		// { controllerId: number, deviceId?: string, on: boolean, level: number }
+		const payload = update as {
+			deviceId?: string;
+			on?: boolean;
+			level?: number;
+		};
 
-		if (!payload || typeof payload.deviceId !== 'string' || typeof payload.on !== 'boolean') {
+		if (!payload || typeof payload.deviceId !== 'string') {
 			return;
 		}
 
 		const accessory = this.deviceIdToAccessory.get(payload.deviceId);
+		this.markDeviceSeen(payload.deviceId);
 		if (!accessory) {
 			this.log.debug(
 				'Cync: LAN update for unknown deviceId=%s; no accessory mapping',
@@ -71,10 +218,16 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 			return;
 		}
 
-		const service = accessory.getService(this.api.hap.Service.Switch);
-		if (!service) {
+		const Service = this.api.hap.Service;
+		const Characteristic = this.api.hap.Characteristic;
+
+		const lightService = accessory.getService(Service.Lightbulb);
+		const switchService = accessory.getService(Service.Switch);
+		const primaryService = lightService || switchService;
+
+		if (!primaryService) {
 			this.log.debug(
-				'Cync: accessory %s has no Switch service for deviceId=%s',
+				'Cync: accessory %s has no Lightbulb or Switch service for deviceId=%s',
 				accessory.displayName,
 				payload.deviceId,
 			);
@@ -87,17 +240,44 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 			meshId: '',
 			deviceId: payload.deviceId,
 		};
-		ctx.cync.on = payload.on;
 
-		this.log.info(
-			'Cync: LAN update -> %s is now %s (deviceId=%s)',
-			accessory.displayName,
-			payload.on ? 'ON' : 'OFF',
-			payload.deviceId,
-		);
+		// ----- On/off -----
+		if (typeof payload.on === 'boolean') {
+			ctx.cync.on = payload.on;
+
+			this.log.info(
+				'Cync: LAN update -> %s is now %s (deviceId=%s)',
+				accessory.displayName,
+				payload.on ? 'ON' : 'OFF',
+				payload.deviceId,
+			);
+
+			primaryService.updateCharacteristic(Characteristic.On, payload.on);
+		}
 
-		// Push the new state into HomeKit
-		service.updateCharacteristic(this.api.hap.Characteristic.On, payload.on);
+		// ----- Brightness (LAN "level" 0–100) -----
+		if (typeof payload.level === 'number' && lightService) {
+			const brightness = Math.max(
+				0,
+				Math.min(100, Math.round(payload.level)),
+			);
+
+			ctx.cync.brightness = brightness;
+
+			this.log.debug(
+				'Cync: LAN update -> %s brightness=%d (deviceId=%s)',
+				accessory.displayName,
+				brightness,
+				payload.deviceId,
+			);
+
+			if (lightService.testCharacteristic(Characteristic.Brightness)) {
+				lightService.updateCharacteristic(
+					Characteristic.Brightness,
+					brightness,
+				);
+			}
+		}
 	}
 
 	private configureCyncSwitchAccessory(
@@ -110,6 +290,16 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 		const service =
 			accessory.getService(this.api.hap.Service.Switch) ||
 			accessory.addService(this.api.hap.Service.Switch, deviceName);
+		const existingLight = accessory.getService(this.api.hap.Service.Lightbulb);
+		if (existingLight) {
+			this.log.info(
+				'Cync: removing stale Lightbulb service from %s (deviceId=%s) before configuring as Switch',
+				deviceName,
+				deviceId,
+			);
+			accessory.removeService(existingLight);
+		}
+		this.applyAccessoryInformationFromCyncDevice(accessory, device, deviceName, deviceId);
 
 		// Ensure context is initialized
 		const ctx = accessory.context as CyncAccessoryContext;
@@ -122,10 +312,18 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 
 		// Remember mapping for LAN updates
 		this.deviceIdToAccessory.set(deviceId, accessory);
+		this.markDeviceSeen(deviceId);
+		this.startPollingDevice(deviceId);
 
 		service
 			.getCharacteristic(this.api.hap.Characteristic.On)
 			.onGet(() => {
+				if (this.isDeviceProbablyOffline(deviceId)) {
+					throw new this.api.hap.HapStatusError(
+						this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+					);
+				}
+
 				const currentOn = !!ctx.cync?.on;
 				this.log.info(
 					'Cync: On.get -> %s for %s (deviceId=%s)',
@@ -140,7 +338,7 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 
 				if (!cyncMeta?.deviceId) {
 					this.log.warn(
-						'Cync: On.set called for %s but no cync.deviceId in context',
+						'Cync: Light On.set called for %s but no cync.deviceId in context',
 						deviceName,
 					);
 					return;
@@ -149,7 +347,111 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 				const on = value === true || value === 1;
 
 				this.log.info(
-					'Cync: On.set -> %s for %s (deviceId=%s)',
+					'Cync: Light On.set -> %s for %s (deviceId=%s)',
+					String(on),
+					deviceName,
+					cyncMeta.deviceId,
+				);
+
+				cyncMeta.on = on;
+
+				if (!on) {
+					// Off is always a plain power packet
+					await this.tcpClient.setSwitchState(cyncMeta.deviceId, { on: false });
+					return;
+				}
+
+				// Turning on:
+				// - If we were in color mode with a known RGB + brightness, restore color.
+				// - Otherwise, just send a basic power-on packet.
+				if (cyncMeta.colorActive && cyncMeta.rgb && typeof cyncMeta.brightness === 'number') {
+					await this.tcpClient.setColor(cyncMeta.deviceId, cyncMeta.rgb, cyncMeta.brightness);
+				} else {
+					await this.tcpClient.setSwitchState(cyncMeta.deviceId, { on: true });
+				}
+			});
+	}
+
+	private configureCyncLightAccessory(
+		mesh: CyncDeviceMesh,
+		device: CyncDevice,
+		accessory: PlatformAccessory,
+		deviceName: string,
+		deviceId: string,
+	): void {
+		// If this accessory used to be a switch, remove that service
+		const existingSwitch = accessory.getService(this.api.hap.Service.Switch);
+		if (existingSwitch) {
+			this.log.info(
+				'Cync: removing stale Switch service from %s (deviceId=%s) before configuring as Lightbulb',
+				deviceName,
+				deviceId,
+			);
+			accessory.removeService(existingSwitch);
+		}
+
+		const service =
+			accessory.getService(this.api.hap.Service.Lightbulb) ||
+			accessory.addService(this.api.hap.Service.Lightbulb, deviceName);
+
+		// Optionally update accessory category so UIs treat it as a light
+		if (accessory.category !== this.api.hap.Categories.LIGHTBULB) {
+			accessory.category = this.api.hap.Categories.LIGHTBULB;
+		}
+
+		// NEW: populate Accessory Information from Cync metadata
+		this.applyAccessoryInformationFromCyncDevice(accessory, device, deviceName, deviceId);
+
+		// Ensure context is initialized
+		const ctx = accessory.context as CyncAccessoryContext;
+		ctx.cync = ctx.cync ?? {
+			meshId: mesh.id,
+			deviceId,
+			productId: device.product_id,
+			on: false,
+		};
+
+		// Remember mapping for LAN updates
+		this.deviceIdToAccessory.set(deviceId, accessory);
+		this.markDeviceSeen(deviceId);
+		this.startPollingDevice(deviceId);
+
+		const Characteristic = this.api.hap.Characteristic;
+
+		// ----- On/Off -----
+		service
+			.getCharacteristic(Characteristic.On)
+			.onGet(() => {
+				if (this.isDeviceProbablyOffline(deviceId)) {
+					throw new this.api.hap.HapStatusError(
+						this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+					);
+				}
+
+				const currentOn = !!ctx.cync?.on;
+				this.log.info(
+					'Cync: Light On.get -> %s for %s (deviceId=%s)',
+					String(currentOn),
+					deviceName,
+					deviceId,
+				);
+				return currentOn;
+			})
+			.onSet(async (value) => {
+				const cyncMeta = ctx.cync;
+
+				if (!cyncMeta?.deviceId) {
+					this.log.warn(
+						'Cync: Light On.set called for %s but no cync.deviceId in context',
+						deviceName,
+					);
+					return;
+				}
+
+				const on = value === true || value === 1;
+
+				this.log.info(
+					'Cync: Light On.set -> %s for %s (deviceId=%s)',
 					String(on),
 					deviceName,
 					cyncMeta.deviceId,
@@ -158,8 +460,346 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 				// Optimistic local cache; LAN update will confirm
 				cyncMeta.on = on;
 
-				await this.tcpClient.setSwitchState(cyncMeta.deviceId, { on });
+				try {
+					await this.tcpClient.setSwitchState(cyncMeta.deviceId, { on });
+					this.markDeviceSeen(cyncMeta.deviceId);
+				} catch (err) {
+					this.log.warn(
+						'Cync: Light On.set failed for %s (deviceId=%s): %s',
+						deviceName,
+						cyncMeta.deviceId,
+						(err as Error).message ?? String(err),
+					);
+
+					throw new this.api.hap.HapStatusError(
+						this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+					);
+				}
+			});
+		// ----- Brightness (dimming via LAN combo_control) -----
+		service
+			.getCharacteristic(Characteristic.Brightness)
+			.onGet(() => {
+				if (this.isDeviceProbablyOffline(deviceId)) {
+					throw new this.api.hap.HapStatusError(
+						this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+					);
+				}
+
+				const current = ctx.cync?.brightness;
+
+				// If we have a cached LAN level, use it; otherwise infer from On.
+				if (typeof current === 'number') {
+					return current;
+				}
+
+				const on = ctx.cync?.on ?? false;
+				return on ? 100 : 0;
+			})
+			.onSet(async (value) => {
+				const cyncMeta = ctx.cync;
+
+				if (!cyncMeta?.deviceId) {
+					this.log.warn(
+						'Cync: Light Brightness.set called for %s but no cync.deviceId in context',
+						deviceName,
+					);
+					return;
+				}
+
+				const brightness = Math.max(0, Math.min(100, Number(value)));
+
+				if (!Number.isFinite(brightness)) {
+					this.log.warn(
+						'Cync: Light Brightness.set received invalid value=%o for %s (deviceId=%s)',
+						value,
+						deviceName,
+						cyncMeta.deviceId,
+					);
+					return;
+				}
+
+				// Optimistic cache
+				cyncMeta.brightness = brightness;
+				cyncMeta.on = brightness > 0;
+
+				this.log.info(
+					'Cync: Light Brightness.set -> %d for %s (deviceId=%s)',
+					brightness,
+					deviceName,
+					cyncMeta.deviceId,
+				);
+
+				try {
+					// If we're in "color mode", keep the existing RGB and scale brightness via setColor();
+					// otherwise treat this as a white-brightness change.
+					if (cyncMeta.colorActive && cyncMeta.rgb) {
+						await this.tcpClient.setColor(
+							cyncMeta.deviceId,
+							cyncMeta.rgb,
+							brightness,
+						);
+					} else {
+						await this.tcpClient.setBrightness(cyncMeta.deviceId, brightness);
+					}
+
+					this.markDeviceSeen(cyncMeta.deviceId);
+				} catch (err) {
+					this.log.warn(
+						'Cync: Light Brightness.set failed for %s (deviceId=%s): %s',
+						deviceName,
+						cyncMeta.deviceId,
+						(err as Error).message ?? String(err),
+					);
+
+					throw new this.api.hap.HapStatusError(
+						this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+					);
+				}
 			});
+		// ----- Hue -----
+		service
+			.getCharacteristic(Characteristic.Hue)
+			.onGet(() => {
+				if (this.isDeviceProbablyOffline(deviceId)) {
+					throw new this.api.hap.HapStatusError(
+						this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+					);
+				}
+
+				const hue = ctx.cync?.hue;
+				if (typeof hue === 'number') {
+					return hue;
+				}
+				// Default to 0° (red) if we have no color history
+				return 0;
+			})
+			.onSet(async (value) => {
+				const cyncMeta = ctx.cync;
+
+				if (!cyncMeta?.deviceId) {
+					this.log.warn(
+						'Cync: Light Hue.set called for %s but no cync.deviceId in context',
+						deviceName,
+					);
+					return;
+				}
+
+				const hue = Math.max(0, Math.min(360, Number(value)));
+				if (!Number.isFinite(hue)) {
+					this.log.warn(
+						'Cync: Light Hue.set received invalid value=%o for %s (deviceId=%s)',
+						value,
+						deviceName,
+						cyncMeta.deviceId,
+					);
+					return;
+				}
+
+				// Use cached saturation/brightness if available, otherwise sane defaults
+				const saturation =
+					typeof cyncMeta.saturation === 'number' ? cyncMeta.saturation : 100;
+
+				const brightness =
+					typeof cyncMeta.brightness === 'number' ? cyncMeta.brightness : 100;
+
+				const rgb = hsvToRgb(hue, saturation, brightness);
+
+				// Optimistic cache
+				cyncMeta.hue = hue;
+				cyncMeta.saturation = saturation;
+				cyncMeta.rgb = rgb;
+				cyncMeta.colorActive = true;
+				cyncMeta.on = brightness > 0;
+				cyncMeta.brightness = brightness;
+
+				this.log.info(
+					'Cync: Light Hue.set -> %d for %s (deviceId=%s) -> rgb=(%d,%d,%d) brightness=%d',
+					hue,
+					deviceName,
+					cyncMeta.deviceId,
+					rgb.r,
+					rgb.g,
+					rgb.b,
+					brightness,
+				);
+
+				try {
+					await this.tcpClient.setColor(cyncMeta.deviceId, rgb, brightness);
+					this.markDeviceSeen(cyncMeta.deviceId);
+				} catch (err) {
+					this.log.warn(
+						'Cync: Light Hue.set failed for %s (deviceId=%s): %s',
+						deviceName,
+						cyncMeta.deviceId,
+						(err as Error).message ?? String(err),
+					);
+
+					throw new this.api.hap.HapStatusError(
+						this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+					);
+				}
+			});
+		// ----- Saturation -----
+		service
+			.getCharacteristic(Characteristic.Saturation)
+			.onGet(() => {
+				if (this.isDeviceProbablyOffline(deviceId)) {
+					throw new this.api.hap.HapStatusError(
+						this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+					);
+				}
+
+				const sat = ctx.cync?.saturation;
+				if (typeof sat === 'number') {
+					return sat;
+				}
+				return 100;
+			})
+			.onSet(async (value) => {
+				const cyncMeta = ctx.cync;
+
+				if (!cyncMeta?.deviceId) {
+					this.log.warn(
+						'Cync: Light Saturation.set called for %s but no cync.deviceId in context',
+						deviceName,
+					);
+					return;
+				}
+
+				const saturation = Math.max(0, Math.min(100, Number(value)));
+				if (!Number.isFinite(saturation)) {
+					this.log.warn(
+						'Cync: Light Saturation.set received invalid value=%o for %s (deviceId=%s)',
+						value,
+						deviceName,
+						cyncMeta.deviceId,
+					);
+					return;
+				}
+
+				const hue = typeof cyncMeta.hue === 'number' ? cyncMeta.hue : 0;
+
+				const brightness =
+					typeof cyncMeta.brightness === 'number' ? cyncMeta.brightness : 100;
+
+				const rgb = hsvToRgb(hue, saturation, brightness);
+
+				// Optimistic cache
+				cyncMeta.hue = hue;
+				cyncMeta.saturation = saturation;
+				cyncMeta.rgb = rgb;
+				cyncMeta.colorActive = true;
+				cyncMeta.on = brightness > 0;
+				cyncMeta.brightness = brightness;
+
+				this.log.info(
+					'Cync: Light Saturation.set -> %d for %s (deviceId=%s) -> rgb=(%d,%d,%d) brightness=%d',
+					saturation,
+					deviceName,
+					cyncMeta.deviceId,
+					rgb.r,
+					rgb.g,
+					rgb.b,
+					brightness,
+				);
+
+				try {
+					await this.tcpClient.setColor(cyncMeta.deviceId, rgb, brightness);
+					this.markDeviceSeen(cyncMeta.deviceId);
+				} catch (err) {
+					this.log.warn(
+						'Cync: Light Saturation.set failed for %s (deviceId=%s): %s',
+						deviceName,
+						cyncMeta.deviceId,
+						(err as Error).message ?? String(err),
+					);
+
+					throw new this.api.hap.HapStatusError(
+						this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+					);
+				}
+			});
+	}
+
+	private applyAccessoryInformationFromCyncDevice(
+		accessory: PlatformAccessory,
+		device: CyncDevice,
+		deviceName: string,
+		deviceId: string,
+	): void {
+		const infoService = accessory.getService(this.api.hap.Service.AccessoryInformation);
+		if (!infoService) {
+			return;
+		}
+
+		const Characteristic = this.api.hap.Characteristic;
+		const deviceWithRaw = device as CyncDeviceWithRaw;
+		const rawDevice = deviceWithRaw.raw ?? {};
+
+		// Name: keep in sync with how we present the accessory
+		const name = deviceName || accessory.displayName;
+		infoService.updateCharacteristic(Characteristic.Name, name);
+
+		// Manufacturer: fixed for all Cync devices
+		infoService.updateCharacteristic(Characteristic.Manufacturer, 'GE Lighting');
+
+		// Model: prefer catalog entry (Cync app-style model name), fall back to raw info
+		const resolvedType = resolveDeviceType(device);
+		const catalogEntry = typeof resolvedType === 'number'
+			? lookupDeviceModel(resolvedType)
+			: undefined;
+
+		let model: string;
+
+		if (catalogEntry) {
+			// Use the Cync app-style model name
+			model = catalogEntry.modelName;
+
+			// Persist for debugging / future use
+			const ctx = accessory.context as Record<string, unknown>;
+			ctx.deviceType = resolvedType;
+			ctx.modelName = catalogEntry.modelName;
+			if (catalogEntry.marketingName) {
+				ctx.marketingName = catalogEntry.marketingName;
+			}
+		} else {
+			// Fallback: use device displayName + type
+			const modelBase =
+				typeof rawDevice.displayName === 'string' && rawDevice.displayName.trim().length > 0
+					? rawDevice.displayName.trim()
+					: 'Cync Device';
+
+			const modelSuffix =
+				typeof resolvedType === 'number'
+					? ` (Type ${resolvedType})`
+					: '';
+
+			model = modelBase + modelSuffix;
+		}
+
+		infoService.updateCharacteristic(Characteristic.Model, model);
+
+
+		// Serial: prefer wifiMac, then mac, then deviceID, then the string deviceId
+		const serial =
+			(typeof rawDevice.wifiMac === 'string' && rawDevice.wifiMac.trim().length > 0)
+				? rawDevice.wifiMac.trim()
+				: (typeof rawDevice.mac === 'string' && rawDevice.mac.trim().length > 0)
+					? rawDevice.mac.trim()
+					: (rawDevice.deviceID !== undefined
+						? String(rawDevice.deviceID)
+						: deviceId);
+
+		infoService.updateCharacteristic(Characteristic.SerialNumber, serial);
+
+		// Firmware revision, if present
+		if (typeof rawDevice.firmwareVersion === 'string' && rawDevice.firmwareVersion.trim().length > 0) {
+			infoService.updateCharacteristic(
+				Characteristic.FirmwareRevision,
+				rawDevice.firmwareVersion.trim(),
+			);
+		}
 	}
 
 	constructor(log: Logger, config: PlatformConfig, api: API) {
@@ -171,7 +811,6 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 		const raw = this.config as Record<string, unknown>;
 
 		// Canonical config keys: username, password, twoFactor
-		// Accept legacy "email" as a fallback source for username, but do not write it back.
 		const username =
 			typeof raw.username === 'string'
 				? raw.username
@@ -291,10 +930,6 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 		}
 	}
 
-	/**
-	 * Discover devices from the Cync cloud config and register them as
-	 * Homebridge accessories.
-	 */
 	private discoverDevices(cloudConfig: CyncCloudConfig): void {
 		if (!cloudConfig.meshes?.length) {
 			this.log.warn('Cync: no meshes returned from cloud; nothing to discover.');
@@ -346,9 +981,27 @@ export class CyncAppPlatform implements DynamicPlatformPlugin {
 					this.accessories.push(accessory);
 				}
 
-				this.configureCyncSwitchAccessory(mesh, device, accessory, deviceName, deviceId);
+				const deviceType = resolveDeviceType(device);
+				const isDownlight = deviceType === 46;
+
+				if (isDownlight) {
+					this.log.info(
+						'Cync: configuring %s as Lightbulb (deviceType=%s, deviceId=%s)',
+						deviceName,
+						String(deviceType),
+						deviceId,
+					);
+					this.configureCyncLightAccessory(mesh, device, accessory, deviceName, deviceId);
+				} else {
+					this.log.info(
+						'Cync: configuring %s as Switch (deviceType=%s, deviceId=%s)',
+						deviceName,
+						deviceType ?? 'unknown',
+						deviceId,
+					);
+					this.configureCyncSwitchAccessory(mesh, device, accessory, deviceName, deviceId);
+				}
 			}
 		}
 	}
-
 }