Update README

* Ability to build arm7 docker image using buildx

* Build arm64 and amd64 images

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
       - 
         uses: actions/setup-node@v1
         with:
-          node-version: 16.6.x
+          node-version: '16'
       - 
         run: yarn install
       - 
@@ -38,6 +38,12 @@ jobs:
         uses: actions/checkout@v2
         with:
           fetch-depth: 0
+      -
+        name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+      -
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
       -
         name: Docker meta
         id: meta
@@ -56,6 +62,7 @@ jobs:
         uses: docker/build-push-action@v2
         with:
           context: .
+          platforms: linux/amd64,linux/arm/v7
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}

Dockerfile

@@ -1,4 +1,4 @@
-FROM node:16.6-alpine as build
+FROM node:16-bullseye as build
 
 WORKDIR /bonob
 
@@ -16,24 +16,32 @@ COPY yarn.lock .
 COPY .yarnrc.yml .
 COPY .yarn/releases ./.yarn/releases
 
-RUN apk add --no-cache --update --virtual .gyp \
-        vips-dev \
+ENV JEST_TIMEOUT=30000
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && \
+    apt-get -y upgrade && \
+    apt-get -y install --no-install-recommends \
+        libvips-dev \
         python3 \
         make \
         git \
         g++ && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/* && \
     yarn install --immutable && \
     yarn gitinfo && \
     yarn test --no-cache && \
     yarn build
 
 
+FROM node:16-bullseye
 
-FROM node:16.6-alpine
+ENV BNB_PORT=4534
+ENV DEBIAN_FRONTEND=noninteractive
+ENV TZ=UTC
 
-ENV BONOB_PORT=4534
-
-EXPOSE $BONOB_PORT
+EXPOSE $BNB_PORT
 
 WORKDIR /bonob
 
@@ -46,9 +54,15 @@ COPY --from=build /bonob/.gitinfo ./
 COPY web ./web
 COPY src/Sonoswsdl-1.19.4-20190411.142401-3.wsdl ./src/Sonoswsdl-1.19.4-20190411.142401-3.wsdl
 
-RUN apk add --no-cache --update vips
+RUN apt-get update && \
+    apt-get -y upgrade && \
+    apt-get -y install --no-install-recommends libvips tzdata && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
 
 USER nobody 
 WORKDIR /bonob/src
 
+HEALTHCHECK CMD wget -O- http://localhost:${BNB_PORT}/about || exit 1   
+
 CMD ["node", "app.js"]

README.md

@@ -2,39 +2,37 @@
 
 A sonos SMAPI implementation to allow registering sources of music with sonos.  
 
-Currently only a single integration allowing Navidrome to be registered with sonos. In theory as Navidrome implements the subsonic API, it *may* work with other subsonic api clones.
+Support for Subsonic API clones (tested against Navidrome and Gonic).
 
 ![Build](https://github.com/simojenki/bonob/workflows/Build/badge.svg)
 
 ## Features
 
-- Integrates with Navidrome
-- Browse by Artist, Albums, Genres, Playlist, Random Albums, Starred Albums, Recently Added Albums, Recently Played Albums, Most Played Albums
-- Artist Art
-- Album Art
+- Integrates with Subsonic API clones (Navidrome, Gonic)
+- Browse by Artist, Albums, Random, Favourites, Top Rated, Playlist, Genres, Recently Added Albums, Recently Played Albums, Most Played Albums
+- Artist & Album Art
 - View Related Artists via Artist -> '...' -> Menu -> Related Arists
 - Now playing & Track Scrobbling
+- Search by Album, Artist, Track
+- Playlist editing through sonos app.
+- Marking of songs as favourites and with ratings through the sonos app.
+- Localization (only en-US & nl-NL supported currently, require translations for other languages).  [Sonos localization and supported languages](https://developer.sonos.com/build/content-service-add-features/strings-and-localization/)
 - Auto discovery of sonos devices
 - Discovery of sonos devices using seed IP address
-- Auto register bonob service with sonos system
+- Auto registration with sonos on start
 - Multiple registrations within a single household.
-- Transcoding performed by Navidrome with specific player for bonob/sonos, customisable by mimeType
-- Ability to search by Album, Artist, Track
-- Ability to play a playlist
-- Ability to add/remove playlists
-- Ability to add/remove tracks from a playlist
-- Localization (only en-US & nl-NL supported currently, require translations for other languages).  [Sonos localization and supported languages](https://developer.sonos.com/build/content-service-add-features/strings-and-localization/)
+- Transcoding support for flacs using a specific player for the flac mimeType bonob/sonos
 
 ## Running
 
-bonob is ditributed via docker and can be run in a number of ways
+bonob is distributed via docker and can be run in a number of ways
 
 ### Full sonos device auto-discovery and auto-registration using docker --network host
 
 ```bash
 docker run \
-    -e BONOB_SONOS_AUTO_REGISTER=true \
-    -e BONOB_SONOS_DEVICE_DISCOVERY=true \
+    -e BNB_SONOS_AUTO_REGISTER=true \
+    -e BNB_SONOS_DEVICE_DISCOVERY=true \
     -p 4534:4534 \
     --network host \
     simojenki/bonob
@@ -46,10 +44,10 @@ Now open http://localhost:4534 in your browser, you should see sonos devices, an
 
 ```bash
 docker run \
-    -e BONOB_PORT=3000 \
-    -e BONOB_SONOS_SEED_HOST=192.168.1.123 \
-    -e BONOB_SONOS_AUTO_REGISTER=true \
-    -e BONOB_SONOS_DEVICE_DISCOVERY=true \
+    -e BNB_PORT=3000 \
+    -e BNB_SONOS_SEED_HOST=192.168.1.123 \
+    -e BNB_SONOS_AUTO_REGISTER=true \
+    -e BNB_SONOS_DEVICE_DISCOVERY=true \
     -p 3000:3000 \
     simojenki/bonob
 ```
@@ -66,13 +64,13 @@ Start bonob outside the LAN with sonos discovery & registration disabled as they
 
 ```bash
 docker run \
-    -e BONOB_PORT=4534 \
-    -e BONOB_SONOS_SERVICE_NAME=MyAwesomeMusic \
-    -e BONOB_SECRET=changeme \
-    -e BONOB_URL=https://my-server.example.com/bonob \
-    -e BONOB_SONOS_AUTO_REGISTER=false \
-    -e BONOB_SONOS_DEVICE_DISCOVERY=false \
-    -e BONOB_NAVIDROME_URL=https://my-navidrome-service.com:4533 \
+    -e BNB_PORT=4534 \
+    -e BNB_SONOS_SERVICE_NAME=MyAwesomeMusic \
+    -e BNB_SECRET=changeme \
+    -e BNB_URL=https://my-server.example.com/bonob \
+    -e BNB_SONOS_AUTO_REGISTER=false \
+    -e BNB_SONOS_DEVICE_DISCOVERY=false \
+    -e BNB_SUBSONIC_URL=https://my-navidrome-service.com:4533 \
     -p 4534:4534 \
     simojenki/bonob
 ```
@@ -93,11 +91,10 @@ docker run \
 ```bash
 docker run \
     --rm \
-    -e BONOB_SONOS_SEED_HOST=192.168.1.163 \
+    -e BNB_SONOS_SEED_HOST=192.168.1.163 \
     simojenki/bonob register https://my-server.example.com/bonob
 ```
 
-
 ### Running bonob and navidrome using docker-compose
 
 ```yaml
@@ -125,76 +122,129 @@ services:
       - "4534:4534"
     restart: unless-stopped
     environment:
-      BONOB_PORT: 4534
+      BNB_PORT: 4534
       # ip address of your machine running bonob
-      BONOB_URL: http://192.168.1.111:4534  
-      BONOB_SECRET: changeme
-      BONOB_SONOS_AUTO_REGISTER: true
-      BONOB_SONOS_DEVICE_DISCOVERY: true
-      BONOB_SONOS_SERVICE_ID: 246
+      BNB_URL: http://192.168.1.111:4534  
+      BNB_SECRET: changeme
+      BNB_SONOS_AUTO_REGISTER: true
+      BNB_SONOS_DEVICE_DISCOVERY: true
+      BNB_SONOS_SERVICE_ID: 246
       # ip address of one of your sonos devices
-      BONOB_SONOS_SEED_HOST: 192.168.1.121
-      BONOB_NAVIDROME_URL: http://navidrome:4533
+      BNB_SONOS_SEED_HOST: 192.168.1.121
+      BNB_SUBSONIC_URL: http://navidrome:4533
 ```
 
+### Running bonob on synology
+
+[See this issue](https://github.com/simojenki/bonob/issues/15)
+
 ## Configuration
 
 item | default value | description
 ---- | ------------- | -----------
-BONOB_PORT | 4534 | Default http port for bonob to listen on
-BONOB_URL | http://$(hostname):4534 | URL (including path) for bonob so that sonos devices can communicate. **This must be either the public IP or DNS entry of the bonob instance so that the sonos devices can communicate with it.**
-BONOB_SECRET | bonob | secret used for encrypting credentials
-BONOB_SONOS_AUTO_REGISTER | false | Whether or not to try and auto-register on startup
-BONOB_SONOS_DEVICE_DISCOVERY | true | whether or not sonos device discovery should be enabled
-BONOB_SONOS_SEED_HOST | undefined | sonos device seed host for discovery, or ommitted for for auto-discovery
-BONOB_SONOS_SERVICE_NAME | bonob | service name for sonos
-BONOB_SONOS_SERVICE_ID | 246 | service id for sonos
-BONOB_NAVIDROME_URL | http://$(hostname):4533 | URL for navidrome
-BONOB_NAVIDROME_CUSTOM_CLIENTS | undefined | Comma delimeted mime types for custom navidrome clients when streaming. ie. "audio/flac,audio/ogg" would use client = 'bonob+audio/flac' for flacs, and 'bonob+audio/ogg' for oggs.
-BONOB_SCROBBLE_TRACKS | true | Whether to scrobble the playing of a track if it has been played for >30s
-BONOB_REPORT_NOW_PLAYING | true | Whether to report a track as now playing
-BONOB_ICON_FOREGROUND_COLOR | undefined | Icon foreground color in sonos app, must be a valid [svg color](https://www.december.com/html/spec/colorsvg.html)
-BONOB_ICON_BACKGROUND_COLOR | undefined | Icon background color in sonos app, must be a valid [svg color](https://www.december.com/html/spec/colorsvg.html)
+BNB_PORT | 4534 | Default http port for bonob to listen on
+BNB_URL | http://$(hostname):4534 | URL (including path) for bonob so that sonos devices can communicate. **This must be either the public IP or DNS entry of the bonob instance so that the sonos devices can communicate with it.**
+BNB_SECRET | bonob | secret used for encrypting credentials
+BNB_AUTH_TIMEOUT | 1h | Timeout for the sonos auth token, described in the format [ms](https://github.com/vercel/ms), ie. '5s' == 5 seconds, '11h' == 11 hours.  In the case of using Navidrome this should be less than the value for ND_SESSIONTIMEOUT
+BNB_SONOS_AUTO_REGISTER | false | Whether or not to try and auto-register on startup
+BNB_SONOS_DEVICE_DISCOVERY | true | Enable/Disable sonos device discovery entirely.  Setting this to 'false' will disable sonos device search, regardless of whether a seed host is specified.
+BNB_SONOS_SEED_HOST | undefined | sonos device seed host for discovery, or ommitted for for auto-discovery
+BNB_SONOS_SERVICE_NAME | bonob | service name for sonos
+BNB_SONOS_SERVICE_ID | 246 | service id for sonos
+BNB_SUBSONIC_URL | http://$(hostname):4533 | URL for subsonic clone
+BNB_SUBSONIC_CUSTOM_CLIENTS | undefined | Comma delimeted mime types for custom subsonic clients when streaming. ie. "audio/flac,audio/ogg" would use client = 'bonob+audio/flac' for flacs, and 'bonob+audio/ogg' for oggs.
+BNB_SUBSONIC_ARTIST_IMAGE_CACHE | undefined | Path for caching of artist images as are sourced externally.  ie. Navidrome provides spotify URLs
+BNB_SCROBBLE_TRACKS | true | Whether to scrobble the playing of a track if it has been played for >30s
+BNB_REPORT_NOW_PLAYING | true | Whether to report a track as now playing
+BNB_ICON_FOREGROUND_COLOR | undefined | Icon foreground color in sonos app, must be a valid [svg color](https://www.december.com/html/spec/colorsvg.html)
+BNB_ICON_BACKGROUND_COLOR | undefined | Icon background color in sonos app, must be a valid [svg color](https://www.december.com/html/spec/colorsvg.html)
+TZ | UTC | Your timezone from the [tz database](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) ie. 'Australia/Melbourne'
 
 ## Initialising service within sonos app
 
-- Configure bonob, make sure to set BONOB_URL. **bonob must be accessible from your sonos devices on BONOB_URL, otherwise it will fail to initialise within the sonos app, so make sure you test this in your browser by putting BONOB_URL in the address bar and seeing the bonob information page**
-- Start bonob, 
+- Configure bonob, make sure to set BNB_URL. **bonob must be accessible from your sonos devices on BNB_URL, otherwise it will fail to initialise within the sonos app, so make sure you test this in your browser by putting BNB_URL in the address bar and seeing the bonob information page**
+- Start bonob
 - Open sonos app on your device
 - Settings -> Services & Voice -> + Add a Service
-- Select your Music Service, default name is 'bonob', can be overriden with configuration BONOB_SONOS_SERVICE_NAME
+- Select your Music Service, default name is 'bonob', can be overriden with configuration BNB_SONOS_SERVICE_NAME
 - Press 'Add to Sonos' -> 'Linking sonos with bonob' -> Authorize
-- Your device should open a browser and you should now see a login screen, enter your navidrome credentials
+- Your device should open a browser and you should now see a login screen, enter your subsonic clone credentials
 - You should get 'Login successful!'
 - Go back into the sonos app and complete the process
-- You should now be able to play music from navidrome
-- Within navidrome a new player will be created, 'bonob (username)', so you can configure transcoding specifically for sonos
+- You should now be able to play music on your sonos devices from you subsonic clone
+- Within the subsonic clone a new player will be created, 'bonob (username)', so you can configure transcoding specifically for sonos
 
-## Implementing a different music source other than navidrome
+## Re-registering your bonob service with sonos App
+
+Generally speaking you will not need to do this very often.  However on occassion bonob will change the implementation of the authentication between sonos and bonob, which will require a re-registration.  Your sonos app will complain about not being able to browse the service, to re-register execute the following steps (taken from the iOS app);
+
+- Open the sonos app
+- Settings -> Services & Voice
+- Your bonob service, will likely have name of either 'bonob' or $BNB_SONOS_SERVICE_NAME
+- Reauthorize Account
+- Authorize
+- Enter credentials, you should see 'Login Successful!'
+- Done
+
+Service should now be registered and everything should work as expected.
+
+## Implementing a different music source other than a subsonic clone
 
 - Implement the MusicService/MusicLibrary interface
 - Startup bonob with your new implementation.
 
-## Sample Icon colors
+## A note on transcoding
 
+tldr; Transcoding to mp3/m4a is not supported as sonos devices will not play the track.  However transcoding to flac does work, use BNB_SUBSONIC_CUSTOM_CLIENTS=audio/flac if you want to transcode flac->flac ie. to downsample HD flacs (see below).
+
+Sonos devices are very particular about how audio streams are presented to them, see [streaming basics](https://developer.sonos.com/build/content-service-add-features/streaming-basics/).  When using transcoding both Navidrome and Gonic report no 'content-length', nor do they support range queries, this will cause the sonos device to fail to play the track.
+
+### Audio File type specific transcoding options within Subsonic
+
+In some situations you may wish to have different 'Players' within you Subsonic server so that you can configure different transcoding options depending on the file type.  For example if you have flacs with a mixture of frequency formats where not all are supported by sonos [See issue #52](https://github.com/simojenki/bonob/issues/52) & [Sonos supported audio formats](https://developer.sonos.com/build/content-service-add-features/supported-audio-formats/)
+
+In this case you could set;
+
+```bash
+BNB_SUBSONIC_CUSTOM_CLIENTS="audio/flac"
 ```
--e BONOB_ICON_FOREGROUND_COLOR=white \
--e BONOB_ICON_BACKGROUND_COLOR=darkgrey
+
+This would result in 2 players in Navidrome, one called 'bonob', the other called 'bonob+audio/flac'.  You could then configure a custom flac transcoder in Navidrome that re-samples the flacs to a sonos supported format, ie [Using something like this](https://stackoverflow.com/questions/41420391/ffmpeg-flac-24-bit-96khz-to-16-bit-48khz);
+
+```bash
+ffmpeg -i %s -af aresample=resampler=soxr:out_sample_fmt=s16:out_sample_rate=48000 -f flac -
 ```
+
+### Changing Icon colors
+
+```bash
+-e BNB_ICON_FOREGROUND_COLOR=white \
+-e BNB_ICON_BACKGROUND_COLOR=darkgrey
+```
+
 ![White & Dark Grey](https://github.com/simojenki/bonob/blob/master/docs/images/whiteDarkGrey.png?raw=true)
 
+```bash
+-e BNB_ICON_FOREGROUND_COLOR=chartreuse \
+-e BNB_ICON_BACKGROUND_COLOR=fuchsia
+```
 
-```
--e BONOB_ICON_FOREGROUND_COLOR=chartreuse \
--e BONOB_ICON_BACKGROUND_COLOR=fuchsia
-```
 ![Chartreuse & Fuchsia](https://github.com/simojenki/bonob/blob/master/docs/images/chartreuseFuchsia.png?raw=true)
 
+```bash
+-e BNB_ICON_FOREGROUND_COLOR=lime \
+-e BNB_ICON_BACKGROUND_COLOR=aliceblue
+```
+
+![Lime & Alice Blue](https://github.com/simojenki/bonob/blob/master/docs/images/limeAliceBlue.png?raw=true)
+
+```bash
+-e 'BNB_ICON_FOREGROUND_COLOR=#1db954' \
+-e 'BNB_ICON_BACKGROUND_COLOR=#121212'
+```
+
+![Spotify-ish](https://github.com/simojenki/bonob/blob/master/docs/images/spotify-ish.png?raw=true)
 
 ## Credits
 
 - Icons courtesy of: [Navidrome](https://www.navidrome.org/), [Vectornator](https://www.vectornator.io/icons), and @jicho
-
-## TODO
-
-- Artist Radio

etc/docker-compose.yaml

@@ -22,13 +22,13 @@ services:
       - "4534:4534"
     restart: unless-stopped
     environment:
-      BONOB_PORT: 4534
+      BNB_PORT: 4534
       # ip address of your machine running bonob
-      BONOB_URL: http://192.168.1.111:4534  
-      BONOB_SECRET: changeme
-      BONOB_SONOS_SERVICE_ID: 246 
-      BONOB_SONOS_AUTO_REGISTER: "true"
-      BONOB_SONOS_DEVICE_DISCOVERY: "true"
+      BNB_URL: http://192.168.1.111:4534  
+      BNB_SECRET: changeme
+      BNB_SONOS_SERVICE_ID: 246 
+      BNB_SONOS_AUTO_REGISTER: "true"
+      BNB_SONOS_DEVICE_DISCOVERY: "true"
       # ip address of one of your sonos devices
-      BONOB_SONOS_SEED_HOST: 192.168.1.121
-      BONOB_NAVIDROME_URL: http://navidrome:4533
+      BNB_SONOS_SEED_HOST: 192.168.1.121
+      BNB_SUBSONIC_URL: http://navidrome:4533

package.json

@@ -8,8 +8,12 @@
   "dependencies": {
     "@svrooij/sonos": "^2.4.0",
     "@types/express": "^4.17.13",
+    "@types/fs-extra": "^9.0.13",
+    "@types/jsonwebtoken": "^8.5.5",
+    "@types/jws": "^3.2.4",
     "@types/morgan": "^1.9.3",
     "@types/node": "^16.7.13",
+    "@types/randomstring": "^1.1.8",
     "@types/sharp": "^0.28.6",
     "@types/underscore": "^1.11.3",
     "@types/uuid": "^8.3.1",
@@ -18,29 +22,35 @@
     "eta": "^1.12.3",
     "express": "^4.17.1",
     "fp-ts": "^2.11.1",
+    "fs-extra": "^10.0.0",
+    "jsonwebtoken": "^8.5.1",
+    "jws": "^4.0.0",
     "libxmljs2": "^0.28.0",
     "morgan": "^1.10.0",
     "node-html-parser": "^4.1.4",
+    "randomstring": "^1.2.1",
     "sharp": "^0.29.1",
     "soap": "^0.42.0",
     "ts-md5": "^1.2.9",
     "typescript": "^4.4.2",
     "underscore": "^1.13.1",
+    "urn-lib": "^2.0.0",
     "uuid": "^8.3.2",
-    "winston": "^3.3.3",
-    "x2js": "^3.4.2"
+    "winston": "^3.3.3"
   },
   "devDependencies": {
     "@types/chai": "^4.2.21",
     "@types/jest": "^27.0.1",
     "@types/mocha": "^9.0.0",
     "@types/supertest": "^2.0.11",
+    "@types/tmp": "^0.2.1",
     "chai": "^4.3.4",
     "get-port": "^5.1.1",
     "image-js": "^0.33.0",
     "jest": "^27.1.0",
     "nodemon": "^2.0.12",
     "supertest": "^6.1.6",
+    "tmp": "^0.2.1",
     "ts-jest": "^27.0.5",
     "ts-mockito": "^2.6.1",
     "ts-node": "^10.2.1",
@@ -50,8 +60,8 @@
   "scripts": {
     "clean": "rm -Rf build node_modules",
     "build": "tsc",
-    "dev": "BONOB_ICON_FOREGROUND_COLOR=white BONOB_ICON_BACKGROUND_COLOR=darkgrey BONOB_SONOS_SERVICE_NAME=bonobDev BONOB_SONOS_DEVICE_DISCOVERY=true nodemon -V ./src/app.ts",
-    "devr": "BONOB_ICON_FOREGROUND_COLOR=white BONOB_ICON_BACKGROUND_COLOR=darkgrey BONOB_SONOS_SERVICE_NAME=bonobDev BONOB_SONOS_DEVICE_DISCOVERY=true BONOB_SONOS_AUTO_REGISTER=true nodemon -V ./src/app.ts",
+    "dev": "BNB_DEBUG=true BNB_SCROBBLE_TRACKS=false BNB_REPORT_NOW_PLAYING=false BNB_ICON_FOREGROUND_COLOR=white BNB_ICON_BACKGROUND_COLOR=darkgrey BNB_SONOS_SERVICE_NAME=bonobDev BNB_SONOS_DEVICE_DISCOVERY=true nodemon -V ./src/app.ts",
+    "devr": "BNB_DEBUG=true BNB_SCROBBLE_TRACKS=false BNB_REPORT_NOW_PLAYING=false BNB_ICON_FOREGROUND_COLOR=white BNB_ICON_BACKGROUND_COLOR=darkgrey BNB_SONOS_SERVICE_NAME=bonobDev BNB_SONOS_DEVICE_DISCOVERY=true BNB_SONOS_AUTO_REGISTER=true nodemon -V ./src/app.ts",
     "register-dev": "ts-node ./src/register.ts http://$(hostname):4534",
     "test": "jest",
     "gitinfo": "git describe --tags > .gitinfo"

src/Sonoswsdl-1.19.4-20190411.142401-3.wsdl

@@ -2059,7 +2059,7 @@
 
     <wsdl:service name="Sonos">
         <wsdl:port name="SonosSoap" binding="tns:SonosSoap">
-		<soap:address location="http://moapi.sonos.com/Test/TestService.php"/>
+		<soap:address location="/about"/>
         </wsdl:port>
     </wsdl:service>
 

src/access_tokens.ts

@@ -1,117 +0,0 @@
-import { Dayjs } from "dayjs";
-import { v4 as uuid } from "uuid";
-import crypto from "crypto";
-
-import { Encryption } from "./encryption";
-import logger from "./logger";
-import { Clock, SystemClock } from "./clock";
-
-type AccessToken = {
-  value: string;
-  authToken: string;
-  expiry: Dayjs;
-};
-
-export interface AccessTokens {
-  mint(authToken: string): string;
-  authTokenFor(value: string): string | undefined;
-}
-
-export class ExpiringAccessTokens implements AccessTokens {
-  tokens = new Map<string, AccessToken>();
-  clock: Clock;
-
-  constructor(clock: Clock = SystemClock) {
-    this.clock = clock;
-  }
-
-  mint(authToken: string): string {
-    this.clearOutExpired();
-    const accessToken = {
-      value: uuid(),
-      authToken,
-      expiry: this.clock.now().add(12, "hours"),
-    };
-    this.tokens.set(accessToken.value, accessToken);
-    return accessToken.value;
-  }
-
-  authTokenFor(value: string): string | undefined {
-    this.clearOutExpired();
-    return this.tokens.get(value)?.authToken;
-  }
-
-  clearOutExpired() {
-    Array.from(this.tokens.values())
-      .filter((it) => it.expiry.isBefore(this.clock.now()))
-      .forEach((expired) => {
-        this.tokens.delete(expired.value);
-      });
-  }
-
-  count = () => this.tokens.size;
-}
-
-export class EncryptedAccessTokens implements AccessTokens {
-  encryption: Encryption;
-
-  constructor(encryption: Encryption) {
-    this.encryption = encryption;
-  }
-
-  mint = (authToken: string): string =>
-    Buffer.from(JSON.stringify(this.encryption.encrypt(authToken))).toString(
-      "base64"
-    );
-
-  authTokenFor(value: string): string | undefined {
-    try {
-      return this.encryption.decrypt(
-        JSON.parse(Buffer.from(value, "base64").toString("ascii"))
-      );
-    } catch {
-      logger.warn("Failed to decrypt access token...");
-      return undefined;
-    }
-  }
-}
-
-export class AccessTokenPerAuthToken implements AccessTokens {
-  authTokenToAccessToken = new Map<string, string>();
-  accessTokenToAuthToken = new Map<string, string>();
-
-  mint = (authToken: string): string => {
-    if (this.authTokenToAccessToken.has(authToken)) {
-      return this.authTokenToAccessToken.get(authToken)!;
-    } else {
-      const accessToken = uuid();
-      this.authTokenToAccessToken.set(authToken, accessToken);
-      this.accessTokenToAuthToken.set(accessToken, authToken);
-      return accessToken;
-    }
-  };
-
-  authTokenFor = (value: string): string | undefined => this.accessTokenToAuthToken.get(value);
-}
-
-export const sha256 = (salt: string) => (authToken: string) => crypto
-  .createHash("sha256")
-  .update(`${authToken}${salt}`)
-  .digest("hex")
-
-export class InMemoryAccessTokens implements AccessTokens {
-  tokens = new Map<string, string>();
-  minter;
-
-  constructor(minter: (authToken: string) => string) {
-    this.minter = minter
-  }
-
-  mint = (authToken: string): string => {
-    const accessToken = this.minter(authToken);
-    this.tokens.set(accessToken, authToken);
-    return accessToken;
-  }
-
-  authTokenFor = (value: string): string | undefined => this.tokens.get(value);
-}

src/api_tokens.ts

@@ -0,0 +1,30 @@
+import crypto from "crypto";
+
+export interface APITokens {
+  mint(authToken: string): string;
+  authTokenFor(apiToken: string): string | undefined;
+}
+
+
+export const sha256 = (salt: string) => (value: string) => crypto
+  .createHash("sha256")
+  .update(`${value}${salt}`)
+  .digest("hex")
+
+
+export class InMemoryAPITokens implements APITokens {
+  tokens = new Map<string, string>();
+  minter;
+
+  constructor(minter: (authToken: string) => string = sha256('bonob')) {
+    this.minter = minter
+  }
+
+  mint = (authToken: string): string => {
+    const accessToken = this.minter(authToken);
+    this.tokens.set(accessToken, authToken);
+    return accessToken;
+  }
+
+  authTokenFor = (apiToken: string): string | undefined => this.tokens.get(apiToken);
+}

src/app.ts

@@ -2,18 +2,26 @@ import path from "path";
 import fs from "fs";
 import server from "./server";
 import logger from "./logger";
-import { appendMimeTypeToClientFor, DEFAULT, Navidrome } from "./navidrome";
-import encryption from "./encryption";
-import { InMemoryAccessTokens, sha256 } from "./access_tokens";
+
+import {
+  appendMimeTypeToClientFor,
+  axiosImageFetcher,
+  cachingImageFetcher,
+  DEFAULT,
+  Subsonic,
+} from "./subsonic";
+import { InMemoryAPITokens, sha256 } from "./api_tokens";
 import { InMemoryLinkCodes } from "./link_codes";
 import readConfig from "./config";
 import sonos, { bonobService } from "./sonos";
 import { MusicService } from "./music_service";
 import { SystemClock } from "./clock";
+import { JWTSmapiLoginTokens } from "./smapi_auth";
 
 const config = readConfig();
+const clock = SystemClock;
 
-logger.info(`Starting bonob with config ${JSON.stringify(config)}`);
+logger.info(`Starting bonob with config ${JSON.stringify({ ...config, secret: "*******" })}`);
 
 const bonob = bonobService(
   config.sonos.serviceName,
@@ -24,20 +32,25 @@ const bonob = bonobService(
 
 const sonosSystem = sonos(config.sonos.discovery);
 
-const streamUserAgent = config.navidrome.customClientsFor
-  ? appendMimeTypeToClientFor(config.navidrome.customClientsFor.split(","))
+const streamUserAgent = config.subsonic.customClientsFor
+  ? appendMimeTypeToClientFor(config.subsonic.customClientsFor.split(","))
   : DEFAULT;
 
-const navidrome = new Navidrome(
-  config.navidrome.url,
-  encryption(config.secret),
-  streamUserAgent
+const artistImageFetcher = config.subsonic.artistImageCache
+  ? cachingImageFetcher(config.subsonic.artistImageCache, axiosImageFetcher)
+  : axiosImageFetcher;
+
+const subsonic = new Subsonic(
+  config.subsonic.url,
+  streamUserAgent,
+  artistImageFetcher
 );
 
 const featureFlagAwareMusicService: MusicService = {
-  generateToken: navidrome.generateToken,
-  login: (authToken: string) =>
-    navidrome.login(authToken).then((library) => {
+  generateToken: subsonic.generateToken,
+  refreshToken: subsonic.refreshToken,
+  login: (serviceToken: string) =>
+    subsonic.login(serviceToken).then((library) => {
       return {
         ...library,
         scrobble: (id: string) => {
@@ -60,7 +73,9 @@ const featureFlagAwareMusicService: MusicService = {
 
 export const GIT_INFO = path.join(__dirname, "..", ".gitinfo");
 
-const version = fs.existsSync(GIT_INFO) ? fs.readFileSync(GIT_INFO).toString().trim() : "v??"
+const version = fs.existsSync(GIT_INFO)
+  ? fs.readFileSync(GIT_INFO).toString().trim()
+  : "v??";
 
 const app = server(
   sonosSystem,
@@ -69,12 +84,14 @@ const app = server(
   featureFlagAwareMusicService,
   {
     linkCodes: () => new InMemoryLinkCodes(),
-    accessTokens: () =>  new InMemoryAccessTokens(sha256(config.secret)),
-    clock: SystemClock,
+    apiTokens: () => new InMemoryAPITokens(sha256(config.secret)),
+    clock,
     iconColors: config.icons,
     applyContextPath: true,
     logRequests: true,
-    version
+    version,
+    smapiAuthTokens: new JWTSmapiLoginTokens(clock, config.secret, config.authTimeout),
+    externalImageResolver: artistImageFetcher
   }
 );
 
@@ -90,12 +107,12 @@ if (config.sonos.autoRegister) {
       );
     }
   });
-} else if(config.sonos.discovery.auto) {
-  sonosSystem.devices().then(devices => {
-    devices.forEach(d => {
-      logger.info(`Found device ${d.name}(${d.group}) @ ${d.ip}:${d.port}`)
-    })
-  })
+} else if (config.sonos.discovery.enabled) {
+  sonosSystem.devices().then((devices) => {
+    devices.forEach((d) => {
+      logger.info(`Found device ${d.name}(${d.group}) @ ${d.ip}:${d.port}`);
+    });
+  });
 }
 
 export default app;

src/b64.ts

@@ -0,0 +1,2 @@
+export const b64Encode = (value: string) => Buffer.from(value).toString("base64");
+export const b64Decode = (value: string) => Buffer.from(value, "base64").toString("ascii");

src/burn.ts

@@ -0,0 +1,90 @@
+import _ from "underscore";
+import { createUrnUtil } from "urn-lib";
+import randomstring from "randomstring";
+
+import jwsEncryption from "./encryption";
+
+const BURN = createUrnUtil("bnb", {
+  components: ["system", "resource"],
+  separator: ":",
+  allowEmpty: false,
+});
+
+export type BUrn = {
+  system: string;
+  resource: string;
+};
+
+const DEFAULT_FORMAT_OPTS = {
+  shorthand: false,
+  encrypt: false,
+}
+
+const SHORTHAND_MAPPINGS: Record<string, string> = {
+  "internal" : "i",
+  "external": "e",
+  "subsonic": "s",
+  "navidrome": "n",
+  "encrypted": "x"
+}
+const REVERSE_SHORTHAND_MAPPINGS: Record<string, string> = Object.keys(SHORTHAND_MAPPINGS).reduce((ret, key) => {
+  ret[SHORTHAND_MAPPINGS[key] as unknown as string] = key;
+  return ret;
+}, {} as Record<string, string>)
+if(SHORTHAND_MAPPINGS.length != REVERSE_SHORTHAND_MAPPINGS.length) {
+  throw `Invalid SHORTHAND_MAPPINGS, must be duplicate!`
+}
+
+export const BURN_SALT = randomstring.generate(5);
+const encryptor = jwsEncryption(BURN_SALT);
+
+export const format = (
+  burn: BUrn,
+  opts: Partial<{ shorthand: boolean; encrypt: boolean }> = {}
+): string => {
+  const o = { ...DEFAULT_FORMAT_OPTS, ...opts }
+  let toBurn = burn;
+  if(o.shorthand) {
+    toBurn = {
+      ...toBurn,
+      system: SHORTHAND_MAPPINGS[toBurn.system] || toBurn.system
+    }
+  }
+  if(o.encrypt) {
+    const encryptedToBurn = {
+      system: "encrypted",
+      resource: encryptor.encrypt(BURN.format(toBurn))
+    }
+    return format(encryptedToBurn, { ...opts, encrypt: false })
+  } else {
+    return BURN.format(toBurn);
+  }
+};
+
+export const formatForURL = (burn: BUrn) => {
+  if(burn.system == "external") return format(burn, { shorthand: true, encrypt: true })
+  else return format(burn, { shorthand: true })
+}
+
+export const parse = (burn: string): BUrn => {
+  const result = BURN.parse(burn)!;
+  const validationErrors = BURN.validate(result) || [];
+  if (validationErrors.length > 0) {
+    throw new Error(`Invalid burn: '${burn}'`);
+  }
+  const system = result.system as string;
+  const x = {
+    system: REVERSE_SHORTHAND_MAPPINGS[system] || system,
+    resource: result.resource as string,
+  };
+  if(x.system == "encrypted") {
+    return parse(encryptor.decrypt(x.resource));
+  } else {
+    return x;
+  }
+}
+
+export function assertSystem(urn: BUrn, system: string): BUrn {
+  if (urn.system != system) throw `Unsupported urn: '${format(urn)}'`;
+  else return urn;
+}

src/clock.ts

@@ -14,3 +14,15 @@ export interface Clock {
 }
 
 export const SystemClock = { now: () => dayjs() };
+
+export class FixedClock implements Clock {
+  time: Dayjs;
+  
+  constructor(time: Dayjs = dayjs()) {
+    this.time = time;
+  }
+
+  add = (t: number, unit: dayjs.UnitTypeShort) => this.time = this.time.add(t, unit)
+
+  now = () => this.time;
+}

src/config.ts

@@ -2,56 +2,94 @@ import { hostname } from "os";
 import logger from "./logger";
 import url from "./url_builder";
 
+export const WORD = /^\w+$/;
+export const COLOR = /^#?\w+$/;
+
+type EnvVarOpts = {
+  default: string | undefined;
+  legacy: string[] | undefined;
+  validationPattern: RegExp | undefined;
+};
+
+export function envVar(
+  name: string,
+  opts: Partial<EnvVarOpts> = {
+    default: undefined,
+    legacy: undefined,
+    validationPattern: undefined,
+  }
+) {
+  const result = [name, ...(opts.legacy || [])]
+    .map((it) => ({ key: it, value: process.env[it] }))
+    .find((it) => it.value);
+
+  if (
+    result &&
+    result.value && 
+    opts.validationPattern &&
+    !result.value.match(opts.validationPattern)
+  ) {
+    throw `Invalid value specified for '${name}', must match ${opts.validationPattern}`;
+  }
+
+  if(result && result.value && result.key != name) {
+    logger.warn(`Configuration key '${result.key}' is deprecated, replace with '${name}'`)
+  }
+
+  return result?.value || opts.default;
+}
+
+export const bnbEnvVar = (key: string, opts: Partial<EnvVarOpts> = {}) =>
+  envVar(`BNB_${key}`, {
+    ...opts,
+    legacy: [`BONOB_${key}`, ...(opts.legacy || [])],
+  });
+
 export default function () {
-  const port = +(process.env["BONOB_PORT"] || 4534);
-  const bonobUrl =
-    process.env["BONOB_URL"] ||
-    process.env["BONOB_WEB_ADDRESS"] ||
-    `http://${hostname()}:${port}`;
+  const port = +bnbEnvVar("PORT", { default: "4534" })!;
+  const bonobUrl = bnbEnvVar("URL", {
+    legacy: ["BONOB_WEB_ADDRESS"],
+    default: `http://${hostname()}:${port}`,
+  })!;
 
   if (bonobUrl.match("localhost")) {
     logger.error(
-      "BONOB_URL containing localhost is almost certainly incorrect, sonos devices will not be able to communicate with bonob using localhost, please specify either public IP or DNS entry"
+      "BNB_URL containing localhost is almost certainly incorrect, sonos devices will not be able to communicate with bonob using localhost, please specify either public IP or DNS entry"
     );
     process.exit(1);
   }
 
-  const wordFrom = (envVar: string) => {
-    const value = process.env[envVar];
-    if (value && value != "") {
-      if (value.match(/^\w+$/)) return value;
-      else throw `Invalid color specified for ${envVar}`;
-    } else {
-      return undefined;
-    }
-  };
-
   return {
     port,
     bonobUrl: url(bonobUrl),
-    secret: process.env["BONOB_SECRET"] || "bonob",
+    secret: bnbEnvVar("SECRET", { default: "bonob" })!,
+    authTimeout: bnbEnvVar("AUTH_TIMEOUT", { default: "1h" })!,
     icons: {
-      foregroundColor: wordFrom("BONOB_ICON_FOREGROUND_COLOR"),
-      backgroundColor: wordFrom("BONOB_ICON_BACKGROUND_COLOR"),
+      foregroundColor: bnbEnvVar("ICON_FOREGROUND_COLOR", {
+        validationPattern: COLOR,
+      }),
+      backgroundColor: bnbEnvVar("ICON_BACKGROUND_COLOR", {
+        validationPattern: COLOR,
+      }),
     },
     sonos: {
-      serviceName: process.env["BONOB_SONOS_SERVICE_NAME"] || "bonob",
+      serviceName: bnbEnvVar("SONOS_SERVICE_NAME", { default: "bonob" })!,
       discovery: {
-        auto:
-          (process.env["BONOB_SONOS_DEVICE_DISCOVERY"] || "true") == "true",
-        seedHost: process.env["BONOB_SONOS_SEED_HOST"],
+        enabled:
+          bnbEnvVar("SONOS_DEVICE_DISCOVERY", { default: "true" }) == "true",
+        seedHost: bnbEnvVar("SONOS_SEED_HOST"),
       },
       autoRegister:
-        (process.env["BONOB_SONOS_AUTO_REGISTER"] || "false") == "true",
-      sid: Number(process.env["BONOB_SONOS_SERVICE_ID"] || "246"),
+        bnbEnvVar("SONOS_AUTO_REGISTER", { default: "false" }) == "true",
+      sid: Number(bnbEnvVar("SONOS_SERVICE_ID", { default: "246" })),
     },
-    navidrome: {
-      url: process.env["BONOB_NAVIDROME_URL"] || `http://${hostname()}:4533`,
-      customClientsFor:
-        process.env["BONOB_NAVIDROME_CUSTOM_CLIENTS"] || undefined,
+    subsonic: {
+      url: bnbEnvVar("SUBSONIC_URL", { legacy: ["BONOB_NAVIDROME_URL"], default: `http://${hostname()}:4533` })!,
+      customClientsFor: bnbEnvVar("SUBSONIC_CUSTOM_CLIENTS", { legacy: ["BONOB_NAVIDROME_CUSTOM_CLIENTS"] }),
+      artistImageCache: bnbEnvVar("SUBSONIC_ARTIST_IMAGE_CACHE"),
     },
-    scrobbleTracks: (process.env["BONOB_SCROBBLE_TRACKS"] || "true") == "true",
+    scrobbleTracks: bnbEnvVar("SCROBBLE_TRACKS", { default: "true" }) == "true",
     reportNowPlaying:
-      (process.env["BONOB_REPORT_NOW_PLAYING"] || "true") == "true",
+      bnbEnvVar("REPORT_NOW_PLAYING", { default: "true" }) == "true",
   };
 }

src/encryption.ts

@@ -1,33 +1,65 @@
-import { createCipheriv, createDecipheriv, randomBytes, createHash } from "crypto";
+import {
+  createCipheriv,
+  createDecipheriv,
+  randomBytes,
+  createHash,
+} from "crypto";
 
-const ALGORITHM = "aes-256-cbc"
+import jws from "jws";
+
+const ALGORITHM = "aes-256-cbc";
 const IV = randomBytes(16);
 
+
 export type Hash = {
-  iv: string,
-  encryptedData: string
-}
+  iv: string;
+  encryptedData: string;
+};
 
 export type Encryption = {
-  encrypt: (value:string) => Hash
-  decrypt: (hash: Hash) => string
-}
+  encrypt: (value: string) => string;
+  decrypt: (value: string) => string;
+};
 
-const encryption = (secret: string): Encryption => {
-  const key = createHash('sha256').update(String(secret)).digest('base64').substr(0, 32);
+export const jwsEncryption = (secret: string): Encryption => {
   return {
-    encrypt: (value: string) => {
-      const cipher = createCipheriv(ALGORITHM, key, IV);
-      return { 
-        iv: IV.toString("hex"), 
-        encryptedData: Buffer.concat([cipher.update(value), cipher.final()]).toString("hex") 
-      };
-    },
-    decrypt: (hash: Hash) => {
-      const decipher = createDecipheriv(ALGORITHM, key, Buffer.from(hash.iv, 'hex'));
-      return Buffer.concat([decipher.update(Buffer.from(hash.encryptedData, 'hex')), decipher.final()]).toString();
-    }
+    encrypt: (value: string) => jws.sign({
+      header: { alg: 'HS256' },
+      payload: value,
+      secret: secret,
+    }),
+    decrypt: (value: string) => jws.decode(value).payload
   }
 }
 
-export default encryption;
+export const cryptoEncryption = (secret: string): Encryption => {
+  const key = createHash("sha256")
+    .update(String(secret))
+    .digest("base64")
+    .substr(0, 32);
+  return {
+    encrypt: (value: string) => {
+      const cipher = createCipheriv(ALGORITHM, key, IV);
+      return `${IV.toString("hex")}.${Buffer.concat([
+        cipher.update(value),
+        cipher.final(),
+      ]).toString("hex")}`;
+    },
+    decrypt: (value: string) => {
+      const parts = value.split(".");
+      if(parts.length != 2) throw `Invalid value to decrypt`;
+
+      const decipher = createDecipheriv(
+        ALGORITHM,
+        key,
+        Buffer.from(parts[0]!, "hex")
+      );
+      return Buffer.concat([
+        decipher.update(Buffer.from(parts[1]!, "hex")),
+        decipher.final(),
+      ]).toString();
+    },
+  };
+};
+
+export default jwsEncryption;

src/i8n.ts

@@ -12,7 +12,7 @@ export type KEY =
   | "playlists"
   | "genres"
   | "random"
-  | "starred"
+  | "topRated"
   | "recentlyAdded"
   | "recentlyPlayed"
   | "mostPlayed"
@@ -37,18 +37,25 @@ export type KEY =
   | "invalidLinkCode"
   | "loginSuccessful"
   | "loginFailed" 
-  | "noSonosDevices";
+  | "noSonosDevices" 
+  | "favourites"
+  | "LOVE"
+  | "LOVE_SUCCESS"
+  | "STAR" 
+  | "UNSTAR"
+  | "STAR_SUCCESS"
+  | "UNSTAR_SUCCESS";
 
 const translations: Record<SUPPORTED_LANG, Record<KEY, string>> = {
   "en-US": {
-    AppLinkMessage: "Linking sonos with $BONOB_SONOS_SERVICE_NAME",
+    AppLinkMessage: "Linking sonos with $BNB_SONOS_SERVICE_NAME",
     artists: "Artists",
     albums: "Albums",
     tracks: "Tracks",
     playlists: "Playlists",
     genres: "Genres",
     random: "Random",
-    starred: "Starred",
+    topRated: "Top Rated",
     recentlyAdded: "Recently added",
     recentlyPlayed: "Recently played",
     mostPlayed: "Most played",
@@ -62,7 +69,7 @@ const translations: Record<SUPPORTED_LANG, Record<KEY, string>> = {
     devices: "Devices",
     services: "Services",
     login: "Login",
-    logInToBonob: "Log in to $BONOB_SONOS_SERVICE_NAME",
+    logInToBonob: "Log in to $BNB_SONOS_SERVICE_NAME",
     username: "Username",
     password: "Password",
     successfullyRegistered: "Successfully registered",
@@ -73,16 +80,23 @@ const translations: Record<SUPPORTED_LANG, Record<KEY, string>> = {
     loginSuccessful: "Login successful!",
     loginFailed: "Login failed!",
     noSonosDevices: "No sonos devices",
+    favourites: "Favourites",
+    STAR: "Star",
+    UNSTAR: "Un-star",
+    STAR_SUCCESS: "Track starred",
+    UNSTAR_SUCCESS: "Track un-starred",
+    LOVE: "Love",
+    LOVE_SUCCESS: "Track loved"
   },
   "nl-NL": {
-    AppLinkMessage: "Sonos koppelen aan $BONOB_SONOS_SERVICE_NAME",
+    AppLinkMessage: "Sonos koppelen aan $BNB_SONOS_SERVICE_NAME",
     artists: "Artiesten",
     albums: "Albums",
     tracks: "Nummers",
     playlists: "Afspeellijsten",
     genres: "Genres",
     random: "Willekeurig",
-    starred: "Favorieten",
+    topRated: "Best beoordeeld",
     recentlyAdded: "Onlangs toegevoegd",
     recentlyPlayed: "Onlangs afgespeeld",
     mostPlayed: "Meest afgespeeld",
@@ -96,7 +110,7 @@ const translations: Record<SUPPORTED_LANG, Record<KEY, string>> = {
     devices: "Apparaten",
     services: "Services",
     login: "Inloggen",
-    logInToBonob: "Login op $BONOB_SONOS_SERVICE_NAME",
+    logInToBonob: "Login op $BNB_SONOS_SERVICE_NAME",
     username: "Gebruikersnaam",
     password: "Wachtwoord",
     successfullyRegistered: "Registratie geslaagd",
@@ -107,6 +121,13 @@ const translations: Record<SUPPORTED_LANG, Record<KEY, string>> = {
     loginSuccessful: "Inloggen gelukt!",
     loginFailed: "Inloggen mislukt!",
     noSonosDevices: "Geen Sonos-apparaten",
+    favourites: "Favorieten",
+    STAR: "Ster ",
+    UNSTAR: "Een ster",
+    STAR_SUCCESS: "Nummer met ster",
+    UNSTAR_SUCCESS: "Track zonder ster",
+    LOVE: "Liefde",
+    LOVE_SUCCESS: "Volg geliefd"
   },
 };
 
@@ -151,7 +172,7 @@ export default (serviceName: string): I8N =>
       translations["en-US"];
     return (key: KEY) => {
       const value = langToUse[key]?.replace(
-        "$BONOB_SONOS_SERVICE_NAME",
+        "$BNB_SONOS_SERVICE_NAME",
         serviceName
       );
       if (value) return value;

src/icon.ts

@@ -166,7 +166,7 @@ export type ICON =
   | "playlists"
   | "genres"
   | "random"
-  | "starred"
+  | "topRated"
   | "recentlyAdded"
   | "recentlyPlayed"
   | "mostPlayed"
@@ -225,7 +225,10 @@ export type ICON =
   | "skywalker"
   | "leia"
   | "r2d2"
-  | "yoda";
+  | "yoda" 
+  | "heart"
+  | "star" 
+  | "solidStar";
 
 const iconFrom = (name: string) =>
   new SvgIcon(
@@ -241,7 +244,7 @@ export const ICONS: Record<ICON, SvgIcon> = {
   playlists: iconFrom("navidrome-playlists.svg"),
   genres: iconFrom("Theatre-Mask-111172.svg"),
   random: iconFrom("navidrome-random.svg"),
-  starred: iconFrom("navidrome-topRated.svg"),
+  topRated: iconFrom("navidrome-topRated.svg"),
   recentlyAdded: iconFrom("navidrome-recentlyAdded.svg"),
   recentlyPlayed: iconFrom("navidrome-recentlyPlayed.svg"),
   mostPlayed: iconFrom("navidrome-mostPlayed.svg"),
@@ -300,6 +303,9 @@ export const ICONS: Record<ICON, SvgIcon> = {
   leia: iconFrom("Princess-Leia-68568.svg"),
   r2d2: iconFrom("R2-D2-39423.svg"),
   yoda: iconFrom("Yoda-68107.svg"),
+  heart: iconFrom("Heart-85038.svg"),
+  star: iconFrom("Star-16101.svg"),
+  solidStar: iconFrom("Star-43879.svg")
 };
 
 export const STAR_WARS = [ICONS.c3po, ICONS.chewy, ICONS.darth, ICONS.skywalker, ICONS.leia, ICONS.r2d2, ICONS.yoda];

src/link_codes.ts

@@ -2,7 +2,7 @@ import { v4 as uuid } from 'uuid';
 
 
 export type Association = {
-  authToken: string
+  serviceToken: string
   userId: string
   nickname: string  
 }

src/music_service.ts

@@ -1,48 +1,29 @@
+import { BUrn } from "./burn";
+import { taskEither as TE } from "fp-ts";
+
 export type Credentials = { username: string; password: string };
 
-export function isSuccess(
-  authResult: AuthSuccess | AuthFailure
-): authResult is AuthSuccess {
-  return (authResult as AuthSuccess).authToken !== undefined;
-}
-
-export function isFailure(
-  authResult: any | AuthFailure
-): authResult is AuthFailure {
-  return (authResult as AuthFailure).message !== undefined;
-}
-
 export type AuthSuccess = {
-  authToken: string;
+  serviceToken: string;
   userId: string;
   nickname: string;
 };
 
-export type AuthFailure = {
-  message: string;
+export class AuthFailure extends Error {
+  constructor(message: string) {
+    super(message);
+  }
 };
 
 export type ArtistSummary = {
-  id: string;
+  id: string | undefined;
   name: string;
-};
-
-export type Images = {
-  small: string | undefined;
-  medium: string | undefined;
-  large: string | undefined;
-};
-
-export const NO_IMAGES: Images = {
-  small: undefined,
-  medium: undefined,
-  large: undefined,
+  image: BUrn | undefined;
 };
 
 export type SimilarArtist = ArtistSummary & { inLibrary: boolean };
 
 export type Artist = ArtistSummary & {
-  image: Images
   albums: AlbumSummary[];
   similarArtists: SimilarArtist[]
 };
@@ -52,9 +33,10 @@ export type AlbumSummary = {
   name: string;
   year: string | undefined;
   genre: Genre | undefined;
+  coverArt: BUrn | undefined;
 
-  artistName: string;
-  artistId: string;
+  artistName: string | undefined;
+  artistId: string | undefined;
 };
 
 export type Album = AlbumSummary & {};
@@ -64,6 +46,11 @@ export type Genre = {
   id: string;
 }
 
+export type Rating = {
+  love: boolean;
+  stars: number;
+}
+
 export type Track = {
   id: string;
   name: string;
@@ -71,8 +58,10 @@ export type Track = {
   duration: number;
   number: number | undefined;
   genre: Genre | undefined;
+  coverArt: BUrn | undefined;
   album: AlbumSummary;
   artist: ArtistSummary;
+  rating: Rating;
 };
 
 export type Paging = {
@@ -99,7 +88,7 @@ export const asResult = <T>([results, total]: [T[], number]) => ({
 
 export type ArtistQuery = Paging;
 
-export type AlbumQueryType = 'alphabeticalByArtist' | 'alphabeticalByName' | 'byGenre' | 'random' | 'recent' | 'frequent' | 'newest' | 'starred';
+export type AlbumQueryType = 'alphabeticalByArtist' | 'alphabeticalByName' | 'byGenre' | 'random' | 'recentlyPlayed' | 'mostPlayed' | 'recentlyAdded' | 'favourited' | 'starred';
 
 export type AlbumQuery = Paging & {
   type: AlbumQueryType;
@@ -109,6 +98,7 @@ export type AlbumQuery = Paging & {
 export const artistToArtistSummary = (it: Artist): ArtistSummary => ({
   id: it.id,
   name: it.name,
+  image: it.image
 });
 
 export const albumToAlbumSummary = (it: Album): AlbumSummary => ({
@@ -118,6 +108,7 @@ export const albumToAlbumSummary = (it: Album): AlbumSummary => ({
   genre: it.genre,
   artistName: it.artistName,
   artistId: it.artistId,
+  coverArt: it.coverArt
 });
 
 export const playlistToPlaylistSummary = (it: Playlist): PlaylistSummary => ({
@@ -155,8 +146,9 @@ export const asArtistAlbumPairs = (artists: Artist[]): [Artist, Album][] =>
   );
 
 export interface MusicService {
-  generateToken(credentials: Credentials): Promise<AuthSuccess | AuthFailure>;
-  login(authToken: string): Promise<MusicLibrary>;
+  generateToken(credentials: Credentials): TE.TaskEither<AuthFailure, AuthSuccess>;
+  refreshToken(serviceToken: string): TE.TaskEither<AuthFailure, AuthSuccess>;
+  login(serviceToken: string): Promise<MusicLibrary>;
 }
 
 export interface MusicLibrary {
@@ -174,7 +166,8 @@ export interface MusicLibrary {
     trackId: string;
     range: string | undefined;
   }): Promise<TrackStream>;
-  coverArt(id: string, type: "album" | "artist", size?: number): Promise<CoverArt | undefined>;
+  rate(trackId: string, rating: Rating): Promise<boolean>;
+  coverArt(coverArtURN: BUrn, size?: number): Promise<CoverArt | undefined>;
   nowPlaying(id: string): Promise<boolean>
   scrobble(id: string): Promise<boolean>
   searchArtists(query: string): Promise<ArtistSummary[]>;

src/navidrome.ts

@@ -1,798 +0,0 @@
-import { option as O } from "fp-ts";
-import * as A from "fp-ts/Array";
-import { ordString } from "fp-ts/lib/Ord";
-import { pipe } from "fp-ts/lib/function";
-import { Md5 } from "ts-md5/dist/md5";
-import {
-  Credentials,
-  MusicService,
-  Album,
-  Artist,
-  ArtistSummary,
-  Result,
-  slice2,
-  AlbumQuery,
-  ArtistQuery,
-  MusicLibrary,
-  Images,
-  AlbumSummary,
-  Genre,
-  Track,
-} from "./music_service";
-import X2JS from "x2js";
-import sharp from "sharp";
-import _, { pick } from "underscore";
-
-import axios, { AxiosRequestConfig } from "axios";
-import { Encryption } from "./encryption";
-import randomString from "./random_string";
-
-export const BROWSER_HEADERS = {
-  accept:
-    "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
-  "accept-encoding": "gzip, deflate, br",
-  "accept-language": "en-GB,en;q=0.5",
-  "upgrade-insecure-requests": "1",
-  "user-agent":
-    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0",
-};
-
-export const t = (password: string, s: string) =>
-  Md5.hashStr(`${password}${s}`);
-
-export const t_and_s = (password: string) => {
-  const s = randomString();
-  return {
-    t: t(password, s),
-    s,
-  };
-};
-
-export const DODGY_IMAGE_NAME = "2a96cbd8b46e442fc41c2b86b821562f.png";
-
-export const isDodgyImage = (url: string) => url.endsWith(DODGY_IMAGE_NAME);
-
-export const validate = (url: string | undefined) =>
-  url && !isDodgyImage(url) ? url : undefined;
-
-export type SubconicEnvelope = {
-  "subsonic-response": SubsonicResponse;
-};
-
-export type SubsonicResponse = {
-  _status: string;
-};
-
-export type album = {
-  _id: string;
-  _name: string;
-  _genre: string | undefined;
-  _year: string | undefined;
-  _coverArt: string | undefined;
-  _artist: string;
-  _artistId: string;
-};
-
-export type artistSummary = {
-  _id: string;
-  _name: string;
-  _albumCount: string;
-  _artistImageUrl: string | undefined;
-};
-
-export type GetArtistsResponse = SubsonicResponse & {
-  artists: {
-    index: {
-      artist: artistSummary[];
-      _name: string;
-    }[];
-  };
-};
-
-export type GetAlbumListResponse = SubsonicResponse & {
-  albumList2: {
-    album: album[];
-  };
-};
-
-export type genre = {
-  _songCount: string;
-  _albumCount: string;
-  __text: string;
-};
-
-export type GetGenresResponse = SubsonicResponse & {
-  genres: {
-    genre: genre[];
-  };
-};
-
-export type SubsonicError = SubsonicResponse & {
-  error: {
-    _code: string;
-    _message: string;
-  };
-};
-
-export type artistInfo = {
-  biography: string | undefined;
-  musicBrainzId: string | undefined;
-  lastFmUrl: string | undefined;
-  smallImageUrl: string | undefined;
-  mediumImageUrl: string | undefined;
-  largeImageUrl: string | undefined;
-  similarArtist: artistSummary[];
-};
-
-export type ArtistInfo = {
-  image: Images;
-  similarArtist: (ArtistSummary & { inLibrary: boolean })[];
-};
-
-export type GetArtistInfoResponse = SubsonicResponse & {
-  artistInfo2: artistInfo;
-};
-
-export type GetArtistResponse = SubsonicResponse & {
-  artist: artistSummary & {
-    album: album[];
-  };
-};
-
-export type song = {
-  _id: string;
-  _parent: string;
-  _title: string;
-  _album: string;
-  _artist: string;
-  _track: string | undefined;
-  _genre: string;
-  _coverArt: string;
-  _created: "2004-11-08T23:36:11";
-  _duration: string | undefined;
-  _bitRate: "128";
-  _suffix: "mp3";
-  _contentType: string;
-  _albumId: string;
-  _artistId: string;
-  _type: "music";
-};
-
-export type GetAlbumResponse = {
-  album: album & {
-    song: song[];
-  };
-};
-
-export type playlist = {
-  _id: string;
-  _name: string;
-};
-
-export type entry = {
-  _id: string;
-  _parent: string;
-  _title: string;
-  _album: string;
-  _artist: string;
-  _track: string;
-  _year: string;
-  _genre: string;
-  _contentType: string;
-  _duration: string;
-  _albumId: string;
-  _artistId: string;
-};
-
-export type GetPlaylistResponse = {
-  playlist: {
-    _id: string;
-    _name: string;
-    entry: entry[];
-  };
-};
-
-export type GetPlaylistsResponse = {
-  playlists: { playlist: playlist[] };
-};
-
-export type GetSimilarSongsResponse = {
-  similarSongs2: { song: song[] };
-};
-
-export type GetTopSongsResponse = {
-  topSongs: { song: song[] };
-};
-
-export type GetSongResponse = {
-  song: song;
-};
-
-export type Search3Response = SubsonicResponse & {
-  searchResult3: {
-    artist: artistSummary[];
-    album: album[];
-    song: song[];
-  };
-};
-
-export function isError(
-  subsonicResponse: SubsonicResponse
-): subsonicResponse is SubsonicError {
-  return (subsonicResponse as SubsonicError).error !== undefined;
-}
-
-export type IdName = {
-  id: string;
-  name: string;
-};
-
-export type getAlbumListParams = {
-  type: string;
-  size?: number;
-  offet?: number;
-  fromYear?: string;
-  toYear?: string;
-  genre?: string;
-};
-
-export const MAX_ALBUM_LIST = 500;
-
-const asTrack = (album: Album, song: song) => ({
-  id: song._id,
-  name: song._title,
-  mimeType: song._contentType,
-  duration: parseInt(song._duration || "0"),
-  number: parseInt(song._track || "0"),
-  genre: maybeAsGenre(song._genre),
-  album,
-  artist: {
-    id: song._artistId,
-    name: song._artist,
-  },
-});
-
-const asAlbum = (album: album) => ({
-  id: album._id,
-  name: album._name,
-  year: album._year,
-  genre: maybeAsGenre(album._genre),
-  artistId: album._artistId,
-  artistName: album._artist,
-});
-
-export const asGenre = (genreName: string) => ({
-  id: genreName,
-  name: genreName,
-});
-
-const maybeAsGenre = (genreName: string | undefined): Genre | undefined =>
-  pipe(
-    genreName,
-    O.fromNullable,
-    O.map(asGenre),
-    O.getOrElseW(() => undefined)
-  );
-
-export type StreamClientApplication = (track: Track) => string;
-
-export const DEFAULT_CLIENT_APPLICATION = "bonob";
-export const USER_AGENT = "bonob";
-
-export const DEFAULT: StreamClientApplication = (_: Track) =>
-  DEFAULT_CLIENT_APPLICATION;
-
-export function appendMimeTypeToClientFor(mimeTypes: string[]) {
-  return (track: Track) =>
-    mimeTypes.includes(track.mimeType) ? `bonob+${track.mimeType}` : "bonob";
-}
-
-export const asURLSearchParams = (q: any) => {
-  const urlSearchParams = new URLSearchParams();
-  Object.keys(q).forEach((k) => {
-    _.flatten([q[k]]).forEach((v) => {
-      urlSearchParams.append(k, `${v}`);
-    });
-  });
-  return urlSearchParams;
-};
-
-export class Navidrome implements MusicService {
-  url: string;
-  encryption: Encryption;
-  streamClientApplication: StreamClientApplication;
-
-  constructor(
-    url: string,
-    encryption: Encryption,
-    streamClientApplication: StreamClientApplication = DEFAULT
-  ) {
-    this.url = url;
-    this.encryption = encryption;
-    this.streamClientApplication = streamClientApplication;
-  }
-
-  get = async (
-    { username, password }: Credentials,
-    path: string,
-    q: {} = {},
-    config: AxiosRequestConfig | undefined = {}
-  ) =>
-    axios
-      .get(`${this.url}${path}`, {
-        params: asURLSearchParams({
-          u: username,
-          v: "1.16.1",
-          c: DEFAULT_CLIENT_APPLICATION,
-          ...t_and_s(password),
-          ...q,
-        }),
-        headers: {
-          "User-Agent": USER_AGENT,
-        },
-        ...config,
-      })
-      .then((response) => {
-        if (response.status != 200 && response.status != 206) {
-          throw `Navidrome failed with a ${response.status || "no!"} status`;
-        } else return response;
-      });
-
-  getJSON = async <T>(
-    { username, password }: Credentials,
-    path: string,
-    q: {} = {}
-  ): Promise<T> =>
-    this.get({ username, password }, path, q)
-      .then(
-        (response) =>
-          new X2JS({
-            arrayAccessFormPaths: [
-              "subsonic-response.album.song",
-              "subsonic-response.albumList2.album",
-              "subsonic-response.artist.album",
-              "subsonic-response.artists.index",
-              "subsonic-response.artists.index.artist",
-              "subsonic-response.artistInfo2.similarArtist",
-              "subsonic-response.genres.genre",
-              "subsonic-response.playlist.entry",
-              "subsonic-response.playlists.playlist",
-              "subsonic-response.searchResult3.album",
-              "subsonic-response.searchResult3.artist",
-              "subsonic-response.searchResult3.song",
-              "subsonic-response.similarSongs2.song",
-              "subsonic-response.topSongs.song",
-            ],
-          }).xml2js(response.data) as SubconicEnvelope
-      )
-      .then((json) => json["subsonic-response"])
-      .then((json) => {
-        if (isError(json)) throw `Navidrome error:${json.error._message}`;
-        else return json as unknown as T;
-      });
-
-  generateToken = async (credentials: Credentials) =>
-    this.getJSON(credentials, "/rest/ping.view")
-      .then(() => ({
-        authToken: Buffer.from(
-          JSON.stringify(this.encryption.encrypt(JSON.stringify(credentials)))
-        ).toString("base64"),
-        userId: credentials.username,
-        nickname: credentials.username,
-      }))
-      .catch((e) => ({ message: `${e}` }));
-
-  parseToken = (token: string): Credentials =>
-    JSON.parse(
-      this.encryption.decrypt(
-        JSON.parse(Buffer.from(token, "base64").toString("ascii"))
-      )
-    );
-
-  getArtists = (
-    credentials: Credentials
-  ): Promise<(IdName & { albumCount: number })[]> =>
-    this.getJSON<GetArtistsResponse>(credentials, "/rest/getArtists")
-      .then((it) => (it.artists.index || []).flatMap((it) => it.artist || []))
-      .then((artists) =>
-        artists.map((artist) => ({
-          id: artist._id,
-          name: artist._name,
-          albumCount: Number.parseInt(artist._albumCount),
-        }))
-      );
-
-  getArtistInfo = (credentials: Credentials, id: string): Promise<ArtistInfo> =>
-    this.getJSON<GetArtistInfoResponse>(credentials, "/rest/getArtistInfo2", {
-      id,
-      count: 50,
-      includeNotPresent: true,
-    }).then((it) => ({
-      image: {
-        small: validate(it.artistInfo2.smallImageUrl),
-        medium: validate(it.artistInfo2.mediumImageUrl),
-        large: validate(it.artistInfo2.largeImageUrl),
-      },
-      similarArtist: (it.artistInfo2.similarArtist || []).map((artist) => ({
-        id: artist._id,
-        name: artist._name,
-        inLibrary: artist._id != "-1",
-      })),
-    }));
-
-  getAlbum = (credentials: Credentials, id: string): Promise<Album> =>
-    this.getJSON<GetAlbumResponse>(credentials, "/rest/getAlbum", { id })
-      .then((it) => it.album)
-      .then((album) => ({
-        id: album._id,
-        name: album._name,
-        year: album._year,
-        genre: maybeAsGenre(album._genre),
-        artistId: album._artistId,
-        artistName: album._artist,
-      }));
-
-  getArtist = (
-    credentials: Credentials,
-    id: string
-  ): Promise<IdName & { albums: AlbumSummary[] }> =>
-    this.getJSON<GetArtistResponse>(credentials, "/rest/getArtist", {
-      id,
-    })
-      .then((it) => it.artist)
-      .then((it) => ({
-        id: it._id,
-        name: it._name,
-        albums: (it.album || []).map((album) => ({
-          id: album._id,
-          name: album._name,
-          year: album._year,
-          genre: maybeAsGenre(album._genre),
-          artistId: it._id,
-          artistName: it._name,
-        })),
-      }));
-
-  getArtistWithInfo = (credentials: Credentials, id: string) =>
-    Promise.all([
-      this.getArtist(credentials, id),
-      this.getArtistInfo(credentials, id),
-    ]).then(([artist, artistInfo]) => ({
-      id: artist.id,
-      name: artist.name,
-      image: artistInfo.image,
-      albums: artist.albums,
-      similarArtists: artistInfo.similarArtist,
-    }));
-
-  getCoverArt = (credentials: Credentials, id: string, size?: number) =>
-    this.get(credentials, "/rest/getCoverArt", size ? { id, size } : { id }, {
-      headers: { "User-Agent": "bonob" },
-      responseType: "arraybuffer",
-    });
-
-  getTrack = (credentials: Credentials, id: string) =>
-    this.getJSON<GetSongResponse>(credentials, "/rest/getSong", {
-      id,
-    })
-      .then((it) => it.song)
-      .then((song) =>
-        this.getAlbum(credentials, song._albumId).then((album) =>
-          asTrack(album, song)
-        )
-      );
-
-  toAlbumSummary = (albumList: album[]): AlbumSummary[] =>
-    albumList.map((album) => ({
-      id: album._id,
-      name: album._name,
-      year: album._year,
-      genre: maybeAsGenre(album._genre),
-      artistId: album._artistId,
-      artistName: album._artist,
-    }));
-
-  search3 = (credentials: Credentials, q: any) =>
-    this.getJSON<Search3Response>(credentials, "/rest/search3", {
-      artistCount: 0,
-      albumCount: 0,
-      songCount: 0,
-      ...q,
-    }).then((it) => ({
-      artists: it.searchResult3.artist || [],
-      albums: it.searchResult3.album || [],
-      songs: it.searchResult3.song || [],
-    }));
-
-  async login(token: string) {
-    const navidrome = this;
-    const credentials: Credentials = this.parseToken(token);
-
-    const musicLibrary: MusicLibrary = {
-      artists: (q: ArtistQuery): Promise<Result<ArtistSummary>> =>
-        navidrome
-          .getArtists(credentials)
-          .then(slice2(q))
-          .then(([page, total]) => ({
-            total,
-            results: page.map((it) => ({ id: it.id, name: it.name })),
-          })),
-      artist: async (id: string): Promise<Artist> =>
-        navidrome.getArtistWithInfo(credentials, id),
-      albums: async (q: AlbumQuery): Promise<Result<AlbumSummary>> => {
-        return Promise.all([
-          navidrome
-            .getArtists(credentials)
-            .then((it) =>
-              _.inject(it, (total, artist) => total + artist.albumCount, 0)
-            ),
-          navidrome
-            .getJSON<GetAlbumListResponse>(credentials, "/rest/getAlbumList2", {
-              ...pick(q, "type", "genre"),
-              size: 500,
-              offset: q._index,
-            })
-            .then((response) => response.albumList2.album || [])
-            .then(navidrome.toAlbumSummary),
-        ]).then(([total, albums]) => ({
-          results: albums.slice(0, q._count),
-          total:
-            albums.length == 500
-              ? total
-              : q._index + albums.length,
-        }));
-      },
-      album: (id: string): Promise<Album> =>
-        navidrome.getAlbum(credentials, id),
-      genres: () =>
-        navidrome
-          .getJSON<GetGenresResponse>(credentials, "/rest/getGenres")
-          .then((it) =>
-            pipe(
-              it.genres.genre || [],
-              A.filter((it) => Number.parseInt(it._albumCount) > 0),
-              A.map((it) => it.__text),
-              A.sort(ordString),
-              A.map((it) => ({ id: it, name: it }))
-            )
-          ),
-      tracks: (albumId: string) =>
-        navidrome
-          .getJSON<GetAlbumResponse>(credentials, "/rest/getAlbum", {
-            id: albumId,
-          })
-          .then((it) => it.album)
-          .then((album) =>
-            (album.song || []).map((song) => asTrack(asAlbum(album), song))
-          ),
-      track: (trackId: string) => navidrome.getTrack(credentials, trackId),
-      stream: async ({
-        trackId,
-        range,
-      }: {
-        trackId: string;
-        range: string | undefined;
-      }) =>
-        navidrome.getTrack(credentials, trackId).then((track) =>
-          navidrome
-            .get(
-              credentials,
-              `/rest/stream`,
-              {
-                id: trackId,
-                c: this.streamClientApplication(track),
-              },
-              {
-                headers: pipe(
-                  range,
-                  O.fromNullable,
-                  O.map((range) => ({
-                    "User-Agent": USER_AGENT,
-                    Range: range,
-                  })),
-                  O.getOrElse(() => ({
-                    "User-Agent": USER_AGENT,
-                  }))
-                ),
-                responseType: "stream",
-              }
-            )
-            .then((res) => ({
-              status: res.status,
-              headers: {
-                "content-type": res.headers["content-type"],
-                "content-length": res.headers["content-length"],
-                "content-range": res.headers["content-range"],
-                "accept-ranges": res.headers["accept-ranges"],
-              },
-              stream: res.data,
-            }))
-        ),
-      coverArt: async (id: string, type: "album" | "artist", size?: number) => {
-        if (type == "album") {
-          return navidrome.getCoverArt(credentials, id, size).then((res) => ({
-            contentType: res.headers["content-type"],
-            data: Buffer.from(res.data, "binary"),
-          }));
-        } else {
-          return navidrome.getArtistWithInfo(credentials, id).then((artist) => {
-            if (artist.image.large) {
-              return axios
-                .get(artist.image.large!, {
-                  headers: BROWSER_HEADERS,
-                  responseType: "arraybuffer",
-                })
-                .then((res) => {
-                  const image = Buffer.from(res.data, "binary");
-                  if (size) {
-                    return sharp(image)
-                      .resize(size)
-                      .toBuffer()
-                      .then((resized) => ({
-                        contentType: res.headers["content-type"],
-                        data: resized,
-                      }));
-                  } else {
-                    return {
-                      contentType: res.headers["content-type"],
-                      data: image,
-                    };
-                  }
-                });
-            } else if (artist.albums.length > 0) {
-              return navidrome
-                .getCoverArt(credentials, artist.albums[0]!.id, size)
-                .then((res) => ({
-                  contentType: res.headers["content-type"],
-                  data: Buffer.from(res.data, "binary"),
-                }));
-            } else {
-              return undefined;
-            }
-          });
-        }
-      },
-      scrobble: async (id: string) =>
-        navidrome
-          .get(credentials, `/rest/scrobble`, {
-            id,
-            submission: true,
-          })
-          .then((_) => true)
-          .catch(() => false),
-      nowPlaying: async (id: string) =>
-        navidrome
-          .get(credentials, `/rest/scrobble`, {
-            id,
-            submission: false,
-          })
-          .then((_) => true)
-          .catch(() => false),
-      searchArtists: async (query: string) =>
-        navidrome
-          .search3(credentials, { query, artistCount: 20 })
-          .then(({ artists }) =>
-            artists.map((artist) => ({
-              id: artist._id,
-              name: artist._name,
-            }))
-          ),
-      searchAlbums: async (query: string) =>
-        navidrome
-          .search3(credentials, { query, albumCount: 20 })
-          .then(({ albums }) => navidrome.toAlbumSummary(albums)),
-      searchTracks: async (query: string) =>
-        navidrome
-          .search3(credentials, { query, songCount: 20 })
-          .then(({ songs }) =>
-            Promise.all(
-              songs.map((it) => navidrome.getTrack(credentials, it._id))
-            )
-          ),
-      playlists: async () =>
-        navidrome
-          .getJSON<GetPlaylistsResponse>(credentials, "/rest/getPlaylists")
-          .then((it) => it.playlists.playlist || [])
-          .then((playlists) =>
-            playlists.map((it) => ({ id: it._id, name: it._name }))
-          ),
-      playlist: async (id: string) =>
-        navidrome
-          .getJSON<GetPlaylistResponse>(credentials, "/rest/getPlaylist", {
-            id,
-          })
-          .then((it) => it.playlist)
-          .then((playlist) => {
-            let trackNumber = 1;
-            return {
-              id: playlist._id,
-              name: playlist._name,
-              entries: (playlist.entry || []).map((entry) => ({
-                id: entry._id,
-                name: entry._title,
-                mimeType: entry._contentType,
-                duration: parseInt(entry._duration || "0"),
-                number: trackNumber++,
-                genre: maybeAsGenre(entry._genre),
-                album: {
-                  id: entry._albumId,
-                  name: entry._album,
-                  year: entry._year,
-                  genre: maybeAsGenre(entry._genre),
-                  artistName: entry._artist,
-                  artistId: entry._artistId,
-                },
-                artist: {
-                  id: entry._artistId,
-                  name: entry._artist,
-                },
-              })),
-            };
-          }),
-      createPlaylist: async (name: string) =>
-        navidrome
-          .getJSON<GetPlaylistResponse>(credentials, "/rest/createPlaylist", {
-            name,
-          })
-          .then((it) => it.playlist)
-          .then((it) => ({ id: it._id, name: it._name })),
-      deletePlaylist: async (id: string) =>
-        navidrome
-          .getJSON<GetPlaylistResponse>(credentials, "/rest/deletePlaylist", {
-            id,
-          })
-          .then((_) => true),
-      addToPlaylist: async (playlistId: string, trackId: string) =>
-        navidrome
-          .getJSON<GetPlaylistResponse>(credentials, "/rest/updatePlaylist", {
-            playlistId,
-            songIdToAdd: trackId,
-          })
-          .then((_) => true),
-      removeFromPlaylist: async (playlistId: string, indicies: number[]) =>
-        navidrome
-          .getJSON<GetPlaylistResponse>(credentials, "/rest/updatePlaylist", {
-            playlistId,
-            songIndexToRemove: indicies,
-          })
-          .then((_) => true),
-      similarSongs: async (id: string) =>
-        navidrome
-          .getJSON<GetSimilarSongsResponse>(
-            credentials,
-            "/rest/getSimilarSongs2",
-            { id, count: 50 }
-          )
-          .then((it) => it.similarSongs2.song || [])
-          .then((songs) =>
-            Promise.all(
-              songs.map((song) =>
-                navidrome
-                  .getAlbum(credentials, song._albumId)
-                  .then((album) => asTrack(album, song))
-              )
-            )
-          ),
-      topSongs: async (artistId: string) =>
-        navidrome.getArtist(credentials, artistId).then(({ name }) =>
-          navidrome
-            .getJSON<GetTopSongsResponse>(credentials, "/rest/getTopSongs", {
-              artist: name,
-              count: 50,
-            })
-            .then((it) => it.topSongs.song || [])
-            .then((songs) =>
-              Promise.all(
-                songs.map((song) =>
-                  navidrome
-                    .getAlbum(credentials, song._albumId)
-                    .then((album) => asTrack(album, song))
-                )
-              )
-            )
-        ),
-    };
-
-    return Promise.resolve(musicLibrary);
-  }
-}

src/random_string.ts

@@ -1,6 +0,0 @@
-import { randomBytes } from "crypto";
-
-const randomString = () => randomBytes(32).toString('hex')
-
-export default randomString
-

src/register.ts

@@ -13,7 +13,7 @@ const bonobUrl = new URLBuilder(params[0]!);
 
 const config = readConfig();
 
-registrar(bonobUrl, config.sonos.discovery)()
+registrar(bonobUrl, config.sonos.discovery.seedHost)()
   .then((success) => {
     if (success) {
       console.log(`Successfully registered bonob @ ${bonobUrl} with sonos`);

src/registrar.ts

@@ -1,15 +1,12 @@
 import axios from "axios";
 import _ from "underscore";
 import logger from "./logger";
-import sonos, { bonobService, Discovery } from "./sonos";
+import sonos, { bonobService } from "./sonos";
 import { URLBuilder } from "./url_builder";
 
 export default (
     bonobUrl: URLBuilder,
-    sonosDiscovery: Discovery = {
-      auto: true,
-      seedHost: undefined,
-    }
+    seedHost?: string
   ) =>
   async () => {
     const about = bonobUrl.append({ pathname: "/about" });
@@ -34,5 +31,5 @@ export default (
       .then(({ name, sid }: { name: string; sid: number }) =>
         bonobService(name, sid, bonobUrl)
       )
-      .then((service) => sonos(sonosDiscovery).register(service));
+      .then((service) => sonos({ enabled: true, seedHost }).register(service));
   };

src/server.ts

@@ -1,8 +1,10 @@
-import { option as O } from "fp-ts";
+import { either as E, taskEither as TE } from "fp-ts";
 import express, { Express, Request } from "express";
 import * as Eta from "eta";
 import path from "path";
 import sharp from "sharp";
+import { v4 as uuid } from "uuid";
+import dayjs from "dayjs";
 
 import { PassThrough, Transform, TransformCallback } from "stream";
 
@@ -15,11 +17,14 @@ import {
   LOGIN_ROUTE,
   CREATE_REGISTRATION_ROUTE,
   REMOVE_REGISTRATION_ROUTE,
+  sonosifyMimeType,
+  ratingFromInt,
+  ratingAsInt,
 } from "./smapi";
 import { LinkCodes, InMemoryLinkCodes } from "./link_codes";
-import { MusicService, isSuccess } from "./music_service";
+import { MusicService, AuthFailure, AuthSuccess } from "./music_service";
 import bindSmapiSoapServiceToExpress from "./smapi";
-import { AccessTokens, AccessTokenPerAuthToken } from "./access_tokens";
+import { APITokens, InMemoryAPITokens } from "./api_tokens";
 import logger from "./logger";
 import { Clock, SystemClock } from "./clock";
 import { pipe } from "fp-ts/lib/function";
@@ -29,6 +34,12 @@ import { Icon, ICONS, festivals, features } from "./icon";
 import _, { shuffle } from "underscore";
 import morgan from "morgan";
 import { takeWithRepeats } from "./utils";
+import { parse } from "./burn";
+import { axiosImageFetcher, ImageFetcher } from "./subsonic";
+import {
+  JWTSmapiLoginTokens,
+  SmapiAuthTokens,
+} from "./smapi_auth";
 
 export const BONOB_ACCESS_TOKEN_HEADER = "bat";
 
@@ -71,7 +82,7 @@ export class RangeBytesFromFilter extends Transform {
 
 export type ServerOpts = {
   linkCodes: () => LinkCodes;
-  accessTokens: () => AccessTokens;
+  apiTokens: () => APITokens;
   clock: Clock;
   iconColors: {
     foregroundColor: string | undefined;
@@ -80,16 +91,24 @@ export type ServerOpts = {
   applyContextPath: boolean;
   logRequests: boolean;
   version: string;
+  smapiAuthTokens: SmapiAuthTokens;
+  externalImageResolver: ImageFetcher;
 };
 
 const DEFAULT_SERVER_OPTS: ServerOpts = {
   linkCodes: () => new InMemoryLinkCodes(),
-  accessTokens: () => new AccessTokenPerAuthToken(),
+  apiTokens: () => new InMemoryAPITokens(),
   clock: SystemClock,
   iconColors: { foregroundColor: undefined, backgroundColor: undefined },
   applyContextPath: true,
   logRequests: false,
   version: "v?",
+  smapiAuthTokens: new JWTSmapiLoginTokens(
+    SystemClock,
+    `bonob-${uuid()}`,
+    "1m"
+  ),
+  externalImageResolver: axiosImageFetcher,
 };
 
 function server(
@@ -102,9 +121,12 @@ function server(
   const serverOpts = { ...DEFAULT_SERVER_OPTS, ...opts };
 
   const linkCodes = serverOpts.linkCodes();
-  const accessTokens = serverOpts.accessTokens();
+  const smapiAuthTokens = serverOpts.smapiAuthTokens;
+  const apiTokens = serverOpts.apiTokens();
   const clock = serverOpts.clock;
 
+  const startUpTime = dayjs();
+
   const app = express();
   const i8n = makeI8N(service.name);
 
@@ -113,8 +135,7 @@ function server(
   }
   app.use(express.urlencoded({ extended: false }));
 
-  // todo: pass options in here?
-  app.use(express.static("./web/public"));
+  app.use(express.static(path.resolve(__dirname, "..", "web", "public")));
   app.engine("eta", Eta.renderFile);
 
   app.set("view engine", "eta");
@@ -148,7 +169,7 @@ function server(
           removeRegistrationRoute: bonobUrl
             .append({ pathname: REMOVE_REGISTRATION_ROUTE })
             .pathname(),
-          version: opts.version,
+          version: serverOpts.version || DEFAULT_SERVER_OPTS.version,
         });
       }
     );
@@ -210,28 +231,41 @@ function server(
     const lang = langFor(req);
     const { username, password, linkCode } = req.body;
     if (!linkCodes.has(linkCode)) {
-      res.status(400).render("failure", {
+      return res.status(400).render("failure", {
         lang,
         message: lang("invalidLinkCode"),
       });
     } else {
-      const authResult = await musicService.generateToken({
-        username,
-        password,
-      });
-      if (isSuccess(authResult)) {
-        linkCodes.associate(linkCode, authResult);
-        res.render("success", {
-          lang,
-          message: lang("loginSuccessful"),
-        });
-      } else {
-        res.status(403).render("failure", {
-          lang,
-          message: lang("loginFailed"),
-          cause: authResult.message,
-        });
-      }
+      return pipe(
+        musicService.generateToken({
+          username,
+          password,
+        }),
+        TE.match(
+          (e: AuthFailure) => ({
+            status: 403,
+            template: "failure",
+            params: {
+              lang,
+              message: lang("loginFailed"),
+              cause: e.message,
+            },
+          }),
+          (success: AuthSuccess) => {
+            linkCodes.associate(linkCode, success);
+            return {
+              status: 200,
+              template: "success",
+              params: {
+                lang,
+                message: lang("loginSuccessful"),
+              },
+            };
+          }
+        )
+      )().then(({ status, template, params }) =>
+        res.status(status).render(template, params)
+      );
     }
   });
 
@@ -251,8 +285,44 @@ function server(
   });
 
   app.get(PRESENTATION_MAP_ROUTE, (_, res) => {
+    const LastModified = startUpTime.format("HH:mm:ss D MMM YYYY");
+
+    const nowPlayingRatingsMatch = (value: number) => {
+      const rating = ratingFromInt(value);
+      const nextLove = { ...rating, love: !rating.love };
+      const nextStar = {
+        ...rating,
+        stars: rating.stars === 5 ? 0 : rating.stars + 1,
+      };
+
+      const loveRatingIcon = bonobUrl
+        .append({
+          pathname: rating.love ? "/love-selected.svg" : "/love-unselected.svg",
+        })
+        .href();
+      const starsRatingIcon = bonobUrl
+        .append({ pathname: `/star${rating.stars}.svg` })
+        .href();
+
+      return `<Match propname="rating" value="${value}">
+        <Ratings>
+          <Rating Id="${ratingAsInt(
+            nextLove
+          )}" AutoSkip="NEVER" OnSuccessStringId="LOVE_SUCCESS" StringId="LOVE">
+            <Icon Controller="universal" LastModified="${LastModified}" Uri="${loveRatingIcon}" />
+          </Rating>
+          <Rating Id="${-ratingAsInt(
+            nextStar
+          )}" AutoSkip="NEVER" OnSuccessStringId="STAR_SUCCESS" StringId="STAR">
+            <Icon Controller="universal" LastModified="${LastModified}" Uri="${starsRatingIcon}" />
+          </Rating>
+        </Ratings>
+      </Match>`;
+    };
+
     res.type("application/xml").send(`<?xml version="1.0" encoding="utf-8" ?>
     <Presentation>
+      <BrowseOptions PageSize="30" />
       <PresentationMap type="ArtWorkSizeMap">
         <Match>
           <imageSizeMap>
@@ -283,25 +353,53 @@ function server(
           </SearchCategories>
         </Match>
       </PresentationMap>
+      <PresentationMap type="NowPlayingRatings" trackEnabled="true" programEnabled="false">
+        ${nowPlayingRatingsMatch(100)}
+        ${nowPlayingRatingsMatch(101)}
+        ${nowPlayingRatingsMatch(110)}
+        ${nowPlayingRatingsMatch(111)}
+        ${nowPlayingRatingsMatch(120)}
+        ${nowPlayingRatingsMatch(121)}
+        ${nowPlayingRatingsMatch(130)}
+        ${nowPlayingRatingsMatch(131)}
+        ${nowPlayingRatingsMatch(140)}
+        ${nowPlayingRatingsMatch(141)}
+        ${nowPlayingRatingsMatch(150)}
+        ${nowPlayingRatingsMatch(151)}
+      </PresentationMap>
     </Presentation>`);
   });
 
   app.get("/stream/track/:id", async (req, res) => {
     const id = req.params["id"]!;
+    const trace = uuid();
+
     logger.info(
-      `-> /stream/track/${id}, headers=${JSON.stringify(req.headers)}`
+      `${trace} bnb<- ${req.method} ${req.path}?${JSON.stringify(
+        req.query
+      )}, headers=${JSON.stringify({ ...req.headers, "bnbt": "*****", "bnbk": "*****" })}`
     );
-    const authToken = pipe(
-      req.header(BONOB_ACCESS_TOKEN_HEADER),
-      O.fromNullable,
-      O.map((accessToken) => accessTokens.authTokenFor(accessToken)),
-      O.getOrElseW(() => undefined)
-    );
-    if (!authToken) {
+
+    const serviceToken = pipe(
+      E.fromNullable("Missing bnbt header")(req.headers["bnbt"] as string),
+      E.chain(token => pipe(
+        E.fromNullable("Missing bnbk header")(req.headers["bnbk"] as string),
+        E.map(key => ({ token, key }))
+      )),
+      E.chain((auth) =>
+        pipe(
+          smapiAuthTokens.verify(auth),
+          E.mapLeft((_) => "Auth token failed to verify")
+        )
+      ),
+      E.getOrElseW(() => undefined)
+    )
+
+    if (!serviceToken) {
       return res.status(401).send();
     } else {
       return musicService
-        .login(authToken)
+        .login(serviceToken)
         .then((it) =>
           it
             .stream({
@@ -312,11 +410,18 @@ function server(
         )
         .then(({ musicLibrary, stream }) => {
           logger.info(
-            `stream response from music service for ${id}, status=${
+            `${trace} bnb<- stream response from music service for ${id}, status=${
               stream.status
             }, headers=(${JSON.stringify(stream.headers)})`
           );
 
+          const sonosisfyContentType = (contentType: string) =>
+            contentType
+              .split(";")
+              .map((it) => it.trim())
+              .map(sonosifyMimeType)
+              .join("; ");
+
           const respondWith = ({
             status,
             filter,
@@ -326,23 +431,25 @@ function server(
           }: {
             status: number;
             filter: Transform;
-            headers: Record<string, string | undefined>;
+            headers: Record<string, string>;
             sendStream: boolean;
             nowPlaying: boolean;
           }) => {
             logger.info(
-              `<- /stream/track/${id}, status=${status}, headers=${JSON.stringify(
-                headers
-              )}`
+              `${trace} bnb-> ${
+                req.path
+              }, status=${status}, headers=${JSON.stringify(headers)}`
             );
             (nowPlaying
               ? musicLibrary.nowPlaying(id)
               : Promise.resolve(true)
             ).then((_) => {
               res.status(status);
-              Object.entries(stream.headers)
+              Object.entries(headers)
                 .filter(([_, v]) => v !== undefined)
-                .forEach(([header, value]) => res.setHeader(header, value));
+                .forEach(([header, value]) => {
+                  res.setHeader(header, value!);
+                });
               if (sendStream) stream.stream.pipe(filter).pipe(res);
               else res.send();
             });
@@ -353,7 +460,9 @@ function server(
               status: 200,
               filter: new PassThrough(),
               headers: {
-                "content-type": stream.headers["content-type"],
+                "content-type": sonosisfyContentType(
+                  stream.headers["content-type"]
+                ),
                 "content-length": stream.headers["content-length"],
                 "accept-ranges": stream.headers["accept-ranges"],
               },
@@ -365,7 +474,9 @@ function server(
               status: 206,
               filter: new PassThrough(),
               headers: {
-                "content-type": stream.headers["content-type"],
+                "content-type": sonosisfyContentType(
+                  stream.headers["content-type"]
+                ),
                 "content-length": stream.headers["content-length"],
                 "content-range": stream.headers["content-range"],
                 "accept-ranges": stream.headers["accept-ranges"],
@@ -457,25 +568,32 @@ function server(
     "centre",
   ];
 
-  app.get("/art/:type/:ids/size/:size", (req, res) => {
-    const authToken = accessTokens.authTokenFor(
+  app.get("/art/:burns/size/:size", (req, res) => {
+    const serviceToken = apiTokens.authTokenFor(
       req.query[BONOB_ACCESS_TOKEN_HEADER] as string
     );
-    const type = req.params["type"]!;
-    const ids = req.params["ids"]!.split("&");
+    const urns = req.params["burns"]!.split("&").map(parse);
     const size = Number.parseInt(req.params["size"]!);
 
-    if (!authToken) {
+    if (!serviceToken) {
       return res.status(401).send();
-    } else if (type != "artist" && type != "album") {
-      return res.status(400).send();
     } else if (!(size > 0)) {
       return res.status(400).send();
     }
 
     return musicService
-      .login(authToken)
-      .then((it) => Promise.all(ids.map((id) => it.coverArt(id, type, size))))
+      .login(serviceToken)
+      .then((musicLibrary) =>
+        Promise.all(
+          urns.map((it) => {
+            if (it.system == "external") {
+              return serverOpts.externalImageResolver(it.resource);
+            } else {
+              return musicLibrary.coverArt(it, size);
+            }
+          })
+        )
+      )
       .then((coverArts) => coverArts.filter((it) => it))
       .then(shuffle)
       .then((coverArts) => {
@@ -513,12 +631,9 @@ function server(
         }
       })
       .catch((e: Error) => {
-        logger.error(
-          `Failed fetching image ${type}/${ids.join("&")}/size/${size}`,
-          {
-            cause: e,
-          }
-        );
+        logger.error(`Failed fetching image ${urns.join("&")}/size/${size}`, {
+          cause: e,
+        });
         return res.status(500).send();
       });
   });
@@ -529,9 +644,10 @@ function server(
     bonobUrl,
     linkCodes,
     musicService,
-    accessTokens,
+    apiTokens,
     clock,
-    i8n
+    i8n,
+    serverOpts.smapiAuthTokens
   );
 
   if (serverOpts.applyContextPath) {

src/smapi.ts

@@ -3,6 +3,9 @@ import { Express, Request } from "express";
 import { listen } from "soap";
 import { readFileSync } from "fs";
 import path from "path";
+import { option as O, either as E, taskEither as TE, task as T } from "fp-ts";
+import { pipe } from "fp-ts/lib/function";
+
 import logger from "./logger";
 
 import { LinkCodes } from "./link_codes";
@@ -14,16 +17,24 @@ import {
   Genre,
   MusicService,
   Playlist,
+  Rating,
   slice2,
   Track,
 } from "./music_service";
-import { AccessTokens } from "./access_tokens";
-import { BONOB_ACCESS_TOKEN_HEADER } from "./server";
+import { APITokens } from "./api_tokens";
 import { Clock } from "./clock";
 import { URLBuilder } from "./url_builder";
 import { asLANGs, I8N } from "./i8n";
 import { ICON, iconForGenre } from "./icon";
-import { uniq } from "underscore";
+import _, { uniq } from "underscore";
+import { BUrn, formatForURL } from "./burn";
+import {
+  isExpiredTokenError,
+  MissingLoginTokenError,
+  SmapiAuthTokens,
+  SMAPI_FAULT_LOGIN_UNAUTHORIZED,
+  ToSmapiFault,
+} from "./smapi_auth";
 
 export const LOGIN_ROUTE = "/login";
 export const CREATE_REGISTRATION_ROUTE = "/registration/add";
@@ -55,6 +66,7 @@ const WSDL_FILE = path.resolve(
 export type Credentials = {
   loginToken: {
     token: string;
+    key: string;
     householdId: string;
   };
   deviceId: string;
@@ -81,6 +93,13 @@ export type GetDeviceAuthTokenResult = {
   };
 };
 
+export const ratingAsInt = (rating: Rating): number =>
+  rating.stars * 10 + (rating.love ? 1 : 0) + 100;
+export const ratingFromInt = (value: number): Rating => {
+  const x = value - 100;
+  return { love: x % 10 == 1, stars: Math.floor(x / 10) };
+};
+
 export type MediaCollection = {
   id: string;
   itemType: "collection";
@@ -138,10 +157,19 @@ export function searchResult(
 class SonosSoap {
   linkCodes: LinkCodes;
   bonobUrl: URLBuilder;
+  smapiAuthTokens: SmapiAuthTokens;
+  clock: Clock;
 
-  constructor(bonobUrl: URLBuilder, linkCodes: LinkCodes) {
+  constructor(
+    bonobUrl: URLBuilder,
+    linkCodes: LinkCodes,
+    smapiAuthTokens: SmapiAuthTokens,
+    clock: Clock
+  ) {
     this.bonobUrl = bonobUrl;
     this.linkCodes = linkCodes;
+    this.smapiAuthTokens = smapiAuthTokens;
+    this.clock = clock;
   }
 
   getAppLink(): GetAppLinkResult {
@@ -170,10 +198,13 @@ class SonosSoap {
   }): GetDeviceAuthTokenResult {
     const association = this.linkCodes.associationFor(linkCode);
     if (association) {
+      const smapiAuthToken = this.smapiAuthTokens.issue(
+        association.serviceToken
+      );
       return {
         getDeviceAuthTokenResult: {
-          authToken: association.authToken,
-          privateKey: "",
+          authToken: smapiAuthToken.token,
+          privateKey: smapiAuthToken.key,
           userInfo: {
             nickname: association.nickname,
             userIdHashCode: crypto
@@ -215,10 +246,7 @@ const genre = (bonobUrl: URLBuilder, genre: Genre) => ({
   itemType: "container",
   id: `genre:${genre.id}`,
   title: genre.name,
-  albumArtURI: iconArtURI(
-    bonobUrl,
-    iconForGenre(genre.name)
-  ).href(),
+  albumArtURI: iconArtURI(bonobUrl, iconForGenre(genre.name)).href(),
 });
 
 const playlist = (bonobUrl: URLBuilder, playlist: Playlist) => ({
@@ -238,31 +266,59 @@ export const playlistAlbumArtURL = (
   bonobUrl: URLBuilder,
   playlist: Playlist
 ) => {
-  const ids = uniq(playlist.entries.map((it) => it.album?.id).filter((it) => it));
-  if (ids.length == 0) {
+  const burns: BUrn[] = uniq(
+    playlist.entries.filter((it) => it.coverArt != undefined),
+    (it) => it.album.id
+  ).map((it) => it.coverArt!);
+  if (burns.length == 0) {
     return iconArtURI(bonobUrl, "error");
   } else {
     return bonobUrl.append({
-      pathname: `/art/album/${ids.slice(0, 9).join("&")}/size/180`
+      pathname: `/art/${burns
+        .slice(0, 9)
+        .map((it) => encodeURIComponent(formatForURL(it)))
+        .join("&")}/size/180`,
     });
   }
 };
 
-export const defaultAlbumArtURI = (bonobUrl: URLBuilder, album: AlbumSummary) =>
-  bonobUrl.append({ pathname: `/art/album/${album.id}/size/180` });
-
-export const iconArtURI = (
+export const defaultAlbumArtURI = (
   bonobUrl: URLBuilder,
-  icon: ICON
+  { coverArt }: { coverArt: BUrn | undefined }
 ) =>
+  pipe(
+    coverArt,
+    O.fromNullable,
+    O.map((it) =>
+      bonobUrl.append({
+        pathname: `/art/${encodeURIComponent(formatForURL(it))}/size/180`,
+      })
+    ),
+    O.getOrElseW(() => iconArtURI(bonobUrl, "vinyl"))
+  );
+
+export const iconArtURI = (bonobUrl: URLBuilder, icon: ICON) =>
   bonobUrl.append({
-    pathname: `/icon/${icon}/size/legacy`
+    pathname: `/icon/${icon}/size/legacy`,
   });
 
 export const defaultArtistArtURI = (
   bonobUrl: URLBuilder,
   artist: ArtistSummary
-) => bonobUrl.append({ pathname: `/art/artist/${artist.id}/size/180` });
+) =>
+  pipe(
+    artist.image,
+    O.fromNullable,
+    O.map((it) =>
+      bonobUrl.append({
+        pathname: `/art/${encodeURIComponent(formatForURL(it))}/size/180`,
+      })
+    ),
+    O.getOrElseW(() => iconArtURI(bonobUrl, "vinyl"))
+  );
+
+export const sonosifyMimeType = (mimeType: string) =>
+  mimeType == "audio/x-flac" ? "audio/flac" : mimeType;
 
 export const album = (bonobUrl: URLBuilder, album: AlbumSummary) => ({
   itemType: "album",
@@ -281,22 +337,25 @@ export const album = (bonobUrl: URLBuilder, album: AlbumSummary) => ({
 export const track = (bonobUrl: URLBuilder, track: Track) => ({
   itemType: "track",
   id: `track:${track.id}`,
-  mimeType: track.mimeType,
+  mimeType: sonosifyMimeType(track.mimeType),
   title: track.name,
 
   trackMetadata: {
     album: track.album.name,
-    albumId: track.album.id,
+    albumId: `album:${track.album.id}`,
     albumArtist: track.artist.name,
-    albumArtistId: track.artist.id,
-    albumArtURI: defaultAlbumArtURI(bonobUrl, track.album).href(),
+    albumArtistId: track.artist.id ? `artist:${track.artist.id}` : undefined,
+    albumArtURI: defaultAlbumArtURI(bonobUrl, track).href(),
     artist: track.artist.name,
-    artistId: track.artist.id,
+    artistId: track.artist.id ? `artist:${track.artist.id}` : undefined,
     duration: track.duration,
     genre: track.album.genre?.name,
     genreId: track.album.genre?.id,
     trackNumber: track.number,
   },
+  dynamic: {
+    property: [{ name: "rating", value: `${ratingAsInt(track.rating)}` }],
+  },
 });
 
 export const artist = (bonobUrl: URLBuilder, artist: ArtistSummary) => ({
@@ -307,39 +366,6 @@ export const artist = (bonobUrl: URLBuilder, artist: ArtistSummary) => ({
   albumArtURI: defaultArtistArtURI(bonobUrl, artist).href(),
 });
 
-const auth = async (
-  musicService: MusicService,
-  accessTokens: AccessTokens,
-  credentials?: Credentials
-) => {
-  if (!credentials) {
-    throw {
-      Fault: {
-        faultcode: "Client.LoginUnsupported",
-        faultstring: "Missing credentials...",
-      },
-    };
-  }
-  const authToken = credentials.loginToken.token;
-  const accessToken = accessTokens.mint(authToken);
-
-  return musicService
-    .login(authToken)
-    .then((musicLibrary) => ({
-      musicLibrary,
-      authToken,
-      accessToken,
-    }))
-    .catch((_) => {
-      throw {
-        Fault: {
-          faultcode: "Client.LoginUnauthorized",
-          faultstring: "Credentials not found...",
-        },
-      };
-    });
-};
-
 function splitId<T>(id: string) {
   const [type, typeId] = id.split(":");
   return (t: T) => ({
@@ -353,25 +379,97 @@ type SoapyHeaders = {
   credentials?: Credentials;
 };
 
+type Auth = {
+  serviceToken: string;
+  credentials: Credentials;
+  apiKey: string;
+};
+
+function isAuth(thing: any): thing is Auth {
+  return thing.serviceToken;
+}
+
 function bindSmapiSoapServiceToExpress(
   app: Express,
   soapPath: string,
   bonobUrl: URLBuilder,
   linkCodes: LinkCodes,
   musicService: MusicService,
-  accessTokens: AccessTokens,
+  apiKeys: APITokens,
   clock: Clock,
-  i8n: I8N
+  i8n: I8N,
+  smapiAuthTokens: SmapiAuthTokens
 ) {
-  const sonosSoap = new SonosSoap(bonobUrl, linkCodes);
+  const sonosSoap = new SonosSoap(bonobUrl, linkCodes, smapiAuthTokens, clock);
 
   const urlWithToken = (accessToken: string) =>
     bonobUrl.append({
       searchParams: {
-        "bat": accessToken,
+        bat: accessToken,
       },
     });
 
+  const auth = (credentials?: Credentials): E.Either<ToSmapiFault, Auth> => {
+    const credentialsFrom = E.fromNullable(new MissingLoginTokenError());
+    return pipe(
+      credentialsFrom(credentials),
+      E.chain((credentials) =>
+        pipe(
+          smapiAuthTokens.verify({
+            token: credentials.loginToken.token,
+            key: credentials.loginToken.key,
+          }),
+          E.map((serviceToken) => ({
+            serviceToken,
+            credentials,
+          }))
+        )
+      ),
+      E.map(({ serviceToken, credentials }) => ({
+        serviceToken,
+        credentials,
+        apiKey: apiKeys.mint(serviceToken),
+      }))
+    );
+  };
+
+  const login = async (credentials?: Credentials) => {
+    const authOrFail = pipe(
+      auth(credentials),
+      E.getOrElseW((fault) => fault)
+    );
+    if (isAuth(authOrFail)) {
+      return musicService
+        .login(authOrFail.serviceToken)
+        .then((musicLibrary) => ({ ...authOrFail, musicLibrary }))
+        .catch((_) => {
+          throw SMAPI_FAULT_LOGIN_UNAUTHORIZED;
+        });
+    } else if (isExpiredTokenError(authOrFail)) {
+      throw await pipe(
+        musicService.refreshToken(authOrFail.expiredToken),
+        TE.map((it) => smapiAuthTokens.issue(it.serviceToken)),
+        TE.map((newToken) => ({
+          Fault: {
+            faultcode: "Client.TokenRefreshRequired",
+            faultstring: "Token has expired",
+            detail: {
+              refreshAuthTokenResult: {
+                authToken: newToken.token,
+                privateKey: newToken.key,
+              },
+            },
+          },
+        })),
+        TE.getOrElse(() =>
+          T.of(SMAPI_FAULT_LOGIN_UNAUTHORIZED)
+        )
+      )();
+    } else {
+      throw authOrFail.toSmapiFault();
+    }
+  };
+
   const soapyService = listen(
     app,
     soapPath,
@@ -389,14 +487,42 @@ function bindSmapiSoapServiceToExpress(
               pollInterval: 60,
             },
           }),
+          refreshAuthToken: async (_, _2, soapyHeaders: SoapyHeaders) => {
+            const serviceToken = pipe(
+              auth(soapyHeaders?.credentials),
+              E.fold(
+                (fault) =>
+                  isExpiredTokenError(fault)
+                    ? E.right(fault.expiredToken)
+                    : E.left(fault),
+                (creds) => E.right(creds.serviceToken)
+              ),
+              E.getOrElseW((fault) => {
+                throw fault.toSmapiFault();
+              })
+            );
+            return pipe(
+              musicService.refreshToken(serviceToken),
+              TE.map((it) => smapiAuthTokens.issue(it.serviceToken)),
+              TE.map((it) => ({
+                refreshAuthTokenResult: {
+                  authToken: it.token,
+                  privateKey: it.key,
+                },
+              })),
+              TE.getOrElse((_) => {
+                throw SMAPI_FAULT_LOGIN_UNAUTHORIZED;
+              })
+            )();
+          },
           getMediaURI: async (
             { id }: { id: string },
             _,
             soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(splitId(id))
-              .then(({ accessToken, type, typeId }) => ({
+              .then(({ credentials, type, typeId }) => ({
                 getMediaURIResult: bonobUrl
                   .append({
                     pathname: `/stream/${type}/${typeId}`,
@@ -404,8 +530,16 @@ function bindSmapiSoapServiceToExpress(
                   .href(),
                 httpHeaders: [
                   {
-                    header: BONOB_ACCESS_TOKEN_HEADER,
-                    value: accessToken,
+                    httpHeader: {
+                      header: "bnbt",
+                      value: credentials.loginToken.token,
+                    },
+                  },
+                  {
+                    httpHeader: {
+                      header: "bnbk",
+                      value: credentials.loginToken.key,
+                    },
                   },
                 ],
               })),
@@ -414,11 +548,11 @@ function bindSmapiSoapServiceToExpress(
             _,
             soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(splitId(id))
-              .then(async ({ musicLibrary, accessToken, typeId }) =>
+              .then(async ({ musicLibrary, apiKey, typeId }) =>
                 musicLibrary.track(typeId!).then((it) => ({
-                  getMediaMetadataResult: track(urlWithToken(accessToken), it),
+                  getMediaMetadataResult: track(urlWithToken(apiKey), it),
                 }))
               ),
           search: async (
@@ -426,16 +560,16 @@ function bindSmapiSoapServiceToExpress(
             _,
             soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(splitId(id))
-              .then(async ({ musicLibrary, accessToken }) => {
+              .then(async ({ musicLibrary, apiKey }) => {
                 switch (id) {
                   case "albums":
                     return musicLibrary.searchAlbums(term).then((it) =>
                       searchResult({
                         count: it.length,
                         mediaCollection: it.map((albumSummary) =>
-                          album(urlWithToken(accessToken), albumSummary)
+                          album(urlWithToken(apiKey), albumSummary)
                         ),
                       })
                     );
@@ -444,7 +578,7 @@ function bindSmapiSoapServiceToExpress(
                       searchResult({
                         count: it.length,
                         mediaCollection: it.map((artistSummary) =>
-                          artist(urlWithToken(accessToken), artistSummary)
+                          artist(urlWithToken(apiKey), artistSummary)
                         ),
                       })
                     );
@@ -453,7 +587,7 @@ function bindSmapiSoapServiceToExpress(
                       searchResult({
                         count: it.length,
                         mediaCollection: it.map((aTrack) =>
-                          album(urlWithToken(accessToken), aTrack.album)
+                          album(urlWithToken(apiKey), aTrack.album)
                         ),
                       })
                     );
@@ -471,9 +605,9 @@ function bindSmapiSoapServiceToExpress(
             _,
             soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(splitId(id))
-              .then(async ({ musicLibrary, accessToken, type, typeId }) => {
+              .then(async ({ musicLibrary, apiKey, type, typeId }) => {
                 const paging = { _index: index, _count: count };
                 switch (type) {
                   case "artist":
@@ -487,7 +621,7 @@ function bindSmapiSoapServiceToExpress(
                           index: paging._index,
                           total,
                           mediaCollection: page.map((it) =>
-                            album(urlWithToken(accessToken), it)
+                            album(urlWithToken(apiKey), it)
                           ),
                           relatedBrowse:
                             artist.similarArtists.filter((it) => it.inLibrary)
@@ -505,25 +639,7 @@ function bindSmapiSoapServiceToExpress(
                   case "track":
                     return musicLibrary.track(typeId).then((it) => ({
                       getExtendedMetadataResult: {
-                        mediaMetadata: {
-                          id: `track:${it.id}`,
-                          itemType: "track",
-                          title: it.name,
-                          mimeType: it.mimeType,
-                          trackMetadata: {
-                            artistId: `artist:${it.artist.id}`,
-                            artist: it.artist.name,
-                            albumId: `album:${it.album.id}`,
-                            album: it.album.name,
-                            genre: it.genre?.name,
-                            genreId: it.genre?.id,
-                            duration: it.duration,
-                            albumArtURI: defaultAlbumArtURI(
-                              urlWithToken(accessToken),
-                              it.album
-                            ).href(),
-                          },
-                        },
+                        mediaMetadata: track(urlWithToken(apiKey), it),
                       },
                     }));
                   case "album":
@@ -535,7 +651,7 @@ function bindSmapiSoapServiceToExpress(
                             userContent: false,
                             renameable: false,
                           },
-                          ...album(urlWithToken(accessToken), it),
+                          ...album(urlWithToken(apiKey), it),
                         },
                         // <mediaCollection readonly="true">
                         //   </mediaCollection>
@@ -561,9 +677,9 @@ function bindSmapiSoapServiceToExpress(
             soapyHeaders: SoapyHeaders,
             { headers }: Pick<Request, "headers">
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(splitId(id))
-              .then(({ musicLibrary, accessToken, type, typeId }) => {
+              .then(({ musicLibrary, apiKey, type, typeId }) => {
                 const paging = { _index: index, _count: count };
                 const acceptLanguage = headers["accept-language"];
                 logger.debug(
@@ -575,7 +691,7 @@ function bindSmapiSoapServiceToExpress(
                   musicLibrary.albums(q).then((result) => {
                     return getMetadataResult({
                       mediaCollection: result.results.map((it) =>
-                        album(urlWithToken(accessToken), it)
+                        album(urlWithToken(apiKey), it)
                       ),
                       index: paging._index,
                       total: result.total,
@@ -598,6 +714,24 @@ function bindSmapiSoapServiceToExpress(
                           albumArtURI: iconArtURI(bonobUrl, "albums").href(),
                           itemType: "albumList",
                         },
+                        {
+                          id: "randomAlbums",
+                          title: lang("random"),
+                          albumArtURI: iconArtURI(bonobUrl, "random").href(),
+                          itemType: "albumList",
+                        },
+                        {
+                          id: "favouriteAlbums",
+                          title: lang("favourites"),
+                          albumArtURI: iconArtURI(bonobUrl, "heart").href(),
+                          itemType: "albumList",
+                        },
+                        {
+                          id: "starredAlbums",
+                          title: lang("topRated"),
+                          albumArtURI: iconArtURI(bonobUrl, "star").href(),
+                          itemType: "albumList",
+                        },
                         {
                           id: "playlists",
                           title: lang("playlists"),
@@ -615,18 +749,6 @@ function bindSmapiSoapServiceToExpress(
                           albumArtURI: iconArtURI(bonobUrl, "genres").href(),
                           itemType: "container",
                         },
-                        {
-                          id: "randomAlbums",
-                          title: lang("random"),
-                          albumArtURI: iconArtURI(bonobUrl, "random").href(),
-                          itemType: "albumList",
-                        },
-                        {
-                          id: "starredAlbums",
-                          title: lang("starred"),
-                          albumArtURI: iconArtURI(bonobUrl, "starred").href(),
-                          itemType: "albumList",
-                        },
                         {
                           id: "recentlyAdded",
                           title: lang("recentlyAdded"),
@@ -655,8 +777,6 @@ function bindSmapiSoapServiceToExpress(
                           itemType: "albumList",
                         },
                       ],
-                      index: 0,
-                      total: 9,
                     });
                   case "search":
                     return getMetadataResult({
@@ -677,14 +797,12 @@ function bindSmapiSoapServiceToExpress(
                           title: lang("tracks"),
                         },
                       ],
-                      index: 0,
-                      total: 3,
                     });
                   case "artists":
                     return musicLibrary.artists(paging).then((result) => {
                       return getMetadataResult({
                         mediaCollection: result.results.map((it) =>
-                          artist(urlWithToken(accessToken), it)
+                          artist(urlWithToken(apiKey), it)
                         ),
                         index: paging._index,
                         total: result.total,
@@ -707,6 +825,11 @@ function bindSmapiSoapServiceToExpress(
                       type: "random",
                       ...paging,
                     });
+                  case "favouriteAlbums":
+                    return albums({
+                      type: "favourited",
+                      ...paging,
+                    });
                   case "starredAlbums":
                     return albums({
                       type: "starred",
@@ -714,17 +837,17 @@ function bindSmapiSoapServiceToExpress(
                     });
                   case "recentlyAdded":
                     return albums({
-                      type: "newest",
+                      type: "recentlyAdded",
                       ...paging,
                     });
                   case "recentlyPlayed":
                     return albums({
-                      type: "recent",
+                      type: "recentlyPlayed",
                       ...paging,
                     });
                   case "mostPlayed":
                     return albums({
-                      type: "frequent",
+                      type: "mostPlayed",
                       ...paging,
                     });
                   case "genres":
@@ -754,7 +877,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaCollection: page.map((it) =>
-                            playlist(urlWithToken(accessToken), it)
+                            playlist(urlWithToken(apiKey), it)
                           ),
                           index: paging._index,
                           total,
@@ -768,7 +891,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaMetadata: page.map((it) =>
-                            track(urlWithToken(accessToken), it)
+                            track(urlWithToken(apiKey), it)
                           ),
                           index: paging._index,
                           total,
@@ -782,7 +905,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaCollection: page.map((it) =>
-                            album(urlWithToken(accessToken), it)
+                            album(urlWithToken(apiKey), it)
                           ),
                           index: paging._index,
                           total,
@@ -799,7 +922,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaCollection: page.map((it) =>
-                            artist(urlWithToken(accessToken), it)
+                            artist(urlWithToken(apiKey), it)
                           ),
                           index: paging._index,
                           total,
@@ -812,7 +935,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaMetadata: page.map((it) =>
-                            track(urlWithToken(accessToken), it)
+                            track(urlWithToken(apiKey), it)
                           ),
                           index: paging._index,
                           total,
@@ -827,7 +950,7 @@ function bindSmapiSoapServiceToExpress(
             _,
             soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(({ musicLibrary }) =>
                 musicLibrary
                   .createPlaylist(title)
@@ -853,7 +976,7 @@ function bindSmapiSoapServiceToExpress(
             _,
             soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(({ musicLibrary }) => musicLibrary.deletePlaylist(id))
               .then((_) => ({ deleteContainerResult: {} })),
           addToContainer: async (
@@ -861,7 +984,7 @@ function bindSmapiSoapServiceToExpress(
             _,
             soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(splitId(id))
               .then(({ musicLibrary, typeId }) =>
                 musicLibrary.addToPlaylist(parentId.split(":")[1]!, typeId)
@@ -872,7 +995,7 @@ function bindSmapiSoapServiceToExpress(
             _,
             soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(splitId(id))
               .then((it) => ({
                 ...it,
@@ -890,28 +1013,41 @@ function bindSmapiSoapServiceToExpress(
                 }
               })
               .then((_) => ({ removeFromContainerResult: { updateId: "" } })),
+          rateItem: async (
+            { id, rating }: { id: string; rating: number },
+            _,
+            soapyHeaders: SoapyHeaders
+          ) =>
+            login(soapyHeaders?.credentials)
+              .then(splitId(id))
+              .then(({ musicLibrary, typeId }) =>
+                musicLibrary.rate(typeId, ratingFromInt(Math.abs(rating)))
+              )
+              .then((_) => ({ rateItemResult: { shouldSkip: false } })),
+
           setPlayedSeconds: async (
             { id, seconds }: { id: string; seconds: string },
             _,
             soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(splitId(id))
               .then(({ musicLibrary, type, typeId }) => {
                 switch (type) {
                   case "track":
-                    musicLibrary.track(typeId).then(({ duration }) => {
+                    return musicLibrary.track(typeId).then(({ duration }) => {
                       if (
                         (duration < 30 && +seconds >= 10) ||
                         (duration >= 30 && +seconds >= 30)
                       ) {
-                        musicLibrary.scrobble(typeId);
+                        return musicLibrary.scrobble(typeId);
+                      } else {
+                        return Promise.resolve(true);
                       }
                     });
-                    break;
                   default:
                     logger.info("Unsupported scrobble", { id, seconds });
-                    break;
+                    return Promise.resolve(true);
                 }
               })
               .then((_) => ({

src/smapi_auth.ts

@@ -0,0 +1,177 @@
+import { either as E } from "fp-ts";
+import jwt from "jsonwebtoken";
+import { v4 as uuid } from "uuid";
+import { b64Decode, b64Encode } from "./b64";
+import { Clock } from "./clock";
+
+export type SmapiFault = { Fault: { faultcode: string; faultstring: string } };
+export type SmapiRefreshTokenResultFault = SmapiFault & {
+  Fault: {
+    detail: {
+      refreshAuthTokenResult: { authToken: string; privateKey: string };
+    };
+  };
+};
+
+function isError(thing: any): thing is Error {
+  return thing.name && thing.message;
+}
+
+export function isSmapiRefreshTokenResultFault(
+  fault: SmapiFault
+): fault is SmapiRefreshTokenResultFault {
+  return (fault.Fault as any).detail?.refreshAuthTokenResult != undefined;
+}
+
+export type SmapiToken = {
+  token: string;
+  key: string;
+};
+
+export interface ToSmapiFault {
+  _tag: string;
+  toSmapiFault(): SmapiFault
+}
+
+export const SMAPI_FAULT_LOGIN_UNAUTHORIZED = {
+  Fault: {
+    faultcode: "Client.LoginUnauthorized",
+    faultstring:
+      "Failed to authenticate, try Re-Authorising your account in the sonos app",
+  },
+};
+
+export const SMAPI_FAULT_LOGIN_UNSUPPORTED = {
+  Fault: {
+    faultcode: "Client.LoginUnsupported",
+    faultstring: "Missing credentials...",
+  },
+};
+
+export class MissingLoginTokenError extends Error implements ToSmapiFault {
+  _tag = "MissingLoginTokenError";
+
+  constructor() {
+    super("Missing Login Token");
+  }
+
+  toSmapiFault = () => SMAPI_FAULT_LOGIN_UNSUPPORTED;
+}
+
+
+export class InvalidTokenError extends Error implements ToSmapiFault {
+  _tag = "InvalidTokenError";
+
+  constructor(message: string) {
+    super(message);
+  }
+
+  toSmapiFault = () => SMAPI_FAULT_LOGIN_UNAUTHORIZED;
+}
+
+export function isExpiredTokenError(thing: any): thing is ExpiredTokenError {
+  return thing._tag == "ExpiredTokenError";
+}
+
+export class ExpiredTokenError extends Error implements ToSmapiFault {
+  _tag = "ExpiredTokenError";
+  expiredToken: string;
+
+  constructor(expiredToken: string) {
+    super("SMAPI token has expired");
+    this.expiredToken = expiredToken;
+  }
+
+  toSmapiFault = () => ({
+    Fault: {
+      faultcode: "Client.TokenRefreshRequired",
+      faultstring: "Token has expired",
+    },
+  });
+}
+
+export type SmapiAuthTokens = {
+  issue: (serviceToken: string) => SmapiToken;
+  verify: (smapiToken: SmapiToken) => E.Either<ToSmapiFault, string>;
+};
+
+type TokenExpiredError = {
+  name: string;
+  message: string;
+  expiredAt: number;
+};
+
+function isTokenExpiredError(thing: any): thing is TokenExpiredError {
+  return thing.name == "TokenExpiredError";
+}
+
+export const smapiTokenAsString = (smapiToken: SmapiToken) =>
+  b64Encode(
+    JSON.stringify({
+      token: smapiToken.token,
+      key: smapiToken.key,
+    })
+  );
+export const smapiTokenFromString = (smapiTokenString: string): SmapiToken =>
+  JSON.parse(b64Decode(smapiTokenString));
+
+export const SMAPI_TOKEN_VERSION = 2;
+
+export class JWTSmapiLoginTokens implements SmapiAuthTokens {
+  private readonly clock: Clock;
+  private readonly secret: string;
+  private readonly expiresIn: string;
+  private readonly version: number;
+  private readonly keyGenerator: () => string;
+
+  constructor(
+    clock: Clock,
+    secret: string,
+    expiresIn: string,
+    keyGenerator: () => string = uuid,
+    version: number = SMAPI_TOKEN_VERSION
+  ) {
+    this.clock = clock;
+    this.secret = secret;
+    this.expiresIn = expiresIn;
+    this.version = version;
+    this.keyGenerator = keyGenerator;
+  }
+
+  issue = (serviceToken: string) => {
+    const key = this.keyGenerator();
+    return {
+      token: jwt.sign(
+        { serviceToken, iat: this.clock.now().unix() },
+        this.secret + this.version + key,
+        { expiresIn: this.expiresIn }
+      ),
+      key,
+    };
+  };
+
+  verify = (smapiToken: SmapiToken): E.Either<ToSmapiFault, string> => {
+    try {
+      return E.right(
+        (
+          jwt.verify(
+            smapiToken.token,
+            this.secret + this.version + smapiToken.key
+          ) as any
+        ).serviceToken
+      );
+    } catch (e) {
+      if (isTokenExpiredError(e)) {
+        const serviceToken = (
+          jwt.verify(
+            smapiToken.token,
+            this.secret + this.version + smapiToken.key,
+            { ignoreExpiration: true }
+          ) as any
+        ).serviceToken;
+        return E.left(new ExpiredTokenError(serviceToken));
+      } else if (isError(e)) return E.left(new InvalidTokenError(e.message));
+      else return E.left(new InvalidTokenError("Failed to verify token"));
+    }
+  };
+}

src/sonos.ts

@@ -24,25 +24,25 @@ export const SONOS_LANG: LANG[] = [
   "zh-CN",
 ];
 
-export const PRESENTATION_AND_STRINGS_VERSION = "21";
+export const PRESENTATION_AND_STRINGS_VERSION =
+  process.env["BNB_DEBUG"] === "true"
+    ? `${Math.round(new Date().getTime() / 1000)}`
+    : "23";
 
-// NOTE: manifest requires https for the URL,
-// otherwise you will get an error trying to register
+// NOTE: manifest requires https for the URL, otherwise you will get an error trying to register
 export type Capability =
   | "search"
-  | "trFavorites"
-  | "alFavorites"
-  | "ucPlaylists"
-  | "extendedMD"
+  | "trFavorites" // Favorites: Adding/Removing Tracks (deprecated)
+  | "alFavorites" // Favorites: Adding/Removing Albums (deprecated)
+  | "ucPlaylists" // User Content Playlists
+  | "extendedMD" // Extended Metadata (More Menu, Info & Options)
   | "contextHeaders"
   | "authorizationHeader"
-  | "logging"
+  | "logging" // Playback duration logging at track end (deprecated)
   | "manifest";
 
 export const BONOB_CAPABILITIES: Capability[] = [
   "search",
-  // "trFavorites",
-  // "alFavorites",
   "ucPlaylists",
   "extendedMD",
   "logging",
@@ -101,8 +101,8 @@ export interface Sonos {
 export const SONOS_DISABLED: Sonos = {
   devices: () => Promise.resolve([]),
   services: () => Promise.resolve([]),
-  remove: (_: number) => Promise.resolve(true),
-  register: (_: Service) => Promise.resolve(true),
+  remove: (_: number) => Promise.resolve(false),
+  register: (_: Service) => Promise.resolve(false),
 };
 
 export const asService = (musicService: MusicService): Service => ({
@@ -243,13 +243,11 @@ export function autoDiscoverySonos(sonosSeedHost?: string): Sonos {
 }
 
 export type Discovery = {
-  auto: boolean;
+  enabled: boolean;
   seedHost?: string;
 };
 
-export default (
-  sonosDiscovery: Discovery = { auto: true }
-): Sonos =>
-  sonosDiscovery.auto
+export default (sonosDiscovery: Discovery = { enabled: true }): Sonos =>
+  sonosDiscovery.enabled
     ? autoDiscoverySonos(sonosDiscovery.seedHost)
     : SONOS_DISABLED;

src/subsonic.ts

@@ -0,0 +1,978 @@
+import { option as O, taskEither as TE } from "fp-ts";
+import * as A from "fp-ts/Array";
+import { ordString } from "fp-ts/lib/Ord";
+import { pipe } from "fp-ts/lib/function";
+import { Md5 } from "ts-md5/dist/md5";
+import {
+  Credentials,
+  MusicService,
+  Album,
+  Result,
+  slice2,
+  AlbumQuery,
+  ArtistQuery,
+  MusicLibrary,
+  AlbumSummary,
+  Genre,
+  Track,
+  CoverArt,
+  Rating,
+  AlbumQueryType,
+  Artist,
+  AuthFailure,
+} from "./music_service";
+import sharp from "sharp";
+import _ from "underscore";
+import fse from "fs-extra";
+import path from "path";
+
+import axios, { AxiosRequestConfig } from "axios";
+import randomstring from "randomstring";
+import { b64Encode, b64Decode } from "./b64";
+import logger from "./logger";
+import { assertSystem, BUrn } from "./burn";
+import { artist } from "./smapi";
+
+export const BROWSER_HEADERS = {
+  accept:
+    "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+  "accept-encoding": "gzip, deflate, br",
+  "accept-language": "en-GB,en;q=0.5",
+  "upgrade-insecure-requests": "1",
+  "user-agent":
+    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0",
+};
+
+export const t = (password: string, s: string) =>
+  Md5.hashStr(`${password}${s}`);
+
+export const t_and_s = (password: string) => {
+  const s = randomstring.generate();
+  return {
+    t: t(password, s),
+    s,
+  };
+};
+
+export const DODGY_IMAGE_NAME = "2a96cbd8b46e442fc41c2b86b821562f.png";
+
+export const isValidImage = (url: string | undefined) =>
+  url != undefined && !url.endsWith(DODGY_IMAGE_NAME);
+
+type SubsonicEnvelope = {
+  "subsonic-response": SubsonicResponse;
+};
+
+type SubsonicResponse = {
+  status: string;
+};
+
+type album = {
+  id: string;
+  name: string;
+  artist: string | undefined;
+  artistId: string | undefined;
+  coverArt: string | undefined;
+  genre: string | undefined;
+  year: string | undefined;
+};
+
+type artist = {
+  id: string;
+  name: string;
+  albumCount: number;
+  artistImageUrl: string | undefined;
+};
+
+type GetArtistsResponse = SubsonicResponse & {
+  artists: {
+    index: {
+      artist: artist[];
+      name: string;
+    }[];
+  };
+};
+
+type GetAlbumListResponse = SubsonicResponse & {
+  albumList2: {
+    album: album[];
+  };
+};
+
+type genre = {
+  songCount: number;
+  albumCount: number;
+  value: string;
+};
+
+type GetGenresResponse = SubsonicResponse & {
+  genres: {
+    genre: genre[];
+  };
+};
+
+type SubsonicError = SubsonicResponse & {
+  error: {
+    code: string;
+    message: string;
+  };
+};
+
+export type images = {
+  smallImageUrl: string | undefined;
+  mediumImageUrl: string | undefined;
+  largeImageUrl: string | undefined;
+};
+
+type artistInfo = images & {
+  biography: string | undefined;
+  musicBrainzId: string | undefined;
+  lastFmUrl: string | undefined;
+  similarArtist: artist[];
+};
+
+type ArtistSummary = IdName & {
+  image: BUrn | undefined;
+};
+
+type GetArtistInfoResponse = SubsonicResponse & {
+  artistInfo2: artistInfo;
+};
+
+type GetArtistResponse = SubsonicResponse & {
+  artist: artist & {
+    album: album[];
+  };
+};
+
+export type song = {
+  id: string;
+  parent: string | undefined;
+  title: string;
+  album: string | undefined;
+  albumId: string | undefined;
+  artist: string | undefined;
+  artistId: string | undefined;
+  track: number | undefined;
+  year: string | undefined;
+  genre: string | undefined;
+  coverArt: string | undefined;
+  created: string | undefined;
+  duration: number | undefined;
+  bitRate: number | undefined;
+  suffix: string | undefined;
+  contentType: string | undefined;
+  type: string | undefined;
+  userRating: number | undefined;
+  starred: string | undefined;
+};
+
+type GetAlbumResponse = {
+  album: album & {
+    song: song[];
+  };
+};
+
+type playlist = {
+  id: string;
+  name: string;
+};
+
+type GetPlaylistResponse = {
+  playlist: {
+    id: string;
+    name: string;
+    entry: song[];
+  };
+};
+
+type GetPlaylistsResponse = {
+  playlists: { playlist: playlist[] };
+};
+
+type GetSimilarSongsResponse = {
+  similarSongs2: { song: song[] };
+};
+
+type GetTopSongsResponse = {
+  topSongs: { song: song[] };
+};
+
+type GetSongResponse = {
+  song: song;
+};
+
+type GetStarredResponse = {
+  starred2: {
+    song: song[];
+    album: album[];
+  };
+};
+
+export type PingResponse = {
+  status: string;
+  version: string;
+  type: string;
+  serverVersion: string;
+};
+
+type Search3Response = SubsonicResponse & {
+  searchResult3: {
+    artist: artist[];
+    album: album[];
+    song: song[];
+  };
+};
+
+export function isError(
+  subsonicResponse: SubsonicResponse
+): subsonicResponse is SubsonicError {
+  return (subsonicResponse as SubsonicError).error !== undefined;
+}
+
+type IdName = {
+  id: string;
+  name: string;
+};
+
+const coverArtURN = (coverArt: string | undefined): BUrn | undefined =>
+  pipe(
+    coverArt,
+    O.fromNullable,
+    O.map((it: string) => ({ system: "subsonic", resource: `art:${it}` })),
+    O.getOrElseW(() => undefined)
+  );
+
+export const artistImageURN = (
+  spec: Partial<{
+    artistId: string | undefined;
+    artistImageURL: string | undefined;
+  }>
+): BUrn | undefined => {
+  const deets = {
+    artistId: undefined,
+    artistImageURL: undefined,
+    ...spec,
+  };
+  if (deets.artistImageURL && isValidImage(deets.artistImageURL)) {
+    return {
+      system: "external",
+      resource: deets.artistImageURL,
+    };
+  } else if (artistIsInLibrary(deets.artistId)) {
+    return {
+      system: "subsonic",
+      resource: `art:${deets.artistId!}`,
+    };
+  } else {
+    return undefined;
+  }
+};
+
+export const asTrack = (album: Album, song: song): Track => ({
+  id: song.id,
+  name: song.title,
+  mimeType: song.contentType!,
+  duration: song.duration || 0,
+  number: song.track || 0,
+  genre: maybeAsGenre(song.genre),
+  coverArt: coverArtURN(song.coverArt),
+  album,
+  artist: {
+    id: song.artistId,
+    name: song.artist ? song.artist : "?",
+    image: song.artistId
+      ? artistImageURN({ artistId: song.artistId })
+      : undefined,
+  },
+  rating: {
+    love: song.starred != undefined,
+    stars:
+      song.userRating && song.userRating <= 5 && song.userRating >= 0
+        ? song.userRating
+        : 0,
+  },
+});
+
+const asAlbum = (album: album): Album => ({
+  id: album.id,
+  name: album.name,
+  year: album.year,
+  genre: maybeAsGenre(album.genre),
+  artistId: album.artistId,
+  artistName: album.artist,
+  coverArt: coverArtURN(album.coverArt),
+});
+
+export const asGenre = (genreName: string) => ({
+  id: b64Encode(genreName),
+  name: genreName,
+});
+
+const maybeAsGenre = (genreName: string | undefined): Genre | undefined =>
+  pipe(
+    genreName,
+    O.fromNullable,
+    O.map(asGenre),
+    O.getOrElseW(() => undefined)
+  );
+
+export type StreamClientApplication = (track: Track) => string;
+
+const DEFAULT_CLIENT_APPLICATION = "bonob";
+const USER_AGENT = "bonob";
+
+export const DEFAULT: StreamClientApplication = (_: Track) =>
+  DEFAULT_CLIENT_APPLICATION;
+
+export function appendMimeTypeToClientFor(mimeTypes: string[]) {
+  return (track: Track) =>
+    mimeTypes.includes(track.mimeType) ? `bonob+${track.mimeType}` : "bonob";
+}
+
+export const asURLSearchParams = (q: any) => {
+  const urlSearchParams = new URLSearchParams();
+  Object.keys(q).forEach((k) => {
+    _.flatten([q[k]]).forEach((v) => {
+      urlSearchParams.append(k, `${v}`);
+    });
+  });
+  return urlSearchParams;
+};
+
+export type ImageFetcher = (url: string) => Promise<CoverArt | undefined>;
+
+export const cachingImageFetcher =
+  (cacheDir: string, delegate: ImageFetcher) =>
+  async (url: string): Promise<CoverArt | undefined> => {
+    const filename = path.join(cacheDir, `${Md5.hashStr(url)}.png`);
+    return fse
+      .readFile(filename)
+      .then((data) => ({ contentType: "image/png", data }))
+      .catch(() =>
+        delegate(url).then((image) => {
+          if (image) {
+            return sharp(image.data)
+              .png()
+              .toBuffer()
+              .then((png) => {
+                return fse
+                  .writeFile(filename, png)
+                  .then(() => ({ contentType: "image/png", data: png }));
+              });
+          } else {
+            return undefined;
+          }
+        })
+      );
+  };
+
+export const axiosImageFetcher = (url: string): Promise<CoverArt | undefined> =>
+  axios
+    .get(url, {
+      headers: BROWSER_HEADERS,
+      responseType: "arraybuffer",
+    })
+    .then((res) => ({
+      contentType: res.headers["content-type"],
+      data: Buffer.from(res.data, "binary"),
+    }))
+    .catch(() => undefined);
+
+const AlbumQueryTypeToSubsonicType: Record<AlbumQueryType, string> = {
+  alphabeticalByArtist: "alphabeticalByArtist",
+  alphabeticalByName: "alphabeticalByName",
+  byGenre: "byGenre",
+  random: "random",
+  recentlyPlayed: "recent",
+  mostPlayed: "frequent",
+  recentlyAdded: "newest",
+  favourited: "starred",
+  starred: "highest",
+};
+
+const artistIsInLibrary = (artistId: string | undefined) =>
+  artistId != undefined && artistId != "-1";
+
+type SubsonicCredentials = Credentials & {
+  type: string;
+  bearer: string | undefined;
+};
+
+export const asToken = (credentials: SubsonicCredentials) =>
+  b64Encode(JSON.stringify(credentials));
+export const parseToken = (token: string): SubsonicCredentials =>
+  JSON.parse(b64Decode(token));
+
+interface SubsonicMusicLibrary extends MusicLibrary {
+  flavour(): string;
+  bearerToken(
+    credentials: Credentials
+  ): TE.TaskEither<Error, string | undefined>;
+}
+
+export class Subsonic implements MusicService {
+  url: string;
+  streamClientApplication: StreamClientApplication;
+  externalImageFetcher: ImageFetcher;
+
+  constructor(
+    url: string,
+    streamClientApplication: StreamClientApplication = DEFAULT,
+    externalImageFetcher: ImageFetcher = axiosImageFetcher
+  ) {
+    this.url = url;
+    this.streamClientApplication = streamClientApplication;
+    this.externalImageFetcher = externalImageFetcher;
+  }
+
+  get = async (
+    { username, password }: Credentials,
+    path: string,
+    q: {} = {},
+    config: AxiosRequestConfig | undefined = {}
+  ) =>
+    axios
+      .get(`${this.url}${path}`, {
+        params: asURLSearchParams({
+          u: username,
+          v: "1.16.1",
+          c: DEFAULT_CLIENT_APPLICATION,
+          ...t_and_s(password),
+          ...q,
+        }),
+        headers: {
+          "User-Agent": USER_AGENT,
+        },
+        ...config,
+      })
+      .catch((e) => {
+        throw `Subsonic failed with: ${e}`;
+      })
+      .then((response) => {
+        if (response.status != 200 && response.status != 206) {
+          throw `Subsonic failed with a ${response.status || "no!"} status`;
+        } else return response;
+      });
+
+  getJSON = async <T>(
+    { username, password }: Credentials,
+    path: string,
+    q: {} = {}
+  ): Promise<T> =>
+    this.get({ username, password }, path, { f: "json", ...q })
+      .then((response) => response.data as SubsonicEnvelope)
+      .then((json) => json["subsonic-response"])
+      .then((json) => {
+        if (isError(json)) throw `Subsonic error:${json.error.message}`;
+        else return json as unknown as T;
+      });
+
+  generateToken = (credentials: Credentials) =>
+    pipe(
+      TE.tryCatch(
+        () =>
+          this.getJSON<PingResponse>(
+            _.pick(credentials, "username", "password"),
+            "/rest/ping.view"
+          ),
+        (e) => new AuthFailure(e as string)
+      ),
+      TE.chain(({ type }) =>
+        pipe(
+          TE.tryCatch(
+            () => this.libraryFor({ ...credentials, type }),
+            () => new AuthFailure("Failed to get library")
+          ),
+          TE.map((library) => ({ type, library }))
+        )
+      ),
+      TE.chain(({ library, type }) =>
+        pipe(
+          library.bearerToken(credentials),
+          TE.map((bearer) => ({ bearer, type }))
+        )
+      ),
+      TE.map(({ bearer, type }) => ({
+        serviceToken: asToken({ ...credentials, bearer, type }),
+        userId: credentials.username,
+        nickname: credentials.username,
+      }))
+    );
+
+  refreshToken = (serviceToken: string) =>
+    this.generateToken(parseToken(serviceToken));
+
+  getArtists = (
+    credentials: Credentials
+  ): Promise<(IdName & { albumCount: number; image: BUrn | undefined })[]> =>
+    this.getJSON<GetArtistsResponse>(credentials, "/rest/getArtists")
+      .then((it) => (it.artists.index || []).flatMap((it) => it.artist || []))
+      .then((artists) =>
+        artists.map((artist) => ({
+          id: `${artist.id}`,
+          name: artist.name,
+          albumCount: artist.albumCount,
+          image: artistImageURN({
+            artistId: artist.id,
+            artistImageURL: artist.artistImageUrl,
+          }),
+        }))
+      );
+
+  getArtistInfo = (
+    credentials: Credentials,
+    id: string
+  ): Promise<{
+    similarArtist: (ArtistSummary & { inLibrary: boolean })[];
+    images: {
+      s: string | undefined;
+      m: string | undefined;
+      l: string | undefined;
+    };
+  }> =>
+    this.getJSON<GetArtistInfoResponse>(credentials, "/rest/getArtistInfo2", {
+      id,
+      count: 50,
+      includeNotPresent: true,
+    })
+      .then((it) => it.artistInfo2)
+      .then((it) => ({
+        images: {
+          s: it.smallImageUrl,
+          m: it.mediumImageUrl,
+          l: it.largeImageUrl,
+        },
+        similarArtist: (it.similarArtist || []).map((artist) => ({
+          id: `${artist.id}`,
+          name: artist.name,
+          inLibrary: artistIsInLibrary(artist.id),
+          image: artistImageURN({
+            artistId: artist.id,
+            artistImageURL: artist.artistImageUrl,
+          }),
+        })),
+      }));
+
+  getAlbum = (credentials: Credentials, id: string): Promise<Album> =>
+    this.getJSON<GetAlbumResponse>(credentials, "/rest/getAlbum", { id })
+      .then((it) => it.album)
+      .then((album) => ({
+        id: album.id,
+        name: album.name,
+        year: album.year,
+        genre: maybeAsGenre(album.genre),
+        artistId: album.artistId,
+        artistName: album.artist,
+        coverArt: coverArtURN(album.coverArt),
+      }));
+
+  getArtist = (
+    credentials: Credentials,
+    id: string
+  ): Promise<
+    IdName & { artistImageUrl: string | undefined; albums: AlbumSummary[] }
+  > =>
+    this.getJSON<GetArtistResponse>(credentials, "/rest/getArtist", {
+      id,
+    })
+      .then((it) => it.artist)
+      .then((it) => ({
+        id: it.id,
+        name: it.name,
+        artistImageUrl: it.artistImageUrl,
+        albums: this.toAlbumSummary(it.album || []),
+      }));
+
+  getArtistWithInfo = (credentials: Credentials, id: string) =>
+    Promise.all([
+      this.getArtist(credentials, id),
+      this.getArtistInfo(credentials, id),
+    ]).then(([artist, artistInfo]) => ({
+      id: artist.id,
+      name: artist.name,
+      image: artistImageURN({
+        artistId: artist.id,
+        artistImageURL: [
+          artist.artistImageUrl,
+          artistInfo.images.l,
+          artistInfo.images.m,
+          artistInfo.images.s,
+        ].find(isValidImage),
+      }),
+      albums: artist.albums,
+      similarArtists: artistInfo.similarArtist,
+    }));
+
+  getCoverArt = (credentials: Credentials, id: string, size?: number) =>
+    this.get(credentials, "/rest/getCoverArt", size ? { id, size } : { id }, {
+      headers: { "User-Agent": "bonob" },
+      responseType: "arraybuffer",
+    });
+
+  getTrack = (credentials: Credentials, id: string) =>
+    this.getJSON<GetSongResponse>(credentials, "/rest/getSong", {
+      id,
+    })
+      .then((it) => it.song)
+      .then((song) =>
+        this.getAlbum(credentials, song.albumId!).then((album) =>
+          asTrack(album, song)
+        )
+      );
+
+  getStarred = (credentials: Credentials) =>
+    this.getJSON<GetStarredResponse>(credentials, "/rest/getStarred2").then(
+      (it) => new Set(it.starred2.song.map((it) => it.id))
+    );
+
+  toAlbumSummary = (albumList: album[]): AlbumSummary[] =>
+    albumList.map((album) => ({
+      id: album.id,
+      name: album.name,
+      year: album.year,
+      genre: maybeAsGenre(album.genre),
+      artistId: album.artistId,
+      artistName: album.artist,
+      coverArt: coverArtURN(album.coverArt),
+    }));
+
+  search3 = (credentials: Credentials, q: any) =>
+    this.getJSON<Search3Response>(credentials, "/rest/search3", {
+      artistCount: 0,
+      albumCount: 0,
+      songCount: 0,
+      ...q,
+    }).then((it) => ({
+      artists: it.searchResult3.artist || [],
+      albums: it.searchResult3.album || [],
+      songs: it.searchResult3.song || [],
+    }));
+
+  getAlbumList2 = (credentials: Credentials, q: AlbumQuery) =>
+    Promise.all([
+      this.getArtists(credentials).then((it) =>
+        _.inject(it, (total, artist) => total + artist.albumCount, 0)
+      ),
+      this.getJSON<GetAlbumListResponse>(credentials, "/rest/getAlbumList2", {
+        type: AlbumQueryTypeToSubsonicType[q.type],
+        ...(q.genre ? { genre: b64Decode(q.genre) } : {}),
+        size: 500,
+        offset: q._index,
+      })
+        .then((response) => response.albumList2.album || [])
+        .then(this.toAlbumSummary),
+    ]).then(([total, albums]) => ({
+      results: albums.slice(0, q._count),
+      total: albums.length == 500 ? total : q._index + albums.length,
+    }));
+
+  // getStarred2 = (credentials: Credentials): Promise<{ albums: Album[] }> =>
+  //   this.getJSON<GetStarredResponse>(credentials, "/rest/getStarred2")
+  //     .then((it) => it.starred2)
+  //     .then((it) => ({
+  //       albums: it.album.map(asAlbum),
+  //     }));
+
+  login = async (token: string) => this.libraryFor(parseToken(token));
+
+  private libraryFor = (
+    credentials: Credentials & { type: string }
+  ): Promise<SubsonicMusicLibrary> => {
+    const subsonic = this;
+
+    const genericSubsonic: SubsonicMusicLibrary = {
+      flavour: () => "subsonic",
+      bearerToken: (_: Credentials) => TE.right(undefined),
+      artists: (q: ArtistQuery): Promise<Result<ArtistSummary>> =>
+        subsonic
+          .getArtists(credentials)
+          .then(slice2(q))
+          .then(([page, total]) => ({
+            total,
+            results: page.map((it) => ({
+              id: it.id,
+              name: it.name,
+              image: it.image,
+            })),
+          })),
+      artist: async (id: string): Promise<Artist> =>
+        subsonic.getArtistWithInfo(credentials, id),
+      albums: async (q: AlbumQuery): Promise<Result<AlbumSummary>> =>
+        subsonic.getAlbumList2(credentials, q),
+      album: (id: string): Promise<Album> => subsonic.getAlbum(credentials, id),
+      genres: () =>
+        subsonic
+          .getJSON<GetGenresResponse>(credentials, "/rest/getGenres")
+          .then((it) =>
+            pipe(
+              it.genres.genre || [],
+              A.filter((it) => it.albumCount > 0),
+              A.map((it) => it.value),
+              A.sort(ordString),
+              A.map((it) => ({ id: b64Encode(it), name: it }))
+            )
+          ),
+      tracks: (albumId: string) =>
+        subsonic
+          .getJSON<GetAlbumResponse>(credentials, "/rest/getAlbum", {
+            id: albumId,
+          })
+          .then((it) => it.album)
+          .then((album) =>
+            (album.song || []).map((song) => asTrack(asAlbum(album), song))
+          ),
+      track: (trackId: string) => subsonic.getTrack(credentials, trackId),
+      rate: (trackId: string, rating: Rating) =>
+        Promise.resolve(true)
+          .then(() => {
+            if (rating.stars >= 0 && rating.stars <= 5) {
+              return subsonic.getTrack(credentials, trackId);
+            } else {
+              throw `Invalid rating.stars value of ${rating.stars}`;
+            }
+          })
+          .then((track) => {
+            const thingsToUpdate = [];
+            if (track.rating.love != rating.love) {
+              thingsToUpdate.push(
+                subsonic.getJSON(
+                  credentials,
+                  `/rest/${rating.love ? "star" : "unstar"}`,
+                  {
+                    id: trackId,
+                  }
+                )
+              );
+            }
+            if (track.rating.stars != rating.stars) {
+              thingsToUpdate.push(
+                subsonic.getJSON(credentials, `/rest/setRating`, {
+                  id: trackId,
+                  rating: rating.stars,
+                })
+              );
+            }
+            return Promise.all(thingsToUpdate);
+          })
+          .then(() => true)
+          .catch(() => false),
+      stream: async ({
+        trackId,
+        range,
+      }: {
+        trackId: string;
+        range: string | undefined;
+      }) =>
+        subsonic.getTrack(credentials, trackId).then((track) =>
+          subsonic
+            .get(
+              credentials,
+              `/rest/stream`,
+              {
+                id: trackId,
+                c: this.streamClientApplication(track),
+              },
+              {
+                headers: pipe(
+                  range,
+                  O.fromNullable,
+                  O.map((range) => ({
+                    "User-Agent": USER_AGENT,
+                    Range: range,
+                  })),
+                  O.getOrElse(() => ({
+                    "User-Agent": USER_AGENT,
+                  }))
+                ),
+                responseType: "stream",
+              }
+            )
+            .then((res) => ({
+              status: res.status,
+              headers: {
+                "content-type": res.headers["content-type"],
+                "content-length": res.headers["content-length"],
+                "content-range": res.headers["content-range"],
+                "accept-ranges": res.headers["accept-ranges"],
+              },
+              stream: res.data,
+            }))
+        ),
+      coverArt: async (coverArtURN: BUrn, size?: number) =>
+        Promise.resolve(coverArtURN)
+          .then((it) => assertSystem(it, "subsonic"))
+          .then((it) => it.resource.split(":")[1]!)
+          .then((it) => subsonic.getCoverArt(credentials, it, size))
+          .then((res) => ({
+            contentType: res.headers["content-type"],
+            data: Buffer.from(res.data, "binary"),
+          }))
+          .catch((e) => {
+            logger.error(
+              `Failed getting coverArt for urn:'${coverArtURN}': ${e}`
+            );
+            return undefined;
+          }),
+      scrobble: async (id: string) =>
+        subsonic
+          .getJSON(credentials, `/rest/scrobble`, {
+            id,
+            submission: true,
+          })
+          .then((_) => true)
+          .catch(() => false),
+      nowPlaying: async (id: string) =>
+        subsonic
+          .getJSON(credentials, `/rest/scrobble`, {
+            id,
+            submission: false,
+          })
+          .then((_) => true)
+          .catch(() => false),
+      searchArtists: async (query: string) =>
+        subsonic
+          .search3(credentials, { query, artistCount: 20 })
+          .then(({ artists }) =>
+            artists.map((artist) => ({
+              id: artist.id,
+              name: artist.name,
+              image: artistImageURN({
+                artistId: artist.id,
+                artistImageURL: artist.artistImageUrl,
+              }),
+            }))
+          ),
+      searchAlbums: async (query: string) =>
+        subsonic
+          .search3(credentials, { query, albumCount: 20 })
+          .then(({ albums }) => subsonic.toAlbumSummary(albums)),
+      searchTracks: async (query: string) =>
+        subsonic
+          .search3(credentials, { query, songCount: 20 })
+          .then(({ songs }) =>
+            Promise.all(
+              songs.map((it) => subsonic.getTrack(credentials, it.id))
+            )
+          ),
+      playlists: async () =>
+        subsonic
+          .getJSON<GetPlaylistsResponse>(credentials, "/rest/getPlaylists")
+          .then((it) => it.playlists.playlist || [])
+          .then((playlists) =>
+            playlists.map((it) => ({ id: it.id, name: it.name }))
+          ),
+      playlist: async (id: string) =>
+        subsonic
+          .getJSON<GetPlaylistResponse>(credentials, "/rest/getPlaylist", {
+            id,
+          })
+          .then((it) => it.playlist)
+          .then((playlist) => {
+            let trackNumber = 1;
+            return {
+              id: playlist.id,
+              name: playlist.name,
+              entries: (playlist.entry || []).map((entry) => ({
+                ...asTrack(
+                  {
+                    id: entry.albumId!,
+                    name: entry.album!,
+                    year: entry.year,
+                    genre: maybeAsGenre(entry.genre),
+                    artistName: entry.artist,
+                    artistId: entry.artistId,
+                    coverArt: coverArtURN(entry.coverArt),
+                  },
+                  entry
+                ),
+                number: trackNumber++,
+              })),
+            };
+          }),
+      createPlaylist: async (name: string) =>
+        subsonic
+          .getJSON<GetPlaylistResponse>(credentials, "/rest/createPlaylist", {
+            name,
+          })
+          .then((it) => it.playlist)
+          .then((it) => ({ id: it.id, name: it.name })),
+      deletePlaylist: async (id: string) =>
+        subsonic
+          .getJSON<GetPlaylistResponse>(credentials, "/rest/deletePlaylist", {
+            id,
+          })
+          .then((_) => true),
+      addToPlaylist: async (playlistId: string, trackId: string) =>
+        subsonic
+          .getJSON<GetPlaylistResponse>(credentials, "/rest/updatePlaylist", {
+            playlistId,
+            songIdToAdd: trackId,
+          })
+          .then((_) => true),
+      removeFromPlaylist: async (playlistId: string, indicies: number[]) =>
+        subsonic
+          .getJSON<GetPlaylistResponse>(credentials, "/rest/updatePlaylist", {
+            playlistId,
+            songIndexToRemove: indicies,
+          })
+          .then((_) => true),
+      similarSongs: async (id: string) =>
+        subsonic
+          .getJSON<GetSimilarSongsResponse>(
+            credentials,
+            "/rest/getSimilarSongs2",
+            { id, count: 50 }
+          )
+          .then((it) => it.similarSongs2.song || [])
+          .then((songs) =>
+            Promise.all(
+              songs.map((song) =>
+                subsonic
+                  .getAlbum(credentials, song.albumId!)
+                  .then((album) => asTrack(album, song))
+              )
+            )
+          ),
+      topSongs: async (artistId: string) =>
+        subsonic.getArtist(credentials, artistId).then(({ name }) =>
+          subsonic
+            .getJSON<GetTopSongsResponse>(credentials, "/rest/getTopSongs", {
+              artist: name,
+              count: 50,
+            })
+            .then((it) => it.topSongs.song || [])
+            .then((songs) =>
+              Promise.all(
+                songs.map((song) =>
+                  subsonic
+                    .getAlbum(credentials, song.albumId!)
+                    .then((album) => asTrack(album, song))
+                )
+              )
+            )
+        ),
+    };
+
+    if (credentials.type == "navidrome") {
+      return Promise.resolve({
+        ...genericSubsonic,
+        flavour: () => "navidrome",
+        bearerToken: (credentials: Credentials) =>
+          pipe(
+            TE.tryCatch(
+              () =>
+                axios.post(
+                  `${this.url}/auth/login`,
+                  _.pick(credentials, "username", "password")
+                ),
+              () => new AuthFailure("Failed to get bearerToken")
+            ),
+            TE.map((it) => it.data.token as string | undefined)
+          ),
+      });
+    } else {
+      return Promise.resolve(genericSubsonic);
+    }
+  };
+}

tests/access_tokens.test.ts

@@ -1,273 +0,0 @@
-import { v4 as uuid } from "uuid";
-import dayjs from "dayjs";
-
-import {
-  AccessTokenPerAuthToken,
-  EncryptedAccessTokens,
-  ExpiringAccessTokens,
-  InMemoryAccessTokens,
-  sha256
-} from "../src/access_tokens";
-import { Encryption } from "../src/encryption";
-
-describe("ExpiringAccessTokens", () => {
-  let now = dayjs();
-
-  const accessTokens = new ExpiringAccessTokens({ now: () => now });
-
-  describe("tokens", () => {
-    it("they should be unique", () => {
-      const authToken = uuid();
-      expect(accessTokens.mint(authToken)).not.toEqual(
-        accessTokens.mint(authToken)
-      );
-    });
-  });
-
-  describe("tokens that dont exist", () => {
-    it("should return undefined", () => {
-      expect(accessTokens.authTokenFor("doesnt exist")).toBeUndefined();
-    });
-  });
-
-  describe("tokens that have not expired", () => {
-    it("should be able to return them", () => {
-      const authToken = uuid();
-
-      const accessToken = accessTokens.mint(authToken);
-
-      expect(accessTokens.authTokenFor(accessToken)).toEqual(authToken);
-    });
-
-    it("should be able to have many per authToken", () => {
-      const authToken = uuid();
-
-      const accessToken1 = accessTokens.mint(authToken);
-      const accessToken2 = accessTokens.mint(authToken);
-
-      expect(accessTokens.authTokenFor(accessToken1)).toEqual(authToken);
-      expect(accessTokens.authTokenFor(accessToken2)).toEqual(authToken);
-    });
-  });
-
-  describe("tokens that have expired", () => {
-    describe("retrieving it", () => {
-      it("should return undefined", () => {
-        const authToken = uuid();
-
-        now = dayjs();
-        const accessToken = accessTokens.mint(authToken);
-
-        now = now.add(12, "hours").add(1, "second");
-
-        expect(accessTokens.authTokenFor(accessToken)).toBeUndefined();
-      });
-    });
-
-    describe("should be cleared out", () => {
-      const authToken1 = uuid();
-      const authToken2 = uuid();
-
-      now = dayjs();
-
-      const accessToken1_1 = accessTokens.mint(authToken1);
-      const accessToken2_1 = accessTokens.mint(authToken2);
-
-      expect(accessTokens.count()).toEqual(2);
-      expect(accessTokens.authTokenFor(accessToken1_1)).toEqual(authToken1);
-      expect(accessTokens.authTokenFor(accessToken2_1)).toEqual(authToken2);
-
-      now = now.add(12, "hours").add(1, "second");
-
-      const accessToken1_2 = accessTokens.mint(authToken1);
-
-      expect(accessTokens.count()).toEqual(1);
-      expect(accessTokens.authTokenFor(accessToken1_1)).toBeUndefined();
-      expect(accessTokens.authTokenFor(accessToken2_1)).toBeUndefined();
-      expect(accessTokens.authTokenFor(accessToken1_2)).toEqual(authToken1);
-
-      now = now.add(6, "hours");
-
-      const accessToken2_2 = accessTokens.mint(authToken2);
-
-      expect(accessTokens.count()).toEqual(2);
-      expect(accessTokens.authTokenFor(accessToken1_1)).toBeUndefined();
-      expect(accessTokens.authTokenFor(accessToken2_1)).toBeUndefined();
-      expect(accessTokens.authTokenFor(accessToken1_2)).toEqual(authToken1);
-      expect(accessTokens.authTokenFor(accessToken2_2)).toEqual(authToken2);
-
-      now = now.add(6, "hours").add(1, "minute");
-
-      expect(accessTokens.authTokenFor(accessToken1_1)).toBeUndefined();
-      expect(accessTokens.authTokenFor(accessToken2_1)).toBeUndefined();
-      expect(accessTokens.authTokenFor(accessToken1_2)).toBeUndefined();
-      expect(accessTokens.authTokenFor(accessToken2_2)).toEqual(authToken2);
-      expect(accessTokens.count()).toEqual(1);
-
-      now = now.add(6, "hours").add(1, "minute");
-
-      expect(accessTokens.authTokenFor(accessToken1_1)).toBeUndefined();
-      expect(accessTokens.authTokenFor(accessToken2_1)).toBeUndefined();
-      expect(accessTokens.authTokenFor(accessToken1_2)).toBeUndefined();
-      expect(accessTokens.authTokenFor(accessToken2_2)).toBeUndefined();
-      expect(accessTokens.count()).toEqual(0);
-    });
-  });
-});
-
-describe("EncryptedAccessTokens", () => {
-  const encryption = {
-    encrypt: jest.fn(),
-    decrypt: jest.fn(),
-  };
-
-  const accessTokens = new EncryptedAccessTokens(
-    (encryption as unknown) as Encryption
-  );
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.resetAllMocks();
-  });
-
-  describe("encrypt and decrypt", () => {
-    it("should be able to round trip the token", () => {
-      const authToken = `the token - ${uuid()}`;
-      const hash = {
-        encryptedData: "the encrypted token",
-        iv: "vi",
-      };
-
-      encryption.encrypt.mockReturnValue(hash);
-      encryption.decrypt.mockReturnValue(authToken);
-
-      const accessToken = accessTokens.mint(authToken);
-
-      expect(accessToken).not.toContain(authToken);
-      expect(accessToken).toEqual(
-        Buffer.from(JSON.stringify(hash)).toString("base64")
-      );
-
-      expect(accessTokens.authTokenFor(accessToken)).toEqual(authToken);
-
-      expect(encryption.encrypt).toHaveBeenCalledWith(authToken);
-      expect(encryption.decrypt).toHaveBeenCalledWith(hash);
-    });
-  });
-
-  describe("when the token is a valid Hash but doesnt decrypt", () => {
-    it("should return undefined", () => {
-      const hash = {
-        encryptedData: "valid hash",
-        iv: "vi",
-      };
-      encryption.decrypt.mockImplementation(() => {
-        throw "Boooooom decryption failed!!!";
-      });
-      expect(
-        accessTokens.authTokenFor(
-          Buffer.from(JSON.stringify(hash)).toString("base64")
-        )
-      ).toBeUndefined();
-    });
-  });
-
-  describe("when the token is not even a valid hash", () => {
-    it("should return undefined", () => {
-      encryption.decrypt.mockImplementation(() => {
-        throw "Boooooom decryption failed!!!";
-      });
-      expect(accessTokens.authTokenFor("some rubbish")).toBeUndefined();
-    });
-  });
-});
-
-describe("AccessTokenPerAuthToken", () => {
-  const accessTokens = new AccessTokenPerAuthToken();
-
-  it("should return the same access token for the same auth token", () => {
-    const authToken = "token1";
-    
-    const accessToken1 = accessTokens.mint(authToken);
-    const accessToken2 = accessTokens.mint(authToken);
-
-    expect(accessToken1).not.toEqual(authToken);
-    expect(accessToken1).toEqual(accessToken2);
-  });
-
-  describe("when there is an auth token for the access token", () => {
-    it("should be able to retrieve it", () => {
-      const authToken = uuid();
-      const accessToken = accessTokens.mint(authToken);
-
-      expect(accessTokens.authTokenFor(accessToken)).toEqual(authToken);
-    });
-  });
-
-  describe("when there is no auth token for the access token", () => {
-    it("should return undefined", () => {
-      expect(accessTokens.authTokenFor(uuid())).toBeUndefined();
-    });
-  });
-});
-
-describe('sha256 minter', () => {
-  it('should return the same value for the same salt and authToken', () => {
-    const authToken = uuid();
-    const token1 = sha256("salty")(authToken);
-    const token2 = sha256("salty")(authToken);
-
-    expect(token1).not.toEqual(authToken);
-    expect(token1).toEqual(token2);
-  });
-
-  it('should returrn different values for the same salt but different authTokens', () => {
-    const authToken1 = uuid();
-    const authToken2 = uuid();
-
-    const token1 = sha256("salty")(authToken1);
-    const token2= sha256("salty")(authToken2);
-
-    expect(token1).not.toEqual(token2);
-  });
-
-  it('should return different values for the same authToken but different salts', () => {
-    const authToken = uuid();
-
-    const token1 = sha256("salt1")(authToken);
-    const token2= sha256("salt2")(authToken);
-
-    expect(token1).not.toEqual(token2);
-  });
-});
-
-describe("InMemoryAccessTokens", () => {
-  const reverseAuthToken = (authToken: string) => authToken.split("").reverse().join("");
-
-  const accessTokens = new InMemoryAccessTokens(reverseAuthToken);
-
-  it("should return the same access token for the same auth token", () => {
-    const authToken = "token1";
-    
-    const accessToken1 = accessTokens.mint(authToken);
-    const accessToken2 = accessTokens.mint(authToken);
-
-    expect(accessToken1).not.toEqual(authToken);
-    expect(accessToken1).toEqual(accessToken2);
-  });
-
-  describe("when there is an auth token for the access token", () => {
-    it("should be able to retrieve it", () => {
-      const authToken = uuid();
-      const accessToken = accessTokens.mint(authToken);
-
-      expect(accessTokens.authTokenFor(accessToken)).toEqual(authToken);
-    });
-  });
-
-  describe("when there is no auth token for the access token", () => {
-    it("should return undefined", () => {
-      expect(accessTokens.authTokenFor(uuid())).toBeUndefined();
-    });
-  });
-});

tests/api_tokens.test.ts

@@ -0,0 +1,67 @@
+import { v4 as uuid } from "uuid";
+
+import {
+  InMemoryAPITokens,
+  sha256
+} from "../src/api_tokens";
+
+describe('sha256 minter', () => {
+  it('should return the same value for the same salt and authToken', () => {
+    const authToken = uuid();
+    const token1 = sha256("salty")(authToken);
+    const token2 = sha256("salty")(authToken);
+
+    expect(token1).not.toEqual(authToken);
+    expect(token1).toEqual(token2);
+  });
+
+  it('should returrn different values for the same salt but different authTokens', () => {
+    const authToken1 = uuid();
+    const authToken2 = uuid();
+
+    const token1 = sha256("salty")(authToken1);
+    const token2= sha256("salty")(authToken2);
+
+    expect(token1).not.toEqual(token2);
+  });
+
+  it('should return different values for the same authToken but different salts', () => {
+    const authToken = uuid();
+
+    const token1 = sha256("salt1")(authToken);
+    const token2= sha256("salt2")(authToken);
+
+    expect(token1).not.toEqual(token2);
+  });
+});
+
+describe("InMemoryAPITokens", () => {
+  const reverseAuthToken = (authToken: string) => authToken.split("").reverse().join("");
+
+  const accessTokens = new InMemoryAPITokens(reverseAuthToken);
+
+  it("should return the same access token for the same auth token", () => {
+    const authToken = "token1";
+    
+    const accessToken1 = accessTokens.mint(authToken);
+    const accessToken2 = accessTokens.mint(authToken);
+
+    expect(accessToken1).not.toEqual(authToken);
+    expect(accessToken1).toEqual(accessToken2);
+  });
+
+  describe("when there is an auth token for the access token", () => {
+    it("should be able to retrieve it", () => {
+      const authToken = uuid();
+      const accessToken = accessTokens.mint(authToken);
+
+      expect(accessTokens.authTokenFor(accessToken)).toEqual(authToken);
+    });
+  });
+
+  describe("when there is no auth token for the access token", () => {
+    it("should return undefined", () => {
+      expect(accessTokens.authTokenFor(uuid())).toBeUndefined();
+    });
+  });
+});

tests/b64.test.ts

@@ -0,0 +1,17 @@
+import { b64Encode, b64Decode } from "../src/b64";
+
+describe("b64", () => {
+    const value = "foobar100";
+    const encoded = Buffer.from(value).toString("base64");
+
+    describe("encode", () => {
+        it("should encode", () => {
+            expect(b64Encode(value)).toEqual(encoded);
+        });
+    });
+    describe("decode", () => {
+        it("should decode", () => {
+            expect(b64Decode(encoded)).toEqual(value);
+        });
+    });
+});

tests/builders.ts

@@ -1,10 +1,23 @@
 import { SonosDevice } from "@svrooij/sonos/lib";
 import { v4 as uuid } from "uuid";
-import { Credentials } from "../src/smapi";
+import randomstring from "randomstring";
 
+import { Credentials } from "../src/smapi";
 import { Service, Device } from "../src/sonos";
-import { Album, Artist, Track, albumToAlbumSummary, artistToArtistSummary, PlaylistSummary, Playlist } from "../src/music_service";
-import randomString from "../src/random_string";
+import {
+  Album,
+  Artist,
+  Track,
+  albumToAlbumSummary,
+  artistToArtistSummary,
+  PlaylistSummary,
+  Playlist,
+  SimilarArtist,
+  AlbumSummary,
+} from "../src/music_service";
+
+import { b64Encode } from "../src/b64";
+import { artistImageURN } from "../src/subsonic";
 
 const randomInt = (max: number) => Math.floor(Math.random() * Math.floor(max));
 const randomIpAddress = () => `127.0.${randomInt(255)}.${randomInt(255)}`;
@@ -28,22 +41,24 @@ export const aService = (fields: Partial<Service> = {}): Service => ({
   ...fields,
 });
 
-export function aPlaylistSummary(fields: Partial<PlaylistSummary> = {}): PlaylistSummary {
+export function aPlaylistSummary(
+  fields: Partial<PlaylistSummary> = {}
+): PlaylistSummary {
   return {
     id: `playlist-${uuid()}`,
-    name: `playlistname-${randomString()}`,
-    ...fields
-  }
+    name: `playlistname-${randomstring.generate()}`,
+    ...fields,
+  };
 }
 
 export function aPlaylist(fields: Partial<Playlist> = {}): Playlist {
   return {
     id: `playlist-${uuid()}`,
-    name: `playlist-${randomString()}`,
+    name: `playlist-${randomstring.generate()}`,
     entries: [aTrack(), aTrack()],
-    ...fields
-  }
-} 
+    ...fields,
+  };
+}
 
 export function aDevice(fields: Partial<Device> = {}): Device {
   return {
@@ -75,10 +90,11 @@ export function getAppLinkMessage() {
   };
 }
 
-export function someCredentials(token: string): Credentials {
+export function someCredentials({ token, key } : { token: string, key: string }): Credentials {
   return {
     loginToken: {
       token,
+      key,
       householdId: "hh1",
     },
     deviceId: "d1",
@@ -86,49 +102,74 @@ export function someCredentials(token: string): Credentials {
   };
 }
 
+export function aSimilarArtist(
+  fields: Partial<SimilarArtist> = {}
+): SimilarArtist {
+  const id = fields.id || uuid();
+  return {
+    id,
+    name: `Similar Artist ${id}`,
+    image: artistImageURN({ artistId: id }),
+    inLibrary: true,
+    ...fields,
+  };
+}
+
 export function anArtist(fields: Partial<Artist> = {}): Artist {
-  const id = uuid();
+  const id = fields.id || uuid();
   const artist = {
     id,
     name: `Artist ${id}`,
     albums: [anAlbum(), anAlbum(), anAlbum()],
-    image: {
-      small: `/artist/art/${id}/small`,
-      medium: `/artist/art/${id}/small`,
-      large: `/artist/art/${id}/large`,
-    },
+    image: { system: "subsonic", resource: `art:${id}` },
     similarArtists: [
-      { id: uuid(), name: "Similar artist1", inLibrary: true },
-      { id: uuid(), name: "Similar artist2", inLibrary: true },
-      { id: "-1", name: "Artist not in library", inLibrary: false },
+      aSimilarArtist({ id: uuid(), name: "Similar artist1", inLibrary: true }),
+      aSimilarArtist({ id: uuid(), name: "Similar artist2", inLibrary: true }),
+      aSimilarArtist({
+        id: "-1",
+        name: "Artist not in library",
+        inLibrary: false,
+      }),
     ],
     ...fields,
   };
-  artist.albums.forEach(album => {
+  artist.albums.forEach((album) => {
     album.artistId = artist.id;
     album.artistName = artist.name;
-  })
+  });
   return artist;
 }
 
-export const HIP_HOP = { id: "genre_hip_hop", name: "Hip-Hop" };
-export const METAL = { id: "genre_metal", name: "Metal" };
-export const NEW_WAVE = { id: "genre_new_wave", name: "New Wave" };
-export const POP = { id: "genre_pop", name: "Pop" };
-export const POP_ROCK = { id: "genre_pop_rock", name: "Pop Rock" };
-export const REGGAE = { id: "genre_reggae", name: "Reggae" };
-export const ROCK = { id: "genre_rock", name: "Rock" };
-export const SKA = { id: "genre_ska", name: "Ska" };
-export const PUNK = { id: "genre_punk", name: "Punk" };
-export const TRIP_HOP = { id: "genre_trip_hop", name: "Trip Hop" };
+export const aGenre = (name: string) => ({ id: b64Encode(name), name });
 
-export const SAMPLE_GENRES = [HIP_HOP, METAL, NEW_WAVE, POP, POP_ROCK, REGGAE, ROCK, SKA];
+export const HIP_HOP = aGenre("Hip-Hop");
+export const METAL = aGenre("Metal");
+export const NEW_WAVE = aGenre("New Wave");
+export const POP = aGenre("Pop");
+export const POP_ROCK = aGenre("Pop Rock");
+export const REGGAE = aGenre("Reggae");
+export const ROCK = aGenre("Rock");
+export const SKA = aGenre("Ska");
+export const PUNK = aGenre("Punk");
+export const TRIP_HOP = aGenre("Trip Hop");
+
+export const SAMPLE_GENRES = [
+  HIP_HOP,
+  METAL,
+  NEW_WAVE,
+  POP,
+  POP_ROCK,
+  REGGAE,
+  ROCK,
+  SKA,
+];
 export const randomGenre = () => SAMPLE_GENRES[randomInt(SAMPLE_GENRES.length)];
 
 export function aTrack(fields: Partial<Track> = {}): Track {
   const id = uuid();
   const artist = anArtist();
   const genre = fields.genre || randomGenre();
+  const rating = { love: false, stars: Math.floor(Math.random() * 5) };
   return {
     id,
     name: `Track ${id}`,
@@ -137,7 +178,11 @@ export function aTrack(fields: Partial<Track> = {}): Track {
     number: randomInt(100),
     genre,
     artist: artistToArtistSummary(artist),
-    album: albumToAlbumSummary(anAlbum({ artistId: artist.id, artistName: artist.name, genre })),
+    album: albumToAlbumSummary(
+      anAlbum({ artistId: artist.id, artistName: artist.name, genre })
+    ),
+    coverArt: { system: "subsonic", resource: `art:${uuid()}`},
+    rating,
     ...fields,
   };
 }
@@ -150,10 +195,25 @@ export function anAlbum(fields: Partial<Album> = {}): Album {
     genre: randomGenre(),
     year: `19${randomInt(99)}`,
     artistId: `Artist ${uuid()}`,
-    artistName: `Artist ${randomString()}`,
+    artistName: `Artist ${randomstring.generate()}`,
+    coverArt: { system: "subsonic", resource: `art:${uuid()}` },
     ...fields,
   };
-}
+};
+
+export function anAlbumSummary(fields: Partial<AlbumSummary> = {}): AlbumSummary {
+  const id = uuid();
+  return {
+    id,
+    name: `Album ${id}`,
+    year: `19${randomInt(99)}`,
+    genre: randomGenre(),
+    coverArt: { system: "subsonic", resource: `art:${uuid()}` },
+    artistId: `Artist ${uuid()}`,
+    artistName: `Artist ${randomstring.generate()}`,
+    ...fields
+  }
+};
 
 export const BLONDIE_ID = uuid();
 export const BLONDIE_NAME = "Blondie";
@@ -167,7 +227,8 @@ export const BLONDIE: Artist = {
       year: "1976",
       genre: NEW_WAVE,
       artistId: BLONDIE_ID,
-      artistName: BLONDIE_NAME
+      artistName: BLONDIE_NAME,
+      coverArt: { system: "subsonic", resource: `art:${uuid()}`},
     },
     {
       id: uuid(),
@@ -175,14 +236,11 @@ export const BLONDIE: Artist = {
       year: "1978",
       genre: POP_ROCK,
       artistId: BLONDIE_ID,
-      artistName: BLONDIE_NAME
+      artistName: BLONDIE_NAME,
+      coverArt: { system: "subsonic", resource: `art:${uuid()}`},
     },
   ],
-  image: {
-    small: undefined,
-    medium: undefined,
-    large: undefined,
-  },
+  image: { system: "external", resource: "http://localhost:1234/images/blondie.jpg" },
   similarArtists: [],
 };
 
@@ -192,15 +250,35 @@ export const BOB_MARLEY: Artist = {
   id: BOB_MARLEY_ID,
   name: BOB_MARLEY_NAME,
   albums: [
-    { id: uuid(), name: "Burin'", year: "1973", genre: REGGAE, artistId: BOB_MARLEY_ID, artistName: BOB_MARLEY_NAME },
-    { id: uuid(), name: "Exodus", year: "1977", genre: REGGAE, artistId: BOB_MARLEY_ID, artistName: BOB_MARLEY_NAME },
-    { id: uuid(), name: "Kaya", year: "1978", genre: SKA, artistId: BOB_MARLEY_ID, artistName: BOB_MARLEY_NAME },
+    {
+      id: uuid(),
+      name: "Burin'",
+      year: "1973",
+      genre: REGGAE,
+      artistId: BOB_MARLEY_ID,
+      artistName: BOB_MARLEY_NAME,
+      coverArt: { system: "subsonic", resource: `art:${uuid()}`},
+    },
+    {
+      id: uuid(),
+      name: "Exodus",
+      year: "1977",
+      genre: REGGAE,
+      artistId: BOB_MARLEY_ID,
+      artistName: BOB_MARLEY_NAME,
+      coverArt: { system: "subsonic", resource: `art:${uuid()}`},
+    },
+    {
+      id: uuid(),
+      name: "Kaya",
+      year: "1978",
+      genre: SKA,
+      artistId: BOB_MARLEY_ID,
+      artistName: BOB_MARLEY_NAME,
+      coverArt: { system: "subsonic", resource: `art:${uuid()}`},
+    },
   ],
-  image: {
-    small: "http://localhost/BOB_MARLEY/sml",
-    medium: "http://localhost/BOB_MARLEY/med",
-    large: "http://localhost/BOB_MARLEY/lge",
-  },
+  image: { system: "subsonic", resource: BOB_MARLEY_ID },
   similarArtists: [],
 };
 
@@ -211,9 +289,8 @@ export const MADONNA: Artist = {
   name: MADONNA_NAME,
   albums: [],
   image: {
-    small: "http://localhost/MADONNA/sml",
-    medium: undefined,
-    large: "http://localhost/MADONNA/lge",
+    system: "external",
+    resource: "http://localhost:1234/images/madonna.jpg",
   },
   similarArtists: [],
 };
@@ -231,6 +308,7 @@ export const METALLICA: Artist = {
       genre: METAL,
       artistId: METALLICA_ID,
       artistName: METALLICA_NAME,
+      coverArt: { system: "subsonic", resource: `art:${uuid()}`},
     },
     {
       id: uuid(),
@@ -239,13 +317,10 @@ export const METALLICA: Artist = {
       genre: METAL,
       artistId: METALLICA_ID,
       artistName: METALLICA_NAME,
+      coverArt: { system: "subsonic", resource: `art:${uuid()}`},
     },
   ],
-  image: {
-    small: "http://localhost/METALLICA/sml",
-    medium: "http://localhost/METALLICA/med",
-    large: "http://localhost/METALLICA/lge",
-  },
+  image: { system: "subsonic", resource: METALLICA_ID },
   similarArtists: [],
 };
 

tests/burn.test.ts

@@ -0,0 +1,114 @@
+import { assertSystem, BUrn, format, formatForURL, parse } from "../src/burn";
+
+type BUrnSpec = {
+  burn: BUrn;
+  asString: string;
+  shorthand: string;
+};
+
+describe("BUrn", () => {
+  describe("format", () => {
+    (
+      [
+        {
+          burn: { system: "internal", resource: "icon:error" },
+          asString: "bnb:internal:icon:error",
+          shorthand: "bnb:i:icon:error",
+        },
+        {
+          burn: {
+            system: "external",
+            resource: "http://example.com/widget.jpg",
+          },
+          asString: "bnb:external:http://example.com/widget.jpg",
+          shorthand: "bnb:e:http://example.com/widget.jpg",
+        },
+        {
+          burn: { system: "subsonic", resource: "art:1234" },
+          asString: "bnb:subsonic:art:1234",
+          shorthand: "bnb:s:art:1234",
+        },
+        {
+          burn: { system: "navidrome", resource: "art:1234" },
+          asString: "bnb:navidrome:art:1234",
+          shorthand: "bnb:n:art:1234",
+        },
+      ] as BUrnSpec[]
+    ).forEach(({ burn, asString, shorthand }) => {
+      describe(asString, () => {
+        it("can be formatted as string and then roundtripped back into BUrn", () => {
+          const stringValue = format(burn);
+          expect(stringValue).toEqual(asString);
+          expect(parse(stringValue)).toEqual(burn);
+        });
+
+        it("can be formatted as shorthand string and then roundtripped back into BUrn", () => {
+          const stringValue = format(burn, { shorthand: true });
+          expect(stringValue).toEqual(shorthand);
+          expect(parse(stringValue)).toEqual(burn);
+        });
+
+        describe(`encrypted ${asString}`, () => {
+          it("can be formatted as an encrypted string and then roundtripped back into BUrn", () => {
+            const stringValue = format(burn, { encrypt: true });
+            expect(stringValue.startsWith("bnb:encrypted:")).toBeTruthy();
+            expect(stringValue).not.toContain(burn.system);
+            expect(stringValue).not.toContain(burn.resource);
+            expect(parse(stringValue)).toEqual(burn);
+          });
+
+          it("can be formatted as an encrypted shorthand string and then roundtripped back into BUrn", () => {
+            const stringValue = format(burn, {
+              shorthand: true,
+              encrypt: true,
+            });
+            expect(stringValue.startsWith("bnb:x:")).toBeTruthy();
+            expect(stringValue).not.toContain(burn.system);
+            expect(stringValue).not.toContain(burn.resource);
+            expect(parse(stringValue)).toEqual(burn);
+          });
+        });
+      });
+    });
+  });
+
+  describe("formatForURL", () => {
+    describe("external", () => {
+      it("should be encrypted", () => {
+        const burn = {
+          system: "external",
+          resource: "http://example.com/foo.jpg",
+        };
+        const formatted = formatForURL(burn);
+        expect(formatted.startsWith("bnb:x:")).toBeTruthy();
+        expect(formatted).not.toContain("http://example.com/foo.jpg");
+
+        expect(parse(formatted)).toEqual(burn);
+      });
+    });
+
+    describe("not external", () => {
+      it("should be shorthand form", () => {
+        expect(formatForURL({ system: "internal", resource: "foo" })).toEqual(
+          "bnb:i:foo"
+        );
+        expect(
+          formatForURL({ system: "subsonic", resource: "foo:bar" })
+        ).toEqual("bnb:s:foo:bar");
+      });
+    });
+  });
+
+  describe("assertSystem", () => {
+    it("should fail if the system is not equal", () => {
+      const burn = { system: "external", resource: "something"};
+      expect(() => assertSystem(burn, "subsonic")).toThrow(`Unsupported urn: '${format(burn)}'`)
+    });
+
+    it("should pass if the system is equal", () => {
+      const burn = { system: "external", resource: "something"};
+      expect(assertSystem(burn, "external")).toEqual(burn);
+    });
+  });
+});
+

tests/config.test.ts

@@ -1,5 +1,81 @@
 import { hostname } from "os";
-import config from "../src/config";
+import config, { COLOR, envVar } from "../src/config";
+
+describe("envVar", () => {
+  const OLD_ENV = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...OLD_ENV };
+
+    process.env["bnb-var"] = "bnb-var-value";
+    process.env["bnb-legacy2"] = "bnb-legacy2-value";
+    process.env["bnb-legacy3"] = "bnb-legacy3-value";
+  });
+
+  afterEach(() => {
+    process.env = OLD_ENV;
+  });
+
+  describe("when the env var exists", () => {
+    describe("and there are no legacy env vars that match", () => {
+      it("should return the env var", () => {
+        expect(envVar("bnb-var")).toEqual("bnb-var-value");
+      });
+    });
+
+    describe("and there are legacy env vars that match", () => {
+      it("should return the env var", () => {
+        expect(
+          envVar("bnb-var", {
+            default: "not valid",
+            legacy: ["bnb-legacy1", "bnb-legacy2", "bnb-legacy3"],
+          })
+        ).toEqual("bnb-var-value");
+      });
+    });
+  });
+
+  describe("when the env var doesnt exist", () => {
+    describe("and there are no legacy env vars specified", () => {
+      describe("and there is no default value specified", () => {
+        it("should be undefined", () => {
+          expect(envVar("bnb-not-set")).toBeUndefined();
+        });
+      });
+
+      describe("and there is a default value specified", () => {
+        it("should return the default", () => {
+          expect(envVar("bnb-not-set", { default: "widget" })).toEqual(
+            "widget"
+          );
+        });
+      });
+    });
+
+    describe("when there are legacy env vars specified", () => {
+      it("should return the value from the first matched legacy env var", () => {
+        expect(
+          envVar("bnb-not-set", {
+            legacy: ["bnb-legacy1", "bnb-legacy2", "bnb-legacy3"],
+          })
+        ).toEqual("bnb-legacy2-value");
+      });
+    });
+  });
+
+  describe("validationPattern", () => {
+    it("should fail when the value does not match the pattern", () => {
+      expect(() =>
+        envVar("bnb-var", {
+          validationPattern: /^foobar$/,
+        })
+      ).toThrowError(
+        `Invalid value specified for 'bnb-var', must match ${/^foobar$/}`
+      );
+    });
+  });
+});
 
 describe("config", () => {
   const OLD_ENV = process.env;
@@ -43,26 +119,22 @@ describe("config", () => {
   }
 
   describe("bonobUrl", () => {
-    describe("when BONOB_URL is specified", () => {
-      it("should be used", () => {
-        const url = "http://bonob1.example.com:8877/";
-        process.env["BONOB_URL"] = url;
+    ["BNB_URL", "BONOB_URL", "BONOB_WEB_ADDRESS"].forEach((key) => {
+      describe(`when ${key} is specified`, () => {
+        it("should be used", () => {
+          const url = "http://bonob1.example.com:8877/";
 
-        expect(config().bonobUrl.href()).toEqual(url);
+          process.env["BNB_URL"] = "";
+          process.env["BONOB_URL"] = "";
+          process.env["BONOB_WEB_ADDRESS"] = "";
+          process.env[key] = url;
+
+          expect(config().bonobUrl.href()).toEqual(url);
+        });
       });
     });
 
-    describe("when BONOB_URL is not specified, however legacy BONOB_WEB_ADDRESS is specified", () => {
-      it("should be used", () => {
-        const url = "http://bonob2.example.com:9988/";
-        process.env["BONOB_URL"] = "";
-        process.env["BONOB_WEB_ADDRESS"] = url;
-
-        expect(config().bonobUrl.href()).toEqual(url);
-      });
-    });
-
-    describe("when neither BONOB_URL nor BONOB_WEB_ADDRESS are specified", () => {
+    describe("when none of BNB_URL, BONOB_URL, BONOB_WEB_ADDRESS are specified", () => {
       describe("when BONOB_PORT is not specified", () => {
         it(`should default to http://${hostname()}:4534`, () => {
           expect(config().bonobUrl.href()).toEqual(
@@ -71,6 +143,15 @@ describe("config", () => {
         });
       });
 
+      describe("when BNB_PORT is specified as 3322", () => {
+        it(`should default to http://${hostname()}:3322`, () => {
+          process.env["BNB_PORT"] = "3322";
+          expect(config().bonobUrl.href()).toEqual(
+            `http://${hostname()}:3322/`
+          );
+        });
+      });
+
       describe("when BONOB_PORT is specified as 3322", () => {
         it(`should default to http://${hostname()}:3322`, () => {
           process.env["BONOB_PORT"] = "3322";
@@ -82,92 +163,89 @@ describe("config", () => {
     });
   });
 
-  describe("navidrome", () => {
-    describe("url", () => {
-      describe("when BONOB_NAVIDROME_URL is not specified", () => {
-        it(`should default to http://${hostname()}:4533`, () => {
-          expect(config().navidrome.url).toEqual(`http://${hostname()}:4533`);
-        });
-      });
-
-      describe("when BONOB_NAVIDROME_URL is ''", () => {
-        it(`should default to http://${hostname()}:4533`, () => {
-          process.env["BONOB_NAVIDROME_URL"] = "";
-          expect(config().navidrome.url).toEqual(`http://${hostname()}:4533`);
-        });
-      });
-
-      describe("when BONOB_NAVIDROME_URL is specified", () => {
-        it(`should use it`, () => {
-          const url = "http://navidrome.example.com:1234";
-          process.env["BONOB_NAVIDROME_URL"] = url;
-          expect(config().navidrome.url).toEqual(url);
-        });
-      });
-    });
-  });
-
   describe("icons", () => {
     describe("foregroundColor", () => {
-      describe("when BONOB_ICON_FOREGROUND_COLOR is not specified", () => {
-        it(`should default to undefined`, () => {
-          expect(config().icons.foregroundColor).toEqual(undefined);
-        });
-      });
+      ["BNB_ICON_FOREGROUND_COLOR", "BONOB_ICON_FOREGROUND_COLOR"].forEach(
+        (k) => {
+          describe(`when ${k} is not specified`, () => {
+            it(`should default to undefined`, () => {
+              expect(config().icons.foregroundColor).toEqual(undefined);
+            });
+          });
 
-      describe("when BONOB_ICON_FOREGROUND_COLOR is ''", () => {
-        it(`should default to undefined`, () => {
-          process.env["BONOB_ICON_FOREGROUND_COLOR"] = "";
-          expect(config().icons.foregroundColor).toEqual(undefined);
-        });
-      });
+          describe(`when ${k} is ''`, () => {
+            it(`should default to undefined`, () => {
+              process.env[k] = "";
+              expect(config().icons.foregroundColor).toEqual(undefined);
+            });
+          });
 
-      describe("when BONOB_ICON_FOREGROUND_COLOR is specified", () => {
-        it(`should use it`, () => {
-          process.env["BONOB_ICON_FOREGROUND_COLOR"] = "pink";
-          expect(config().icons.foregroundColor).toEqual("pink");
-        });
-      });
+          describe(`when ${k} is specified as a color`, () => {
+            it(`should use it`, () => {
+              process.env[k] = "pink";
+              expect(config().icons.foregroundColor).toEqual("pink");
+            });
+          });
 
-      describe("when BONOB_ICON_FOREGROUND_COLOR is an invalid string", () => {
-        it(`should blow up`, () => {
-          process.env["BONOB_ICON_FOREGROUND_COLOR"] = "#dfasd";
-          expect(() => config()).toThrow(
-            "Invalid color specified for BONOB_ICON_FOREGROUND_COLOR"
-          );
-        });
-      });
+          describe(`when ${k} is specified as hex`, () => {
+            it(`should use it`, () => {
+              process.env[k] = "#1db954";
+              expect(config().icons.foregroundColor).toEqual("#1db954");
+            });
+          });
+
+          describe(`when ${k} is an invalid string`, () => {
+            it(`should blow up`, () => {
+              process.env[k] = "!dfasd";
+              expect(() => config()).toThrow(
+                `Invalid value specified for 'BNB_ICON_FOREGROUND_COLOR', must match ${COLOR}`
+              );
+            });
+          });
+        }
+      );
     });
 
     describe("backgroundColor", () => {
-      describe("when BONOB_ICON_BACKGROUND_COLOR is not specified", () => {
-        it(`should default to undefined`, () => {
-          expect(config().icons.backgroundColor).toEqual(undefined);
-        });
-      });
+      ["BNB_ICON_BACKGROUND_COLOR", "BONOB_ICON_BACKGROUND_COLOR"].forEach(
+        (k) => {
+          describe(`when ${k} is not specified`, () => {
+            it(`should default to undefined`, () => {
+              expect(config().icons.backgroundColor).toEqual(undefined);
+            });
+          });
 
-      describe("when BONOB_ICON_BACKGROUND_COLOR is ''", () => {
-        it(`should default to undefined`, () => {
-          process.env["BONOB_ICON_BACKGROUND_COLOR"] = "";
-          expect(config().icons.backgroundColor).toEqual(undefined);
-        });
-      });
+          describe(`when ${k} is ''`, () => {
+            it(`should default to undefined`, () => {
+              process.env[k] = "";
+              expect(config().icons.backgroundColor).toEqual(undefined);
+            });
+          });
 
-      describe("when BONOB_ICON_BACKGROUND_COLOR is specified", () => {
-        it(`should use it`, () => {
-          process.env["BONOB_ICON_BACKGROUND_COLOR"] = "blue";
-          expect(config().icons.backgroundColor).toEqual("blue");
-        });
-      });
+          describe(`when ${k} is specified as a color`, () => {
+            it(`should use it`, () => {
+              process.env[k] = "blue";
+              expect(config().icons.backgroundColor).toEqual("blue");
+            });
+          });
 
-      describe("when BONOB_ICON_BACKGROUND_COLOR is an invalid string", () => {
-        it(`should blow up`, () => {
-          process.env["BONOB_ICON_BACKGROUND_COLOR"] = "#red";
-          expect(() => config()).toThrow(
-            "Invalid color specified for BONOB_ICON_BACKGROUND_COLOR"
-          );
-        });
-      });
+          describe(`when ${k} is specified as hex`, () => {
+            it(`should use it`, () => {
+              process.env[k] = "#1db954";
+              expect(config().icons.backgroundColor).toEqual("#1db954");
+            });
+          });
+
+          describe(`when ${k} is an invalid string`, () => {
+            it(`should blow up`, () => {
+              process.env[k] = "!red";
+              expect(() => config()).toThrow(
+                `Invalid value specified for 'BNB_ICON_BACKGROUND_COLOR', must match ${COLOR}`
+              );
+            });
+          });
+        }
+      );
     });
   });
 
@@ -176,29 +254,48 @@ describe("config", () => {
       expect(config().secret).toEqual("bonob");
     });
 
-    it("should be overridable", () => {
-      process.env["BONOB_SECRET"] = "new secret";
-      expect(config().secret).toEqual("new secret");
+    ["BNB_SECRET", "BONOB_SECRET"].forEach((key) => {
+      it(`should be overridable using ${key}`, () => {
+        process.env[key] = "new secret";
+        expect(config().secret).toEqual("new secret");
+      });
     });
   });
 
+  describe("authTimeout", () => {
+    it("should default to 1h", () => {
+      expect(config().authTimeout).toEqual("1h");
+    });
+
+    it(`should be overridable using BNB_AUTH_TIMEOUT`, () => {
+      process.env["BNB_AUTH_TIMEOUT"] = "33s";
+      expect(config().authTimeout).toEqual("33s");
+    });
+});
+
   describe("sonos", () => {
     describe("serviceName", () => {
       it("should default to bonob", () => {
         expect(config().sonos.serviceName).toEqual("bonob");
       });
 
-      it("should be overridable", () => {
-        process.env["BONOB_SONOS_SERVICE_NAME"] = "foobar1000";
-        expect(config().sonos.serviceName).toEqual("foobar1000");
+      ["BNB_SONOS_SERVICE_NAME", "BONOB_SONOS_SERVICE_NAME"].forEach((k) => {
+        it("should be overridable", () => {
+          process.env[k] = "foobar1000";
+          expect(config().sonos.serviceName).toEqual("foobar1000");
+        });
       });
     });
 
-    describeBooleanConfigValue(
-      "deviceDiscovery",
-      "BONOB_SONOS_DEVICE_DISCOVERY",
-      true,
-      (config) => config.sonos.discovery.auto
+    ["BNB_SONOS_DEVICE_DISCOVERY", "BONOB_SONOS_DEVICE_DISCOVERY"].forEach(
+      (k) => {
+        describeBooleanConfigValue(
+          "deviceDiscovery",
+          k,
+          true,
+          (config) => config.sonos.discovery.enabled
+        );
+      }
     );
 
     describe("seedHost", () => {
@@ -206,65 +303,113 @@ describe("config", () => {
         expect(config().sonos.discovery.seedHost).toBeUndefined();
       });
 
-      it("should be overridable", () => {
-        process.env["BONOB_SONOS_SEED_HOST"] = "123.456.789.0";
-        expect(config().sonos.discovery.seedHost).toEqual("123.456.789.0");
+      ["BNB_SONOS_SEED_HOST", "BONOB_SONOS_SEED_HOST"].forEach((k) => {
+        it("should be overridable", () => {
+          process.env[k] = "123.456.789.0";
+          expect(config().sonos.discovery.seedHost).toEqual("123.456.789.0");
+        });
       });
     });
 
-    describeBooleanConfigValue(
-      "autoRegister",
-      "BONOB_SONOS_AUTO_REGISTER",
-      false,
-      (config) => config.sonos.autoRegister
-    );
+    ["BNB_SONOS_AUTO_REGISTER", "BONOB_SONOS_AUTO_REGISTER"].forEach((k) => {
+      describeBooleanConfigValue(
+        "autoRegister",
+        k,
+        false,
+        (config) => config.sonos.autoRegister
+      );
+    });
 
     describe("sid", () => {
       it("should default to 246", () => {
         expect(config().sonos.sid).toEqual(246);
       });
 
-      it("should be overridable", () => {
-        process.env["BONOB_SONOS_SERVICE_ID"] = "786";
-        expect(config().sonos.sid).toEqual(786);
+      ["BNB_SONOS_SERVICE_ID", "BONOB_SONOS_SERVICE_ID"].forEach((k) => {
+        it("should be overridable", () => {
+          process.env[k] = "786";
+          expect(config().sonos.sid).toEqual(786);
+        });
       });
     });
   });
 
-  describe("navidrome", () => {
+  describe("subsonic", () => {
     describe("url", () => {
-      it("should default to http://${hostname()}:4533", () => {
-        expect(config().navidrome.url).toEqual(`http://${hostname()}:4533`);
-      });
+      ["BNB_SUBSONIC_URL", "BONOB_SUBSONIC_URL", "BONOB_NAVIDROME_URL"].forEach(
+        (k) => {
+          describe(`when ${k} is not specified`, () => {
+            it(`should default to http://${hostname()}:4533`, () => {
+              expect(config().subsonic.url).toEqual(
+                `http://${hostname()}:4533`
+              );
+            });
+          });
 
-      it("should be overridable", () => {
-        process.env["BONOB_NAVIDROME_URL"] = "http://farfaraway.com";
-        expect(config().navidrome.url).toEqual("http://farfaraway.com");
-      });
+          describe(`when ${k} is ''`, () => {
+            it(`should default to http://${hostname()}:4533`, () => {
+              process.env[k] = "";
+              expect(config().subsonic.url).toEqual(
+                `http://${hostname()}:4533`
+              );
+            });
+          });
+
+          describe(`when ${k} is specified`, () => {
+            it(`should use it for ${k}`, () => {
+              const url = "http://navidrome.example.com:1234";
+              process.env[k] = url;
+              expect(config().subsonic.url).toEqual(url);
+            });
+          });
+        }
+      );
     });
 
     describe("customClientsFor", () => {
       it("should default to undefined", () => {
-        expect(config().navidrome.customClientsFor).toBeUndefined();
+        expect(config().subsonic.customClientsFor).toBeUndefined();
       });
 
-      it("should be overridable", () => {
-        process.env["BONOB_NAVIDROME_CUSTOM_CLIENTS"] = "whoop/whoop";
-        expect(config().navidrome.customClientsFor).toEqual("whoop/whoop");
+      [
+        "BNB_SUBSONIC_CUSTOM_CLIENTS",
+        "BONOB_SUBSONIC_CUSTOM_CLIENTS",
+        "BONOB_NAVIDROME_CUSTOM_CLIENTS",
+      ].forEach((k) => {
+        it(`should be overridable for ${k}`, () => {
+          process.env[k] = "whoop/whoop";
+          expect(config().subsonic.customClientsFor).toEqual("whoop/whoop");
+        });
+      });
+    });
+
+    describe("artistImageCache", () => {
+      it("should default to undefined", () => {
+        expect(config().subsonic.artistImageCache).toBeUndefined();
+      });
+
+      it(`should be overridable for BNB_SUBSONIC_ARTIST_IMAGE_CACHE`, () => {
+        process.env["BNB_SUBSONIC_ARTIST_IMAGE_CACHE"] = "/some/path";
+        expect(config().subsonic.artistImageCache).toEqual("/some/path");
       });
     });
   });
 
-  describeBooleanConfigValue(
-    "scrobbleTracks",
-    "BONOB_SCROBBLE_TRACKS",
-    true,
-    (config) => config.scrobbleTracks
-  );
-  describeBooleanConfigValue(
-    "reportNowPlaying",
-    "BONOB_REPORT_NOW_PLAYING",
-    true,
-    (config) => config.reportNowPlaying
-  );
+  ["BNB_SCROBBLE_TRACKS", "BONOB_SCROBBLE_TRACKS"].forEach((k) => {
+    describeBooleanConfigValue(
+      "scrobbleTracks",
+      k,
+      true,
+      (config) => config.scrobbleTracks
+    );
+  });
+
+  ["BNB_REPORT_NOW_PLAYING", "BONOB_REPORT_NOW_PLAYING"].forEach((k) => {
+    describeBooleanConfigValue(
+      "reportNowPlaying",
+      k,
+      true,
+      (config) => config.reportNowPlaying
+    );
+  });
 });

tests/encryption.test.ts

@@ -1,12 +1,45 @@
-import encryption from '../src/encryption';
-
-describe("encrypt", () => {
-  const e = encryption("secret squirrel");
+import { cryptoEncryption, jwsEncryption } from '../src/encryption';
 
+describe("jwsEncryption", () => {
   it("can encrypt and decrypt", () => {
+    const e = jwsEncryption("secret squirrel");
+
     const value = "bobs your uncle"
     const hash = e.encrypt(value)
-    expect(hash.encryptedData).not.toEqual(value);
+    expect(hash).not.toContain(value);
     expect(e.decrypt(hash)).toEqual(value);
   });
-})
+
+  it("returns different values for different secrets", () => {
+    const e1 = jwsEncryption("e1");
+    const e2 = jwsEncryption("e2");
+
+    const value = "bobs your uncle"
+    const h1 = e1.encrypt(value)
+    const h2 = e2.encrypt(value)
+
+    expect(h1).not.toEqual(h2);
+  });
+})
+
+describe("cryptoEncryption", () => {
+  it("can encrypt and decrypt", () => {
+    const e = cryptoEncryption("secret squirrel");
+
+    const value = "bobs your uncle"
+    const hash = e.encrypt(value)
+    expect(hash).not.toContain(value);
+    expect(e.decrypt(hash)).toEqual(value);
+  });
+
+  it("returns different values for different secrets", () => {
+    const e1 = cryptoEncryption("e1");
+    const e2 = cryptoEncryption("e2");
+
+    const value = "bobs your uncle"
+    const h1 = e1.encrypt(value)
+    const h2 = e2.encrypt(value)
+
+    expect(h1).not.toEqual(h2);
+  });
+})

tests/icon.test.ts

@@ -1,5 +1,6 @@
 import dayjs from "dayjs";
 import libxmljs from "libxmljs2";
+import { FixedClock } from "../src/clock";
 
 import {
   contains,
@@ -556,12 +557,11 @@ describe("festivals", () => {
     backgroundColor: "black",
     foregroundColor: "black",
   });
-  let now = dayjs();
-  const clock = { now: () => now };
+  const clock = new FixedClock(dayjs());
 
   describe("on a day that isn't festive", () => {
     beforeEach(() => {
-      now = dayjs("2022/10/12");
+      clock.time = dayjs("2022/10/12");
     });
 
     it("should use the given colors", () => {
@@ -587,7 +587,7 @@ describe("festivals", () => {
 
   describe("on christmas day", () => {
     beforeEach(() => {
-      now = dayjs("2022/12/25");
+      clock.time = dayjs("2022/12/25");
     });
 
     it("should use the christmas theme colors", () => {
@@ -613,7 +613,7 @@ describe("festivals", () => {
 
   describe("on halloween", () => {
     beforeEach(() => {
-      now = dayjs("2022/10/31");
+      clock.time = dayjs("2022/10/31");
     });
 
     it("should use the given colors", () => {
@@ -638,7 +638,7 @@ describe("festivals", () => {
 
   describe("on may 4", () => {
     beforeEach(() => {
-      now = dayjs("2022/5/4");
+      clock.time = dayjs("2022/5/4");
     });
 
     it("should use the undefined colors, so no color", () => {
@@ -664,7 +664,7 @@ describe("festivals", () => {
   describe("on cny", () => {
     describe("2022", () => {
       beforeEach(() => {
-        now = dayjs("2022/02/01");
+        clock.time = dayjs("2022/02/01");
       });
 
       it("should use the cny theme", () => {
@@ -689,7 +689,7 @@ describe("festivals", () => {
 
     describe("2023", () => {
       beforeEach(() => {
-        now = dayjs("2023/01/22");
+        clock.time = dayjs("2023/01/22");
       });
 
       it("should use the cny theme", () => {
@@ -714,7 +714,7 @@ describe("festivals", () => {
 
     describe("2024", () => {
       beforeEach(() => {
-        now = dayjs("2024/02/10");
+        clock.time = dayjs("2024/02/10");
       });
 
       it("should use the cny theme", () => {
@@ -740,7 +740,7 @@ describe("festivals", () => {
 
   describe("on holi", () => {
     beforeEach(() => {
-      now = dayjs("2022/03/18");
+      clock.time = dayjs("2022/03/18");
     });
 
     it("should use the given colors", () => {

tests/in_memory_music_service.test.ts

@@ -1,6 +1,8 @@
+import { taskEither as TE } from "fp-ts";
+import { pipe } from "fp-ts/lib/function";
+
 import { InMemoryMusicService } from "./in_memory_music_service";
 import {
-  AuthSuccess,
   MusicLibrary,
   artistToArtistSummary,
   albumToAlbumSummary,
@@ -18,6 +20,7 @@ import {
 } from "./builders";
 import _ from "underscore";
 
+
 describe("InMemoryMusicService", () => {
   const service = new InMemoryMusicService();
 
@@ -27,12 +30,15 @@ describe("InMemoryMusicService", () => {
 
       service.hasUser(credentials);
 
-      const token = (await service.generateToken(credentials)) as AuthSuccess;
+      const token = await pipe(
+        service.generateToken(credentials),
+        TE.getOrElse(e => { throw e })
+      )();
 
       expect(token.userId).toEqual(credentials.username);
       expect(token.nickname).toEqual(credentials.username);
 
-      const musicLibrary = service.login(token.authToken);
+      const musicLibrary = service.login(token.serviceToken);
 
       expect(musicLibrary).toBeDefined();
     });
@@ -42,34 +48,19 @@ describe("InMemoryMusicService", () => {
 
       service.hasUser(credentials);
 
-      const token = (await service.generateToken(credentials)) as AuthSuccess;
+      const token = await pipe(
+        service.generateToken(credentials),
+        TE.getOrElse(e => { throw e })
+      )();
 
       service.clear();
 
-      return expect(service.login(token.authToken)).rejects.toEqual(
+      return expect(service.login(token.serviceToken)).rejects.toEqual(
         "Invalid auth token"
       );
     });
   });
-
-  describe("artistToArtistSummary", () => {
-    it("should map fields correctly", () => {
-      const artist = anArtist({
-        id: uuid(),
-        name: "The Artist",
-        image: {
-          small: "/path/to/small/jpg",
-          medium: "/path/to/medium/jpg",
-          large: "/path/to/large/jpg",
-        },
-      });
-      expect(artistToArtistSummary(artist)).toEqual({
-        id: artist.id,
-        name: artist.name,
-      });
-    });
-  });
-
+  
   describe("Music Library", () => {
     const user = { username: "user100", password: "password100" };
     let musicLibrary: MusicLibrary;
@@ -79,8 +70,12 @@ describe("InMemoryMusicService", () => {
 
       service.hasUser(user);
 
-      const token = (await service.generateToken(user)) as AuthSuccess;
-      musicLibrary = (await service.login(token.authToken)) as MusicLibrary;
+      const token = await pipe(
+        service.generateToken(user),
+        TE.getOrElse(e => { throw e })
+      )();
+
+      musicLibrary = (await service.login(token.serviceToken)) as MusicLibrary;
     });
 
     describe("artists", () => {
@@ -143,8 +138,8 @@ describe("InMemoryMusicService", () => {
 
       describe("when it exists", () => {
         it("should provide an artist", async () => {
-          expect(await musicLibrary.artist(artist1.id)).toEqual(artist1);
-          expect(await musicLibrary.artist(artist2.id)).toEqual(artist2);
+          expect(await musicLibrary.artist(artist1.id!)).toEqual(artist1);
+          expect(await musicLibrary.artist(artist2.id!)).toEqual(artist2);
         });
       });
 
@@ -175,8 +170,8 @@ describe("InMemoryMusicService", () => {
       describe("fetching tracks for an album", () => {
         it("should return only tracks on that album", async () => {
           expect(await musicLibrary.tracks(artist1Album1.id)).toEqual([
-            track1,
-            track2,
+            { ...track1, rating: { love: false, stars: 0 } },
+            { ...track2, rating: { love: false, stars: 0 } },
           ]);
         });
       });
@@ -192,7 +187,7 @@ describe("InMemoryMusicService", () => {
       describe("fetching a single track", () => {
         describe("when it exists", () => {
           it("should return the track", async () => {
-            expect(await musicLibrary.track(track3.id)).toEqual(track3);
+            expect(await musicLibrary.track(track3.id)).toEqual({ ...track3, rating: { love: false, stars: 0 } },);
           });
         });
       });
@@ -221,7 +216,10 @@ describe("InMemoryMusicService", () => {
         ],
       });
       const artist2 = anArtist({ name: "artist2", albums: [artist2_album1] });
-      const artist3 = anArtist({ name: "artist3", albums: [artist3_album1, artist3_album2] });
+      const artist3 = anArtist({
+        name: "artist3",
+        albums: [artist3_album1, artist3_album2],
+      });
       const artistWithNoAlbums = anArtist({ albums: [] });
 
       const allAlbums = [artist1, artist2, artist3, artistWithNoAlbums].flatMap(
@@ -258,7 +256,7 @@ describe("InMemoryMusicService", () => {
             });
 
             expect(albums.total).toEqual(totalAlbumCount);
-            expect(albums.results.length).toEqual(3)
+            expect(albums.results.length).toEqual(3);
             // cannot really assert the results and they will change every time
           });
         });
@@ -282,9 +280,9 @@ describe("InMemoryMusicService", () => {
                     albumToAlbumSummary(artist1_album3),
                     albumToAlbumSummary(artist1_album4),
                     albumToAlbumSummary(artist1_album5),
-  
+
                     albumToAlbumSummary(artist2_album1),
-  
+
                     albumToAlbumSummary(artist3_album1),
                     albumToAlbumSummary(artist3_album2),
                   ],
@@ -302,13 +300,11 @@ describe("InMemoryMusicService", () => {
                     type: "alphabeticalByName",
                   })
                 ).toEqual({
-                  results:                   
-                  _.sortBy(allAlbums, 'name').map(albumToAlbumSummary),
+                  results: _.sortBy(allAlbums, "name").map(albumToAlbumSummary),
                   total: totalAlbumCount,
                 });
               });
             });
-
           });
 
           describe("fetching a page", () => {
@@ -467,9 +463,9 @@ describe("InMemoryMusicService", () => {
         it("should provide an array of artists", async () => {
           expect(await musicLibrary.genres()).toEqual([
             HIP_HOP,
+            SKA,
             POP,
             ROCK,
-            SKA,
           ]);
         });
       });

tests/in_memory_music_service.ts

@@ -1,10 +1,12 @@
-import { option as O } from "fp-ts";
+import { option as O, taskEither as TE } from "fp-ts";
 import * as A from "fp-ts/Array";
 import { fromEquals } from "fp-ts/lib/Eq";
 import { pipe } from "fp-ts/lib/function";
 import { ordString, fromCompare } from "fp-ts/lib/Ord";
 import { shuffle } from "underscore";
 
+import { b64Encode, b64Decode } from "../src/b64";
+
 import {
   MusicService,
   Credentials,
@@ -20,7 +22,9 @@ import {
   albumToAlbumSummary,
   Track,
   Genre,
+  Rating,
 } from "../src/music_service";
+import { BUrn } from "../src/burn";
 
 export class InMemoryMusicService implements MusicService {
   users: Record<string, string> = {};
@@ -30,28 +34,29 @@ export class InMemoryMusicService implements MusicService {
   generateToken({
     username,
     password,
-  }: Credentials): Promise<AuthSuccess | AuthFailure> {
+  }: Credentials): TE.TaskEither<AuthFailure, AuthSuccess> {
     if (
       username != undefined &&
       password != undefined &&
       this.users[username] == password
     ) {
-      return Promise.resolve({
-        authToken: Buffer.from(JSON.stringify({ username, password })).toString(
-          "base64"
-        ),
+      return TE.right({
+        serviceToken: b64Encode(JSON.stringify({ username, password })),
         userId: username,
         nickname: username,
+        type: "in-memory"
       });
     } else {
-      return Promise.resolve({ message: `Invalid user:${username}` });
+      return TE.left(new AuthFailure(`Invalid user:${username}`));
     }
   }
 
-  login(token: string): Promise<MusicLibrary> {
-    const credentials = JSON.parse(
-      Buffer.from(token, "base64").toString("ascii")
-    ) as Credentials;
+  refreshToken(serviceToken: string): TE.TaskEither<AuthFailure, AuthSuccess> {
+    return this.generateToken(JSON.parse(b64Decode(serviceToken)))
+  }
+
+  login(serviceToken: string): Promise<MusicLibrary> {
+    const credentials = JSON.parse(b64Decode(serviceToken)) as Credentials;
     if (this.users[credentials.username] != credentials.password)
       return Promise.reject("Invalid auth token");
 
@@ -77,9 +82,11 @@ export class InMemoryMusicService implements MusicService {
             switch (q.type) {
               case "alphabeticalByArtist":
                 return artist2Album;
-                case "alphabeticalByName":
-                  return artist2Album.sort((a, b) => a.album.name.localeCompare(b.album.name));
-                case "byGenre":
+              case "alphabeticalByName":
+                return artist2Album.sort((a, b) =>
+                  a.album.name.localeCompare(b.album.name)
+                );
+              case "byGenre":
                 return artist2Album.filter(
                   (it) => it.album.genre?.id === q.genre
                 );
@@ -109,26 +116,29 @@ export class InMemoryMusicService implements MusicService {
             A.map((it) => O.fromNullable(it.genre)),
             A.compact,
             A.uniq(fromEquals((x, y) => x.id === y.id)),
-            A.sort(
-              fromCompare<Genre>((x, y) => ordString.compare(x.id, y.id))
-            )
+            A.sort(fromCompare<Genre>((x, y) => ordString.compare(x.id, y.id)))
           )
         ),
       tracks: (albumId: string) =>
-        Promise.resolve(this.tracks.filter((it) => it.album.id === albumId)),
+        Promise.resolve(
+          this.tracks
+            .filter((it) => it.album.id === albumId)
+            .map((it) => ({ ...it, rating: { love: false, stars: 0 } }))
+        ),
+      rate: (_: string, _2: Rating) => Promise.resolve(false),
       track: (trackId: string) =>
         pipe(
           this.tracks.find((it) => it.id === trackId),
           O.fromNullable,
-          O.map((it) => Promise.resolve(it)),
+          O.map((it) => Promise.resolve({ ...it, rating: { love: false, stars: 0 } })),
           O.getOrElse(() =>
             Promise.reject(`Failed to find track with id ${trackId}`)
           )
         ),
       stream: (_: { trackId: string; range: string | undefined }) =>
         Promise.reject("unsupported operation"),
-      coverArt: (id: string, _: "album" | "artist", size?: number) =>
-        Promise.reject(`Cannot retrieve coverArt for ${id}, size ${size}`),
+      coverArt: (coverArtURN: BUrn, size?: number) =>
+        Promise.reject(`Cannot retrieve coverArt for ${coverArtURN}, size ${size}`),
       scrobble: async (_: string) => {
         return Promise.resolve(true);
       },
@@ -141,10 +151,14 @@ export class InMemoryMusicService implements MusicService {
       playlists: async () => Promise.resolve([]),
       playlist: async (id: string) =>
         Promise.reject(`No playlist with id ${id}`),
-      createPlaylist: async (_: string) => Promise.reject("Unsupported operation"),
-      deletePlaylist: async (_: string) => Promise.reject("Unsupported operation"),
-      addToPlaylist: async (_: string) => Promise.reject("Unsupported operation"),
-      removeFromPlaylist: async (_: string, _2: number[]) => Promise.reject("Unsupported operation"),
+      createPlaylist: async (_: string) =>
+        Promise.reject("Unsupported operation"),
+      deletePlaylist: async (_: string) =>
+        Promise.reject("Unsupported operation"),
+      addToPlaylist: async (_: string) =>
+        Promise.reject("Unsupported operation"),
+      removeFromPlaylist: async (_: string, _2: number[]) =>
+        Promise.reject("Unsupported operation"),
       similarSongs: async (_: string) => Promise.resolve([]),
       topSongs: async (_: string) => Promise.resolve([]),
     });

tests/link_codes.test.ts

@@ -18,7 +18,7 @@ describe("InMemoryLinkCodes", () => {
     describe('when token is valid', () => {
       it('should associate the token', () => {
         const linkCode = linkCodes.mint();
-        const association = { authToken: "token123", nickname: "bob", userId: "1" };
+        const association = { serviceToken: "token123", nickname: "bob", userId: "1" };
 
         linkCodes.associate(linkCode, association);
 
@@ -29,7 +29,7 @@ describe("InMemoryLinkCodes", () => {
     describe('when token is valid', () => {
       it('should throw an error', () => {
         const invalidLinkCode = "invalidLinkCode";
-        const association = { authToken: "token456", nickname: "bob", userId: "1" };
+        const association = { serviceToken: "token456", nickname: "bob", userId: "1" };
 
         expect(() => linkCodes.associate(invalidLinkCode, association)).toThrow(`Invalid linkCode ${invalidLinkCode}`)
       }); 

tests/music_service.test.ts

@@ -0,0 +1,22 @@
+import { v4 as uuid } from "uuid";
+
+import { anArtist } from "./builders";
+import { artistToArtistSummary } from "../src/music_service";
+
+describe("artistToArtistSummary", () => {
+  it("should map fields correctly", () => {
+    const artist = anArtist({
+      id: uuid(),
+      name: "The Artist",
+      image: {
+        system: "external",
+        resource: "http://example.com:1234/image.jpg",
+      },
+    });
+    expect(artistToArtistSummary(artist)).toEqual({
+      id: artist.id,
+      name: artist.name,
+      image: artist.image,
+    });
+  });
+});

tests/random_string.test.ts

@@ -1,16 +0,0 @@
-import randomString from "../src/random_string";
-
-describe('randomString', () => {
-  it('should produce different strings...', () => {
-    const s1 = randomString()
-    const s2 = randomString()
-    const s3 = randomString()
-    const s4 = randomString()
-
-    expect(s1.length).toEqual(64)
-    
-    expect(s1).not.toEqual(s2);
-    expect(s1).not.toEqual(s3);
-    expect(s1).not.toEqual(s4);
-  });
-});

tests/registrar.test.ts

@@ -75,41 +75,62 @@ describe("registrar", () => {
       (sonos as jest.Mock).mockReturnValue(fakeSonos);
     });
 
+    describe("seedHost", () => {
+      describe("is specified", () => {
+        it("should register using the seed host", async () => {
+          fakeSonos.register.mockResolvedValue(true);
+          const seedHost = "127.0.0.11";
+  
+          expect(await registrar(bonobUrl, seedHost)()).toEqual(
+            true
+          );
+  
+          expect(bonobService).toHaveBeenCalledWith(
+            serviceDetails.name,
+            serviceDetails.sid,
+            bonobUrl
+          );
+          expect(sonos).toHaveBeenCalledWith({ enabled: true, seedHost });
+          expect(fakeSonos.register).toHaveBeenCalledWith(service);
+        });
+      });
+
+      describe("is not specified", () => {
+        it("should register without using the seed host", async () => {
+          fakeSonos.register.mockResolvedValue(true);
+
+          expect(await registrar(bonobUrl)()).toEqual(
+            true
+          );
+  
+          expect(bonobService).toHaveBeenCalledWith(
+            serviceDetails.name,
+            serviceDetails.sid,
+            bonobUrl
+          );
+          expect(sonos).toHaveBeenCalledWith({ enabled: true });
+          expect(fakeSonos.register).toHaveBeenCalledWith(service);
+        });
+      });
+    });
+
     describe("when registration succeeds", () => {
       it("should fetch the service details and register", async () => {
         fakeSonos.register.mockResolvedValue(true);
-        const sonosDiscovery = { auto: true };
 
-        expect(await registrar(bonobUrl, sonosDiscovery)()).toEqual(
+        expect(await registrar(bonobUrl)()).toEqual(
           true
         );
-
-        expect(bonobService).toHaveBeenCalledWith(
-          serviceDetails.name,
-          serviceDetails.sid,
-          bonobUrl
-        );
-        expect(sonos).toHaveBeenCalledWith(sonosDiscovery);
-        expect(fakeSonos.register).toHaveBeenCalledWith(service);
       });
     });
 
     describe("when registration fails", () => {
       it("should fetch the service details and register", async () => {
         fakeSonos.register.mockResolvedValue(false);
-        const sonosDiscovery = { auto: false, seedHost: "192.168.1.163" };
 
-        expect(await registrar(bonobUrl, sonosDiscovery)()).toEqual(
+        expect(await registrar(bonobUrl)()).toEqual(
           false
         );
-
-        expect(bonobService).toHaveBeenCalledWith(
-          serviceDetails.name,
-          serviceDetails.sid,
-          bonobUrl
-        );
-        expect(sonos).toHaveBeenCalledWith(sonosDiscovery);
-        expect(fakeSonos.register).toHaveBeenCalledWith(service);
       });
     });
   });

tests/scenarios.test.ts

@@ -33,9 +33,10 @@ class LoggedInSonosDriver {
     this.client = client;
     this.token = token;
     this.client.addSoapHeader({
-      credentials: someCredentials(
-        this.token.getDeviceAuthTokenResult.authToken
-      ),
+      credentials: someCredentials({
+        token: this.token.getDeviceAuthTokenResult.authToken,
+        key: this.token.getDeviceAuthTokenResult.privateKey
+      }),
     });
   }
 
@@ -272,7 +273,7 @@ describe("scenarios", () => {
       bonobUrl,
       musicService,
       {
-        linkCodes: () => linkCodes
+        linkCodes: () => linkCodes,
       }
     );
 

tests/smapi_auth.test.ts

@@ -0,0 +1,188 @@
+import { v4 as uuid } from "uuid";
+import jwt from "jsonwebtoken";
+
+import {
+  ExpiredTokenError,
+  InvalidTokenError,
+  isSmapiRefreshTokenResultFault,
+  JWTSmapiLoginTokens,
+  smapiTokenAsString,
+  smapiTokenFromString,
+  SMAPI_TOKEN_VERSION,
+} from "../src/smapi_auth";
+import { either as E } from "fp-ts";
+import { FixedClock } from "../src/clock";
+import dayjs from "dayjs";
+import { b64Encode } from "../src/b64";
+
+describe("smapiTokenAsString", () => {
+  it("can round trip token to and from string", () => {
+    const smapiToken = { token: uuid(), key: uuid(), someOtherStuff: 'this needs to be explicitly ignored' };
+    const asString = smapiTokenAsString(smapiToken)
+
+    expect(asString).toEqual(b64Encode(JSON.stringify({
+      token: smapiToken.token,
+      key: smapiToken.key,
+    })));
+    expect(smapiTokenFromString(asString)).toEqual({
+      token: smapiToken.token,
+      key: smapiToken.key
+    });
+  });
+});
+
+describe("isSmapiRefreshTokenResultFault", () => {
+  it("should return true for a refreshAuthTokenResult fault", () => {
+    const faultWithRefreshAuthToken = {
+      Fault: {
+        faultcode: "",
+        faultstring: "",
+        detail: {
+          refreshAuthTokenResult: {
+            authToken: "x",
+            privateKey: "x",
+          },
+        },
+      },
+    };
+    expect(isSmapiRefreshTokenResultFault(faultWithRefreshAuthToken)).toEqual(
+      true
+    );
+  });
+
+  it("should return false when is not a refreshAuthTokenResult", () => {
+    expect(isSmapiRefreshTokenResultFault({ Fault: { faultcode: "", faultstring:" " }})).toEqual(
+      false
+    );
+  });
+});
+
+describe("auth", () => {
+  describe("JWTSmapiLoginTokens", () => {
+    const clock = new FixedClock(dayjs());
+
+    const expiresIn = "1h";
+    const secret = `secret-${uuid()}`;
+    const key = uuid();
+    const smapiLoginTokens = new JWTSmapiLoginTokens(clock, secret, expiresIn, () => key);
+
+    describe("issuing a new token", () => {
+      it("should issue a token that can then be verified", () => {
+        const serviceToken = `service-token-${uuid()}`;
+
+        const smapiToken = smapiLoginTokens.issue(serviceToken);
+
+        const expected = jwt.sign(
+          {
+            serviceToken,
+            iat: clock.now().unix(),
+          },
+          secret + SMAPI_TOKEN_VERSION + key,
+          { expiresIn }
+        );
+
+        expect(smapiToken.token).toEqual(expected);
+        expect(smapiToken.token).not.toContain(serviceToken);
+        expect(smapiToken.token).not.toContain(secret);
+        expect(smapiToken.token).not.toContain(":");
+
+        const roundTripped = smapiLoginTokens.verify(smapiToken);
+
+        expect(roundTripped).toEqual(E.right(serviceToken));
+      });
+    });
+
+    describe("when verifying the token fails", () => {
+      describe("due to the version changing", () => {
+        it("should return an error", () => {
+          const authToken = uuid();
+
+          const vXSmapiTokens = new JWTSmapiLoginTokens(
+            clock,
+            secret,
+            expiresIn,
+            uuid,
+            SMAPI_TOKEN_VERSION
+          );
+
+          const vXPlus1SmapiTokens = new JWTSmapiLoginTokens(
+            clock,
+            secret,
+            expiresIn,
+            () => uuid(),
+            SMAPI_TOKEN_VERSION + 1
+          );
+
+          const v1Token = vXSmapiTokens.issue(authToken);
+          expect(vXSmapiTokens.verify(v1Token)).toEqual(E.right(authToken));
+
+          const result = vXPlus1SmapiTokens.verify(v1Token);
+          expect(result).toEqual(
+            E.left(new InvalidTokenError("invalid signature"))
+          );
+        });
+      });
+      
+      describe("due to secret changing", () => {
+        it("should return an error", () => {
+          const authToken = uuid();
+
+          const smapiToken = new JWTSmapiLoginTokens(
+            clock,
+            "A different secret",
+            expiresIn
+          ).issue(authToken);
+
+          const result = smapiLoginTokens.verify(smapiToken);
+          expect(result).toEqual(
+            E.left(new InvalidTokenError("invalid signature"))
+          );
+        });
+      });
+
+      describe("due to key changing", () => {
+        it("should return an error", () => {
+          const authToken = uuid();
+
+          const smapiToken = smapiLoginTokens.issue(authToken);
+
+          const result = smapiLoginTokens.verify({
+            ...smapiToken,
+            key: "some other key",
+          });
+          expect(result).toEqual(
+            E.left(new InvalidTokenError("invalid signature"))
+          );
+        });
+      });
+    });
+
+    describe("when the token has expired", () => {
+      it("should return an ExpiredTokenError, with the authToken", () => {
+        const authToken = uuid();
+        const now = dayjs();
+        const tokenIssuedAt = now.subtract(31, "seconds");
+
+        const tokensWith30SecondExpiry = new JWTSmapiLoginTokens(
+          clock,
+          uuid(),
+          "30s"
+        );
+
+        clock.time = tokenIssuedAt;
+        const expiredToken = tokensWith30SecondExpiry.issue(authToken);
+
+        clock.time = now;
+
+        const result = tokensWith30SecondExpiry.verify(expiredToken);
+        expect(result).toEqual(
+          E.left(
+            new ExpiredTokenError(
+              authToken
+            )
+          )
+        );
+      });
+    });
+  });
+});

tests/sonos.test.ts

@@ -274,12 +274,13 @@ describe("sonos", () => {
 
   describe("when is disabled", () => {
     it("should return a disabled client", async () => {
-      const disabled = sonos({ auto: false });
+      const disabled = sonos({ enabled: false });
 
       expect(disabled).toEqual(SONOS_DISABLED);
       expect(await disabled.devices()).toEqual([]);
       expect(await disabled.services()).toEqual([]);
-      expect(await disabled.register(aService())).toEqual(true);
+      expect(await disabled.register(aService())).toEqual(false);
+      expect(await disabled.remove(123)).toEqual(false);
     });
   });
 
@@ -310,7 +311,7 @@ describe("sonos", () => {
         );
         sonosManager.InitializeWithDiscovery.mockResolvedValue(true);
 
-        const actualDevices = await sonos({ auto: true }).devices();
+        const actualDevices = await sonos({ enabled: true }).devices();
 
         expect(SonosManager).toHaveBeenCalledTimes(1);
         expect(sonosManager.InitializeWithDiscovery).toHaveBeenCalledWith(10);
@@ -331,7 +332,7 @@ describe("sonos", () => {
         );
         sonosManager.InitializeWithDiscovery.mockResolvedValue(true);
 
-        const actualDevices = await sonos({ auto: true, seedHost: "" }).devices();
+        const actualDevices = await sonos({ enabled: true, seedHost: "" }).devices();
 
         expect(SonosManager).toHaveBeenCalledTimes(1);
         expect(sonosManager.InitializeWithDiscovery).toHaveBeenCalledWith(10);
@@ -354,7 +355,7 @@ describe("sonos", () => {
         );
         sonosManager.InitializeFromDevice.mockResolvedValue(true);
 
-        const actualDevices = await sonos({ auto: true, seedHost }).devices();
+        const actualDevices = await sonos({ enabled: true, seedHost }).devices();
 
         expect(SonosManager).toHaveBeenCalledTimes(1);
         expect(sonosManager.InitializeFromDevice).toHaveBeenCalledWith(
@@ -377,7 +378,7 @@ describe("sonos", () => {
         );
         sonosManager.InitializeWithDiscovery.mockResolvedValue(true);
 
-        const actualDevices = await sonos({ auto: true, seedHost: undefined }).devices();
+        const actualDevices = await sonos({ enabled: true, seedHost: undefined }).devices();
 
         expect(actualDevices).toEqual([
           {
@@ -408,7 +409,7 @@ describe("sonos", () => {
         );
         sonosManager.InitializeWithDiscovery.mockResolvedValue(false);
 
-        expect(await sonos({ auto: true, seedHost: "" }).devices()).toEqual([]);
+        expect(await sonos({ enabled: true, seedHost: "" }).devices()).toEqual([]);
       });
     });
   });

tests/tsconfig.json

@@ -1,23 +1,23 @@
 {
-    "extends": "../tsconfig.json",
-    "compilerOptions": {
-      "target": "es2019",
-      "baseUrl": "./",
-      "module": "commonjs",
-      "experimentalDecorators": true,
-      "strictPropertyInitialization": false,
-      "isolatedModules": false,
-      "strict": true,
-      "noImplicitAny": false,
-      "typeRoots" : [
-        "../typings",
-        "../node_modules/@types"
-      ]
-    },
-    "exclude": [
-      "../node_modules"
-    ],
-    "include": [
-      "./**/*.ts"
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "target": "es2019",
+    "baseUrl": "./",
+    "module": "commonjs",
+    "experimentalDecorators": true,
+    "strictPropertyInitialization": false,
+    "isolatedModules": false,
+    "strict": true,
+    "noImplicitAny": false,
+    "typeRoots" : [
+      "../typings",
+      "../node_modules/@types"
     ]
