homebridge-nest-accfactory 0.3.0 → 0.3.2

package/dist/config.js

@@ -1,23 +1,19 @@
 // Configuration validation and processing
 // Part of homebridge-nest-accfactory
 //
-// Code version 2025.06.12
+// Code version 2025.06.30
 // 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';
+
+// Import our modules
+import FFmpeg from './ffmpeg.js';
 
 // Define constants
-const FFMPEGVERSION = '6.0.0';
-const AccountType = {
-  Nest: 'Nest',
-  Google: 'Google',
-};
+import { FFMPEG_VERSION, ACCOUNT_TYPE } from './consts.js';
 
 function processConfig(config, log) {
   let options = (config.options = typeof config?.options === 'object' ? config.options : {});
@@ -40,93 +36,79 @@ function processConfig(config, log) {
   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;
+  options.ffmpeg = {
+    binary: undefined,
+    valid: false,
+    debug: config.options?.ffmpegDebug === true,
+    hwaccel: false,
+  };
+
+  let ffmpegPath =
+    typeof config.options?.ffmpegPath === 'string' && config.options.ffmpegPath !== '' ? config.options.ffmpegPath : '/usr/local/bin';
+
+  let resolvedPath = path.resolve(ffmpegPath);
+  if (resolvedPath.endsWith('/ffmpeg') === false) {
+    resolvedPath += '/ffmpeg';
   }
 
-  if (fs.existsSync(options.ffmpeg.binary) === true) {
-    let ffmpegProcess = child_process.spawnSync(options.ffmpeg.binary, ['-version'], {
-      env: process.env,
+  // Create FFmpeg probe
+  let ffmpeg = new FFmpeg(resolvedPath, log);
+
+  if (typeof ffmpeg.version !== 'string') {
+    log?.warn?.('ffmpeg binary "%s" not found or not executable, camera/doorbell streaming will be unavailable', ffmpeg.binary);
+  } else {
+    // Proceed with compatibility checks
+    options.ffmpeg.valid = ffmpeg.hasMinimumSupport({
+      version: FFMPEG_VERSION,
+      encoders: ['libx264', 'libfdk_aac', 'libopus'],
+      decoders: ['libspeex'],
     });
+    if (options.ffmpeg.valid === false) {
+      log?.warn?.('ffmpeg binary "%s" does not meet the minimum support requirements', ffmpeg.binary);
 
-    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, {
+      if (
+        ffmpeg.version?.localeCompare(FFMPEG_VERSION, undefined, {
           numeric: true,
           sensitivity: 'case',
           caseFirst: 'upper',
-        }) === -1;
+        }) === -1
+      ) {
+        log?.warn?.('Minimum binary version is "%s", however the installed version is "%s"', FFMPEG_VERSION, ffmpeg.version);
+        log?.warn?.('Stream video/recording from camera/doorbells will be unavailable');
+      }
+
+      if ((ffmpeg.features?.decoders || []).includes('libspeex') === false) {
+        log?.warn?.('Missing speex decoder in ffmpeg, talkback on certain camera/doorbells will be unavailable');
+      }
 
       if (
-        versionTooOld ||
-        options.ffmpeg.libspeex === false ||
-        options.ffmpeg.libopus === false ||
-        options.ffmpeg.libx264 === false ||
-        options.ffmpeg.libfdk_aac === false
+        (ffmpeg.features?.encoders || []).includes('libfdk_aac') === false &&
+        (ffmpeg.features?.encoders || []).includes('libopus') === 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
-        }
+        log?.warn?.('Missing fdk_aac and opus encoders in ffmpeg, audio from camera/doorbells will be unavailable');
+      }
+
+      if ((ffmpeg.features?.encoders || []).includes('libfdk_aac') === false) {
+        log?.warn?.('Missing fdk_aac encoder in ffmpeg, audio from camera/doorbells will be unavailable');
+      }
+
+      if ((ffmpeg.features?.encoders || []).includes('libopus') === false) {
+        log?.warn?.('Missing opus encoder in ffmpeg, talkback on certain camera/doorbells will be unavailable');
+      }
+
+      if ((ffmpeg.features?.encoders || []).includes('libx264') === false) {
+        log?.warn?.('Missing libx264 encoder in ffmpeg, stream video/recording from camera/doorbells will be unavailable');
       }
     }
-  }
 
-  if (options.ffmpeg.binary !== undefined) {
-    log?.success?.('Found valid ffmpeg binary in %s', options.ffmpeg.binary);
+    if (options.ffmpeg.valid === true) {
+      log?.success?.('Found valid ffmpeg binary in %s', ffmpeg.binary);
+      options.ffmpeg.binary = ffmpeg.binary;
+      options.ffmpeg.hwaccel = ffmpeg.supportsHardwareH264 === true;
+      if (ffmpeg.supportsHardwareH264 === true) {
+        log?.debug?.('Hardware H264 encoding available via "%s"', ffmpeg.hardwareH264Codec);
+      }
+    }
   }
 
   // Process per device configuration(s)
@@ -135,7 +117,7 @@ function processConfig(config, log) {
   }
 
   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
+    // If the devices section is a JSON object keyed by the devices serial number, convert to devices array object
     let newDeviceArray = [];
     for (const [serialNumber, props] of Object.entries(config.devices)) {
       newDeviceArray.push({
@@ -167,7 +149,7 @@ function buildConnections(config) {
       let fieldTest = section?.fieldTest === true;
       connections[crypto.randomUUID()] = {
         name: key,
-        type: AccountType.Nest,
+        type: ACCOUNT_TYPE.NEST,
         authorised: false,
         access_token: section.access_token,
         fieldTest,
@@ -187,7 +169,7 @@ function buildConnections(config) {
       let fieldTest = section?.fieldTest === true;
       connections[crypto.randomUUID()] = {
         name: key,
-        type: AccountType.Google,
+        type: ACCOUNT_TYPE.GOOGLE,
         authorised: false,
         issuetoken: section.issuetoken,
         cookie: section.cookie,
@@ -204,4 +186,4 @@ function buildConnections(config) {
 }
 
 // Define exports
-export { AccountType, processConfig, buildConnections };
+export { processConfig, buildConnections };

package/dist/consts.js

@@ -0,0 +1,160 @@
+// Common defines
+// Part of homebridge-nest-accfactory
+//
+// Code version 2025.08.07
+// Mark Hulskamp
+'use strict';
+
+// Define nodejs module requirements
+import path from 'node:path';
+import url from 'node:url';
+
+// Define constants
+export const TIMERS = {
+  ALERTS: 2000, // Camera alert polling interval (ms)
+  ZONES: 30000, // Camera zone polling interval (ms)
+  WEATHER: 300000, // Weather data refresh interval (ms)
+  NEST_API: 10000, // Nest API request timeout (ms)
+  TALKBACK_AUDIO: 1000, // Audio talkback timeout (ms)
+  SNAPSHOT: 30000, // Timeout for retaining snapshot image timeout (ms)
+};
+
+export const USER_AGENT = 'Nest/5.82.2 (iOScom.nestlabs.jasper.release) os=18.5'; // User Agent string
+
+export const __dirname = path.dirname(url.fileURLToPath(import.meta.url)); // Make a defined for JS __dirname
+
+export const DATA_SOURCE = {
+  NEST: 'Nest', // From the Nest API
+  GOOGLE: 'Google', // From the Protobuf/Google API
+};
+
+export const DAYS_OF_WEEK_FULL = ['MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY', 'SATURDAY', 'SUNDAY'];
+
+export const DAYS_OF_WEEK_SHORT = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'];
+
+export const PROTOBUF_RESOURCES = {
+  THERMOSTAT: [
+    'nest.resource.NestAmber1DisplayResource',
+    'nest.resource.NestAmber2DisplayResource',
+    'nest.resource.NestLearningThermostat1Resource',
+    'nest.resource.NestLearningThermostat2Resource',
+    'nest.resource.NestLearningThermostat3Resource',
+    'nest.resource.NestAgateDisplayResource',
+    'nest.resource.NestOnyxResource',
+    'google.resource.GoogleZirconium1Resource',
+    'google.resource.GoogleBismuth1Resource',
+  ],
+  HEATLINK: ['nest.resource.NestAgateHeatlinkResource'],
+  KRYPTONITE: ['nest.resource.NestKryptoniteResource'],
+  LOCK: ['yale.resource.LinusLockResource'],
+  PROTECT: [
+    'nest.resource.NestProtect1LinePoweredResource',
+    'nest.resource.NestProtect1BatteryPoweredResource',
+    'nest.resource.NestProtect2LinePoweredResource',
+    'nest.resource.NestProtect2BatteryPoweredResource',
+    'nest.resource.NestProtect2Resource',
+  ],
+  CAMERA: [
+    'google.resource.GreenQuartzResource',
+    'google.resource.SpencerResource',
+    'google.resource.VenusResource',
+    'nest.resource.NestCamIndoorResource',
+    'nest.resource.NestCamIQResource',
+    'nest.resource.NestCamIQOutdoorResource',
+    'nest.resource.NestCamOutdoorResource',
+    'nest.resource.NestHelloResource',
+    'google.resource.GoogleNewmanResource',
+  ],
+  DOORBELL: ['nest.resource.NestHelloResource', 'google.resource.GreenQuartzResource', 'google.resource.VenusResource'],
+  FLOODLIGHT: ['google.resource.NeonQuartzResource', 'google.resource.AzizResource'],
+  CONNECT: ['nest.resource.NestConnectResource'],
+  DETECT: ['nest.resource.NestDetectResource'],
+  GUARD: ['nest.resource.NestHelloResource'],
+};
+
+export const NEST_API_BUCKETS = [
+  'buckets',
+  'delayed_topaz',
+  'demand_response',
+  'device',
+  'device_alert_dialog',
+  'geofence_info',
+  'kryptonite',
+  'link',
+  'message',
+  'message_center',
+  'metadata',
+  'occupancy',
+  'quartz',
+  'safety',
+  'rcs_settings',
+  'safety_summary',
+  'schedule',
+  'shared',
+  'structure',
+  'structure_metadata',
+  'topaz',
+  'topaz_resource',
+  'track',
+  'trip',
+  'tuneups',
+  'user',
+  'user_settings',
+  'where',
+  'widget_track',
+];
+
+export const DEVICE_TYPE = {
+  THERMOSTAT: 'Thermostat',
+  TEMPSENSOR: 'TemperatureSensor',
+  PROTECT: 'Protect',
+  CAMERA: 'Camera',
+  DOORBELL: 'Doorbell',
+  FLOODLIGHT: 'FloodlightCamera',
+  WEATHER: 'Weather',
+  HEATLINK: 'Heatlink',
+  LOCK: 'Lock',
+  ALARM: 'Alarm',
+};
+
+export const FFMPEG_VERSION = '6.0.0';
+
+export const ACCOUNT_TYPE = {
+  NEST: 'Nest',
+  GOOGLE: 'Google',
+};
+
+export const LOW_BATTERY_LEVEL = 10; // Low battery level percentage
+
+export const THERMOSTAT_MIN_TEMPERATURE = 9; // Minimum temperature for Nest Thermostat
+
+export const THERMOSTAT_MAX_TEMPERATURE = 32; // Maximum temperature for Nest Thermostat
+
+export const HOTWATER_MIN_TEMPERATURE = 30; // Minimum temperature for hotwater heating
+
+export const HOTWATER_MAX_TEMPERATURE = 70; // Maximum temperature for hotwater heating
+
+export const HOTWATER_BOOST_TIMES = [1800, 3600, 7200]; // Valid hotwater boost times
+
+export const RESOURCE_PATH = './res';
+export const RESOURCE_IMAGES = {
+  CAMERA_OFFLINE: 'Nest_camera_offline.jpg',
+  CAMERA_OFF: 'Nest_camera_off.jpg',
+  CAMERA_TRANSFER: 'Nest_camera_transfer.jpg',
+};
+
+export const RESOURCE_FRAMES = {
+  CAMERA_OFFLINE: 'Nest_camera_offline.h264',
+  CAMERA_OFF: 'Nest_camera_off.h264',
+  CAMERA_TRANSFER: 'Nest_camera_transfer.h264',
+};
+
+export const LOG_LEVELS = {
+  INFO: 'info',
+  SUCCESS: 'success',
+  WARN: 'warn',
+  ERROR: 'error',
+  DEBUG: 'debug',
+};
+
+export const NESTLABS_MAC_PREFIX = '18B430';

package/dist/devices.js

@@ -1,7 +1,7 @@
 // Device support loader
 // Part of homebridge-nest-accfactory
 //
-// Code version 2025.06.12
+// Code version 2025.07.25
 // Mark Hulskamp
 'use strict';
 
@@ -14,62 +14,50 @@ import url from 'node:url';
 import HomeKitDevice from './HomeKitDevice.js';
 
 // Define constants
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-const DeviceType = Object.freeze({
-  THERMOSTAT: 'Thermostat',
-  TEMPSENSOR: 'TemperatureSensor',
-  SMOKESENSOR: 'Protect',
-  CAMERA: 'Camera',
-  DOORBELL: 'Doorbell',
-  FLOODLIGHT: 'FloodlightCamera',
-  WEATHER: 'Weather',
-  HEATLINK: 'Heatlink',
-  LOCK: 'Lock',
-  ALARM: 'Alarm',
-});
+import { __dirname, DEVICE_TYPE } from './consts.js';
 
 async function loadDeviceModules(log, pluginDir = '') {
   let baseDir = path.join(__dirname, pluginDir);
   let deviceMap = new Map();
   let files = (await fs.readdir(baseDir)).sort();
 
+  log?.debug?.('Using base module v%s', HomeKitDevice.VERSION);
+
   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 modulePath = url.pathToFileURL(path.join(baseDir, file)).href;
+      let module = await import(modulePath);
+      let chosenClass = undefined;
+
+      // First pass: find a valid subclass of HomeKitDevice
+      for (const exported of Object.values(module)) {
+        if (
+          typeof exported === 'function' &&
+          HomeKitDevice.prototype.isPrototypeOf(exported.prototype) &&
+          typeof exported.TYPE === 'string' &&
+          typeof exported.VERSION === 'string'
+        ) {
+          chosenClass = exported;
+          break; // first valid one wins (like your original)
         }
+      }
 
-        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;
-          }
+      if (chosenClass && deviceMap.has(chosenClass.TYPE) === false) {
+        let entry = { class: chosenClass };
 
-          proto = Object.getPrototypeOf(proto);
+        // Add additional named functions (like processRawData)
+        for (const [key, value] of Object.entries(module)) {
+          if (typeof value === 'function' && value !== chosenClass) {
+            entry[key] = value;
+          }
         }
+
+        deviceMap.set(chosenClass.TYPE, entry);
+        log?.info?.('Loaded %s module v%s', chosenClass.TYPE, chosenClass.VERSION);
       }
     } catch (error) {
       log?.warn?.('Failed to load device support file "%s": %s', file, error.message);
@@ -82,27 +70,31 @@ async function loadDeviceModules(log, pluginDir = '') {
 function getDeviceHKCategory(type) {
   let category = 1; // Categories.OTHER
 
-  if (type === DeviceType.LOCK) {
+  if (type === DEVICE_TYPE.LOCK) {
     category = 6; // Categories.DOOR_LOCK
   }
 
-  if (type === DeviceType.THERMOSTAT) {
+  if (type === DEVICE_TYPE.HEATLINK) {
+    category = 8; // Categories.SWITCH
+  }
+
+  if (type === DEVICE_TYPE.THERMOSTAT) {
     category = 9; // Categories.THERMOSTAT
   }
 
-  if (type === DeviceType.TEMPSENSOR || type === DeviceType.HEATLINK || type === DeviceType.SMOKESENSOR || type === DeviceType.WEATHER) {
+  if (type === DEVICE_TYPE.TEMPSENSOR || type === DEVICE_TYPE.PROTECT || type === DEVICE_TYPE.WEATHER) {
     category = 10; // Categories.SENSOR
   }
 
-  if (type === DeviceType.ALARM) {
+  if (type === DEVICE_TYPE.ALARM) {
     category = 11; // Categories.SECURITY_SYSTEM
   }
 
-  if (type === DeviceType.CAMERA || type === DeviceType.FLOODLIGHT) {
+  if (type === DEVICE_TYPE.CAMERA || type === DEVICE_TYPE.FLOODLIGHT) {
     category = 17; // Categories.IP_CAMERA
   }
 
-  if (type === DeviceType.DOORBELL) {
+  if (type === DEVICE_TYPE.DOORBELL) {
     category = 18; // Categories.VIDEO_DOORBELL
   }
 
@@ -110,4 +102,4 @@ function getDeviceHKCategory(type) {
 }
 
 // Define exports
-export { DeviceType, loadDeviceModules, getDeviceHKCategory };
+export { loadDeviceModules, getDeviceHKCategory };