yoto-nodejs-client 0.0.1

package/lib/mqtt/commands.d.ts

@@ -0,0 +1,69 @@
+export function createVolumeCommand(volume: number): YotoVolumeCommand;
+export function createAmbientCommand(r: number, g: number, b: number): YotoAmbientCommand;
+export function createAmbientCommandFromHex(hexColor: string): YotoAmbientCommand;
+export function createSleepTimerCommand(seconds: number): YotoSleepTimerCommand;
+export function createCardStartCommand(options: {
+    uri: string;
+    chapterKey?: string | undefined;
+    trackKey?: string | undefined;
+    secondsIn?: number | undefined;
+    cutOff?: number | undefined;
+    anyButtonStop?: boolean | undefined;
+}): YotoCardStartCommand;
+export function createBluetoothOnCommand(options?: {
+    action?: string | undefined;
+    mode?: string | boolean | undefined;
+    rssi?: number | undefined;
+    name?: string | undefined;
+    mac?: string | undefined;
+}): YotoBluetoothCommand;
+export function createBluetoothSpeakerCommand(): YotoBluetoothCommand;
+export function createBluetoothAudioSourceCommand(): YotoBluetoothCommand;
+export function createDisplayPreviewCommand(options: {
+    uri: string;
+    timeout: number;
+    animated: boolean;
+}): YotoDisplayPreviewCommand;
+export namespace commands {
+    export { createVolumeCommand as volume };
+    export { createAmbientCommand as ambient };
+    export { createAmbientCommandFromHex as ambientFromHex };
+    export { createSleepTimerCommand as sleepTimer };
+    export { createCardStartCommand as cardStart };
+    export { createBluetoothOnCommand as bluetoothOn };
+    export { createBluetoothSpeakerCommand as bluetoothSpeaker };
+    export { createBluetoothAudioSourceCommand as bluetoothAudioSource };
+    export { createDisplayPreviewCommand as displayPreview };
+}
+export type YotoVolumeCommand = {
+    volume: number;
+};
+export type YotoAmbientCommand = {
+    r: number;
+    g: number;
+    b: number;
+};
+export type YotoSleepTimerCommand = {
+    seconds: number;
+};
+export type YotoCardStartCommand = {
+    uri: string;
+    chapterKey?: string;
+    trackKey?: string;
+    secondsIn?: number;
+    cutOff?: number;
+    anyButtonStop?: boolean;
+};
+export type YotoBluetoothCommand = {
+    action?: string;
+    mode?: boolean | string;
+    rssi?: number;
+    name?: string;
+    mac?: string;
+};
+export type YotoDisplayPreviewCommand = {
+    uri: string;
+    timeout: number;
+    animated: 0 | 1;
+};
+//# sourceMappingURL=commands.d.ts.map

package/lib/mqtt/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["commands.js"],"names":[],"mappings":"AAwEA,4CAJW,MAAM,GACJ,iBAAiB,CAS7B;AAUD,wCANW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,kBAAkB,CAS9B;AAQD,sDAJW,MAAM,GACJ,kBAAkB,CAgB9B;AAQD,iDAJW,MAAM,GACJ,qBAAqB,CASjC;AAcD,gDATG;IAAwB,GAAG,EAAnB,MAAM;IACW,UAAU;IACV,QAAQ;IACR,SAAS;IACT,MAAM;IACL,aAAa;CACvC,GAAU,oBAAoB,CAkBhC;AAYD,mDAPG;IAAyB,MAAM;IACI,IAAI;IACd,IAAI;IACJ,IAAI;IACJ,GAAG;CAC5B,GAAU,oBAAoB,CAahC;AAMD,iDAFa,oBAAoB,CAIhC;AAMD,qDAFa,oBAAoB,CAIhC;AAWD,qDANG;IAAwB,GAAG,EAAnB,MAAM;IACU,OAAO,EAAvB,MAAM;IACW,QAAQ,EAAzB,OAAO;CACf,GAAU,yBAAyB,CAiBrC;;;;;;;;;;;;;YA/Ma,MAAM;;;OAON,MAAM;OACN,MAAM;OACN,MAAM;;;aAON,MAAM;;;SAON,MAAM;iBACN,MAAM;eACN,MAAM;gBACN,MAAM;aACN,MAAM;oBACN,OAAO;;;aAOP,MAAM;WACN,OAAO,GAAG,MAAM;WAChB,MAAM;WACN,MAAM;UACN,MAAM;;;SAON,MAAM;aACN,MAAM;cACN,CAAC,GAAG,CAAC"}

