yoto-nodejs-client 0.0.1

package/bin/auth.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=auth.d.ts.map

package/bin/auth.d.ts.map

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

package/bin/auth.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+/**
+ * @import {ArgscloptsParseArgsOptionsConfig} from 'argsclopts'
+ */
+
+import { printHelpText } from 'argsclopts'
+import { parseArgs } from 'node:util'
+import { YotoClient } from '../index.js'
+import { pkg } from '../lib/pkg.cjs'
+import { DEFAULT_CLIENT_ID } from '../lib/api-endpoints/constants.js'
+import { sleep, saveTokensToEnv } from './lib/token-helpers.js'
+import {
+  getCommonOptions,
+  handleCliError,
+  printHeader
+} from './lib/cli-helpers.js'
+
+/** @type {ArgscloptsParseArgsOptionsConfig} */
+const options = {
+  ...getCommonOptions(),
+  output: {
+    type: 'string',
+    short: 'o',
+    default: '.env',
+    help: 'Output file for tokens (default: .env)'
+  }
+}
+
+const args = parseArgs({ options, strict: false })
+
+if (args.values['help']) {
+  await printHelpText({
+    options,
+    name: 'yoto-auth',
+    version: pkg.version,
+    exampleFn: ({ name }) => `    Yoto device flow authentication helper\n\n    Example: ${name} --client-id your-client-id\n`
+  })
+  process.exit(0)
+}
+
+const clientId = String(args.values['client-id'] || process.env['YOTO_CLIENT_ID'] || DEFAULT_CLIENT_ID)
+
+const outputFile = String(args.values['output'] || '.env')
+
+async function main () {
+  printHeader('Yoto Device Flow Authentication')
+  console.log()
+
+  // Step 1: Request device code
+  console.log('Requesting device code...\n')
+
+  const deviceAuth = await YotoClient.requestDeviceCode({ clientId })
+
+  // Step 2: Display instructions to user
+  console.log('┌────────────────────────────────────────────────────┐')
+  console.log('│  Please complete authentication in your browser:  │')
+  console.log('└────────────────────────────────────────────────────┘\n')
+
+  if (deviceAuth.verification_uri_complete) {
+    console.log('  Visit this URL (code included):')
+    console.log(`  ${deviceAuth.verification_uri_complete}\n`)
+    console.log('  Or manually enter:')
+    console.log(`  URL:  ${deviceAuth.verification_uri}`)
+    console.log(`  Code: ${deviceAuth.user_code}\n`)
+  } else {
+    console.log(`  URL:  ${deviceAuth.verification_uri}`)
+    console.log(`  Code: ${deviceAuth.user_code}\n`)
+  }
+
+  const expiresInMinutes = Math.round(deviceAuth.expires_in / 60)
+  console.log(`  Code expires in: ${expiresInMinutes} minute(s)`)
+  console.log(`  Polling every:   ${deviceAuth.interval} second(s)\n`)
+
+  // Step 3: Poll for authorization
+  console.log('Waiting for authorization...')
+
+  let pollInterval = deviceAuth.interval * 1000
+  const startTime = Date.now()
+  const expiresAt = startTime + (deviceAuth.expires_in * 1000)
+
+  while (true) {
+    // Check if we've exceeded the expiration time
+    if (Date.now() >= expiresAt) {
+      console.error('\n❌ Device code has expired. Please run the command again.')
+      process.exit(1)
+    }
+
+    try {
+      const tokens = await YotoClient.exchangeToken({
+        grantType: 'urn:ietf:params:oauth:grant-type:device_code',
+        deviceCode: deviceAuth.device_code,
+        clientId
+      })
+
+      // Success! Save tokens to .env file
+      console.log('\n✅ Authorization successful!\n')
+
+      await saveTokensToEnv(outputFile, tokens, clientId)
+
+      console.log(`✨ Tokens saved to ${outputFile}`)
+      console.log('\nYou can now use these environment variables:')
+      console.log('  - YOTO_ACCESS_TOKEN')
+      console.log('  - YOTO_REFRESH_TOKEN')
+      console.log('  - YOTO_CLIENT_ID')
+
+      process.exit(0)
+    } catch (err) {
+      const error = /** @type {any} */ (err)
+      if (error.body?.error === 'authorization_pending') {
+        process.stdout.write('.')
+        await sleep(pollInterval)
+        continue
+      } else if (error.body?.error === 'slow_down') {
+        pollInterval += 5000
+        console.log(`\n⚠️  Slowing down polling to ${pollInterval / 1000}s...`)
+        await sleep(pollInterval)
+        continue
+      } else if (error.body?.error === 'expired_token') {
+        console.error('\n❌ Device code has expired. Please run the command again.')
+        process.exit(1)
+      } else {
+        handleCliError(error)
+      }
+    }
+  }
+}
+
+// Run the main function
+await main().catch(handleCliError)