-  }
+  },
+  "exclude": [
+    "../node_modules"
+  ],
+  "include": [
+    "./**/*.ts"
+  ]
+}

web/icons/Heart-85038.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+    <path d="M16.5,3C13.605,3,12,5.09,12,5.09S10.395,3,7.5,3C4.462,3,2,5.462,2,8.5c0,4.171,4.912,8.213,6.281,9.49C9.858,19.46,12,21.35,12,21.35s2.142-1.89,3.719-3.36C17.088,16.713,22,12.671,22,8.5C22,5.462,19.538,3,16.5,3z M14.811,16.11c-0.177,0.16-0.331,0.299-0.456,0.416c-0.751,0.7-1.639,1.503-2.355,2.145c-0.716-0.642-1.605-1.446-2.355-2.145c-0.126-0.117-0.28-0.257-0.456-0.416C7.769,14.827,4,11.419,4,8.5C4,6.57,5.57,5,7.5,5c1.827,0,2.886,1.275,2.914,1.308L12,8l1.586-1.692C13.596,6.295,14.673,5,16.5,5C18.43,5,20,6.57,20,8.5C20,11.419,16.231,14.827,14.811,16.11z"/>
+</svg>

web/icons/Heart-85339.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+    <path d="M16.5,3C13.605,3,12,5.09,12,5.09S10.395,3,7.5,3C4.462,3,2,5.462,2,8.5c0,4.171,4.912,8.213,6.281,9.49C9.858,19.46,12,21.35,12,21.35s2.142-1.89,3.719-3.36C17.088,16.713,22,12.671,22,8.5C22,5.462,19.538,3,16.5,3z"/>
+</svg>

