homebridge-nest-accfactory 0.2.9 → 0.3.0

package/dist/HomeKitDevice.js

@@ -27,15 +27,16 @@
 // HomeKitDevice.HOMEKITHISTORY
 // HomeKitDevice.PLUGIN_NAME
 // HomeKitDevice.PLATFORM_NAME
+// HomeKitDevice.TYPE
+// HomeKitDevice.VERSION
 //
 // The following functions should be overriden in your class which extends this
 //
-// HomeKitDevice.addServices()
-// HomeKitDevice.removeServices()
-// HomeKitDevice.updateServices(deviceData)
-// HomeKitDevice.messageServices(type, message)
+// HomeKitDevice.setupDevice()
+// HomeKitDevice.removeDevice()
+// HomeKitDevice.updateDevice(deviceData)
+// HomeKitDevice.messageDevice(type, message)
 //
-// Code version 8/10/2024
 // Mark Hulskamp
 'use strict';
 
@@ -43,75 +44,76 @@
 import crypto from 'crypto';
 import EventEmitter from 'node:events';
 
+// Define constants
+const HK_PIN_3_2_3 = /^\d{3}-\d{2}-\d{3}$/;
+const HK_PIN_4_4 = /^\d{4}-\d{4}$/;
+const MAC_ADDR = /^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$/;
+const LOGLEVELS = {
+  info: 'info',
+  success: 'success',
+  warn: 'warn',
+  error: 'error',
+  debug: 'debug',
+};
+
 // Define our HomeKit device class
