@lox-audio-server/sonos 0.1.0

package/dist/sonos/models.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayModesWrapper = exports.PlaybackActionsWrapper = void 0;
+exports.normalizeContainerType = normalizeContainerType;
+exports.normalizeMusicService = normalizeMusicService;
+const types_1 = require("./types");
+class PlaybackActionsWrapper {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    get canSkipForward() {
+        return this.raw.canSkipForward ?? this.raw.canSkip ?? false;
+    }
+    get canSkipBackward() {
+        return this.raw.canSkipBack ?? this.raw.canSkipToPrevious ?? false;
+    }
+    get canPlay() {
+        return this.raw.canPlay ?? false;
+    }
+    get canPause() {
+        return this.raw.canPause ?? false;
+    }
+    get canStop() {
+        return this.raw.canStop ?? false;
+    }
+}
+exports.PlaybackActionsWrapper = PlaybackActionsWrapper;
+class PlayModesWrapper {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    get crossfade() {
+        return this.raw.crossfade;
+    }
+    get repeat() {
+        return this.raw.repeat;
+    }
+    get repeatOne() {
+        return this.raw.repeatOne;
+    }
+    get shuffle() {
+        return this.raw.shuffle;
+    }
+}
+exports.PlayModesWrapper = PlayModesWrapper;
+function normalizeContainerType(containerType) {
+    if (!containerType)
+        return null;
+    if (Object.values(types_1.ContainerType).includes(containerType)) {
+        return containerType;
+    }
+    return containerType;
+}
+function normalizeMusicService(serviceId) {
+    if (!serviceId)
+        return null;
+    if (Object.values(types_1.MusicService).includes(serviceId)) {
+        return serviceId;
+    }
+    return serviceId;
+}

package/dist/sonos/player.d.ts

@@ -0,0 +1,33 @@
+import { SonosClient } from './client';
+import { SonosGroup } from './group';
+import { Player } from './types';
+export declare class SonosPlayer {
+    private client;
+    private data;
+    private volumeData;
+    private activeGroup;
+    constructor(client: SonosClient, data: Player);
+    init(): Promise<void>;
+    get id(): string;
+    get name(): string;
+    get icon(): string;
+    get volumeLevel(): number | undefined;
+    get volumeMuted(): boolean | undefined;
+    get hasFixedVolume(): boolean | undefined;
+    get group(): SonosGroup | null;
+    get groupMembers(): string[];
+    get isCoordinator(): boolean;
+    get isPassive(): boolean;
+    setVolume(volume?: number, muted?: boolean): Promise<void>;
+    duck(durationMillis?: number): Promise<void>;
+    leaveGroup(): Promise<void>;
+    joinGroup(groupId: string): Promise<void>;
+    playAudioClip(url: string, options?: {
+        volume?: number;
+        name?: string;
+    }): Promise<void>;
+    loadHomeTheaterPlayback(): Promise<void>;
+    updateData(newData: Player): void;
+    checkActiveGroup(): void;
+    private handleVolumeUpdate;
+}

