yoto-nodejs-client 0.0.4 → 0.0.6

package/lib/api-client.js

@@ -7,9 +7,9 @@
  * @import { YotoAudioUploadUrlResponse, YotoUploadCoverImageResponse, YotoCoverType } from './api-endpoints/media.js'
  * @import { YotoTokenResponse, YotoDeviceCodeResponse, YotoDevicePollResult } from './api-endpoints/auth.js'
  * @import { YotoMqttClient } from './mqtt/client.js'
- * @import { MqttClientOptions, YotoMqttOptions } from './mqtt/factory.js'
+ * @import { YotoMqttOptions } from './mqtt/factory.js'
  * @import { RequestOptions } from './api-endpoints/helpers.js'
- * @import { RefreshSuccessEvent } from './token.js'
+ * @import { OnTokenRefreshHandler } from './token.js'
  */
 
 import { RefreshableToken } from './token.js'
@@ -27,11 +27,12 @@ import { createYotoMqttClient } from './mqtt/index.js'
  * @property {string} clientId - OAuth client ID
  * @property {string} refreshToken - OAuth refresh token
  * @property {string} accessToken - Initial OAuth access token (JWT)
- * @property {(refreshedTokenData: RefreshSuccessEvent) => void | Promise<void>} onTokenRefresh - **REQUIRED** Callback invoked when tokens are refreshed. You MUST persist these tokens (to file, database, etc.) as the refresh can happen at any time during API calls. The refresh token may be rotated by the auth server. **DO NOT STUB THIS CALLBACK** - always implement proper persistence logic.
+ * @property {OnTokenRefreshHandler} onTokenRefresh - **REQUIRED** Callback invoked when tokens are refreshed. You MUST persist these tokens (to file, database, etc.) as the refresh can happen at any time during API calls. The refresh token may be rotated by the auth server. **DO NOT STUB THIS CALLBACK** - always implement proper persistence logic.
  * @property {number} [bufferSeconds=30] - Seconds before expiration to consider token expired
  * @property {() => void | Promise<void>} [onRefreshStart] - Optional callback invoked when token refresh starts. Defaults to console.log.
  * @property {(error: Error) => void | Promise<void>} [onRefreshError] - Optional callback invoked when token refresh fails with a transient error. Defaults to console.warn.
  * @property {(error: Error) => void | Promise<void>} [onInvalid] - Optional callback invoked when refresh token is permanently invalid. Defaults to console.error.
+ * @property {string} [mqttSessionId] - Stable unique client ID suffix used for MQTT connections (defaults to a random UUID per YotoClient instance)
  * @property {string} [userAgent] - Optional user agent string to identify your application
  * @property {RequestOptions} [defaultRequestOptions] - Default undici request options for all requests (dispatcher, timeouts, etc.)
  */
@@ -187,15 +188,13 @@ export class YotoClient {
       clientId,
       refreshToken,
       accessToken,
-      ...(bufferSeconds !== undefined && { bufferSeconds })
+      ...(bufferSeconds !== undefined && { bufferSeconds }),
+      onTokenRefresh
     })
 
     this.#userAgent = userAgent
     this.#defaultRequestOptions = defaultRequestOptions
 
-    // Listen for token refresh events and call the user's callbacks
-    this.#token.on('refresh:success', onTokenRefresh)
-
     this.#token.on('refresh:start', onRefreshStart || (() => {
       console.log('Token refresh started')
     }))