-export default class HomeKitDevice {
-  static ADD = 'HomeKitDevice.add'; // Device add message
+class HomeKitDevice {
   static UPDATE = 'HomeKitDevice.update'; // Device update message
   static REMOVE = 'HomeKitDevice.remove'; // Device remove message
   static SET = 'HomeKitDevice.set'; // Device set property message
   static GET = 'HomeKitDevice.get'; // Device get property message
-  static PLUGIN_NAME = undefined; // Homebridge plugin name (override)
-  static PLATFORM_NAME = undefined; // Homebridge platform name (override)
-  static HISTORY = undefined; // HomeKit History object (override)
+
+  // Override this in the class which extends
+  static PLUGIN_NAME = undefined; // Homebridge plugin name
+  static PLATFORM_NAME = undefined; // Homebridge platform name
+  static HISTORY = undefined; // HomeKit History object
+  static TYPE = 'base'; // String naming type of device
+  static VERSION = '2025.06.12'; // Code version
 
   deviceData = {}; // The devices data we store
   historyService = undefined; // HomeKit history service
-  accessory = undefined; // Accessory service for this device
-  hap = undefined; // HomeKit Accessory Protocol API stub
+  accessory = undefined; // HomeKit accessory service for this device
+  hap = undefined; // HomeKit Accessory Protocol (HAP) API stub
   log = undefined; // Logging function object
   uuid = undefined; // UUID for this instance
 
   // Internal data only for this class
   #platform = undefined; // Homebridge platform api
   #eventEmitter = undefined; // Event emitter to use for comms
+  #postSetupDetails = []; // Use for extra output details once a device has been setup
 
   constructor(accessory, api, log, eventEmitter, deviceData) {
     // Validate the passed in logging object. We are expecting certain functions to be present
-    if (
-      typeof log?.info === 'function' &&
-      typeof log?.success === 'function' &&
-      typeof log?.warn === 'function' &&
-      typeof log?.error === 'function' &&
-      typeof log?.debug === 'function'
-    ) {
+    if (Object.keys(LOGLEVELS).every((fn) => typeof log?.[fn] === 'function')) {
       this.log = log;
     }
 
-    // Workout if we're running under HomeBridge or HAP-NodeJS library
+    // Workout if we're running under Homebridge or HAP-NodeJS library
     if (isNaN(api?.version) === false && typeof api?.hap === 'object' && api?.HAPLibraryVersion === undefined) {
-      // We have the HomeBridge version number and hap API object
+      // We have the Homebridge version number and hap API object
       this.hap = api.hap;
       this.#platform = api;
 
-      this?.log?.debug && this.log.debug('HomeKitDevice module using Homebridge backend for "%s"', deviceData?.description);
+      this.postSetupDetail('Homebridge backend', LOGLEVELS.debug);
     }
 
     if (typeof api?.HAPLibraryVersion === 'function' && api?.version === undefined && api?.hap === undefined) {
-      // As we're missing the HomeBridge entry points but have the HAP library version
+      // As we're missing the Homebridge entry points but have the HAP library version
       this.hap = api;
 
-      this?.log?.debug && this.log.debug('HomeKitDevice module using HAP-NodeJS library for "%s"', deviceData?.description);
+      this.postSetupDetail('HAP-NodeJS library', LOGLEVELS.debug);
     }
 
     // Generate UUID for this device instance
     // Will either be a random generated one or HAP generated one
     // HAP is based upon defined plugin name and devices serial number
-    this.uuid = crypto.randomUUID();
-    if (
-      typeof HomeKitDevice.PLUGIN_NAME === 'string' &&
-      HomeKitDevice.PLUGIN_NAME !== '' &&
-      typeof deviceData.serialNumber === 'string' &&
-      deviceData.serialNumber !== '' &&
-      typeof this?.hap?.uuid?.generate === 'function'
-    ) {
-      this.uuid = this.hap.uuid.generate(HomeKitDevice.PLUGIN_NAME + '_' + deviceData.serialNumber.toUpperCase());
-    }
+    this.uuid = HomeKitDevice.generateUUID(HomeKitDevice.PLUGIN_NAME, api, deviceData.serialNumber);
 
     // See if we were passed in an existing accessory object or array of accessory objects
-    // Mainly used to restore a HomeBridge cached accessory
+    // Mainly used to restore a Homebridge cached accessory
     if (typeof accessory === 'object' && this.#platform !== undefined) {
       if (Array.isArray(accessory) === true) {
-        this.accessory = accessory.find((accessory) => accessory?.UUID === this.uuid);
+        this.accessory = accessory.find((accessory) => this?.uuid !== undefined && accessory?.UUID === this.uuid);
       }
       if (Array.isArray(accessory) === false && accessory?.UUID === this.uuid) {
         this.accessory = accessory;
@@ -155,17 +157,17 @@ export default class HomeKitDevice {
       this.deviceData.manufacturer === '' ||
       (this.#platform === undefined &&
         (typeof this.deviceData?.hkPairingCode !== 'string' ||
-          (new RegExp(/^([0-9]{3}-[0-9]{2}-[0-9]{3})$/).test(this.deviceData.hkPairingCode) === false &&
-            new RegExp(/^([0-9]{4}-[0-9]{4})$/).test(this.deviceData.hkPairingCode) === false) ||
+          (new RegExp(HK_PIN_3_2_3).test(this.deviceData.hkPairingCode) === false &&
+            new RegExp(HK_PIN_4_4).test(this.deviceData.hkPairingCode) === false) ||
           typeof this.deviceData?.hkUsername !== 'string' ||
-          new RegExp(/^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/).test(this.deviceData.hkUsername) === false))
+          new RegExp(MAC_ADDR).test(this.deviceData.hkUsername) === false))
     ) {
       return;
     }
 
     // If we do not have an existing accessory object, create a new one
     if (this.accessory === undefined && this.#platform !== undefined) {
-      // Create HomeBridge platform accessory
+      // Create Homebridge platform accessory
       this.accessory = new this.#platform.platformAccessory(this.deviceData.description, this.uuid);
       this.#platform.registerPlatformAccessories(HomeKitDevice.PLUGIN_NAME, HomeKitDevice.PLATFORM_NAME, [this.accessory]);
     }
@@ -194,21 +196,29 @@ export default class HomeKitDevice {
       this.historyService = new HomeKitDevice.HISTORY(this.accessory, this.log, this.hap, {});
     }
 
-    if (typeof this.addServices === 'function') {
+    if (typeof this?.setupDevice === 'function') {
       try {
-        let postSetupDetails = await this.addServices();
-        this?.log?.info &&
-          this.log.info('Setup %s %s as "%s"', this.deviceData.manufacturer, this.deviceData.model, this.deviceData.description);
+        this.postSetupDetail('Serial number "%s"', this.deviceData.serialNumber, LOGLEVELS.debug);
+
+        await this.setupDevice();
+
         if (this.historyService?.EveHome !== undefined) {
-          this?.log?.info && this.log.info('  += EveHome support as "%s"', this.historyService.EveHome.evetype);
-        }
-        if (typeof postSetupDetails === 'object') {
-          postSetupDetails.forEach((output) => {
-            this?.log?.info && this.log.info('  += %s', output);
-          });
+          this.postSetupDetail('EveHome support as "%s"', this.historyService.EveHome.evetype);
         }
+
+        this?.log?.info?.('Setup %s %s as "%s"', this.deviceData.manufacturer, this.deviceData.model, this.deviceData.description);
+
+        this.#postSetupDetails.forEach((entry) => {
+          if (typeof entry === 'string') {
+            this?.log?.[LOGLEVELS.info]?.('  += %s', entry);
+          } else if (typeof entry?.message === 'string') {
+            let level =
+              Object.hasOwn(LOGLEVELS, entry?.level) && typeof this?.log?.[entry?.level] === 'function' ? entry.level : LOGLEVELS.info;
+            this?.log?.[level]?.('  += ' + entry.message, ...(Array.isArray(entry?.args) ? entry.args : []));
+          }
+        });
       } catch (error) {
-        this?.log?.error && this.log.error('addServices call for device "%s" failed. Error was', this.deviceData.description, error);
+        this?.log?.error('setupDevice call for device "%s" failed. Error was', this.deviceData.description, error);
       }
     }
 
@@ -223,26 +233,26 @@ export default class HomeKitDevice {
         category: this.accessory.category,
       });
 
-      this?.log?.info && this.log.info('  += Advertising as "%s"', this.accessory.displayName);
-      this?.log?.info && this.log.info('  += Pairing code is "%s"', this.accessory.pincode);
+      this?.log?.info('  += Advertising as "%s"', this.accessory.displayName);
+      this?.log?.info('  += Pairing code is "%s"', this.accessory.pincode);
     }
-
+    this.#postSetupDetails = []; // Dont' need these anymore
     return this.accessory; // Return our HomeKit accessory
   }
 
   remove() {
-    this?.log?.warn && this.log.warn('Device "%s" has been removed', this.deviceData.description);
+    this?.log?.warn?.('Device "%s" has been removed', this.deviceData.description);
 
     if (this.#eventEmitter !== undefined) {
       // Remove listener for 'messages'
       this.#eventEmitter.removeAllListeners(this.uuid);
     }
 
-    if (typeof this.removeServices === 'function') {
+    if (typeof this?.removeDevice === 'function') {
       try {
-        this.removeServices();
+        this.removeDevice();
       } catch (error) {
-        this?.log?.error && this.log.error('removeServices call for device "%s" failed. Error was', this.deviceData.description, error);
+        this?.log?.error('removeDevice call for device "%s" failed. Error was', this.deviceData.description, error);
       }
     }
 
@@ -332,8 +342,8 @@ export default class HomeKitDevice {
           deviceData.serialNumber !== '' &&
           deviceData.serialNumber.toUpperCase() !== this.deviceData.serialNumber.toUpperCase()
         ) {
-          this?.log?.warn && this.log.warn('Serial number on "%s" has changed', deviceData.description);
-          this?.log?.warn && this.log.warn('This may cause the device to become unresponsive in HomeKit');
+          this?.log?.warn?.('Serial number on "%s" has changed', deviceData.description);
+          this?.log?.warn?.('This may cause the device to become unresponsive in HomeKit');
 
           // Update software version on the HomeKit accessory
           informationService.updateCharacteristic(this.hap.Characteristic.SerialNumber, deviceData.serialNumber);
@@ -343,19 +353,19 @@ export default class HomeKitDevice {
       if (typeof deviceData?.online === 'boolean' && deviceData.online !== this.deviceData.online) {
         // Output device online/offline status
         if (deviceData.online === false) {
-          this?.log?.warn && this.log.warn('Device "%s" is offline', deviceData.description);
+          this?.log?.warn?.('Device "%s" is offline', deviceData.description);
         }
 
         if (deviceData.online === true) {
-          this?.log?.success && this.log.success('Device "%s" is online', deviceData.description);
+          this?.log?.success?.('Device "%s" is online', deviceData.description);
         }
       }
 
-      if (typeof this.updateServices === 'function') {
+      if (typeof this?.updateDevice === 'function') {
         try {
-          this.updateServices(deviceData); // Pass updated data on for accessory to process as it needs
+          this.updateDevice(deviceData); // Pass updated data on for accessory to process as it needs
         } catch (error) {
-          this?.log?.error && this.log.error('updateServices call for device "%s" failed. Error was', deviceData.description, error);
+          this?.log?.error('updateDevice call for device "%s" failed. Error was', deviceData.description, error);
         }
       }
 
@@ -397,14 +407,6 @@ export default class HomeKitDevice {
 
   #message(type, message) {
     switch (type) {
-      case HomeKitDevice.ADD: {
-        // Got message for device add
-        if (typeof message?.name === 'string' && isNaN(message?.category) === false && typeof message?.history === 'boolean') {
-          this.add(message.name, Number(message.category), message.history);
-        }
-        break;
-      }
-
       case HomeKitDevice.UPDATE: {
         // Got some device data, so process any updates
         this.update(message, false);
@@ -419,16 +421,131 @@ export default class HomeKitDevice {
 
       default: {
         // This is not a message we know about, so pass onto accessory for it to perform any processing
-        if (typeof this.messageServices === 'function') {
+        if (typeof this?.messageDevice === 'function') {
           try {
-            this.messageServices(type, message);
+            this.messageDevice(type, message);
           } catch (error) {
-            this?.log?.error &&
-              this.log.error('messageServices call for device "%s" failed. Error was', this.deviceData.description, error);
+            this?.log?.error('messageDevice call for device "%s" failed. Error was', this.deviceData.description, error);
           }
         }
         break;
       }
     }
   }
+
+  addHKService(hkServiceType, name = '', subType = undefined) {
+    let service = undefined;
+
+    if (
+      hkServiceType !== undefined &&
+      typeof this?.accessory?.getService === 'function' &&
+      typeof this?.accessory?.getServiceById === 'function' &&
+      typeof this?.accessory?.addService === 'function'
+    ) {
+      if (subType !== undefined) {
+        service = this.accessory.getServiceById(hkServiceType, subType);
+      } else {
+        service = this.accessory.getService(hkServiceType);
+      }
+
+      if (service === undefined) {
+        service = this.accessory.addService(hkServiceType, name, subType);
+      }
+    }
+
+    return service;
+  }
+
+  addHKCharacteristic(hkService, hkCharacteristicType, { props, onSet, onGet } = {}) {
+    let characteristic = undefined;
+
+    if (
+      hkCharacteristicType !== undefined &&
+      typeof hkService?.getCharacteristic === 'function' &&
+      typeof hkService?.testCharacteristic === 'function' &&
+      typeof hkService?.addCharacteristic === 'function' &&
+      typeof hkService?.addOptionalCharacteristic === 'function'
+    ) {
+      if (hkService.testCharacteristic(hkCharacteristicType) === false) {
+        if (
+          Array.isArray(hkService?.optionalCharacteristics) &&
+          hkService.optionalCharacteristics.includes(hkCharacteristicType) &&
+          typeof hkService?.addOptionalCharacteristic === 'function'
+        ) {
+          hkService.addOptionalCharacteristic(hkCharacteristicType);
+        } else {
+          hkService.addCharacteristic(hkCharacteristicType);
+        }
+      }
+
+      characteristic = hkService.getCharacteristic(hkCharacteristicType);
+
+      // Apply optional config
+      if (typeof onSet === 'function') {
+        characteristic.onSet(onSet);
+      }
+      if (typeof onGet === 'function') {
+        characteristic.onGet(onGet);
+      }
+      if (typeof props === 'object' && typeof characteristic.setProps === 'function') {
+        characteristic.setProps(props);
+      }
+    }
+    return characteristic;
+  }
+
+  postSetupDetail(message, ...args) {
+    if (typeof message !== 'string' || message === '') {
+      return;
+    }
+
+    let level = 'info';
+    let availableLevel = Object.keys(LOGLEVELS).find((lvl) => typeof this.log?.[lvl] === 'function') || 'info';
+    let lastArg = args.at(-1);
+
+    if (typeof lastArg === 'string' && Object.hasOwn(LOGLEVELS, lastArg)) {
+      level = lastArg;
+      args = args.slice(0, -1);
+    } else {
+      level = availableLevel;
+    }
+
+    this.#postSetupDetails.push({
+      level,
+      message,
+      args: args.length > 0 ? args : undefined,
+    });
+  }
+
+  static generateUUID(PLUGIN_NAME, api, serialNumber) {
+    let hap = undefined;
+    let uuid = crypto.randomUUID();
+
+    // Workout if we're running under Homebridge or HAP-NodeJS library
+    if (isNaN(api?.version) === false && typeof api?.hap === 'object' && api?.HAPLibraryVersion === undefined) {
+      // We have the Homebridge version number and hap API object
+      hap = api.hap;
+    }
+
+    if (typeof api?.HAPLibraryVersion === 'function' && api?.version === undefined && api?.hap === undefined) {
+      // As we're missing the Homebridge entry points but have the HAP library version
+      hap = api;
+    }
+
+    if (
+      typeof PLUGIN_NAME === 'string' &&
+      PLUGIN_NAME !== '' &&
+      typeof serialNumber === 'string' &&
+      serialNumber !== '' &&
+      typeof hap?.uuid?.generate === 'function'
+    ) {
+      uuid = hap.uuid.generate(PLUGIN_NAME + '_' + serialNumber.toUpperCase());
+    }
+
+    return uuid;
+  }
 }
+
+// Define exports
+export { HK_PIN_3_2_3, HK_PIN_4_4, MAC_ADDR, HomeKitDevice };
+export default HomeKitDevice;

package/dist/HomeKitHistory.js

@@ -10,7 +10,7 @@
 //
 // Credit to https://github.com/simont77/fakegato-history for the work on starting the EveHome comms protocol decoding
 //
-// Version 2025/18/01
+// Version 2025/01/18
 // Mark Hulskamp
 
 // Define nodejs module requirements

package/dist/config.js

@@ -0,0 +1,207 @@
+// Configuration validation and processing
+// Part of homebridge-nest-accfactory
+//
+// Code version 2025.06.12
+// Mark Hulskamp
+'use strict';
+
+// Define nodejs module requirements
+import fs from 'fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import process from 'node:process';
+import child_process from 'node:child_process';
+
+// Define constants
+const FFMPEGVERSION = '6.0.0';
+const AccountType = {
+  Nest: 'Nest',
+  Google: 'Google',
+};
+
+function processConfig(config, log) {
+  let options = (config.options = typeof config?.options === 'object' ? config.options : {});
+
+  options.eveHistory = config.options?.eveHistory === true;
+  options.weather = config.options?.weather === true;
+  options.hksv = config.options?.hksv === true;
+  options.exclude = config.options?.exclude === true;
+
+  options.elevation =
+    isNaN(config.options?.elevation) === false && Number(config.options.elevation) >= 0 && Number(config.options.elevation) <= 8848
+      ? Number(config.options.elevation)
+      : 0;
+
+  // Controls what APIs we use, default is to use both Nest and protobuf APIs
+  options.useNestAPI = config.options?.useNestAPI === true || config.options?.useNestAPI === undefined;
+  options.useGoogleAPI = config.options?.useGoogleAPI === true || config.options?.useGoogleAPI === undefined;
+
+  // Get configuration for max number of concurrent 'live view' streams. For HomeKit Secure Video, this will always be 1
+  options.maxStreams = isNaN(config.options?.maxStreams) === false ? Number(config.options.maxStreams) : 2;
+
+  // Check if a ffmpeg binary exist via a specific path in configuration OR /usr/local/bin
+  options.ffmpeg = {};
+  options.ffmpeg.debug = config.options?.ffmpegDebug === true;
+  options.ffmpeg.binary = path.resolve(
+    typeof config.options?.ffmpegPath === 'string' && config.options.ffmpegPath !== '' ? config.options.ffmpegPath : '/usr/local/bin',
+  );
+
+  // If the path doesn't include 'ffmpeg' on the end, we'll add it here
+  if (options.ffmpeg.binary.endsWith('/ffmpeg') === false) {
+    options.ffmpeg.binary += '/ffmpeg';
+  }
+
+  options.ffmpeg.version = undefined;
+  options.ffmpeg.libspeex = false;
+  options.ffmpeg.libopus = false;
+  options.ffmpeg.libx264 = false;
+  options.ffmpeg.libfdk_aac = false;
+
+  if (fs.existsSync(options.ffmpeg.binary) === false) {
+    // If we flag ffmpegPath as undefined, no video streaming/record support enabled for camers/doorbells
+    log?.warn?.('Specified ffmpeg binary "%s" was not found', options.ffmpeg.binary);
+    log?.warn?.('Stream video/recording from camera/doorbells will be unavailable');
+    options.ffmpeg.binary = undefined;
+  }
+
+  if (fs.existsSync(options.ffmpeg.binary) === true) {
+    let ffmpegProcess = child_process.spawnSync(options.ffmpeg.binary, ['-version'], {
+      env: process.env,
+    });
+
+    if (ffmpegProcess.stdout !== null) {
+      let stdout = ffmpegProcess.stdout.toString();
+
+      // Determine what libraries ffmpeg is compiled with
+      options.ffmpeg.version = stdout.match(/(?:ffmpeg version:(\d+)\.)?(?:(\d+)\.)?(?:(\d+)\.\d+)(.*?)/gim)?.[0];
+      options.ffmpeg.libspeex = stdout.includes('--enable-libspeex') === true;
+      options.ffmpeg.libopus = stdout.includes('--enable-libopus') === true;
+      options.ffmpeg.libx264 = stdout.includes('--enable-libx264') === true;
+      options.ffmpeg.libfdk_aac = stdout.includes('--enable-libfdk-aac') === true;
+
+      let versionTooOld =
+        options.ffmpeg.version?.localeCompare(FFMPEGVERSION, undefined, {
+          numeric: true,
+          sensitivity: 'case',
+          caseFirst: 'upper',
+        }) === -1;
+
+      if (
+        versionTooOld ||
+        options.ffmpeg.libspeex === false ||
+        options.ffmpeg.libopus === false ||
+        options.ffmpeg.libx264 === false ||
+        options.ffmpeg.libfdk_aac === false
+      ) {
+        log?.warn?.('ffmpeg binary "%s" does not meet the minimum support requirements', options.ffmpeg.binary);
+
+        if (versionTooOld) {
+          log?.warn?.('Minimum binary version is "%s", however the installed version is "%s"', FFMPEGVERSION, options.ffmpeg.version);
+          log?.warn?.('Stream video/recording from camera/doorbells will be unavailable');
+          options.ffmpeg.binary = undefined; // No ffmpeg since below min version
+        }
+
+        if (!options.ffmpeg.libspeex && options.ffmpeg.libx264 && options.ffmpeg.libfdk_aac) {
+          log?.warn?.('Missing libspeex in ffmpeg binary, talkback on certain camera/doorbells will be unavailable');
+        }
+
+        if (options.ffmpeg.libx264 && !options.ffmpeg.libfdk_aac && !options.ffmpeg.libopus) {
+          log?.warn?.('Missing libfdk_aac and libopus in ffmpeg binary, audio from camera/doorbells will be unavailable');
+        }
+
+        if (options.ffmpeg.libx264 && !options.ffmpeg.libfdk_aac) {
+          log?.warn?.('Missing libfdk_aac in ffmpeg binary, audio from camera/doorbells will be unavailable');
+        }
+
+        if (options.ffmpeg.libx264 && options.ffmpeg.libfdk_aac && !options.ffmpeg.libopus) {
+          log?.warn?.('Missing libopus in ffmpeg binary, audio (including talkback) from certain camera/doorbells will be unavailable');
+        }
+
+        if (!options.ffmpeg.libx264) {
+          log?.warn?.('Missing libx264 in ffmpeg binary, stream video/recording from camera/doorbells will be unavailable');
+          options.ffmpeg.binary = undefined; // No ffmpeg since we do not have all the required libraries
+        }
+      }
+    }
+  }
+
+  if (options.ffmpeg.binary !== undefined) {
+    log?.success?.('Found valid ffmpeg binary in %s', options.ffmpeg.binary);
+  }
+
+  // Process per device configuration(s)
+  if (config?.devices === undefined) {
+    config.devices = [];
+  }
+
+  if (config?.devices !== undefined && Array.isArray(config.devices) === false) {
+    // If the devices section is a JSON oject keyed by the devices serial number, convert to devices array object
+    let newDeviceArray = [];
+    for (const [serialNumber, props] of Object.entries(config.devices)) {
+      newDeviceArray.push({
+        serialNumber,
+        ...props,
+      });
+    }
+    config.devices = newDeviceArray;
+
+    // Alert user to changed configuration for them to update config
+    log?.warn?.('');
+    log?.warn?.('NOTICE');
+    log?.warn?.('> The per device configuration contains legacy options. Please review the readme at the link below');
+    log?.warn?.('> Consider updating your configuration file as the mapping from legacy to current per device configuration maybe removed');
+    log?.warn?.('> https://github.com/n0rt0nthec4t/homebridge-nest-accfactory/blob/main/src/README.md');
+    log?.warn?.('');
+  }
+
+  return config;
+}
+
+function buildConnections(config) {
+  let connections = {};
+
+  Object.keys(config).forEach((key) => {
+    let section = config[key];
+
+    if (typeof section?.access_token === 'string' && section.access_token !== '') {
+      let fieldTest = section?.fieldTest === true;
+      connections[crypto.randomUUID()] = {
+        name: key,
+        type: AccountType.Nest,
+        authorised: false,
+        access_token: section.access_token,
+        fieldTest,
+        referer: fieldTest ? 'home.ft.nest.com' : 'home.nest.com',
+        restAPIHost: fieldTest ? 'home.ft.nest.com' : 'home.nest.com',
+        cameraAPIHost: fieldTest ? 'camera.home.ft.nest.com' : 'camera.home.nest.com',
+        protobufAPIHost: fieldTest ? 'grpc-web.ft.nest.com' : 'grpc-web.production.nest.com',
+      };
+    }
+
+    if (
+      typeof section?.issuetoken === 'string' &&
+      section.issuetoken !== '' &&
+      typeof section?.cookie === 'string' &&
+      section.cookie !== ''
+    ) {
+      let fieldTest = section?.fieldTest === true;
+      connections[crypto.randomUUID()] = {
+        name: key,
+        type: AccountType.Google,
+        authorised: false,
+        issuetoken: section.issuetoken,
+        cookie: section.cookie,
+        fieldTest,
+        referer: fieldTest ? 'home.ft.nest.com' : 'home.nest.com',
+        restAPIHost: fieldTest ? 'home.ft.nest.com' : 'home.nest.com',
+        cameraAPIHost: fieldTest ? 'camera.home.ft.nest.com' : 'camera.home.nest.com',
+        protobufAPIHost: fieldTest ? 'grpc-web.ft.nest.com' : 'grpc-web.production.nest.com',
+      };
+    }
+  });
+
+  return connections;
+}
+
+// Define exports
+export { AccountType, processConfig, buildConnections };