@homebridge-plugins/homebridge-firstalert 0.0.1-beta.0

package/src/platform.ts

@@ -0,0 +1,112 @@
+
+import type { API, DynamicPlatformPlugin, Logger, PlatformAccessory, PlatformConfig } from 'homebridge'
+import { ResideoClient } from './api/resideoClient.js'
+import { Thermostats } from './devices/thermostats.js'
+import { LeakSensor } from './devices/leaksensors.js'
+import { Valve } from './devices/valve.js'
+import { deviceBase } from './devices/device.js'
+import { SmokeSensor } from './devices/smoke.js'
+
+export class ResideoPlatform implements DynamicPlatformPlugin {
+  private readonly log: Logger
+  private readonly config: PlatformConfig
+  private readonly api: API
+  private readonly pollInterval: number
+  public readonly client!: ResideoClient
+  private pollTimer?: any
+  private accessories: PlatformAccessory[] = []
+  private deviceInstances: Record<string, deviceBase> = {}
+
+  constructor(log: Logger, config: PlatformConfig, api: API) {
+    this.log = log
+    this.config = config
+    this.api = api
+    this.pollInterval = config.pollInterval || 60
+    if (!config.refreshToken) {
+      this.log.error('No refresh token configured. Please log in via the Homebridge UI.')
+      return
+    }
+    this.client = new ResideoClient(config.refreshToken)
+    api.on('didFinishLaunching', () => this.discoverDevices())
+  }
+
+  async discoverDevices() {
+    try {
+      const account = await this.client.getAccount()
+      for (const device of account.devices) {
+        // Find or create accessory
+        let accessory = this.accessories.find(a => a.context.deviceID === device.deviceId)
+        if (!accessory) {
+          accessory = new this.api.platformAccessory(device.name, this.api.hap.uuid.generate(device.deviceId))
+          accessory.context.deviceID = device.deviceId
+          accessory.context.deviceType = device.globalDeviceType
+          this.api.registerPlatformAccessories('@homebridge-plugins/homebridge-firstalert', 'FirstAlert', [accessory])
+          this.accessories.push(accessory)
+          this.log.info(`Registered new accessory: ${device.name} (${device.deviceId})`)
+        }
+        // Instantiate correct device class
+        let instance: deviceBase | undefined
+        switch (device.globalDeviceType) {
+          case 'thermostat':
+            instance = new Thermostats(this, accessory, device as any)
+            break
+          case 'leakSensor':
+            instance = new LeakSensor(this, accessory, device as any)
+            break
+          case 'valve':
+            instance = new Valve(this, accessory, device as any)
+            break
+          case 'smoke':
+          case 'smokeSensor':
+          case 'smokeDetector':
+          case 'carbonMonoxideSensor':
+          case 'carbonDioxideSensor':
+            instance = new SmokeSensor(this, accessory, device as any)
+            break
+          default:
+            this.log.warn(`Unknown device type: ${device.globalDeviceType} (${device.deviceId})`)
+        }
+        if (instance) {
+          this.deviceInstances[device.deviceId] = instance
+        }
+        this.log.info(`Discovered device: ${device.name} (${device.deviceId})`)
+      }
+      this.startPolling(account.devices.map(d => d.deviceId))
+    } catch (err) {
+      this.log.error('Failed to discover devices:', err)
+    }
+  }
+
+  startPolling(deviceIds: string[]) {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer)
+    }
+    this.pollTimer = setInterval(() => this.pollDevices(deviceIds), this.pollInterval * 1000)
+    this.pollDevices(deviceIds) // Initial poll
+  }
+
+  async pollDevices(deviceIds: string[]) {
+    for (const deviceId of deviceIds) {
+      const instance = this.deviceInstances[deviceId]
+      if (instance && typeof (instance as any).updateState === 'function') {
+        try {
+          await (instance as any).updateState()
+        } catch (err) {
+          this.log.warn(`Failed to update state for device ${deviceId}:`, err)
+        }
+      } else {
+        try {
+          const state = await this.client.getDeviceState(deviceId)
+          this.log.debug(`Polled device ${deviceId}:`, JSON.stringify(state))
+        } catch (err) {
+          this.log.warn(`Failed to poll device ${deviceId}:`, err)
+        }
+      }
+    }
+  }
+
+  configureAccessory(accessory: PlatformAccessory) {
+    // Required for restoring cached accessories
+    this.accessories.push(accessory)
+  }
+}

