homebridge-nest-accfactory 0.2.11 → 0.3.1

package/dist/config.js

@@ -0,0 +1,207 @@
+// Configuration validation and processing
+// Part of homebridge-nest-accfactory
+//
+// Code version 2025.06.15
+// 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 FFMPEG_VERSION = '6.0.0';
+const ACCOUNT_TYPE = {
+  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(FFMPEG_VERSION, 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"', FFMPEG_VERSION, 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: ACCOUNT_TYPE.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: ACCOUNT_TYPE.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 { ACCOUNT_TYPE, processConfig, buildConnections };

package/dist/devices.js

@@ -0,0 +1,118 @@
+// Device support loader
+// Part of homebridge-nest-accfactory
+//
+// Code version 2025.06.15
+// Mark Hulskamp
+'use strict';
+
+// Define nodejs module requirements
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import url from 'node:url';
+
+// Import our modules
+import HomeKitDevice from './HomeKitDevice.js';
+
+// Define constants
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+const DEVICE_TYPE = Object.freeze({
+  THERMOSTAT: 'Thermostat',
+  TEMPSENSOR: 'TemperatureSensor',
+  SMOKESENSOR: 'Protect',
+  CAMERA: 'Camera',
+  DOORBELL: 'Doorbell',
+  FLOODLIGHT: 'FloodlightCamera',
+  WEATHER: 'Weather',
+  HEATLINK: 'Heatlink',
+  LOCK: 'Lock',
+  ALARM: 'Alarm',
+});
+
+async function loadDeviceModules(log, pluginDir = '') {
+  let baseDir = path.join(__dirname, pluginDir);
+  let deviceMap = new Map();
+  let files = (await fs.readdir(baseDir)).sort();
+
+  for (const file of files) {
+    if (file.endsWith('.js') === false) {
+      continue;
+    }
+
+    try {
+      let module = await import(url.pathToFileURL(path.join(baseDir, file)).href);
+      let exportsToCheck = Object.values(module);
+
+      for (const exported of exportsToCheck) {
+        if (typeof exported !== 'function') {
+          continue;
+        }
+
+        let proto = Object.getPrototypeOf(exported);
+        while (proto !== undefined && proto.name !== '') {
+          if (proto === HomeKitDevice) {
+            if (
+              typeof exported.TYPE !== 'string' ||
+              exported.TYPE === '' ||
+              typeof exported.VERSION !== 'string' ||
+              exported.VERSION === ''
+            ) {
+              log?.warn?.('Skipping device module %s (missing TYPE or VERSION)', file);
+              break;
+            }
+
+            if (deviceMap.has(exported.TYPE) === false) {
+              deviceMap.set(exported.TYPE, exported);
+              log?.info?.('Loaded device module "%s" (v%s)', exported.TYPE, exported.VERSION);
+            }
+
+            break;
+          }
+
+          proto = Object.getPrototypeOf(proto);
+        }
+      }
+    } catch (error) {
+      log?.warn?.('Failed to load device support file "%s": %s', file, error.message);
+    }
+  }
+
+  return deviceMap;
+}
+
+function getDeviceHKCategory(type) {
+  let category = 1; // Categories.OTHER
+
+  if (type === DEVICE_TYPE.LOCK) {
+    category = 6; // Categories.DOOR_LOCK
+  }
+
+  if (type === DEVICE_TYPE.THERMOSTAT) {
+    category = 9; // Categories.THERMOSTAT
+  }
+
+  if (
+    type === DEVICE_TYPE.TEMPSENSOR ||
+    type === DEVICE_TYPE.HEATLINK ||
+    type === DEVICE_TYPE.SMOKESENSOR ||
+    type === DEVICE_TYPE.WEATHER
+  ) {
+    category = 10; // Categories.SENSOR
+  }
+
+  if (type === DEVICE_TYPE.ALARM) {
+    category = 11; // Categories.SECURITY_SYSTEM
+  }
+
+  if (type === DEVICE_TYPE.CAMERA || type === DEVICE_TYPE.FLOODLIGHT) {
+    category = 17; // Categories.IP_CAMERA
+  }
+
+  if (type === DEVICE_TYPE.DOORBELL) {
+    category = 18; // Categories.VIDEO_DOORBELL
+  }
+
+  return category;
+}
+
+// Define exports
+export { DEVICE_TYPE, loadDeviceModules, getDeviceHKCategory };

package/dist/index.js

@@ -10,13 +10,14 @@
 // Nest Temp Sensors (1st gen)
 // Nest Cameras (Cam Indoor, IQ Indoor, Outdoor, IQ Outdoor, Cam with Floodlight)
 // Nest Doorbells (wired 1st gen)
+// Nest HeatLink
 //
 // The accessory supports authentication to Nest/Google using either a Nest account OR Google (migrated Nest account) account.
 // "preliminary" support for using FieldTest account types also.
 //
 // Supports both Nest REST and Protobuf APIs for communication
 //
-// Code version 7/10/2024
+// Code version 2025.06.05
 // Mark Hulskamp
 'use strict';
 

package/dist/nexustalk.js

@@ -5,7 +5,7 @@
 //
 // Credit to https://github.com/Brandawg93/homebridge-nest-cam for the work on the Nest Camera comms code on which this is based
 //
-// Code version 20/11/2024
+// Code version 2025.06.15
 // Mark Hulskamp
 'use strict';
 
@@ -25,11 +25,11 @@ import { fileURLToPath } from 'node:url';
 import Streamer from './streamer.js';
 
 // Define constants
-const PINGINTERVAL = 15000; // Ping interval to nexus server while stream active
-const USERAGENT = 'Nest/5.78.0 (iOScom.nestlabs.jasper.release) os=18.0'; // User Agent string
+const PING_INTERVAL = 15000; // Ping interval to nexus server while stream active
+const USER_AGENT = 'Nest/5.78.0 (iOScom.nestlabs.jasper.release) os=18.0'; // User Agent string
 const __dirname = path.dirname(fileURLToPath(import.meta.url)); // Make a defined for JS __dirname
 
-const PacketType = {
+const PACKET_TYPE = {
   PING: 1,
   HELLO: 100,
   PING_CAMERA: 101,
@@ -56,7 +56,7 @@ const PacketType = {
 };
 
 // Blank audio in AAC format, mono channel @48000
-const AACMONO48000BLANK = Buffer.from([
+const AAC_MONO_48000_BLANK = Buffer.from([
   0xff, 0xf1, 0x4c, 0x40, 0x03, 0x9f, 0xfc, 0xde, 0x02, 0x00, 0x4c, 0x61, 0x76, 0x63, 0x35, 0x39, 0x2e, 0x31, 0x38, 0x2e, 0x31, 0x30, 0x30,
   0x00, 0x02, 0x30, 0x40, 0x0e,
 ]);
@@ -68,7 +68,7 @@ export default class NexusTalk extends Streamer {
   pingTimer = undefined; // Timer object for ping interval
   stalledTimer = undefined; // Timer object for no received data
   host = ''; // Host to connect to or connected too
-  blankAudio = AACMONO48000BLANK;
+  blankAudio = AAC_MONO_48000_BLANK;
   video = {}; // Video stream details once connected
   audio = {}; // Audio stream details once connected
 
@@ -123,11 +123,11 @@ export default class NexusTalk extends Streamer {
       }
 
       this.connected = false; // Starting connection
-      this?.log?.debug && this.log.debug('Connection started to "%s"', host);
+      this?.log?.debug?.('Connection started to "%s"', host);
 
       this.#socket = tls.connect({ host: host, port: 1443 }, () => {
         // Opened connection to Nexus server, so now need to authenticate ourselves
-        this?.log?.debug && this.log.debug('Connection established to "%s"', host);
+        this?.log?.debug?.('Connection established to "%s"', host);
 
         this.#socket.setKeepAlive(true); // Keep socket connection alive
         this.host = host; // update internal host name since we've connected
@@ -144,7 +144,7 @@ export default class NexusTalk extends Streamer {
       });
 
       this.#socket.on('close', (hadError) => {
-        this?.log?.debug && this.log.debug('Connection closed to "%s"', host);
+        this?.log?.debug?.('Connection closed to "%s"', host);
 
         clearInterval(this.pingTimer);
         clearTimeout(this.stalledTimer);
@@ -199,7 +199,7 @@ export default class NexusTalk extends Streamer {
 
     if (this.host !== deviceData.streaming_host) {
       this.host = deviceData.streaming_host;
-      this?.log?.debug && this.log.debug('New host has been requested for connection. Host requested is "%s"', this.host);
+      this?.log?.debug?.('New host has been requested for connection. Host requested is "%s"', this.host);
     }
 
     // Let our parent handle the remaining updates
@@ -219,7 +219,7 @@ export default class NexusTalk extends Streamer {
             sampleRate: 16000,
           }),
         ).finish();
-        this.#sendMessage(PacketType.AUDIO_PAYLOAD, encodedData);
+        this.#sendMessage(PACKET_TYPE.AUDIO_PAYLOAD, encodedData);
       }
     }
   }
@@ -248,7 +248,7 @@ export default class NexusTalk extends Streamer {
           profileNotFoundAction: 'REDIRECT',
         }),
       ).finish();
