homebridge-cync-app 0.1.7 → 0.1.9

package/src/cync/config-client.ts

@@ -28,6 +28,38 @@ type CyncErrorBody = {
 	[key: string]: unknown;
 };
 
+type CyncApiError = {
+	status: number;
+	statusText: string;
+	body: unknown;
+	code?: number;
+	msg?: string;
+};
+
+function extractCyncError(body: unknown): { code?: number; msg?: string } {
+	if (!body || typeof body !== 'object') {
+		return {};
+	}
+
+	const obj = body as Record<string, unknown>;
+	const err = obj.error;
+
+	if (!err || typeof err !== 'object') {
+		return {};
+	}
+
+	const e = err as Record<string, unknown>;
+	const code = typeof e.code === 'number' ? e.code : undefined;
+	const msg = typeof e.msg === 'string' ? e.msg : undefined;
+
+	return { code, msg };
+}
+
+function isDevicePropertyNotExists(status: number, body: unknown): boolean {
+	const { code, msg } = extractCyncError(body);
+	return status === 404 && (code === 4041009 || msg === 'device property not exists');
+}
+
 export interface CyncLoginSession {
 	accessToken: string;
 	userId: string;
@@ -223,6 +255,119 @@ export class ConfigClient {
 			raw: json,
 		};
 	}
