@homebridge-plugins/homebridge-august 3.2.3 → 3.3.0-beta.0

package/test/device.test.ts

@@ -0,0 +1,384 @@
+import type { CharacteristicValue, Service } from 'homebridge'
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Create a simplified test implementation that mimics the updateCharacteristic behavior
+class MockDeviceWithCharacteristics {
+  accessory = { context: {} as Record<string, CharacteristicValue>, displayName: 'Test Lock' }
+  debugLog = vi.fn()
+  debugWarnLog = vi.fn()
+  infoLog = vi.fn()
+
+  async updateCharacteristic(
+    Service: Service,
+    ServiceName: string,
+    Characteristic: any,
+    CharacteristicValue: CharacteristicValue,
+    CharacteristicName: string,
+    Value?: CharacteristicValue,
+    StatusMatch?: string,
+    StatusDoesNotMatch?: string,
+  ): Promise<void> {
+    if (CharacteristicValue === undefined) {
+      await this.debugLog(`${CharacteristicName}: ${CharacteristicValue}`)
+    } else {
+      const contextKey = `${ServiceName}${CharacteristicName}`
+      await this.debugWarnLog(`context before: ${this.accessory.context[contextKey]}`)
+      const contextBefore = this.accessory.context[contextKey]
+      this.accessory.context[contextKey] = CharacteristicValue
+      await this.debugWarnLog(`context after: ${this.accessory.context[contextKey]}`)
+      await this.debugLog(`updateCharacteristic ${CharacteristicName}: ${CharacteristicValue} (${CharacteristicValue === Value ? StatusMatch : StatusDoesNotMatch})`)
+      if (contextBefore !== CharacteristicValue) {
+        // Value actually changed - push update to HomeKit
+        Service.updateCharacteristic(Characteristic, CharacteristicValue)
+        // Only log state change messages when we had a prior known value (not initial discovery)
+        if (contextBefore !== undefined && StatusMatch && StatusDoesNotMatch) {
+          await this.infoLog(`was ${CharacteristicValue === Value ? StatusMatch : StatusDoesNotMatch}`)
+        }
+      }
+    }
+  }
+}
+
+// Create a simplified test implementation that mimics the statusCode behavior
+class MockDevice {
+  debugLog = vi.fn()
+  debugErrorLog = vi.fn()
+
+  /**
+   * Check if error is a network timeout or session expiration that requires session refresh
+   * Handles 502 Bad Gateway, 401 Unauthorized, 503 Service Unavailable, and network timeouts
+   */
+  isTimeoutError(error: { message: string, name?: string, statusCode?: number }): boolean {
+    // Check for august-yale TimeoutError by name (stable contract — works regardless
+    // of message format changes) and Node.js network timeouts by message
+    if (error.name === 'TimeoutError' || error.message?.includes('ETIMEDOUT')) {
+      return true
+    }
+
+    // Check for status codes that indicate session expiration or temporary server issues
+    // 502 Bad Gateway - typically indicates session has expired or server issues
+    // 503 Service Unavailable - temporary server issues
+    // 401 Unauthorized - session has expired
+    if (error.statusCode && (error.statusCode === 502 || error.statusCode === 503 || error.statusCode === 401)) {
+      return true
+    }
+
+    // Check for error messages containing these status codes (from tiny-json-http error format)
+    // Format: "POST failed with: 502" or "GET failed with: 401"
+    if (error.message) {
+      const sessionErrorPatterns = [
+        /failed with: 502/i,
+        /failed with: 503/i,
+        /failed with: 401/i,
+        /Bad Gateway/i,
+        /Service Unavailable/i,
+        /Unauthorized/i,
+      ]
+      return sessionErrorPatterns.some(pattern => pattern.test(error.message))
+    }
+
+    return false
+  }
+
+  async statusCode(action: string, error: { message: string, constructor?: { name: string } }): Promise<void> {
+    const statusCodeString = error.message || '' // Convert statusCode to a string, handle undefined/null
+
+    // Check if the error is an AggregateError or doesn't contain a status code
+    if (error.constructor?.name === 'AggregateError' || !/^\d{3}/.test(statusCodeString)) {
+      await this.debugErrorLog(`${action} failed with ${error.constructor?.name || 'Error'}: ${statusCodeString}`)
+      return
+    }
+
+    const statusCode = statusCodeString.slice(0, 3)
+    const logMap: Record<string, string> = {
+      100: `Command successfully sent, statusCode: ${statusCodeString}`,
+      200: `Request successful, statusCode: ${statusCodeString}`,
+      400: `Bad Request, statusCode: ${statusCodeString}`,
+      429: `Too Many Requests, exceeded the number of requests allowed for a given time window, statusCode: ${statusCodeString}`,
+    }
+    const logMessage = logMap[statusCode]
+      ?? `Unknown statusCode: ${statusCodeString}, Submit Bugs Here: https://tinyurl.com/AugustYaleBug`
+    await this.debugLog(logMessage)
+    if (!logMap[statusCode]) {
+      await this.debugErrorLog(`failed ${action}, Error: ${error}`)
+    }
+  }
+}
+
+describe('statusCode error handling', () => {
+  let mockDevice: MockDevice
+
+  beforeEach(() => {
+    mockDevice = new MockDevice()
+  })
+
+  describe('isTimeoutError method', () => {
+    it('should detect august-yale TimeoutError by error.name', () => {
+      const error = { message: 'Request timed out after 30000ms', name: 'TimeoutError' }
+      expect(mockDevice.isTimeoutError(error)).toBe(true)
+    })
+
+    it('should detect august-yale TimeoutError regardless of message content', () => {
+      const error = { message: 'anything', name: 'TimeoutError' }
+      expect(mockDevice.isTimeoutError(error)).toBe(true)
+    })
+
+    it('should detect ETIMEDOUT network errors', () => {
+      const error = { message: 'ETIMEDOUT connection timed out' }
+      expect(mockDevice.isTimeoutError(error)).toBe(true)
+    })
+
+    it('should detect 502 Bad Gateway status code', () => {
+      const error = { message: 'POST failed with: 502', statusCode: 502 }
+      expect(mockDevice.isTimeoutError(error)).toBe(true)
+    })
+
+    it('should detect 502 in error message', () => {
+      const error = { message: 'POST failed with: 502' }
+      expect(mockDevice.isTimeoutError(error)).toBe(true)
+    })
+
+    it('should detect 503 Service Unavailable status code', () => {
+      const error = { message: 'GET failed with: 503', statusCode: 503 }
+      expect(mockDevice.isTimeoutError(error)).toBe(true)
+    })
+
+    it('should detect 503 in error message', () => {
+      const error = { message: 'Service Unavailable' }
+      expect(mockDevice.isTimeoutError(error)).toBe(true)
+    })
+
+    it('should detect 401 Unauthorized status code', () => {
+      const error = { message: 'POST failed with: 401', statusCode: 401 }
+      expect(mockDevice.isTimeoutError(error)).toBe(true)
+    })
+
+    it('should detect 401 in error message', () => {
+      const error = { message: 'Unauthorized access' }
+      expect(mockDevice.isTimeoutError(error)).toBe(true)
+    })
+
+    it('should detect Bad Gateway in error message', () => {
+      const error = { message: 'Bad Gateway' }
+      expect(mockDevice.isTimeoutError(error)).toBe(true)
+    })
+
+    it('should return false for non-timeout errors', () => {
+      const error = { message: '404 Not Found' }
+      expect(mockDevice.isTimeoutError(error)).toBe(false)
+    })
+
+    it('should return false for 400 Bad Request', () => {
+      const error = { message: '400 Bad Request', statusCode: 400 }
+      expect(mockDevice.isTimeoutError(error)).toBe(false)
+    })
+
+    it('should return false for 429 Too Many Requests', () => {
+      const error = { message: '429 Too Many Requests', statusCode: 429 }
+      expect(mockDevice.isTimeoutError(error)).toBe(false)
+    })
+
+    it('should return false for empty message', () => {
+      const error = { message: '' }
+      expect(mockDevice.isTimeoutError(error)).toBe(false)
+    })
+
+    it('should return false for errors with non-timeout name', () => {
+      const error = { message: 'something failed', name: 'Error' }
+      expect(mockDevice.isTimeoutError(error)).toBe(false)
+    })
+
+    it('should not match 401 in non-HTTP status contexts', () => {
+      const error = { message: 'Expected 4012 records but found 401' }
+      expect(mockDevice.isTimeoutError(error)).toBe(false)
+    })
+
+    it('should not match 502 in non-HTTP status contexts', () => {
+      const error = { message: 'Lock ID 50234 not found' }
+      expect(mockDevice.isTimeoutError(error)).toBe(false)
+    })
+  })
+
+  describe('statusCode method', () => {
+    it('should handle standard HTTP status codes', async () => {
+      await mockDevice.statusCode('test action', { message: '400 Bad Request' })
+
+      expect(mockDevice.debugLog).toHaveBeenCalledWith('Bad Request, statusCode: 400 Bad Request')
+      expect(mockDevice.debugErrorLog).not.toHaveBeenCalled()
+    })
+
+    it('should handle AggregateError specifically', async () => {
+      await mockDevice.statusCode('refreshStatus', {
+        message: 'Multiple errors occurred',
+        constructor: { name: 'AggregateError' },
+      })
+
+      expect(mockDevice.debugErrorLog).toHaveBeenCalledWith('refreshStatus failed with AggregateError: Multiple errors occurred')
+      expect(mockDevice.debugLog).not.toHaveBeenCalled()
+    })
+
+    it('should handle error with empty message', async () => {
+      await mockDevice.statusCode('refreshStatus', { message: '' })
+
+      expect(mockDevice.debugErrorLog).toHaveBeenCalledWith('refreshStatus failed with Object: ')
+      expect(mockDevice.debugLog).not.toHaveBeenCalled()
+    })
+
+    it('should handle error message without numeric status code', async () => {
+      await mockDevice.statusCode('refreshStatus', { message: 'Network connection failed' })
+
+      expect(mockDevice.debugErrorLog).toHaveBeenCalledWith('refreshStatus failed with Object: Network connection failed')
+      expect(mockDevice.debugLog).not.toHaveBeenCalled()
+    })
+
+    it('should handle 429 Too Many Requests status code', async () => {
+      await mockDevice.statusCode('test action', { message: '429 Too Many Requests' })
+
+      expect(mockDevice.debugLog).toHaveBeenCalledWith('Too Many Requests, exceeded the number of requests allowed for a given time window, statusCode: 429 Too Many Requests')
+      expect(mockDevice.debugErrorLog).not.toHaveBeenCalled()
+    })
+
+    it('should handle unknown numeric status codes', async () => {
+      await mockDevice.statusCode('test action', { message: '503 Service Unavailable' })
+
+      expect(mockDevice.debugLog).toHaveBeenCalledWith('Unknown statusCode: 503 Service Unavailable, Submit Bugs Here: https://tinyurl.com/AugustYaleBug')
+      expect(mockDevice.debugErrorLog).toHaveBeenCalledWith('failed test action, Error: [object Object]')
+    })
+  })
+})
+
+describe('updateCharacteristic', () => {
+  let device: MockDeviceWithCharacteristics
+  let mockService: Service
+  const CHARACTERISTIC = 'LockCurrentState'
+
+  beforeEach(() => {
+    device = new MockDeviceWithCharacteristics()
+    mockService = {
+      updateCharacteristic: vi.fn(),
+    } as unknown as Service
+  })
+
+  it('should skip HomeKit update when CharacteristicValue is undefined', async () => {
+    await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, undefined as any, 'LockCurrentState')
+
+    expect(mockService.updateCharacteristic).not.toHaveBeenCalled()
+    expect(device.debugLog).toHaveBeenCalledWith('LockCurrentState: undefined')
+  })
+
+  describe('initial state discovery (no prior context)', () => {
+    it('should push value to HomeKit on first update', async () => {
+      await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, 0, 'LockCurrentState', 1, 'Locked', 'Unlocked')
+
+      expect(mockService.updateCharacteristic).toHaveBeenCalledWith(CHARACTERISTIC, 0)
+    })
+
+    it('should NOT log info message on initial discovery', async () => {
+      await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, 0, 'LockCurrentState', 1, 'Locked', 'Unlocked')
+
+      expect(device.infoLog).not.toHaveBeenCalled()
+    })
+
+    it('should store the value in context for future comparisons', async () => {
+      await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, 0, 'LockCurrentState', 1, 'Locked', 'Unlocked')
+
+      expect(device.accessory.context.LockMechanismLockCurrentState).toBe(0)
+    })
+  })
+
+  describe('subsequent updates with unchanged value', () => {
+    it('should NOT push to HomeKit when value has not changed', async () => {
+      // Seed context as if a previous update occurred
+      device.accessory.context.LockMechanismLockCurrentState = 1
+
+      await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, 1, 'LockCurrentState', 1, 'Locked', 'Unlocked')
+
+      expect(mockService.updateCharacteristic).not.toHaveBeenCalled()
+    })
+
+    it('should NOT log info message when value has not changed', async () => {
+      device.accessory.context.LockMechanismLockCurrentState = 1
+
+      await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, 1, 'LockCurrentState', 1, 'Locked', 'Unlocked')
+
+      expect(device.infoLog).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('genuine state change', () => {
+    it('should push to HomeKit when value changes', async () => {
+      device.accessory.context.LockMechanismLockCurrentState = 1
+
+      await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, 0, 'LockCurrentState', 1, 'Locked', 'Unlocked')
+
+      expect(mockService.updateCharacteristic).toHaveBeenCalledWith(CHARACTERISTIC, 0)
+    })
+
+    it('should log "was Unlocked" when lock changes from secured to unsecured', async () => {
+      device.accessory.context.LockMechanismLockCurrentState = 1
+
+      await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, 0, 'LockCurrentState', 1, 'Locked', 'Unlocked')
+
+      expect(device.infoLog).toHaveBeenCalledWith('was Unlocked')
+    })
+
+    it('should log "was Locked" when lock changes from unsecured to secured', async () => {
+      device.accessory.context.LockMechanismLockCurrentState = 0
+
+      await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, 1, 'LockCurrentState', 1, 'Locked', 'Unlocked')
+
+      expect(device.infoLog).toHaveBeenCalledWith('was Locked')
+    })
+
+    it('should update context to new value', async () => {
+      device.accessory.context.LockMechanismLockCurrentState = 1
+
+      await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, 0, 'LockCurrentState', 1, 'Locked', 'Unlocked')
+
+      expect(device.accessory.context.LockMechanismLockCurrentState).toBe(0)
+    })
+  })
+
+  describe('contact sensor state changes', () => {
+    it('should log "was Closed" when door changes to closed', async () => {
+      device.accessory.context.ContactSensorContactSensorState = 1
+
+      await device.updateCharacteristic(mockService, 'ContactSensor', 'ContactSensorState', 0, 'ContactSensorState', 1, 'Opened', 'Closed')
+
+      expect(device.infoLog).toHaveBeenCalledWith('was Closed')
+    })
+
+    it('should log "was Opened" when door changes to open', async () => {
+      device.accessory.context.ContactSensorContactSensorState = 0
+
+      await device.updateCharacteristic(mockService, 'ContactSensor', 'ContactSensorState', 1, 'ContactSensorState', 1, 'Opened', 'Closed')
+
+      expect(device.infoLog).toHaveBeenCalledWith('was Opened')
+    })
+  })
+
+  describe('updates without StatusMatch/StatusDoesNotMatch', () => {
+    it('should push to HomeKit but not log info when no status strings provided', async () => {
+      device.accessory.context.BatteryBatteryLevel = 90
+
+      await device.updateCharacteristic(mockService, 'Battery', 'BatteryLevel', 85, 'BatteryLevel')
+
+      expect(mockService.updateCharacteristic).toHaveBeenCalledWith('BatteryLevel', 85)
+      expect(device.infoLog).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('startup simulation (seeded context matches API response)', () => {
+    it('should not push to HomeKit or log when seeded context matches first API value', async () => {
+      // Simulate constructor seeding: accessory.context.LockMechanismLockCurrentState ??= SECURED
+      device.accessory.context.LockMechanismLockCurrentState = 1
+
+      // First API response returns same state (SECURED = 1)
+      await device.updateCharacteristic(mockService, 'LockMechanism', CHARACTERISTIC, 1, 'LockCurrentState', 1, 'Locked', 'Unlocked')
+
+      expect(mockService.updateCharacteristic).not.toHaveBeenCalled()
+      expect(device.infoLog).not.toHaveBeenCalled()
+    })
+  })
+})

package/test/{platform.test.ts → platform.hap.test.ts}

@@ -10,7 +10,7 @@ import { readFileSync, writeFileSync } from 'node:fs'
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { AugustPlatform } from '../src/Platform.HAP.js'
+import { AugustPlatformHAP } from '../src/Platform.HAP.js'
 
 // Mock the august-yale module
 vi.mock('august-yale', () => {
@@ -37,7 +37,7 @@ vi.mock('node:fs', () => ({
 }))
 
 describe('augustPlatform', () => {
-  let platform: AugustPlatform
+  let platform: AugustPlatformHAP
   let mockApi: API
   let mockLog: Logging
   let mockConfig: AugustPlatformConfig
@@ -110,7 +110,7 @@ describe('augustPlatform', () => {
       },
     }
 
-    platform = new AugustPlatform(mockLog, config, mockApi)
+    platform = new AugustPlatformHAP(mockLog, config, mockApi)
 
     // Access the private method for testing
     const normalizeMethod = (platform as any).normalizeCredentialsForApi.bind(platform)
@@ -137,7 +137,7 @@ describe('augustPlatform', () => {
       },
     }
 
-    platform = new AugustPlatform(mockLog, config, mockApi)
+    platform = new AugustPlatformHAP(mockLog, config, mockApi)
 
     // Access the private method for testing
     const normalizeMethod = (platform as any).normalizeCredentialsForApi.bind(platform)
@@ -165,7 +165,7 @@ describe('augustPlatform', () => {
       },
     }
 
-    platform = new AugustPlatform(mockLog, config, mockApi)
+    platform = new AugustPlatformHAP(mockLog, config, mockApi)
 
     // Access the private method for testing
     const normalizeMethod = (platform as any).normalizeCredentialsForApi.bind(platform)
@@ -192,7 +192,7 @@ describe('augustPlatform', () => {
       },
     }
 
-    platform = new AugustPlatform(mockLog, config, mockApi)
+    platform = new AugustPlatformHAP(mockLog, config, mockApi)
 
     // Access the private method for testing
     const normalizeMethod = (platform as any).normalizeCredentialsForApi.bind(platform)
@@ -217,7 +217,7 @@ describe('augustPlatform', () => {
       },
     }
 
-    platform = new AugustPlatform(mockLog, config, mockApi)
+    platform = new AugustPlatformHAP(mockLog, config, mockApi)
 
     // Access the private method for testing
     const normalizeMethod = (platform as any).normalizeCredentialsForApi.bind(platform)
@@ -245,7 +245,7 @@ describe('augustPlatform', () => {
       },
     }
 
-    platform = new AugustPlatform(mockLog, config, mockApi)
+    platform = new AugustPlatformHAP(mockLog, config, mockApi)
 
     // Access the private method for testing
     const normalizeMethod = (platform as any).normalizeCredentialsForApi.bind(platform)
@@ -277,7 +277,7 @@ describe('augustPlatform', () => {
       },
     }
 
-    platform = new AugustPlatform(mockLog, config, mockApi)
+    platform = new AugustPlatformHAP(mockLog, config, mockApi)
 
     // Test the public method
     const normalizedCredentials = await platform.getNormalizedCredentials()
@@ -302,7 +302,7 @@ describe('augustPlatform', () => {
       },
     }
 
-    platform = new AugustPlatform(mockLog, config, mockApi)
+    platform = new AugustPlatformHAP(mockLog, config, mockApi)
 
     // Access the private method for testing
     const normalizeMethod = (platform as any).normalizeCredentialsForApi.bind(platform)
@@ -327,7 +327,7 @@ describe('augustPlatform', () => {
       },
     }
 
-    platform = new AugustPlatform(mockLog, config, mockApi)
+    platform = new AugustPlatformHAP(mockLog, config, mockApi)
 
     // First call should normalize and cache
     const firstCall = await platform.getNormalizedCredentials()
@@ -346,7 +346,7 @@ describe('augustPlatform', () => {
   describe('discoverDevices', () => {
     it('should handle 401 authentication errors and trigger re-authentication', async () => {
       // Create platform instance
-      platform = new AugustPlatform(mockLog, mockConfig, mockApi)
+      platform = new AugustPlatformHAP(mockLog, mockConfig, mockApi)
 
       // Mock August.details to throw 401 error
       const August = await import('august-yale')
@@ -370,7 +370,7 @@ describe('augustPlatform', () => {
 
     it('should handle "unauthorized" errors and trigger re-authentication', async () => {
       // Create platform instance
-      platform = new AugustPlatform(mockLog, mockConfig, mockApi)
+      platform = new AugustPlatformHAP(mockLog, mockConfig, mockApi)
 
       // Mock August.details to throw unauthorized error
       const August = await import('august-yale')
@@ -391,7 +391,7 @@ describe('augustPlatform', () => {
 
     it('should re-throw non-authentication errors', async () => {
       // Create platform instance
-      platform = new AugustPlatform(mockLog, mockConfig, mockApi)
+      platform = new AugustPlatformHAP(mockLog, mockConfig, mockApi)
 
       // Mock August.details to throw non-401 error
       const August = await import('august-yale')
@@ -405,7 +405,7 @@ describe('augustPlatform', () => {
 
     it('should process devices successfully when no errors occur', async () => {
       // Create platform instance
-      platform = new AugustPlatform(mockLog, mockConfig, mockApi)
+      platform = new AugustPlatformHAP(mockLog, mockConfig, mockApi)
 
       // Mock successful August.details response
       const August = await import('august-yale')
@@ -440,7 +440,7 @@ describe('augustPlatform', () => {
         },
       }
 
-      platform = new AugustPlatform(mockLog, configWithExcludes, mockApi)
+      platform = new AugustPlatformHAP(mockLog, configWithExcludes, mockApi)
 
       const August = await import('august-yale')
       const mockDeviceIncluded = { lockId: 'included-lock-id', LockName: 'Included Lock' } as any
@@ -465,7 +465,7 @@ describe('augustPlatform', () => {
         },
       }
 
-      platform = new AugustPlatform(mockLog, configWithExcludes, mockApi)
+      platform = new AugustPlatformHAP(mockLog, configWithExcludes, mockApi)
 
       const August = await import('august-yale')
       const mockDeviceIncluded = { lockId: 'included-lock-id', LockName: 'Included Lock' } as any
@@ -492,7 +492,7 @@ describe('augustPlatform', () => {
       // Make uuid.generate return predictable UUIDs based on input
       vi.mocked(mockApi.hap.uuid.generate).mockImplementation((input: any) => `uuid-${input}`)
 
-      platform = new AugustPlatform(mockLog, configWithExcludes, mockApi)
+      platform = new AugustPlatformHAP(mockLog, configWithExcludes, mockApi)
 
       // Simulate a cached accessory for the excluded lock
       const mockAccessory = {
@@ -528,7 +528,7 @@ describe('augustPlatform', () => {
         },
       }
 
-      platform = new AugustPlatform(mockLog, configWithEmptyExcludes, mockApi)
+      platform = new AugustPlatformHAP(mockLog, configWithEmptyExcludes, mockApi)
 
       const August = await import('august-yale')
       const mockDeviceA = { lockId: 'lock-a', LockName: 'Lock A' } as any
@@ -554,7 +554,7 @@ describe('augustPlatform', () => {
         },
       }
 
-      platform = new AugustPlatform(mockLog, configWithBoth, mockApi)
+      platform = new AugustPlatformHAP(mockLog, configWithBoth, mockApi)
 
       const August = await import('august-yale')
       const mockDeviceIncluded = { lockId: 'included-lock-id', LockName: 'Included Lock' } as any
@@ -585,7 +585,7 @@ describe('augustPlatform', () => {
 
       vi.mocked(readFileSync).mockReturnValue(JSON.stringify(mockConfigFile))
 
-      platform = new AugustPlatform(mockLog, mockConfig, mockApi)
+      platform = new AugustPlatformHAP(mockLog, mockConfig, mockApi)
 
       // This should not throw an error when trying to set installId
       await expect(platform.validated()).resolves.toBeUndefined()
@@ -605,7 +605,7 @@ describe('augustPlatform', () => {
 
       vi.mocked(readFileSync).mockReturnValue(JSON.stringify(mockConfigFile))
 
-      platform = new AugustPlatform(mockLog, mockConfig, mockApi)
+      platform = new AugustPlatformHAP(mockLog, mockConfig, mockApi)
 
       // This should not throw an error when trying to set installId
       await expect(platform.validated()).resolves.toBeUndefined()
@@ -625,7 +625,7 @@ describe('augustPlatform', () => {
 
       vi.mocked(readFileSync).mockReturnValue(JSON.stringify(mockConfigFile))
 
-      platform = new AugustPlatform(mockLog, mockConfig, mockApi)
+      platform = new AugustPlatformHAP(mockLog, mockConfig, mockApi)
 
       await platform.validated()
 

package/test/platform.polling.test.ts

@@ -33,7 +33,7 @@ import { readFileSync } from 'node:fs'
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { AugustPlatform } from '../src/Platform.HAP.js'
+import { AugustPlatformHAP } from '../src/Platform.HAP.js'
 
 // Same mock conventions as the rest of the suite.
 vi.mock('august-yale', () => {
@@ -57,7 +57,7 @@ vi.mock('node:fs', () => ({
 // execute() runs the supplied fn against a fake "client" passed through
 // from the test. Returns the underlying mock execute fn for assertions.
 function installConnectivity(
-  platform: AugustPlatform,
+  platform: AugustPlatformHAP,
   client: any,
   state: 'healthy' | 'degraded' | 'offline' | 'recovering' = 'healthy',
 ) {
@@ -78,7 +78,7 @@ function installConnectivity(
 // Helper: register N stub LockMechanism objects on the platform. Each
 // has its own lockId and a vi.fn() applyRefresh. Returns the array of
 // stubs in registration order.
-function registerLocks(platform: AugustPlatform, count: number) {
+function registerLocks(platform: AugustPlatformHAP, count: number) {
   const locks: any[] = []
   for (let i = 0; i < count; i++) {
     const lock = {
@@ -94,7 +94,7 @@ function registerLocks(platform: AugustPlatform, count: number) {
 }
 
 describe('augustPlatform.startPolling', () => {
-  let platform: AugustPlatform
+  let platform: AugustPlatformHAP
   let mockApi: API
   let mockLog: Logging
   let mockConfig: AugustPlatformConfig
@@ -137,7 +137,7 @@ describe('augustPlatform.startPolling', () => {
       options: { logging: 'debug' },
     }
 
-    platform = new AugustPlatform(mockLog, mockConfig, mockApi)
+    platform = new AugustPlatformHAP(mockLog, mockConfig, mockApi)
     // Force a deterministic poll interval (1s) so tests can advance
     // time precisely.
     ;(platform as any).platformRefreshRate = 1

package/.github/scripts/compute-version-override.cjs

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-
-const child = require('node:child_process')
-const fs = require('node:fs')
-
-const bump = (process.argv[2] || 'patch').toLowerCase()
-const allowed = new Set(['major', 'minor', 'patch'])
-
-if (!allowed.has(bump)) {
-  console.error(`Invalid bump level '${bump}'. Use major, minor, or patch.`)
-  process.exit(1)
-}
-
-const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'))
-
-function inc(v, level) {
-  const parts = v.split('-')[0].split('+')[0].split('.').map(Number)
-  if (level === 'major') {
-    parts[0] += 1
-    parts[1] = 0
-    parts[2] = 0
-  } else if (level === 'minor') {
-    parts[1] += 1
-    parts[2] = 0
-  } else {
-    parts[2] += 1
-  }
-  return parts.join('.')
-}
-
-function latestStable(name) {
-  try {
-    const versions = JSON.parse(child.execSync(`npm info ${name} versions --json`).toString('utf8').trim())
-    const stable = (Array.isArray(versions) ? versions : [])
-      .filter(v => /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-.]+)?(?:\+[0-9A-Za-z-.]+)?$/.test(v) && !v.includes('-'))
-    stable.sort((a, b) => {
-      const ap = a.split('.').map(Number)
-      const bp = b.split('.').map(Number)
-      for (let i = 0; i < 3; i++) {
-        if (ap[i] !== bp[i]) return bp[i] - ap[i]
-      }
-      return 0
-    })
-    return stable[0] || ''
-  } catch {
-    return ''
-  }
-}
-
-const base = latestStable(pkg.name) || pkg.version
-process.stdout.write(inc(base, bump))