package/bin/content.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=content.d.ts.map

package/bin/content.d.ts.map

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

package/bin/content.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/**
+ * @import { ArgscloptsParseArgsOptionsConfig } from 'argsclopts'
+ */
+
+import { printHelpText } from 'argsclopts'
+import { parseArgs } from 'node:util'
+import { pkg } from '../lib/pkg.cjs'
+import {
+  getCommonOptions,
+  loadTokensFromEnv,
+  createYotoClient,
+  handleCliError,
+  printHeader
+} from './lib/cli-helpers.js'
+
+/** @type {ArgscloptsParseArgsOptionsConfig} */
+const options = {
+  ...getCommonOptions(),
+  'card-id': {
+    type: 'string',
+    short: 'd',
+    help: 'Specific card/content ID to fetch'
+  },
+  'show-deleted': {
+    type: 'boolean',
+    help: 'Include deleted content (for MYO content list)'
+  },
+  timezone: {
+    type: 'string',
+    short: 't',
+    help: 'Timezone identifier (e.g., "Pacific/Auckland")'
+  },
+  'signing-type': {
+    type: 'string',
+    short: 's',
+    help: 'Type of URL signing: "full" or "pre"'
+  },
+  playable: {
+    type: 'boolean',
+    short: 'p',
+    help: 'Return playable signed URLs'
+  }
+}
+
+const args = parseArgs({ options, strict: false })
+
+if (args.values['help']) {
+  await printHelpText({
+    options,
+    name: 'yoto-content',
+    version: pkg.version,
+    exampleFn: ({ name }) => `    Yoto content information helper\n\n    Examples:\n      ${name}                                    # List all MYO content\n      ${name} --show-deleted                     # List all MYO content including deleted\n      ${name} --card-id abc123                   # Get specific content\n      ${name} --card-id abc123 --playable        # Get content with playable URLs\n      ${name} --card-id abc123 --timezone "Pacific/Auckland" --signing-type full --playable\n`
+  })
+  process.exit(0)
+}
+
+// Load tokens from environment
+const { clientId, refreshToken, accessToken, envFile } = loadTokensFromEnv(args)
+
+const cardId = args.values['card-id'] ? String(args.values['card-id']) : null
+const showDeleted = Boolean(args.values['show-deleted'])
+const timezone = args.values['timezone'] ? String(args.values['timezone']) : undefined
+const signingType = args.values['signing-type'] ? /** @type {'full' | 'pre'} */ (String(args.values['signing-type'])) : undefined
+const playable = Boolean(args.values['playable'])
+
+// Validate signing-type if provided
+if (signingType && signingType !== 'full' && signingType !== 'pre') {
+  console.error('❌ Invalid --signing-type value')
+  console.error('Valid values: "full" or "pre"')
+  process.exit(1)
+}
+
+async function main () {
+  printHeader('Yoto Content')
+
+  try {
+    // Create client
+    const client = createYotoClient({
+      clientId,
+      refreshToken,
+      accessToken,
+      outputFile: envFile
+    })
+
+    if (cardId) {
+      // Get specific content
+      console.log(`\nFetching content: ${cardId}\n`)
+      const content = await client.getContent({
+        cardId,
+        ...(timezone && { timezone }),
+        ...(signingType && { signingType }),
+        ...(playable && { playable })
+      })
+      console.dir(content, { depth: null, colors: true })
+    } else {
+      // Get all MYO content
+      console.log(`\nFetching all MYO content${showDeleted ? ' (including deleted)' : ''}...\n`)
+      const myoContent = await client.getUserMyoContent({
+        ...(showDeleted && { showDeleted })
+      })
+      console.dir(myoContent, { depth: null, colors: true })
+    }
+
+    process.exit(0)
+  } catch (error) {
+    handleCliError(error)
+  }
+}
+
+// Run the main function
+await main().catch(err => {
+  console.error('\n❌ Unexpected error:')
+  console.error(err)
+  process.exit(1)
+})

