homebridge-cync-app 0.1.3 → 0.1.6

package/src/cync/tcp-client.ts

@@ -14,13 +14,6 @@ const defaultLogger: CyncLogger = {
 export type DeviceUpdateCallback = (payload: unknown) => void;
 export type RawFrameListener = (frame: Buffer) => void;
 
-interface QueuedPowerPacket {
-	deviceId: string;
-	on: boolean;
-	seq: number;
-	packet: Buffer;
-}
-
 export class TcpClient {
 	public registerSwitchMapping(controllerId: number, deviceId: string): void {
 		if (!Number.isFinite(controllerId)) {
@@ -28,6 +21,7 @@ export class TcpClient {
 		}
 		this.controllerToDevice.set(controllerId, deviceId);
 	}
+	private commandChain: Promise<void> = Promise.resolve();
 	private homeDevices: Record<string, string[]> = {};
 	private switchIdToHomeId = new Map<number, string>();
 	private readonly log: CyncLogger;
@@ -44,9 +38,33 @@ export class TcpClient {
 	private heartbeatTimer: NodeJS.Timeout | null = null;
 	private rawFrameListeners: RawFrameListener[] = [];
 	private controllerToDevice = new Map<number, string>();
-	private connecting: Promise<boolean> | null = null;
-	private readonly sendQueue: QueuedPowerPacket[] = [];
-	private sending = false;
+
+	private enqueueCommand<T>(fn: () => Promise<T>): Promise<T> {
+		let resolveWrapper: (value: T | PromiseLike<T>) => void;
+		let rejectWrapper: (reason?: unknown) => void;
+
+		const p = new Promise<T>((resolve, reject) => {
+			resolveWrapper = resolve;
+			rejectWrapper = reject;
+		});
+
+		// Chain onto the existing promise
+		this.commandChain = this.commandChain
+			.then(async () => {
+				try {
+					const result = await fn();
+					resolveWrapper(result);
+				} catch (err) {
+					rejectWrapper(err);
+				}
+			})
+			.catch(() => {
+				// Swallow errors in the chain so a failed command
+				// doesn't permanently block the queue.
+			});
+
+		return p;
+	}
 	private parseSwitchStateFrame(frame: Buffer): { controllerId: number; on: boolean; level: number } | null {
 		if (frame.length < 16) {
 			return null;
@@ -156,7 +174,6 @@ export class TcpClient {
 		await this.ensureConnected();
 	}
 
-
 	public applyLanTopology(topology: {
 		homeDevices: Record<string, string[]>;
 		switchIdToHomeId: Record<number, string>;
@@ -178,11 +195,6 @@ export class TcpClient {
 		);
 	}
 
-	/**
-	 * Ensure we have an open, logged-in socket.
-	 * If multiple callers invoke this concurrently, they will share a single
-	 * connection attempt via `this.connecting`.
-	 */
 	private async ensureConnected(): Promise<boolean> {
 		if (this.socket && !this.socket.destroyed) {
 			return true;
@@ -195,34 +207,10 @@ export class TcpClient {
 			return false;
 		}
 
-		if (!this.connecting) {
-			this.connecting = (async () => {
-				await this.establishSocket();
-				const ok = !!(this.socket && !this.socket.destroyed);
-				if (!ok) {
-					this.log.warn(
-						'[Cync TCP] establishSocket() completed but socket is not usable.',
-					);
-				}
-				this.connecting = null;
-				return ok;
-			})().catch((err) => {
-				this.log.error(
-					'[Cync TCP] ensureConnected() connect attempt failed: %s',
-					String(err),
-				);
-				this.connecting = null;
-				return false;
-			});
-		}
-
-		return this.connecting;
+		await this.establishSocket();
+		return !!(this.socket && !this.socket.destroyed);
 	}
 
-	/**
-	 * Open a new socket to cm.gelighting.com and send the loginCode,
-	 * mirroring the HA integration’s behavior.
-	 */
 	private async establishSocket(): Promise<void> {
 		const host = 'cm.gelighting.com';
 		const portTLS = 23779;
@@ -325,45 +313,6 @@ export class TcpClient {
 		return this.seq;
 	}
 
-	private async flushQueue(): Promise<void> {
-		if (this.sending) {
-			return;
-		}
-		this.sending = true;
-
-		try {
-			while (this.sendQueue.length > 0) {
-				const item = this.sendQueue.shift();
-				if (!item) {
-					break;
-				}
-
-				const connected = await this.ensureConnected();
-				if (!connected || !this.socket || this.socket.destroyed) {
-					this.log.warn(
-						'[Cync TCP] Socket not available while flushing queue; dropping remaining %d packets.',
-						this.sendQueue.length + 1,
-					);
-					this.sendQueue.length = 0;
-					break;
-				}
-
-				this.socket.write(item.packet);
-				this.log.info(
-					'[Cync TCP] Sent power packet: device=%s on=%s seq=%d',
-					item.deviceId,
-					String(item.on),
-					item.seq,
-				);
-
-				// Small delay so we don't hammer the bridge/device with a burst
-				await new Promise((resolve) => setTimeout(resolve, 50));
-			}
-		} finally {
-			this.sending = false;
-		}
-	}
-
 	private buildPowerPacket(
 		controllerId: number,
 		meshId: number,
@@ -404,6 +353,69 @@ export class TcpClient {
 		]);
 	}
 
+	private buildComboPacket(
+		controllerId: number,
+		meshId: number,
+		on: boolean,
+		brightnessPct: number,
+		colorTone: number,
+		rgb: { r: number; g: number; b: number },
+		seq: number,
+	): Buffer {
+		const header = Buffer.from('7300000022', 'hex');
+
+		const switchBytes = Buffer.alloc(4);
+		switchBytes.writeUInt32BE(controllerId, 0);
+
+		const seqBytes = Buffer.alloc(2);
+		seqBytes.writeUInt16BE(seq, 0);
+
+		const middle = Buffer.from('007e00000000f8f010000000000000', 'hex');
+
+		const meshBytes = Buffer.alloc(2);
+		meshBytes.writeUInt16LE(meshId, 0);
+
+		const tailPrefix = Buffer.from('f00000', 'hex');
+
+		const onByte = on ? 1 : 0;
+		const brightnessByte = Math.max(0, Math.min(100, Math.round(brightnessPct)));
+		const colorToneByte = Math.max(0, Math.min(255, Math.round(colorTone)));
+
+		const r = Math.max(0, Math.min(255, Math.round(rgb.r)));
+		const g = Math.max(0, Math.min(255, Math.round(rgb.g)));
+		const b = Math.max(0, Math.min(255, Math.round(rgb.b)));
+
+		const rgbBytes = Buffer.from([r, g, b]);
+
+		const checksumSeed =
+				496 +
+				meshBytes[0] +
+				meshBytes[1] +
+				onByte +
+				brightnessByte +
+				colorToneByte +
+				r +
+				g +
+				b;
+
+		const checksum = Buffer.from([checksumSeed & 0xff]);
+		const end = Buffer.from('7e', 'hex');
+
+		return Buffer.concat([
+			header,
+			switchBytes,
+			seqBytes,
+			middle,
+			meshBytes,
+			tailPrefix,
+			Buffer.from([onByte]),
+			Buffer.from([brightnessByte]),
+			Buffer.from([colorToneByte]),
+			rgbBytes,
+			checksum,
+			end,
+		]);
+	}
 	public async disconnect(): Promise<void> {
 		this.log.info('[Cync TCP] disconnect() called.');
 		if (this.heartbeatTimer) {
@@ -414,9 +426,6 @@ export class TcpClient {
 			this.socket.destroy();
 			this.socket = null;
 		}
-		this.sendQueue.length = 0;
-		this.sending = false;
-		this.connecting = null;
 	}
 
 	public onDeviceUpdate(cb: DeviceUpdateCallback): void {
@@ -440,53 +449,203 @@ export class TcpClient {
 		this.rawFrameListeners.push(listener);
 	}
 
-	/**
-	 * High-level API to change switch state.
-	 * Now enqueues a power packet so multiple HomeKit scene writes are
-	 * serialized over a single TCP session.
-	 */
 	public async setSwitchState(
 		deviceId: string,
 		params: { on: boolean },
 	): Promise<void> {
-		if (!this.config) {
-			this.log.warn('[Cync TCP] No config available.');
-			return;
-		}
+		return this.enqueueCommand(async () => {
+			if (!this.config) {
+				this.log.warn('[Cync TCP] No config available.');
+				return;
+			}
 
-		const device = this.findDevice(deviceId);
-		if (!device) {
-			this.log.warn('[Cync TCP] Unknown deviceId=%s', deviceId);
-			return;
-		}
+			const connected = await this.ensureConnected();
+			if (!connected || !this.socket || this.socket.destroyed) {
+				this.log.warn(
+					'[Cync TCP] Cannot send, socket not ready even after reconnect attempt.',
+				);
+				return;
+			}
 
-		const controllerId = Number((device as Record<string, unknown>).switch_controller);
-		const meshIndex = Number((device as Record<string, unknown>).mesh_id);
+			const device = this.findDevice(deviceId);
+			if (!device) {
+				this.log.warn('[Cync TCP] Unknown deviceId=%s', deviceId);
+				return;
+			}
 
-		if (!Number.isFinite(controllerId) || !Number.isFinite(meshIndex)) {
-			this.log.warn(
-				'[Cync TCP] Device %s is missing LAN fields (switch_controller=%o mesh_id=%o)',
+			const record = device as Record<string, unknown>;
+			this.log.debug(
+				'[Cync TCP] setSwitchState: deviceId=%s device_type=%o switch_controller=%o mesh_id=%o home_id=%o',
 				deviceId,
-				(device as Record<string, unknown>).switch_controller,
-				(device as Record<string, unknown>).mesh_id,
+				record.device_type,
+				record.switch_controller,
+				record.mesh_id,
+				record.home_id,
 			);
-			return;
-		}
+			const controllerId = Number(record.switch_controller);
+			const meshIndex = Number(record.mesh_id);
+
+			if (!Number.isFinite(controllerId) || !Number.isFinite(meshIndex)) {
+				this.log.warn(
+					'[Cync TCP] Device %s is missing LAN fields (switch_controller=%o mesh_id=%o)',
+					deviceId,
+					record.switch_controller,
+					record.mesh_id,
+				);
+				return;
+			}
 
-		const seq = this.nextSeq();
-		const packet = this.buildPowerPacket(controllerId, meshIndex, params.on, seq);
+			const seq = this.nextSeq();
+			const packet = this.buildPowerPacket(controllerId, meshIndex, params.on, seq);
 
-		this.sendQueue.push({
-			deviceId,
-			on: params.on,
-			seq,
-			packet,
+			// At this point socket has been validated above
+			this.socket.write(packet);
+			this.log.info(
+				'[Cync TCP] Sent power packet: device=%s on=%s seq=%d',
+				deviceId,
+				String(params.on),
+				seq,
+			);
 		});
+	}
 
-		// Async fire-and-forget; actual sends are serialized in flushQueue()
-		void this.flushQueue();
+	public async setBrightness(deviceId: string, brightnessPct: number): Promise<void> {
+		return this.enqueueCommand(async () => {
+			if (!this.config) {
+				this.log.warn('[Cync TCP] setBrightness: no config available.');
+				return;
+			}
+
+			const connected = await this.ensureConnected();
+			if (!connected || !this.socket || this.socket.destroyed) {
+				this.log.warn(
+					'[Cync TCP] setBrightness: socket not ready even after reconnect attempt.',
+				);
+				return;
+			}
+
+			const device = this.findDevice(deviceId);
+			if (!device) {
+				this.log.warn('[Cync TCP] setBrightness: unknown deviceId=%s', deviceId);
+				return;
+			}
+
+			const record = device as Record<string, unknown>;
+			const controllerId = Number(record.switch_controller);
+			const meshIndex = Number(record.mesh_id);
+
+			if (!Number.isFinite(controllerId) || !Number.isFinite(meshIndex)) {
+				this.log.warn(
+					'[Cync TCP] setBrightness: device %s missing LAN fields (switch_controller=%o mesh_id=%o)',
+					deviceId,
+					record.switch_controller,
+					record.mesh_id,
+				);
+				return;
+			}
+
+			const clamped = Math.max(0, Math.min(100, Number(brightnessPct)));
+			const on = clamped > 0;
+
+			const seq = this.nextSeq();
+
+			// White-only combo control for now; color support can layer on this later.
+			const packet = this.buildComboPacket(
+				controllerId,
+				meshIndex,
+				on,
+				clamped,
+				255, // color_tone=255 ("white" in HA integration)
+				{ r: 255, g: 255, b: 255 },
+				seq,
+			);
+
+			this.socket.write(packet);
+			this.log.info(
+				'[Cync TCP] Sent combo (brightness) packet: device=%s on=%s brightness=%d seq=%d',
+				deviceId,
+				String(on),
+				clamped,
+				seq,
+			);
+		});
 	}
 
+	public async setColor(
+		deviceId: string,
+		rgb: { r: number; g: number; b: number },
+		brightnessPct?: number,
+	): Promise<void> {
+		return this.enqueueCommand(async () => {
+			if (!this.config) {
+				this.log.warn('[Cync TCP] setColor: no config available.');
+				return;
+			}
+
+			const connected = await this.ensureConnected();
+			if (!connected || !this.socket || this.socket.destroyed) {
+				this.log.warn(
+					'[Cync TCP] setColor: socket not ready even after reconnect attempt.',
+				);
+				return;
+			}
+
+			const device = this.findDevice(deviceId);
+			if (!device) {
+				this.log.warn('[Cync TCP] setColor: unknown deviceId=%s', deviceId);
+				return;
+			}
+
+			const record = device as Record<string, unknown>;
+			const controllerId = Number(record.switch_controller);
+			const meshIndex = Number(record.mesh_id);
+
+			if (!Number.isFinite(controllerId) || !Number.isFinite(meshIndex)) {
+				this.log.warn(
+					'[Cync TCP] setColor: device %s missing LAN fields (switch_controller=%o mesh_id=%o)',
+					deviceId,
+					record.switch_controller,
+					record.mesh_id,
+				);
+				return;
+			}
+
+			const clampedBrightness = Math.max(
+				0,
+				Math.min(100, Math.round(brightnessPct ?? 100)),
+			);
+			const on = clampedBrightness > 0;
+
+			const r = Math.max(0, Math.min(255, Math.round(rgb.r)));
+			const g = Math.max(0, Math.min(255, Math.round(rgb.g)));
+			const b = Math.max(0, Math.min(255, Math.round(rgb.b)));
+
+			const seq = this.nextSeq();
+
+			// colorTone=254 => "color" mode, per HA's combo_control for RGB
+			const packet = this.buildComboPacket(
+				controllerId,
+				meshIndex,
+				on,
+				clampedBrightness,
+				254,
+				{ r, g, b },
+				seq,
+			);
+
+			this.socket.write(packet);
+			this.log.info(
+				'[Cync TCP] Sent color combo packet: device=%s on=%s brightness=%d rgb=(%d,%d,%d) seq=%d',
+				deviceId,
+				String(on),
+				clampedBrightness,
+				r,
+				g,
+				b,
+				seq,
+			);
+		});
+	}
 	private findDevice(deviceId: string) {
 		for (const mesh of this.config?.meshes ?? []) {
 			for (const dev of mesh.devices ?? []) {
@@ -515,9 +674,7 @@ export class TcpClient {
 
 		socket.on('close', () => {
 			this.log.warn('[Cync TCP] Socket closed.');
-			if (this.socket === socket) {
-				this.socket = null;
-			}
+			this.socket = null;
 		});
 
 		socket.on('error', (err) => {
@@ -596,13 +753,14 @@ export class TcpClient {
 		// Default payload is the raw frame
 		let payload: unknown = frame;
 
-		if (type === 0x83) {
-			// Preferred path: HA-style per-device parsing using homeDevices + switchIdToHomeId
+		// 0x73 / 0x83 carry per-device state updates on the LAN.
+		// Mirror the HA integration: try the topology-based parser first.
+		if (type === 0x73 || type === 0x83) {
 			const lanParsed = this.parseLanSwitchUpdate(frame);
 			if (lanParsed) {
 				payload = lanParsed;
-			} else {
-				// Fallback to legacy controller-level parsing
+			} else if (type === 0x83) {
+				// Fallback to legacy controller-level parsing only for 0x83
 				const parsed = this.parseSwitchStateFrame(frame);
 				if (parsed) {
 					const deviceId = this.controllerToDevice.get(parsed.controllerId);