bose-soundtouch 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Paul Grant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,326 @@
+# bose-soundtouch
+
+A JavaScript/TypeScript library for controlling Bose SoundTouch speakers via the local REST API.
+
+## Background
+
+On January 7, 2026, Bose announced that cloud support for SoundTouch products will end on May 6, 2026. After this date:
+
+**What will continue to work:**
+
+- Streaming via Bluetooth, AirPlay, Spotify Connect, and AUX
+- Setting up and configuring your system
+- Remote control features (play, pause, skip, volume)
+- Grouping multiple speakers together
+
+**What will stop working:**
+
+- Presets (preset buttons and app presets)
+- Browsing music services from the SoundTouch app
+
+As part of this transition, Bose released their SoundTouch API Documentation to enable independent developers to create their own SoundTouch-compatible tools.
+
+This library provides a clean, TypeScript-friendly interface to control SoundTouch speakers over your local network, ensuring your speakers remain fully functional even after cloud services end.
+
+## Installation
+
+```bash
+npm install bose-soundtouch
+```
+
+or
+
+```bash
+yarn add bose-soundtouch
+```
+
+## Quick Start
+
+```typescript
+import { SoundTouch } from "bose-soundtouch";
+
+// Connect to a speaker by IP address
+const speaker = new SoundTouch("192.168.1.100");
+
+// Get device info
+const info = await speaker.getInfo();
+console.log(`Connected to: ${info.name} (${info.type})`);
+
+// Control playback
+await speaker.play();
+await speaker.setVolume(30);
+
+// Check what's playing
+const nowPlaying = await speaker.getNowPlaying();
+console.log(`Playing: ${nowPlaying.track} by ${nowPlaying.artist}`);
+```
+
+## Demo Script
+
+A comprehensive demo script is included to test the library against a real device:
+
+```bash
+npm run demo 192.168.1.100
+```
+
+or
+
+```bash
+ts-node demo.ts 192.168.1.100
+```
+
+The demo walks through device info, capabilities, sources, presets, volume control, mute, and playback controls.
+
+## Features
+
+- Control playback (play, pause, stop, next/previous track)
+- Adjust volume and mute
+- Select presets (1-6)
+- Select sources (AUX, Bluetooth, etc.)
+- Get now playing information
+- Control bass and tone settings
+- Full TypeScript support with type definitions
+- Error handling with custom error classes
+
+## Usage Examples
+
+### Playback Control
+
+```typescript
+import { SoundTouch } from "bose-soundtouch";
+
+const speaker = new SoundTouch("192.168.1.100");
+
+await speaker.play();
+await speaker.pause();
+await speaker.playPause(); // Toggle
+await speaker.stop();
+await speaker.nextTrack();
+await speaker.previousTrack();
+```
+
+### Volume Control
+
+```typescript
+import { SoundTouch } from "bose-soundtouch";
+
+const speaker = new SoundTouch("192.168.1.100");
+
+// Get current volume
+const volume = await speaker.getVolume();
+console.log(`Volume: ${volume.actualvolume}, Muted: ${volume.muteenabled}`);
+
+// Set volume (0-100)
+await speaker.setVolume(50);
+
+// Mute/unmute
+await speaker.mute();
+await speaker.unmute();
+
+// Volume up/down buttons
+await speaker.volumeUp();
+await speaker.volumeDown();
+```
+
+### Presets
+
+```typescript
+import { SoundTouch } from "bose-soundtouch";
+
+const speaker = new SoundTouch("192.168.1.100");
+
+// Get all presets
+const presets = await speaker.getPresets();
+for (const preset of presets.preset) {
+  if (preset.contentItem) {
+    console.log(`Preset ${preset.id}: ${preset.contentItem.itemName}`);
+  }
+}
+
+// Select a preset
+await speaker.selectPreset(1);
+```
+
+### Now Playing
+
+```typescript
+import { SoundTouch, PlayStatus } from "bose-soundtouch";
+
+const speaker = new SoundTouch("192.168.1.100");
+
+const now = await speaker.getNowPlaying();
+
+console.log(`Source: ${now.source}`);
+console.log(`Track: ${now.track}`);
+console.log(`Artist: ${now.artist}`);
+console.log(`Album: ${now.album}`);
+
+if (now.playStatus === PlayStatus.PLAY_STATE) {
+  console.log("Currently playing");
+} else if (now.playStatus === PlayStatus.PAUSE_STATE) {
+  console.log("Paused");
+}
+```
+
+### Source Selection
+
+```typescript
+import { SoundTouch } from "bose-soundtouch";
+
+const speaker = new SoundTouch("192.168.1.100");
+
+// List available sources
+const sources = await speaker.getSources();
+for (const source of sources.sourceItem) {
+  console.log(`${source.source}: ${source.status}`);
+}
+
+// Select a source
+await speaker.selectSource("AUX", "AUX");
+await speaker.selectSource("BLUETOOTH");
+```
+
+### Device Information
+
+```typescript
+import { SoundTouch } from "bose-soundtouch";
+
+const speaker = new SoundTouch("192.168.1.100");
+
+const info = await speaker.getInfo();
+
+console.log(`Name: ${info.name}`);
+console.log(`Type: ${info.type}`);
+console.log(`Device ID: ${info.deviceID}`);
+
+for (const net of info.networkInfo) {
+  console.log(`  ${net.type}: ${net.ipAddress}`);
+}
+```
+
+### Raw Key Press
+
+For advanced use cases, you can send raw key presses:
+
+```typescript
+import { SoundTouch, KeyValue } from "bose-soundtouch";
+
+const speaker = new SoundTouch("192.168.1.100");
+
+// Using enum
+await speaker.sendKey(KeyValue.THUMBS_UP);
+
+// Using string
+await speaker.sendKey("POWER");
+```
+
+### Error Handling
+
+```typescript
+import {
+  SoundTouch,
+  ConnectionError,
+  TimeoutError,
+  ApiError,
+} from "bose-soundtouch";
+
+try {
+  const speaker = new SoundTouch("192.168.1.100", 8090, 5.0);
+  await speaker.setVolume(50);
+} catch (error) {
+  if (error instanceof ConnectionError) {
+    console.error("Could not connect to speaker");
+  } else if (error instanceof TimeoutError) {
+    console.error("Request timed out");
+  } else if (error instanceof ApiError) {
+    console.error(`API error: ${error.errorName} (code ${error.errorCode})`);
+  } else {
+    console.error("Unknown error:", error);
+  }
+}
+```
+
+## API Reference
+
+### SoundTouch Class
+
+```typescript
+new SoundTouch(
+  host: string,        // IP address or hostname
+  port?: number,      // HTTP port (default: 8090)
+  timeout?: number    // Request timeout in seconds (default: 10.0)
+)
+```
+
+### Methods
+
+| Method                             | Description                |
+| ---------------------------------- | -------------------------- |
+| `getInfo()`                        | Get device information     |
+| `getCapabilities()`                | Get device capabilities    |
+| `setName(name: string)`            | Set device name            |
+| `getNowPlaying()`                  | Get current playback state |
+| `getSources()`                     | Get available sources      |
+| `selectSource(source, account?)`   | Select a source            |
+| `getVolume()`                      | Get volume state           |
+| `setVolume(level: number)`         | Set volume (0-100)         |
+| `mute()` / `unmute()`              | Mute/unmute                |
+| `volumeUp()` / `volumeDown()`      | Adjust volume              |
+| `getPresets()`                     | Get preset slots           |
+| `selectPreset(presetId: number)`   | Select preset (1-6)        |
+| `play()` / `pause()` / `stop()`    | Playback control           |
+| `playPause()`                      | Toggle play/pause          |
+| `nextTrack()` / `previousTrack()`  | Track navigation           |
+| `getBass()` / `setBass(level)`     | Bass control               |
+| `getTone()`                        | Get tone settings          |
+| `sendKey(key: KeyValue \| string)` | Send raw key press         |
+
+### Types
+
+The library exports TypeScript types and enums:
+
+- `DeviceInfo` - Device information structure
+- `Capabilities` - Device capabilities
+- `Presets` - Preset slots
+- `Sources` - Available sources
+- `Volume` - Volume state
+- `NowPlaying` - Current playback information
+- `Bass` - Bass settings
+- `Tone` - Tone settings (bass and treble)
+- `PlayStatus` - Playback status enum
+- `KeyValue` - Key press enum
+
+### Error Classes
+
+- `ConnectionError` - Network connection errors
+- `TimeoutError` - Request timeout errors
+- `ApiError` - API error responses
+
+## Requirements
+
+- Node.js 18.0.0 or higher
+- TypeScript 5.0+ (for TypeScript projects)
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run in watch mode
+npm run dev
+
+# Run demo
+npm run demo <ip-address>
+```
+
+## License
+
+MIT License
+
+---
+
+Not affiliated with, endorsed, sponsored, or approved by Bose. Bose and SoundTouch are trademarks of Bose Corporation.

package/dist/errors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Custom error classes for SoundTouch API
+ */
+export declare class ConnectionError extends Error {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
+export interface ApiErrorResponse {
+    error: {
+        name: string;
+        code: number;
+        message?: string;
+    };
+}
+export declare class ApiError extends Error {
+    readonly errorName: string;
+    readonly errorCode: number;
+    constructor(errorName: string, errorCode: number, message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Custom error classes for SoundTouch API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = exports.TimeoutError = exports.ConnectionError = void 0;
+class ConnectionError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "ConnectionError";
+        Object.setPrototypeOf(this, ConnectionError.prototype);
+    }
+}
+exports.ConnectionError = ConnectionError;
+class TimeoutError extends Error {
+    constructor(message = "Request timed out") {
+        super(message);
+        this.name = "TimeoutError";
+        Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+}
+exports.TimeoutError = TimeoutError;
+class ApiError extends Error {
+    errorName;
+    errorCode;
+    constructor(errorName, errorCode, message) {
+        super(message || `API error: ${errorName} (code ${errorCode})`);
+        this.errorName = errorName;
+        this.errorCode = errorCode;
+        this.name = "ApiError";
+        Object.setPrototypeOf(this, ApiError.prototype);
+    }
+}
+exports.ApiError = ApiError;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * bose-soundtouch
+ * A TypeScript library for controlling Bose SoundTouch speakers
+ */
+export { SoundTouch } from "./soundtouch";
+export * from "./types";
+export * from "./errors";

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * bose-soundtouch
+ * A TypeScript library for controlling Bose SoundTouch speakers
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoundTouch = void 0;
+var soundtouch_1 = require("./soundtouch");
+Object.defineProperty(exports, "SoundTouch", { enumerable: true, get: function () { return soundtouch_1.SoundTouch; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./errors"), exports);

package/dist/soundtouch.d.ts

@@ -0,0 +1,134 @@
+import { DeviceInfo, Capabilities, Presets, Sources, Volume, NowPlaying, Bass, Tone, KeyValue } from "./types";
+/**
+ * Main class for controlling Bose SoundTouch speakers
+ */
+export declare class SoundTouch {
+    private host;
+    private port;
+    private timeout;
+    private client;
+    private baseUrl;
+    /**
+     * Create a new SoundTouch instance
+     * @param host - IP address or hostname of the speaker
+     * @param port - HTTP port (default: 8090)
+     * @param timeout - Request timeout in seconds (default: 10.0)
+     */
+    constructor(host: string, port?: number, timeout?: number);
+    /**
+     * Handle errors and convert to appropriate error types
+     */
+    private handleError;
+    /**
+     * Parse XML string to JavaScript object
+     */
+    private parseXml;
+    /**
+     * Make a GET request and parse XML response
+     */
+    private get;
+    /**
+     * Make a POST request with XML body
+     */
+    private post;
+    /**
+     * Get device information
+     */
+    getInfo(): Promise<DeviceInfo>;
+    /**
+     * Get device capabilities
+     */
+    getCapabilities(): Promise<Capabilities>;
+    /**
+     * Set device name
+     */
+    setName(name: string): Promise<void>;
+    /**
+     * Get current playback state
+     */
+    getNowPlaying(): Promise<NowPlaying>;
+    /**
+     * Get available sources
+     */
+    getSources(): Promise<Sources>;
+    /**
+     * Select a source
+     */
+    selectSource(source: string, sourceAccount?: string): Promise<void>;
+    /**
+     * Get volume state
+     */
+    getVolume(): Promise<Volume>;
+    /**
+     * Set volume level (0-100)
+     */
+    setVolume(level: number): Promise<void>;
+    /**
+     * Mute the speaker
+     */
+    mute(): Promise<void>;
+    /**
+     * Unmute the speaker
+     */
+    unmute(): Promise<void>;
+    /**
+     * Increase volume
+     */
+    volumeUp(): Promise<void>;
+    /**
+     * Decrease volume
+     */
+    volumeDown(): Promise<void>;
+    /**
+     * Get presets
+     */
+    getPresets(): Promise<Presets>;
+    /**
+     * Select a preset (1-6)
+     */
+    selectPreset(presetId: number): Promise<void>;
+    /**
+     * Play
+     */
+    play(): Promise<void>;
+    /**
+     * Pause
+     */
+    pause(): Promise<void>;
+    /**
+     * Toggle play/pause
+     */
+    playPause(): Promise<void>;
+    /**
+     * Stop
+     */
+    stop(): Promise<void>;
+    /**
+     * Next track
+     */
+    nextTrack(): Promise<void>;
+    /**
+     * Previous track
+     */
+    previousTrack(): Promise<void>;
+    /**
+     * Get bass level
+     */
+    getBass(): Promise<Bass>;
+    /**
+     * Set bass level (-10 to 10)
+     */
+    setBass(level: number): Promise<void>;
+    /**
+     * Get tone settings (bass and treble)
+     */
+    getTone(): Promise<Tone>;
+    /**
+     * Send a raw key press
+     */
+    sendKey(key: KeyValue | string): Promise<void>;
+    /**
+     * Escape XML special characters
+     */
+    private escapeXml;
+}

package/dist/soundtouch.js

@@ -0,0 +1,322 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoundTouch = void 0;
+const axios_1 = __importDefault(require("axios"));
+const xml2js_1 = require("xml2js");
+const types_1 = require("./types");
+const errors_1 = require("./errors");
+/**
+ * Main class for controlling Bose SoundTouch speakers
+ */
+class SoundTouch {
+    host;
+    port;
+    timeout;
+    client;
+    baseUrl;
+    /**
+     * Create a new SoundTouch instance
+     * @param host - IP address or hostname of the speaker
+     * @param port - HTTP port (default: 8090)
+     * @param timeout - Request timeout in seconds (default: 10.0)
+     */
+    constructor(host, port = 8090, timeout = 10.0) {
+        this.host = host;
+        this.port = port;
+        this.timeout = timeout;
+        this.baseUrl = `http://${host}:${port}`;
+        this.client = axios_1.default.create({
+            baseURL: this.baseUrl,
+            timeout: timeout * 1000,
+            headers: {
+                "Content-Type": "application/xml",
+            },
+        });
+    }
+    /**
+     * Handle errors and convert to appropriate error types
+     */
+    handleError(error) {
+        if (axios_1.default.isAxiosError(error)) {
+            const axiosError = error;
+            if (axiosError.code === "ECONNREFUSED" || axiosError.code === "ENOTFOUND") {
+                throw new errors_1.ConnectionError(`Could not connect to speaker at ${this.baseUrl}`, axiosError);
+            }
+            if (axiosError.code === "ETIMEDOUT" || axiosError.code === "ECONNABORTED") {
+                throw new errors_1.TimeoutError(`Request to ${this.baseUrl} timed out`);
+            }
+            // Check for API error response
+            if (axiosError.response?.data) {
+                const data = axiosError.response.data;
+                if (typeof data === "object" && "error" in data) {
+                    const errorData = data;
+                    throw new errors_1.ApiError(errorData.error.name, errorData.error.code, errorData.error.message);
+                }
+            }
+            throw new errors_1.ConnectionError(`Request failed: ${axiosError.message}`, axiosError);
+        }
+        throw error;
+    }
+    /**
+     * Parse XML string to JavaScript object
+     */
+    async parseXml(xml) {
+        return new Promise((resolve, reject) => {
+            (0, xml2js_1.parseString)(xml, {
+                explicitArray: false,
+                mergeAttrs: true,
+                explicitCharkey: false,
+                trim: true,
+                normalize: true,
+                ignoreAttrs: false,
+                attrNameProcessors: [],
+                tagNameProcessors: [],
+            }, (err, result) => {
+                if (err) {
+                    reject(new Error(`Failed to parse XML: ${err.message}`));
+                }
+                else {
+                    resolve(result);
+                }
+            });
+        });
+    }
+    /**
+     * Make a GET request and parse XML response
+     */
+    async get(endpoint) {
+        try {
+            const response = await this.client.get(endpoint, {
+                responseType: "text",
+            });
+            const parsed = await this.parseXml(response.data);
+            return parsed;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Make a POST request with XML body
+     */
+    async post(endpoint, body) {
+        try {
+            await this.client.post(endpoint, body);
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Get device information
+     */
+    async getInfo() {
+        const data = await this.get("/info");
+        // Normalize networkInfo to always be an array
+        if (data.info.networkInfo && !Array.isArray(data.info.networkInfo)) {
+            data.info.networkInfo = [data.info.networkInfo];
+        }
+        return data.info;
+    }
+    /**
+     * Get device capabilities
+     */
+    async getCapabilities() {
+        const data = await this.get("/capabilities");
+        // Normalize capabilities array
+        if (data.capabilities.capability && !Array.isArray(data.capabilities.capability)) {
+            data.capabilities.capability = [data.capabilities.capability];
+        }
+        console.log(data.capabilities.capability);
+        return data.capabilities;
+    }
+    /**
+     * Set device name
+     */
+    async setName(name) {
+        const xml = `<name>${this.escapeXml(name)}</name>`;
+        await this.post("/name", xml);
+    }
+    /**
+     * Get current playback state
+     */
+    async getNowPlaying() {
+        const data = await this.get("/now_playing");
+        return data.nowPlaying;
+    }
+    /**
+     * Get available sources
+     */
+    async getSources() {
+        const data = await this.get("/sources");
+        // Normalize sourceItem array
+        if (data.sources.sourceItem && !Array.isArray(data.sources.sourceItem)) {
+            data.sources.sourceItem = [data.sources.sourceItem];
+        }
+        return data.sources;
+    }
+    /**
+     * Select a source
+     */
+    async selectSource(source, sourceAccount) {
+        let xml = `<ContentItem source="${this.escapeXml(source)}"`;
+        if (sourceAccount) {
+            xml += ` sourceAccount="${this.escapeXml(sourceAccount)}"`;
+        }
+        xml += ` location=""></ContentItem>`;
+        await this.post("/select", xml);
+    }
+    /**
+     * Get volume state
+     */
+    async getVolume() {
+        const data = await this.get("/volume");
+        return data.volume;
+    }
+    /**
+     * Set volume level (0-100)
+     */
+    async setVolume(level) {
+        if (level < 0 || level > 100) {
+            throw new Error("Volume level must be between 0 and 100");
+        }
+        const xml = `<volume>${level}</volume>`;
+        await this.post("/volume", xml);
+    }
+    /**
+     * Mute the speaker
+     */
+    async mute() {
+        const xml = "<volume>mute</volume>";
+        await this.post("/volume", xml);
+    }
+    /**
+     * Unmute the speaker
+     */
+    async unmute() {
+        const xml = "<volume>unmute</volume>";
+        await this.post("/volume", xml);
+    }
+    /**
+     * Increase volume
+     */
+    async volumeUp() {
+        await this.post("/volume", "<volume>volumeUp</volume>");
+    }
+    /**
+     * Decrease volume
+     */
+    async volumeDown() {
+        await this.post("/volume", "<volume>volumeDown</volume>");
+    }
+    /**
+     * Get presets
+     */
+    async getPresets() {
+        const data = await this.get("/presets");
+        // Normalize preset array
+        if (data.presets.preset && !Array.isArray(data.presets.preset)) {
+            data.presets.preset = [data.presets.preset];
+        }
+        return data.presets;
+    }
+    /**
+     * Select a preset (1-6)
+     */
+    async selectPreset(presetId) {
+        if (presetId < 1 || presetId > 6) {
+            throw new Error("Preset ID must be between 1 and 6");
+        }
+        const key = `PRESET_${presetId}`;
+        await this.sendKey(key);
+    }
+    /**
+     * Play
+     */
+    async play() {
+        await this.sendKey(types_1.KeyValue.PLAY);
+    }
+    /**
+     * Pause
+     */
+    async pause() {
+        await this.sendKey(types_1.KeyValue.PAUSE);
+    }
+    /**
+     * Toggle play/pause
+     */
+    async playPause() {
+        const nowPlaying = await this.getNowPlaying();
+        if (nowPlaying.playStatus === types_1.PlayStatus.PLAY_STATE) {
+            await this.pause();
+        }
+        else {
+            await this.play();
+        }
+    }
+    /**
+     * Stop
+     */
+    async stop() {
+        await this.sendKey(types_1.KeyValue.PAUSE);
+    }
+    /**
+     * Next track
+     */
+    async nextTrack() {
+        await this.sendKey(types_1.KeyValue.NEXT_TRACK);
+    }
+    /**
+     * Previous track
+     */
+    async previousTrack() {
+        await this.sendKey(types_1.KeyValue.PREV_TRACK);
+    }
+    /**
+     * Get bass level
+     */
+    async getBass() {
+        const data = await this.get("/bass");
+        return data.bass;
+    }
+    /**
+     * Set bass level (-10 to 10)
+     */
+    async setBass(level) {
+        if (level < -10 || level > 10) {
+            throw new Error("Bass level must be between -10 and 10");
+        }
+        const xml = `<bass>${level}</bass>`;
+        await this.post("/bass", xml);
+    }
+    /**
+     * Get tone settings (bass and treble)
+     */
+    async getTone() {
+        const data = await this.get("/tone");
+        return data.tone;
+    }
+    /**
+     * Send a raw key press
+     */
+    async sendKey(key) {
+        const keyValue = typeof key === "string" ? key : key;
+        const xml = `<key state="press" sender="Gabbo">${keyValue}</key>`;
+        await this.post("/key", xml);
+    }
+    /**
+     * Escape XML special characters
+     */
+    escapeXml(unsafe) {
+        return unsafe
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&apos;");
+    }
+}
+exports.SoundTouch = SoundTouch;

package/dist/types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Type definitions for Bose SoundTouch API responses
+ */
+export declare enum PlayStatus {
+    PLAY_STATE = "PLAY_STATE",
+    PAUSE_STATE = "PAUSE_STATE",
+    STOP_STATE = "STOP_STATE",
+    BUFFERING_STATE = "BUFFERING_STATE"
+}
+export declare enum KeyValue {
+    POWER = "POWER",
+    PLAY = "PLAY",
+    PAUSE = "PAUSE",
+    PREV_TRACK = "PREV_TRACK",
+    NEXT_TRACK = "NEXT_TRACK",
+    THUMBS_UP = "THUMBS_UP",
+    THUMBS_DOWN = "THUMBS_DOWN",
+    BOOKMARK = "BOOKMARK",
+    PRESET_1 = "PRESET_1",
+    PRESET_2 = "PRESET_2",
+    PRESET_3 = "PRESET_3",
+    PRESET_4 = "PRESET_4",
+    PRESET_5 = "PRESET_5",
+    PRESET_6 = "PRESET_6",
+    AUX_INPUT = "AUX_INPUT",
+    SHUFFLE_OFF = "SHUFFLE_OFF",
+    SHUFFLE_ON = "SHUFFLE_ON",
+    REPEAT_OFF = "REPEAT_OFF",
+    REPEAT_ONE = "REPEAT_ONE",
+    REPEAT_ALL = "REPEAT_ALL",
+    ADD_FAVORITE = "ADD_FAVORITE",
+    REMOVE_FAVORITE = "REMOVE_FAVORITE",
+    INVALID_KEY = "INVALID_KEY"
+}
+export interface NetworkInfo {
+    type: string;
+    macAddress: string;
+    ipAddress: string;
+}
+export interface DeviceInfo {
+    deviceID: string;
+    name: string;
+    type: string;
+    networkInfo: NetworkInfo[];
+}
+export interface Capability {
+    name: string;
+    value: string;
+}
+export interface Capabilities {
+    capability: Capability[];
+}
+export interface ContentItem {
+    source: string;
+    sourceAccount?: string;
+    location?: string;
+    isPresetable?: boolean;
+    itemName?: string;
+    containerArt?: string;
+    type?: string;
+}
+export interface Preset {
+    id: string;
+    contentItem?: ContentItem;
+}
+export interface Presets {
+    preset: Preset[];
+}
+export interface Source {
+    source: string;
+    sourceAccount?: string;
+    status: string;
+    isLocal?: boolean;
+    multiroomallowed?: boolean;
+}
+export interface Sources {
+    sourceItem: Source[];
+}
+export interface Volume {
+    targetvolume: number;
+    actualvolume: number;
+    muteenabled: boolean;
+}
+export interface NowPlaying {
+    source: string;
+    ContentItem?: ContentItem;
+    track?: string;
+    artist?: string;
+    album?: string;
+    stationName?: string;
+    art?: string;
+    artImageStatus?: string;
+    playStatus?: PlayStatus;
+    skipEnabled?: boolean;
+    skipPreviousEnabled?: boolean;
+    favoriteEnabled?: boolean;
+    isFavorite?: boolean;
+    stationLocation?: string;
+    time?: number;
+    totalTime?: number;
+}
+export interface Bass {
+    targetbass: number;
+    actualbass: number;
+    available?: boolean;
+}
+export interface Tone {
+    targettreble: number;
+    actualtreble: number;
+    targetbass: number;
+    actualbass: number;
+    available?: boolean;
+}

package/dist/types.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Type definitions for Bose SoundTouch API responses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyValue = exports.PlayStatus = void 0;
+var PlayStatus;
+(function (PlayStatus) {
+    PlayStatus["PLAY_STATE"] = "PLAY_STATE";
+    PlayStatus["PAUSE_STATE"] = "PAUSE_STATE";
+    PlayStatus["STOP_STATE"] = "STOP_STATE";
+    PlayStatus["BUFFERING_STATE"] = "BUFFERING_STATE";
+})(PlayStatus || (exports.PlayStatus = PlayStatus = {}));
+var KeyValue;
+(function (KeyValue) {
+    KeyValue["POWER"] = "POWER";
+    KeyValue["PLAY"] = "PLAY";
+    KeyValue["PAUSE"] = "PAUSE";
+    KeyValue["PREV_TRACK"] = "PREV_TRACK";
+    KeyValue["NEXT_TRACK"] = "NEXT_TRACK";
+    KeyValue["THUMBS_UP"] = "THUMBS_UP";
+    KeyValue["THUMBS_DOWN"] = "THUMBS_DOWN";
+    KeyValue["BOOKMARK"] = "BOOKMARK";
+    KeyValue["PRESET_1"] = "PRESET_1";
+    KeyValue["PRESET_2"] = "PRESET_2";
+    KeyValue["PRESET_3"] = "PRESET_3";
+    KeyValue["PRESET_4"] = "PRESET_4";
+    KeyValue["PRESET_5"] = "PRESET_5";
+    KeyValue["PRESET_6"] = "PRESET_6";
+    KeyValue["AUX_INPUT"] = "AUX_INPUT";
+    KeyValue["SHUFFLE_OFF"] = "SHUFFLE_OFF";
+    KeyValue["SHUFFLE_ON"] = "SHUFFLE_ON";
+    KeyValue["REPEAT_OFF"] = "REPEAT_OFF";
+    KeyValue["REPEAT_ONE"] = "REPEAT_ONE";
+    KeyValue["REPEAT_ALL"] = "REPEAT_ALL";
+    KeyValue["ADD_FAVORITE"] = "ADD_FAVORITE";
+    KeyValue["REMOVE_FAVORITE"] = "REMOVE_FAVORITE";
+    KeyValue["INVALID_KEY"] = "INVALID_KEY";
+})(KeyValue || (exports.KeyValue = KeyValue = {}));

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "bose-soundtouch",
+  "version": "0.1.0",
+  "description": "A JavaScript/TypeScript library for controlling Bose SoundTouch speakers via the local REST API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "demo": "ts-node demo.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "bose",
+    "soundtouch",
+    "speaker",
+    "audio",
+    "rest",
+    "api"
+  ],
+  "author": "Paul Grant",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/captivus/bose-soundtouch.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.7.7",
+    "xml2js": "^0.6.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.10",
+    "@types/xml2js": "^0.4.14",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}