homebridge-eufy-security 4.4.2-beta.2 → 4.4.2-beta.20

package/homebridge-ui/server.js

@@ -1,483 +1,600 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+import { EufySecurity, libVersion, Device, PropertyName, CommandName, DeviceType, UserType } from 'eufy-security-client';
+import * as fs from 'fs';
+import { Logger as TsLogger } from 'tslog';
+import { createStream } from 'rotating-file-stream';
+import { Zip } from 'zip-lib';
+import { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils';
+import path from 'path';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { version: LIB_VERSION } = require('../package.json');
+
+const LoginFailReason = Object.freeze({
+  UNKNOWN: 0,
+  CAPTCHA: 1,
+  TFA: 2,
+  TIMEOUT: 3,
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const eufy_security_client_1 = require("eufy-security-client");
-const fs = __importStar(require("fs"));
-const tslog_1 = require("tslog");
-const rotating_file_stream_1 = require("rotating-file-stream");
-const zip_lib_1 = require("zip-lib");
-const types_js_1 = require("./configui/app/util/types.js");
-const version_js_1 = require("./version.js");
-const path_1 = __importDefault(require("path"));
-class UiServer {
-    stations = [];
-    eufyClient = null;
-    log;
-    tsLog;
-    homebridgeStoragePath;
-    storagePath;
-    storedAccessories_file;
-    logZipFilePath;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    pushEvent;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    onRequest;
-    ready;
-    adminAccountUsed = false;
-    config = {
-        username: '',
-        password: '',
-        language: 'en',
-        country: 'US',
-        trustedDeviceName: 'My Phone',
-        persistentDir: '',
-        p2pConnectionSetup: 0,
-        pollingIntervalMinutes: 99,
-        eventDurationSeconds: 10,
-        acceptInvitations: true,
-    };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    constructor(server) {
-        // Copy over properties from the HomebridgePluginUiServer instance
-        this.homebridgeStoragePath = server.homebridgeStoragePath;
-        this.pushEvent = server.pushEvent.bind(server);
-        this.onRequest = server.onRequest.bind(server);
-        this.ready = server.ready.bind(server);
-        // Initialize paths now that we have homebridgeStoragePath
-        this.storagePath = this.homebridgeStoragePath + '/eufysecurity';
-        this.storedAccessories_file = this.storagePath + '/accessories.json';
-        this.logZipFilePath = this.storagePath + '/logs.zip';
-        this.config.persistentDir = this.storagePath;
-        this.initLogger();
-        this.initTransportStreams();
-        this.initEventListeners();
-        this.ready();
-    }
-    initLogger() {
-        this.log = new tslog_1.Logger({
-            name: `[${version_js_1.LIB_VERSION}]`,
-            prettyLogTemplate: '{{name}}\t{{logLevelName}}\t[{{fileNameWithLine}}]\t',
-            prettyErrorTemplate: '\n{{errorName}} {{errorMessage}}\nerror stack:\n{{errorStack}}',
-            prettyErrorStackTemplate: '  • {{fileName}}\t{{method}}\n\t{{fileNameWithLine}}',
-            prettyErrorParentNamesSeparator: ':',
-            prettyErrorLoggerNameDelimiter: '\t',
-            stylePrettyLogs: true,
-            minLevel: 2,
-            prettyLogTimeZone: 'local',
-            prettyLogStyles: {
-                logLevelName: {
-                    '*': ['bold', 'black', 'bgWhiteBright', 'dim'],
-                    SILLY: ['bold', 'white'],
-                    TRACE: ['bold', 'whiteBright'],
-                    DEBUG: ['bold', 'green'],
-                    INFO: ['bold', 'blue'],
-                    WARN: ['bold', 'yellow'],
-                    ERROR: ['bold', 'red'],
-                    FATAL: ['bold', 'redBright'],
-                },
-                dateIsoStr: 'gray',
-                filePathWithLine: 'white',
-                name: 'green',
-                nameWithDelimiterPrefix: ['white', 'bold'],
-                nameWithDelimiterSuffix: ['white', 'bold'],
-                errorName: ['bold', 'bgRedBright', 'whiteBright'],
-                fileName: ['yellow'],
-            },
-        });
-        this.tsLog = new tslog_1.Logger({ type: 'hidden', minLevel: 2 });
-    }
-    initTransportStreams() {
-        if (!fs.existsSync(this.storagePath)) {
-            fs.mkdirSync(this.storagePath);
-        }
-        const pluginLogStream = (0, rotating_file_stream_1.createStream)('configui-server.log', { path: this.storagePath, interval: '1d', rotate: 3, maxSize: '200M' });
-        const pluginLogLibStream = (0, rotating_file_stream_1.createStream)('configui-lib.log', { path: this.storagePath, interval: '1d', rotate: 3, maxSize: '200M' });
-        this.log.attachTransport((logObj) => pluginLogStream.write(JSON.stringify(logObj) + '\n'));
-        this.tsLog.attachTransport((logObj) => pluginLogLibStream.write(JSON.stringify(logObj) + '\n'));
-        this.log.debug('Using bropats eufy-security-client library in version ' + eufy_security_client_1.libVersion);
+
+class UiServer extends HomebridgePluginUiServer {
+
+  stations = [];
+  eufyClient = null;
+  log;
+  tsLog;
+  storagePath;
+  storedAccessories_file;
+  logZipFilePath;
+
+  adminAccountUsed = false;
+
+  // Batch processing for stations and devices
+  pendingStations = [];
+  pendingDevices = [];
+  processingTimeout;
+
+  config = {
+    username: '',
+    password: '',
+    language: 'en',
+    country: 'US',
+    trustedDeviceName: 'My Phone',
+    persistentDir: '',
+    p2pConnectionSetup: 0,
+    pollingIntervalMinutes: 99,
+    eventDurationSeconds: 10,
+    acceptInvitations: true,
+  };
+
+  constructor() {
+    super();
+
+    this.storagePath = this.homebridgeStoragePath + '/eufysecurity';
+    this.storedAccessories_file = this.storagePath + '/accessories.json';
+    this.logZipFilePath = this.storagePath + '/logs.zip';
+    this.config.persistentDir = this.storagePath;
+
+    this.initLogger();
+    this.initTransportStreams();
+    this.initEventListeners();
+    this.ready();
+  }
+
+  initLogger() {
+    this.log = new TsLogger({
+      name: `[${LIB_VERSION}]`,
+      prettyLogTemplate: '{{name}}\t{{logLevelName}}\t',
+      prettyErrorTemplate: '\n{{errorName}} {{errorMessage}}\nerror stack:\n{{errorStack}}',
+      prettyErrorStackTemplate: '  • {{fileName}}\t{{method}}\n\t{{fileNameWithLine}}',
+      prettyErrorParentNamesSeparator: ':',
+      prettyErrorLoggerNameDelimiter: '\t',
+      stylePrettyLogs: true,
+      minLevel: 2,
+      prettyLogTimeZone: 'local',
+      prettyLogStyles: {
+        logLevelName: {
+          '*': ['bold', 'black', 'bgWhiteBright', 'dim'],
+          SILLY: ['bold', 'white'],
+          TRACE: ['bold', 'whiteBright'],
+          DEBUG: ['bold', 'green'],
+          INFO: ['bold', 'blue'],
+          WARN: ['bold', 'yellow'],
+          ERROR: ['bold', 'red'],
+          FATAL: ['bold', 'redBright'],
+        },
+        dateIsoStr: 'gray',
+        filePathWithLine: 'white',
+        name: 'green',
+        nameWithDelimiterPrefix: ['white', 'bold'],
+        nameWithDelimiterSuffix: ['white', 'bold'],
+        errorName: ['bold', 'bgRedBright', 'whiteBright'],
+        fileName: ['yellow'],
+      },
+    });
+    this.tsLog = new TsLogger({ type: 'hidden', minLevel: 2 });
+  }
+
+  initTransportStreams() {
+    if (!fs.existsSync(this.storagePath)) {
+      fs.mkdirSync(this.storagePath);
     }
-    initEventListeners() {
-        this.onRequest('/login', this.login.bind(this));
-        this.onRequest('/storedAccessories', this.loadStoredAccessories.bind(this));
-        this.onRequest('/reset', this.resetPlugin.bind(this));
-        this.onRequest('/downloadLogs', this.downloadLogs.bind(this));
+    const pluginLogStream = createStream('configui-server.log', { path: this.storagePath, interval: '1d', rotate: 3, maxSize: '200M' });
+    const pluginLogLibStream = createStream('configui-lib.log', { path: this.storagePath, interval: '1d', rotate: 3, maxSize: '200M' });
+    this.log.attachTransport((logObj) => pluginLogStream.write(JSON.stringify(logObj) + '\n'));
+    this.tsLog.attachTransport((logObj) => pluginLogLibStream.write(JSON.stringify(logObj) + '\n'));
+    this.log.debug('Using bropats eufy-security-client library in version ' + libVersion);
+  }
+
+  initEventListeners() {
+    this.onRequest('/login', this.login.bind(this));
+    this.onRequest('/checkCache', this.checkCache.bind(this));
+    this.onRequest('/storedAccessories', this.loadStoredAccessories.bind(this));
+    this.onRequest('/reset', this.resetPlugin.bind(this));
+    this.onRequest('/downloadLogs', this.downloadLogs.bind(this));
+    this.onRequest('/systemInfo', this.getSystemInfo.bind(this));
+  }
+
+  async deleteFileIfExists(filePath) {
+    try {
+      await fs.promises.unlink(filePath);
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
     }
-    /**
-     * Deletes a file if it exists.
-     *
-     * @param filePath The path to the file to be deleted.
-     * @returns A Promise that resolves when the operation is complete, or rejects if an error occurs.
-     * @throws Will reject the Promise with the error if file deletion fails.
-     */
-    async deleteFileIfExists(filePath) {
-        try {
-            if (fs.existsSync(filePath)) {
-                fs.unlinkSync(filePath);
-            }
-        }
-        catch (error) {
-            return Promise.reject(error);
+  }
+
+  async resetPersistentData() {
+    return this.deleteFileIfExists(this.storagePath + '/persistent.json');
+  }
+
+  async resetAccessoryData() {
+    return this.deleteFileIfExists(this.storedAccessories_file);
+  }
+
+  async checkCache() {
+    const persistentFile = this.storagePath + '/persistent.json';
+    try {
+      if (fs.existsSync(persistentFile)) {
+        const data = JSON.parse(await fs.promises.readFile(persistentFile, 'utf-8'));
+        // Basic validity check: ensure it has some expected content
+        if (data && Object.keys(data).length > 0) {
+          this.log.debug('Persistent cache file found and valid.');
+          return { valid: true };
         }
+      }
+    } catch (error) {
+      this.log.warn('Error checking persistent cache: ' + error);
     }
-    /**
-     * Resets the persistent data by removing the persistent.json file.
-     *
-     * @returns A Promise that resolves when the operation is complete, or rejects if an error occurs.
-     */
-    async resetPersistentData() {
-        return this.deleteFileIfExists(this.storagePath + '/persistent.json');
+    return { valid: false };
+  }
+
+  async login(options) {
+    try {
+      if (options && options.username && options.password && !options.reconnect) {
+        this.log.info('deleting persistent.json and accessories due to new login');
+        await this.resetAccessoryData();
+        await this.resetPersistentData();
+      } else if (options && options.reconnect) {
+        this.log.info('Reconnecting using persistent cache (skipping data reset)');
+      }
+    } catch (error) {
+      this.log.error('Could not delete persistent.json due to error: ' + error);
     }
-    /**
-     * Resets the accessory data by removing the stored accessories file.
-     *
-     * @returns A Promise that resolves when the operation is complete, or rejects if an error occurs.
-     */
-    async resetAccessoryData() {
-        return this.deleteFileIfExists(this.storedAccessories_file);
+
+    if (!this.eufyClient && options && options.username && options.password && options.country) {
+      // Clear any pending timeouts from a previous login attempt
+      if (this.processingTimeout) {
+        clearTimeout(this.processingTimeout);
+        this.processingTimeout = null;
+      }
+      if (this._closeTimeout) {
+        clearTimeout(this._closeTimeout);
+        this._closeTimeout = null;
+      }
+      this.stations = [];
+      this.pendingStations = [];
+      this.pendingDevices = [];
+      this.log.debug('init eufyClient');
+      this.config.username = options.username;
+      this.config.password = options.password;
+      this.config.country = options.country;
+      this.config.trustedDeviceName = options.deviceName;
+      try {
+        this.eufyClient = await EufySecurity.initialize(this.config, this.tsLog);
+        this.eufyClient?.on('station added', this.addStation.bind(this));
+        this.eufyClient?.on('device added', this.addDevice.bind(this));
+        // Wait for 45 seconds to gather all stations and devices, then process them
+        this.processingTimeout = setTimeout(() => {
+          this.processPendingAccessories().catch(error => this.log.error('Error processing pending accessories:', error));
+        }, 45 * 1000);
+        // Close connection after 50 seconds to allow processing time
+        this._closeTimeout = setTimeout(() => {
+          this.eufyClient?.removeAllListeners();
+          this.eufyClient?.close();
+        }, 50 * 1000);
+      } catch (error) {
+        this.log.error(error);
+      }
     }
-    async login(options) {
+
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        resolve({ success: false, failReason: LoginFailReason.TIMEOUT });
+      }, 25 * 1000);
+
+      if (options && options.username && options.password && options.country) {
+        this.log.debug('login with credentials');
         try {
-            if (options && options.username && options.password) {
-                this.log.info('deleting persistent.json and accessories due to new login');
-                this.resetAccessoryData();
-                await this.resetPersistentData(); // To be commented for testing purpose
-            }
-        }
-        catch (error) {
-            this.log.error('Could not delete persistent.json due to error: ' + error);
+          this.loginHandlers(resolve);
+          this.eufyClient?.connect()
+            .then(() => this.log.debug('connected?: ' + this.eufyClient?.isConnected()))
+            .catch((error) => this.log.error(error));
+        } catch (error) {
+          this.log.error(error);
+          resolve({ success: false, failReason: LoginFailReason.UNKNOWN, data: { error } });
         }
-        if (!this.eufyClient && options && options.username && options.password && options.country) {
-            this.stations = [];
-            this.log.debug('init eufyClient');
-            this.config.username = options.username;
-            this.config.password = options.password;
-            this.config.country = options.country;
-            this.config.trustedDeviceName = options.deviceName;
-            try {
-                this.eufyClient = await eufy_security_client_1.EufySecurity.initialize(this.config, this.tsLog);
-                this.eufyClient?.on('station added', await this.addStation.bind(this));
-                this.eufyClient?.on('device added', await this.addDevice.bind(this));
-                // Close connection after 40 seconds enough time to get all devices
-                setTimeout(() => {
-                    this.eufyClient?.removeAllListeners();
-                    this.eufyClient?.close();
-                }, 40 * 1000);
-            }
-            catch (error) {
-                this.log.error(error);
-            }
+      } else if (options && options.verifyCode) {
+        try {
+          this.loginHandlers(resolve);
+          this.eufyClient?.connect({ verifyCode: options.verifyCode, force: false });
+        } catch (error) {
+          resolve({ success: false, failReason: LoginFailReason.UNKNOWN, data: { error } });
         }
-        return new Promise((resolve, reject) => {
-            setTimeout(() => {
-                resolve({ success: false, failReason: types_js_1.LoginFailReason.TIMEOUT });
-            }, 25 * 1000);
-            if (options && options.username && options.password && options.country) {
-                this.log.debug('login with credentials');
-                try {
-                    this.loginHandlers(resolve);
-                    this.eufyClient?.connect()
-                        .then(() => this.log.debug('connected?: ' + this.eufyClient?.isConnected()))
-                        .catch((error) => this.log.error(error));
-                }
-                catch (error) {
-                    this.log.error(error);
-                    resolve({ success: false, failReason: types_js_1.LoginFailReason.UNKNOWN, data: { error: error } });
-                }
-            }
-            else if (options && options.verifyCode) {
-                try {
-                    this.loginHandlers(resolve);
-                    this.eufyClient?.connect({ verifyCode: options.verifyCode, force: false });
-                }
-                catch (error) {
-                    resolve({ success: false, failReason: types_js_1.LoginFailReason.UNKNOWN, data: { error: error } });
-                }
-            }
-            else if (options && options.captcha) {
-                try {
-                    this.loginHandlers(resolve);
-                    this.eufyClient?.connect({ captcha: { captchaCode: options.captcha.captchaCode, captchaId: options.captcha.captchaId }, force: false });
-                }
-                catch (error) {
-                    resolve({ success: false, failReason: types_js_1.LoginFailReason.UNKNOWN, data: { error: error } });
-                }
-            }
-            else {
-                reject('unsupported login method');
-            }
-        });
-    }
-    loginHandlers(resolveCallback) {
-        this.eufyClient?.once('tfa request', () => resolveCallback({ success: false, failReason: types_js_1.LoginFailReason.TFA }));
-        this.eufyClient?.once('captcha request', (id, captcha) => resolveCallback({ success: false, failReason: types_js_1.LoginFailReason.CAPTCHA, data: { id: id, captcha: captcha } }));
-        this.eufyClient?.once('connect', () => resolveCallback({ success: true }));
-    }
-    /**
-     * Asynchronously loads stored accessories from a file.
-     * @returns A promise resolving to an array of accessories.
-     */
-    async loadStoredAccessories() {
+      } else if (options && options.captcha) {
         try {
-            // Check if the stored accessories file exists
-            if (!fs.existsSync(this.storedAccessories_file)) {
-                // If the file doesn't exist, log a warning and return an empty array
-                this.log.debug('Stored accessories file does not exist.');
-                return [];
-            }
-            // Read the content of the stored accessories file asynchronously
-            const storedData = await fs.promises.readFile(this.storedAccessories_file, { encoding: 'utf-8' });
-            // Parse the JSON data obtained from the file
-            const { version: storedVersion, stations: storedAccessories } = JSON.parse(storedData);
-            // Compare the stored version with the current version
-            if (storedVersion !== version_js_1.LIB_VERSION) {
-                // If the versions do not match, log a warning and push an event
-                this.pushEvent('versionUnmatched', { currentVersion: version_js_1.LIB_VERSION, storedVersion: storedVersion });
-                this.log.warn(`Stored version (${storedVersion}) does not match current version (${version_js_1.LIB_VERSION})`);
-            }
-            // Return the parsed accessories
-            return storedAccessories;
+          this.loginHandlers(resolve);
+          this.eufyClient?.connect({ captcha: { captchaCode: options.captcha.captchaCode, captchaId: options.captcha.captchaId }, force: false });
+        } catch (error) {
+          resolve({ success: false, failReason: LoginFailReason.UNKNOWN, data: { error } });
         }
-        catch (error) {
-            // If an error occurs during the process, log an error message and return an empty array
-            this.log.error('Could not get stored accessories. Most likely no stored accessories yet: ' + error);
-            return [];
+      } else {
+        reject('unsupported login method');
+      }
+    });
+  }
+
+  loginHandlers(resolveCallback) {
+    this.eufyClient?.once('tfa request', () => resolveCallback({ success: false, failReason: LoginFailReason.TFA }));
+    this.eufyClient?.once('captcha request', (id, captcha) => resolveCallback({ success: false, failReason: LoginFailReason.CAPTCHA, data: { id, captcha } }));
+    this.eufyClient?.once('connect', () => resolveCallback({ success: true }));
+  }
+
+  /**
+   * Parse a semver string into [major, minor, patch].
+   * @param {string} ver - e.g. '4.4.2-beta.18'
+   * @returns {number[]}
+   */
+  _parseSemver(ver) {
+    return (ver || '0.0.0').replace(/-.*$/, '').split('.').map(Number);
+  }
+
+  async loadStoredAccessories() {
+    try {
+      if (!fs.existsSync(this.storedAccessories_file)) {
+        this.log.debug('Stored accessories file does not exist.');
+        return [];
+      }
+
+      const storedData = await fs.promises.readFile(this.storedAccessories_file, { encoding: 'utf-8' });
+      const { version: storedVersion, storedAt, stations: storedAccessories } = JSON.parse(storedData);
+
+      // --- Cache age check (30 days) ---
+      if (storedAt) {
+        const ageMs = Date.now() - new Date(storedAt).getTime();
+        const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
+        if (ageDays >= 30) {
+          this.pushEvent('cacheWarning', { reason: 'stale', ageDays });
+          this.log.warn(`Stored accessories are ${ageDays} days old. User should re-login to refresh.`);
         }
+      }
+
+      // --- Version branch check ---
+      if (storedVersion && storedVersion !== LIB_VERSION) {
+        const [curMajor, curMinor] = this._parseSemver(LIB_VERSION);
+        const [stoMajor, stoMinor] = this._parseSemver(storedVersion);
+
+        if (curMajor !== stoMajor || curMinor !== stoMinor) {
+          // Different minor (or major) branch → force re-login
+          this.pushEvent('cacheWarning', {
+            reason: 'versionForce',
+            currentVersion: LIB_VERSION,
+            storedVersion,
+          });
+          this.log.warn(`Stored version (${storedVersion}) is on a different branch than current (${LIB_VERSION}). Forcing re-login.`);
+          return { stations: [], storedAt: null }; // Return empty to force login flow
+        } else {
+          // Same minor branch, different patch → soft warning
+          this.pushEvent('cacheWarning', {
+            reason: 'versionWarn',
+            currentVersion: LIB_VERSION,
+            storedVersion,
+          });
+          this.log.warn(`Stored version (${storedVersion}) differs from current (${LIB_VERSION}) but same branch. Consider re-login.`);
+        }
+      }
+
+      return { stations: storedAccessories, storedAt: storedAt || null };
+    } catch (error) {
+      this.log.error('Could not get stored accessories. Most likely no stored accessories yet: ' + error);
+      return { stations: [], storedAt: null };
     }
-    async delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    async addStation(station) {
-        // Before doing anything check if creds are guest admin
-        const rawStation = station.getRawStation();
-        if (rawStation.member.member_type !== eufy_security_client_1.UserType.ADMIN) {
-            this.adminAccountUsed = true;
-            this.eufyClient?.close();
-            this.pushEvent('AdminAccountUsed', true);
-            this.resetPlugin();
-            this.log.error(`
+  }
+
+  async delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  async addStation(station) {
+    // Check if creds are guest admin
+    const rawStation = station.getRawStation();
+    if (rawStation.member.member_type !== UserType.ADMIN) {
+      this.adminAccountUsed = true;
+      this.eufyClient?.close();
+      this.pushEvent('AdminAccountUsed', true);
+      this.resetPlugin();
+      this.log.error(`
       #########################
       ######### ERROR #########
       #########################
       You're not using a guest admin account with this plugin! You must use a guest admin account!
       Please look here for more details: 
-      https://github.com/homebridge-eufy-security/plugin/wiki/Create-a-dedicated-admin-account-for-Homebridge-Eufy-Security-Plugin
+      https://github.com/homebridge-plugins/homebridge-eufy-security/wiki/Create-a-dedicated-admin-account-for-Homebridge-Eufy-Security-Plugin
       #########################
       `);
-            return;
-        }
-        await this.delay(1000);
-        const s = {
-            uniqueId: station.getSerial(),
-            displayName: station.getName(),
-            type: station.getDeviceType(),
-            typename: eufy_security_client_1.DeviceType[station.getDeviceType()],
-            disabled: false,
-            devices: [],
-        };
-        s.ignored = (this.config['ignoreStations'] ?? []).includes(s.uniqueId);
-        // Standalone Lock or Doorbell doesn't have Security Control
-        if (eufy_security_client_1.Device.isLock(s.type) || eufy_security_client_1.Device.isDoorbell(s.type)) {
-            s.disabled = true;
-            s.ignored = true;
-        }
-        this.stations.push(s);
-        this.storeAccessories();
-        this.pushEvent('addAccessory', this.stations);
+      return;
     }
-    async addDevice(device) {
-        // Before doing anything check if creds are guest admin
-        if (this.adminAccountUsed) {
-            this.pushEvent('AdminAccountUsed', true);
-            return;
-        }
-        await this.delay(2000);
-        const d = {
-            uniqueId: device.getSerial(),
-            displayName: device.getName(),
-            type: device.getDeviceType(),
-            typename: eufy_security_client_1.DeviceType[device.getDeviceType()],
-            standalone: device.getSerial() === device.getStationSerial(),
-            hasBattery: device.hasBattery(),
-            isCamera: device.isCamera(),
-            isDoorbell: device.isDoorbell(),
-            isKeypad: device.isKeyPad(),
-            supportsRTSP: device.hasPropertyValue(eufy_security_client_1.PropertyName.DeviceRTSPStream),
-            supportsTalkback: device.hasCommand(eufy_security_client_1.CommandName.DeviceStartTalkback),
-            DeviceEnabled: device.hasProperty(eufy_security_client_1.PropertyName.DeviceEnabled),
-            DeviceMotionDetection: device.hasProperty(eufy_security_client_1.PropertyName.DeviceMotionDetection),
-            DeviceLight: device.hasProperty(eufy_security_client_1.PropertyName.DeviceLight),
-            DeviceChimeIndoor: device.hasProperty(eufy_security_client_1.PropertyName.DeviceChimeIndoor),
-            disabled: false,
-            properties: device.getProperties(),
-        };
-        if (device.hasProperty(eufy_security_client_1.PropertyName.DeviceChargingStatus)) {
-            d.chargingStatus = device.getPropertyValue(eufy_security_client_1.PropertyName.DeviceChargingStatus);
-        }
-        try {
-            delete d.properties.picture;
-        }
-        catch (error) {
-            this.log.error(error);
-        }
-        d.ignored = (this.config['ignoreDevices'] ?? []).includes(d.uniqueId);
-        const stationUniqueId = device.getStationSerial();
-        const stationIndex = this.stations.findIndex(station => station.uniqueId === stationUniqueId);
-        if (stationIndex !== -1) {
-            if (!this.stations[stationIndex].devices) {
-                this.stations[stationIndex].devices = [];
-            }
-            this.stations[stationIndex].devices.push(d);
-            this.storeAccessories();
-            this.pushEvent('addAccessory', this.stations);
-        }
-        else {
-            this.log.error('Station not found for device:', d.displayName);
-        }
+
+    this.pendingStations.push(station);
+    this.log.debug(`${station.getName()}: Station queued for processing`);
+  }
+
+  async addDevice(device) {
+    if (this.adminAccountUsed) {
+      this.pushEvent('AdminAccountUsed', true);
+      return;
     }
-    storeAccessories() {
-        const dataToStore = { version: version_js_1.LIB_VERSION, stations: this.stations };
-        fs.writeFileSync(this.storedAccessories_file, JSON.stringify(dataToStore));
+
+    const deviceType = device.getDeviceType();
+    if (Device.isKeyPad(deviceType)) {
+      this.log.warn(`${device.getName()}: The keypad is ignored as it serves no purpose in this plugin. You can ignore this message.`);
+      return;
     }
-    async resetPlugin() {
-        try {
-            fs.rmSync(this.storagePath, { recursive: true });
-            return { result: 1 };
-        }
-        catch (error) {
-            this.log.error('Could not reset plugin: ' + error);
-            return { result: 0 };
-        }
+
+    this.pendingDevices.push(device);
+    this.log.debug(`${device.getName()}: Device queued for processing`);
+  }
+
+  async processPendingAccessories() {
+    this.log.debug(`Processing ${this.pendingStations.length} stations and ${this.pendingDevices.length} devices`);
+
+    if (this.pendingStations.length === 0 || this.pendingDevices.length === 0) {
+      this.log.warn(
+        `Discovery finished with ${this.pendingStations.length} station(s) and ${this.pendingDevices.length} device(s). ` +
+        'If this is unexpected, please verify your Eufy account has devices and the credentials used are for a guest admin account.',
+      );
     }
-    async getLogs() {
-        // Step 1: List Files in Directory
-        // Asynchronously list all files in the directory specified by this.storagePath.
-        const files = await fs.promises.readdir(this.storagePath);
-        // Step 2: Filter Log Files
-        // Filter the list of files to include only those with names ending in .log, .log.0.
-        const logFiles = files.filter(file => {
-            return file.endsWith('.log') || file.endsWith('.log.0');
-        });
-        // Step 3: Filter out Empty Log Files
-        const nonEmptyLogFiles = await Promise.all(logFiles.map(async (file) => {
-            const filePath = path_1.default.join(this.storagePath, file);
-            const stats = await fs.promises.stat(filePath);
-            if (stats.size > 0) {
-                return file;
-            }
-            return null;
-        }));
-        // Step 4: Remove null entries (empty log files) from the array
-        return nonEmptyLogFiles.filter(file => file !== null);
+
+    // Build set of stations that have at least one device
+    const stationsWithDevices = new Set();
+    for (const device of this.pendingDevices) {
+      stationsWithDevices.add(device.getStationSerial());
     }
-    /**
-     * Asynchronously compresses log files from a directory and returns a Promise that resolves to a Buffer.
-     * @returns {Promise<Buffer>} A Promise resolving to a Buffer containing compressed log files.
-     */
-    async downloadLogs() {
-        this.pushEvent('downloadLogsProgress', { progress: 10, status: 'Gets non-empty log files' });
-        const finalLogFiles = await this.getLogs();
-        // Step 5: Add Log Files to Zip
-        // Initialize a Zip instance and add each log file to the archive.
-        this.pushEvent('downloadLogsProgress', { progress: 30, status: 'Add Log Files to Zip' });
-        const zip = new zip_lib_1.Zip();
-        let numberOfFiles = 0;
-        finalLogFiles.forEach(logFile => {
-            const filePath = path_1.default.join(this.storagePath, logFile);
-            zip.addFile(filePath);
-            numberOfFiles++;
-        });
-        // Step 6: Handle No Log Files Found
-        // If no log files are found after filtering, throw an error.
-        this.pushEvent('downloadLogsProgress', { progress: 40, status: 'No Log Files Found' });
-        if (numberOfFiles === 0) {
-            throw new Error('No log files were found');
-        }
-        try {
-            // Step 7: Archive Zip
-            // Archive the Zip instance to the specified log zip file.
-            this.pushEvent('downloadLogsProgress', { progress: 45, status: `Compressing ${numberOfFiles} files` });
-            await zip.archive(this.logZipFilePath);
-            // Step 8: Read Zip File
-            // Read the content of the generated log zip file into a Buffer.
-            this.pushEvent('downloadLogsProgress', { progress: 80, status: 'Reading content' });
-            const fileBuffer = fs.readFileSync(this.logZipFilePath);
-            // Step 9: Return Buffer
-            // Return the Buffer containing the compressed log files.
-            this.pushEvent('downloadLogsProgress', { progress: 90, status: 'Returning zip file' });
-            return fileBuffer;
-        }
-        catch (error) {
-            // Step 10: Error Handling
-            // Log an error if archiving the zip file fails and propagate the error.
-            this.log.error('Error while generating log files: ' + error);
-            throw error;
-        }
-        finally {
-            // Step 11: Cleanup
-            // Ensure to remove any compressed log files after the operation, regardless of success or failure.
-            this.removeCompressedLogs();
+
+    // Process queued stations
+    for (const station of this.pendingStations) {
+      const stationType = station.getDeviceType();
+      const stationSerial = station.getSerial();
+
+      const s = {
+        uniqueId: stationSerial,
+        displayName: station.getName(),
+        type: stationType,
+        typename: DeviceType[stationType],
+        disabled: false,
+        devices: [],
+        properties: station.getProperties(),
+      };
+
+      try {
+        delete s.properties.picture;
+      } catch (error) {
+        // ignore
+      }
+
+      s.ignored = (this.config['ignoreStations'] ?? []).includes(s.uniqueId);
+
+      if (stationType !== DeviceType.STATION) {
+        // Non-HomeBase station — the station IS a device (station.type == device.type)
+        // Check if the matching device was emitted by the client
+        const hasMatchingDevice = this.pendingDevices.some(d => d.getSerial() === stationSerial);
+
+        if (hasMatchingDevice) {
+          s.standalone = true;
+          s.disabled = true; // No separate station card; settings accessible via device card
+
+          // Standalone Locks and Doorbells don't have Security Control
+          if (Device.isLock(s.type) || Device.isDoorbell(s.type)) {
+            s.noSecurityControl = true;
+          }
+        } else {
+          // Station exists but no device counterpart was emitted — unsupported
+          s.unsupported = true;
+          this.log.warn(`Station "${station.getName()}" (${DeviceType[stationType]}) has no matching device and will be marked as unsupported`);
         }
+      }
+
+      this.stations.push(s);
     }
-    removeCompressedLogs() {
-        try {
-            if (fs.existsSync(this.logZipFilePath)) {
-                fs.unlinkSync(this.logZipFilePath);
-            }
-            return true;
-        }
-        catch {
-            return false;
+
+    // Process queued devices and attach them to stations
+    for (const device of this.pendingDevices) {
+      const devType = device.getDeviceType();
+      const d = {
+        uniqueId: device.getSerial(),
+        displayName: device.getName(),
+        type: devType,
+        typename: DeviceType[devType],
+        standalone: device.getSerial() === device.getStationSerial(),
+        hasBattery: device.hasBattery(),
+        isCamera: device.isCamera(),
+        isDoorbell: device.isDoorbell(),
+        isKeypad: device.isKeyPad(),
+        isMotionSensor: Device.isMotionSensor(devType),
+        isEntrySensor: Device.isEntrySensor(devType),
+        isLock: Device.isLock(devType),
+        supportsRTSP: device.hasPropertyValue(PropertyName.DeviceRTSPStream),
+        supportsTalkback: device.hasCommand(CommandName.DeviceStartTalkback),
+        DeviceEnabled: device.hasProperty(PropertyName.DeviceEnabled),
+        DeviceMotionDetection: device.hasProperty(PropertyName.DeviceMotionDetection),
+        DeviceLight: device.hasProperty(PropertyName.DeviceLight),
+        DeviceChimeIndoor: device.hasProperty(PropertyName.DeviceChimeIndoor),
+        disabled: false,
+        properties: device.getProperties(),
+      };
+
+      // Mark device as unsupported if it doesn't match any known accessory type
+      if (!device.isCamera() && !Device.isMotionSensor(devType) && !Device.isEntrySensor(devType) && !Device.isLock(devType)) {
+        d.unsupported = true;
+      }
+
+      if (device.hasProperty(PropertyName.DeviceChargingStatus)) {
+        d.chargingStatus = device.getPropertyValue(PropertyName.DeviceChargingStatus);
+      }
+
+      try {
+        delete d.properties.picture;
+      } catch (error) {
+        this.log.error(error);
+      }
+
+      d.ignored = (this.config['ignoreDevices'] ?? []).includes(d.uniqueId);
+
+      const stationUniqueId = device.getStationSerial();
+      const stationIndex = this.stations.findIndex(station => station.uniqueId === stationUniqueId);
+
+      if (stationIndex !== -1) {
+        if (!this.stations[stationIndex].devices) {
+          this.stations[stationIndex].devices = [];
         }
+        this.stations[stationIndex].devices.push(d);
+      } else {
+        this.log.error('Station not found for device:', d.displayName);
+      }
     }
-}
-// Start the instance of the server with dynamic import
-(async () => {
+
+    // Clear pending queues
+    this.pendingStations = [];
+    this.pendingDevices = [];
+
+    // Always send the final list to the UI, even if empty
     try {
-        // Dynamically import the ESM module
-        const pluginUiUtils = await import('@homebridge/plugin-ui-utils');
-        const HomebridgePluginUiServer = pluginUiUtils.HomebridgePluginUiServer;
-        // Create an instance of HomebridgePluginUiServer
-        const server = new HomebridgePluginUiServer();
-        // Initialize our UiServer with the server instance
-        new UiServer(server);
+      this.storeAccessories();
+    } catch (error) {
+      this.log.error('Error storing accessories:', error);
     }
-    catch (error) {
-        console.error('Failed to initialize server:', error);
+    this.pushEvent('addAccessory', this.stations);
+  }
+
+  storeAccessories() {
+    const dataToStore = { version: LIB_VERSION, storedAt: new Date().toISOString(), stations: this.stations };
+    fs.writeFileSync(this.storedAccessories_file, JSON.stringify(dataToStore));
+  }
+
+  async resetPlugin() {
+    try {
+      fs.rmSync(this.storagePath, { recursive: true, force: true });
+      return { result: 1 };
+    } catch (error) {
+      this.log.error('Could not reset plugin: ' + error);
+      return { result: 0 };
     }
-})();
-//# sourceMappingURL=server.js.map
+  }
+
+  async getLogs() {
+    const files = await fs.promises.readdir(this.storagePath);
+
+    const logFiles = files.filter(file => {
+      return file.endsWith('.log') || file.endsWith('.log.0');
+    });
+
+    const nonEmptyLogFiles = await Promise.all(logFiles.map(async file => {
+      const filePath = path.join(this.storagePath, file);
+      const stats = await fs.promises.stat(filePath);
+      if (stats.size > 0) {
+        return file;
+      }
+      return null;
+    }));
+
+    return nonEmptyLogFiles.filter(file => file !== null);
+  }
+
+  async downloadLogs() {
+    this.pushEvent('downloadLogsProgress', { progress: 10, status: 'Gets non-empty log files' });
+    const finalLogFiles = await this.getLogs();
+
+    this.pushEvent('downloadLogsProgress', { progress: 30, status: 'Add Log Files to Zip' });
+    const zip = new Zip();
+    let numberOfFiles = 0;
+    finalLogFiles.forEach(logFile => {
+      const filePath = path.join(this.storagePath, logFile);
+      zip.addFile(filePath);
+      numberOfFiles++;
+    });
+
+    this.pushEvent('downloadLogsProgress', { progress: 40, status: 'No Log Files Found' });
+    if (numberOfFiles === 0) {
+      throw new Error('No log files were found');
+    }
+
+    try {
+      this.pushEvent('downloadLogsProgress', { progress: 45, status: `Compressing ${numberOfFiles} files` });
+      await zip.archive(this.logZipFilePath);
+
+      this.pushEvent('downloadLogsProgress', { progress: 80, status: 'Reading content' });
+      const fileBuffer = fs.readFileSync(this.logZipFilePath);
+
+      this.pushEvent('downloadLogsProgress', { progress: 90, status: 'Returning zip file' });
+      return fileBuffer;
+    } catch (error) {
+      this.log.error('Error while generating log files: ' + error);
+      throw error;
+    } finally {
+      this.removeCompressedLogs();
+    }
+  }
+
+  removeCompressedLogs() {
+    try {
+      if (fs.existsSync(this.logZipFilePath)) {
+        fs.unlinkSync(this.logZipFilePath);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async getSystemInfo() {
+    const os = await import('os');
+    let homebridgeVersion = 'unknown';
+    try {
+      const hbPkg = require('homebridge/package.json');
+      homebridgeVersion = hbPkg.version;
+    } catch {
+      // Homebridge package not resolvable from here
+    }
+
+    let deviceSummary = [];
+    try {
+      if (fs.existsSync(this.storedAccessories_file)) {
+        const storedData = JSON.parse(fs.readFileSync(this.storedAccessories_file, 'utf-8'));
+        if (storedData.stations) {
+          deviceSummary = storedData.stations.map(s => ({
+            name: s.displayName,
+            type: s.typename,
+            devices: (s.devices || []).map(d => ({
+              name: d.displayName,
+              type: d.typename,
+            })),
+          }));
+        }
+      }
+    } catch {
+      // ignore
+    }
+
+    return {
+      pluginVersion: LIB_VERSION,
+      eufyClientVersion: libVersion,
+      homebridgeVersion,
+      nodeVersion: process.version,
+      os: `${os.type()} ${os.release()} (${os.arch()})`,
+      devices: deviceSummary,
+    };
+  }
+}
+
+(() => new UiServer())();