package/src/settings.ts

@@ -0,0 +1,402 @@
+/* Copyright(C) 2022-2024, donavanbecker (https://github.com/donavanbecker). All rights reserved.
+ *
+ * settings.ts: homebridge-firstalert.
+ */
+import type { PlatformConfig } from 'homebridge'
+
+/**
+ * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
+ */
+export const PLATFORM_NAME = 'FirstAlert'
+
+/**
+ * This must match the name of your plugin as defined the package.json
+ */
+export const PLUGIN_NAME = '@homebridge-plugins/homebridge-firstalert'
+
+/**
+ * This is the main url used to access FirstAlert API
+ */
+export const AuthorizeURL = 'https://api.honeywell.com/oauth2/authorize?'
+
+/**
+ * This is the main url used to access FirstAlert API
+ */
+export const TokenURL = 'https://api.honeywell.com/oauth2/token'
+
+/**
+ * This is the main url used to access FirstAlert API
+ */
+export const LocationURL = 'https://api.honeywell.com/v2/locations'
+
+/**
+ * This is the main url used to access FirstAlert API
+ */
+export const DeviceURL = 'https://api.honeywell.com/v2/devices'
+
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD'
+
+// Config
+export interface ResideoPlatformConfig extends PlatformConfig {
+  credentials?: credentials
+  callbackUrl?: string
+  port?: string
+}
+
+export interface credentials {
+  accessToken?: string
+  refreshToken?: string
+  consumerKey?: string
+  consumerSecret?: string
+}
+
+export interface modes {
+  Off: number
+  Heat: number
+  Cool: number
+  Auto: number
+}
+
+export interface holdModes {
+  NoHold: number
+  TemporaryHold: number
+  PermanentHold: number
+}
+
+export interface payload {
+  mode?: string
+  heatSetpoint?: number
+  coolSetpoint?: number
+  thermostatSetpointStatus?: string
+  nextPeriodTime?: string
+  autoChangeoverActive?: boolean
+  thermostatSetpoint?: number
+  unit?: string
+  state?: string
+}
+
+export type locations = location[]
+
+// Location
+export interface location {
+  locationID: string | number // Updated to handle both string and number
+  name: string
+  devices: resideoDevice[]
+}
+
+export interface resideoDevice {
+  deviceID: string | number // Updated to handle both string and number
+  deviceClass: string
+  deviceModel: string
+  userDefinedDeviceName: string
+  firmware?: string
+  thermostatVersion?: string
+  external?: boolean
+  groups?: T9groups[]
+  inBuiltSensorState?: inBuiltSensorState
+  settings?: Settings
+  deviceType: string
+  name?: string
+  isAlive: boolean
+  priorityType?: string
+  units?: string
+  indoorTemperature?: number
+  allowedModes?: string[]
+  minHeatSetpoint?: number
+  maxHeatSetpoint?: number
+  minCoolSetpoint?: number
+  maxCoolSetpoint?: number
+  changeableValues?: ChangeableValues
+  operationStatus?: OperationStatus
+  indoorHumidity?: number
+  displayedOutdoorHumidity?: number
+  scheduleStatus?: string
+  allowedTimeIncrements?: number
+  isUpgrading?: boolean
+  isProvisioned?: boolean
+  macID?: string
+  dataSyncStatus?: string
+  outdoorTemperature?: number
+  deadband?: number
+  hasDualSetpointStatus?: boolean
+  parentDeviceId?: number
+  service: Service
+  deviceSettings: Record<string, unknown> // DeviceSettings
+  firmwareVersion?: string
+  vacationHold?: VacationHold
+  currentSchedulePeriod?: CurrentSchedulePeriod
+  scheduleCapabilities?: ScheduleCapabilities
+  scheduleType?: ScheduleType
+  changeSource?: ChangeSource
+  partnerInfo?: PartnerInfo
+  deviceRegistrationDate?: Date
+  indoorHumidityStatus?: string
+  waterPresent: boolean
+  currentSensorReadings: CurrentSensorReadings
+  batteryRemaining: number
+  isRegistered: boolean
+  hasDeviceCheckedIn: boolean
+  isDeviceOffline: boolean
+  deviceMac: string // Device MAC address
+  dataSyncInfo: dataSyncInfo
+  lastCheckin: Date // Last time data received from device
+  actuatorValve: actuatorValve // Values specific to the valve operation
+  daylightSavingsInfo: daylightSavingsInfo // Daylight savings time config info
+  maintenance: maintenance // Maintenance settings
+}
+
+export interface T9groups {
+  id: number
+}
+
+export interface inBuiltSensorState {
+  roomId: number
+  roomName: string
+}
+
+// Fan Settings
+export interface Settings {
+  homeSetPoints?: HomeSetPoints
+  awaySetPoints?: AwaySetPoints
+  fan: Fan
+  temperatureMode?: TemperatureMode
+  specialMode?: SpecialMode
+  hardwareSettings?: HardwareSettings
+  devicePairingEnabled?: boolean
+}
+
+export interface ChangeableValues {
+  mode: string
+  autoChangeoverActive?: boolean
+  heatSetpoint: number
+  coolSetpoint: number
+  thermostatSetpointStatus?: string
+  nextPeriodTime?: string
+  endHeatSetpoint?: number
+  endCoolSetpoint?: number
+  heatCoolMode: string
+  emergencyHeatActive?: boolean
+}
+
+export interface OperationStatus {
+  mode: string
+  fanRequest?: boolean
+  circulationFanRequest?: boolean
+}
+
+export interface Service {
+  mode: string
+}
+
+export interface AwaySetPoints {
+  awayHeatSP: number
+  awayCoolSP: number
+  smartCoolSP: number
+  smartHeatSP: number
+  useAutoSmart: boolean
+  units: string
+}
+
+export interface HomeSetPoints {
+  homeHeatSP: number
+  homeCoolSP: number
+  units: string
+}
+
+export interface TemperatureMode {
+  feelsLike?: boolean
+  air: boolean
+}
+
+export interface SpecialMode {
+  autoChangeoverActive: boolean
+  emergencyHeatActive?: boolean
+}
+
+export interface Fan {
+  allowedModes: string[]
+  changeableValues: FanChangeableValues
+  fanRunning: boolean
+  allowedSpeeds?: AllowedSpeed[]
+}
+
+export interface FanChangeableValues {
+  mode: string
+}
+
+export interface AllowedSpeed {
+  item: string
+  value: Value
+}
+
+export interface Value {
+  speed?: number
+  mode: string
+}
+
+export interface VacationHold {
+  enabled: boolean
+}
+
+export interface CurrentSchedulePeriod {
+  day: string
+  period: string
+}
+
+export interface ScheduleCapabilities {
+  availableScheduleTypes: string[]
+  schedulableFan: boolean
+}
+
+export interface ScheduleType {
+  scheduleType: string
+  scheduleSubType: string
+}
+
+export interface ChangeSource {
+  by: string
+  name: string
+}
+
+export interface HardwareSettings {
+  brightness: number
+  maxBrightness: number
+}
+
+export interface PartnerInfo {
+  singleOrMultiODUConfiguration: number
+  parentDeviceModelId: number
+  parentDeviceBrandId: number
+  oduName: string
+}
+
+export interface DeviceSettings {
+  temp: Temp
+  humidity: Humidity
+  userDefinedName: string
+  buzzerMuted: boolean
+  checkinPeriod: number
+  currentSensorReadPeriod: number
+}
+
+export interface Humidity {
+  high: Record<string, unknown>
+  low: Record<string, unknown>
+}
+
+export interface CurrentSensorReadings {
+  temperature: number
+  humidity: number
+}
+
+export interface Temp {
+  high: Record<string, unknown>
+  low: Record<string, unknown>
+}
+
+// T9 Room Sensors
+export interface sensorAccessory {
+  accessoryId: number
+  accessoryAttribute: accessoryAttribute
+  accessoryValue: accessoryValue
+  roomId: number
+}
+
+export interface accessoryAttribute {
+  type: string
+  connectionMethod: string
+  name: string
+  model: string
+  serialNumber: string
+  softwareRevision: string
+  hardwareRevision: string
+}
+
+export interface accessoryValue {
+  coolSetpoint: number
+  heatSetpoint: number
+  indoorHumidity: number
+  indoorTemperature: number
+  motionDet: boolean
+  occupancyDet: boolean
+  excludeTemp: boolean
+  excludeMotion: boolean
+  pressure: number
+  occupancyTimeout: number
+  status: string
+  batteryStatus: string
+  rssiAverage: number
+  occupancySensitivity: string
+}
+
+// T9 Room Priority
+export interface roomPriorityStatus {
+  deviceId: string
+  status: string
+  currentPriority: CurrentPriority
+}
+
+export interface CurrentPriority {
+  priorityType: string
+  selectedRooms: Record<string, unknown>
+  rooms: PriorityRooms[]
+}
+
+export interface PriorityRooms {
+  rooms: PriorityRoom
+}
+
+export interface PriorityRoom {
+  id: number
+  roomName: string
+  roomAvgTemp: number
+  roomAvgHumidity: number
+  overallMotion: boolean
+  accessories: Accessory[]
+}
+
+export interface Accessory {
+  id: number
+  type: string
+  excludeTemp: boolean
+  excludeMotion: boolean
+  temperature: number
+  status: string
+  detectMotion: boolean
+}
+
+export interface dataSyncInfo {
+  state: string // 'NotStarted' | 'Initiated' | 'Completed' | 'Failed'
+  transactionId: string // Internal reference ID for the DataSync operation
+}
+
+export interface actuatorValve {
+  commandSource: string// 'app' | 'wldFreeze' | 'wldLeak' | 'manual' | 'buildInLeak' | 'maintenance';
+  runningTime: number // Operation time
+  valveStatus: string // 'unknown' | 'open' | 'close' | 'notOpen' | 'notClose' | 'opening' | 'closing' | 'antiScaleOpening' | 'antiScaleClosing';
+  motorCycles: number // Count of motor operations
+  motorCurrentAverage: number
+  motorCurrentMax: number
+  deviceTemperature: number // Current temperature of device in Fahrenheit units
+  lastAntiScaleTime: Date // Last time of anti - scale operation
+  leakStatus: string // 'ok' | 'leak' | 'na' | 'err'
+  timeValveChanged: Date // Time of last valve change
+}
+
+export interface daylightSavingsInfo {
+  isDaylightSaving: boolean // If device is currently using DST or not
+  nextOffsetChange: Date // Next scheduled DST changeover
+}
+
+export interface maintenance {
+  antiScaleSettings: string // Current anti - scale cycle: 'OncePerWeek' | 'OncePerTwoWeeks' | 'OncePerMonth' | 'OncePerTwoMonths' | 'Disabled'
+  antiScaleDOWSettings: string // 'Sunday' | 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday'
+  antiScaleDOMSettings: number // If monthly anti - scale is used, day of the month.
+  antiScaleTimeSettings: string // Time for anti - scale in 24 hrs format
+}
+
+export interface fanStatus {
+  changeableValues: {
+    mode: string
+  }
+}

