yoto-nodejs-client 0.0.1

package/lib/mqtt/client.d.ts

@@ -0,0 +1,124 @@
+export class YotoMqttClient extends EventEmitter<any> {
+    constructor(mqttClient: MqttClient, deviceId: string, options?: {
+        autoSubscribe?: boolean | undefined;
+    });
+    mqttClient: MqttClient;
+    deviceId: string;
+    autoSubscribe: boolean;
+    commands: {
+        volume: typeof import("./commands.js").createVolumeCommand;
+        ambient: typeof import("./commands.js").createAmbientCommand;
+        ambientFromHex: typeof import("./commands.js").createAmbientCommandFromHex;
+        sleepTimer: typeof import("./commands.js").createSleepTimerCommand;
+        cardStart: typeof import("./commands.js").createCardStartCommand;
+        bluetoothOn: typeof import("./commands.js").createBluetoothOnCommand;
+        bluetoothSpeaker: typeof import("./commands.js").createBluetoothSpeakerCommand;
+        bluetoothAudioSource: typeof import("./commands.js").createBluetoothAudioSourceCommand;
+        displayPreview: typeof import("./commands.js").createDisplayPreviewCommand;
+    };
+    get state(): YotoMqttConnectionState;
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    requestEvents(): Promise<void>;
+    requestStatus(): Promise<void>;
+    setVolume(volume: number): Promise<void>;
+    setAmbient(r: number, g: number, b: number): Promise<void>;
+    setAmbientHex(hexColor: string): Promise<void>;
+    setSleepTimer(seconds: number): Promise<void>;
+    reboot(): Promise<void>;
+    startCard(options: {
+        uri: string;
+        chapterKey?: string | undefined;
+        trackKey?: string | undefined;
+        secondsIn?: number | undefined;
+        cutOff?: number | undefined;
+        anyButtonStop?: boolean | undefined;
+    }): Promise<void>;
+    stopCard(): Promise<void>;
+    pauseCard(): Promise<void>;
+    resumeCard(): Promise<void>;
+    bluetoothOn(options?: {
+        action?: string | undefined;
+        mode?: string | boolean | undefined;
+        rssi?: number | undefined;
+        name?: string | undefined;
+        mac?: string | undefined;
+    }): Promise<void>;
+    bluetoothOff(): Promise<void>;
+    bluetoothSpeakerMode(): Promise<void>;
+    bluetoothAudioSourceMode(): Promise<void>;
+    bluetoothDeleteBonds(): Promise<void>;
+    bluetoothConnect(): Promise<void>;
+    bluetoothDisconnect(): Promise<void>;
+    bluetoothGetState(): Promise<void>;
+    displayPreview(options: {
+        uri: string;
+        timeout: number;
+        animated: boolean;
+    }): Promise<void>;
+    #private;
+}
+export type YotoEventsMessage = {
+    repeatAll?: boolean;
+    streaming?: boolean;
+    volume?: number;
+    volumeMax?: number;
+    playbackWait?: boolean;
+    sleepTimerActive?: boolean;
+    eventUtc?: number;
+    trackLength?: number;
+    position?: number;
+    cardId?: string;
+    source?: string;
+    cardUpdatedAt?: string;
+    chapterTitle?: string;
+    chapterKey?: string;
+    trackTitle?: string;
+    trackKey?: string;
+    playbackStatus?: string;
+    sleepTimerSeconds?: number;
+};
+export type YotoStatusMessage = {
+    statusVersion: number;
+    fwVersion: string;
+    productType: string;
+    batteryLevel: number;
+    als: number;
+    freeDisk: number;
+    shutdownTimeout: number;
+    dbatTimeout: number;
+    charging: number;
+    activeCard: string;
+    cardInserted: number;
+    playingStatus: number;
+    headphones: boolean;
+    dnowBrightness: number;
+    dayBright: number;
+    nightBright: number;
+    bluetoothHp: boolean;
+    volume: number;
+    userVolume: number;
+    timeFormat: "12" | "24";
+    nightlightMode: string;
+    temp: string;
+    day: number;
+};
+export type YotoResponseMessage = {
+    status: {
+        volume?: "OK" | "FAIL" | undefined;
+        ambients?: "OK" | "FAIL" | undefined;
+        card?: "OK" | "FAIL" | undefined;
+        events?: "OK" | "FAIL" | undefined;
+        status?: "OK" | "FAIL" | undefined;
+        bluetooth?: "OK" | "FAIL" | undefined;
+        display?: "OK" | "FAIL" | undefined;
+        reboot?: "OK" | "FAIL" | undefined;
+        req_body: string;
+        sleepTimer: "OK" | "FAIL";
+    };
+};
+export type YotoMqttConnectionState = "disconnected" | "connected" | "reconnecting";
+import { EventEmitter } from 'events';
+import type { MqttClient } from 'mqtt';
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["client.js"],"names":[],"mappings":"AAgIA;IAQE,wBALW,UAAU,YACV,MAAM,YAEd;QAA0B,aAAa;KACzC,EAaA;IATC,uBAA4B;IAC5B,iBAAwB;IACxB,uBAAoD;IAMpD;;;;;;;;;;MAAwB;IAO1B,aAFa,uBAAuB,CAMnC;IAMD,iBAFa,OAAO,CAInB;IA2GD,WAFa,OAAO,CAAC,IAAI,CAAC,CA8BzB;IAMD,cAFa,OAAO,CAAC,IAAI,CAAC,CAiBzB;IA4BD,iBAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAMD,iBAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAOD,kBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAMzB;IASD,cALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAMzB;IAOD,wBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAMzB;IAOD,uBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAMzB;IAMD,UAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAaD,mBARG;QAAwB,GAAG,EAAnB,MAAM;QACW,UAAU;QACV,QAAQ;QACR,SAAS;QACT,MAAM;QACL,aAAa;KACvC,GAAU,OAAO,CAAC,IAAI,CAAC,CAMzB;IAMD,YAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAMD,aAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAMD,cAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAYD,sBAPG;QAAyB,MAAM;QACI,IAAI;QACd,IAAI;QACJ,IAAI;QACJ,GAAG;KAC5B,GAAU,OAAO,CAAC,IAAI,CAAC,CAMzB;IAMD,gBAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAMD,wBAFa,OAAO,CAAC,IAAI,CAAC,CAMzB;IAMD,4BAFa,OAAO,CAAC,IAAI,CAAC,CAMzB;IAMD,wBAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAMD,oBAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAMD,uBAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAMD,qBAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAUD,wBALG;QAAwB,GAAG,EAAnB,MAAM;QACU,OAAO,EAAvB,MAAM;QACW,QAAQ,EAAzB,OAAO;KACf,GAAU,OAAO,CAAC,IAAI,CAAC,CAMzB;;CACF;;gBAzhBa,OAAO;gBACP,OAAO;aACP,MAAM;gBACN,MAAM;mBACN,OAAO;uBACP,OAAO;eACP,MAAM;kBACN,MAAM;eACN,MAAM;aACN,MAAM;aACN,MAAM;oBACN,MAAM;mBACN,MAAM;iBACN,MAAM;iBACN,MAAM;eACN,MAAM;qBACN,MAAM;wBACN,MAAM;;;mBAON,MAAM;eACN,MAAM;iBACN,MAAM;kBACN,MAAM;SACN,MAAM;cACN,MAAM;qBACN,MAAM;iBACN,MAAM;cACN,MAAM;gBACN,MAAM;kBACN,MAAM;mBACN,MAAM;gBACN,OAAO;oBACP,MAAM;eACN,MAAM;iBACN,MAAM;iBACN,OAAO;YACP,MAAM;gBACN,MAAM;gBACN,IAAI,GAAG,IAAI;oBACX,MAAM;UACN,MAAM;SACN,MAAM;;;YAQjB;QAAkC,MAAM;QACN,QAAQ;QACR,IAAI;QACJ,MAAM;QACN,MAAM;QACN,SAAS;QACT,OAAO;QACP,MAAM;QACd,QAAQ,EAAvB,MAAM;QACgB,UAAU,EAAhC,IAAI,GAAG,MAAM;KAE1B;;sCAIY,cAAc,GAAG,WAAW,GAAG,cAAc;6BAG7B,QAAQ;gCAhFN,MAAM"}