package/lib/mqtt/commands.js

@@ -0,0 +1,238 @@
+/**
+ * MQTT Command Builders for Yoto Players
+ *
+ * Type-safe builders for constructing MQTT command payloads
+ * @see https://yoto.dev/players-mqtt/
+ */
+
+// ============================================================================
+// MQTT Commands: Type-safe command builders
+// ============================================================================
+
+/**
+ * Volume command payload
+ * @see https://yoto.dev/players-mqtt/mqtt-docs/#deviceidcommandvolumeset
+ * @typedef {Object} YotoVolumeCommand
+ * @property {number} volume - Volume level [0-100]
+ */
+
+/**
+ * Ambient light command payload
+ * @see https://yoto.dev/players-mqtt/mqtt-docs/#deviceidcommandambientsset
+ * @typedef {Object} YotoAmbientCommand
+ * @property {number} r - Red intensity [0-255]
+ * @property {number} g - Green intensity [0-255]
+ * @property {number} b - Blue intensity [0-255]
+ */
+
+/**
+ * Sleep timer command payload
+ * @see https://yoto.dev/players-mqtt/mqtt-docs/#deviceidcommandsleep-timerset
+ * @typedef {Object} YotoSleepTimerCommand
+ * @property {number} seconds - Timer duration in seconds (0 to disable)
+ */
+
+/**
+ * Card start command payload
+ * @see https://yoto.dev/players-mqtt/mqtt-docs/#deviceidcommandcardstart
+ * @typedef {Object} YotoCardStartCommand
+ * @property {string} uri - Card URI (e.g., "https://yoto.io/<cardID>")
+ * @property {string} [chapterKey] - Chapter to start from
+ * @property {string} [trackKey] - Track to start from
+ * @property {number} [secondsIn] - Playback start offset in seconds
+ * @property {number} [cutOff] - Playback stop offset in seconds
+ * @property {boolean} [anyButtonStop] - Whether button press stops playback
+ */
+
+/**
+ * Bluetooth command payload
+ * @see https://yoto.dev/players-mqtt/mqtt-docs/#deviceidcommandbluetooth
+ * @typedef {Object} YotoBluetoothCommand
+ * @property {string} [action] - Bluetooth action (e.g., "on")
+ * @property {boolean | string} [mode] - Bluetooth mode (true for audio source, "bt_speaker" for sink)
+ * @property {number} [rssi] - RSSI threshold for auto-connect
+ * @property {string} [name] - Target Bluetooth device name
+ * @property {string} [mac] - Target Bluetooth MAC address
+ */
+
+/**
+ * Display preview command payload
+ * @see https://yoto.dev/players-mqtt/mqtt-docs/#deviceidcommanddisplaypreview
+ * @typedef {Object} YotoDisplayPreviewCommand
+ * @property {string} uri - Filepath to icon asset
+ * @property {number} timeout - Display duration in seconds
+ * @property {0 | 1} animated - Whether icon is animated (1) or static (0)
+ */
+
+/**
+ * Create a volume set command
+ * @param {number} volume - Volume level [0-100]
+ * @returns {YotoVolumeCommand}
+ * @throws {Error} If volume is out of range
+ */
+export function createVolumeCommand (volume) {
+  if (volume < 0 || volume > 100) {
+    throw new Error('Volume must be between 0 and 100')
+  }
+
+  return { volume }
+}
+
+/**
+ * Create an ambient light set command
+ * @param {number} r - Red intensity [0-255]
+ * @param {number} g - Green intensity [0-255]
+ * @param {number} b - Blue intensity [0-255]
+ * @returns {YotoAmbientCommand}
+ * @throws {Error} If any color value is out of range
+ */
+export function createAmbientCommand (r, g, b) {
+  if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
+    throw new Error('RGB values must be between 0 and 255')
+  }
+
+  return { r, g, b }
+}
+
+/**
+ * Create an ambient light command from hex color
+ * @param {string} hexColor - Hex color string (e.g., "#FF0000" or "FF0000")
+ * @returns {YotoAmbientCommand}
+ * @throws {Error} If hex color is invalid
+ */
+export function createAmbientCommandFromHex (hexColor) {
+  // Remove # if present
+  const hex = hexColor.replace(/^#/, '')
+
+  if (!/^[0-9A-Fa-f]{6}$/.test(hex)) {
+    throw new Error('Invalid hex color format. Expected format: #RRGGBB or RRGGBB')
+  }
+
+  const r = parseInt(hex.slice(0, 2), 16)
+  const g = parseInt(hex.slice(2, 4), 16)
+  const b = parseInt(hex.slice(4, 6), 16)
+
+  return { r, g, b }
+}
+
+/**
+ * Create a sleep timer set command
+ * @param {number} seconds - Timer duration in seconds (0 to disable)
+ * @returns {YotoSleepTimerCommand}
+ * @throws {Error} If seconds is negative
+ */
+export function createSleepTimerCommand (seconds) {
+  if (seconds < 0) {
+    throw new Error('Seconds must be non-negative (use 0 to disable timer)')
+  }
+
+  return { seconds }
+}
+
+/**
+ * Create a card start command
+ * @param {Object} options - Card start options
+ * @param {string} options.uri - Card URI (e.g., "https://yoto.io/<cardID>")
+ * @param {string} [options.chapterKey] - Chapter to start from
+ * @param {string} [options.trackKey] - Track to start from
+ * @param {number} [options.secondsIn] - Playback start offset in seconds
+ * @param {number} [options.cutOff] - Playback stop offset in seconds
+ * @param {boolean} [options.anyButtonStop] - Whether button press stops playback
+ * @returns {YotoCardStartCommand}
+ * @throws {Error} If uri is missing
+ */
+export function createCardStartCommand (options) {
+  if (!options.uri) {
+    throw new Error('Card URI is required')
+  }
+
+  /** @type {YotoCardStartCommand} */
+  const command = { uri: options.uri }
+
+  if (options.chapterKey !== undefined) command.chapterKey = options.chapterKey
+  if (options.trackKey !== undefined) command.trackKey = options.trackKey
+  if (options.secondsIn !== undefined) command.secondsIn = options.secondsIn
+  if (options.cutOff !== undefined) command.cutOff = options.cutOff
+  if (options.anyButtonStop !== undefined) command.anyButtonStop = options.anyButtonStop
+
+  return command
+}
+
+/**
+ * Create a bluetooth on command
+ * @param {Object} [options] - Bluetooth options
+ * @param {string} [options.action] - Bluetooth action (e.g., "on")
+ * @param {boolean | string} [options.mode] - Bluetooth mode (true for audio source, "bt_speaker" for sink)
+ * @param {number} [options.rssi] - RSSI threshold for auto-connect
+ * @param {string} [options.name] - Target Bluetooth device name
+ * @param {string} [options.mac] - Target Bluetooth MAC address
+ * @returns {YotoBluetoothCommand}
+ */
+export function createBluetoothOnCommand (options = {}) {
+  /** @type {YotoBluetoothCommand} */
+  const command = {}
+
+  if (options.action !== undefined) command.action = options.action
+  if (options.mode !== undefined) command.mode = options.mode
+  if (options.rssi !== undefined) command.rssi = options.rssi
+  if (options.name !== undefined) command.name = options.name
+  if (options.mac !== undefined) command.mac = options.mac
+
+  return command
+}
+
+/**
+ * Create a bluetooth speaker mode command
+ * @returns {YotoBluetoothCommand}
+ */
+export function createBluetoothSpeakerCommand () {
+  return { mode: 'bt_speaker' }
+}
+
+/**
+ * Create a bluetooth audio source mode command
+ * @returns {YotoBluetoothCommand}
+ */
+export function createBluetoothAudioSourceCommand () {
+  return { action: 'on', mode: true }
+}
+
+/**
+ * Create a display preview command
+ * @param {Object} options - Display preview options
+ * @param {string} options.uri - Filepath to icon asset
+ * @param {number} options.timeout - Display duration in seconds
+ * @param {boolean} options.animated - Whether icon is animated
+ * @returns {YotoDisplayPreviewCommand}
+ * @throws {Error} If uri or timeout is missing
+ */
+export function createDisplayPreviewCommand (options) {
+  if (!options.uri) {
+    throw new Error('Icon URI is required')
+  }
+
+  if (options.timeout === undefined) {
+    throw new Error('Timeout is required')
+  }
+
+  return {
+    uri: options.uri,
+    timeout: options.timeout,
+    animated: options.animated ? 1 : 0
+  }
+}
+
+/**
+ * Command builders object for convenient access
+ */
+export const commands = {
+  volume: createVolumeCommand,
+  ambient: createAmbientCommand,
+  ambientFromHex: createAmbientCommandFromHex,
+  sleepTimer: createSleepTimerCommand,
+  cardStart: createCardStartCommand,
+  bluetoothOn: createBluetoothOnCommand,
+  bluetoothSpeaker: createBluetoothSpeakerCommand,
+  bluetoothAudioSource: createBluetoothAudioSourceCommand,
+  displayPreview: createDisplayPreviewCommand
+}

package/lib/mqtt/factory.d.ts

@@ -0,0 +1,12 @@
+export function createYotoMqttClient(options: YotoMqttOptions): YotoMqttClient;
+export type YotoMqttOptions = {
+    deviceId: string;
+    accessToken: string;
+    clientIdPrefix?: string;
+    brokerUrl?: string;
+    keepalive?: number;
+    port?: number;
+    autoSubscribe?: boolean;
+};
+import { YotoMqttClient } from './client.js';
+//# sourceMappingURL=factory.d.ts.map

package/lib/mqtt/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["factory.js"],"names":[],"mappings":"AA2DA,8CApBW,eAAe,GACb,cAAc,CAkE1B;;cAzFa,MAAM;iBACN,MAAM;qBACN,MAAM;gBACN,MAAM;gBACN,MAAM;WACN,MAAM;oBACN,OAAO;;+BAIU,aAAa"}