+
+	/**
+	 * Password-only login for background refresh.
+	 *
+	 * This uses the /user_auth endpoint (no two_factor) and is intended
+	 * for automatic re-auth when the access token has expired, after an
+	 * initial 2FA bootstrap has already been completed.
+	 */
+	public async loginWithPassword(
+		email: string,
+		password: string,
+	): Promise<CyncLoginSession & { refreshToken?: string; expiresAt?: number }> {
+		const url = `${CYNC_API_BASE}user_auth`;
+		this.log.debug('Logging into Cync with password-only auth for %s…', email);
+
+		const body = {
+			corp_id: CORP_ID,
+			email,
+			password,
+			resource: ConfigClient.randomLoginResource(),
+		};
+
+		const res = (await fetch(url, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(body),
+		})) as HttpResponse;
+
+		const json: unknown = await res.json().catch(async () => {
+			const text = await res.text().catch(() => '');
+			throw new Error(`Cync password login returned non-JSON payload: ${text}`);
+		});
+
+		if (!res.ok) {
+			this.log.error(
+				'Cync password login failed: HTTP %d %s %o',
+				res.status,
+				res.statusText,
+				json,
+			);
+			const errBody = json as CyncErrorBody;
+			throw new Error(
+				errBody.error?.msg ??
+				`Cync password login failed with status ${res.status} ${res.statusText}`,
+			);
+		}
+
+		const obj = json as Record<string, unknown>;
+		this.log.debug('Cync password login response: keys=%o', Object.keys(obj));
+
+		const accessTokenRaw = obj.access_token ?? obj.accessToken;
+		const userIdRaw = obj.user_id ?? obj.userId;
+		const authorizeRaw = obj.authorize;
+		const refreshTokenRaw = obj.refresh_token ?? obj.refreshToken;
+		const expiresAtRaw = obj.expires_at ?? obj.expiresAt;
+
+		const accessToken =
+			typeof accessTokenRaw === 'string' && accessTokenRaw.length > 0
+				? accessTokenRaw
+				: undefined;
+
+		const userId =
+			userIdRaw !== undefined && userIdRaw !== null
+				? String(userIdRaw)
+				: undefined;
+
+		const authorize =
+			typeof authorizeRaw === 'string' && authorizeRaw.length > 0
+				? authorizeRaw
+				: undefined;
+
+		if (!accessToken || !userId) {
+			this.log.error(
+				'Cync password login missing access_token or user_id: %o',
+				json,
+			);
+			throw new Error(
+				'Cync password login response missing access_token or user_id',
+			);
+		}
+
+		let refreshToken: string | undefined;
+		if (typeof refreshTokenRaw === 'string' && refreshTokenRaw.length > 0) {
+			refreshToken = refreshTokenRaw;
+		}
+
+		let expiresAt: number | undefined;
+		if (typeof expiresAtRaw === 'number') {
+			expiresAt = expiresAtRaw;
+		}
+
+		this.accessToken = accessToken;
+		this.userId = userId;
+		this.authorize = authorize ?? null;
+
+		this.log.info('Cync password login successful; userId=%s', userId);
+
+		return {
+			accessToken,
+			userId,
+			authorize,
+			raw: {
+				...obj,
+				refreshToken,
+				expiresAt,
+			},
+			refreshToken,
+			expiresAt,
+		};
+	}
+
 	/**
 	 * Refresh the access token using a stored refresh token.
 	 *
@@ -412,19 +557,37 @@ export class ConfigClient {
 		});
 
 		if (!res.ok) {
-			this.log.error(
-				'Cync properties call failed: HTTP %d %s %o',
-				res.status,
-				res.statusText,
-				json,
-			);
-			const errBody = json as CyncErrorBody;
-			const msg =
-				errBody.error?.msg ?? `Cync properties failed with ${res.status}`;
-			throw new Error(msg);
+			const { code, msg } = extractCyncError(json);
+			const outMsg = msg ?? `Cync properties failed with ${res.status}`;
+
+			if (isDevicePropertyNotExists(res.status, json)) {
+				this.log.debug(
+					'Cync properties call failed (expected): HTTP %d %s code=%s msg=%s',
+					res.status,
+					res.statusText,
+					code !== undefined ? String(code) : 'unknown',
+					outMsg,
+				);
+			} else {
+				this.log.error(
+					'Cync properties call failed: HTTP %d %s %o',
+					res.status,
+					res.statusText,
+					json,
+				);
+			}
+
+			const e: CyncApiError = {
+				status: res.status,
+				statusText: res.statusText,
+				body: json,
+				code,
+				msg: outMsg,
+			};
+
+			throw e;
 		}
 
-		// We keep this as a loose record; callers can shape it as needed.
 		return json as Record<string, unknown>;
 	}
 
@@ -446,7 +609,7 @@ export class ConfigClient {
 			throw new Error('Cync session not initialised. Call loginWithTwoFactor() first.');
 		}
 	}
-	// ### 🧩 LAN Login Blob Builder: Generates the auth_code payload used by Cync LAN TCP
+	// LAN Login Blob Builder: Generates the auth_code payload used by Cync LAN TCP
 	public static buildLanLoginCode(userId: string, authorize: string): Uint8Array {
 		const authBytes = Buffer.from(authorize, 'ascii');
 		const lengthByte = 10 + authBytes.length;

package/src/cync/cync-accessory-helpers.ts

@@ -0,0 +1,233 @@
+// src/cync/cync-accessory-helpers.ts
+import type {
+	API,
+	Logger,
+	PlatformAccessory,
+} from 'homebridge';
+
+import type { CyncDevice } from './config-client.js';
+import type { TcpClient } from './tcp-client.js';
+import { lookupDeviceModel } from './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;
+  [key: string]: unknown;
+};
+
+// CyncDevice as seen by the platform, possibly enriched with a `raw` block
+type CyncDeviceWithRaw = CyncDevice & {
+  raw?: CyncDeviceRaw;
+};
+
+// Context stored on the accessory
+export interface CyncAccessoryContext {
+  cync?: {
+    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;
+}
+
+// Minimal runtime “env” that accessory modules need from the platform
+export interface CyncAccessoryEnv {
+  log: Logger;
+  api: API;
+  tcpClient: TcpClient;
+
+  isDeviceProbablyOffline(deviceId: string): boolean;
+  markDeviceSeen(deviceId: string): void;
+  startPollingDevice(deviceId: string): void;
+  registerAccessoryForDevice(deviceId: string, accessory: PlatformAccessory): void;
+}
+
+/**
+ * HSV (HomeKit style) → RGB helper used by color lights.
+ */
+export 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),
+	};
+}
+
+/**
+ * Resolve the numeric device type from cloud + raw device shape.
+ */
+export 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;
+}
+
+/**
+ * Populate the standard Accessory Information service with Cync metadata.
+ */
+export function applyAccessoryInformationFromCyncDevice(
+	api: API,
+	accessory: PlatformAccessory,
+	device: CyncDevice,
+	deviceName: string,
+	deviceId: string,
+): void {
+	const infoService = accessory.getService(api.hap.Service.AccessoryInformation);
+	if (!infoService) {
+		return;
+	}
+
+	const Characteristic = 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 / Software revision
+	if (typeof rawDevice.firmwareVersion === 'string' && rawDevice.firmwareVersion.trim().length > 0) {
+		const rev = rawDevice.firmwareVersion.trim();
+
+		infoService.updateCharacteristic(Characteristic.FirmwareRevision, rev);
+		infoService.updateCharacteristic(Characteristic.SoftwareRevision, rev);
+	}
+}