@@ -216,6 +215,7 @@ export class YotoClient {
   get token () {
     return this.#token
   }
+
   // ============================================================================
   // Content API
   // ============================================================================
@@ -438,7 +438,7 @@ export class YotoClient {
   async createGroup ({ group, requestOptions }) {
     const accessToken = await this.#token.getAccessToken()
     return await FamilyLibraryGroups.createGroup({
-      token: accessToken,
+      accessToken,
       userAgent: this.#userAgent,
       requestOptions: requestOptions || this.#defaultRequestOptions,
       group
@@ -661,19 +661,17 @@ export class YotoClient {
 
   /**
    * Create an MQTT client for a device
-   * @param {Object} params
-   * @param {string} params.deviceId - Device ID to connect to
-   * @param {MqttClientOptions} [params.mqttOptions] - MQTT.js client options (excluding deviceId and accessToken which are provided automatically)
+   * @param {Omit<YotoMqttOptions, 'token'>} YotoMqttOptions
    * @returns {Promise<YotoMqttClient>}
    */
   async createMqttClient ({ deviceId, mqttOptions }) {
-    const accessToken = await this.#token.getAccessToken()
+    await this.#token.getAccessToken()
 
     /** @type {YotoMqttOptions} */
     const opts = {
       deviceId,
-      accessToken,
-      ...mqttOptions
+      token: this.#token,
+      ...(mqttOptions && { mqttOptions })
     }
 
     return createYotoMqttClient(opts)

package/lib/api-endpoints/auth.test.js

@@ -4,7 +4,7 @@ import { exchangeToken, pollForDeviceToken } from './auth.js'
 import { YotoAPIError } from './helpers.js'
 import { loadTestTokens } from './endpoint-test-helpers.js'
 
-const { clientId } = loadTestTokens()
+const { token } = loadTestTokens()
 
 test('exchangeToken - refresh flow', async (t) => {
   await t.test('should fail with invalid refresh token', async () => {
@@ -13,7 +13,7 @@ test('exchangeToken - refresh flow', async (t) => {
         await exchangeToken({
           grantType: 'refresh_token',
           refreshToken: 'invalid-refresh-token',
-          clientId
+          clientId: token.clientId
         })
       },
       (err) => {
@@ -33,7 +33,7 @@ test('pollForDeviceToken', async (t) => {
       async () => {
         await pollForDeviceToken({
           deviceCode: 'invalid-device-code',
-          clientId,
+          clientId: token.clientId,
           currentInterval: 5000
         })
       },
@@ -54,7 +54,7 @@ test('pollForDeviceToken', async (t) => {
       async () => {
         await pollForDeviceToken({
           deviceCode: 'expired-device-code-xyz',
-          clientId,
+          clientId: token.clientId,
           currentInterval: 5000
         })
       },

package/lib/api-endpoints/content.test.js

@@ -4,12 +4,12 @@ import { getContent, getUserMyoContent } from './content.js'
 import { YotoAPIError } from './helpers.js'
 import { loadTestTokens, logResponse } from './endpoint-test-helpers.js'
 
-const { accessToken } = loadTestTokens()
+const { token } = loadTestTokens()
 
 test('getUserMyoContent', async (t) => {
   await t.test('should fetch user MYO cards', async () => {
     const response = await getUserMyoContent({
-      accessToken
+      accessToken: await token.getAccessToken()
     })
 
     // Log response for type verification and documentation
@@ -23,15 +23,15 @@ test('getUserMyoContent', async (t) => {
     // Validate card structure
     const card = response.cards[0]
     assert.ok(card, 'Card should exist')
-    assert.ok(typeof card.cardId === 'string', 'Card should have cardId string')
-    assert.ok(typeof card.title === 'string', 'Card should have title string')
-    assert.ok(typeof card.createdAt === 'string', 'Card should have createdAt string')
-    assert.ok(typeof card.updatedAt === 'string', 'Card should have updatedAt string')
-    assert.ok(typeof card.userId === 'string', 'Card should have userId string')
+    assert.equal(typeof card.cardId, 'string', 'Card should have cardId string')
+    assert.equal(typeof card.title, 'string', 'Card should have title string')
+    assert.equal(typeof card.createdAt, 'string', 'Card should have createdAt string')
+    assert.equal(typeof card.updatedAt, 'string', 'Card should have updatedAt string')
+    assert.equal(typeof card.userId, 'string', 'Card should have userId string')
     assert.ok(card.content, 'Card should have content object')
     assert.ok(card.metadata, 'Card should have metadata object')
     assert.ok(card.metadata.media, 'Metadata should have media object')
-    assert.ok(typeof card.metadata.media.duration === 'number', 'Media should have duration number')
+    assert.equal(typeof card.metadata.media.duration, 'number', 'Media should have duration number')
 
     // Validate metadata category enum if present and non-empty
     if (card.metadata.category && card.metadata.category.length > 0) {
@@ -51,7 +51,7 @@ test('getUserMyoContent', async (t) => {
     if (card.metadata.status) {
       const validStatuses = ['new', 'inprogress', 'complete', 'live', 'archived']
       assert.ok(validStatuses.includes(card.metadata.status.name), `Status name should be valid: ${card.metadata.status.name}`)
-      assert.ok(typeof card.metadata.status.updatedAt === 'string', 'Status should have updatedAt string')
+      assert.equal(typeof card.metadata.status.updatedAt, 'string', 'Status should have updatedAt string')
     }
 
     if (card.metadata.playbackDirection) {
@@ -61,7 +61,7 @@ test('getUserMyoContent', async (t) => {
 
   await t.test('should accept showDeleted parameter', async () => {
     const response = await getUserMyoContent({
-      accessToken,
+      accessToken: await token.getAccessToken(),
       showDeleted: true
     })
 
@@ -93,7 +93,7 @@ test('getContent', async (t) => {
   // Get real card IDs to test with
   await t.test('setup - get card IDs from user content', async () => {
     const response = await getUserMyoContent({
-      accessToken
+      accessToken: await token.getAccessToken()
     })
 
     assert.ok(response.cards.length > 0, 'User should have at least one card for getContent tests')
@@ -106,7 +106,7 @@ test('getContent', async (t) => {
     // Test with multiple cards to ensure consistency
     for (const cardId of testCardIds) {
       const content = await getContent({
-        accessToken,
+        accessToken: await token.getAccessToken(),
         cardId
       })
 
@@ -117,9 +117,9 @@ test('getContent', async (t) => {
       assert.ok(content, 'Response should exist')
       assert.ok(content.card, 'Response should have card property')
       assert.strictEqual(content.card.cardId, cardId, 'Returned card ID should match requested ID')
-      assert.ok(typeof content.card.title === 'string', 'Card should have title')
-      assert.ok(typeof content.card.createdAt === 'string', 'Card should have createdAt')
-      assert.ok(typeof content.card.updatedAt === 'string', 'Card should have updatedAt')
+      assert.equal(typeof content.card.title, 'string', 'Card should have title')
+      assert.equal(typeof content.card.createdAt, 'string', 'Card should have createdAt')
+      assert.equal(typeof content.card.updatedAt, 'string', 'Card should have updatedAt')
       assert.ok(content.card.content, 'Card should have content property')
       assert.ok(Array.isArray(content.card.content.chapters), 'Content should have chapters array')
       assert.ok(content.card.metadata, 'Card should have metadata')
@@ -143,7 +143,7 @@ test('getContent', async (t) => {
     assert.ok(cardId, 'Card ID should exist')
 
     const content = await getContent({
-      accessToken,
+      accessToken: await token.getAccessToken(),
       cardId
     })
 
@@ -156,14 +156,14 @@ test('getContent', async (t) => {
       assert.ok(chapter, 'Chapter should exist')
 
       // Validate chapter structure
-      assert.ok(typeof chapter.key === 'string', 'Chapter should have key string')
-      assert.ok(typeof chapter.title === 'string', 'Chapter should have title string')
-      assert.ok(typeof chapter.overlayLabel === 'string', 'Chapter should have overlayLabel string')
+      assert.equal(typeof chapter.key, 'string', 'Chapter should have key string')
+      assert.equal(typeof chapter.title, 'string', 'Chapter should have title string')
+      assert.equal(typeof chapter.overlayLabel, 'string', 'Chapter should have overlayLabel string')
       assert.ok(Array.isArray(chapter.tracks), 'Chapter should have tracks array')
       assert.ok(chapter.display, 'Chapter should have display object')
-      assert.ok(typeof chapter.display.icon16x16 === 'string', 'Chapter display should have icon16x16 string')
-      assert.ok(typeof chapter.duration === 'number', 'Chapter should have duration number')
-      assert.ok(typeof chapter.fileSize === 'number', 'Chapter should have fileSize number')
+      assert.equal(typeof chapter.display.icon16x16, 'string', 'Chapter display should have icon16x16 string')
+      assert.equal(typeof chapter.duration, 'number', 'Chapter should have duration number')
+      assert.equal(typeof chapter.fileSize, 'number', 'Chapter should have fileSize number')
       assert.ok('availableFrom' in chapter, 'Chapter should have availableFrom property')
       assert.ok('ambient' in chapter, 'Chapter should have ambient property')
       assert.ok('defaultTrackDisplay' in chapter, 'Chapter should have defaultTrackDisplay property')
@@ -175,24 +175,24 @@ test('getContent', async (t) => {
         assert.ok(track, 'Track should exist')
 
         // Validate track structure
-        assert.ok(typeof track.key === 'string', 'Track should have key string')
-        assert.ok(typeof track.title === 'string', 'Track should have title string')
-        assert.ok(typeof track.trackUrl === 'string', 'Track should have trackUrl string')
+        assert.equal(typeof track.key, 'string', 'Track should have key string')
+        assert.equal(typeof track.title, 'string', 'Track should have title string')
+        assert.equal(typeof track.trackUrl, 'string', 'Track should have trackUrl string')
         assert.ok(track.trackUrl.startsWith('yoto:#'), 'Track URL should start with "yoto:#"')
-        assert.ok(typeof track.format === 'string', 'Track should have format string')
+        assert.equal(typeof track.format, 'string', 'Track should have format string')
 
         // Validate audio format enum
         const validFormats = ['mp3', 'aac', 'opus', 'ogg']
         assert.ok(validFormats.includes(track.format), `Track format should be valid: ${track.format}`)
 
         assert.ok(track.type === 'audio' || track.type === 'stream', 'Track type should be "audio" or "stream"')
-        assert.ok(typeof track.overlayLabel === 'string', 'Track should have overlayLabel string')
-        assert.ok(typeof track.duration === 'number', 'Track should have duration number')
-        assert.ok(typeof track.fileSize === 'number', 'Track should have fileSize number')
+        assert.equal(typeof track.overlayLabel, 'string', 'Track should have overlayLabel string')
+        assert.equal(typeof track.duration, 'number', 'Track should have duration number')
+        assert.equal(typeof track.fileSize, 'number', 'Track should have fileSize number')
         assert.ok(track.channels === 'stereo' || track.channels === 'mono', 'Track channels should be "stereo" or "mono"')
         assert.ok('ambient' in track, 'Track should have ambient property')
         assert.ok(track.display, 'Track should have display object')
-        assert.ok(typeof track.display.icon16x16 === 'string', 'Track display should have icon16x16 string')
+        assert.equal(typeof track.display.icon16x16, 'string', 'Track display should have icon16x16 string')
         assert.ok(track.display.icon16x16.startsWith('yoto:#'), 'Track display icon should start with "yoto:#"')
       }
     }
@@ -203,7 +203,7 @@ test('getContent', async (t) => {
     assert.ok(cardId, 'Card ID should exist')
 
     const content = await getContent({
-      accessToken,
+      accessToken: await token.getAccessToken(),
       cardId,
       timezone: 'Pacific/Auckland'
     })
@@ -220,7 +220,7 @@ test('getContent', async (t) => {
     assert.ok(cardId, 'Card ID should exist')
 
     const content = await getContent({
-      accessToken,
+      accessToken: await token.getAccessToken(),
       cardId,
       playable: true,
       signingType: 's3'

package/lib/api-endpoints/devices.d.ts

@@ -185,7 +185,7 @@ export function getDeviceStatus({ accessToken, userAgent, deviceId, requestOptio
  * @property {string} bluetoothEnabled - Bluetooth enabled state ('0' or '1')
  * @property {boolean} btHeadphonesEnabled - Bluetooth headphones enabled
  * @property {string} clockFace - Clock face style (e.g., 'digital-sun')
- * @property {string} dayDisplayBrightness - Day display brightness (e.g., 'auto', '100')
+ * @property {string} dayDisplayBrightness - Day display brightness (e.g., 'auto', '0' - '100')
  * @property {string} dayTime - Day mode start time (e.g., '07:00')
  * @property {string} dayYotoDaily - Day mode Yoto Daily card path
  * @property {string} dayYotoRadio - Day mode Yoto Radio card path
@@ -198,7 +198,7 @@ export function getDeviceStatus({ accessToken, userAgent, deviceId, requestOptio
  * @property {string} locale - Device locale (e.g., 'en') (undocumented)
  * @property {string} maxVolumeLimit - Maximum volume limit
  * @property {string} nightAmbientColour - Night ambient light color (hex code)
- * @property {string} nightDisplayBrightness - Night display brightness
+ * @property {string} nightDisplayBrightness - Night display brightness (e.g., 'auto', '0' - '100')
  * @property {string} nightMaxVolumeLimit - Night maximum volume limit
  * @property {string} nightTime - Night mode start time (e.g., '19:20')
  * @property {string} nightYotoDaily - Night mode Yoto Daily card path
@@ -865,7 +865,7 @@ export type YotoDeviceConfig = {
      */
     clockFace: string;
     /**
-     * - Day display brightness (e.g., 'auto', '100')
+     * - Day display brightness (e.g., 'auto', '0' - '100')
      */
     dayDisplayBrightness: string;
     /**
@@ -917,7 +917,7 @@ export type YotoDeviceConfig = {
      */
     nightAmbientColour: string;
     /**
-     * - Night display brightness
+     * - Night display brightness (e.g., 'auto', '0' - '100')
      */
     nightDisplayBrightness: string;
     /**

package/lib/api-endpoints/devices.js

@@ -226,7 +226,7 @@ export async function getDeviceStatus ({
  * @property {string} bluetoothEnabled - Bluetooth enabled state ('0' or '1')
  * @property {boolean} btHeadphonesEnabled - Bluetooth headphones enabled
  * @property {string} clockFace - Clock face style (e.g., 'digital-sun')
- * @property {string} dayDisplayBrightness - Day display brightness (e.g., 'auto', '100')
+ * @property {string} dayDisplayBrightness - Day display brightness (e.g., 'auto', '0' - '100')
  * @property {string} dayTime - Day mode start time (e.g., '07:00')
  * @property {string} dayYotoDaily - Day mode Yoto Daily card path
  * @property {string} dayYotoRadio - Day mode Yoto Radio card path
@@ -239,7 +239,7 @@ export async function getDeviceStatus ({
  * @property {string} locale - Device locale (e.g., 'en') (undocumented)
  * @property {string} maxVolumeLimit - Maximum volume limit
  * @property {string} nightAmbientColour - Night ambient light color (hex code)
- * @property {string} nightDisplayBrightness - Night display brightness
+ * @property {string} nightDisplayBrightness - Night display brightness (e.g., 'auto', '0' - '100')
  * @property {string} nightMaxVolumeLimit - Night maximum volume limit
  * @property {string} nightTime - Night mode start time (e.g., '19:20')
  * @property {string} nightYotoDaily - Night mode Yoto Daily card path

package/lib/api-endpoints/devices.test.js

@@ -1,15 +1,15 @@
 import test from 'node:test'
-import assert from 'node:assert'
+import assert from 'node:assert/strict'
 import { getDevices, getDeviceStatus, getDeviceConfig } from './devices.js'
 import { YotoAPIError } from './helpers.js'
 import { loadTestTokens, logResponse } from './endpoint-test-helpers.js'
 
-const { accessToken } = loadTestTokens()
+const { token } = loadTestTokens()
 
 test('getDevices', async (t) => {
   await t.test('should fetch user devices', async () => {
     const response = await getDevices({
-      accessToken
+      accessToken: await token.getAccessToken()
     })
 
     // Log response for type verification and documentation
@@ -23,14 +23,14 @@ test('getDevices', async (t) => {
     // Validate device structure
     const device = response.devices[0]
     assert.ok(device, 'Device should exist')
-    assert.ok(typeof device.deviceId === 'string', 'Device should have deviceId string')
-    assert.ok(typeof device.name === 'string', 'Device should have name string')
-    assert.ok(typeof device.description === 'string', 'Device should have description string')
-    assert.ok(typeof device.online === 'boolean', 'Device should have online boolean')
-    assert.ok(typeof device.releaseChannel === 'string', 'Device should have releaseChannel string')
-    assert.ok(typeof device.deviceType === 'string', 'Device should have deviceType string')
-    assert.ok(typeof device.deviceFamily === 'string', 'Device should have deviceFamily string')
-    assert.ok(typeof device.deviceGroup === 'string', 'Device should have deviceGroup string')
+    assert.equal(typeof device.deviceId, 'string', 'Device should have deviceId string')
+    assert.equal(typeof device.name, 'string', 'Device should have name string')
+    assert.equal(typeof device.description, 'string', 'Device should have description string')
+    assert.equal(typeof device.online, 'boolean', 'Device should have online boolean')
+    assert.equal(typeof device.releaseChannel, 'string', 'Device should have releaseChannel string')
+    assert.equal(typeof device.deviceType, 'string', 'Device should have deviceType string')
+    assert.equal(typeof device.deviceFamily, 'string', 'Device should have deviceFamily string')
+    assert.equal(typeof device.deviceGroup, 'string', 'Device should have deviceGroup string')
   })
 
   await t.test('should fail with invalid token', async () => {
@@ -61,7 +61,7 @@ test('getDeviceStatus', async (t) => {
   // Get real device IDs to test with
   await t.test('setup - get device IDs', async () => {
     const response = await getDevices({
-      accessToken
+      accessToken: await token.getAccessToken()
     })
 
     assert.ok(response.devices.length > 0, 'User should have at least one device for getDeviceStatus tests')
@@ -79,7 +79,7 @@ test('getDeviceStatus', async (t) => {
     assert.ok(deviceId, 'Device ID should exist')
 
     const status = await getDeviceStatus({
-      accessToken,
+      accessToken: await token.getAccessToken(),
       deviceId
     })
 
@@ -89,23 +89,23 @@ test('getDeviceStatus', async (t) => {
     // Validate response structure matches YotoDeviceStatusResponse
     assert.ok(status, 'Response should exist')
     assert.strictEqual(status.deviceId, deviceId, 'Returned device ID should match requested ID')
-    assert.ok(typeof status.updatedAt === 'string', 'Status should have updatedAt string')
+    assert.equal(typeof status.updatedAt, 'string', 'Status should have updatedAt string')
 
     // Optional fields - only validate type if present
     if (status.batteryLevelPercentage !== undefined) {
-      assert.ok(typeof status.batteryLevelPercentage === 'number', 'Battery level should be number')
+      assert.equal(typeof status.batteryLevelPercentage, 'number', 'Battery level should be number')
     }
     if (status.isCharging !== undefined) {
-      assert.ok(typeof status.isCharging === 'boolean', 'isCharging should be boolean')
+      assert.equal(typeof status.isCharging, 'boolean', 'isCharging should be boolean')
     }
     if (status.isOnline !== undefined) {
-      assert.ok(typeof status.isOnline === 'boolean', 'isOnline should be boolean')
+      assert.equal(typeof status.isOnline, 'boolean', 'isOnline should be boolean')
     }
     if (status.userVolumePercentage !== undefined) {
-      assert.ok(typeof status.userVolumePercentage === 'number', 'User volume should be number')
+      assert.equal(typeof status.userVolumePercentage, 'number', 'User volume should be number')
     }
     if (status.systemVolumePercentage !== undefined) {
-      assert.ok(typeof status.systemVolumePercentage === 'number', 'System volume should be number')
+      assert.equal(typeof status.systemVolumePercentage, 'number', 'System volume should be number')
     }
     if (status.temperatureCelcius !== undefined && status.temperatureCelcius !== null) {
       assert.ok(
@@ -114,7 +114,7 @@ test('getDeviceStatus', async (t) => {
       )
     }
     if (status.wifiStrength !== undefined) {
-      assert.ok(typeof status.wifiStrength === 'number', 'WiFi strength should be number')
+      assert.equal(typeof status.wifiStrength, 'number', 'WiFi strength should be number')
     }
     if (status.cardInsertionState !== undefined) {
       assert.ok([0, 1, 2].includes(status.cardInsertionState), 'Card insertion state should be 0, 1, or 2')
@@ -131,7 +131,7 @@ test('getDeviceStatus', async (t) => {
     // Test with multiple devices to ensure consistency
     for (const deviceId of testDeviceIds) {
       const status = await getDeviceStatus({
-        accessToken,
+        accessToken: await token.getAccessToken(),
         deviceId
       })
 
@@ -146,7 +146,7 @@ test('getDeviceStatus', async (t) => {
     }
 
     const status = await getDeviceStatus({
-      accessToken,
+      accessToken: await token.getAccessToken(),
       deviceId: onlineDeviceId
     })
 
@@ -163,7 +163,7 @@ test('getDeviceStatus', async (t) => {
     }
 
     const status = await getDeviceStatus({
-      accessToken,
+      accessToken: await token.getAccessToken(),
       deviceId: offlineDeviceId
     })
 
@@ -178,13 +178,13 @@ test('getDeviceStatus', async (t) => {
     await assert.rejects(
       async () => {
         await getDeviceStatus({
-          accessToken,
+          accessToken: await token.getAccessToken(),
           deviceId: 'invalid-device-id-12345'
         })
       },
       (err) => {
         assert.ok(err instanceof YotoAPIError, 'Should throw YotoAPIError')
-        assert.ok(err.statusCode === 404, 'Should return 404 for invalid device ID')
+        assert.equal(err.statusCode, 404, 'Should return 404 for invalid device ID')
         assert.ok(err.body, 'Error should have body')
         return true
       }
@@ -225,7 +225,7 @@ test('getDeviceConfig', async (t) => {
   // Get real device IDs to test with
   await t.test('setup - get device IDs', async () => {
     const response = await getDevices({
-      accessToken
+      accessToken: await token.getAccessToken()
     })
 
     assert.ok(response.devices.length > 0, 'User should have at least one device for getDeviceConfig tests')
@@ -251,7 +251,7 @@ test('getDeviceConfig', async (t) => {
     for (const deviceId of testDeviceIds) {
       try {
         const config = await getDeviceConfig({
-          accessToken,
+          accessToken: await token.getAccessToken(),
           deviceId
         })
         if (config.device.config.alarms && config.device.config.alarms.length > 0) {
@@ -273,7 +273,7 @@ test('getDeviceConfig', async (t) => {
     assert.ok(deviceId, 'Device ID should exist')
 
     const config = await getDeviceConfig({
-      accessToken,
+      accessToken: await token.getAccessToken(),
       deviceId
     })
 
@@ -286,33 +286,33 @@ test('getDeviceConfig', async (t) => {
     assert.strictEqual(config.device.deviceId, deviceId, 'Returned device ID should match requested ID')
 
     // Validate device structure
-    assert.ok(typeof config.device.deviceFamily === 'string', 'Device should have deviceFamily string')
-    assert.ok(typeof config.device.deviceType === 'string', 'Device should have deviceType string')
-    assert.ok(typeof config.device.online === 'boolean', 'Device should have online boolean')
+    assert.equal(typeof config.device.deviceFamily, 'string', 'Device should have deviceFamily string')
+    assert.equal(typeof config.device.deviceType, 'string', 'Device should have deviceType string')
+    assert.equal(typeof config.device.online, 'boolean', 'Device should have online boolean')
 
     // Validate config object exists
     assert.ok(config.device.config, 'Device should have config object')
-    assert.ok(typeof config.device.config === 'object', 'Config should be an object')
+    assert.equal(typeof config.device.config, 'object', 'Config should be an object')
 
     // Validate some config fields
-    if (config.device.config.ambientColour !== undefined) {
-      assert.ok(typeof config.device.config.ambientColour === 'string', 'ambientColour should be string')
+    if (config.device.config.ambientColour !== null) {
+      assert.equal(typeof config.device.config.ambientColour, 'string', 'ambientColour should be string')
     }
     if (config.device.config.clockFace !== undefined) {
-      assert.ok(typeof config.device.config.clockFace === 'string', 'clockFace should be string')
+      assert.equal(typeof config.device.config.clockFace, 'string', 'clockFace should be string')
     }
     if (config.device.config.repeatAll !== undefined) {
-      assert.ok(typeof config.device.config.repeatAll === 'boolean', 'repeatAll should be boolean')
+      assert.equal(typeof config.device.config.repeatAll, 'boolean', 'repeatAll should be boolean')
     }
     if (config.device.config.volumeLevel !== undefined) {
-      assert.ok(typeof config.device.config.volumeLevel === 'string', 'volumeLevel should be string')
+      assert.equal(typeof config.device.config.volumeLevel, 'string', 'volumeLevel should be string')
     }
 
     // Validate shortcuts if present (beta feature)
     if (config.device.shortcuts) {
-      assert.ok(typeof config.device.shortcuts === 'object', 'Shortcuts should be an object')
+      assert.equal(typeof config.device.shortcuts, 'object', 'Shortcuts should be an object')
       if (config.device.shortcuts.versionId) {
-        assert.ok(typeof config.device.shortcuts.versionId === 'string', 'versionId should be string')
+        assert.equal(typeof config.device.shortcuts.versionId, 'string', 'versionId should be string')
       }
     }
   })
@@ -321,7 +321,7 @@ test('getDeviceConfig', async (t) => {
     // Test with different device types to ensure config properties vary appropriately
     for (const [deviceType, deviceId] of deviceTypeMap) {
       const config = await getDeviceConfig({
-        accessToken,
+        accessToken: await token.getAccessToken(),
         deviceId
       })
 
@@ -335,7 +335,7 @@ test('getDeviceConfig', async (t) => {
 
       // Config should always be present but properties may vary by device type
       assert.ok(config.device.config, 'Config should exist for all device types')
-      assert.ok(typeof config.device.config === 'object', 'Config should be object')
+      assert.equal(typeof config.device.config, 'object', 'Config should be object')
     }
   })
 
@@ -343,7 +343,7 @@ test('getDeviceConfig', async (t) => {
     // Log configurations for different device types to see variations
     for (const [deviceType, deviceId] of deviceTypeMap) {
       const config = await getDeviceConfig({
-        accessToken,
+        accessToken: await token.getAccessToken(),
         deviceId
       })
 
@@ -358,7 +358,7 @@ test('getDeviceConfig', async (t) => {
     }
 
     const config = await getDeviceConfig({
-      accessToken,
+      accessToken: await token.getAccessToken(),
       deviceId: onlineDeviceId
     })
 
@@ -378,7 +378,7 @@ test('getDeviceConfig', async (t) => {
     }
 
     const config = await getDeviceConfig({
-      accessToken,
+      accessToken: await token.getAccessToken(),
       deviceId: deviceWithAlarmsId
     })
 
@@ -448,7 +448,7 @@ test('getDeviceConfig', async (t) => {
     await assert.rejects(
       async () => {
         await getDeviceConfig({
-          accessToken,
+          accessToken: await token.getAccessToken(),
           deviceId: 'invalid-device-id-12345'
         })
       },

package/lib/api-endpoints/endpoint-test-helpers.d.ts

@@ -1,11 +1,9 @@
 /**
  * Load tokens from .env file for testing
- * @returns {{accessToken: string, refreshToken: string, clientId: string}}
+ * @returns {{ token: RefreshableToken }}
  */
 export function loadTestTokens(): {
-    accessToken: string;
-    refreshToken: string;
-    clientId: string;
+    token: RefreshableToken;
 };
 /**
  * Log API response for type verification and documentation.
@@ -25,4 +23,5 @@ export function loadTestTokens(): {
  * logResponse('GET DEVICES', devices)
  */
 export function logResponse(label: string, response: any): void;
+import { RefreshableToken } from '../token.js';
 //# sourceMappingURL=endpoint-test-helpers.d.ts.map

package/lib/api-endpoints/endpoint-test-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"endpoint-test-helpers.d.ts","sourceRoot":"","sources":["endpoint-test-helpers.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,kCAFa;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAiCzE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mCAPW,MAAM,YACN,GAAG,QASb"}
+{"version":3,"file":"endpoint-test-helpers.d.ts","sourceRoot":"","sources":["endpoint-test-helpers.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,kCAFa;IAAE,KAAK,EAAE,gBAAgB,CAAA;CAAE,CA+CvC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mCAPW,MAAM,YACN,GAAG,QASb;iCA1EgC,aAAa"}