web/icons/Star-16101.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+    <path fill="none" stroke="#000" stroke-miterlimit="10" stroke-width="2" d="M16 4.587L19.486 12.407 28 13.306 21.64 19.037 23.416 27.413 16 23.135 8.584 27.413 10.36 19.037 4 13.306 12.514 12.407z"/>
+</svg>

web/icons/Star-43879.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16">
+  <path fill="none" stroke="#000" stroke-miterlimit="10" d="M8 2.25L9.701 6.283 13.875 6.738 10.753 9.686 11.631 14 8 11.788 4.369 14 5.247 9.686 2.125 6.738 6.299 6.283z"/>
+</svg>

web/public/love-selected.svg

@@ -0,0 +1,4 @@
+<svg width="44" height="44" viewBox="0 0 44 44" fill="none"
+  xmlns="http://www.w3.org/2000/svg">
+  <path d="M26.4287 14.0097C25.1137 13.9677 23.7987 14.4057 22.7378 15.3397L22.2507 15.7707L21.7618 15.3377C19.6558 13.4727 16.4607 13.5687 14.4717 15.5577L14.4647 15.5657C12.5117 17.5177 12.5117 20.6837 14.4647 22.6367L21.8897 30.0607C22.0847 30.2567 22.4018 30.2567 22.5968 30.0607L29.8757 22.7817C31.8717 20.7867 31.9697 17.4207 29.9277 15.4747C28.9507 14.5427 27.6967 14.0437 26.4287 14.0097Z" fill="white"/>
+</svg>