package/src/utils.ts

@@ -0,0 +1,61 @@
+/* Copyright(C) 2022-2024, donavanbecker (https://github.com/donavanbecker). All rights reserved.
+ *
+ * util.ts: homebridge-firstalert platform class.
+ */
+
+/**
+ * Converts the value to celsius if the temperature units are in Fahrenheit
+ */
+export function toCelsius(value: number, unit: number): number {
+  if (unit === 0) {
+    return value
+  }
+
+  // celsius should be to the nearest 0.5 degree
+  return Math.round((5 / 9) * (value - 32) * 2) / 2
+}
+
+/**
+ * Converts the value to fahrenheit if the temperature units are in Fahrenheit
+ */
+export function toFahrenheit(value: number, unit: number): number {
+  if (unit === 0) {
+    return value
+  }
+
+  return Math.round((value * 9) / 5 + 32)
+}
+
+// Map HomeKit Modes to FirstAlert Modes
+export enum HomeKitModes {
+  Off = 0, // this.hap.Characteristic.TargetHeatingCoolingState.OFF
+  Heat = 1, // this.hap.Characteristic.TargetHeatingCoolingState.HEAT
+  Cool = 2, // this.hap.Characteristic.TargetHeatingCoolingState.COOL
+  Auto = 3, // this.hap.Characteristic.TargetHeatingCoolingState.AUTO
+}
+
+// Don't change the order of these!
+export enum ResideoModes {
+  Off = 'Off',
+  Heat = 'Heat',
+  Cool = 'Cool',
+  Auto = 'Auto',
+};
+
+/*
+export enum holdModes {
+  NoHold = 0, //this.hap.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS
+  TemporaryHold = 1, //this.hap.Characteristic.ProgrammableSwitchEvent.DOUBLE_PRESS
+  PermanentHold = 2, //this.hap.Characteristic.ProgrammableSwitchEvent.LONG_PRESS
+}
+
+export enum fanModes {
+  Auto = 0, //this.hap.Characteristic.TargetFanState.AUTO
+  On = 1, //this.hap.Characteristic.TargetFanState.ON
+}
+
+export type resideoHold = {
+  NoHold: 'NoHold',
+  TemporaryHold: 'TemporaryHold',
+  PermanentHold: 'PermanentHold'
+}; */