package/lib/mqtt/factory.js

@@ -0,0 +1,107 @@
+/**
+ * MQTT Client Factory for Yoto Players
+ *
+ * Factory function to create properly configured MQTT clients for Yoto devices
+ * @see https://yoto.dev/players-mqtt/
+ */
+
+/**
+ * @import { IClientOptions } from 'mqtt'
+ */
+
+// ============================================================================
+// MQTT Factory: Create properly configured MQTT clients for Yoto devices
+// ============================================================================
+
+/**
+ * @typedef {Object} YotoMqttOptions
+ * @property {string} deviceId - Device ID to connect to
+ * @property {string} accessToken - JWT access token for authentication
+ * @property {string} [clientIdPrefix='DASH'] - Prefix for MQTT client ID (default: 'DASH')
+ * @property {string} [brokerUrl='wss://aqrphjqbp3u2z-ats.iot.eu-west-2.amazonaws.com'] - MQTT broker URL
+ * @property {number} [keepalive=300] - Keepalive interval in seconds
+ * @property {number} [port=443] - MQTT broker port
+ * @property {boolean} [autoSubscribe=true] - Auto-subscribe to device topics on connect
+ */
+
+import mqtt from 'mqtt'
+import { YotoMqttClient } from './client.js'
+import {
+  MQTT_BROKER_URL,
+  MQTT_AUTH_NAME,
+  MQTT_PORT,
+  MQTT_PROTOCOL,
+  MQTT_KEEPALIVE,
+  MQTT_ALPN_PROTOCOLS
+} from './topics.js'
+
+/**
+ * Create a configured MQTT client for a Yoto device
+ * @param {YotoMqttOptions} options - MQTT connection options
+ * @returns {YotoMqttClient} Configured Yoto MQTT client
+ * @throws {Error} If required options are missing
+ *
+ * @example
+ * ```javascript
+ * import { createYotoMqttClient } from 'yoto-nodejs-client/lib/mqtt'
+ *
+ * const client = createYotoMqttClient({
+ *   deviceId: 'abc123',
+ *   accessToken: 'eyJhbGc...'
+ * })
+ *
+ * client.on('events', (message) => {
+ *   console.log('Playing:', message.trackTitle)
+ * })
+ *
+ * await client.connect()
+ * ```
+ */
+export function createYotoMqttClient (options) {
+  // Validate required options
+  if (!options.deviceId) {
+    throw new Error('deviceId is required')
+  }
+
+  if (!options.accessToken) {
+    throw new Error('accessToken is required')
+  }
+
+  // Extract options with defaults
+  const {
+    deviceId,
+    accessToken,
+    clientIdPrefix = 'DASH',
+    brokerUrl = MQTT_BROKER_URL,
+    keepalive = MQTT_KEEPALIVE,
+    port = MQTT_PORT,
+    autoSubscribe = true
+  } = options
+
+  // Build MQTT client ID
+  const clientId = `${clientIdPrefix}${deviceId}`
+
+  // Build username with authorizer
+  const username = `${deviceId}?x-amz-customauthorizer-name=${MQTT_AUTH_NAME}`
+
+  // Create MQTT connection options
+  /** @type {IClientOptions} */
+  const mqttOptions = {
+    clientId,
+    username,
+    password: accessToken,
+    keepalive,
+    port,
+    protocol: MQTT_PROTOCOL,
+    reconnectPeriod: 0, // Disable auto-reconnect, handle manually
+    ALPNProtocols: MQTT_ALPN_PROTOCOLS
+  }
+
+  // Create underlying MQTT client (not connected yet)
+  const mqttClient = mqtt.connect(brokerUrl, mqttOptions)
+
+  // Create and return Yoto MQTT client wrapper
+  return new YotoMqttClient(mqttClient, deviceId, {
+    autoSubscribe
+  })
+}