web/public/love-unselected.svg

@@ -0,0 +1,4 @@
+<svg width="44" height="44" viewBox="0 0 44 44" fill="none"
+  xmlns="http://www.w3.org/2000/svg">
+  <path d="M28.5217 21.3077L22.2437 27.5867L15.8788 21.2227C14.5428 19.8857 14.7378 17.5727 16.4758 16.5097C17.7548 15.7267 19.4187 15.9657 20.5557 16.9447L20.7367 17.0997L21.9117 18.1417C22.1007 18.3097 22.3857 18.3097 22.5747 18.1417L23.7498 17.0997L24.0597 16.8307C25.4047 15.6457 27.4587 15.7457 28.6877 17.0637C29.8018 18.2567 29.6757 20.1537 28.5217 21.3077ZM26.4287 14.0097C25.1137 13.9677 23.7987 14.4057 22.7378 15.3397L22.2507 15.7707L21.7618 15.3377C19.6558 13.4727 16.4607 13.5687 14.4717 15.5577L14.4647 15.5657C12.5117 17.5177 12.5117 20.6837 14.4647 22.6367L21.8897 30.0607C22.0847 30.2567 22.4018 30.2567 22.5968 30.0607L29.8757 22.7817C31.8717 20.7867 31.9697 17.4207 29.9277 15.4747C28.9507 14.5427 27.6967 14.0437 26.4287 14.0097Z" fill="white" fill-opacity="0.6"/>
+</svg>