package/test/index.test.ts

@@ -0,0 +1,18 @@
+import type { API } from 'homebridge'
+import { describe, expect, it, vi } from 'vitest'
+
+import registerPlatform from '../src/index.js'
+import { ResideoPlatform } from '../src/platform.js'
+import { PLATFORM_NAME, PLUGIN_NAME } from '../src/settings.js'
+
+describe('index.ts', () => {
+  it('should register the platform with homebridge', () => {
+    const apiMock: API = {
+      registerPlatform: vi.fn(),
+    } as unknown as API
+
+    registerPlatform(apiMock)
+
+    expect(apiMock.registerPlatform).toHaveBeenCalledWith(PLUGIN_NAME, PLATFORM_NAME, ResideoPlatform)
+  })
+})

package/test/platform.test.ts

@@ -0,0 +1,65 @@
+import type { API, Logging } from 'homebridge'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { ResideoPlatform } from '../src/platform.js'
+import type { ResideoPlatformConfig } from '../src/settings.js'
+
+vi.mock('axios')
+
+describe('resideoPlatform', () => {
+  let platform: ResideoPlatform
+  let log: Logging
+  let config: ResideoPlatformConfig
+  let api: API
+
+  beforeEach(() => {
+    log = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    } as unknown as Logging
+
+    config = {
+      platform: 'FirstAlert',
+      name: 'Test Platform',
+      credentials: {
+        accessToken: 'testAccessToken',
+        consumerKey: 'testConsumerKey',
+        consumerSecret: 'testConsumerSecret',
+        refreshToken: 'testRefreshToken',
+      },
+      options: {
+        refreshRate: 120,
+        pushRate: 0.1,
+        devices: [],
+      },
+    }
+
+    api = {
+      hap: {
+        uuid: {
+          generate: vi.fn().mockReturnValue('test-uuid'),
+        },
+      },
+      platformAccessory: vi.fn().mockImplementation((name, uuid) => ({
+        displayName: name,
+        UUID: uuid,
+        context: {},
+      })),
+      user: {
+        configPath: vi.fn().mockReturnValue('/path/to/config.json'),
+      },
+      on: vi.fn(),
+      updatePlatformAccessories: vi.fn(),
+    } as unknown as API
+
+    platform = new ResideoPlatform(log, config, api)
+  })
+
+  it('should initialize platform and call discoverDevices', async () => {
+    // The constructor should call discoverDevices (which logs an error if no refreshToken)
+    expect(platform).toBeDefined()
+    // Optionally, you can spy on log methods or client methods here
+  })
+})