package/lib/mqtt/index.d.ts

@@ -0,0 +1,5 @@
+export { createYotoMqttClient } from "./factory.js";
+export { YotoMqttClient } from "./client.js";
+export { createVolumeCommand, createAmbientCommand, createAmbientCommandFromHex, createSleepTimerCommand, createCardStartCommand, createBluetoothOnCommand, createBluetoothSpeakerCommand, createBluetoothAudioSourceCommand, createDisplayPreviewCommand, commands } from "./commands.js";
+export { MQTT_BROKER_URL, MQTT_AUTH_NAME, MQTT_PORT, MQTT_PROTOCOL, MQTT_KEEPALIVE, MQTT_ALPN_PROTOCOLS, getEventsTopic, getStatusTopic, getResponseTopic, getSubscriptionTopics, getCommandTopic, parseTopic, getEventsRequestTopic, getStatusRequestTopic, getVolumeSetTopic, getAmbientsSetTopic, getSleepTimerSetTopic, getRebootTopic, getCardStartTopic, getCardStopTopic, getCardPauseTopic, getCardResumeTopic, getBluetoothOnTopic, getBluetoothOffTopic, getBluetoothDeleteBondsTopic, getBluetoothConnectTopic, getBluetoothDisconnectTopic, getBluetoothStateTopic, getDisplayPreviewTopic } from "./topics.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/mqtt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":""}