web/public/ratingIcons.html

@@ -0,0 +1,10 @@
+<html>
+  <body style="background-color: black;">
+    <img src="star0.svg" width="80px"><br>
+    <img src="star1.svg" width="80px"><br>
+    <img src="star2.svg" width="80px"><br>
+    <img src="star3.svg" width="80px"><br>
+    <img src="star4.svg" width="80px"><br>
+    <img src="star5.svg" width="80px"><br>
+  </body>
+</html>

web/public/star0.svg

@@ -0,0 +1,5 @@
+<svg version="1.1" baseProfile="basic" id="_x38_8"
+	xmlns="http://www.w3.org/2000/svg"
+	xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 44 44" xml:space="preserve">
+	<path id="star" fill="#FFFFFF" d="M28,31l-6-4.3L16,31l2.6-6.8l-5.1-4.3h6l2.5-6.9l2.6,6.9h6l-5.1,4.3L28,31z"/>
+</svg>

web/public/star1.svg

@@ -0,0 +1,6 @@
+<svg version="1.1" baseProfile="basic" id="_x38_8"
+	xmlns="http://www.w3.org/2000/svg"
+	xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 44 44" xml:space="preserve">
+	<path id="star" fill="#FBB040" d="M28,31l-6-4.3L16,31l2.6-6.8l-5.1-4.3h6l2.5-6.9l2.6,6.9h6l-5.1,4.3L28,31z"/>
+	<circle cx="22" cy="32" r="2" fill="#FBB040"/>
+</svg>

