@ciphore/radiocli 0.2.3 → 0.2.5

package/vendor/node-airtunes2/lib/devices.js

@@ -0,0 +1,266 @@
+const events = require('events')
+const util = require('util')
+const async = require('async')
+const AirTunesDevice = require('./device_airtunes')
+
+function Devices(audioOut) {
+  events.EventEmitter.call(this)
+
+  this.source = null
+  this.devices = {}
+  this.hasAirTunes = false
+  this.audioOut = audioOut
+}
+
+util.inherits(Devices, events.EventEmitter)
+
+Devices.prototype.init = function () {
+  var self = this
+  self.audioOut.on('need_sync', function (seq) {
+    // relay to all devices
+
+    self.forEach(function (dev) {
+      try {
+        if (dev.onSyncNeeded && dev.controlPort)
+          dev.onSyncNeeded(seq)
+      }
+      catch (e) {}
+    })
+  })
+}
+
+Devices.prototype.forEach = function (it) {
+  for (const i in this.devices) {
+    if (!this.devices.hasOwnProperty(i))
+      continue
+
+    it(this.devices[i], i)
+  }
+}
+
+Devices.prototype.add = function (type, host, options) {
+  var self = this
+
+  this.status = 'connecting'
+  var dev
+  // type === 'coreaudio' ?
+  //   new CoreAudioDevice(this.hasAirTunes, this.audioOut, options) :
+    = new AirTunesDevice(host, this.audioOut, options, options?.mode ?? 0, options?.txt ?? [])
+
+  var previousDev = this.devices[dev.key]
+
+  if (previousDev) {
+    // if device is already in the pool, just report its existing status.
+    previousDev.reportStatus()
+
+    return previousDev
+  }
+
+  this.devices[dev.key] = dev
+
+  dev.on('status', function (status, arg) {
+    if (status === 'error' || status === 'stopped') {
+      delete self.devices[dev.key]
+      self.checkAirTunesDevices()
+    }
+
+    if (this.hasAirTunes && status === 'playing') {
+      self.emit('need_sync')
+    }
+
+    self.emit('status', dev.key, status, '')
+  })
+
+  dev.start()
+  self.checkAirTunesDevices()
+
+  return dev
+}
+
+Devices.prototype.setVolume = function (key, volume, callback) {
+  var dev = this.devices[key]
+
+  if (!dev) {
+    this.emit('status', key, 'error', 'not_found')
+
+    return
+  }
+
+  dev.setVolume(volume, callback)
+}
+
+Devices.prototype.setProgress = function (key, progress, duration, callback) {
+  try {
+    if (key === 'all') {
+      for (const device of Object.keys(this.devices)) {
+        try {
+          this.devices[device].setProgress(progress, duration, callback)
+        }
+        catch (e) {
+          try {
+            if (e.name === 'TypeError')
+              delete this.devices[device]
+          }
+          catch (e) {}
+
+          console.log(e)
+        }
+      };
+    }
+    else {
+      var dev = this.devices[key]
+
+      if (!dev) {
+        this.emit('status', key, 'error', 'not_found')
+
+        return
+      }
+
+      dev.setProgress(progress, duration, callback)
+    }
+  }
+  catch (e) { console.log(e) }
+}
+
+Devices.prototype.setTrackInfo = function (key, name, artist, album, callback) {
+  try {
+    if (key === 'all') {
+      for (const device of Object.keys(this.devices)) {
+        try {
+          this.devices[device].setTrackInfo(name, artist, album, callback)
+        }
+        catch (e) {
+          try {
+            if (e.name === 'TypeError')
+              delete this.devices[device]
+          }
+          catch (e) {}
+          console.log(e)
+        }
+      }
+    }
+    else {
+      var dev = this.devices[key]
+
+      if (!dev) {
+        this.emit('status', key, 'error', 'not_found')
+
+        return
+      }
+      else {
+        dev.setTrackInfo(name, artist, album, callback)
+      }
+    }
+  }
+  catch (e) { console.log(e) }
+}
+
+Devices.prototype.setArtwork = function (key, art, contentType, callback) {
+  try {
+    if (key === 'all') {
+      for (const device of Object.keys(this.devices)) {
+        try {
+          this.devices[device].setArtwork(art, contentType, callback)
+        }
+        catch (e) {
+          try {
+            if (e.name === 'TypeError')
+              delete this.devices[device]
+          }
+          catch (e) {}
+          console.log(e)
+        }
+      }
+    }
+    else {
+      var dev = this.devices[key]
+
+      if (!dev) {
+        this.emit('status', key, 'error', 'not_found')
+
+        return
+      }
+
+      dev.setArtwork(art, contentType, callback)
+    }
+  }
+  catch (e) { console.log(e) }
+}
+
+Devices.prototype.setPasscode = function (key, passcode) {
+  var dev = this.devices[key]
+
+  if (!dev) {
+    this.emit('status', key, 'error', 'not_found')
+
+    return
+  }
+
+  dev.setPasscode(passcode)
+}
+
+Devices.prototype.stop = function (key) {
+  var dev = this.devices[key]
+  if (!dev) {
+    this.emit('status', key, 'error', 'not_found')
+
+    return
+  }
+  dev.stop()
+  this.devices[key] = undefined
+}
+
+Devices.prototype.stopAll = function (allCb) {
+  // conver to array to make async happy
+  var devices = []
+  for (const i in this.devices) {
+    if (!this.devices.hasOwnProperty(i))
+      continue
+
+    devices.push(this.devices[i])
+  }
+  if (allCb != null) {
+    async.forEach(
+      devices,
+      function (dev, cb) {
+        dev.stop(cb)
+      },
+      function () {
+        this.devices = {}
+        allCb()
+      },
+    )
+  }
+}
+
+Devices.prototype.checkAirTunesDevices = function () {
+  try {
+    var newHasAirTunes = false
+
+    for (const key in this.devices) {
+      if (!this.devices.hasOwnProperty(key))
+        continue
+
+      var device = this.devices[key]
+
+      // if(device.type === 'airtunes') {
+      newHasAirTunes = true
+      break
+      // }
+    }
+
+    if (newHasAirTunes !== this.hasAirTunes) {
+      this.emit('airtunes_devices', newHasAirTunes)
+
+      this.forEach(function (dev) {
+        if (dev.setHasAirTunes)
+          dev.setHasAirTunes(newHasAirTunes)
+      })
+    }
+
+    this.hasAirTunes = newHasAirTunes
+  }
+  catch (e) { console.log(e) }
+}
+
+module.exports = Devices

