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

package/dist/platform.js

@@ -1,26 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EufySecurityPlatform = void 0;
-const settings_1 = require("./settings");
-const config_1 = require("./config");
-const StationAccessory_1 = require("./accessories/StationAccessory");
-const EntrySensorAccessory_1 = require("./accessories/EntrySensorAccessory");
-const MotionSensorAccessory_1 = require("./accessories/MotionSensorAccessory");
-const CameraAccessory_1 = require("./accessories/CameraAccessory");
-const LockAccessory_1 = require("./accessories/LockAccessory");
-const AutoSyncStationAccessory_1 = require("./accessories/AutoSyncStationAccessory");
-const eufy_security_client_1 = require("eufy-security-client");
-const rotating_file_stream_1 = require("rotating-file-stream");
-const fs_1 = __importDefault(require("fs"));
-const node_os_1 = __importDefault(require("node:os"));
-const node_process_1 = require("node:process");
-const node_fs_1 = require("node:fs");
-const utils_1 = require("./utils/utils");
-const version_1 = require("./version");
-class EufySecurityPlatform {
+import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js';
+import { DEFAULT_CONFIG_VALUES } from './config.js';
+import { StationAccessory } from './accessories/StationAccessory.js';
+import { EntrySensorAccessory } from './accessories/EntrySensorAccessory.js';
+import { MotionSensorAccessory } from './accessories/MotionSensorAccessory.js';
+import { CameraAccessory } from './accessories/CameraAccessory.js';
+import { LockAccessory } from './accessories/LockAccessory.js';
+import { AutoSyncStationAccessory } from './accessories/AutoSyncStationAccessory.js';
+import { EufySecurity, Device, DeviceType, UserType, libVersion, LogLevel, } from 'eufy-security-client';
+import { createStream } from 'rotating-file-stream';
+import fs from 'fs';
+import os from 'node:os';
+import { platform } from 'node:process';
+import { readFileSync } from 'node:fs';
+import { initLog, log, tsLogger, ffmpegLogger, HAP } from './utils/utils.js';
+import { LIB_VERSION } from './version.js';
+export class EufySecurityPlatform {
     config;
     api;
     eufyClient = {};
@@ -37,8 +31,8 @@ class EufySecurityPlatform {
         this.config = config;
         this.api = api;
         this.eufyPath = this.api.user.storagePath() + '/eufysecurity';
-        if (!fs_1.default.existsSync(this.eufyPath)) {
-            fs_1.default.mkdirSync(this.eufyPath);
+        if (!fs.existsSync(this.eufyPath)) {
+            fs.mkdirSync(this.eufyPath);
         }
         // Identify what we're running on so we can take advantage of hardware-specific features.
         this.probeHwOs();
@@ -56,10 +50,10 @@ class EufySecurityPlatform {
         // Assigns the provided config object to this.config, casting it to the EufySecurityPlatformConfig type.
         this.config = config;
         // Iterates over each key in the DEFAULT_CONFIG_VALUES object.
-        Object.keys(config_1.DEFAULT_CONFIG_VALUES).forEach(key => {
+        Object.keys(DEFAULT_CONFIG_VALUES).forEach(key => {
             // Checks if the corresponding property in the config object is undefined or null.
             // If it is, assigns the default value from DEFAULT_CONFIG_VALUES to it.
-            this.config[key] ??= config_1.DEFAULT_CONFIG_VALUES[key];
+            this.config[key] ??= DEFAULT_CONFIG_VALUES[key];
         });
         // List of properties that need to be parsed as numeric values
         const numericProperties = [
@@ -139,12 +133,12 @@ class EufySecurityPlatform {
         };
         // Modify log options if detailed logging is enabled
         if (this.config.enableDetailedLogging) {
-            logOptions.name = `[EufySecurity-${version_1.LIB_VERSION}]`; // Modify logger name with plugin version
+            logOptions.name = `[EufySecurity-${LIB_VERSION}]`; // Modify logger name with plugin version
             logOptions.prettyLogTemplate = '[{{mm}}/{{dd}}/{{yyyy}} {{hh}}:{{MM}}:{{ss}}]\t{{name}}\t{{logLevelName}}\t[{{fileNameWithLine}}]\t'; // Modify log template
             logOptions.minLevel = 2; // Adjust minimum log level
         }
         // Initialize the global logger with the configured options
-        (0, utils_1.init_log)(logOptions);
+        initLog(logOptions);
         // Configures log streams for various log files
         this.configureLogStreams();
     }
@@ -154,19 +148,19 @@ class EufySecurityPlatform {
     configureLogStreams() {
         // Log a message if log file storage will be omitted
         if (this.config.omitLogFiles) {
-            utils_1.log.info('log file storage will be omitted.');
+            log.info('log file storage will be omitted.');
             return;
         }
         // Log streams configuration
         const logStreams = [
-            { name: 'eufy-security.log', logger: utils_1.log },
-            { name: 'ffmpeg.log', logger: utils_1.ffmpegLogger },
-            { name: 'eufy-lib.log', logger: utils_1.tsLogger },
+            { name: 'eufy-security.log', logger: log },
+            { name: 'ffmpeg.log', logger: ffmpegLogger },
+            { name: 'eufy-lib.log', logger: tsLogger },
         ];
         // Iterate over log streams
         for (const { name, logger } of logStreams) {
             // Create a log stream with specific configurations
-            const logStream = (0, rotating_file_stream_1.createStream)(name, {
+            const logStream = createStream(name, {
                 path: this.eufyPath, // Log file path
                 interval: '1d', // Log rotation interval (1 day)
                 rotate: 3, // Number of rotated log files to keep
@@ -197,18 +191,18 @@ class EufySecurityPlatform {
         // Start off with a generic identifier.
         this._hostSystem = 'generic';
         // Take a look at the platform we're on for an initial hint of what we are.
-        switch (node_process_1.platform) {
+        switch (platform) {
             // The beloved macOS.
             case 'darwin':
                 // For macOS, we check the CPU model to determine if it's an Apple CPU or an Intel CPU.
-                this._hostSystem = 'macOS.' + (node_os_1.default.cpus()[0].model.includes('Apple') ? 'Apple' : 'Intel');
+                this._hostSystem = 'macOS.' + (os.cpus()[0].model.includes('Apple') ? 'Apple' : 'Intel');
                 break;
             // The indomitable Linux.
             case 'linux':
                 // Let's further see if we're a small, but scrappy, Raspberry Pi.
                 try {
                     // As of the 4.9 kernel, Raspberry Pi prefers to be identified using this method and has deprecated cpuinfo.
-                    const systemId = (0, node_fs_1.readFileSync)('/sys/firmware/devicetree/base/model', { encoding: 'utf8' });
+                    const systemId = readFileSync('/sys/firmware/devicetree/base/model', { encoding: 'utf8' });
                     // Check if it's a Raspberry Pi 4.
                     if (/Raspberry Pi (Compute Module )?4/.test(systemId)) {
                         // If it's a Pi 4, we identify the system as running Raspbian.
@@ -231,12 +225,11 @@ class EufySecurityPlatform {
         return this._hostSystem;
     }
     initSetup() {
-        utils_1.log.debug('warning: planned changes, see https://github.com/homebridge-eufy-security/plugin/issues/1');
-        utils_1.log.debug('plugin data store:', this.eufyPath);
-        utils_1.log.debug('OS is', this.hostSystem);
-        utils_1.log.debug('Using bropats @homebridge-eufy-security/eufy-security-client library in version ', eufy_security_client_1.libVersion);
+        log.debug('plugin data store:', this.eufyPath);
+        log.debug('OS is', this.hostSystem);
+        log.debug('Using bropats @homebridge-eufy-security/eufy-security-client library in version ', libVersion);
         // Log the final configuration object for debugging purposes
-        utils_1.log.debug('The config is:', this.config);
+        log.debug('The config is:', this.config);
         const eufyConfig = {
             username: this.config.username,
             password: this.config.password,
@@ -249,7 +242,7 @@ class EufySecurityPlatform {
             enableEmbeddedPKCS1Support: this.config.enableEmbeddedPKCS1Support,
             eventDurationSeconds: 10,
             logging: {
-                level: (this.config.enableDetailedLogging) ? eufy_security_client_1.LogLevel.Debug : eufy_security_client_1.LogLevel.Info,
+                level: (this.config.enableDetailedLogging) ? LogLevel.Debug : LogLevel.Info,
             },
         };
         this.api.on("didFinishLaunching" /* APIEvent.DID_FINISH_LAUNCHING */, async () => {
@@ -258,33 +251,36 @@ class EufySecurityPlatform {
         this.api.on("shutdown" /* APIEvent.SHUTDOWN */, async () => {
             await this.pluginShutdown();
         });
-        utils_1.log.debug('Finished booting!');
+        log.debug('Finished booting!');
     }
     async pluginSetup(eufyConfig) {
         try {
-            this.eufyClient = await eufy_security_client_1.EufySecurity.initialize(eufyConfig, (this.config.enableDetailedLogging) ? utils_1.tsLogger : undefined);
+            this.eufyClient = await EufySecurity.initialize(eufyConfig, (this.config.enableDetailedLogging) ? tsLogger : undefined);
+            // Each camera adds listeners (livestream, talkback) on top of the base ones.
+            // Raise limit to prevent MaxListenersExceededWarning in Node 22+.
+            this.eufyClient.setMaxListeners(30);
             this.eufyClient.on('station added', this.stationAdded.bind(this));
             this.eufyClient.on('station removed', this.stationRemoved.bind(this));
             this.eufyClient.on('device added', this.deviceAdded.bind(this));
             this.eufyClient.on('device removed', this.deviceRemoved.bind(this));
             this.eufyClient.on('push connect', () => {
-                utils_1.log.debug('Push Connected!');
+                log.debug('Push Connected!');
             });
             this.eufyClient.on('push close', () => {
-                utils_1.log.debug('Push Closed!');
+                log.debug('Push Closed!');
             });
             this.eufyClient.on('connect', () => {
-                utils_1.log.debug('Connected!');
+                log.debug('Connected!');
             });
             this.eufyClient.on('close', () => {
-                utils_1.log.debug('Closed!');
+                log.debug('Closed!');
             });
             this.eufyClient.on('connection error', async (error) => {
-                utils_1.log.debug(`Error: ${error}`);
+                log.debug(`Error: ${error}`);
                 await this.pluginShutdown();
             });
             this.eufyClient.once('captcha request', async () => {
-                utils_1.log.error(`
+                log.error(`
         ***************************
         ***** WARNING MESSAGE *****
         ***************************
@@ -293,13 +289,13 @@ class EufySecurityPlatform {
         Please abstain from any activities until this period elapses...
         Should your issue persist beyond this timeframe, you may need to consider setting up a new account.
         For more detailed instructions, please consult:
-        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
         ***************************
         `);
                 await this.pluginShutdown();
             });
             this.eufyClient.on('tfa request', async () => {
-                utils_1.log.error(`
+                log.error(`
         ***************************
         ***** WARNING MESSAGE *****
         ***************************
@@ -308,28 +304,29 @@ class EufySecurityPlatform {
         Kindly refrain from making any further attempts during this period...
         If your concern remains unresolved after 24 hours, you may need to consider creating a new account.
         For additional information, refer to:
-        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
         ***************************
         `);
                 await this.pluginShutdown();
             });
         }
         catch (e) {
-            utils_1.log.error(`Error while setup : ${e}`);
-            utils_1.log.error('Not connected can\'t continue!');
+            log.error(`Error while setup : ${e}`);
+            log.error('Not connected can\'t continue!');
             return;
         }
         try {
             await this.eufyClient.connect();
-            utils_1.log.debug('EufyClient connected ' + this.eufyClient.isConnected());
+            log.debug('EufyClient connected ' + this.eufyClient.isConnected());
         }
         catch (e) {
-            utils_1.log.error(`Error authenticating Eufy: ${e}`);
+            log.error(`Error authenticating Eufy: ${e}`);
         }
         if (!this.eufyClient.isConnected()) {
-            utils_1.log.error('Not connected can\'t continue!');
+            log.error('Not connected can\'t continue!');
             return;
         }
+        log.info('Connected to Eufy. Discovering stations and devices... This may take up to 45 seconds.');
         // give the connection 45 seconds to discover all devices
         // then process pending stations and devices, and clean old accessories after that
         this.cleanCachedAccessoriesTimeout = setTimeout(async () => {
@@ -338,10 +335,10 @@ class EufySecurityPlatform {
         }, 45 * 1000);
         if (this.config.CameraMaxLivestreamDuration > 86400) {
             this.config.CameraMaxLivestreamDuration = 86400;
-            utils_1.log.warn('Your maximum livestream duration value is too large. Since this can cause problems it was reset to 86400 seconds (1 day maximum).');
+            log.warn('Your maximum livestream duration value is too large. Since this can cause problems it was reset to 86400 seconds (1 day maximum).');
         }
         this.eufyClient.setCameraMaxLivestreamDuration(this.config.CameraMaxLivestreamDuration);
-        utils_1.log.debug(`CameraMaxLivestreamDuration: ${this.eufyClient.getCameraMaxLivestreamDuration()}`);
+        log.debug(`CameraMaxLivestreamDuration: ${this.eufyClient.getCameraMaxLivestreamDuration()}`);
     }
     /**
      * Generates a UUID based on the given identifier and station flag.
@@ -353,28 +350,11 @@ class EufySecurityPlatform {
         // Add prefix 's_' if it's a station identifier, otherwise, no prefix.
         const prefix = isStation ? 's1_' : 'd1_';
         // Generate UUID based on the prefix + identifier.
-        return utils_1.HAP.uuid.generate(prefix + identifier);
+        return HAP.uuid.generate(prefix + identifier);
     }
     async delay(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
-    /**
-     * Checks if a device type is supported by the plugin.
-     * A device is considered supported if it matches at least one handler type:
-     * - Motion Sensor
-     * - Entry Sensor
-     * - Lock
-     * - Camera
-     *
-     * @param deviceType The device type to check
-     * @returns true if the device type is supported, false otherwise
-     */
-    isSupportedDevice(deviceType) {
-        return (eufy_security_client_1.Device.isMotionSensor(deviceType) ||
-            eufy_security_client_1.Device.isEntrySensor(deviceType) ||
-            eufy_security_client_1.Device.isLock(deviceType) ||
-            eufy_security_client_1.Device.isCamera(deviceType));
-    }
     /**
      * Defines an accessory for a device or station.
      *
@@ -392,7 +372,7 @@ class EufySecurityPlatform {
             this.accessories.splice(this.accessories.indexOf(cachedAccessory), 1);
         }
         // Determine if the device is a camera
-        const isCamera = (deviceContainer.eufyDevice instanceof eufy_security_client_1.Device)
+        const isCamera = (deviceContainer.eufyDevice instanceof Device)
             ? deviceContainer.eufyDevice.isCamera()
             : false;
         // Create a new accessory if not cached, otherwise use the cached one
@@ -426,7 +406,7 @@ class EufySecurityPlatform {
                 // Remove station or device accessories created prior to plugin upgrade,
                 // which may have been subject to removal due to newly introduced logic.
                 if (isExist) {
-                    this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+                    this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
                 }
                 throw error;
             }
@@ -437,100 +417,125 @@ class EufySecurityPlatform {
             // Update or register the accessory with the platform
             if (isExist) {
                 this.api.updatePlatformAccessories([accessory]);
-                utils_1.log.info(`Updating existing accessory: ${accessory.displayName}`);
+                log.info(`Updating existing accessory: ${accessory.displayName}`);
             }
             else {
-                this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
-                utils_1.log.info(`Registering new accessory: ${accessory.displayName}`);
+                this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+                log.info(`Registering new accessory: ${accessory.displayName}`);
             }
         }
         catch (error) {
             // Log any errors that occur during accessory addition or update
-            utils_1.log.error(`Error in ${isStation ? 'stationAdded' : 'deviceAdded'}:`, error);
+            log.error(`Error in ${isStation ? 'stationAdded' : 'deviceAdded'}:`, error);
         }
     }
     async stationAdded(station) {
         try {
             if (this.config.ignoreStations.includes(station.getSerial())) {
-                utils_1.log.debug(`${station.getName()}: Station ignored`);
+                log.debug(`${station.getName()}: Station ignored`);
                 return;
             }
             const rawStation = station.getRawStation();
-            if (rawStation.member.member_type !== eufy_security_client_1.UserType.ADMIN) {
+            if (rawStation.member.member_type !== UserType.ADMIN) {
                 await this.pluginShutdown();
-                utils_1.log.error(`
+                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;
             }
             // Store station for batch processing later
             this.pendingStations.push(station);
-            utils_1.log.debug(`${station.getName()}: Station queued for processing`);
+            log.debug(`${station.getName()}: Station queued for processing`);
         }
         catch (error) {
-            utils_1.log.error(`Error in stationAdded:, ${error}`);
+            log.error(`Error in stationAdded:, ${error}`);
         }
     }
     async deviceAdded(device) {
         try {
             if (this.config.ignoreDevices.includes(device.getSerial())) {
-                utils_1.log.debug(`${device.getName()}: Device ignored`);
+                log.debug(`${device.getName()}: Device ignored`);
                 return;
             }
             // Check if the device is a keypad and ignore it from the start
             const deviceType = device.getDeviceType();
-            if (eufy_security_client_1.Device.isKeyPad(deviceType)) {
-                utils_1.log.warn(`${device.getName()}: The keypad is ignored as it serves no purpose in this plugin. You can ignore this message.`);
+            if (Device.isKeyPad(deviceType)) {
+                log.warn(`${device.getName()}: The keypad is ignored as it serves no purpose in this plugin. You can ignore this message.`);
                 return;
             }
             // Store device for batch processing later
             this.pendingDevices.push(device);
-            utils_1.log.debug(`${device.getName()}: Device queued for processing`);
+            log.debug(`${device.getName()}: Device queued for processing`);
         }
         catch (error) {
-            utils_1.log.error(`Error in deviceAdded: ${error}`);
+            log.error(`Error in deviceAdded: ${error}`);
         }
     }
     async stationRemoved(station) {
         const serial = station.getSerial();
-        utils_1.log.debug(`A device has been removed: ${serial}`);
+        log.debug(`A device has been removed: ${serial}`);
     }
     async deviceRemoved(device) {
         const serial = device.getSerial();
-        utils_1.log.debug(`A device has been removed: ${serial}`);
+        log.debug(`A device has been removed: ${serial}`);
     }
     /**
      * Processes pending stations and devices in batch.
      * Only creates station entities if:
      * 1. It's a real HomeBase (DeviceType.STATION) OR
-     * 2. It has at least one supported device attached
+     * 2. It has at least one device attached
      *
-     * Devices are only created if their type is supported.
+     * All discovered devices are processed since they are already verified by bropat/eufy-security-client.
      */
     async processPendingDevices() {
-        utils_1.log.debug(`Processing ${this.pendingStations.length} stations and ${this.pendingDevices.length} devices`);
-        // Build set of stations that have at least one supported device
-        const stationsWithSupportedDevices = new Set();
+        log.debug(`[PROCESSING START] Processing ${this.pendingStations.length} stations and ${this.pendingDevices.length} devices`);
+        if (this.pendingStations.length === 0 || this.pendingDevices.length === 0) {
+            log.warn(`[DISCOVERY WARNING] Discovery finished with ${this.pendingStations.length} station(s) and ${this.pendingDevices.length} devices(s). ` +
+                'If this is unexpected, please verify your Eufy account has devices and the credentials used are for a guest admin account.');
+        }
+        // Build set of stations that have at least one device
+        const stationsWithDevices = new Set();
+        // Create all queued devices (they are already verified by bropat/eufy-security-client)
+        log.debug(`[DEVICES PROCESSING] Starting to process ${this.pendingDevices.length} devices`);
         for (const device of this.pendingDevices) {
-            if (this.isSupportedDevice(device.getDeviceType())) {
-                stationsWithSupportedDevices.add(device.getStationSerial());
+            stationsWithDevices.add(device.getStationSerial());
+            try {
+                const deviceType = device.getDeviceType();
+                const deviceContainer = {
+                    deviceIdentifier: {
+                        uniqueId: device.getSerial(),
+                        displayName: 'DEVICE ' + device.getName().replace(/[^a-zA-Z0-9]/g, ''),
+                        type: deviceType,
+                    },
+                    eufyDevice: device,
+                };
+                log.debug(`[DEVICE] Processing: ${deviceContainer.deviceIdentifier.displayName}`);
+                await this.addOrUpdateAccessory(deviceContainer, false);
+                log.debug(`[DEVICE] Completed: ${deviceContainer.deviceIdentifier.displayName}`);
+            }
+            catch (error) {
+                log.error(`[DEVICE ERROR] Error processing device "${device.getName()}": ${error}`);
             }
         }
+        log.debug(`[DEVICES COMPLETE] All ${this.pendingDevices.length} devices processed`);
         // Create queued stations that should be created
+        log.debug(`[STATIONS PROCESSING] Starting to process ${this.pendingStations.length} stations`);
+        let stationsSkipped = 0;
         for (const station of this.pendingStations) {
             const stationType = station.getDeviceType();
             const stationSerial = station.getSerial();
-            // Create if: it's a real HomeBase OR it has supported devices
-            const shouldCreate = stationType === eufy_security_client_1.DeviceType.STATION ||
-                stationsWithSupportedDevices.has(stationSerial);
+            // Create if: it's a real HomeBase OR it has devices
+            const shouldCreate = stationType === DeviceType.STATION ||
+                stationsWithDevices.has(stationSerial);
             if (!shouldCreate) {
-                utils_1.log.warn(`Station "${station.getName()}" has no supported devices and will be skipped`);
+                stationsSkipped++;
+                log.debug(`[STATION SKIP] "${station.getName()}" has no devices and will be skipped`);
                 continue;
             }
             try {
@@ -542,43 +547,19 @@ class EufySecurityPlatform {
                     },
                     eufyDevice: station,
                 };
-                await this.delay(settings_1.STATION_INIT_DELAY);
-                utils_1.log.debug(`${deviceContainer.deviceIdentifier.displayName} pre-caching complete`);
+                log.debug(`[STATION] Processing: ${deviceContainer.deviceIdentifier.displayName}`);
                 await this.addOrUpdateAccessory(deviceContainer, true);
+                log.debug(`[STATION] Completed: ${deviceContainer.deviceIdentifier.displayName}`);
             }
             catch (error) {
-                utils_1.log.error(`Error processing station "${station.getName()}": ${error}`);
-            }
-        }
-        // Create queued devices that are supported
-        for (const device of this.pendingDevices) {
-            const deviceType = device.getDeviceType();
-            // Skip unsupported devices
-            if (!this.isSupportedDevice(deviceType)) {
-                utils_1.log.debug(`${device.getName()}: Device type ${deviceType} not supported, skipping`);
-                continue;
-            }
-            try {
-                const deviceContainer = {
-                    deviceIdentifier: {
-                        uniqueId: device.getSerial(),
-                        displayName: 'DEVICE ' + device.getName().replace(/[^a-zA-Z0-9]/g, ''),
-                        type: deviceType,
-                    },
-                    eufyDevice: device,
-                };
-                await this.delay(settings_1.DEVICE_INIT_DELAY);
-                utils_1.log.debug(`${deviceContainer.deviceIdentifier.displayName} pre-caching complete`);
-                await this.addOrUpdateAccessory(deviceContainer, false);
-            }
-            catch (error) {
-                utils_1.log.error(`Error processing device "${device.getName()}": ${error}`);
+                log.error(`[STATION ERROR] Error processing station "${station.getName()}": ${error}`);
             }
         }
+        log.debug(`[STATIONS COMPLETE] ${this.pendingStations.length - stationsSkipped} stations created, ${stationsSkipped} skipped`);
         // Clear pending queues
         this.pendingStations = [];
         this.pendingDevices = [];
-        utils_1.log.debug('Finished processing pending stations and devices');
+        log.info(`[PROCESSING COMPLETE] All pending devices and stations processed`);
     }
     async pluginShutdown() {
         // Ensure a single shutdown to prevent corruption of the persistent file.
@@ -594,10 +575,10 @@ class EufySecurityPlatform {
             if (this.eufyClient.isConnected()) {
                 this.eufyClient.close();
             }
-            utils_1.log.info('Finished shutdown!');
+            log.info('Finished shutdown!');
         }
         catch (e) {
-            utils_1.log.error(`Error while shutdown: ${e}`);
+            log.error(`Error while shutdown: ${e}`);
         }
     }
     /**
@@ -605,68 +586,67 @@ class EufySecurityPlatform {
      * It should be used to setup event handlers for characteristics and update respective values.
      */
     configureAccessory(accessory) {
-        utils_1.log.debug(`Loading accessory from cache: ${accessory.displayName}`);
+        log.debug(`Loading accessory from cache: ${accessory.displayName}`);
         // add the restored accessory to the accessories cache so we can track if it has already been registered
         this.accessories.push(accessory);
     }
     cleanCachedAccessories() {
         if (this.config.cleanCache) {
-            utils_1.log.debug('Looking for old cached accessories that seem to be outdated...');
+            log.debug('Looking for old cached accessories that seem to be outdated...');
             let num = 0;
             const staleAccessories = this.accessories.filter((item) => {
                 return this.activeAccessoryIds.indexOf(item.UUID) === -1;
             });
             staleAccessories.forEach((staleAccessory) => {
-                utils_1.log.info(`Removing cached accessory ${staleAccessory.UUID} ${staleAccessory.displayName}`);
+                log.info(`Removing cached accessory ${staleAccessory.UUID} ${staleAccessory.displayName}`);
                 num++;
-                this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [staleAccessory]);
+                this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [staleAccessory]);
             });
             if (num > 0) {
-                utils_1.log.info('Removed ' + num + ' cached accessories');
+                log.info('Removed ' + num + ' cached accessories');
             }
             else {
-                utils_1.log.info('No outdated cached accessories found.');
+                log.info('No outdated cached accessories found.');
             }
         }
     }
     register_station(accessory, container) {
-        utils_1.log.debug(accessory.displayName + ' UUID:' + accessory.UUID);
+        log.debug(accessory.displayName + ' UUID:' + accessory.UUID);
         const type = container.deviceIdentifier.type;
         const station = container.eufyDevice;
-        if (type !== eufy_security_client_1.DeviceType.STATION) {
+        if (type !== DeviceType.STATION) {
             // Standalone Lock or Doorbell doesn't have Security Control
-            if (eufy_security_client_1.Device.isDoorbell(type) || eufy_security_client_1.Device.isLock(type)) {
+            if (Device.isDoorbell(type) || Device.isLock(type)) {
                 throw new Error(`looks station but it's not could imply some errors! Type: ${type}. You can ignore this message.`);
             }
         }
         if (this.config.autoSyncStation) {
-            new AutoSyncStationAccessory_1.AutoSyncStationAccessory(this, accessory, station);
+            new AutoSyncStationAccessory(this, accessory, station);
         }
         else {
-            new StationAccessory_1.StationAccessory(this, accessory, station);
+            new StationAccessory(this, accessory, station);
         }
     }
     register_device(accessory, container) {
-        utils_1.log.debug(accessory.displayName + ' UUID:' + accessory.UUID);
+        log.debug(accessory.displayName + ' UUID:' + accessory.UUID);
         const device = container.eufyDevice;
         const type = container.deviceIdentifier.type;
-        if (eufy_security_client_1.Device.isMotionSensor(type)) {
-            utils_1.log.debug(accessory.displayName + ' isMotionSensor!');
-            new MotionSensorAccessory_1.MotionSensorAccessory(this, accessory, device);
+        if (Device.isMotionSensor(type)) {
+            log.debug(accessory.displayName + ' isMotionSensor!');
+            new MotionSensorAccessory(this, accessory, device);
         }
-        if (eufy_security_client_1.Device.isEntrySensor(type)) {
-            utils_1.log.debug(accessory.displayName + ' isEntrySensor!');
-            new EntrySensorAccessory_1.EntrySensorAccessory(this, accessory, device);
+        if (Device.isEntrySensor(type)) {
+            log.debug(accessory.displayName + ' isEntrySensor!');
+            new EntrySensorAccessory(this, accessory, device);
         }
-        if (eufy_security_client_1.Device.isLock(type)) {
-            utils_1.log.debug(accessory.displayName + ' isLock!');
-            new LockAccessory_1.LockAccessory(this, accessory, device);
+        if (Device.isLock(type)) {
+            log.debug(accessory.displayName + ' isLock!');
+            new LockAccessory(this, accessory, device);
         }
-        if (eufy_security_client_1.Device.isCamera(type)) {
-            utils_1.log.debug(accessory.displayName + ' isCamera!');
-            new CameraAccessory_1.CameraAccessory(this, accessory, device);
+        if (Device.isCamera(type)) {
+            log.debug(accessory.displayName + ' isCamera!');
+            new CameraAccessory(this, accessory, device);
         }
     }
 }
-exports.EufySecurityPlatform = EufySecurityPlatform;
 //# sourceMappingURL=platform.js.map