package/bin/devices.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=devices.d.ts.map

package/bin/devices.d.ts.map

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

package/bin/devices.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+/**
+ * @import { ArgscloptsParseArgsOptionsConfig } from 'argsclopts'
+ */
+
+import { printHelpText } from 'argsclopts'
+import { parseArgs } from 'node:util'
+import { pkg } from '../lib/pkg.cjs'
+import {
+  getCommonOptions,
+  loadTokensFromEnv,
+  createYotoClient,
+  handleCliError,
+  printHeader
+} from './lib/cli-helpers.js'
+import { createYotoMqttClient } from '../lib/mqtt/index.js'
+
+/** @type {ArgscloptsParseArgsOptionsConfig} */
+const options = {
+  ...getCommonOptions(),
+  'device-id': {
+    type: 'string',
+    short: 'd',
+    help: 'Specific device ID to fetch'
+  },
+  status: {
+    type: 'boolean',
+    short: 's',
+    help: 'Get device status (requires --device-id)'
+  },
+  mqtt: {
+    type: 'boolean',
+    short: 'm',
+    help: 'Connect to MQTT and listen for device messages (requires --device-id)'
+  },
+  'mqtt-stop-after-seconds': {
+    type: 'string',
+    help: 'Auto-disconnect MQTT after N seconds (requires --mqtt)'
+  }
+}
+
+const args = parseArgs({ options, strict: false })
+
+if (args.values['help']) {
+  await printHelpText({
+    options,
+    name: 'yoto-devices',
+    version: pkg.version,
+    exampleFn: ({ name }) => `    Yoto devices information helper\n\n    Examples:\n      ${name}                              # List all devices\n      ${name} --device-id abc123           # Get specific device\n      ${name} --device-id abc123 --status  # Get device status\n      ${name} --device-id abc123 --mqtt    # Listen to MQTT messages\n      ${name} --device-id abc123 --mqtt --mqtt-stop-after-seconds 10  # Sample MQTT for 10s\n`
+  })
+  process.exit(0)
+}
+
+// Load tokens from environment
+const { clientId, refreshToken, accessToken, envFile } = loadTokensFromEnv(args)
+
+const deviceId = args.values['device-id'] ? String(args.values['device-id']) : null
+const getStatus = Boolean(args.values['status'])
+const useMqtt = Boolean(args.values['mqtt'])
+const mqttStopAfter = args.values['mqtt-stop-after-seconds'] ? Number(args.values['mqtt-stop-after-seconds']) : null
+
+if (getStatus && !deviceId) {
+  console.error('❌ --status flag requires --device-id')
+  console.error('Usage: yoto-devices --device-id abc123 --status')
+  process.exit(1)
+}
+
+if (useMqtt && !deviceId) {
+  console.error('❌ --mqtt flag requires --device-id')
+  console.error('Usage: yoto-devices --device-id abc123 --mqtt')
+  process.exit(1)
+}
+
+if (mqttStopAfter && !useMqtt) {
+  console.error('❌ --mqtt-stop-after-seconds requires --mqtt')
+  console.error('Usage: yoto-devices --device-id abc123 --mqtt --mqtt-stop-after-seconds 10')
+  process.exit(1)
+}
+
+async function main () {
+  printHeader('Yoto Devices')
+
+  try {
+    // Create client
+    const client = createYotoClient({
+      clientId,
+      refreshToken,
+      accessToken,
+      outputFile: envFile
+    })
+
+    if (deviceId) {
+      if (getStatus) {
+        // Get device status
+        console.log(`\nFetching status for device: ${deviceId}\n`)
+        const status = await client.getDeviceStatus({ deviceId })
+        console.dir(status, { depth: null, colors: true })
+      } else {
+        // Get specific device from list
+        console.log(`\nFetching device: ${deviceId}\n`)
+        const devicesResponse = await client.getDevices()
+        const device = devicesResponse.devices.find(d => d.deviceId === deviceId)
+
+        if (device) {
+          console.log('Device:')
+          console.dir(device, { depth: null, colors: true })
+
+          // Get device config
+          console.log('\nDevice Config:')
+          const config = await client.getDeviceConfig({ deviceId })
+          console.dir(config, { depth: null, colors: true })
+
+          // Get device shortcuts
+          console.log('\nDevice Shortcuts:')
+          const shortcuts = await client.getDeviceConfig({ deviceId })
+          if (shortcuts.device?.shortcuts) {
+            console.dir(shortcuts.device.shortcuts, { depth: null, colors: true })
+          } else {
+            console.log('No shortcuts available')
+          }
+        } else {
+          console.error(`❌ Device with ID '${deviceId}' not found`)
+          process.exit(1)
+        }
+      }
+    } else {
+      // Get all devices
+      console.log('\nFetching all devices...\n')
+      const devicesResponse = await client.getDevices()
+      console.dir(devicesResponse, { depth: null, colors: true })
+    }
+
+    // MQTT listening mode
+    if (useMqtt && deviceId) {
+      console.log('\n' + '='.repeat(60))
+      console.log('🔌 Connecting to MQTT...')
+      console.log('='.repeat(60))
+
+      const mqttClient = createYotoMqttClient({
+        deviceId,
+        accessToken
+      })
+
+      // Setup message handlers
+      mqttClient.on('connected', () => {
+        console.log('✅ Connected to MQTT broker')
+        console.log(`📡 Subscribed to device/${deviceId}/*`)
+        console.log('\n👂 Listening for messages... (Ctrl+C to stop)\n')
+
+        if (mqttStopAfter) {
+          console.log(`⏱️  Will auto-disconnect after ${mqttStopAfter} seconds\n`)
+        }
+
+        // Request initial status and events after a delay to ensure subscriptions are ready
+        setTimeout(() => {
+          mqttClient.requestStatus().catch(err => {
+            console.error('⚠️  Failed to request status:', err.message)
+          })
+          mqttClient.requestEvents().catch(err => {
+            console.error('⚠️  Failed to request events:', err.message)
+          })
+        }, 1000)
+      })
+
+      mqttClient.on('events', (message) => {
+        const timestamp = new Date().toISOString()
+        console.log(`\n📨 EVENTS MESSAGE [${timestamp}]:`)
+        console.log('─'.repeat(60))
+        console.dir(message, { depth: null, colors: true })
+      })
+
+      mqttClient.on('status', (message) => {
+        const timestamp = new Date().toISOString()
+        console.log(`\n📊 STATUS MESSAGE [${timestamp}]:`)
+        console.log('─'.repeat(60))
+        console.dir(message, { depth: null, colors: true })
+      })
+
+      mqttClient.on('response', (message) => {
+        const timestamp = new Date().toISOString()
+        console.log(`\n✉️  RESPONSE MESSAGE [${timestamp}]:`)
+        console.log('─'.repeat(60))
+        console.dir(message, { depth: null, colors: true })
+      })
+
+      mqttClient.on('disconnected', () => {
+        console.log('\n❌ Disconnected from MQTT broker')
+      })
+
+      mqttClient.on('reconnecting', () => {
+        console.log('\n🔄 Reconnecting to MQTT broker...')
+      })
+
+      mqttClient.on('error', (error) => {
+        console.error('\n⚠️  MQTT Error:', error.message)
+      })
+
+      // Handle graceful shutdown
+      const cleanup = async () => {
+        console.log('\n\n🛑 Shutting down...')
+        try {
+          await mqttClient.disconnect()
+          console.log('✅ Disconnected cleanly')
+          process.exit(0)
+        } catch (err) {
+          console.error('❌ Error during disconnect:', err)
+          process.exit(1)
+        }
+      }
+
+      process.on('SIGINT', cleanup)
+      process.on('SIGTERM', cleanup)
+
+      // Connect to MQTT
+      await mqttClient.connect()
+
+      // Auto-disconnect timer if specified
+      if (mqttStopAfter) {
+        setTimeout(async () => {
+          console.log(`\n⏰ ${mqttStopAfter} seconds elapsed, disconnecting...`)
+          await cleanup()
+        }, mqttStopAfter * 1000)
+      }
+
+      // Keep process alive (unless auto-disconnect is set)
+      if (!mqttStopAfter) {
+        await new Promise(() => {}) // Keep alive indefinitely
+      }
+    } else {
+      process.exit(0)
+    }
+  } catch (error) {
+    handleCliError(error)
+  }
+}
+
+// Run the main function
+await main().catch(handleCliError)