package/vendor/node-airtunes2/lib/ed25519.js

@@ -0,0 +1,26 @@
+// RadioCLI modification, 2026-10-16. Distributed under the accompanying AGPLv3.
+// Preserve the sender's synchronous hex API using Node's Ed25519 implementation.
+const crypto = require('node:crypto')
+const pkcs8Prefix = Buffer.from('302e020100300506032b657004220420', 'hex')
+
+function bytes(hex, length) {
+  if (typeof hex !== 'string' || !/^(?:[a-f\d]{2})*$/i.test(hex) || (length !== undefined && hex.length !== length * 2)) {
+    throw new TypeError('Invalid Ed25519 hexadecimal input')
+  }
+  return Buffer.from(hex, 'hex')
+}
+
+function privateKey(seed) {
+  return crypto.createPrivateKey({key: Buffer.concat([pkcs8Prefix, bytes(seed, 32)]), format: 'der', type: 'pkcs8'})
+}
+
+function publicKey(seed) {
+  const key = crypto.createPublicKey(privateKey(seed)).export({format: 'jwk'})
+  return Buffer.from(key.x, 'base64url').toString('hex')
+}
+
+function sign(seed, message) {
+  return crypto.sign(null, bytes(message), privateKey(seed)).toString('hex').toUpperCase()
+}
+
+module.exports = {publicKey, sign}

package/vendor/node-airtunes2/lib/homekit/credentials.js