package/lib/mqtt/index.js

@@ -0,0 +1,81 @@
+/**
+ * Yoto MQTT Module
+ *
+ * MQTT client for connecting to and controlling Yoto players
+ * @see https://yoto.dev/players-mqtt/
+ *
+ * @example
+ * ```javascript
+ * import { createYotoMqttClient } from 'yoto-nodejs-client/lib/mqtt'
+ *
+ * const client = createYotoMqttClient({
+ *   deviceId: 'abc123',
+ *   accessToken: 'eyJhbGc...'
+ * })
+ *
+ * client.on('events', (message) => {
+ *   console.log('Now playing:', message.trackTitle)
+ * })
+ *
+ * client.on('status', (message) => {
+ *   console.log('Battery:', message.batteryLevel, '%')
+ * })
+ *
+ * await client.connect()
+ * await client.setVolume(50)
+ * await client.setAmbientHex('#FF0000')
+ * ```
+ */
+
+// Factory
+export { createYotoMqttClient } from './factory.js'
+
+// Client class
+export { YotoMqttClient } from './client.js'
+
+// Command builders
+export {
+  createVolumeCommand,
+  createAmbientCommand,
+  createAmbientCommandFromHex,
+  createSleepTimerCommand,
+  createCardStartCommand,
+  createBluetoothOnCommand,
+  createBluetoothSpeakerCommand,
+  createBluetoothAudioSourceCommand,
+  createDisplayPreviewCommand,
+  commands
+} from './commands.js'
+
+// Topic builders and constants
+export {
+  MQTT_BROKER_URL,
+  MQTT_AUTH_NAME,
+  MQTT_PORT,
+  MQTT_PROTOCOL,
+  MQTT_KEEPALIVE,
+  MQTT_ALPN_PROTOCOLS,
+  getEventsTopic,
+  getStatusTopic,
+  getResponseTopic,
+  getSubscriptionTopics,
+  getCommandTopic,
+  parseTopic,
+  getEventsRequestTopic,
+  getStatusRequestTopic,
+  getVolumeSetTopic,
+  getAmbientsSetTopic,
+  getSleepTimerSetTopic,
+  getRebootTopic,
+  getCardStartTopic,
+  getCardStopTopic,
+  getCardPauseTopic,
+  getCardResumeTopic,
+  getBluetoothOnTopic,
+  getBluetoothOffTopic,
+  getBluetoothDeleteBondsTopic,
+  getBluetoothConnectTopic,
+  getBluetoothDisconnectTopic,
+  getBluetoothStateTopic,
+  getDisplayPreviewTopic
+} from './topics.js'