package/bin/groups.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=groups.d.ts.map

package/bin/groups.d.ts.map

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

package/bin/groups.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+/**
+ * @import { ArgscloptsParseArgsOptionsConfig } from 'argsclopts'
+ */
+
+import { printHelpText } from 'argsclopts'
+import { parseArgs } from 'node:util'
+import { pkg } from '../lib/pkg.cjs'
+import {
+  getCommonOptions,
+  loadTokensFromEnv,
+  createYotoClient,
+  handleCliError,
+  printHeader
+} from './lib/cli-helpers.js'
+
+/** @type {ArgscloptsParseArgsOptionsConfig} */
+const options = {
+  ...getCommonOptions(),
+  'group-id': {
+    type: 'string',
+    short: 'g',
+    help: 'Specific group ID to fetch'
+  }
+}
+
+const args = parseArgs({ options, strict: false })
+
+if (args.values['help']) {
+  await printHelpText({
+    options,
+    name: 'yoto-groups',
+    version: pkg.version,
+    exampleFn: ({ name }) => `    Yoto family library groups information helper\n\n    Examples:\n      ${name}                    # List all family library groups\n      ${name} --group-id abc123  # Get specific group\n`
+  })
+  process.exit(0)
+}
+
+// Load tokens from environment
+const { clientId, refreshToken, accessToken, envFile } = loadTokensFromEnv(args)
+
+const groupId = args.values['group-id'] ? String(args.values['group-id']) : null
+
+async function main () {
+  printHeader('Yoto Family Library Groups')
+
+  try {
+    // Create client
+    const client = createYotoClient({
+      clientId,
+      refreshToken,
+      accessToken,
+      outputFile: envFile
+    })
+
+    if (groupId) {
+      // Get specific group
+      console.log(`\nFetching group: ${groupId}\n`)
+      const group = await client.getGroup({ groupId })
+      console.dir(group, { depth: null, colors: true })
+    } else {
+      // Get all groups
+      console.log('\nFetching all family library groups...\n')
+      const groups = await client.getGroups()
+      console.dir(groups, { depth: null, colors: true })
+    }
+
+    process.exit(0)
+  } catch (error) {
+    handleCliError(error)
+  }
+}
+
+// Run the main function
+await main().catch(err => {
+  console.error('\n❌ Unexpected error:')
+  console.error(err)
+  process.exit(1)
+})

package/bin/icons.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=icons.d.ts.map

package/bin/icons.d.ts.map

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