@@ -0,0 +1,86 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+const struct = require('python-struct')
+const encryption_1 = require('./encryption')
+
+class Credentials {
+  constructor(uniqueIdentifier, identifier, pairingId, publicKey, encryptionKey) {
+    this.uniqueIdentifier = uniqueIdentifier
+    this.identifier = identifier
+    this.pairingId = pairingId
+    this.publicKey = publicKey
+    this.encryptionKey = encryptionKey
+    this.encryptCount = 0
+    this.decryptCount = 0
+  }
+
+  /**
+    * Parse a credentials string into a Credentials object.
+    * @param text  The credentials string.
+    * @returns A credentials object.
+    */
+  static parse(text) {
+    let parts = text.split(':')
+    return new Credentials(parts[0], Buffer.from(parts[1], 'hex'), Buffer.from(parts[2], 'hex').toString(), Buffer.from(parts[3], 'hex'), Buffer.from(parts[4], 'hex'))
+  }
+
+  /**
+    * Returns a string representation of a Credentials object.
+    * @returns A string representation of a Credentials object.
+    */
+  toString() {
+    return this.uniqueIdentifier
+      + ':'
+      + this.identifier.toString('hex')
+      + ':'
+      + Buffer.from(this.pairingId).toString('hex')
+      + ':'
+      + this.publicKey.toString('hex')
+      + ':'
+      + this.encryptionKey.toString('hex')
+  }
+
+  encrypt(message) {
+    let offset = 0
+    let total = message.byteLength
+    let result = Buffer.concat([])
+    while (offset < total) {
+      let length = Math.min(total - offset, 1024)
+      let s1length_bytes = struct.pack('H', length)
+      // let cipher = crypto.createCipheriv('chacha20-poly1305', this.writeKey, Buffer.concat([Buffer.from([0x00,0x00,0x00,0x00]),struct.pack("Q", this.decryptCount)]), { authTagLength: 16 });
+      // cipher.setAAD(s1length_bytes);
+      // let s1ct = cipher.update(message);
+      // cipher.final();
+      // let s1tag = encryption_1.default.computePoly1305(s1ct,s1length_bytes,Buffer.concat([Buffer.from([0x00,0x00,0x00,0x00]),struct.pack("Q", this.decryptCount)]),this.writeKey)
+      let [s1ct, s1tag] = encryption_1.default.encryptAndSeal(message.slice(offset, offset + length), s1length_bytes, Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), struct.pack('Q', this.encryptCount)]), this.writeKey)
+
+      let ciphertext = Buffer.concat([s1length_bytes, s1ct, s1tag])
+      offset += length
+      this.encryptCount += 1
+      result = Buffer.concat([result, ciphertext])
+    }
+    return result
+  }
+
+  decrypt(message) {
+    let offset = 0
+    let result = Buffer.concat([])
+    while (offset < message.byteLength) {
+      let lengthbytes = message.slice(offset, offset + 2)
+      let length = struct.unpack('H', lengthbytes)
+      let messagea = message.slice(offset + 2, offset + 2 + length[0] + 16)
+      let cipherText = messagea.slice(0, -16)
+      let hmac = messagea.slice(-16)
+      let decrypted = encryption_1.default.verifyAndDecrypt(cipherText, hmac, lengthbytes, Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), struct.pack('Q', this.decryptCount)]), this.readKey)
+      this.decryptCount += 1
+      offset = offset + length[0] + 16 + 2
+      result = Buffer.concat([result, decrypted])
+    }
+    return result
+  }
+
+  encryptAudio(message, aad, nonce) {
+    return Buffer.concat([Buffer.concat(encryption_1.default.encryptAndSeal(message, aad, struct.pack('Q', nonce), this.writeKey)), Buffer.from(struct.pack('Q', nonce))])
+  }
+}
+exports.Credentials = Credentials

package/vendor/node-airtunes2/lib/homekit/encryption.js