package/dist/sonos/player.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonosPlayer = void 0;
+const constants_1 = require("./constants");
+class SonosPlayer {
+    client;
+    data;
+    volumeData = null;
+    activeGroup = null;
+    constructor(client, data) {
+        this.client = client;
+        this.data = data;
+        this.activeGroup = this.client.groups.find((g) => g.coordinatorId === this.id || g.playerIds.includes(this.id)) ?? null;
+    }
+    async init() {
+        this.volumeData = await this.client.api.playerVolume.getVolume(this.id);
+        await this.client.api.playerVolume.subscribe(this.id, (data) => this.handleVolumeUpdate(data));
+    }
+    get id() {
+        return this.data.id;
+    }
+    get name() {
+        return this.data.name;
+    }
+    get icon() {
+        return this.data.icon ?? '';
+    }
+    get volumeLevel() {
+        return this.volumeData?.volume;
+    }
+    get volumeMuted() {
+        return this.volumeData?.muted;
+    }
+    get hasFixedVolume() {
+        return this.volumeData?.fixed;
+    }
+    get group() {
+        return this.activeGroup;
+    }
+    get groupMembers() {
+        return this.group?.playerIds ?? [];
+    }
+    get isCoordinator() {
+        return Boolean(this.group && this.group.coordinatorId === this.id);
+    }
+    get isPassive() {
+        return Boolean(this.group && this.group.coordinatorId !== this.id);
+    }
+    async setVolume(volume, muted) {
+        await this.client.api.playerVolume.setVolume(this.id, volume, muted);
+    }
+    async duck(durationMillis) {
+        await this.client.api.playerVolume.duck(this.id, durationMillis);
+    }
+    async leaveGroup() {
+        if (!this.group)
+            return;
+        await this.client.api.groups.modifyGroupMembers(this.group.id, [], [this.id]);
+    }
+    async joinGroup(groupId) {
+        await this.client.api.groups.modifyGroupMembers(groupId, [this.id], []);
+    }
+    async playAudioClip(url, options = {}) {
+        await this.client.api.audioClip.loadAudioClip(this.id, {
+            name: options.name ?? 'lox-sonos',
+            appId: 'lox-sonos',
+            streamUrl: url,
+            volume: options.volume,
+        });
+    }
+    async loadHomeTheaterPlayback() {
+        await this.client.api.homeTheater.loadHomeTheaterPlayback(this.id);
+    }
+    updateData(newData) {
+        this.checkActiveGroup();
+        let changed = false;
+        for (const [key, value] of Object.entries(newData)) {
+            if (this.data[key] !== value) {
+                this.data[key] = value;
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.client.signalEvent({
+                eventType: constants_1.EventType.PLAYER_UPDATED,
+                objectId: this.id,
+                data: this,
+            });
+        }
+    }
+    checkActiveGroup() {
+        const prevGroupId = this.activeGroup?.id;
+        this.activeGroup =
+            this.client.groups.find((g) => g.coordinatorId === this.id || g.playerIds.includes(this.id)) ?? null;
+        if (prevGroupId !== this.activeGroup?.id) {
+            this.client.signalEvent({
+                eventType: constants_1.EventType.PLAYER_UPDATED,
+                objectId: this.id,
+                data: this,
+            });
+        }
+    }
+    handleVolumeUpdate(data) {
+        this.volumeData = data;
+        this.client.signalEvent({
+            eventType: constants_1.EventType.PLAYER_UPDATED,
+            objectId: this.id,
+            data: this,
+        });
+    }
+}
+exports.SonosPlayer = SonosPlayer;

package/dist/sonos/types.d.ts

@@ -0,0 +1,279 @@
+import { EventType } from './constants';
+export interface CommandMessage {
+    namespace: string;
+    command: string;
+    sessionId?: string;
+    cmdId?: string;
+    [key: string]: unknown;
+}
+export interface ResultMessage {
+    namespace: string;
+    response: string;
+    householdId: string;
+    type?: string;
+    sessionId?: string;
+    cmdId?: string;
+    success?: boolean;
+    [key: string]: unknown;
+}
+export interface ErrorResponse {
+    errorCode: string;
+    reason?: string;
+}
+export declare enum PlayBackState {
+    IDLE = "PLAYBACK_STATE_IDLE",
+    BUFFERING = "PLAYBACK_STATE_BUFFERING",
+    PAUSED = "PLAYBACK_STATE_PAUSED",
+    PLAYING = "PLAYBACK_STATE_PLAYING"
+}
+export declare enum SonosCapability {
+    CLOUD = "CLOUD",
+    PLAYBACK = "PLAYBACK",
+    AIRPLAY = "AIRPLAY",
+    LINE_IN = "LINE_IN",
+    VOICE = "VOICE",
+    AUDIO_CLIP = "AUDIO_CLIP",
+    MICROPHONE_SWITCH = "MICROPHONE_SWITCH",
+    HT_PLAYBACK = "HT_PLAYBACK"
+}
+export interface Group {
+    _objectType: 'group';
+    coordinatorId: string;
+    id: string;
+    name: string;
+    playbackState?: string;
+    playerIds: string[];
+    areaIds?: string[];
+}
+export interface GroupInfo {
+    _objectType: 'groupInfo';
+    group: Group;
+}
+export interface ZoneMemberState {
+    _objectType: 'zoneMemberState';
+    disconnected: boolean;
+}
+export interface ActiveZoneMember {
+    _objectType: 'activeZoneMember';
+    channelMap: string[];
+    id: string;
+    state: ZoneMemberState;
+}
+export interface ActiveZone {
+    _objectType: 'activeZone';
+    members: ActiveZoneMember[];
+    name: string;
+    zoneId?: string;
+}
+export interface DeviceInfo {
+    _objectType: 'deviceInfo';
+    id: string;
+    primaryDeviceId?: string;
+    serialNumber?: string;
+    modelDisplayName?: string;
+    color?: string;
+    capabilities: SonosCapability[];
+    apiVersion?: string;
+    minApiVersion?: string;
+    name?: string;
+    websocketUrl?: string;
+    softwareVersion?: string;
+    hwVersion?: string;
+    swGen?: number;
+}
+export interface Player {
+    _objectType: 'player';
+    id: string;
+    name: string;
+    websocketUrl: string;
+    softwareVersion: string;
+    apiVersion: string;
+    minApiVersion: string;
+    devices: DeviceInfo[];
+    zoneInfo: ActiveZone;
+    icon?: string;
+}
+export interface Groups {
+    _objectType: 'groups';
+    groups: Group[];
+    partial: boolean;
+    players: Player[];
+}
+export interface DiscoveryInfo {
+    _objectType: 'discoveryInfo';
+    device: DeviceInfo;
+    householdId: string;
+    locationId: string;
+    playerId: string;
+    groupId: string;
+    websocketUrl: string;
+    restUrl: string;
+}
+export interface PlaybackActions {
+    _objectType?: 'playbackAction';
+    canCrossfade?: boolean;
+    canPause?: boolean;
+    canPlay?: boolean;
+    canRepeat?: boolean;
+    canRepeatOne?: boolean;
+    canSeek?: boolean;
+    canShuffle?: boolean;
+    canSkip?: boolean;
+    canSkipBack?: boolean;
+    canSkipToPrevious?: boolean;
+    canStop?: boolean;
+    canSkipForward?: boolean;
+}
+export interface PlayModes {
+    _objectType?: 'playModes';
+    crossfade?: boolean;
+    repeat?: boolean;
+    repeatOne?: boolean;
+    shuffle?: boolean;
+}
+export interface PlaybackStatus {
+    _objectType: 'playbackStatus';
+    availablePlaybackActions: PlaybackActions;
+    isDucking: boolean;
+    playbackState: PlayBackState;
+    playModes: PlayModes;
+    positionMillis: number;
+    previousPositionMillis: number;
+}
+export interface GroupVolume {
+    _objectType: 'groupVolume';
+    fixed: boolean;
+    muted: boolean;
+    volume: number;
+}
+export interface PlayerVolume {
+    _objectType: 'playerVolume';
+    fixed: boolean;
+    muted: boolean;
+    volume: number;
+}
+export declare enum MusicService {
+    SPOTIFY = "9",
+    MUSIC_ASSISTANT = "mass",
+    TUNEIN = "303",
+    QOBUZ = "31",
+    YOUTUBE_MUSIC = "284",
+    LOCAL_LIBRARY = "local-library"
+}
+export interface MetadataId {
+    _objectType: 'id';
+    serviceId?: string;
+    objectId?: string;
+    accountId?: string;
+}
+export interface Service {
+    _objectType: 'service';
+    name: string;
+    images?: Image[];
+}
+export interface Image {
+    _objectType: 'image';
+    url: string;
+    name?: string;
+    type?: string;
+}
+export interface Artist {
+    _objectType: 'artist';
+    name: string;
+}
+export interface Album {
+    _objectType: 'album';
+    name: string;
+}
+export interface Track {
+    _objectType: 'track';
+    type: string;
+    name: string;
+    mediaUrl?: string;
+    images?: Image[];
+    contentType?: string;
+    album?: Album;
+    artist?: Artist;
+    releaseDate?: string;
+    id?: MetadataId;
+    service?: Service;
+    durationMillis?: number;
+    trackNumber?: number;
+    explicit?: boolean;
+}
+export declare enum ContainerType {
+    LINEIN = "linein",
+    STATION = "station",
+    PLAYLIST = "playlist",
+    AIRPLAY = "linein.airplay",
+    PODCAST = "podcast",
+    BOOK = "book",
+    ARTIST = "artist",
+    ALBUM = "album",
+    ARTIST_LOCAL = "artist.local",
+    ALBUM_LOCAL = "album.local",
+    HOME_THEATER_SPDIF = "linein.homeTheater.spdif",
+    HOME_THEATER_HDMI = "linein.homeTheater.hdmi"
+}
+export interface Container {
+    _objectType: 'container';
+    name: string;
+    type: string;
+    id?: MetadataId;
+    service?: Service;
+    images?: Image[];
+    explicit?: boolean;
+}
+export interface QueueItem {
+    _objectType: 'queueItem';
+    id: string;
+    deleted?: boolean;
+    track?: Track;
+}
+export interface PlaybackSession {
+    _objectType: 'sessionStatus';
+    sessionId: string;
+    sessionState: string;
+    sessionCreated: boolean;
+    customData: string;
+}
+export interface MetadataStatus {
+    _objectType: 'metadataStatus';
+    container?: Container;
+    currentItem?: QueueItem;
+    nextItem?: QueueItem;
+    streamInfo?: string;
+    playbackSession?: PlaybackSession;
+}
+export interface AudioClip {
+    _objectType: 'audioClip';
+    id: string;
+    name: string;
+    appId: string;
+    priority: string;
+    clipType: string;
+    status: string;
+    clipLEDBehavior: string;
+}
+export interface AudioClipStatusEvent {
+    _objectType: 'audioClipStatus';
+    audioClips: AudioClip[];
+}
+export interface LoadContentRequest {
+    type: string;
+    id: MetadataId;
+    playbackAction: string;
+    playModes?: PlayModes;
+}
+export interface SessionStatus {
+    _objectType: 'sessionStatus';
+    sessionId: string;
+    sessionState: string;
+    sessionCreated: boolean;
+    customData: string;
+}
+export interface SonosEvent {
+    eventType: EventType;
+    objectId?: string | null;
+    data?: any;
+}

package/dist/sonos/types.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerType = exports.MusicService = exports.SonosCapability = exports.PlayBackState = void 0;
+var PlayBackState;
+(function (PlayBackState) {
+    PlayBackState["IDLE"] = "PLAYBACK_STATE_IDLE";
+    PlayBackState["BUFFERING"] = "PLAYBACK_STATE_BUFFERING";
+    PlayBackState["PAUSED"] = "PLAYBACK_STATE_PAUSED";
+    PlayBackState["PLAYING"] = "PLAYBACK_STATE_PLAYING";
+})(PlayBackState || (exports.PlayBackState = PlayBackState = {}));
+var SonosCapability;
+(function (SonosCapability) {
+    SonosCapability["CLOUD"] = "CLOUD";
+    SonosCapability["PLAYBACK"] = "PLAYBACK";
+    SonosCapability["AIRPLAY"] = "AIRPLAY";
+    SonosCapability["LINE_IN"] = "LINE_IN";
+    SonosCapability["VOICE"] = "VOICE";
+    SonosCapability["AUDIO_CLIP"] = "AUDIO_CLIP";
+    SonosCapability["MICROPHONE_SWITCH"] = "MICROPHONE_SWITCH";
+    SonosCapability["HT_PLAYBACK"] = "HT_PLAYBACK";
+})(SonosCapability || (exports.SonosCapability = SonosCapability = {}));
+var MusicService;
+(function (MusicService) {
+    MusicService["SPOTIFY"] = "9";
+    MusicService["MUSIC_ASSISTANT"] = "mass";
+    MusicService["TUNEIN"] = "303";
+    MusicService["QOBUZ"] = "31";
+    MusicService["YOUTUBE_MUSIC"] = "284";
+    MusicService["LOCAL_LIBRARY"] = "local-library";
+})(MusicService || (exports.MusicService = MusicService = {}));
+var ContainerType;
+(function (ContainerType) {
+    ContainerType["LINEIN"] = "linein";
+    ContainerType["STATION"] = "station";
+    ContainerType["PLAYLIST"] = "playlist";
+    ContainerType["AIRPLAY"] = "linein.airplay";
+    ContainerType["PODCAST"] = "podcast";
+    ContainerType["BOOK"] = "book";
+    ContainerType["ARTIST"] = "artist";
+    ContainerType["ALBUM"] = "album";
+    ContainerType["ARTIST_LOCAL"] = "artist.local";
+    ContainerType["ALBUM_LOCAL"] = "album.local";
+    ContainerType["HOME_THEATER_SPDIF"] = "linein.homeTheater.spdif";
+    ContainerType["HOME_THEATER_HDMI"] = "linein.homeTheater.hdmi";
+    // fallbacks for unknown types will be treated as strings
+})(ContainerType || (exports.ContainerType = ContainerType = {}));

package/dist/sonos/utils.d.ts

@@ -0,0 +1,6 @@
+import { Agent } from 'undici';
+import { DiscoveryInfo } from './types';
+export interface DiscoveryOptions {
+    dispatcher?: Agent;
+}
+export declare function getDiscoveryInfo(playerIp: string, options?: DiscoveryOptions): Promise<DiscoveryInfo>;

package/dist/sonos/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiscoveryInfo = getDiscoveryInfo;
+const undici_1 = require("undici");
+const constants_1 = require("./constants");
+async function getDiscoveryInfo(playerIp, options) {
+    const dispatcher = options?.dispatcher ?? new undici_1.Agent({ connect: { rejectUnauthorized: false } });
+    const resp = await (0, undici_1.fetch)(`https://${playerIp}:1443/api/v1/players/local/info`, {
+        method: 'GET',
+        headers: { 'X-Sonos-Api-Key': constants_1.LOCAL_API_TOKEN },
+        dispatcher,
+    });
+    if (!resp.ok) {
+        throw new Error(`Sonos discovery failed (${resp.status} ${resp.statusText})`);
+    }
+    const data = (await resp.json());
+    return data;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@lox-audio-server/sonos",
+  "version": "0.1.0",
+  "description": "Sonos Controller",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist/**/*", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.json",
+    "build:esm": "tsc -p tsconfig.esm.json && node -e \"const fs=require('fs');fs.mkdirSync('dist/esm',{recursive:true});fs.writeFileSync('dist/esm/package.json','{\\\"type\\\":\\\"module\\\"}\\n');\"",
+    "clean": "rimraf dist",
+    "prepare": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rudyberends/lox-audio-server-sonos.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rudyberends/lox-audio-server-sonos/issues"
+  },
+  "homepage": "https://github.com/rudyberends/lox-audio-server-sonos#readme",
+  "keywords": ["sonos", "controller", "audio", "streaming"],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "undici": "^6.19.8",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.13",
+    "@types/node": "^22.19.3",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.9.3"
+  },
+  "license": "AGPL-3.0"
+}