-      this.#sendMessage(PacketType.START_PLAYBACK, encodedData);
+      this.#sendMessage(PACKET_TYPE.START_PLAYBACK, encodedData);
     }
   }
 
@@ -261,13 +261,13 @@ export default class NexusTalk extends Streamer {
             sessionId: this.#id,
           }),
         ).finish();
-        this.#sendMessage(PacketType.STOP_PLAYBACK, encodedData);
+        this.#sendMessage(PACKET_TYPE.STOP_PLAYBACK, encodedData);
       }
     }
   }
 
   #sendMessage(type, data) {
-    if (this.#socket?.readyState !== 'open' || (type !== PacketType.HELLO && this.#authorised === false)) {
+    if (this.#socket?.readyState !== 'open' || (type !== PACKET_TYPE.HELLO && this.#authorised === false)) {
       // We're not connect and/or authorised yet, so 'cache' message for processing once this occurs
       this.#messages.push({ type: type, data: data });
       return;
@@ -275,11 +275,11 @@ export default class NexusTalk extends Streamer {
 
     // Create nexusTalk message header
     let header = Buffer.alloc(3);
-    if (type !== PacketType.LONG_PLAYBACK_PACKET) {
+    if (type !== PACKET_TYPE.LONG_PLAYBACK_PACKET) {
       header.writeUInt8(type, 0);
       header.writeUInt16BE(data.length, 1);
     }
-    if (type === PacketType.LONG_PLAYBACK_PACKET) {
+    if (type === PACKET_TYPE.LONG_PLAYBACK_PACKET) {
       header = Buffer.alloc(5);
       header.writeUInt8(type, 0);
       header.writeUInt32BE(data.length, 1);
@@ -308,28 +308,28 @@ export default class NexusTalk extends Streamer {
 
       if (reauthorise === true && authoriseRequest !== null) {
         // Request to re-authorise only
-        this?.log?.debug && this.log.debug('Re-authentication requested to "%s"', this.host);
-        this.#sendMessage(PacketType.AUTHORIZE_REQUEST, authoriseRequest);
+        this?.log?.debug?.('Re-authentication requested to "%s"', this.host);
+        this.#sendMessage(PACKET_TYPE.AUTHORIZE_REQUEST, authoriseRequest);
       }
 
       if (reauthorise === false && authoriseRequest !== null) {
         // This isn't a re-authorise request, so perform 'Hello' packet
         let TraitMap = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.Hello');
         if (TraitMap !== null) {
-          this?.log?.debug && this.log.debug('Performing authentication to "%s"', this.host);
+          this?.log?.debug?.('Performing authentication to "%s"', this.host);
 
           let encodedData = TraitMap.encode(
             TraitMap.fromObject({
               protocolVersion: 'VERSION_3',
               uuid: this.uuid.split(/[._]+/)[1],
               requireConnectedCamera: false,
-              userAgent: USERAGENT,
+              USER_AGENT: USER_AGENT,
               deviceId: crypto.randomUUID(),
               clientType: 'IOS',
               authoriseRequest: authoriseRequest,
             }),
           ).finish();
-          this.#sendMessage(PacketType.HELLO, encodedData);
+          this.#sendMessage(PACKET_TYPE.HELLO, encodedData);
         }
       }
     }
@@ -350,7 +350,7 @@ export default class NexusTalk extends Streamer {
       return;
     }
 
-    this?.log?.debug && this.log.debug('Redirect requested from "%s" to "%s"', this.host, redirectToHost);
+    this?.log?.debug?.('Redirect requested from "%s" to "%s"', this.host, redirectToHost);
 
     // Setup listener for socket close event. Once socket is closed, we'll perform the redirect
     this.#socket &&
@@ -389,7 +389,7 @@ export default class NexusTalk extends Streamer {
       this.#packets = [];
       this.#messages = [];
 
-      this?.log?.debug && this.log.debug('Playback started from "%s" with session ID "%s"', this.host, this.#id);
+      this?.log?.debug?.('Playback started from "%s" with session ID "%s"', this.host, this.#id);
     }
   }
 
@@ -403,12 +403,11 @@ export default class NexusTalk extends Streamer {
       // <-- testing to see how often this occurs first
       clearTimeout(this.stalledTimer);
       this.stalledTimer = setTimeout(() => {
-        this?.log?.debug &&
-          this.log.debug(
-            'We have not received any data from nexus in the past "%s" seconds for uuid "%s". Attempting restart',
-            10,
-            this.uuid,
-          );
+        this?.log?.debug?.(
+          'We have not received any data from nexus in the past "%s" seconds for uuid "%s". Attempting restart',
+          10,
+          this.uuid,
+        );
 
         // Setup listener for socket close event. Once socket is closed, we'll perform the re-connection
         this.#socket &&
@@ -437,13 +436,12 @@ export default class NexusTalk extends Streamer {
 
       if (this.#id !== undefined && decodedMessage.reason === 'USER_ENDED_SESSION') {
         // Normal playback ended ie: when we stopped playback
-        this?.log?.debug && this.log.debug('Playback ended on "%s"', this.host);
+        this?.log?.debug?.('Playback ended on "%s"', this.host);
       }
 
       if (decodedMessage.reason !== 'USER_ENDED_SESSION') {
         // Error during playback, so we'll attempt to restart by reconnection to host
-        this?.log?.debug &&
-          this.log.debug('Playback ended on "%s" with error "%s". Attempting reconnection', this.host, decodedMessage.reason);
+        this?.log?.debug?.('Playback ended on "%s" with error "%s". Attempting reconnection', this.host, decodedMessage.reason);
 
         // Setup listener for socket close event. Once socket is closed, we'll perform the re-connection
         this.#socket &&
@@ -464,7 +462,7 @@ export default class NexusTalk extends Streamer {
         this.#Authenticate(true); // Update authorisation only
       } else {
         // NexusStreamer Error, packet.message contains the message
-        this?.log?.debug && this.log.debug('Error', decodedMessage.message);
+        this?.log?.debug?.('Error', decodedMessage.message);
       }
     }
   }
@@ -474,7 +472,7 @@ export default class NexusTalk extends Streamer {
     if (typeof payload === 'object' && this.#protobufNexusTalk !== undefined) {
       //let decodedMessage = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.TalkbackBegin').decode(payload).toJSON();
       this.audio.talking = true;
-      this?.log?.debug && this.log.debug('Talking started on uuid "%s"', this.uuid);
+      this?.log?.debug?.('Talking started on uuid "%s"', this.uuid);
     }
   }
 
@@ -483,7 +481,7 @@ export default class NexusTalk extends Streamer {
     if (typeof payload === 'object' && this.#protobufNexusTalk !== undefined) {
       //let decodedMessage = this.#protobufNexusTalk.lookup('nest.nexustalk.v1.TalkbackEnd').decode(payload).toJSON();
       this.audio.talking = false;
-      this?.log?.debug && this.log.debug('Talking ended on uuid "%s"', this.uuid);
+      this?.log?.debug?.('Talking ended on uuid "%s"', this.uuid);
     }
   }
 
@@ -496,7 +494,7 @@ export default class NexusTalk extends Streamer {
       let packetType = this.#packets.readUInt8(0);
       let packetSize = this.#packets.readUInt16BE(1);
 
-      if (packetType === PacketType.LONG_PLAYBACK_PACKET) {
+      if (packetType === PACKET_TYPE.LONG_PLAYBACK_PACKET) {
         headerSize = 5;
         packetSize = this.#packets.readUInt32BE(1);
       }
@@ -511,11 +509,11 @@ export default class NexusTalk extends Streamer {
       this.#packets = this.#packets.subarray(headerSize + packetSize);
 
       switch (packetType) {
-        case PacketType.PING: {
+        case PACKET_TYPE.PING: {
           break;
         }
 
-        case PacketType.OK: {
+        case PACKET_TYPE.OK: {
           // process any pending messages we have stored
           this.#authorised = true; // OK message, means we're connected and authorised to Nexus
           for (let message = this.#messages.shift(); message; message = this.#messages.shift()) {
@@ -525,46 +523,46 @@ export default class NexusTalk extends Streamer {
           // Periodically send PING message to keep stream alive
           clearInterval(this.pingTimer);
           this.pingTimer = setInterval(() => {
-            this.#sendMessage(PacketType.PING, Buffer.alloc(0));
-          }, PINGINTERVAL);
+            this.#sendMessage(PACKET_TYPE.PING, Buffer.alloc(0));
+          }, PING_INTERVAL);
 
           // Start processing data
           this.#startNexusData();
           break;
         }
 
-        case PacketType.ERROR: {
+        case PACKET_TYPE.ERROR: {
           this.#handleNexusError(protoBufPayload);
           break;
         }
 
-        case PacketType.PLAYBACK_BEGIN: {
+        case PACKET_TYPE.PLAYBACK_BEGIN: {
           this.#handlePlaybackBegin(protoBufPayload);
           break;
         }
 
-        case PacketType.PLAYBACK_END: {
+        case PACKET_TYPE.PLAYBACK_END: {
           this.#handlePlaybackEnd(protoBufPayload);
           break;
         }
 
-        case PacketType.PLAYBACK_PACKET:
-        case PacketType.LONG_PLAYBACK_PACKET: {
+        case PACKET_TYPE.PLAYBACK_PACKET:
+        case PACKET_TYPE.LONG_PLAYBACK_PACKET: {
           this.#handlePlaybackPacket(protoBufPayload);
           break;
         }
 
-        case PacketType.REDIRECT: {
+        case PACKET_TYPE.REDIRECT: {
           this.#handleRedirect(protoBufPayload);
           break;
         }
 
-        case PacketType.TALKBACK_BEGIN: {
+        case PACKET_TYPE.TALKBACK_BEGIN: {
           this.#handleTalkbackBegin(protoBufPayload);
           break;
         }
 
-        case PacketType.TALKBACK_END: {
+        case PACKET_TYPE.TALKBACK_END: {
           this.#handleTalkbackEnd(protoBufPayload);
           break;
         }