package/lib/mqtt/mqtt.test.js

@@ -0,0 +1,168 @@
+import test from 'node:test'
+import assert from 'node:assert'
+import { getDevices } from '../api-endpoints/devices.js'
+import { loadTestTokens, logResponse } from '../api-endpoints/test-helpers.js'
+import { createYotoMqttClient } from './index.js'
+
+const { accessToken } = loadTestTokens()
+
+test('MQTT client', async (t) => {
+  await t.test('should connect, request status/events, and receive response and events messages', async () => {
+    // Get an online device
+    const response = await getDevices({ accessToken })
+    assert.ok(response.devices.length > 0, 'Should have at least one device')
+
+    const onlineDevice = response.devices.find(d => d.online)
+    assert.ok(onlineDevice, 'Should have at least one online device for MQTT testing')
+
+    const deviceId = onlineDevice.deviceId
+
+    // Create MQTT client
+    const mqttClient = createYotoMqttClient({
+      deviceId,
+      accessToken
+    })
+
+    // Track received messages
+    let statusResponseReceived = false
+    let eventsResponseReceived = false
+    let eventsMessageReceived = false
+    let statusMessageReceived = false
+    /** @type {Error[]} */
+    const errors = []
+
+    // Setup message handlers
+    mqttClient.on('events', (message) => {
+      logResponse('MQTT events message', message)
+
+      try {
+        // Validate events message structure
+        assert.ok(message, 'Events message should exist')
+
+        // Events messages are partial - not all fields are always present
+        if (message.playbackStatus !== undefined) {
+          assert.ok(typeof message.playbackStatus === 'string', 'playbackStatus should be string')
+        }
+        if (message.cardId !== undefined) {
+          assert.ok(typeof message.cardId === 'string', 'cardId should be string')
+        }
+
+        eventsMessageReceived = true
+      } catch (err) {
+        errors.push(/** @type {Error} */ (err))
+      }
+    })
+
+    mqttClient.on('status', (message) => {
+      logResponse('MQTT status message', message)
+
+      try {
+        // Validate status message structure
+        assert.ok(message, 'Status message should exist')
+        assert.ok(message.status, 'Status message should have status object')
+        assert.ok(typeof message.status.statusVersion === 'number', 'Should have statusVersion number')
+        assert.ok(typeof message.status.fwVersion === 'string', 'Should have fwVersion string')
+        assert.ok(typeof message.status.productType === 'string', 'Should have productType string')
+        assert.ok(typeof message.status.batteryLevel === 'number', 'Should have batteryLevel number')
+        assert.ok(typeof message.status.volume === 'number', 'Should have volume number')
+
+        statusMessageReceived = true
+      } catch (err) {
+        errors.push(/** @type {Error} */ (err))
+      }
+    })
+
+    mqttClient.on('response', (message) => {
+      logResponse('MQTT response message', message)
+
+      try {
+        // Validate response message structure
+        assert.ok(message, 'Response message should exist')
+        assert.ok(message.status, 'Response should have status object')
+        assert.ok(typeof message.status.req_body === 'string', 'Response should have req_body string')
+
+        // Check if status request was acknowledged (field name is 'status/request')
+        if (message.status['status/request']) {
+          assert.ok(
+            message.status['status/request'] === 'OK' || message.status['status/request'] === 'FAIL',
+            'Status request field should be OK or FAIL'
+          )
+          statusResponseReceived = true
+        }
+
+        // Check if events request was acknowledged
+        if (message.status.events) {
+          assert.ok(
+            message.status.events === 'OK' || message.status.events === 'FAIL',
+            'Events request field should be OK or FAIL'
+          )
+          eventsResponseReceived = true
+        }
+      } catch (err) {
+        errors.push(/** @type {Error} */ (err))
+      }
+    })
+
+    mqttClient.on('error', (error) => {
+      console.error('MQTT error:', error)
+      errors.push(error)
+    })
+
+    /** @type {NodeJS.Timeout | undefined} */
+    let timeoutId
+    /** @type {NodeJS.Timeout | undefined} */
+    let checkIntervalId
+
+    try {
+      // Connect to MQTT
+      await mqttClient.connect()
+      assert.ok(mqttClient.connected, 'MQTT client should be connected')
+
+      // Request status and events
+      await mqttClient.requestStatus()
+      await mqttClient.requestEvents()
+
+      // Wait for messages (with timeout)
+      await new Promise((resolve, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new Error(`Timeout waiting for messages. statusResponse=${statusResponseReceived}, eventsResponse=${eventsResponseReceived}, eventsMessage=${eventsMessageReceived}, statusMessage=${statusMessageReceived}`))
+        }, 5000) // 5 second timeout
+
+        checkIntervalId = setInterval(() => {
+          if (errors.length > 0) {
+            clearTimeout(timeoutId)
+            clearInterval(checkIntervalId)
+            reject(errors[0])
+          }
+          if (statusResponseReceived && eventsResponseReceived && eventsMessageReceived && statusMessageReceived) {
+            clearTimeout(timeoutId)
+            clearInterval(checkIntervalId)
+            resolve(undefined)
+          }
+        }, 100)
+      })
+
+      // Verify we received all expected messages
+      assert.ok(statusResponseReceived, 'Should have received status request response')
+      assert.ok(eventsResponseReceived, 'Should have received events request response')
+      assert.ok(eventsMessageReceived, 'Should have received events data message')
+      assert.ok(statusMessageReceived, 'Should have received status data message')
+    } catch (err) {
+      // Clean up timers on error
+      if (timeoutId) clearTimeout(timeoutId)
+      if (checkIntervalId) clearInterval(checkIntervalId)
+      throw err
+    } finally {
+      // Always disconnect, even if test fails
+      if (timeoutId) clearTimeout(timeoutId)
+      if (checkIntervalId) clearInterval(checkIntervalId)
+      await mqttClient.disconnect()
+      assert.ok(!mqttClient.connected, 'MQTT client should be disconnected')
+    }
+
+    // Re-throw any errors that occurred in event handlers
+    if (errors.length > 0) {
+      throw errors[0]
+    }
+  })
+})