homebridge-yoto 0.0.6 → 0.0.8

package/lib/constants.js

@@ -21,32 +21,33 @@ export const YOTO_OAUTH_DEVICE_CODE_URL = `${YOTO_OAUTH_BASE_URL}/oauth/device/c
  * MQTT configuration
  */
 export const YOTO_MQTT_BROKER_URL = 'wss://aqrphjqbp3u2z-ats.iot.eu-west-2.amazonaws.com'
+export const YOTO_MQTT_AUTH_NAME = 'PublicJWTAuthorizer'
 export const MQTT_RECONNECT_PERIOD = 5000 // milliseconds
 export const MQTT_CONNECT_TIMEOUT = 30000 // milliseconds
 
 /**
  * MQTT topic templates
  */
-export const MQTT_TOPIC_DATA_STATUS = '/device/{deviceId}/data/status'
-export const MQTT_TOPIC_DATA_EVENTS = '/device/{deviceId}/data/events'
-export const MQTT_TOPIC_RESPONSE = '/device/{deviceId}/response'
-export const MQTT_TOPIC_COMMAND_STATUS_REQUEST = '/device/{deviceId}/command/status/request'
-export const MQTT_TOPIC_COMMAND_EVENTS_REQUEST = '/device/{deviceId}/command/events/request'
-export const MQTT_TOPIC_COMMAND_VOLUME_SET = '/device/{deviceId}/command/volume/set'
-export const MQTT_TOPIC_COMMAND_CARD_START = '/device/{deviceId}/command/card/start'
-export const MQTT_TOPIC_COMMAND_CARD_STOP = '/device/{deviceId}/command/card/stop'
-export const MQTT_TOPIC_COMMAND_CARD_PAUSE = '/device/{deviceId}/command/card/pause'
-export const MQTT_TOPIC_COMMAND_CARD_RESUME = '/device/{deviceId}/command/card/resume'
-export const MQTT_TOPIC_COMMAND_SLEEP_TIMER = '/device/{deviceId}/command/sleep-timer/set'
-export const MQTT_TOPIC_COMMAND_AMBIENTS_SET = '/device/{deviceId}/command/ambients/set'
-export const MQTT_TOPIC_COMMAND_REBOOT = '/device/{deviceId}/command/reboot'
+export const MQTT_TOPIC_DATA_STATUS = 'device/{deviceId}/status'
+export const MQTT_TOPIC_DATA_EVENTS = 'device/{deviceId}/events'
+export const MQTT_TOPIC_RESPONSE = 'device/{deviceId}/response'
+export const MQTT_TOPIC_COMMAND_STATUS_REQUEST = 'device/{deviceId}/command/status/request'
+export const MQTT_TOPIC_COMMAND_EVENTS_REQUEST = 'device/{deviceId}/command/events/request'
+export const MQTT_TOPIC_COMMAND_VOLUME_SET = 'device/{deviceId}/command/volume/set'
+export const MQTT_TOPIC_COMMAND_CARD_START = 'device/{deviceId}/command/card/start'
+export const MQTT_TOPIC_COMMAND_CARD_STOP = 'device/{deviceId}/command/card/stop'
+export const MQTT_TOPIC_COMMAND_CARD_PAUSE = 'device/{deviceId}/command/card/pause'
+export const MQTT_TOPIC_COMMAND_CARD_RESUME = 'device/{deviceId}/command/card/resume'
+export const MQTT_TOPIC_COMMAND_SLEEP_TIMER = 'device/{deviceId}/command/sleep-timer/set'
+export const MQTT_TOPIC_COMMAND_AMBIENTS_SET = 'device/{deviceId}/command/ambients/set'
+export const MQTT_TOPIC_COMMAND_REBOOT = 'device/{deviceId}/command/reboot'
 
 /**
  * OAuth configuration
  */
 export const OAUTH_CLIENT_ID = 'Y4HJ8BFqRQ24GQoLzgOzZ2KSqWmFG8LI'
 export const OAUTH_AUDIENCE = 'https://api.yotoplay.com'
-export const OAUTH_SCOPE = 'profile offline_access'
+export const OAUTH_SCOPE = 'openid profile offline_access'
 export const OAUTH_POLLING_INTERVAL = 5000 // milliseconds
 export const OAUTH_DEVICE_CODE_TIMEOUT = 300000 // 5 minutes
 

package/lib/platform.js

@@ -5,9 +5,10 @@
 /** @import { API, DynamicPlatformPlugin, Logger, PlatformAccessory, PlatformConfig } from 'homebridge' */
 /** @import { YotoDevice, YotoPlatformConfig, YotoAccessoryContext } from './types.js' */
 
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import { join } from 'path'
 import { YotoAuth } from './auth.js'
 import { YotoApi } from './yotoApi.js'
-import { YotoMqtt } from './yotoMqtt.js'
 import { YotoPlayerAccessory } from './playerAccessory.js'
 import {
   PLATFORM_NAME,
@@ -44,10 +45,13 @@ export class YotoPlatform {
     /** @type {string[]} */
     this.discoveredUUIDs = []
 
+    // Persistent storage path for tokens
+    this.storagePath = api.user.storagePath()
+    this.tokenFilePath = join(this.storagePath, 'homebridge-yoto-tokens.json')
+
     // Initialize API clients
     this.auth = new YotoAuth(log, this.config.clientId)
     this.yotoApi = new YotoApi(log, this.auth)
-    this.yotoMqtt = new YotoMqtt(log)
 
     // Set up token refresh callback
     this.yotoApi.setTokenRefreshCallback(this.handleTokenRefresh.bind(this))
@@ -69,25 +73,12 @@ export class YotoPlatform {
    */
   async initialize () {
     try {
+      // Load tokens from persistent storage
+      await this.loadTokens()
+
       // Check if we have stored credentials
       if (!this.config.accessToken || !this.config.refreshToken) {
-        this.log.warn(LOG_PREFIX.PLATFORM, ERROR_MESSAGES.NO_AUTH)
-        this.log.info(LOG_PREFIX.PLATFORM, 'Starting OAuth flow...')
-
-        const tokenResponse = await this.auth.authorize()
-
-        // Store tokens in config
-        this.config.accessToken = tokenResponse.access_token
-        this.config.refreshToken = tokenResponse.refresh_token || ''
-        this.config.tokenExpiresAt = this.auth.calculateExpiresAt(tokenResponse.expires_in)
-
-        this.log.info(LOG_PREFIX.PLATFORM, '✓ Authentication successful!')
-        this.log.warn(LOG_PREFIX.PLATFORM, 'IMPORTANT: Please update your Homebridge config with the following:')
-        this.log.warn(LOG_PREFIX.PLATFORM, JSON.stringify({
-          accessToken: this.config.accessToken,
-          refreshToken: this.config.refreshToken,
-          tokenExpiresAt: this.config.tokenExpiresAt
-        }, null, 2))
+        await this.performDeviceFlow()
       }
 
       // Set tokens in API client
@@ -97,16 +88,61 @@ export class YotoPlatform {
         this.config.tokenExpiresAt || 0
       )
 
-      // Connect to MQTT
-      await this.yotoMqtt.connect(this.config.accessToken)
-
       // Discover and register devices
-      await this.discoverDevices()
+      try {
+        await this.discoverDevices()
+      } catch (error) {
+        // Check if this is an auth error that requires re-authentication
+        if (error instanceof Error && error.message.includes('TOKEN_REFRESH_FAILED')) {
+          this.log.warn(LOG_PREFIX.PLATFORM, 'Token refresh failed, clearing tokens and restarting auth flow...')
+          await this.clearTokensAndReauth()
+          return
+        }
+        throw error
+      }
     } catch (error) {
       this.log.error(LOG_PREFIX.PLATFORM, 'Initialization failed:', error)
     }
   }
 
+  /**
+   * Perform device authorization flow
+   * @returns {Promise<void>}
+   */
+  async performDeviceFlow () {
+    this.log.warn(LOG_PREFIX.PLATFORM, ERROR_MESSAGES.NO_AUTH)
+    this.log.info(LOG_PREFIX.PLATFORM, 'Starting OAuth flow...')
+
+    const tokenResponse = await this.auth.authorize()
+
+    // Store tokens in config
+    this.config.accessToken = tokenResponse.access_token
+    this.config.refreshToken = tokenResponse.refresh_token || ''
+    this.config.tokenExpiresAt = this.auth.calculateExpiresAt(tokenResponse.expires_in)
+
+    // Save tokens to persistent storage
+    await this.saveTokens()
+
+    this.log.info(LOG_PREFIX.PLATFORM, '✓ Authentication successful and saved!')
+  }
+
+  /**
+   * Clear invalid tokens and restart authentication
+   * @returns {Promise<void>}
+   */
+  async clearTokensAndReauth () {
+    // Clear tokens from config
+    this.config.accessToken = ''
+    this.config.refreshToken = ''
+    this.config.tokenExpiresAt = 0
+
+    // Save cleared tokens
+    await this.saveTokens()
+
+    // Restart initialization
+    await this.initialize()
+  }
+
   /**
    * Handle token refresh - update config
    * @param {string} accessToken - New access token
@@ -114,17 +150,69 @@ export class YotoPlatform {
    * @param {number} expiresAt - New expiration timestamp
    */
   handleTokenRefresh (accessToken, refreshToken, expiresAt) {
-    this.log.info(LOG_PREFIX.PLATFORM, 'Token refreshed, please update your config')
+    this.log.info(LOG_PREFIX.PLATFORM, 'Token refreshed')
     this.config.accessToken = accessToken
     this.config.refreshToken = refreshToken
     this.config.tokenExpiresAt = expiresAt
 
-    // Update MQTT connection with new token
-    this.yotoMqtt.disconnect().then(() => {
-      return this.yotoMqtt.connect(accessToken)
-    }).catch(error => {
-      this.log.error(LOG_PREFIX.PLATFORM, 'Failed to reconnect MQTT after token refresh:', error)
+    // Save updated tokens to persistent storage
+    this.saveTokens().catch(error => {
+      this.log.error(LOG_PREFIX.PLATFORM, 'Failed to save refreshed tokens:', error)
     })
+
+    // Note: MQTT reconnection is handled by each accessory's own MQTT client
+  }
+
+  /**
+   * Load tokens from config or persistent storage
+   * Priority: config.json > persistent storage file
+   * @returns {Promise<void>}
+   */
+  async loadTokens () {
+    // First check if tokens are in config.json
+    if (this.config.accessToken && this.config.refreshToken) {
+      this.log.debug(LOG_PREFIX.PLATFORM, 'Using tokens from config.json')
+      return
+    }
+
+    // Fall back to persistent storage file
+    try {
+      const data = await readFile(this.tokenFilePath, 'utf-8')
+      const tokens = JSON.parse(data)
+
+      if (tokens.accessToken && tokens.refreshToken) {
+        this.config.accessToken = tokens.accessToken
+        this.config.refreshToken = tokens.refreshToken
+        this.config.tokenExpiresAt = tokens.tokenExpiresAt
+        this.log.debug(LOG_PREFIX.PLATFORM, 'Loaded tokens from persistent storage')
+      }
+    } catch (error) {
+      // File doesn't exist or is invalid - not an error on first run
+      this.log.debug(LOG_PREFIX.PLATFORM, 'No saved tokens found in storage')
+    }
+  }
+
+  /**
+   * Save tokens to persistent storage
+   * @returns {Promise<void>}
+   */
+  async saveTokens () {
+    try {
+      // Ensure storage directory exists
+      await mkdir(this.storagePath, { recursive: true })
+
+      const tokens = {
+        accessToken: this.config.accessToken || '',
+        refreshToken: this.config.refreshToken || '',
+        tokenExpiresAt: this.config.tokenExpiresAt || 0
+      }
+
+      await writeFile(this.tokenFilePath, JSON.stringify(tokens, null, 2), 'utf-8')
+      this.log.debug(LOG_PREFIX.PLATFORM, 'Saved tokens to persistent storage')
+    } catch (error) {
+      this.log.error(LOG_PREFIX.PLATFORM, 'Failed to save tokens:', error)
+      throw error
+    }
   }
 
   /**
@@ -196,8 +284,12 @@ export class YotoPlatform {
       this.api.updatePlatformAccessories([existingAccessory])
 
       // Create handler for this accessory
-      // eslint-disable-next-line no-new
-      new YotoPlayerAccessory(this, typedAccessory)
+      const handler = new YotoPlayerAccessory(this, typedAccessory)
+
+      // Initialize accessory (connect MQTT, etc.)
+      handler.initialize().catch(error => {
+        this.log.error(LOG_PREFIX.PLATFORM, `Failed to initialize ${device.name}:`, error)
+      })
     } else {
       // Create new accessory
       this.log.info(LOG_PREFIX.PLATFORM, 'Adding new accessory:', device.name)
@@ -218,8 +310,12 @@ export class YotoPlatform {
       }
 
       // Create handler for this accessory
-      // eslint-disable-next-line no-new
-      new YotoPlayerAccessory(this, typedAccessory)
+      const handler = new YotoPlayerAccessory(this, typedAccessory)
+
+      // Initialize accessory (connect MQTT, etc.)
+      handler.initialize().catch(error => {
+        this.log.error(LOG_PREFIX.PLATFORM, `Failed to initialize ${device.name}:`, error)
+      })
 
       // Register with Homebridge
       this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory])
@@ -257,11 +353,6 @@ export class YotoPlatform {
    */
   async shutdown () {
     this.log.info(LOG_PREFIX.PLATFORM, 'Shutting down...')
-
-    try {
-      await this.yotoMqtt.disconnect()
-    } catch (error) {
-      this.log.error(LOG_PREFIX.PLATFORM, 'Error during shutdown:', error)
-    }
+    // MQTT cleanup is handled by individual accessories
   }
 }

package/lib/playerAccessory.js

@@ -6,6 +6,7 @@
 /** @import { YotoPlatform } from './platform.js' */
 /** @import { YotoAccessoryContext, YotoDeviceStatus, YotoPlaybackEvents } from './types.js' */
 
+import { YotoMqtt } from './yotoMqtt.js'
 import {
   DEFAULT_MANUFACTURER,
   DEFAULT_MODEL,
@@ -37,6 +38,9 @@ export class YotoPlayerAccessory {
     this.currentEvents = accessory.context.lastEvents || null
     this.lastUpdateTime = Date.now()
 
+    // Create dedicated MQTT client for this device
+    this.mqtt = new YotoMqtt(this.log)
+
     this.log.debug(LOG_PREFIX.ACCESSORY, `[${this.device.name}] Initializing accessory`)
 
     // Set up services
@@ -93,8 +97,16 @@ export class YotoPlayerAccessory {
       this.activeContentInfo = null
     }
 
-    // Subscribe to MQTT updates
-    this.subscribeMqtt()
+    // MQTT connection will be initiated by platform after construction
+  }
+
+  /**
+   * Initialize the accessory - connect MQTT and subscribe to updates
+   * Called by platform after construction
+   * @returns {Promise<void>}
+   */
+  async initialize () {
+    await this.connectMqtt()
   }
 
   /**
@@ -386,17 +398,32 @@ export class YotoPlayerAccessory {
   }
 
   /**
-   * Subscribe to MQTT updates for this device
+   * Connect MQTT for this device
    */
-  async subscribeMqtt () {
+  async connectMqtt () {
     try {
-      await this.platform.yotoMqtt.subscribeToDevice(this.device.deviceId, {
+      // Ensure we have an access token
+      if (!this.platform.config.accessToken) {
+        this.log.warn(LOG_PREFIX.ACCESSORY, `[${this.device.name}] No access token available for MQTT connection`)
+        return
+      }
+
+      // Connect MQTT with device ID and access token
+      await this.mqtt.connect(
+        this.platform.config.accessToken,
+        this.device.deviceId
+      )
+
+      // Subscribe to device topics
+      await this.mqtt.subscribeToDevice(this.device.deviceId, {
         onStatus: this.handleStatusUpdate.bind(this),
         onEvents: this.handleEventsUpdate.bind(this),
         onResponse: this.handleCommandResponse.bind(this)
       })
+
+      this.log.debug(LOG_PREFIX.ACCESSORY, `[${this.device.name}] MQTT connected and subscribed`)
     } catch (error) {
-      this.log.error(LOG_PREFIX.ACCESSORY, `[${this.device.name}] Failed to subscribe to MQTT:`, error)
+      this.log.error(LOG_PREFIX.ACCESSORY, `[${this.device.name}] Failed to connect MQTT:`, error)
     }
   }
 
@@ -657,11 +684,11 @@ export class YotoPlayerAccessory {
 
     try {
       if (value === this.platform.Characteristic.TargetMediaState.PLAY) {
-        await this.platform.yotoMqtt.resumeCard(this.device.deviceId)
+        await this.mqtt.resumeCard(this.device.deviceId)
       } else if (value === this.platform.Characteristic.TargetMediaState.PAUSE) {
-        await this.platform.yotoMqtt.pauseCard(this.device.deviceId)
+        await this.mqtt.pauseCard(this.device.deviceId)
       } else if (value === this.platform.Characteristic.TargetMediaState.STOP) {
-        await this.platform.yotoMqtt.stopCard(this.device.deviceId)
+        await this.mqtt.stopCard(this.device.deviceId)
       }
     } catch (error) {
       this.log.error(LOG_PREFIX.ACCESSORY, `[${this.device.name}] Failed to set media state:`, error)
@@ -690,7 +717,7 @@ export class YotoPlayerAccessory {
     this.log.debug(LOG_PREFIX.ACCESSORY, `[${this.device.name}] Set volume:`, value)
 
     try {
-      await this.platform.yotoMqtt.setVolume(this.device.deviceId, Number(value))
+      await this.mqtt.setVolume(this.device.deviceId, Number(value))
     } catch (error) {
       this.log.error(LOG_PREFIX.ACCESSORY, `[${this.device.name}] Failed to set volume:`, error)
       throw new this.platform.api.hap.HapStatusError(
@@ -720,12 +747,12 @@ export class YotoPlayerAccessory {
     try {
       if (value) {
         // Mute - set volume to 0
-        await this.platform.yotoMqtt.setVolume(this.device.deviceId, 0)
+        await this.mqtt.setVolume(this.device.deviceId, 0)
       } else {
         // Unmute - restore to a reasonable volume if currently 0
         const currentVolume = this.currentStatus?.userVolume || 0
         const targetVolume = currentVolume === 0 ? 50 : currentVolume
-        await this.platform.yotoMqtt.setVolume(this.device.deviceId, targetVolume)
+        await this.mqtt.setVolume(this.device.deviceId, targetVolume)
       }
     } catch (error) {
       this.log.error(LOG_PREFIX.ACCESSORY, `[${this.device.name}] Failed to set mute:`, error)
@@ -1014,10 +1041,10 @@ export class YotoPlayerAccessory {
     try {
       if (value === this.platform.Characteristic.Active.INACTIVE) {
         // Turn off timer
-        await this.platform.yotoMqtt.setSleepTimer(this.device.deviceId, 0)
+        await this.mqtt.setSleepTimer(this.device.deviceId, 0)
       } else {
         // Turn on with default duration (30 minutes)
-        await this.platform.yotoMqtt.setSleepTimer(this.device.deviceId, 30 * 60)
+        await this.mqtt.setSleepTimer(this.device.deviceId, 30 * 60)
       }
     } catch (error) {
       this.log.error(LOG_PREFIX.ACCESSORY, `[${this.device.name}] Failed to set sleep timer active:`, error)
@@ -1056,10 +1083,10 @@ export class YotoPlayerAccessory {
 
       if (seconds === 0) {
         // Turn off timer
-        await this.platform.yotoMqtt.setSleepTimer(this.device.deviceId, 0)
+        await this.mqtt.setSleepTimer(this.device.deviceId, 0)
       } else {
         // Set timer with specified duration
-        await this.platform.yotoMqtt.setSleepTimer(this.device.deviceId, seconds)
+        await this.mqtt.setSleepTimer(this.device.deviceId, seconds)
       }
     } catch (error) {
       this.log.error(LOG_PREFIX.ACCESSORY, `[${this.device.name}] Failed to set sleep timer:`, error)
@@ -1205,10 +1232,10 @@ export class YotoPlayerAccessory {
     try {
       if (value) {
         // Turn on - set to white or previous color
-        await this.platform.yotoMqtt.setAmbientLight(this.device.deviceId, 255, 255, 255)
+        await this.mqtt.setAmbientLight(this.device.deviceId, 255, 255, 255)
       } else {
         // Turn off - set to black
-        await this.platform.yotoMqtt.setAmbientLight(this.device.deviceId, 0, 0, 0)
+        await this.mqtt.setAmbientLight(this.device.deviceId, 0, 0, 0)
       }
     } catch (error) {
       this.log.error(LOG_PREFIX.ACCESSORY, `[${this.device.name}] Failed to set ambient light on:`, error)
@@ -1318,7 +1345,7 @@ export class YotoPlayerAccessory {
       const { r, g, b } = this.hsvToRgb(h, s, v)
 
       // Send MQTT command
-      await this.platform.yotoMqtt.setAmbientLight(this.device.deviceId, r, g, b)
+      await this.mqtt.setAmbientLight(this.device.deviceId, r, g, b)
 
       // Clear pending values
       this.pendingAmbientHue = undefined

package/lib/yotoApi.js

@@ -81,7 +81,8 @@ export class YotoApi {
         }
       } catch (error) {
         this.log.error(LOG_PREFIX.API, 'Token refresh failed:', error)
-        throw error
+        // Throw specific error so platform can detect and restart auth flow
+        throw new Error('TOKEN_REFRESH_FAILED')
       }
     }
   }

package/lib/yotoMqtt.js

@@ -8,6 +8,7 @@
 import mqtt from 'mqtt'
 import {
   YOTO_MQTT_BROKER_URL,
+  YOTO_MQTT_AUTH_NAME,
   MQTT_RECONNECT_PERIOD,
   MQTT_CONNECT_TIMEOUT,
   MQTT_TOPIC_DATA_STATUS,
@@ -51,9 +52,10 @@ export class YotoMqtt {
   /**
    * Connect to MQTT broker
    * @param {string} accessToken - Yoto access token for authentication
+   * @param {string} deviceId - Device ID for MQTT client identification
    * @returns {Promise<void>}
    */
-  async connect (accessToken) {
+  async connect (accessToken, deviceId) {
     if (this.client) {
       this.log.warn(LOG_PREFIX.MQTT, 'Already connected, disconnecting first...')
       await this.disconnect()
@@ -62,12 +64,19 @@ export class YotoMqtt {
     return new Promise((resolve, reject) => {
       this.log.info(LOG_PREFIX.MQTT, `Connecting to ${this.brokerUrl}...`)
 
+      const clientId = `homebridge-yoto-${deviceId}-${Date.now()}`
+
       this.client = mqtt.connect(this.brokerUrl, {
-        username: accessToken,
-        password: '',
+        keepalive: 300,
+        port: 443,
+        protocol: 'wss',
+        username: `${deviceId}?x-amz-customauthorizer-name=${YOTO_MQTT_AUTH_NAME}`,
+        password: accessToken,
         reconnectPeriod: MQTT_RECONNECT_PERIOD,
         connectTimeout: MQTT_CONNECT_TIMEOUT,
-        clean: true
+        clientId,
+        clean: true,
+        ALPNProtocols: ['x-amzn-mqtt-ca']
       })
 
       this.client.on('connect', () => {
@@ -319,10 +328,10 @@ export class YotoMqtt {
         return
       }
 
-      if (topic.includes('/data/status')) {
+      if (topic.includes('/status')) {
         this.log.debug(LOG_PREFIX.MQTT, `Status update for ${deviceId}`)
         callbacks.onStatus?.(payload)
-      } else if (topic.includes('/data/events')) {
+      } else if (topic.includes('/events')) {
         this.log.debug(LOG_PREFIX.MQTT, `Events update for ${deviceId}`)
         callbacks.onEvents?.(payload)
       } else if (topic.includes('/response')) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-yoto",
   "description": "Control your Yoto players through Apple HomeKit with real-time MQTT updates",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "author": "Bret Comnes <bcomnes@gmail.com> (https://bret.io)",
   "bugs": {
     "url": "https://github.com/bcomnes/homebridge-yoto/issues"