package/lib/mqtt/client.js

@@ -0,0 +1,558 @@
+/**
+ * Yoto MQTT Client
+ *
+ * Wrapper around mqtt.js with Yoto-specific functionality
+ * @see https://yoto.dev/players-mqtt/
+ */
+
+// ============================================================================
+// MQTT Client: Yoto-specific wrapper around mqtt.js
+// ============================================================================
+
+/**
+ * @import { MqttClient } from 'mqtt'
+ */
+
+/**
+ * Events message from device
+ * Note: Messages are partial - only changed fields are included
+ * @see https://yoto.dev/players-mqtt/mqtt-docs/#deviceiddataevents
+ * @typedef {Object} YotoEventsMessage
+ * @property {boolean} [repeatAll] - Repeat all tracks
+ * @property {boolean} [streaming] - Whether streaming
+ * @property {number} [volume] - Current volume level
+ * @property {number} [volumeMax] - Maximum volume level
+ * @property {boolean} [playbackWait] - Playback waiting
+ * @property {boolean} [sleepTimerActive] - Sleep timer active
+ * @property {number} [eventUtc] - Unix timestamp
+ * @property {number} [trackLength] - Track duration in seconds
+ * @property {number} [position] - Current position in seconds
+ * @property {string} [cardId] - Currently playing card ID
+ * @property {string} [source] - Source of playback (e.g., "card", "remote", "MQTT")
+ * @property {string} [cardUpdatedAt] - ISO8601 format timestamp
+ * @property {string} [chapterTitle] - Current chapter title
+ * @property {string} [chapterKey] - Current chapter key
+ * @property {string} [trackTitle] - Current track title
+ * @property {string} [trackKey] - Current track key
+ * @property {string} [playbackStatus] - Playback status (e.g., "playing", "paused", "stopped")
+ * @property {number} [sleepTimerSeconds] - Seconds remaining on sleep timer
+ */
+
+/**
+ * Status message from device
+ * @see https://yoto.dev/players-mqtt/mqtt-docs/#deviceiddatastatus
+ * @typedef {Object} YotoStatusMessage
+ * @property {number} statusVersion - Status message version
+ * @property {string} fwVersion - Firmware version
+ * @property {string} productType - Product type identifier
+ * @property {number} batteryLevel - Battery level percentage
+ * @property {number} als - Ambient light sensor reading
+ * @property {number} freeDisk - Free disk space
+ * @property {number} shutdownTimeout - Shutdown timeout in seconds
+ * @property {number} dbatTimeout - DBAT timeout
+ * @property {number} charging - Charging state (0 or 1)
+ * @property {string} activeCard - Active card ID
+ * @property {number} cardInserted - Card insertion state
+ * @property {number} playingStatus - Playing status code
+ * @property {boolean} headphones - Headphones connected
+ * @property {number} dnowBrightness - Current display brightness
+ * @property {number} dayBright - Day brightness setting
+ * @property {number} nightBright - Night brightness setting
+ * @property {boolean} bluetoothHp - Bluetooth headphones enabled
+ * @property {number} volume - Current volume
+ * @property {number} userVolume - User volume setting
+ * @property {'12' | '24'} timeFormat - Time format preference
+ * @property {string} nightlightMode - Nightlight mode setting
+ * @property {string} temp - Temperature reading
+ * @property {number} day - Day mode (0 or 1)
+ */
+
+/**
+ * Response message from device
+ * @see https://yoto.dev/players-mqtt/mqtt-docs/#deviceidresponse
+ * @typedef {Object} YotoResponseMessage
+ * @property {Object} status - Status object with dynamic resource keys
+ * @property {'OK' | 'FAIL'} [status.volume] - Volume command result
+ * @property {'OK' | 'FAIL'} [status.ambients] - Ambients command result
+ * @property {'OK' | 'FAIL'} [status.card] - Card command result
+ * @property {'OK' | 'FAIL'} [status.events] - Events request result
+ * @property {'OK' | 'FAIL'} [status.status] - Status request result
+ * @property {'OK' | 'FAIL'} [status.bluetooth] - Bluetooth command result
+ * @property {'OK' | 'FAIL'} [status.display] - Display command result
+ * @property {'OK' | 'FAIL'} [status.reboot] - Reboot command result
+ * @property {string} status.req_body - Stringified JSON from original request
+ * @property {'OK' | 'FAIL'} status.sleepTimer - Sleep timer command result (note: actual field name is 'sleep-timer')
+
+ */
+
+/**
+ * MQTT connection state
+ * @typedef {'disconnected' | 'connected' | 'reconnecting'} YotoMqttConnectionState
+ */
+
+import { EventEmitter } from 'events'
+import {
+  getSubscriptionTopics,
+  parseTopic,
+  getEventsRequestTopic,
+  getStatusRequestTopic,
+  getVolumeSetTopic,
+  getAmbientsSetTopic,
+  getSleepTimerSetTopic,
+  getRebootTopic,
+  getCardStartTopic,
+  getCardStopTopic,
+  getCardPauseTopic,
+  getCardResumeTopic,
+  getBluetoothOnTopic,
+  getBluetoothOffTopic,
+  getBluetoothDeleteBondsTopic,
+  getBluetoothConnectTopic,
+  getBluetoothDisconnectTopic,
+  getBluetoothStateTopic,
+  getDisplayPreviewTopic
+} from './topics.js'
+import { commands } from './commands.js'
+
+/**
+ * Yoto MQTT Client class
+ * @extends EventEmitter
+ *
+ * @fires YotoMqttClient#events
+ * @fires YotoMqttClient#status
+ * @fires YotoMqttClient#response
+ * @fires YotoMqttClient#connected
+ * @fires YotoMqttClient#disconnected
+ * @fires YotoMqttClient#reconnecting
+ * @fires YotoMqttClient#error
+ */
+export class YotoMqttClient extends EventEmitter {
+  /**
+   * Create a Yoto MQTT client
+   * @param {MqttClient} mqttClient - Underlying MQTT client
+   * @param {string} deviceId - Device ID
+   * @param {Object} [options] - Client options
+   * @param {boolean} [options.autoSubscribe=true] - Auto-subscribe to device topics on connect
+   */
+  constructor (mqttClient, deviceId, options = {}) {
+    super()
+
+    this.mqttClient = mqttClient
+    this.deviceId = deviceId
+    this.autoSubscribe = options.autoSubscribe !== false
+
+    // Bind MQTT event handlers
+    this.#setupEventHandlers()
+
+    // Export command builders for convenience
+    this.commands = commands
+  }
+
+  /**
+   * Get current connection state
+   * @returns {YotoMqttConnectionState}
+   */
+  get state () {
+    if (this.mqttClient.connected) return 'connected'
+    if (this.mqttClient.reconnecting) return 'reconnecting'
+    return 'disconnected'
+  }
+
+  /**
+   * Check if client is connected
+   * @returns {boolean}
+   */
+  get connected () {
+    return this.mqttClient.connected
+  }
+
+  /**
+   * Setup MQTT event handlers
+   */
+  #setupEventHandlers () {
+    // Connection established
+    this.mqttClient.on('connect', async () => {
+      // Auto-subscribe to device topics if enabled
+      if (this.autoSubscribe) {
+        await this.#subscribe()
+      }
+
+      // Only emit connected after subscriptions are ready
+      this.emit('connected')
+    })
+
+    // Connection lost
+    this.mqttClient.on('disconnect', () => {
+      this.emit('disconnected')
+    })
+
+    // Connection closed
+    this.mqttClient.on('close', () => {
+      this.emit('disconnected')
+    })
+
+    // Reconnecting
+    this.mqttClient.on('reconnect', () => {
+      this.emit('reconnecting')
+    })
+
+    // Error occurred
+    this.mqttClient.on('error', (error) => {
+      this.emit('error', error)
+    })
+
+    // Message received
+    this.mqttClient.on('message', (topic, message) => {
+      this.#handleMessage(topic, message)
+    })
+  }
+
+  /**
+   * Subscribe to device topics
+   * @returns {Promise<void>}
+   */
+  async #subscribe () {
+    const topics = getSubscriptionTopics(this.deviceId)
+
+    // Wait for all subscriptions to complete
+    await Promise.all(
+      topics.map((topic) => {
+        return new Promise((resolve, reject) => {
+          this.mqttClient.subscribe(topic, (err) => {
+            if (err) {
+              const error = new Error(`Failed to subscribe to ${topic}: ${err.message}`)
+              this.emit('error', error)
+              reject(error)
+            } else {
+              resolve(undefined)
+            }
+          })
+        })
+      })
+    )
+  }
+
+  /**
+   * Handle incoming MQTT message
+   * @param {string} topic - MQTT topic
+   * @param {Buffer} message - Message payload
+   */
+  #handleMessage (topic, message) {
+    const { deviceId, messageType } = parseTopic(topic)
+
+    // Ignore messages from other devices
+    if (deviceId !== this.deviceId) {
+      return
+    }
+
+    // Ignore unknown message types
+    if (messageType === 'unknown') {
+      return
+    }
+
+    try {
+      const payload = JSON.parse(message.toString())
+
+      // Emit typed events based on message type
+      if (messageType === 'events') {
+        this.emit('events', /** @type {YotoEventsMessage} */ (payload))
+      } else if (messageType === 'status') {
+        this.emit('status', /** @type {YotoStatusMessage} */ (payload))
+      } else if (messageType === 'response') {
+        this.emit('response', /** @type {YotoResponseMessage} */ (payload))
+      }
+    } catch (err) {
+      const error = /** @type {Error} */ (err)
+      this.emit('error', new Error(`Failed to parse message from ${topic}: ${error.message}`))
+    }
+  }
+
+  /**
+   * Connect to MQTT broker
+   * @returns {Promise<void>}
+   */
+  async connect () {
+    return new Promise((resolve, reject) => {
+      if (this.connected) {
+        resolve()
+        return
+      }
+
+      const onConnect = () => {
+        cleanup()
+        resolve()
+      }
+
+      const onError = (/** @type {Error} */ error) => {
+        cleanup()
+        reject(error)
+      }
+
+      const cleanup = () => {
+        this.mqttClient.off('connect', onConnect)
+        this.mqttClient.off('error', onError)
+      }
+
+      this.mqttClient.once('connect', onConnect)
+      this.mqttClient.once('error', onError)
+
+      // MQTT client should already be connecting from factory
+      // If not connected, it will connect automatically
+    })
+  }
+
+  /**
+   * Disconnect from MQTT broker
+   * @returns {Promise<void>}
+   */
+  async disconnect () {
+    return new Promise((resolve) => {
+      if (!this.connected && !this.mqttClient.reconnecting) {
+        resolve()
+        return
+      }
+
+      const onClose = () => {
+        this.mqttClient.off('close', onClose)
+        resolve()
+      }
+
+      this.mqttClient.once('close', onClose)
+      this.mqttClient.end()
+    })
+  }
+
+  /**
+   * Publish a message to a topic
+   * @param {string} topic - MQTT topic
+   * @param {Object | string} payload - Message payload (will be JSON stringified if object)
+   * @returns {Promise<void>}
+   */
+  async #publish (topic, payload) {
+    return new Promise((resolve, reject) => {
+      const message = typeof payload === 'string' ? payload : JSON.stringify(payload)
+
+      this.mqttClient.publish(topic, message, (err) => {
+        if (err) {
+          reject(new Error(`Failed to publish to ${topic}: ${err.message}`))
+        } else {
+          resolve()
+        }
+      })
+    })
+  }
+
+  // Command methods
+
+  /**
+   * Request current events from device
+   * @returns {Promise<void>}
+   */
+  async requestEvents () {
+    const topic = getEventsRequestTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Request current status from device
+   * @returns {Promise<void>}
+   */
+  async requestStatus () {
+    const topic = getStatusRequestTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Set device volume
+   * @param {number} volume - Volume level [0-100]
+   * @returns {Promise<void>}
+   */
+  async setVolume (volume) {
+    const command = commands.volume(volume)
+    const topic = getVolumeSetTopic(this.deviceId)
+    return this.#publish(topic, command)
+  }
+
+  /**
+   * Set ambient light color
+   * @param {number} r - Red intensity [0-255]
+   * @param {number} g - Green intensity [0-255]
+   * @param {number} b - Blue intensity [0-255]
+   * @returns {Promise<void>}
+   */
+  async setAmbient (r, g, b) {
+    const command = commands.ambient(r, g, b)
+    const topic = getAmbientsSetTopic(this.deviceId)
+    return this.#publish(topic, command)
+  }
+
+  /**
+   * Set ambient light color from hex
+   * @param {string} hexColor - Hex color string (e.g., "#FF0000")
+   * @returns {Promise<void>}
+   */
+  async setAmbientHex (hexColor) {
+    const command = commands.ambientFromHex(hexColor)
+    const topic = getAmbientsSetTopic(this.deviceId)
+    return this.#publish(topic, command)
+  }
+
+  /**
+   * Set sleep timer
+   * @param {number} seconds - Timer duration in seconds (0 to disable)
+   * @returns {Promise<void>}
+   */
+  async setSleepTimer (seconds) {
+    const command = commands.sleepTimer(seconds)
+    const topic = getSleepTimerSetTopic(this.deviceId)
+    return this.#publish(topic, command)
+  }
+
+  /**
+   * Reboot device
+   * @returns {Promise<void>}
+   */
+  async reboot () {
+    const topic = getRebootTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Start card playback
+   * @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 {Promise<void>}
+   */
+  async startCard (options) {
+    const command = commands.cardStart(options)
+    const topic = getCardStartTopic(this.deviceId)
+    return this.#publish(topic, command)
+  }
+
+  /**
+   * Stop card playback
+   * @returns {Promise<void>}
+   */
+  async stopCard () {
+    const topic = getCardStopTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Pause card playback
+   * @returns {Promise<void>}
+   */
+  async pauseCard () {
+    const topic = getCardPauseTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Resume card playback
+   * @returns {Promise<void>}
+   */
+  async resumeCard () {
+    const topic = getCardResumeTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Turn Bluetooth on
+   * @param {Object} [options] - Bluetooth options
+   * @param {string} [options.action] - Bluetooth action
+   * @param {boolean | string} [options.mode] - Bluetooth mode
+   * @param {number} [options.rssi] - RSSI threshold
+   * @param {string} [options.name] - Target device name
+   * @param {string} [options.mac] - Target device MAC
+   * @returns {Promise<void>}
+   */
+  async bluetoothOn (options) {
+    const command = commands.bluetoothOn(options)
+    const topic = getBluetoothOnTopic(this.deviceId)
+    return this.#publish(topic, command)
+  }
+
+  /**
+   * Turn Bluetooth off
+   * @returns {Promise<void>}
+   */
+  async bluetoothOff () {
+    const topic = getBluetoothOffTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Enable Bluetooth speaker mode
+   * @returns {Promise<void>}
+   */
+  async bluetoothSpeakerMode () {
+    const command = commands.bluetoothSpeaker()
+    const topic = getBluetoothOnTopic(this.deviceId)
+    return this.#publish(topic, command)
+  }
+
+  /**
+   * Enable Bluetooth audio source mode
+   * @returns {Promise<void>}
+   */
+  async bluetoothAudioSourceMode () {
+    const command = commands.bluetoothAudioSource()
+    const topic = getBluetoothOnTopic(this.deviceId)
+    return this.#publish(topic, command)
+  }
+
+  /**
+   * Delete all Bluetooth bonds
+   * @returns {Promise<void>}
+   */
+  async bluetoothDeleteBonds () {
+    const topic = getBluetoothDeleteBondsTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Connect to Bluetooth device
+   * @returns {Promise<void>}
+   */
+  async bluetoothConnect () {
+    const topic = getBluetoothConnectTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Disconnect Bluetooth device
+   * @returns {Promise<void>}
+   */
+  async bluetoothDisconnect () {
+    const topic = getBluetoothDisconnectTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Get Bluetooth state
+   * @returns {Promise<void>}
+   */
+  async bluetoothGetState () {
+    const topic = getBluetoothStateTopic(this.deviceId)
+    return this.#publish(topic, '')
+  }
+
+  /**
+   * Preview display icon
+   * @param {Object} options - Display preview options
+   * @param {string} options.uri - Icon URI
+   * @param {number} options.timeout - Display duration in seconds
+   * @param {boolean} options.animated - Whether icon is animated
+   * @returns {Promise<void>}
+   */
+  async displayPreview (options) {
+    const command = commands.displayPreview(options)
+    const topic = getDisplayPreviewTopic(this.deviceId)
+    return this.#publish(topic, command)
+  }
+}