web/public/star2.svg

@@ -0,0 +1,7 @@
+<svg version="1.1" baseProfile="basic" id="_x38_8"
+	xmlns="http://www.w3.org/2000/svg"
+	xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 44 44" xml:space="preserve">
+	<path id="star" fill="#FBB040" d="M28,31l-6-4.3L16,31l2.6-6.8l-5.1-4.3h6l2.5-6.9l2.6,6.9h6l-5.1,4.3L28,31z"/>
+	<circle cx="22" cy="32" r="2" fill="#FBB040"/>
+	<circle cx="14" cy="26" r="2" fill="#FBB040"/>
+</svg>

web/public/star3.svg

@@ -0,0 +1,8 @@
+<svg version="1.1" baseProfile="basic" id="_x38_8"
+	xmlns="http://www.w3.org/2000/svg"
+	xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 44 44" xml:space="preserve">
+	<path id="star" fill="#FBB040" d="M28,31l-6-4.3L16,31l2.6-6.8l-5.1-4.3h6l2.5-6.9l2.6,6.9h6l-5.1,4.3L28,31z"/>
+	<circle cx="22" cy="32" r="2" fill="#FBB040"/>
+	<circle cx="14" cy="26" r="2" fill="#FBB040"/>
+	<circle cx="17" cy="16" r="2" fill="#FBB040"/>
+</svg>

