homebridge-tydom 0.30.0 → 0.30.1

package/README.md

@@ -236,6 +236,33 @@ Nothing in your config needs to change, and no accessory is re-registered: rooms
 
 ## Troubleshooting
 
+### Duplicate accessories, or `Cannot serialize accessory`
+
+Versions up to v0.30.0 handed each newly discovered accessory to Homebridge for
+caching before registering it, which made the cache write fail:
+
+```text
+Failed to save cached accessories to disk: Cannot serialize accessory 'Salon' - missing associated plugin
+Accessory 'Salon' has the same UUID as existing accessory 'Salon'. Skipping duplicate.
+```
+
+v0.30.1 fixes the cause, and Homebridge rewrites one entry per accessory on the
+first scan after upgrading — so most installations recover on their own after a
+restart. An accessory that was duplicated and then removed from the gateway can
+be left orphaned in the cache, which only a reset clears. If the warnings
+persist, stop Homebridge and delete the cache file once:
+
+```sh
+rm ~/.homebridge/accessories/cachedAccessories
+```
+
+On a child bridge the file is named `cachedAccessories.<bridge-username>`. This
+re-registers every accessory, so rooms, names and automations for Tydom devices
+have to be set up again — which is why it is a last resort rather than a routine
+upgrade step.
+
+### Debugging
+
 Set `debug` to `true` in the config, or start Homebridge with:
 
 ```bash

package/dist/index.mjs

@@ -4903,6 +4903,16 @@ var TydomPlatform = class {
 	* that made per-accessory teardown impossible. The platform fans out instead.
 	*/
 	companions = /* @__PURE__ */ new Map();
+	/**
+	* The `device` handlers still in flight.
+	*
+	* The controller announces every device synchronously from `scan`, but the
+	* handler is async and only reaches `accessories.set` after two awaits, so
+	* nothing it registers has landed when `scan` resolves. The startup sweep and
+	* the count used to run right there — which is why a fully populated gateway
+	* reported `Properly loaded 0-accessories`.
+	*/
+	pendingDevices = /* @__PURE__ */ new Set();
 	controller;
 	/**
 	* The endpoint-facing API, handed to every accessory.
@@ -4950,9 +4960,12 @@ var TydomPlatform = class {
 			this.stop();
 		});
 		this.controller.on("device", (context) => {
-			this.handleControllerDevice(context).catch((err) => {
+			const pending = this.handleControllerDevice(context).catch((err) => {
 				this.log.error(`Failed to handle device ${context.deviceId}: ${stringifyError(err)}`);
+			}).finally(() => {
+				this.pendingDevices.delete(pending);
 			});
+			this.pendingDevices.add(pending);
 		});
 		this.controller.on("update", this.handleControllerDataUpdate.bind(this));
 		this.controller.on("notification", this.handleControllerNotification.bind(this));
@@ -4992,14 +5005,51 @@ var TydomPlatform = class {
 			}
 		}
 		await this.controller.scan();
+		await this.settlePendingDevices();
 		this.cleanupAccessoriesIds.forEach((accessoryId) => {
 			const accessory = this.accessories.get(accessoryId);
 			if (!accessory) return;
 			this.log.warn(`Deleting missing accessory with id=${styleNumber(accessoryId)}`);
 			this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+			this.forgetAccessory(accessoryId);
 		});
 		this.log.info(`Properly loaded ${this.accessories.size}-accessories`);
 	}
+	/**
+	* Drain the announced-device handlers.
+	*
+	* Looping rather than awaiting once covers a handler that itself announces
+	* more work; the `finally` that empties the set is attached before
+	* `allSettled` subscribes, so the loop always terminates.
+	*/
+	async settlePendingDevices() {
+		while (this.pendingDevices.size > 0) await Promise.allSettled(this.pendingDevices);
+	}
+	/**
+	* Drop every trace of an accessory the platform no longer owns.
+	*
+	* `unregisterPlatformAccessories` only tells Homebridge; the platform's own
+	* tables used to keep the entry. That inflated the `Properly loaded` count by
+	* every accessory the sweep had just removed, and left the handler holding
+	* its timers and the companion links pointing at an accessory that is gone.
+	*
+	* `pruneCompanions` is false when the accessory is about to be rebuilt under
+	* the same UUID: the links are keyed by the primary but written by the
+	* companion's own pass, and the controller announces each accessory once.
+	*/
+	forgetAccessory(id, { pruneCompanions = true } = {}) {
+		this.accessories.delete(id);
+		this.handlers.get(id)?.dispose();
+		this.handlers.delete(id);
+		if (!pruneCompanions) return;
+		this.companions.delete(id);
+		for (const [primaryId, companionIds] of this.companions) {
+			if (!companionIds.includes(id)) continue;
+			const remaining = companionIds.filter((companionId) => companionId !== id);
+			if (remaining.length > 0) this.companions.set(primaryId, remaining);
+			else this.companions.delete(primaryId);
+		}
+	}
 	async handleControllerDevice(context) {
 		const { name, deviceId, category, accessoryId } = context;
 		const id = this.api.hap.uuid.generate(accessoryId);
@@ -5015,8 +5065,10 @@ var TydomPlatform = class {
 		} else {
 			this.log.warn(`Deleting accessory with new category with id=${styleNumber(accessoryId)}`);
 			this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [existingAccessory]);
+			this.forgetAccessory(id, { pruneCompanions: false });
 		}
 		const accessory = await this.createAccessory(name, id, category, context);
+		await this.configureHandler(accessory, context);
 		this.accessories.set(id, accessory);
 		this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
 	}
@@ -5063,18 +5115,37 @@ var TydomPlatform = class {
 		this.log.info(`Creating accessory named=${styleString(accessoryName)}, deviceId="${styleNumber(context.deviceId)} (id=${styleKeyword(id)})"`);
 		const accessory = new PlatformAccessory(accessoryName, id, category);
 		Object.assign(accessory.context, context);
-		await this.updateAccessory(accessory, context);
 		return accessory;
 	}
+	/**
+	* Re-configure an accessory Homebridge already knows about, and persist it.
+	*
+	* Only ever call this on an accessory that came back from `configureAccessory`
+	* or that has already been through `registerPlatformAccessories` — those are
+	* the only two ways an accessory gets its plugin association, and without one
+	* the cache write below throws and takes every other accessory down with it.
+	*/
 	async updateAccessory(accessory, context) {
 		const { displayName: accessoryName, UUID: id } = accessory;
 		this.log.info(`Updating accessory named=${styleString(accessoryName)}, deviceId=${styleNumber(context.deviceId)} (id=${styleKeyword(id)})"`);
