homebridge-cync-app 0.1.3 → 0.1.5

package/homebridge-ui/server.js

@@ -1,97 +1,62 @@
 // homebridge-ui/server.js
 import { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils';
-import fetch from 'node-fetch';
+import { ConfigClient } from '../dist/cync/config-client.js';
+import { CyncTokenStore } from '../dist/cync/token-store.js';
 
-class PluginUiServer extends HomebridgePluginUiServer {
+class CyncUiServer extends HomebridgePluginUiServer {
 	constructor() {
 		super();
 
-		this.onRequest('/requestCode', this.handleRequestCode.bind(this));
-		this.onRequest('/login', this.handleLogin.bind(this));
+		this.configClient = new ConfigClient({
+			debug: (...a) => console.debug('[cync-ui-config]', ...a),
+			info:  (...a) => console.info('[cync-ui-config]', ...a),
+			warn:  (...a) => console.warn('[cync-ui-config]', ...a),
+			error: (...a) => console.error('[cync-ui-config]', ...a),
+		});
+
+		this.tokenStore = new CyncTokenStore(this.homebridgeStoragePath);
+
+		this.onRequest('/request-otp', this.handleRequestOtp.bind(this));
+		this.onRequest('/sign-out', this.handleSignOut.bind(this));
+		this.onRequest('/status', this.handleStatus.bind(this));
 
-		// Tell Homebridge UI that we’re ready
 		this.ready();
 	}
 
-	// Request a 2FA code via email
-	async handleRequestCode(payload) {
-		const email = (payload?.emailAddress || '').trim();
+	async handleRequestOtp(payload) {
+		const email = typeof payload?.email === 'string' ? payload.email.trim() : '';
 		if (!email) {
-			throw new Error('Email address is required to request a 2FA code.');
+			return { ok: false, error: 'Missing email' };
 		}
 
-		const requestBody = {
-			corp_id: '1007d2ad150c4000',
-			email,
-			local_lang: 'en-us',
-		};
-
-		await fetch(
-			'https://api.gelighting.com/v2/two_factor/email/verifycode',
-			{
-				method: 'POST',
-				body: JSON.stringify(requestBody),
-				headers: { 'Content-Type': 'application/json' },
-			},
-		);
+		await this.configClient.sendTwoFactorCode(email);
+		return { ok: true };
 	}
 
-	// Validate email + password + 2FA against Cync and return platform config
-	async handleLogin(payload) {
-		const email = (payload?.emailAddress || '').trim();
-		const password = (payload?.password || '').trim();
-		const mfaCode = (payload?.mfaCode || '').trim();
-
-		if (!email || !password || !mfaCode) {
-			return {
-				error: 'Email, password, and 2FA code are required.',
-			};
-		}
-
-		const requestBody = {
-			corp_id: '1007d2ad150c4000',
-			email,
-			password,
-			two_factor: mfaCode,
-			resource: 'abcdefghijk',
-		};
+	// Delete token file
+	async handleSignOut() {
+		await this.tokenStore.clear();
+		return { ok: true };
+	}
 
+	// Report whether a token exists
+	async handleStatus() {
 		try {
-			const response = await fetch(
-				'https://api.gelighting.com/v2/user_auth/two_factor',
-				{
-					method: 'POST',
-					body: JSON.stringify(requestBody),
-					headers: { 'Content-Type': 'application/json' },
-				},
-			);
-
-			const data = await response.json();
-			if (data && data.error) {
-				return {
-					error:
-						'Login failed. Please check your password and 2FA code.',
-				};
+			const token = await this.tokenStore.load();
+			if (!token) {
+				return { ok: true, hasToken: false };
 			}
-		} catch (err) {
-			console.error('[cync-ui] Login request failed:', err);
 			return {
-				error:
-					'Login failed due to a network or server error. Please try again.',
+				ok: true,
+				hasToken: true,
+				userId: token.userId,
+				expiresAt: token.expiresAt ?? null,
 			};
+		} catch {
+			// On error, just say "no token"
+			return { ok: true, hasToken: false };
 		}
-
-		// At this point, Cync accepted the credentials.
-		// Return the platform config that your platform.ts expects.
-		return {
-			platform: 'CyncAppPlatform',
-			name: 'Cync App',
-			username: email,
-			password,
-			twoFactor: mfaCode,
-		};
 	}
 }
 
-// Start the instance
-(() => new PluginUiServer())();
+(() => new CyncUiServer())();

package/package.json

@@ -2,7 +2,7 @@
 	"name": "homebridge-cync-app",
 	"displayName": "Homebridge Cync App",
 	"type": "module",
-	"version": "0.1.3",
+	"version": "0.1.5",
 	"private": false,
 	"description": "Homebridge plugin that integrates your GE Cync account (via the Cync app/API) and exposes all supported devices: plugs, lights, switches, etc",
 	"author": "Dustin Newell",
@@ -19,17 +19,12 @@
 		"homebridge-plugin",
 		"homebridge",
 		"cync",
-		"ge",
 		"ge cync",
-		"ge-lighting",
 		"smart plug",
 		"smart lights",
 		"C by GE"
 	],
 	"main": "dist/index.js",
-	"publishConfig": {
-		"access": "public"
-	},
 	"homebridge": {
 		"pluginType": "platform",
 		"platform": "CyncAppPlatform"
@@ -45,9 +40,8 @@
 		"watch": "npm run build && npm link && nodemon"
 	},
 	"dependencies": {
-		"homebridge-lib": "^7.1.12",
-		"node-fetch": "^3.3.2",
-		"@homebridge/plugin-ui-utils": "^1.0.0"
+		"@homebridge/plugin-ui-utils": "^2.1.2",
+		"homebridge-lib": "^7.1.12"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.39.1",

package/src/cync/config-client.ts

@@ -8,6 +8,7 @@
 const CYNC_API_BASE = 'https://api.gelighting.com/v2/';
 const CORP_ID = '1007d2ad150c4000';
 
+// Minimal fetch/response typing for Node 18+, without depending on DOM lib types.
 type FetchLike = (input: unknown, init?: unknown) => Promise<unknown>;
 
 declare const fetch: FetchLike;
@@ -64,7 +65,10 @@ export interface CyncCloudConfig {
 	meshes: CyncDeviceMesh[];
 }
 
-
+/**
+ * Very small logger interface so we can accept either the Homebridge log
+ * object or console.* functions in tests.
+ */
 export interface CyncLogger {
 	debug(message: string, ...args: unknown[]): void;
 	info(message: string, ...args: unknown[]): void;
@@ -147,6 +151,7 @@ export class ConfigClient {
 			email,
 			password,
 			two_factor: otpCode,
+			// Matches the reference implementations: random 16-char string.
 			resource: ConfigClient.randomLoginResource(),
 		};
 

package/src/cync/cync-client.ts

@@ -42,7 +42,12 @@ export class CyncClient {
 	private switchIdToHomeId: Record<number, string> = {};
 
 	// Credentials from config.json, used to drive 2FA bootstrap.
-	private readonly loginConfig: { email: string; password: string; twoFactor?: string };
+	//
+	// Canonical keys (must match platform + config):
+	//   - username: login identifier (email address used in Cync app)
+	//   - password: account password
+	//   - twoFactor: 6-digit OTP, optional; when present we complete 2FA on restart.
+	private readonly loginConfig: { username: string; password: string; twoFactor?: string };
 
 	// Optional LAN update hook for the platform
 	private lanUpdateHandler: ((update: unknown) => void) | null = null;
@@ -70,7 +75,7 @@ export class CyncClient {
 	constructor(
 		configClient: ConfigClient,
 		tcpClient: TcpClient,
-		loginConfig: { email: string; password: string; twoFactor?: string },
+		loginConfig: { username: string; password: string; twoFactor?: string },
 		storagePath: string,
 		logger?: CyncLogger,
 	) {
@@ -80,7 +85,18 @@ export class CyncClient {
 
 		this.loginConfig = loginConfig;
 		this.tokenStore = new CyncTokenStore(storagePath);
+
+		// One-time sanity log so we can see exactly what was passed in from platform/config.
+		this.log.debug(
+			'CyncClient: constructed with loginConfig=%o',
+			{
+				username: loginConfig.username,
+				hasPassword: !!loginConfig.password,
+				twoFactor: loginConfig.twoFactor,
+			},
+		);
 	}
+
 	// ### 🧩 LAN Login Code Builder
 	private buildLanLoginCode(authorize: string, userId: number): Uint8Array {
 		const authorizeBytes = Buffer.from(authorize, 'ascii');
@@ -133,17 +149,20 @@ export class CyncClient {
 		}
 
 		// 2) No stored token – run 2FA bootstrap
-		const { email, password, twoFactor } = this.loginConfig;
+		const { username, password, twoFactor } = this.loginConfig;
 
-		if (!email || !password) {
-			this.log.error('CyncClient: email and password are required to obtain a new token.');
+		if (!username || !password) {
+			this.log.error('CyncClient: username and password are required to obtain a new token.');
 			return false;
 		}
 
-		if (!twoFactor || String(twoFactor).trim() === '') {
+		const trimmedCode = typeof twoFactor === 'string' ? twoFactor.trim() : '';
+		const hasTwoFactor = trimmedCode.length > 0;
+
+		if (!hasTwoFactor) {
 			// No 2FA code – request one
-			this.log.info('Cync: starting 2FA handshake for %s', email);
-			await this.requestTwoFactorCode(email);
+			this.log.info('Cync: starting 2FA handshake for %s', username);
+			await this.requestTwoFactorCode(username);
 			this.log.info(
 				'Cync: 2FA code sent to your email. Enter the code as "twoFactor" in the plugin config and restart Homebridge to complete login.',
 			);
@@ -151,11 +170,11 @@ export class CyncClient {
 		}
 
 		// We have a 2FA code – complete login and persist token
-		this.log.info('Cync: completing 2FA login for %s', email);
+		this.log.info('Cync: completing 2FA login for %s', username);
 		const loginResult = await this.completeTwoFactorLogin(
-			email,
+			username,
 			password,
-			String(twoFactor).trim(),
+			trimmedCode,
 		);
 
 		// Build LAN login code
@@ -191,25 +210,22 @@ export class CyncClient {
 		this.applyAccessToken(tokenData);
 
 		this.log.info('Cync login successful; userId=%s (token stored)', tokenData.userId);
-		this.log.info(
-			'Cync: 2FA login complete and a token has been stored. You may now clear the "twoFactor" code from the plugin config; ' +
-					'it will only be needed again if the stored token expires or is removed.',
-		);
 		return true;
 	}
 
 
 	/**
-		 * Internal helper: request a 2FA email code using existing authenticate().
-		 */
-	private async requestTwoFactorCode(email: string): Promise<void> {
-		await this.authenticate(email);
+	 * Internal helper: request a 2FA email code using existing authenticate().
+	 * Accepts the same username value we store in loginConfig (email address for Cync).
+	 */
+	private async requestTwoFactorCode(username: string): Promise<void> {
+		await this.authenticate(username);
 	}
 
 	/**
-		 * Internal helper: complete 2FA login using existing submitTwoFactor().
-		 * This converts CyncLoginSession into the richer shape we want for token storage.
-		 */
+	 * Internal helper: complete 2FA login using existing submitTwoFactor().
+	 * This converts CyncLoginSession into the richer shape we want for token storage.
+	 */
 	private async completeTwoFactorLogin(
 		email: string,
 		password: string,
@@ -222,12 +238,15 @@ export class CyncClient {
 		}
 	> {
 		const session = await this.submitTwoFactor(email, password, code);
+
 		// Extract authorize field from session.raw (Cync returns it)
 		const raw = session.raw as Record<string, unknown>;
 		const authorize = typeof raw?.authorize === 'string' ? raw.authorize : undefined;
 
 		if (!authorize) {
-			throw new Error('CyncClient: missing "authorize" field from login response; LAN login cannot be generated.');
+			throw new Error(
+				'CyncClient: missing "authorize" field from login response; LAN login cannot be generated.',
+			);
 		}
 
 		const s = session as unknown as SessionWithPossibleTokens;
@@ -320,11 +339,11 @@ export class CyncClient {
 	 * in the same process, so it works across Homebridge restarts.
 	 */
 	public async submitTwoFactor(
-		email: string,
+		username: string,
 		password: string,
 		code: string,
 	): Promise<CyncLoginSession> {
-		const trimmedEmail = email.trim();
+		const trimmedEmail = username.trim();
 		const trimmedCode = code.trim();
 
 		this.log.info('CyncClient: completing 2FA login for %s', trimmedEmail);
@@ -351,7 +370,6 @@ export class CyncClient {
 		return session;
 	}
 
-
 	/**
 	 * Fetch and cache the cloud configuration (meshes/devices) for the logged-in user.
 	 * Also builds HA-style LAN topology mappings:

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,38 @@ 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;
+	/**
+	 * ### 🧩 LAN Command Serializer: Ensures TCP commands are sent one at a time
+	 *
+	 * Wraps any TCP command in a promise chain so commands are serialized
+	 * and cannot be written to the socket concurrently.
+	 */
+	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;
@@ -180,8 +203,7 @@ 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`.
+	 * If the socket is closed or missing, attempt to reconnect.
 	 */
 	private async ensureConnected(): Promise<boolean> {
 		if (this.socket && !this.socket.destroyed) {
@@ -195,28 +217,8 @@ 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);
 	}
 
 	/**
@@ -325,45 +327,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,
@@ -414,9 +377,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 {
@@ -442,49 +402,58 @@ export class TcpClient {
 
 	/**
 	 * High-level API to change switch state.
-	 * Now enqueues a power packet so multiple HomeKit scene writes are
-	 * serialized over a single TCP session.
+	 * Ensures we have a live socket before sending and serializes commands.
 	 */
 	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 device = this.findDevice(deviceId);
+			if (!device) {
+				this.log.warn('[Cync TCP] Unknown deviceId=%s', deviceId);
+				return;
+			}
 
-		const controllerId = Number((device as Record<string, unknown>).switch_controller);
-		const meshIndex = Number((device as Record<string, unknown>).mesh_id);
+			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] Device %s is missing LAN fields (switch_controller=%o mesh_id=%o)',
-				deviceId,
-				(device as Record<string, unknown>).switch_controller,
-				(device as Record<string, unknown>).mesh_id,
-			);
-			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)',
+					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();
 	}
 
 	private findDevice(deviceId: string) {
@@ -515,9 +484,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) => {

package/src/cync/token-store.ts

@@ -13,17 +13,12 @@ export interface CyncTokenData {
 
 /**
  * Simple JSON token store under the Homebridge storage path.
- *
- * Files are stored at:
- *   <storagePath>/homebridge-cync-app/cync-tokens.json
  */
 export class CyncTokenStore {
-	private readonly dirPath: string;
 	private readonly filePath: string;
 
 	public constructor(storagePath: string) {
-		this.dirPath = path.join(storagePath, 'homebridge-cync-app');
-		this.filePath = path.join(this.dirPath, 'cync-tokens.json');
+		this.filePath = path.join(storagePath, 'cync-tokens.json');
 	}
 
 	public async load(): Promise<CyncTokenData | null> {
@@ -38,16 +33,12 @@ export class CyncTokenStore {
 
 			return data;
 		} catch {
-			// file missing or unreadable → treat as no token
 			return null;
 		}
 	}
 
 	public async save(data: CyncTokenData): Promise<void> {
 		const json = JSON.stringify(data, null, 2);
-
-		// Ensure directory exists before writing
-		await fs.mkdir(this.dirPath, { recursive: true });
 		await fs.writeFile(this.filePath, json, 'utf8');
 	}
 
@@ -55,7 +46,7 @@ export class CyncTokenStore {
 		try {
 			await fs.unlink(this.filePath);
 		} catch {
-			// ignore if missing or already removed
+			// ignore if missing
 		}
 	}
 }