web/public/star4.svg

@@ -0,0 +1,9 @@
+<svg version="1.1" baseProfile="basic" id="_x38_8"
+	xmlns="http://www.w3.org/2000/svg"
+	xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 44 44" xml:space="preserve">
+	<path id="star" fill="#FBB040" d="M28,31l-6-4.3L16,31l2.6-6.8l-5.1-4.3h6l2.5-6.9l2.6,6.9h6l-5.1,4.3L28,31z"/>
+	<circle cx="22" cy="32" r="2" fill="#FBB040"/>
+	<circle cx="14" cy="26" r="2" fill="#FBB040"/>
+	<circle cx="17" cy="16" r="2" fill="#FBB040"/>
+	<circle cx="27" cy="16" r="2" fill="#FBB040"/>
+</svg>

web/public/star5.svg

@@ -0,0 +1,10 @@
+<svg version="1.1" baseProfile="basic" id="_x38_8"
+	xmlns="http://www.w3.org/2000/svg"
+	xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 44 44" xml:space="preserve">
+	<path id="star" fill="#FBB040" d="M28,31l-6-4.3L16,31l2.6-6.8l-5.1-4.3h6l2.5-6.9l2.6,6.9h6l-5.1,4.3L28,31z"/>
+	<circle cx="22" cy="32" r="2" fill="#FBB040"/>
+	<circle cx="14" cy="26" r="2" fill="#FBB040"/>
+	<circle cx="17" cy="16" r="2" fill="#FBB040"/>
+	<circle cx="27" cy="16" r="2" fill="#FBB040"/>
+	<circle cx="30" cy="26" r="2" fill="#FBB040"/>
+</svg>