@@ -0,0 +1,69 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+const chacha = require('chacha-js')
+const crypto = require('crypto')
+// i'd really prefer for this to be a direct call to
+// Sodium.crypto_aead_chacha20poly1305_decrypt()
+// but unfortunately the way it constructs the message to
+// calculate the HMAC is not compatible with homekit
+// (long story short, it uses [ AAD, AAD.length, CipherText, CipherText.length ]
+// whereas homekit expects [ AAD, CipherText, AAD.length, CipherText.length ]
+function verifyAndDecrypt(cipherText, mac, AAD, nonce, key) {
+  try {
+    if (nonce.byteLength == 8) nonce = Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), nonce])
+    const decipher = chacha.createDecipher(key, nonce)
+    if (AAD != null) decipher.setAAD(AAD)// must be called before data
+    decipher.setAuthTag(mac)
+    return decipher.update(cipherText)
+  }
+  catch (e) {
+    return null
+  }
+}
+
+function encryptAndSeal(plainText, AAD, nonce, key) {
+  if (nonce.byteLength == 8) nonce = Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), nonce])
+  var cipher = chacha.createCipher(key, nonce)
+  if (AAD != null) cipher.setAAD(AAD)// must be called before data
+  let cipherText = cipher.update(plainText)
+  cipher.final()
+  let hmac = cipher.getAuthTag()
+  return [cipherText, hmac]
+}
+// function getPadding(buffer, blockSize) {
+//     return buffer.length % blockSize === 0
+//         ? Buffer.alloc(0)
+//         : Buffer.alloc(blockSize - (buffer.length % blockSize));
+// }
+function HKDF(hashAlg, salt, ikm, info, size) {
+  // create the hash alg to see if it exists and get its length
+  var hash = crypto.createHash(hashAlg)
+  var hashLength = hash.digest().length
+  // now we compute the PRK
+  var hmac = crypto.createHmac(hashAlg, salt)
+  hmac.update(ikm)
+  var prk = hmac.digest()
+  var prev = Buffer.alloc(0)
+  var output
+  var buffers = []
+  var num_blocks = Math.ceil(size / hashLength)
+  info = Buffer.from(info)
+  for (var i = 0; i < num_blocks; i++) {
+    var hmac = crypto.createHmac(hashAlg, prk)
+    var input = Buffer.concat([
+      prev,
+      info,
+      Buffer.from(String.fromCharCode(i + 1)),
+    ])
+    hmac.update(input)
+    prev = hmac.digest()
+    buffers.push(prev)
+  }
+  output = Buffer.concat(buffers, size)
+  return output.slice(0, size)
+}
+exports.default = {
+  encryptAndSeal,
+  verifyAndDecrypt,
+  HKDF,
+}

package/vendor/node-airtunes2/lib/homekit/number.js

@@ -0,0 +1,44 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+const assert = require('assert')
+/*
+ * Originally based on code from github:KhaosT/HAP-NodeJS@0c8fd88 used
+ * used per the terms of the Apache Software License v2.
+ *
+ * Original code copyright Khaos Tian <khaos.tian@gmail.com>
+ *
+ * Modifications copyright Zach Bean <zb@forty2.com>
+ *  * Reformatted for ES6-style module
+ *  * renamed *UInt64* to *UInt53* to be more clear about range
+ *  * renamed uintHighLow to be more clear about what it does
+ *  * Refactored to return a buffer rather write into a passed-in buffer
+ */
+function splitUInt53(number) {
+  const MAX_UINT32 = 0x00000000FFFFFFFF
+  const MAX_INT53 = 0x001FFFFFFFFFFFFF
+  assert(number > -1 && number <= MAX_INT53, 'number out of range')
+  assert(Math.floor(number) === number, 'number must be an integer')
+  let high = 0
+  const signbit = number & 0xFFFFFFFF
+  const low = signbit < 0 ? (number & 0x7FFFFFFF) + 0x80000000 : signbit
+  if (number > MAX_UINT32) {
+    high = (number - low) / (MAX_UINT32 + 1)
+  }
+  return [high, low]
+}
+function UInt53toBufferLE(number) {
+  const [high, low] = splitUInt53(number)
+  const buf = Buffer.alloc(8)
+  buf.writeUInt32LE(low, 0)
+  buf.writeUInt32LE(high, 4)
+  return buf
+}
+function UInt16toBufferBE(number) {
+  const buf = Buffer.alloc(2)
+  buf.writeUInt16BE(number, 0)
+  return buf
+}
+exports.default = {
+  UInt53toBufferLE,
+  UInt16toBufferBE,
+}