+		if (!await this.configureHandler(accessory, context)) return;
+		this.api.updatePlatformAccessories([accessory]);
+	}
+	/**
+	* Attach (or re-attach) the handler and its companion links.
+	*
+	* Deliberately touches no Homebridge persistence, so it is safe to run on an
+	* accessory that has not been registered yet. Returns whether a handler was
+	* actually wired, so callers can skip persisting a category they cannot serve.
+	*/
+	async configureHandler(accessory, context) {
+		const { displayName: accessoryName, UUID: id } = accessory;
 		Object.assign(accessory.context, context);
 		assert(this.apiClient);
 		const deviceType = this.resolveDeviceType(context, accessory.category);
 		if (!deviceType) {
 			this.log.warn(`Skipping accessory named=${styleString(accessoryName)}: no handler for category=${styleNumber(accessory.category)}`);
-			return;
+			return false;
 		}
 		if (context.companionOf) {
 			const primaryId = this.api.hap.uuid.generate(context.companionOf);
@@ -5094,7 +5165,7 @@ var TydomPlatform = class {
 				});
 			}
 		}));
-		this.api.updatePlatformAccessories([accessory]);
+		return true;
 	}
 	configureAccessory(accessory) {
 		this.log.debug(`Found cached accessory with id="${accessory.UUID}"`);