yarn.lock

@@ -1131,6 +1131,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/fs-extra@npm:^9.0.13":
+  version: 9.0.13
+  resolution: "@types/fs-extra@npm:9.0.13"
+  dependencies:
+    "@types/node": "*"
+  checksum: add79e212acd5ac76b97b9045834e03a7996aef60a814185e0459088fd290519a3c1620865d588fa36c4498bf614210d2a703af5cf80aa1dbc125db78f6edac3
+  languageName: node
+  linkType: hard
+
 "@types/graceful-fs@npm:^4.1.2":
   version: 4.1.5
   resolution: "@types/graceful-fs@npm:4.1.5"
@@ -1175,6 +1184,24 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/jsonwebtoken@npm:^8.5.5":
+  version: 8.5.5
+  resolution: "@types/jsonwebtoken@npm:8.5.5"
+  dependencies:
+    "@types/node": "*"
+  checksum: 33c30354641bc7849be7507e9f48685b1f487e944321a932650eac6c247c85184667f5e207ccfcab0da8cb24bde93a8372c09cacf1849e976bbf2cb90b26ce90
+  languageName: node
+  linkType: hard
+
+"@types/jws@npm:^3.2.4":
+  version: 3.2.4
+  resolution: "@types/jws@npm:3.2.4"
+  dependencies:
+    "@types/node": "*"
+  checksum: 43427a5b00ef0c5e60df6bc8e59c4153220c757fdbde2b79a1852e86083bdc76b660b3c0d89ae9e5902dab00bf6ae9f25a551a375ca233b6e02fa1e4e3fff6c4
+  languageName: node
+  linkType: hard
+
 "@types/keyv@npm:^3.1.1":
   version: 3.1.2
   resolution: "@types/keyv@npm:3.1.2"
@@ -1242,6 +1269,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/randomstring@npm:^1.1.8":
+  version: 1.1.8
+  resolution: "@types/randomstring@npm:1.1.8"
+  checksum: 22a9e4b09583ad8e7fa7ca214133abc014636d7d6eb49ca9ee671c09b241311107b0a6ea48205bf795ac61fbe5b185ac415aed2dd27c7f5806235bfea0e5532f
+  languageName: node
+  linkType: hard
+
 "@types/range-parser@npm:*":
   version: 1.2.3
   resolution: "@types/range-parser@npm:1.2.3"
@@ -1303,6 +1337,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/tmp@npm:^0.2.1":
+  version: 0.2.1
+  resolution: "@types/tmp@npm:0.2.1"
+  checksum: 2617d2a04811ca78a8d21f5ffc3bd7c392e03c440053a615b091f3e3726540d36babffc750614a803c81b9f2c5f218cdafc748d8cf4638eade2962f8ccddd2fa
+  languageName: node
+  linkType: hard
+
 "@types/underscore@npm:^1.11.3":
   version: 1.11.3
   resolution: "@types/underscore@npm:1.11.3"
@@ -1333,7 +1374,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@xmldom/xmldom@npm:^0.7.0, @xmldom/xmldom@npm:^0.7.4":
+"@xmldom/xmldom@npm:^0.7.0":
   version: 0.7.4
   resolution: "@xmldom/xmldom@npm:0.7.4"
   checksum: f807a921fe2c1b4244bb0c79ac6b61f06c8a71c5108017aa022060aa0ffb0c832aa7a704288a9c66888991bf701da8c9148c0775e66b0b3efe8d884153c5729d
@@ -1566,6 +1607,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"array-uniq@npm:1.0.2":
+  version: 1.0.2
+  resolution: "array-uniq@npm:1.0.2"
+  checksum: 8c4beb94aa183791da1e155935aba4df3fe2eeb6f491c69e666ca7351f897b9b260fa04d016e0ce766ae8280129c16f11071e17359c81c01741289009bb5ac6d
+  languageName: node
+  linkType: hard
+
 "assertion-error@npm:^1.1.0":
   version: 1.1.0
   resolution: "assertion-error@npm:1.1.0"
@@ -1764,12 +1812,17 @@ __metadata:
     "@svrooij/sonos": ^2.4.0
     "@types/chai": ^4.2.21
     "@types/express": ^4.17.13
+    "@types/fs-extra": ^9.0.13
     "@types/jest": ^27.0.1
+    "@types/jsonwebtoken": ^8.5.5
+    "@types/jws": ^3.2.4
     "@types/mocha": ^9.0.0
     "@types/morgan": ^1.9.3
     "@types/node": ^16.7.13
+    "@types/randomstring": ^1.1.8
     "@types/sharp": ^0.28.6
     "@types/supertest": ^2.0.11
+    "@types/tmp": ^0.2.1
     "@types/underscore": ^1.11.3
     "@types/uuid": ^8.3.1
     axios: ^0.21.4
@@ -1778,25 +1831,30 @@ __metadata:
     eta: ^1.12.3
     express: ^4.17.1
     fp-ts: ^2.11.1
+    fs-extra: ^10.0.0
     get-port: ^5.1.1
     image-js: ^0.33.0
     jest: ^27.1.0
+    jsonwebtoken: ^8.5.1
+    jws: ^4.0.0
     libxmljs2: ^0.28.0
     morgan: ^1.10.0
     node-html-parser: ^4.1.4
     nodemon: ^2.0.12
+    randomstring: ^1.2.1
     sharp: ^0.29.1
     soap: ^0.42.0
     supertest: ^6.1.6
+    tmp: ^0.2.1
     ts-jest: ^27.0.5
     ts-md5: ^1.2.9
     ts-mockito: ^2.6.1
     ts-node: ^10.2.1
     typescript: ^4.4.2
     underscore: ^1.13.1
+    urn-lib: ^2.0.0
     uuid: ^8.3.2
     winston: ^3.3.3
-    x2js: ^3.4.2
     xmldom-ts: ^0.3.1
     xpath-ts: ^1.3.13
   languageName: unknown
@@ -1884,6 +1942,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"buffer-equal-constant-time@npm:1.0.1":
+  version: 1.0.1
+  resolution: "buffer-equal-constant-time@npm:1.0.1"
+  checksum: 80bb945f5d782a56f374b292770901065bad21420e34936ecbe949e57724b4a13874f735850dd1cc61f078773c4fb5493a41391e7bda40d1fa388d6bd80daaab
+  languageName: node
+  linkType: hard
+
 "buffer-from@npm:^1.0.0":
   version: 1.1.1
   resolution: "buffer-from@npm:1.1.1"
@@ -2698,6 +2763,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"ecdsa-sig-formatter@npm:1.0.11":
+  version: 1.0.11
+  resolution: "ecdsa-sig-formatter@npm:1.0.11"
+  dependencies:
+    safe-buffer: ^5.0.1
+  checksum: 207f9ab1c2669b8e65540bce29506134613dd5f122cccf1e6a560f4d63f2732d427d938f8481df175505aad94583bcb32c688737bb39a6df0625f903d6d93c03
+  languageName: node
+  linkType: hard
+
 "ee-first@npm:1.1.1":
   version: 1.1.1
   resolution: "ee-first@npm:1.1.1"
@@ -3162,6 +3236,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"fs-extra@npm:^10.0.0":
+  version: 10.0.0
+  resolution: "fs-extra@npm:10.0.0"
+  dependencies:
+    graceful-fs: ^4.2.0
+    jsonfile: ^6.0.1
+    universalify: ^2.0.0
+  checksum: 5285a3d8f34b917cf2b66af8c231a40c1623626e9d701a20051d3337be16c6d7cac94441c8b3732d47a92a2a027886ca93c69b6a4ae6aee3c89650d2a8880c0a
+  languageName: node
+  linkType: hard
+
 "fs-minipass@npm:^2.0.0":
   version: 2.1.0
   resolution: "fs-minipass@npm:2.1.0"
@@ -3362,7 +3447,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"graceful-fs@npm:^4.2.6":
+"graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.6":
   version: 4.2.8
   resolution: "graceful-fs@npm:4.2.8"
   checksum: 5d224c8969ad0581d551dfabdb06882706b31af2561bd5e2034b4097e67cc27d05232849b8643866585fd0a41c7af152950f8776f4dd5579e9853733f31461c6
@@ -4598,6 +4683,79 @@ __metadata:
   languageName: node
   linkType: hard
 
+"jsonfile@npm:^6.0.1":
+  version: 6.1.0
+  resolution: "jsonfile@npm:6.1.0"
+  dependencies:
+    graceful-fs: ^4.1.6
+    universalify: ^2.0.0
+  dependenciesMeta:
+    graceful-fs:
+      optional: true
+  checksum: 7af3b8e1ac8fe7f1eccc6263c6ca14e1966fcbc74b618d3c78a0a2075579487547b94f72b7a1114e844a1e15bb00d440e5d1720bfc4612d790a6f285d5ea8354
+  languageName: node
+  linkType: hard
+
+"jsonwebtoken@npm:^8.5.1":
+  version: 8.5.1
+  resolution: "jsonwebtoken@npm:8.5.1"
+  dependencies:
+    jws: ^3.2.2
+    lodash.includes: ^4.3.0
+    lodash.isboolean: ^3.0.3
+    lodash.isinteger: ^4.0.4
+    lodash.isnumber: ^3.0.3
+    lodash.isplainobject: ^4.0.6
+    lodash.isstring: ^4.0.1
+    lodash.once: ^4.0.0
+    ms: ^2.1.1
+    semver: ^5.6.0
+  checksum: 93c9e3f23c59b758ac88ba15f4e4753b3749dfce7a6f7c40fb86663128a1e282db085eec852d4e0cbca4cefdcd3a8275ee255dbd08fcad0df26ad9f6e4cc853a
+  languageName: node
+  linkType: hard
+
+"jwa@npm:^1.4.1":
+  version: 1.4.1
+  resolution: "jwa@npm:1.4.1"
+  dependencies:
+    buffer-equal-constant-time: 1.0.1
+    ecdsa-sig-formatter: 1.0.11
+    safe-buffer: ^5.0.1
+  checksum: ff30ea7c2dcc61f3ed2098d868bf89d43701605090c5b21b5544b512843ec6fd9e028381a4dda466cbcdb885c2d1150f7c62e7168394ee07941b4098e1035e2f
+  languageName: node
+  linkType: hard
+
+"jwa@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "jwa@npm:2.0.0"
+  dependencies:
+    buffer-equal-constant-time: 1.0.1
+    ecdsa-sig-formatter: 1.0.11
+    safe-buffer: ^5.0.1
+  checksum: 8f00b71ad5fe94cb55006d0d19202f8f56889109caada2f7eeb63ca81755769ce87f4f48101967f398462e3b8ae4faebfbd5a0269cb755dead5d63c77ba4d2f1
+  languageName: node
+  linkType: hard
+
+"jws@npm:^3.2.2":
+  version: 3.2.2
+  resolution: "jws@npm:3.2.2"
+  dependencies:
+    jwa: ^1.4.1
+    safe-buffer: ^5.0.1
+  checksum: f0213fe5b79344c56cd443428d8f65c16bf842dc8cb8f5aed693e1e91d79c20741663ad6eff07a6d2c433d1831acc9814e8d7bada6a0471fbb91d09ceb2bf5c2
+  languageName: node
+  linkType: hard
+
+"jws@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "jws@npm:4.0.0"
+  dependencies:
+    jwa: ^2.0.0
+    safe-buffer: ^5.0.1
+  checksum: d68d07aa6d1b8cb35c363a9bd2b48f15064d342a5d9dc18a250dbbce8dc06bd7e4792516c50baa16b8d14f61167c19e851fd7f66b59ecc68b7f6a013759765f7
+  languageName: node
+  linkType: hard
+
 "keyv@npm:^3.0.0":
   version: 3.1.0
   resolution: "keyv@npm:3.1.0"
@@ -4667,6 +4825,55 @@ __metadata:
   languageName: node
   linkType: hard
 
+"lodash.includes@npm:^4.3.0":
+  version: 4.3.0
+  resolution: "lodash.includes@npm:4.3.0"
+  checksum: 71092c130515a67ab3bd928f57f6018434797c94def7f46aafa417771e455ce3a4834889f4267b17887d7f75297dfabd96231bf704fd2b8c5096dc4a913568b6
+  languageName: node
+  linkType: hard
+
+"lodash.isboolean@npm:^3.0.3":
+  version: 3.0.3
+  resolution: "lodash.isboolean@npm:3.0.3"
+  checksum: b70068b4a8b8837912b54052557b21fc4774174e3512ed3c5b94621e5aff5eb6c68089d0a386b7e801d679cd105d2e35417978a5e99071750aa2ed90bffd0250
+  languageName: node
+  linkType: hard
+
+"lodash.isinteger@npm:^4.0.4":
+  version: 4.0.4
+  resolution: "lodash.isinteger@npm:4.0.4"
+  checksum: 6034821b3fc61a2ffc34e7d5644bb50c5fd8f1c0121c554c21ac271911ee0c0502274852845005f8651d51e199ee2e0cfebfe40aaa49c7fe617f603a8a0b1691
+  languageName: node
+  linkType: hard
+
+"lodash.isnumber@npm:^3.0.3":
+  version: 3.0.3
+  resolution: "lodash.isnumber@npm:3.0.3"
+  checksum: 913784275b565346255e6ae6a6e30b760a0da70abc29f3e1f409081585875105138cda4a429ff02577e1bc0a7ae2a90e0a3079a37f3a04c3d6c5aaa532f4cab2
+  languageName: node
+  linkType: hard
+
+"lodash.isplainobject@npm:^4.0.6":
+  version: 4.0.6
+  resolution: "lodash.isplainobject@npm:4.0.6"
+  checksum: 29c6351f281e0d9a1d58f1a4c8f4400924b4c79f18dfc4613624d7d54784df07efaff97c1ff2659f3e085ecf4fff493300adc4837553104cef2634110b0d5337
+  languageName: node
+  linkType: hard
+
+"lodash.isstring@npm:^4.0.1":
+  version: 4.0.1
+  resolution: "lodash.isstring@npm:4.0.1"
+  checksum: eaac87ae9636848af08021083d796e2eea3d02e80082ab8a9955309569cb3a463ce97fd281d7dc119e402b2e7d8c54a23914b15d2fc7fff56461511dc8937ba0
+  languageName: node
+  linkType: hard
+
+"lodash.once@npm:^4.0.0":
+  version: 4.1.1
+  resolution: "lodash.once@npm:4.1.1"
+  checksum: d768fa9f9b4e1dc6453be99b753906f58990e0c45e7b2ca5a3b40a33111e5d17f6edf2f768786e2716af90a8e78f8f91431ab8435f761fef00f9b0c256f6d245
+  languageName: node
+  linkType: hard
+
 "lodash@npm:4.x, lodash@npm:^4.17.21, lodash@npm:^4.17.5, lodash@npm:^4.7.0":
   version: 4.17.21
   resolution: "lodash@npm:4.17.21"
@@ -5823,6 +6030,25 @@ __metadata:
   languageName: node
   linkType: hard
 
+"randombytes@npm:2.0.3":
+  version: 2.0.3
+  resolution: "randombytes@npm:2.0.3"
+  checksum: 13e1abd143404dd87024bf345fb1a446b2e2ee46d8e1a5a073e8370c9b1e58000d81a97d4327ba7089087213eb6d8c77fa67ab4e91aa00605126d634fcccb9d4
+  languageName: node
+  linkType: hard
+
+"randomstring@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "randomstring@npm:1.2.1"
+  dependencies:
+    array-uniq: 1.0.2
+    randombytes: 2.0.3
+  bin:
+    randomstring: bin/randomstring
+  checksum: 501da2ec59638d502dbb66c237ab80790dbb0b50b493347cbf6abc2dfbf6fe08f195d85e37911689bc406f85d31cf9826757398b5af8c9cae7c0ad4f808f3ac0
+  languageName: node
+  linkType: hard
+
 "range-parser@npm:~1.2.1":
   version: 1.2.1
   resolution: "range-parser@npm:1.2.1"
@@ -6095,7 +6321,7 @@ resolve@^1.20.0:
   languageName: node
   linkType: hard
 
-"semver@npm:^5.4.1, semver@npm:^5.7.1":
+"semver@npm:^5.4.1, semver@npm:^5.6.0, semver@npm:^5.7.1":
   version: 5.7.1
   resolution: "semver@npm:5.7.1"
   bin:
@@ -6685,6 +6911,15 @@ resolve@^1.20.0:
   languageName: node
   linkType: hard
 
+"tmp@npm:^0.2.1":
+  version: 0.2.1
+  resolution: "tmp@npm:0.2.1"
+  dependencies:
+    rimraf: ^3.0.0
+  checksum: 8b1214654182575124498c87ca986ac53dc76ff36e8f0e0b67139a8d221eaecfdec108c0e6ec54d76f49f1f72ab9325500b246f562b926f85bcdfca8bf35df9e
+  languageName: node
+  linkType: hard
+
 "tmpl@npm:1.0.x":
   version: 1.0.4
   resolution: "tmpl@npm:1.0.4"
@@ -6992,6 +7227,13 @@ typescript@^4.4.2:
   languageName: node
   linkType: hard
 
+"universalify@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "universalify@npm:2.0.0"
+  checksum: 2406a4edf4a8830aa6813278bab1f953a8e40f2f63a37873ffa9a3bc8f9745d06cc8e88f3572cb899b7e509013f7f6fcc3e37e8a6d914167a5381d8440518c44
+  languageName: node
+  linkType: hard
+
 "unpipe@npm:1.0.0, unpipe@npm:~1.0.0":
   version: 1.0.0
   resolution: "unpipe@npm:1.0.0"
@@ -7029,6 +7271,13 @@ typescript@^4.4.2:
   languageName: node
   linkType: hard
 
+"urn-lib@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "urn-lib@npm:2.0.0"
+  checksum: fde3f4b8c38483d6229fe49e23cbf9cc012e0b4459d6aacb9bb2f3f1a32992b0e1115122401cca3708598ffa279355182158c7f7c248881ff72dc0f9e9f76d82
+  languageName: node
+  linkType: hard
+
 "utf8@npm:^2.1.2":
   version: 2.1.2
   resolution: "utf8@npm:2.1.2"
@@ -7260,15 +7509,6 @@ typescript@^4.4.2:
   languageName: node
   linkType: hard
 
-"x2js@npm:^3.4.2":
-  version: 3.4.2
-  resolution: "x2js@npm:3.4.2"
-  dependencies:
-    "@xmldom/xmldom": ^0.7.4
-  checksum: 4a77f684b312492f42265aad88c849347831fe17c7c43c66b2f45f3742bd008221c80d0c6875d2a14d63ebcb833130086d7c0d0103674c68c41a9e222e9c05d2
-  languageName: node
-  linkType: hard
-
 "xdg-basedir@npm:^4.0.0":
   version: 4.0.0
   resolution: "xdg-basedir@npm:4.0.0"