@smarterhomeapp/homebridge-vantage 1.0.4 → 1.0.6

package/dist/platform.d.ts

@@ -12,6 +12,8 @@ export declare class VantagePlatform implements DynamicPlatformPlugin {
     constructor(log: Logger, config: PlatformConfig, api: API);
     configureAccessory(accessory: PlatformAccessory): void;
     private syncAccessories;
+    private shouldSkipStaleRemoval;
+    private rebuildAccessoryVidMap;
     private wireRealtimeListeners;
     private finalizeLogs;
     getInfusion(): VantageInfusion;

package/dist/platform.js

@@ -50,10 +50,27 @@ class VantagePlatform {
     // Reconcile cached accessories with current device list
     async syncAccessories(devices) {
         const uuidFor = (d) => this.api.hap.uuid.generate(String(d.vid));
+        if (devices.length === 0 && this.accessories.length > 0) {
+            this.log.error(`Discovery returned 0 devices; preserving ${this.accessories.length} cached accessories ` +
+                'and rebuilding realtime VID map.');
+            this.rebuildAccessoryVidMap();
+            this.wireRealtimeListeners();
+            this.syncedOnce = true;
+            return;
+        }
         // Map current devices
         const wanted = new Map();
         for (const d of devices)
             wanted.set(uuidFor(d), d);
+        const toUnregister = this.accessories.filter((acc) => !wanted.has(acc.UUID));
+        if (toUnregister.length && this.shouldSkipStaleRemoval(devices.length, toUnregister.length)) {
+            this.log.error(`Suspicious partial discovery detected; preserving ${this.accessories.length} cached accessories. ` +
+                `Discovery returned ${devices.length} devices and would remove ${toUnregister.length}.`);
+            this.rebuildAccessoryVidMap();
+            this.wireRealtimeListeners();
+            this.syncedOnce = true;
+            return;
+        }
         // Update existing / mark seen
         const seen = new Set();
         const toUpdate = [];
@@ -93,10 +110,9 @@ class VantagePlatform {
             this.log.info(`Registered ${toRegister.length} new accessories`);
         }
         // Unregister stale
-        const toUnregister = this.accessories.filter((acc) => !wanted.has(acc.UUID));
         if (toUnregister.length) {
             this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, toUnregister);
-            this.log.info(`Unregistered ${toUnregister.length} stale accessories`);
+            this.log.info(`Unregistered ${toUnregister.length} stale accessories after successful discovery`);
             // Remove from local cache & VID map
             for (const acc of toUnregister) {
                 const vid = acc?.context?.device?.vid;
@@ -111,6 +127,24 @@ class VantagePlatform {
         this.wireRealtimeListeners();
         this.syncedOnce = true;
     }
+    shouldSkipStaleRemoval(discoveredCount, staleCount) {
+        const cachedCount = this.accessories.length;
+        if (cachedCount === 0 || staleCount === 0)
+            return false;
+        const removalRatio = staleCount / cachedCount;
+        const discoveredRatio = discoveredCount / cachedCount;
+        // Allow small cleanup, but refuse sudden large percentage drops that look like partial discovery.
+        return staleCount >= 5 && removalRatio > 0.5 && discoveredRatio < 0.5;
+    }
+    rebuildAccessoryVidMap() {
+        this.accessoriesByVid.clear();
+        for (const acc of this.accessories) {
+            const vid = acc?.context?.device?.vid;
+            if (vid !== undefined && vid !== null) {
+                this.accessoriesByVid.set(String(vid), acc);
+            }
+        }
+    }
     wireRealtimeListeners() {
         if (this.realtimeWired)
             return;

package/dist/platformAccessory.js

@@ -21,6 +21,7 @@ class VantagePlatformAccessory {
             this.accessory.addService(this.Service.AccessoryInformation);
         info.setCharacteristic(this.Characteristic.Manufacturer, 'Vantage Controls');
         info.setCharacteristic(this.Characteristic.Model, device.objectType ?? device.type);
+        info.setCharacteristic(this.Characteristic.Name, device.name);
         info.setCharacteristic(this.Characteristic.SerialNumber, `VID ${device.vid}`);
         // Build the correct primary service for the type
         let primary;
@@ -184,6 +185,8 @@ class VantagePlatformAccessory {
             this.platform.log.warn(`Unsupported device type ${device.type} for ${this.accessory.displayName}`);
             return;
         }
+        primary.displayName = device.name;
+        primary.setCharacteristic(this.Characteristic.Name, device.name);
         // Mark primary (helps Home app pick the right tile)
         try {
             primary.setPrimaryService?.(true);

package/dist/vantageInfusion.d.ts

@@ -18,6 +18,7 @@ export declare class VantageInfusion extends EventEmitter {
     private isInsecureCmd;
     private isInsecureCfg;
     private getCacheFilePath;
+    private cacheKeyForIp;
     constructor(opts: Options);
     /** Probe ports and open command session */
     start(): Promise<void>;
@@ -29,11 +30,16 @@ export declare class VantageInfusion extends EventEmitter {
     /** XML/config discovery; returns devices (replaces old Discover/DiscoverSSL) */
     discoverDevices(): Promise<VantageDevice[]>;
     private processConfigurationXml;
+    private parseAndValidateConfigurationXml;
+    private isRelevantConfigObject;
+    private errorMessage;
     /** Escape text for XML (same as sanitize in index.js). */
     private static escapeXml;
     /** Build cache XML from readObjects (same structure + sanitization as original index.js). */
     private buildCacheXml;
     private pullConfigurationXml;
+    private writeCacheAtomically;
+    private validateExistingCacheForReplacement;
     setBrightness(vid: string, level: number): Promise<void>;
     setHue(vid: string, hue: number): Promise<void>;
     setSaturation(vid: string, sat: number): Promise<void>;

package/dist/vantageInfusion.js

@@ -71,14 +71,19 @@ const OBJECT_TYPES = [
     ...TYPE_THERMO,
     ...TYPE_BLIND,
 ];
+const DISCOVERABLE_OBJECT_TYPES = OBJECT_TYPES.filter((type) => type !== 'Area');
 class VantageInfusion extends events_1.EventEmitter {
     getCacheFilePath() {
-        // Try /tmp first (Linux/macOS), then fall back to user's home directory
-        const tmpPath = '/tmp/vantage.dc';
+        const fileName = `vantage-${this.cacheKeyForIp(this.opts.ipaddress)}.dc`;
+        // Try /tmp first (Linux/macOS), then fall back to user's home directory.
+        const tmpPath = path.join('/tmp', fileName);
         if (fs.existsSync('/tmp')) {
             return tmpPath;
         }
-        return path.join(os.homedir(), 'vantage.dc');
+        return path.join(os.homedir(), fileName);
+    }
+    cacheKeyForIp(ipaddress) {
+        return ipaddress.replace(/[^a-zA-Z0-9.-]/g, '_');
     }
     constructor(opts) {
         super();
@@ -268,24 +273,25 @@ class VantageInfusion extends events_1.EventEmitter {
             if (fs.existsSync(cachePath)) {
                 try {
                     const cachedXml = fs.readFileSync(cachePath, 'utf8');
-                    this.opts.log.info(`Using cached configuration from ${cachePath}`);
-                    return this.processConfigurationXml(cachedXml);
+                    const devices = await this.processConfigurationXml(cachedXml, `cached configuration from ${cachePath}`);
+                    this.opts.log.info(`Valid cached configuration loaded from ${cachePath}`);
+                    return devices;
                 }
                 catch (error) {
-                    this.opts.log.warn(`Failed to read cached configuration: ${error}`);
+                    this.opts.log.warn(`Cached configuration rejected from ${cachePath}: ${this.errorMessage(error)}`);
                 }
             }
         }
         const xml = await this.pullConfigurationXml();
         // Legacy: "end configuration download"
         this.opts.log.debug('VantagePlatform for InFusion Controller (end configuration download)');
-        return this.processConfigurationXml(xml);
+        const devices = await this.processConfigurationXml(xml, 'downloaded configuration');
+        this.opts.log.info('Valid configuration loaded from controller download');
+        return devices;
     }
-    async processConfigurationXml(xml) {
-        const sanitized = this.sanitizeXml(xml);
-        const parsed = await this.xml.parseStringPromise(sanitized).catch(() => ({}));
+    async processConfigurationXml(xml, source = 'configuration') {
+        const { objects } = await this.parseAndValidateConfigurationXml(xml, source);
         const devices = [];
-        const objects = parsed?.Project?.Objects?.Object || [];
         const Areas = objects.filter((el) => Object.keys(el)[0] === 'Area');
         const Area = {};
         for (const a of Areas)
@@ -323,7 +329,7 @@ class VantageInfusion extends events_1.EventEmitter {
                 devices.push(dev);
             };
             if (it.DeviceCategory === 'HVAC' || TYPE_THERMO.includes(it.ObjectType)) {
-                this.opts.log.info(`New HVAC added (VID=${it.VID}, Name=${it.Name})`);
+                this.opts.log.info(`New HVAC added (VID=${it.VID}, Name=${name})`);
                 pushUnique({
                     name,
                     address: vid,
@@ -357,7 +363,7 @@ class VantageInfusion extends events_1.EventEmitter {
                     it.LoadType === 'Motor' ||
                     it.LoadType === 'High Voltage Relay';
                 if (isRelay) {
-                    this.opts.log.info(`New relay added (VID=${it.VID}, Name=${it.Name}, RELAY)`);
+                    this.opts.log.info(`New relay added (VID=${it.VID}, Name=${name}, RELAY)`);
                     pushUnique({
                         name,
                         address: vid,
@@ -370,7 +376,7 @@ class VantageInfusion extends events_1.EventEmitter {
                     });
                 }
                 else if (it.ObjectType === 'Vantage.DDGColorLoad') {
-                    this.opts.log.info(`New load added (VID=${it.VID}, Name=${it.Name}, RGB)`);
+                    this.opts.log.info(`New load added (VID=${it.VID}, Name=${name}, RGB)`);
                     pushUnique({
                         name,
                         address: vid,
@@ -385,7 +391,7 @@ class VantageInfusion extends events_1.EventEmitter {
                     });
                 }
                 else {
-                    this.opts.log.info(`New load added (VID=${it.VID}, Name=${it.Name}, DIMMER)`);
+                    this.opts.log.info(`New load added (VID=${it.VID}, Name=${name}, DIMMER)`);
                     pushUnique({
                         name,
                         address: vid,
@@ -404,7 +410,7 @@ class VantageInfusion extends events_1.EventEmitter {
                     blindOpenClose[it.OpenLoad] = it.OpenLoad;
                     blindOpenClose[it.CloseLoad] = it.CloseLoad;
                 }
-                this.opts.log.info(`New Blind added (VID=${it.VID}, Name=${it.Name}, BLIND)`);
+                this.opts.log.info(`New Blind added (VID=${it.VID}, Name=${name}, BLIND)`);
                 pushUnique({ name, address: vid, type: 'blind', vid, objectType: it.ObjectType, pos: 100, posState: 2 });
                 continue;
             }
@@ -420,6 +426,51 @@ class VantageInfusion extends events_1.EventEmitter {
         }
         return filtered;
     }
+    async parseAndValidateConfigurationXml(xml, source) {
+        const sanitized = this.sanitizeXml(xml);
+        let parsedAny;
+        try {
+            parsedAny = await this.xml.parseStringPromise(sanitized);
+        }
+        catch (error) {
+            const message = `${source} rejected: XML parsing failed: ${this.errorMessage(error)}`;
+            this.opts.log.error(message);
+            throw new Error(message);
+        }
+        const parsed = parsedAny?.smarterHome ?? parsedAny;
+        const objectNode = parsed?.Project?.Objects?.Object;
+        if (!objectNode) {
+            const message = `${source} rejected: missing Project.Objects.Object configuration structure`;
+            this.opts.log.error(message);
+            throw new Error(message);
+        }
+        const objects = Array.isArray(objectNode) ? objectNode : [objectNode];
+        if (objects.length === 0) {
+            const message = `${source} rejected: Project.Objects.Object contains no objects`;
+            this.opts.log.error(message);
+            throw new Error(message);
+        }
+        const relevantObjectCount = objects.filter((object) => this.isRelevantConfigObject(object)).length;
+        if (relevantObjectCount === 0) {
+            const message = `${source} rejected: configuration contains no discoverable Vantage objects`;
+            this.opts.log.error(message);
+            throw new Error(message);
+        }
+        return { objects, relevantObjectCount };
+    }
+    isRelevantConfigObject(raw) {
+        if (!raw || typeof raw !== 'object')
+            return false;
+        const key = Object.keys(raw)[0];
+        const value = raw[key];
+        if (!value || typeof value !== 'object')
+            return false;
+        const objectType = value?.ObjectType ?? key;
+        return DISCOVERABLE_OBJECT_TYPES.includes(key) || DISCOVERABLE_OBJECT_TYPES.includes(objectType);
+    }
+    errorMessage(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
     /** Escape text for XML (same as sanitize in index.js). */
     static escapeXml(s) {
         return String(s)
@@ -440,30 +491,33 @@ class VantageInfusion extends events_1.EventEmitter {
         return `<Project><Objects>${frag}</Objects></Project>`;
     }
     pullConfigurationXml() {
-        return new Promise((resolve) => {
-            const finishOnce = (socket, xml) => {
+        return new Promise((resolve, reject) => {
+            const finishOnce = async (socket, xml) => {
                 if (finishOnce._done)
                     return;
                 finishOnce._done = true;
                 // Save configuration to cache if usecache is enabled
-                if (this.opts.usecache) {
-                    try {
-                        const cachePath = this.getCacheFilePath();
-                        fs.writeFileSync(cachePath, xml);
-                        this.opts.log.info(`Configuration cached to ${cachePath}`);
+                try {
+                    if (this.opts.usecache) {
+                        await this.writeCacheAtomically(xml);
                     }
-                    catch (error) {
-                        this.opts.log.warn(`Failed to cache configuration: ${error}`);
+                    // legacy log + event
+                    this.opts.log.debug('VantagePlatform for InFusion Controller (end configuration download)');
+                    this.emit('endDownloadConfiguration', xml);
+                    try {
+                        socket.destroy();
                     }
+                    catch { /* noop */ }
+                    resolve(xml);
                 }
-                // legacy log + event
-                this.opts.log.debug('VantagePlatform for InFusion Controller (end configuration download)');
-                this.emit('endDownloadConfiguration', xml);
-                try {
-                    socket.destroy();
+                catch (error) {
+                    this.opts.log.error(`Downloaded configuration rejected; preserving existing cache: ${this.errorMessage(error)}`);
+                    try {
+                        socket.destroy();
+                    }
+                    catch { /* noop */ }
+                    reject(error);
                 }
-                catch { /* noop */ }
-                resolve(xml);
             };
             const onData = (socket) => {
                 this.opts.log.info('load dc file'); // legacy
@@ -484,7 +538,7 @@ class VantageInfusion extends events_1.EventEmitter {
                     if (readObjects.length && Date.now() - lastProgress > 2000) {
                         const xml = this.buildCacheXml(readObjects);
                         clearInterval(watchdog);
-                        finishOnce(socket, xml);
+                        void finishOnce(socket, xml);
                     }
                 }, 750);
                 const writeOpenFilter = () => {
@@ -593,7 +647,7 @@ class VantageInfusion extends events_1.EventEmitter {
                             const xml = this.buildCacheXml(readObjects);
                             clearLoginFallback();
                             clearInterval(watchdog);
-                            finishOnce(socket, xml);
+                            void finishOnce(socket, xml);
                         }
                     });
                 });
@@ -603,7 +657,7 @@ class VantageInfusion extends events_1.EventEmitter {
                         const xml = this.buildCacheXml(readObjects);
                         clearLoginFallback();
                         clearInterval(watchdog);
-                        finishOnce(socket, xml);
+                        void finishOnce(socket, xml);
                     }
                 });
                 socket.on('close', () => {
@@ -612,7 +666,7 @@ class VantageInfusion extends events_1.EventEmitter {
                         const xml = this.buildCacheXml(readObjects);
                         clearLoginFallback();
                         clearInterval(watchdog);
-                        finishOnce(socket, xml);
+                        void finishOnce(socket, xml);
                     }
                 });
             };
@@ -624,6 +678,50 @@ class VantageInfusion extends events_1.EventEmitter {
             }
         });
     }
+    async writeCacheAtomically(xml) {
+        const cachePath = this.getCacheFilePath();
+        const tmpPath = `${cachePath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+        const candidateValidation = await this.parseAndValidateConfigurationXml(xml, 'downloaded configuration');
+        try {
+            fs.writeFileSync(tmpPath, xml, 'utf8');
+            const tmpXml = fs.readFileSync(tmpPath, 'utf8');
+            const validation = await this.parseAndValidateConfigurationXml(tmpXml, `temporary cache ${tmpPath}`);
+            if (fs.existsSync(cachePath)) {
+                const existingValidation = await this.validateExistingCacheForReplacement(cachePath);
+                if (existingValidation &&
+                    existingValidation.relevantObjectCount >= 20 &&
+                    candidateValidation.relevantObjectCount < existingValidation.relevantObjectCount * 0.5) {
+                    const message = `Downloaded configuration rejected as incomplete: ${candidateValidation.relevantObjectCount} relevant objects ` +
+                        `vs ${existingValidation.relevantObjectCount} in existing cache.`;
+                    this.opts.log.error(message);
+                    throw new Error(message);
+                }
+            }
+            fs.renameSync(tmpPath, cachePath);
+            this.opts.log.info(`Validated controller configuration accepted and cache replaced atomically at ${cachePath} ` +
+                `(${validation.relevantObjectCount} relevant objects).`);
+        }
+        catch (error) {
+            try {
+                if (fs.existsSync(tmpPath))
+                    fs.unlinkSync(tmpPath);
+            }
+            catch {
+                /* preserve original error */
+            }
+            throw error;
+        }
+    }
+    async validateExistingCacheForReplacement(cachePath) {
+        try {
+            const existingXml = fs.readFileSync(cachePath, 'utf8');
+            return await this.parseAndValidateConfigurationXml(existingXml, `existing cache ${cachePath}`);
+        }
+        catch (error) {
+            this.opts.log.warn(`Existing cache is invalid; replacing it with validated controller configuration: ${this.errorMessage(error)}`);
+            return undefined;
+        }
+    }
     // ===== Commands used by platformAccessory handlers =====
     async setBrightness(vid, level) {
         const lvl = Math.max(0, Math.min(100, Number(level)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smarterhomeapp/homebridge-vantage",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Homebridge plugin for Vantage InFusion (dynamic platform, HB 1.6+ / 2.0 ready)",
   "license": "MIT",
   "keywords": [