package/vendor/node-airtunes2/lib/homekit/tlv.js

@@ -0,0 +1,95 @@
+'use strict'
+/**
+ * Type Length Value encoding/decoding, used by HAP as a wire format.
+ * https://en.wikipedia.org/wiki/Type-length-value
+ *
+ * Originally based on code from github:KhaosT/HAP-NodeJS@0c8fd88 used
+ * used per the terms of the Apache Software License v2.
+ *
+ * Original code copyright Khaos Tian <khaos.tian@gmail.com>
+ *
+ * Modifications copyright Zach Bean <zb@forty2.com>
+ *  * Reformatted for ES6-style module
+ *  * Rewrote encode() to be non-recursive; also simplified the logic
+ *  * Rewrote decode()
+ */
+Object.defineProperty(exports, '__esModule', { value: true })
+const Tag = {
+  PairingMethod: 0x00,
+  Username: 0x01,
+  Salt: 0x02,
+  // could be either the SRP client public key (384 bytes) or the ED25519 public key (32 bytes), depending on context
+  PublicKey: 0x03,
+  Proof: 0x04,
+  EncryptedData: 0x05,
+  Sequence: 0x06,
+  ErrorCode: 0x07,
+  BackOff: 0x08,
+  Signature: 0x0A,
+  MFiCertificate: 0x09,
+  MFiSignature: 0x0A,
+  Flags: 0x13,
+}
+function encode(type, data) {
+  var encodedTLVBuffer = Buffer.alloc(0)
+  // coerce data to Buffer if needed
+  if (typeof data === 'number')
+    data = Buffer.from([data])
+  else if (typeof data === 'string')
+    data = Buffer.from(data)
+  if (data.length <= 255) {
+    encodedTLVBuffer = Buffer.concat([Buffer.from([type, data.length]), data])
+  }
+  else {
+    var leftLength = data.length
+    var tempBuffer = Buffer.alloc(0)
+    var currentStart = 0
+    for (; leftLength > 0;) {
+      if (leftLength >= 255) {
+        tempBuffer = Buffer.concat([tempBuffer, Buffer.from([type, 0xFF]), data.slice(currentStart, currentStart + 255)])
+        leftLength -= 255
+        currentStart = currentStart + 255
+      }
+      else {
+        tempBuffer = Buffer.concat([tempBuffer, Buffer.from([type, leftLength]), data.slice(currentStart, currentStart + leftLength)])
+        leftLength -= leftLength
+      }
+    }
+    encodedTLVBuffer = tempBuffer
+  }
+  // do we have more to encode?
+  if (arguments.length > 2) {
+    // chop off the first two arguments which we already processed, and process the rest recursively
+    var remainingArguments = Array.prototype.slice.call(arguments, 2)
+    var remainingTLVBuffer = encode.apply(this, remainingArguments)
+    // append the remaining encoded arguments directly to the buffer
+    encodedTLVBuffer = Buffer.concat([encodedTLVBuffer, remainingTLVBuffer])
+  }
+  return encodedTLVBuffer
+}
+function decode(data) {
+  const objects = {}
+  let leftLength = data.length
+  let currentIndex = 0
+  for (; leftLength > 0;) {
+    const type = data[currentIndex]
+    const length = data[currentIndex + 1]
+    currentIndex += 2
+    leftLength -= 2
+    const newData = data.slice(currentIndex, currentIndex + length)
+    if (objects[type]) {
+      objects[type] = Buffer.concat([objects[type], newData])
+    }
+    else {
+      objects[type] = newData
+    }
+    currentIndex += length
+    leftLength -= length
+  }
+  return objects
+}
+exports.default = {
+  Tag,
+  encode,
+  decode,
+}