refactor

* Improve ffmpeg command to transcode flac

The command previously suggested forced the output sample rate to 48 kHz, even if the input was lower, at 44.1 kHz. 
This new command lets `ffmpeg` select the appropriate output sample rate to minimize conversion. 
Documentation: https://www.ffmpeg.org/ffmpeg-filters.html#aformat-1

* Update transcoding command

- Support more sample rates and bit depths.
- Add note about S1

.github/workflows/ci.yml

@@ -16,11 +16,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - 
+        name: Check out the repo
         uses: actions/checkout@v2
       - 
         uses: actions/setup-node@v1
         with:
-          node-version: 16.x
+          node-version: '16'
       - 
         run: yarn install
       - 
@@ -29,11 +30,20 @@ jobs:
 
   push_to_registry:
     name: Push Docker image to Docker Hub
+    needs: build_and_test
     runs-on: ubuntu-latest
     steps:
       - 
         name: Check out the repo
         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
@@ -52,6 +62,7 @@ jobs:
         uses: docker/build-push-action@v2
         with:
           context: .
+          platforms: linux/amd64,linux/arm/v7,linux/arm64
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}

Dockerfile

@@ -1,8 +1,10 @@
-FROM node:16.6-alpine as build
+FROM node:16-bullseye as build
 
 WORKDIR /bonob
 
+COPY .git ./.git
 COPY src ./src
+COPY docs ./docs
 COPY typings ./typings
 COPY web ./web
 COPY tests ./tests
@@ -14,34 +16,53 @@ COPY yarn.lock .
 COPY .yarnrc.yml .
 COPY .yarn/releases ./.yarn/releases
 
-RUN apk add --no-cache --update --virtual .gyp \
+ENV JEST_TIMEOUT=30000
-        vips-dev \
+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 $BNB_PORT
-
-EXPOSE $BONOB_PORT
 
 WORKDIR /bonob
 
 COPY package.json .
 COPY yarn.lock .
-COPY --from=build /bonob/build/src/* ./
-COPY --from=build /bonob/node_modules ./node_modules
-COPY web web
-COPY src/Sonoswsdl-1.19.4-20190411.142401-3.wsdl /bonob/Sonoswsdl-1.19.4-20190411.142401-3.wsdl
 
-RUN apk add --no-cache --update vips
+COPY --from=build /bonob/build/src ./src
+COPY --from=build /bonob/node_modules ./node_modules
+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 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
 
-CMD ["node", "./app.js"]
+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
+- Integrates with Subsonic API clones (Navidrome, Gonic)
-- Browse by Artist, Albums, Genres, Playlist, Random Albums, Starred Albums, Recently Added Albums, Recently Played Albums, Most Played Albums
+- Browse by Artist, Albums, Random, Favourites, Top Rated, Playlist, Genres, Recently Added Albums, Recently Played Albums, Most Played Albums
-- Artist Art
+- Artist & Album Art
-- 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
+- Transcoding support for flacs using a specific player for the flac mimeType bonob/sonos
-- 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/)
 
 ## 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 BNB_SONOS_AUTO_REGISTER=true \
-    -e BONOB_SONOS_DEVICE_DISCOVERY=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 BNB_PORT=3000 \
-    -e BONOB_SONOS_SEED_HOST=192.168.1.123 \
+    -e BNB_SONOS_SEED_HOST=192.168.1.123 \
-    -e BONOB_SONOS_AUTO_REGISTER=true \
+    -e BNB_SONOS_AUTO_REGISTER=true \
-    -e BONOB_SONOS_DEVICE_DISCOVERY=true \
+    -e BNB_SONOS_DEVICE_DISCOVERY=true \
     -p 3000:3000 \
     simojenki/bonob
 ```
@@ -66,19 +64,21 @@ Start bonob outside the LAN with sonos discovery & registration disabled as they
 
 ```bash
 docker run \
-    -e BONOB_PORT=4534 \
+    -e BNB_PORT=4534 \
-    -e BONOB_SONOS_SERVICE_NAME=MyAwesomeMusic \
+    -e BNB_SONOS_SERVICE_NAME=MyAwesomeMusic \
-    -e BONOB_SECRET=changeme \
+    -e BNB_SECRET=changeme \
-    -e BONOB_URL=https://my-server.example.com/bonob \
+    -e BNB_URL=https://my-server.example.com/bonob \
-    -e BONOB_SONOS_AUTO_REGISTER=false \
+    -e BNB_SONOS_AUTO_REGISTER=false \
-    -e BONOB_SONOS_DEVICE_DISCOVERY=false \
+    -e BNB_SONOS_DEVICE_DISCOVERY=false \
-    -e BONOB_NAVIDROME_URL=https://my-navidrome-service.com:4533 \
+    -e BNB_SUBSONIC_URL=https://my-navidrome-service.com:4533 \
     -p 4534:4534 \
     simojenki/bonob
 ```
 
 Now within the LAN that contains the sonos devices run bonob the registration process.
 
+#### Using auto-discovery
+
 ```bash
 docker run \
     --rm \
@@ -86,6 +86,15 @@ docker run \
     simojenki/bonob register https://my-server.example.com/bonob
 ```
 
+#### Using a seed host
+
+```bash
+docker run \
+    --rm \
+    -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
@@ -113,56 +122,135 @@ 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  
+      BNB_URL: http://192.168.1.111:4534  
-      BONOB_SECRET: changeme
+      BNB_SECRET: changeme
-      BONOB_SONOS_AUTO_REGISTER: true
+      BNB_SONOS_AUTO_REGISTER: true
-      BONOB_SONOS_DEVICE_DISCOVERY: true
+      BNB_SONOS_DEVICE_DISCOVERY: true
-      BONOB_SONOS_SERVICE_ID: 246
+      BNB_SONOS_SERVICE_ID: 246
       # ip address of one of your sonos devices
-      BONOB_SONOS_SEED_HOST: 192.168.1.121
+      BNB_SONOS_SEED_HOST: 192.168.1.121
-      BONOB_NAVIDROME_URL: http://navidrome:4533
+      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
+BNB_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.**
+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.**
-BONOB_SECRET | bonob | secret used for encrypting credentials
+BNB_SECRET | bonob | secret used for encrypting credentials
-BONOB_SONOS_AUTO_REGISTER | false | Whether or not to try and auto-register on startup
+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
-BONOB_SONOS_DEVICE_DISCOVERY | true | whether or not sonos device discovery should be enabled
+BNB_SONOS_AUTO_REGISTER | false | Whether or not to try and auto-register on startup
-BONOB_SONOS_SEED_HOST | undefined | sonos device seed host for discovery, or ommitted for for auto-discovery
+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.
-BONOB_SONOS_SERVICE_NAME | bonob | service name for sonos
+BNB_SONOS_SEED_HOST | undefined | sonos device seed host for discovery, or ommitted for for auto-discovery
-BONOB_SONOS_SERVICE_ID | 246 | service id for sonos
+BNB_SONOS_SERVICE_NAME | bonob | service name for sonos
-BONOB_NAVIDROME_URL | http://$(hostname):4533 | URL for navidrome
+BNB_SONOS_SERVICE_ID | 246 | service id for sonos
-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.
+BNB_SUBSONIC_URL | http://$(hostname):4533 | URL for subsonic clone
-BONOB_SCROBBLE_TRACKS | true | Whether to scrobble the playing of a track if it has been played for >30s
+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.
-BONOB_REPORT_NOW_PLAYING | true | Whether to report a track as now playing
+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 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
+- You should now be able to play music on your sonos devices from you subsonic clone
-- Within navidrome a new player will be created, 'bonob (username)', so you can configure transcoding specifically for sonos
+- 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.
 
+## 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"
+```
+
+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) or [this](https://stackoverflow.com/questions/52119489/ffmpeg-limit-audio-sample-rate):
+
+```bash
+ffmpeg -i %s -af aformat=sample_fmts=s16|s32:sample_rates=8000|11025|16000|22050|24000|32000|44100|48000 -f flac -
+```
+
+**Note for Sonos S1:** [24-bit depth is only supported by Sonos S2](https://support.sonos.com/s/article/79?language=en_US), so if your system is still on Sonos S1, transcoding should convert all FLACs to 16-bit:
+
+```bash
+ffmpeg -i %s -af aformat=sample_fmts=s16:sample_rates=8000|11025|16000|22050|24000|32000|44100|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
+```
+
+![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/), and @jicho
+- 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  
+      BNB_URL: http://192.168.1.111:4534  
-      BONOB_SECRET: changeme
+      BNB_SECRET: changeme
-      BONOB_SONOS_SERVICE_ID: 246 
+      BNB_SONOS_SERVICE_ID: 246 
-      BONOB_SONOS_AUTO_REGISTER: "true"
+      BNB_SONOS_AUTO_REGISTER: true
-      BONOB_SONOS_DEVICE_DISCOVERY: "true"
+      BNB_SONOS_DEVICE_DISCOVERY: true
       # ip address of one of your sonos devices
-      BONOB_SONOS_SEED_HOST: 192.168.1.121
+      BNB_SONOS_SEED_HOST: 192.168.1.121
-      BONOB_NAVIDROME_URL: http://navidrome:4533
+      BNB_SUBSONIC_URL: http://navidrome:4533

jest.config.js

@@ -2,4 +2,8 @@ module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
   setupFilesAfterEnv: ["<rootDir>/tests/setup.js"],
+  modulePathIgnorePatterns: [
+    '<rootDir>/node_modules',
+    '<rootDir>/build',
+    ],
 };

package.json

@@ -6,53 +6,64 @@
   "author": "simojenki <simojenki@users.noreply.github.com>",
   "license": "GPL-3.0-only",
   "dependencies": {
-    "@svrooij/sonos": "^2.3.0",
+    "@svrooij/sonos": "^2.4.0",
-    "@types/express": "^4.17.11",
+    "@types/express": "^4.17.13",
-    "@types/morgan": "^1.9.2",
+    "@types/fs-extra": "^9.0.13",
-    "@types/node": "^14.14.22",
+    "@types/jsonwebtoken": "^8.5.5",
-    "@types/sharp": "^0.27.1",
+    "@types/jws": "^3.2.4",
-    "@types/underscore": "1.10.24",
+    "@types/morgan": "^1.9.3",
-    "@types/uuid": "^8.3.0",
+    "@types/node": "^16.7.13",
-    "axios": "^0.21.1",
+    "@types/randomstring": "^1.1.8",
-    "dayjs": "^1.10.4",
+    "@types/sharp": "^0.28.6",
-    "eta": "^1.12.1",
+    "@types/underscore": "^1.11.3",
+    "@types/uuid": "^8.3.1",
+    "axios": "^0.21.4",
+    "dayjs": "^1.10.6",
+    "eta": "^1.12.3",
     "express": "^4.17.1",
-    "fp-ts": "^2.9.5",
+    "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": "^2.1.0",
+    "node-html-parser": "^4.1.4",
-    "scale-that-svg": "^1.0.5",
+    "randomstring": "^1.2.1",
-    "sharp": "^0.27.2",
+    "sharp": "^0.29.1",
-    "soap": "^0.37.0",
+    "soap": "^0.42.0",
-    "ts-md5": "^1.2.7",
+    "ts-md5": "^1.2.9",
-    "typescript": "^4.1.3",
+    "typescript": "^4.4.2",
-    "underscore": "^1.12.1",
+    "underscore": "^1.13.1",
+    "urn-lib": "^2.0.0",
     "uuid": "^8.3.2",
-    "winston": "^3.3.3",
+    "winston": "^3.3.3"
-    "x2js": "^3.4.1"
   },
   "devDependencies": {
-    "@types/chai": "^4.2.14",
+    "@types/chai": "^4.2.21",
-    "@types/jest": "^26.0.20",
+    "@types/jest": "^27.0.1",
-    "@types/mocha": "^8.2.0",
+    "@types/mocha": "^9.0.0",
-    "@types/supertest": "^2.0.10",
+    "@types/supertest": "^2.0.11",
-    "chai": "^4.2.0",
+    "@types/tmp": "^0.2.1",
+    "chai": "^4.3.4",
     "get-port": "^5.1.1",
-    "image-js": "^0.32.0",
+    "image-js": "^0.33.0",
-    "jest": "^26.6.3",
+    "jest": "^27.1.0",
-    "nodemon": "^2.0.7",
+    "nodemon": "^2.0.12",
-    "supertest": "^6.1.3",
+    "supertest": "^6.1.6",
-    "ts-jest": "^26.4.4",
+    "tmp": "^0.2.1",
+    "ts-jest": "^27.0.5",
     "ts-mockito": "^2.6.1",
-    "ts-node": "^9.1.1",
+    "ts-node": "^10.2.1",
     "xmldom-ts": "^0.3.1",
     "xpath-ts": "^1.3.13"
   },
   "scripts": {
-    "clean": "rm -Rf build",
+    "clean": "rm -Rf build node_modules",
     "build": "tsc",
-    "dev": "BONOB_SONOS_SERVICE_NAME=bonobDev BONOB_SONOS_DEVICE_DISCOVERY=true nodemon ./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=z_bonobDev BNB_SONOS_DEVICE_DISCOVERY=true nodemon -V ./src/app.ts",
-    "devr": "BONOB_SONOS_SERVICE_NAME=bonobDev BONOB_SONOS_DEVICE_DISCOVERY=true BONOB_SONOS_AUTO_REGISTER=true nodemon ./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=z_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 --testPathIgnorePatterns=build"
+    "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

@@ -1,17 +1,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 {
-import { InMemoryAccessTokens, sha256 } from "./access_tokens";
+  appendMimeTypeToClientFor,
+  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";
+import { axiosImageFetcher, cachingImageFetcher } from "./images";
 
 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,
@@ -20,22 +29,28 @@ const bonob = bonobService(
   "AppLink"
 );
 
-const sonosSystem = sonos(config.sonos.deviceDiscovery, config.sonos.seedHost);
+const sonosSystem = sonos(config.sonos.discovery);
 
-const streamUserAgent = config.navidrome.customClientsFor
+// todo: just pass in the customClientsForStringArray into subsonic and make it sort it out.
-  ? appendMimeTypeToClientFor(config.navidrome.customClientsFor.split(","))
+const streamUserAgent = config.subsonic.customClientsFor
+  ? appendMimeTypeToClientFor(config.subsonic.customClientsFor.split(","))
   : DEFAULT;
 
-const navidrome = new Navidrome(
+const artistImageFetcher = config.subsonic.artistImageCache
-  config.navidrome.url,
+  ? cachingImageFetcher(config.subsonic.artistImageCache, axiosImageFetcher)
-  encryption(config.secret),
+  : axiosImageFetcher;
-  streamUserAgent
+
+const subsonic = new Subsonic(
+  config.subsonic.url,
+  streamUserAgent,
+  artistImageFetcher
 );
 
 const featureFlagAwareMusicService: MusicService = {
-  generateToken: navidrome.generateToken,
+  generateToken: subsonic.generateToken,
-  login: (authToken: string) =>
+  refreshToken: subsonic.refreshToken,
-    navidrome.login(authToken).then((library) => {
+  login: (serviceToken: string) =>
+    subsonic.login(serviceToken).then((library) => {
       return {
         ...library,
         scrobble: (id: string) => {
@@ -56,15 +71,28 @@ 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 app = server(
   sonosSystem,
   bonob,
   config.bonobUrl,
   featureFlagAwareMusicService,
-  new InMemoryLinkCodes(),
+  {
-  new InMemoryAccessTokens(sha256(config.secret)),
+    linkCodes: () => new InMemoryLinkCodes(),
-  SystemClock,
+    apiTokens: () => new InMemoryAPITokens(sha256(config.secret)),
-  true,
+    clock,
+    iconColors: config.icons,
+    applyContextPath: true,
+    logRequests: true,
+    version,
+    smapiAuthTokens: new JWTSmapiLoginTokens(clock, config.secret, config.authTimeout),
+    externalImageResolver: artistImageFetcher
+  }
 );
 
 app.listen(config.port, () => {
@@ -79,12 +107,12 @@ if (config.sonos.autoRegister) {
       );
     }
   });
-} else if(config.sonos.deviceDiscovery) {
+} else if (config.sonos.discovery.enabled) {
-  sonosSystem.devices().then(devices => {
+  sonosSystem.devices().then((devices) => {
-    devices.forEach(d => {
+    devices.forEach((d) => {
-      logger.info(`Found device ${d.name}(${d.group}) @ ${d.ip}:${d.port}`)
+      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

@@ -1,7 +1,54 @@
 import dayjs, { Dayjs } from "dayjs";
 
+function fixedDateMonthEvent(dateMonth: string) {
+  const date = Number.parseInt(dateMonth.split("/")[0]!);
+  const month = Number.parseInt(dateMonth.split("/")[1]!);
+  return (clock: Clock = SystemClock) => {
+    return clock.now().date() == date && clock.now().month() == month - 1;
+  };
+}
+
+function fixedDateEvent(date: string) {
+  const dayjsDate = dayjs(date);
+  return (clock: Clock = SystemClock) => {
+    return clock.now().isSame(dayjsDate, "day");
+  };
+}
+
+function anyOf(rules: ((clock: Clock) => boolean)[]) {
+  return (clock: Clock = SystemClock) => {
+    return rules.find((rule) => rule(clock)) != undefined;
+  };
+}
+
+export const isChristmas = fixedDateMonthEvent("25/12");
+export const isMay4 = fixedDateMonthEvent("04/05");
+export const isHalloween = fixedDateMonthEvent("31/10");
+export const isHoli = anyOf(
+  ["2022/03/18", "2023/03/07", "2024/03/25", "2025/03/14"].map(fixedDateEvent)
+)
+
+export const isCNY_2022 = fixedDateEvent("2022/02/01");
+export const isCNY_2023 = fixedDateEvent("2023/01/22");
+export const isCNY_2024 = fixedDateEvent("2024/02/10");
+export const isCNY_2025 = fixedDateEvent("2025/02/29");
+export const isCNY = anyOf([isCNY_2022, isCNY_2023, isCNY_2024, isCNY_2025]);
+
 export interface Clock {
   now(): Dayjs;
 }
 
 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,16 +2,72 @@ import { hostname } from "os";
 import logger from "./logger";
 import url from "./url_builder";
 
+export const WORD = /^\w+$/;
+export const COLOR = /^#?\w+$/;
+
+type EnvVarOpts<T> = {
+  default: T | undefined;
+  legacy: string[] | undefined;
+  validationPattern: RegExp | undefined;
+  parser: ((value: string) => T) | undefined
+};
+
+export function envVar<T>(
+  name: string,
+  opts: Partial<EnvVarOpts<T>> = {
+    default: undefined,
+    legacy: undefined,
+    validationPattern: undefined,
+    parser: undefined
+  }
+): T {
+  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}'`)
+  }
+
+  let value: T | undefined = undefined;
+
+  if(result?.value && opts.parser) {
+    value = opts.parser(result?.value)
+  } else if(result?.value)
+    value = result?.value as any as T
+
+  return value == undefined ? opts.default as T : value;
+}
+
+export const bnbEnvVar = <T>(key: string, opts: Partial<EnvVarOpts<T>> = {}) =>
+  envVar(`BNB_${key}`, {
+    ...opts,
+    legacy: [`BONOB_${key}`, ...(opts.legacy || [])],
+  });
+
+const asBoolean = (value: string) => value == "true";
+
+const asInt = (value: string) => Number.parseInt(value);
+
 export default function () {
-  const port = +(process.env["BONOB_PORT"] || 4534);
+  const port = bnbEnvVar<number>("PORT", { default: 4534, parser: asInt })!;
-  const bonobUrl =
+  const bonobUrl = bnbEnvVar("URL", {
-    process.env["BONOB_URL"] ||
+    legacy: ["BONOB_WEB_ADDRESS"],
-    process.env["BONOB_WEB_ADDRESS"] ||
+    default: `http://${hostname()}:${port}`,
-    `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);
   }
@@ -19,23 +75,34 @@ export default function () {
   return {
     port,
     bonobUrl: url(bonobUrl),
-    secret: process.env["BONOB_SECRET"] || "bonob",
+    secret: bnbEnvVar<string>("SECRET", { default: "bonob" })!,
+    authTimeout: bnbEnvVar<string>("AUTH_TIMEOUT", { default: "1h" })!,
+    icons: {
+      foregroundColor: bnbEnvVar<string>("ICON_FOREGROUND_COLOR", {
+        validationPattern: COLOR,
+      }),
+      backgroundColor: bnbEnvVar<string>("ICON_BACKGROUND_COLOR", {
+        validationPattern: COLOR,
+      }),
+    },
     sonos: {
-      serviceName: process.env["BONOB_SONOS_SERVICE_NAME"] || "bonob",
+      serviceName: bnbEnvVar<string>("SONOS_SERVICE_NAME", { default: "bonob" })!,
-      deviceDiscovery:
+      discovery: {
-        (process.env["BONOB_SONOS_DEVICE_DISCOVERY"] || "true") == "true",
+        enabled:
-      seedHost: process.env["BONOB_SONOS_SEED_HOST"],
+          bnbEnvVar<boolean>("SONOS_DEVICE_DISCOVERY", { default: true, parser: asBoolean }),
+        seedHost: bnbEnvVar<string>("SONOS_SEED_HOST"),
+      },
       autoRegister:
-        (process.env["BONOB_SONOS_AUTO_REGISTER"] || "false") == "true",
+        bnbEnvVar<boolean>("SONOS_AUTO_REGISTER", { default: false, parser: asBoolean }),
-      sid: Number(process.env["BONOB_SONOS_SERVICE_ID"] || "246"),
+      sid: bnbEnvVar<number>("SONOS_SERVICE_ID", { default: 246, parser: asInt }),
     },
-    navidrome: {
+    subsonic: {
-      url: process.env["BONOB_NAVIDROME_URL"] || `http://${hostname()}:4533`,
+      url: bnbEnvVar("SUBSONIC_URL", { legacy: ["BONOB_NAVIDROME_URL"], default: `http://${hostname()}:4533` })!,
-      customClientsFor:
+      customClientsFor: bnbEnvVar<string>("SUBSONIC_CUSTOM_CLIENTS", { legacy: ["BONOB_NAVIDROME_CUSTOM_CLIENTS"] }),
-        process.env["BONOB_NAVIDROME_CUSTOM_CLIENTS"] || undefined,
+      artistImageCache: bnbEnvVar<string>("SUBSONIC_ARTIST_IMAGE_CACHE"),
     },
-    scrobbleTracks: (process.env["BONOB_SCROBBLE_TRACKS"] || "true") == "true",
+    scrobbleTracks: bnbEnvVar<boolean>("SCROBBLE_TRACKS", { default: true, parser: asBoolean }),
     reportNowPlaying:
-      (process.env["BONOB_REPORT_NOW_PLAYING"] || "true") == "true",
+      bnbEnvVar<boolean>("REPORT_NOW_PLAYING", { default: true, parser: asBoolean }),
   };
 }

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,
+  iv: string;
-  encryptedData: string
+  encryptedData: string;
-}
+};
 
 export type Encryption = {
-  encrypt: (value:string) => Hash
+  encrypt: (value: string) => string;
-  decrypt: (hash: Hash) => string
+  decrypt: (value: string) => string;
+};
+
+export const jwsEncryption = (secret: string): Encryption => {
+  return {
+    encrypt: (value: string) => jws.sign({
+      header: { alg: 'HS256' },
+      payload: value,
+      secret: secret,
+    }),
+    decrypt: (value: string) => jws.decode(value).payload
+  }
 }
 
-const encryption = (secret: string): Encryption => {
+export const cryptoEncryption = (secret: string): Encryption => {
-  const key = createHash('sha256').update(String(secret)).digest('base64').substr(0, 32);
+  const key = createHash("sha256")
+    .update(String(secret))
+    .digest("base64")
+    .substr(0, 32);
   return {
     encrypt: (value: string) => {
       const cipher = createCipheriv(ALGORITHM, key, IV);
-      return { 
+      return `${IV.toString("hex")}.${Buffer.concat([
-        iv: IV.toString("hex"), 
+        cipher.update(value),
-        encryptedData: Buffer.concat([cipher.update(value), cipher.final()]).toString("hex") 
+        cipher.final(),
-      };
+      ]).toString("hex")}`;
     },
-    decrypt: (hash: Hash) => {
+    decrypt: (value: string) => {
-      const decipher = createDecipheriv(ALGORITHM, key, Buffer.from(hash.iv, 'hex'));
+      const parts = value.split(".");
-      return Buffer.concat([decipher.update(Buffer.from(hash.encryptedData, 'hex')), decipher.final()]).toString();
+      if(parts.length != 2) throw `Invalid value to decrypt`;
-    }
-  }
-}
 
-export default encryption;
+      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/http.ts

@@ -0,0 +1,67 @@
+import {
+  AxiosPromise,
+  AxiosRequestConfig,
+  Method,
+  ResponseType,
+} from "axios";
+
+// todo: do i need this anymore?
+export interface Http {
+  (config: AxiosRequestConfig): AxiosPromise<any>;
+}
+export interface Http2 extends Http {
+  with: (params: Partial<RequestParams>) => Http2;
+}
+
+export type RequestParams = {
+  baseURL: string;
+  url: string;
+  params: any;
+  headers: any;
+  responseType: ResponseType;
+  method: Method;
+};
+
+const wrap = (http2: Http2, params: Partial<RequestParams>): Http2 => {
+  const f = ((config: AxiosRequestConfig) => http2(merge(params, config))) as Http2;
+  f.with = (params: Partial<RequestParams>) => wrap(f, params);
+  return f;
+};
+
+export const http2From = (http: Http): Http2 => {
+  const f = ((config: AxiosRequestConfig) => http(config)) as Http2;
+  f.with = (defaults: Partial<RequestParams>) => wrap(f, defaults);
+  return f;
+}
+
+const merge = (
+  defaults: Partial<RequestParams>,
+  config: AxiosRequestConfig
+) => {
+  let toApply = {
+    ...defaults,
+    ...config,
+  };
+  if (defaults.params) {
+    toApply = {
+      ...toApply,
+      params: {
+        ...defaults.params,
+        ...config.params,
+      },
+    };
+  }
+  if (defaults.headers) {
+    toApply = {
+      ...toApply,
+      headers: {
+        ...defaults.headers,
+        ...config.headers,
+      },
+    };
+  }
+  return toApply;
+};
+
+export const http =
+  (base: Http, defaults: Partial<RequestParams>): Http => (config: AxiosRequestConfig) => base(merge(defaults, config));

src/i8n.ts

@@ -3,7 +3,8 @@ import { pipe } from "fp-ts/lib/function";
 import { option as O } from "fp-ts";
 import _ from "underscore";
 
-export type LANG = "en-US" | "nl-NL";
+export type LANG = "en-US" | "da-DK" | "de-DE" | "es-ES" | "fr-FR" | "it-IT" | "ja-JP" | "nb-NO" | "nl-NL" | "pt-BR" | "sv-SE" | "zh-CN"
+export type SUPPORTED_LANG = "en-US" | "nl-NL";
 export type KEY =
   | "AppLinkMessage"
   | "artists"
@@ -11,7 +12,7 @@ export type KEY =
   | "playlists"
   | "genres"
   | "random"
-  | "starred"
+  | "topRated"
   | "recentlyAdded"
   | "recentlyPlayed"
   | "mostPlayed"
@@ -35,18 +36,26 @@ export type KEY =
   | "failedToRemoveRegistration"
   | "invalidLinkCode"
   | "loginSuccessful"
-  | "loginFailed";
+  | "loginFailed" 
+  | "noSonosDevices" 
+  | "favourites"
+  | "LOVE"
+  | "LOVE_SUCCESS"
+  | "STAR" 
+  | "UNSTAR"
+  | "STAR_SUCCESS"
+  | "UNSTAR_SUCCESS";
 
-const translations: Record<LANG, Record<KEY, string>> = {
+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",
@@ -60,7 +69,7 @@ const translations: Record<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",
@@ -70,16 +79,24 @@ const translations: Record<LANG, Record<KEY, string>> = {
     invalidLinkCode: "Invalid linkCode!",
     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",
@@ -93,7 +110,7 @@ const translations: Record<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",
@@ -103,19 +120,27 @@ const translations: Record<LANG, Record<KEY, string>> = {
     invalidLinkCode: "Ongeldige linkcode!",
     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"
   },
 };
 
 const translationsLookup = Object.keys(translations).reduce((lookups, lang) => {
-  lookups.set(lang, translations[lang as LANG]);
+  lookups.set(lang, translations[lang as SUPPORTED_LANG]);
-  lookups.set(lang.toLocaleLowerCase(), translations[lang as LANG]);
+  lookups.set(lang.toLocaleLowerCase(), translations[lang as SUPPORTED_LANG]);
-  lookups.set(lang.toLocaleLowerCase().split("-")[0]!, translations[lang as LANG]);
+  lookups.set(lang.toLocaleLowerCase().split("-")[0]!, translations[lang as SUPPORTED_LANG]);
   return lookups;
 }, new Map<string, Record<KEY, string>>())
 
 export const randomLang = () => _.shuffle(["en-US", "nl-NL"])[0]!;
 
-export const asLANGs = (acceptLanguageHeader: string | undefined) =>
+export const asLANGs = (acceptLanguageHeader: string | undefined): LANG[] =>
   pipe(
     acceptLanguageHeader,
     O.fromNullable,
@@ -125,7 +150,8 @@ export const asLANGs = (acceptLanguageHeader: string | undefined) =>
       pipe(
         it.split(","),
         A.map((it) => it.trim()),
-        A.filter((it) => it != "")
+        A.filter((it) => it != ""),
+        A.map(it => it as LANG)
       )
     ),
     O.getOrElseW(() => [])
@@ -137,16 +163,16 @@ export type Lang = (key: KEY) => string;
 
 export const langs = () => Object.keys(translations);
 
-export const keys = (lang: LANG = "en-US") => Object.keys(translations[lang]);
+export const keys = (lang: SUPPORTED_LANG = "en-US") => Object.keys(translations[lang]);
 
 export default (serviceName: string): I8N =>
   (...langs: string[]): Lang => {
     const langToUse =
-      langs.map((l) => translationsLookup.get(l as LANG)).find((it) => it) ||
+      langs.map((l) => translationsLookup.get(l as SUPPORTED_LANG)).find((it) => it) ||
       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

@@ -0,0 +1,476 @@
+import libxmljs, { Element, Attribute } from "libxmljs2";
+import _ from "underscore";
+import fs from "fs";
+
+import {
+  Clock,
+  isChristmas,
+  isCNY_2022,
+  isCNY_2023,
+  isCNY_2024,
+  isHalloween,
+  isHoli,
+  isMay4,
+  SystemClock,
+} from "./clock";
+import path from "path";
+
+const SVG_NS = {
+  svg: "http://www.w3.org/2000/svg",
+};
+
+class ViewBox {
+  minX: number;
+  minY: number;
+  width: number;
+  height: number;
+
+  constructor(viewBox: string) {
+    const parts = viewBox.split(" ").map((it) => Number.parseInt(it));
+    this.minX = parts[0]!;
+    this.minY = parts[1]!;
+    this.width = parts[2]!;
+    this.height = parts[3]!;
+  }
+
+  public increasePercent = (percent: number) => {
+    const i = Math.floor(((percent / 100) * this.height) / 3);
+    return new ViewBox(
+      `${-i} ${-i} ${this.height + 2 * i} ${this.height + 2 * i}`
+    );
+  };
+
+  public toString = () =>
+    `${this.minX} ${this.minY} ${this.width} ${this.height}`;
+}
+
+export type IconFeatures = {
+  viewPortIncreasePercent: number | undefined;
+  backgroundColor: string | undefined;
+  foregroundColor: string | undefined;
+};
+
+export type IconSpec = {
+  svg: string | undefined;
+  features: Partial<IconFeatures> | undefined;
+};
+
+export interface Icon {
+  with(spec: Partial<IconSpec>): Icon;
+  apply(transformer: Transformer): Icon;
+}
+
+export type Transformer = (icon: Icon) => Icon;
+
+export function transform(spec: Partial<IconSpec>): Transformer {
+  return (icon: Icon) =>
+    icon.with({
+      ...spec,
+      features: { ...spec.features },
+    });
+}
+
+export function features(features: Partial<IconFeatures>): Transformer {
+  return (icon: Icon) => icon.with({ features });
+}
+
+export function maybeTransform(rule: () => Boolean, transformer: Transformer) {
+  return (icon: Icon) => (rule() ? transformer(icon) : icon);
+}
+
+export function allOf(...transformers: Transformer[]): Transformer {
+  return (icon: Icon): Icon =>
+    _.inject(
+      transformers,
+      (current: Icon, transformer: Transformer) => transformer(current),
+      icon
+    );
+}
+
+export class SvgIcon implements Icon {
+  svg: string;
+  features: IconFeatures;
+
+  constructor(
+    svg: string,
+    features: Partial<IconFeatures> = {
+      viewPortIncreasePercent: undefined,
+      backgroundColor: undefined,
+      foregroundColor: undefined,
+    }
+  ) {
+    this.svg = svg;
+    this.features = {
+      viewPortIncreasePercent: undefined,
+      backgroundColor: undefined,
+      foregroundColor: undefined,
+      ...features,
+    };
+  }
+
+  public apply = (transformer: Transformer): Icon => transformer(this);
+
+  public with = (spec: Partial<IconSpec>) =>
+    new SvgIcon(spec.svg || this.svg, {
+      ...this.features,
+      ...spec.features,
+    });
+
+  public toString = () => {
+    const xml = libxmljs.parseXmlString(this.svg, {
+      noblanks: true,
+      net: false,
+    });
+    const viewBoxAttr = xml.get("//svg:svg/@viewBox", SVG_NS) as Attribute;
+    let viewBox = new ViewBox(viewBoxAttr.value());
+    if (
+      this.features.viewPortIncreasePercent &&
+      this.features.viewPortIncreasePercent > 0
+    ) {
+      viewBox = viewBox.increasePercent(this.features.viewPortIncreasePercent);
+      viewBoxAttr.value(viewBox.toString());
+    }
+    if (this.features.backgroundColor) {
+      (xml.get("//svg:svg/*[1]", SVG_NS) as Element).addPrevSibling(
+        new Element(xml, "rect").attr({
+          x: `${viewBox.minX}`,
+          y: `${viewBox.minY}`,
+          width: `${Math.abs(viewBox.minX) + viewBox.width}`,
+          height: `${Math.abs(viewBox.minY) + viewBox.height}`,
+          fill: this.features.backgroundColor,
+        })
+      );
+    }
+    if (this.features.foregroundColor) {
+      (xml.find("//svg:path", SVG_NS) as Element[]).forEach((path) => {
+        if (path.attr("fill"))
+          path.attr({ stroke: this.features.foregroundColor! });
+        else path.attr({ fill: this.features.foregroundColor! });
+      });
+    }
+    return xml.toString();
+  };
+}
+
+export const HOLI_COLORS = [
+  "#06bceb",
+  "#9fc717",
+  "#fbdc10",
+  "#f00b9a",
+  "#fa9705",
+];
+
+export type ICON =
+  | "artists"
+  | "albums"
+  | "playlists"
+  | "genres"
+  | "random"
+  | "topRated"
+  | "recentlyAdded"
+  | "recentlyPlayed"
+  | "mostPlayed"
+  | "discover"
+  | "blank"
+  | "mushroom"
+  | "african"
+  | "rock"
+  | "metal"
+  | "punk"
+  | "americana"
+  | "guitar"
+  | "book"
+  | "oz"
+  | "rap"
+  | "horror"
+  | "hipHop"
+  | "pop"
+  | "blues"
+  | "classical"
+  | "comedy"
+  | "vinyl"
+  | "electronic"
+  | "pills"
+  | "trumpet"
+  | "conductor"
+  | "reggae"
+  | "music"
+  | "error"
+  | "chill"
+  | "country"
+  | "dance"
+  | "disco"
+  | "film"
+  | "new"
+  | "old"
+  | "cannabis"
+  | "trip"
+  | "opera"
+  | "world"
+  | "violin"
+  | "celtic"
+  | "children"
+  | "chillout"
+  | "progressiveRock"
+  | "christmas"
+  | "halloween"
+  | "yoDragon"
+  | "yoRabbit"
+  | "yoTiger"
+  | "chapel"
+  | "audioWave"
+  | "c3po"
+  | "chewy"
+  | "darth"
+  | "skywalker"
+  | "leia"
+  | "r2d2"
+  | "yoda" 
+  | "heart"
+  | "star" 
+  | "solidStar";
+
+const iconFrom = (name: string) =>
+  new SvgIcon(
+    fs
+      .readFileSync(path.resolve(__dirname, "..", "web", "icons", name))
+      .toString()
+  );
+
+export const ICONS: Record<ICON, SvgIcon> = {
+  artists: iconFrom("navidrome-artists.svg"),
+  albums: iconFrom("navidrome-all.svg"),
+  blank: iconFrom("blank.svg"),
+  playlists: iconFrom("navidrome-playlists.svg"),
+  genres: iconFrom("Theatre-Mask-111172.svg"),
+  random: iconFrom("navidrome-random.svg"),
+  topRated: iconFrom("navidrome-topRated.svg"),
+  recentlyAdded: iconFrom("navidrome-recentlyAdded.svg"),
+  recentlyPlayed: iconFrom("navidrome-recentlyPlayed.svg"),
+  mostPlayed: iconFrom("navidrome-mostPlayed.svg"),
+  discover: iconFrom("Opera-Glasses-102740.svg"),
+  mushroom: iconFrom("Mushroom-63864.svg"),
+  african: iconFrom("Africa-48087.svg"),
+  rock: iconFrom("Rock-Music-11076.svg"),
+  progressiveRock: iconFrom("Progressive-Rock-24862.svg"),
+  metal: iconFrom("Metal-Music-17763.svg"),
+  punk: iconFrom("Punk-40450.svg"),
+  americana: iconFrom("US-Capitol-104805.svg"),
+  guitar: iconFrom("Guitar-110433.svg"),
+  book: iconFrom("Book-22940.svg"),
+  oz: iconFrom("Kangaroo-16730.svg"),
+  hipHop: iconFrom("Hip-Hop Music-17757.svg"),
+  rap: iconFrom("Rap-24851.svg"),
+  horror: iconFrom("Horror-88855.svg"),
+  pop: iconFrom("Ice-Pop Yellow-94532.svg"),
+  blues: iconFrom("Blues-113548.svg"),
+  classical: iconFrom("Classic-Music-17728.svg"),
+  comedy: iconFrom("Comedy-5937.svg"),
+  vinyl: iconFrom("Music-Record-102104.svg"),
+  electronic: iconFrom("Electronic-Music-17745.svg"),
+  pills: iconFrom("Pills-92954.svg"),
+  trumpet: iconFrom("Trumpet-17823.svg"),
+  conductor: iconFrom("Music-Conductor-225.svg"),
+  reggae: iconFrom("Reggae-24843.svg"),
+  music: iconFrom("Music-14097.svg"),
+  error: iconFrom("Error-82783.svg"),
+  chill: iconFrom("Fridge-282.svg"),
+  country: iconFrom("Country-Music-113286.svg"),
+  dance: iconFrom("Tango-25015.svg"),
+  disco: iconFrom("Disco-Ball-25777.svg"),
+  film: iconFrom("Film-Reel-3230.svg"),
+  new: iconFrom("New-47652.svg"),
+  old: iconFrom("Old-Woman-77881.svg"),
+  cannabis: iconFrom("Cannabis-33270.svg"),
+  trip: iconFrom("TripAdvisor-44407.svg"),
+  opera: iconFrom("Sydney-Opera House-59090.svg"),
+  world: iconFrom("Globe-1301.svg"),
+  violin: iconFrom("Violin-3421.svg"),
+  celtic: iconFrom("Scottish-Thistle-108212.svg"),
+  children: iconFrom("Children-78186.svg"),
+  chillout: iconFrom("Sleeping-in Bed-14385.svg"),
+  christmas: iconFrom("Christmas-Tree-63332.svg"),
+  halloween: iconFrom("Jack-o' Lantern-66580.svg"),
+  yoDragon: iconFrom("Year-of Dragon-4537.svg"),
+  yoRabbit: iconFrom("Year-of Rabbit-6313.svg"),
+  yoTiger: iconFrom("Year-of Tiger-22776.svg"),
+  chapel: iconFrom("Chapel-69791.svg"),
+  audioWave: iconFrom("Audio-Wave-1892.svg"),
+  c3po: iconFrom("C-3PO-31823.svg"),
+  chewy: iconFrom("Chewbacca-89771.svg"),
+  darth: iconFrom("Darth-Vader-35734.svg"),
+  skywalker: iconFrom("Luke-Skywalker-39424.svg"),
+  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];
+
+export type RULE = (genre: string) => boolean;
+
+export const eq =
+  (expected: string): RULE =>
+  (value: string) =>
+    expected.toLowerCase() === value.toLowerCase();
+
+export const contains =
+  (expected: string): RULE =>
+  (value: string) =>
+    value.toLowerCase().includes(expected.toLowerCase());
+
+export const containsWord =
+  (expected: string): RULE =>
+  (value: string) =>
+    value.toLowerCase().split(/\W/).includes(expected.toLowerCase());
+
+const containsWithAllTheNonWordCharsRemoved =
+  (expected: string): RULE =>
+  (value: string) =>
+    value.replace(/\W+/, " ").toLowerCase().includes(expected.toLowerCase());
+
+const GENRE_RULES: [RULE, ICON][] = [
+  [eq("Acid House"), "mushroom"],
+  [eq("African"), "african"],
+  [eq("Americana"), "americana"],
+  [eq("Film Score"), "film"],
+  [eq("Soundtrack"), "film"],
+  [eq("Stoner Rock"), "cannabis"],
+  [eq("Turntablism"), "vinyl"],
+  [eq("Celtic"), "celtic"],
+  [eq("Progressive Rock"), "progressiveRock"],
+  [containsWord("Christmas"), "christmas"],
+  [containsWord("Kerst"), "christmas"], // christmas in dutch
+  [containsWord("Country"), "country"],
+  [containsWord("Rock"), "rock"],
+  [containsWord("Folk"), "guitar"],
+  [containsWord("Book"), "book"],
+  [containsWord("Australian"), "oz"],
+  [containsWord("Baroque"), "violin"],
+  [containsWord("Rap"), "rap"],
+  [containsWithAllTheNonWordCharsRemoved("Hip Hop"), "hipHop"],
+  [containsWithAllTheNonWordCharsRemoved("Trip Hop"), "trip"],
+  [containsWord("Metal"), "metal"],
+  [containsWord("Punk"), "punk"],
+  [containsWord("Blues"), "blues"],
+  [eq("Classic"), "classical"],
+  [containsWord("Classical"), "classical"],
+  [containsWord("Comedy"), "comedy"],
+  [containsWord("Komedie"), "comedy"], // dutch for Comedy
+  [containsWord("Turntable"), "vinyl"],
+  [containsWord("Dub"), "electronic"],
+  [eq("Dubstep"), "electronic"],
+  [eq("Drum And Bass"), "electronic"],
+  [contains("Goa"), "mushroom"],
+  [contains("Psy"), "mushroom"],
+  [containsWord("Trance"), "pills"],
+  [containsWord("Techno"), "pills"],
+  [containsWord("House"), "pills"],
+  [containsWord("Rave"), "pills"],
+  [containsWord("Jazz"), "trumpet"],
+  [containsWord("Orchestra"), "conductor"],
+  [containsWord("Reggae"), "reggae"],
+  [containsWord("Disco"), "disco"],
+  [containsWord("New"), "new"],
+  [containsWord("Opera"), "opera"],
+  [containsWord("Vocal"), "opera"],
+  [containsWord("Ballad"), "opera"],
+  [containsWord("Western"), "country"],
+  [containsWord("World"), "world"],
+  [contains("Electro"), "electronic"],
+  [contains("Dance"), "dance"],
+  [contains("Pop"), "pop"],
+  [contains("Horror"), "horror"],
+  [contains("Children"), "children"],
+  [contains("Chill"), "chill"],
+  [contains("Old"), "old"],
+  [containsWord("Christian"), "chapel"],
+  [containsWord("Religious"), "chapel"],
+  [containsWord("Spoken"), "audioWave"],
+];
+
+export function iconForGenre(genre: string): ICON {
+  const [_, name] = GENRE_RULES.find(([rule, _]) => rule(genre)) || [
+    "music",
+    "music",
+  ];
+  return name! as ICON;
+}
+
+export const festivals = (clock: Clock = SystemClock): Transformer => {
+  const randomHoliColors = _.shuffle([...HOLI_COLORS]);
+  return allOf(
+    maybeTransform(
+      () => isChristmas(clock),
+      transform({
+        svg: ICONS.christmas.svg,
+        features: {
+          backgroundColor: "green",
+          foregroundColor: "red",
+        },
+      })
+    ),
+    maybeTransform(
+      () => isHoli(clock),
+      transform({
+        features: {
+          backgroundColor: randomHoliColors.pop(),
+          foregroundColor: randomHoliColors.pop(),
+        },
+      })
+    ),
+    maybeTransform(
+      () => isCNY_2022(clock),
+      transform({
+        svg: ICONS.yoTiger.svg,
+        features: {
+          backgroundColor: "red",
+          foregroundColor: "yellow",
+        },
+      })
+    ),
+    maybeTransform(
+      () => isCNY_2023(clock),
+      transform({
+        svg: ICONS.yoRabbit.svg,
+        features: {
+          backgroundColor: "red",
+          foregroundColor: "yellow",
+        },
+      })
+    ),
+    maybeTransform(
+      () => isCNY_2024(clock),
+      transform({
+        svg: ICONS.yoDragon.svg,
+        features: {
+          backgroundColor: "red",
+          foregroundColor: "yellow",
+        },
+      })
+    ),
+    maybeTransform(
+      () => isHalloween(clock),
+      transform({
+        svg: ICONS.halloween.svg,
+        features: {
+          backgroundColor: "black",
+          foregroundColor: "orange",
+        },
+      })
+    ),
+    maybeTransform(
+      () => isMay4(clock),
+      transform({
+        svg: STAR_WARS[_.random(STAR_WARS.length - 1)]!.svg,
+        features: {
+          backgroundColor: undefined,
+          foregroundColor: undefined,
+        },
+      })
+    )
+  );
+};

src/images.ts

@@ -0,0 +1,48 @@
+
+import sharp from "sharp";
+import fse from "fs-extra";
+import path from "path";
+import { Md5 } from "ts-md5/dist/md5";
+import axios from "axios";
+
+import { CoverArt } from "./music_service";
+import { BROWSER_HEADERS } from "./utils";
+
+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);

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,35 @@
+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 = {
+export class AuthFailure extends Error {
-  message: string;
+  constructor(message: string) {
+    super(message);
+  }
 };
 
-export type ArtistSummary = {
+export type IdName = {
   id: string;
   name: string;
 };
 
-export type Images = {
+export type ArtistSummary = {
-  small: string | undefined;
+  // todo: why can this be undefined?
-  medium: string | undefined;
+  id: string | undefined;
-  large: string | undefined;
+  name: string;
-};
+  image: BUrn | undefined;
-
-export const NO_IMAGES: Images = {
-  small: undefined,
-  medium: undefined,
-  large: undefined,
 };
 
 export type SimilarArtist = ArtistSummary & { inLibrary: boolean };
 
 export type Artist = ArtistSummary & {
-  image: Images
   albums: AlbumSummary[];
   similarArtists: SimilarArtist[]
 };
@@ -52,9 +39,10 @@ export type AlbumSummary = {
   name: string;
   year: string | undefined;
   genre: Genre | undefined;
+  coverArt: BUrn | undefined;
 
-  artistName: string;
+  artistName: string | undefined;
-  artistId: string;
+  artistId: string | undefined;
 };
 
 export type Album = AlbumSummary & {};
@@ -64,6 +52,11 @@ export type Genre = {
   id: string;
 }
 
+export type Rating = {
+  love: boolean;
+  stars: number;
+}
+
 export type Track = {
   id: string;
   name: string;
@@ -71,13 +64,15 @@ export type Track = {
   duration: number;
   number: number | undefined;
   genre: Genre | undefined;
+  coverArt: BUrn | undefined;
   album: AlbumSummary;
   artist: ArtistSummary;
+  rating: Rating;
 };
 
 export type Paging = {
-  _index: number;
+  _index: number | undefined;
-  _count: number;
+  _count: number | undefined;
 };
 
 export type Result<T> = {
@@ -85,9 +80,10 @@ export type Result<T> = {
   total: number;
 };
 
-export function slice2<T>({ _index, _count }: Paging) {
+export function slice2<T>({ _index, _count }: Partial<Paging> = {}) {
+  const i = _index || 0;
   return (things: T[]): [T[], number] => [
-    things.slice(_index, _index + _count),
+    _count ? things.slice(i, i + _count) : things.slice(i),
     things.length,
   ];
 }
@@ -99,7 +95,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 +105,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,8 +115,14 @@ export const albumToAlbumSummary = (it: Album): AlbumSummary => ({
   genre: it.genre,
   artistName: it.artistName,
   artistId: it.artistId,
+  coverArt: it.coverArt
 });
 
+export const playlistToPlaylistSummary = (it: Playlist): PlaylistSummary => ({
+  id: it.id,
+  name: it.name
+})
+
 export type StreamingHeader = "content-type" | "content-length" | "content-range" | "accept-ranges";
 
 export type TrackStream = {
@@ -142,6 +145,10 @@ export type Playlist = PlaylistSummary & {
   entries: Track[]
 }
 
+export type Sortable = {
+  sortName: string
+}
+
 export const range = (size: number) => [...Array(size).keys()];
 
 export const asArtistAlbumPairs = (artists: Artist[]): [Artist, Album][] =>
@@ -150,12 +157,13 @@ export const asArtistAlbumPairs = (artists: Artist[]): [Artist, Album][] =>
   );
 
 export interface MusicService {
-  generateToken(credentials: Credentials): Promise<AuthSuccess | AuthFailure>;
+  generateToken(credentials: Credentials): TE.TaskEither<AuthFailure, AuthSuccess>;
-  login(authToken: string): Promise<MusicLibrary>;
+  refreshToken(serviceToken: string): TE.TaskEither<AuthFailure, AuthSuccess>;
+  login(serviceToken: string): Promise<MusicLibrary>;
 }
 
 export interface MusicLibrary {
-  artists(q: ArtistQuery): Promise<Result<ArtistSummary>>;
+  artists(q: ArtistQuery): Promise<Result<ArtistSummary & Sortable>>;
   artist(id: string): Promise<Artist>;
   albums(q: AlbumQuery): Promise<Result<AlbumSummary>>;
   album(id: string): Promise<Album>;
@@ -169,7 +177,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,768 +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 & {
-  albumList: {
-    album: album[];
-  };
-};
-
-export type genre = {
-  _songCount: string;
-  _albumCount: string;
-  __text: string;
-};
-
-export type GenGenresResponse = 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 & {
-  artistInfo: 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 = {
-  similarSongs: { 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;
-};
-
-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.albumList.album",
-              "subsonic-response.artist.album",
-              "subsonic-response.artists.index",
-              "subsonic-response.artists.index.artist",
-              "subsonic-response.artistInfo.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.similarSongs.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[]> =>
-    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,
-        }))
-      );
-
-  getArtistInfo = (credentials: Credentials, id: string): Promise<ArtistInfo> =>
-    this.getJSON<GetArtistInfoResponse>(credentials, "/rest/getArtistInfo", {
-      id,
-      count: 50,
-      includeNotPresent: true
-    }).then((it) => ({
-      image: {
-        small: validate(it.artistInfo.smallImageUrl),
-        medium: validate(it.artistInfo.mediumImageUrl),
-        large: validate(it.artistInfo.largeImageUrl),
-      },
-      similarArtist: (it.artistInfo.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: (q: AlbumQuery): Promise<Result<AlbumSummary>> =>
-        navidrome
-          .getJSON<GetAlbumListResponse>(credentials, "/rest/getAlbumList", {
-            ...pick(q, "type", "genre"),
-            size: Math.min(MAX_ALBUM_LIST, q._count),
-            offset: q._index,
-          })
-          .then((response) => response.albumList.album || [])
-          .then(navidrome.toAlbumSummary)
-          .then(slice2(q))
-          .then(([page, total]) => ({
-            results: page,
-            total: Math.min(MAX_ALBUM_LIST, total),
-          })),
-      album: (id: string): Promise<Album> =>
-        navidrome.getAlbum(credentials, id),
-      genres: () =>
-        navidrome
-          .getJSON<GenGenresResponse>(credentials, "/rest/getGenres")
-          .then((it) =>
-            pipe(
-              it.genres.genre,
-              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/getSimilarSongs", { id, count: 50 })
-        .then((it) => (it.similarSongs.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

@@ -1,4 +1,5 @@
 import registrar from "./registrar";
+import readConfig from "./config";
 import { URLBuilder } from "./url_builder";
 
 const params = process.argv.slice(2);
@@ -9,7 +10,10 @@ if (params.length != 1) {
 }
 
 const bonobUrl = new URLBuilder(params[0]!);
-registrar(bonobUrl)()
+
+const config = readConfig();
+
+registrar(bonobUrl, config.sonos.discovery.seedHost)()
   .then((success) => {
     if (success) {
       console.log(`Successfully registered bonob @ ${bonobUrl} with sonos`);

src/registrar.ts

@@ -1,9 +1,14 @@
 import axios from "axios";
+import _ from "underscore";
 import logger from "./logger";
 import sonos, { bonobService } from "./sonos";
 import { URLBuilder } from "./url_builder";
 
-export default (bonobUrl: URLBuilder) => async () => {
+export default (
+    bonobUrl: URLBuilder,
+    seedHost?: string
+  ) =>
+  async () => {
     const about = bonobUrl.append({ pathname: "/about" });
     logger.info(`Fetching bonob service about from ${about}`);
     return axios
@@ -12,8 +17,19 @@ export default (bonobUrl: URLBuilder) => async () => {
         if (res.status == 200) return res.data;
         else throw `Unexpected response status ${res.status} from ${about}`;
       })
-    .then((about) =>
+      .then((res) => {
-      bonobService(about.service.name, about.service.sid, bonobUrl)
+        const name = _.get(res, ["service", "name"]);
+        const sid = _.get(res, ["service", "sid"]);
+        if (!name || !sid) {
+          throw `Unexpected response from ${about.href()}, expected service.name and service.sid`;
+        }
+        return {
+          name,
+          sid: Number.parseInt(sid),
+        };
+      })
+      .then(({ name, sid }: { name: string; sid: number }) =>
+        bonobService(name, sid, bonobUrl)
       )
-    .then((bonobService) => sonos(true).register(bonobService));
+      .then((service) => sonos({ enabled: true, seedHost }).register(service));
-};
+  };

src/server.ts

@@ -1,11 +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 morgan from "morgan";
 import path from "path";
-import scale from "scale-that-svg";
 import sharp from "sharp";
-import fs from "fs";
+import { v4 as uuid } from "uuid";
+import dayjs from "dayjs";
 
 import { PassThrough, Transform, TransformCallback } from "stream";
 
@@ -18,39 +17,28 @@ import {
   LOGIN_ROUTE,
   CREATE_REGISTRATION_ROUTE,
   REMOVE_REGISTRATION_ROUTE,
-  ICON,
+  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";
 import { URLBuilder } from "./url_builder";
 import makeI8N, { asLANGs, KEY, keys as i8nKeys, LANG } from "./i8n";
+import { Icon, ICONS, festivals, features } from "./icon";
+import _, { shuffle } from "underscore";
+import morgan from "morgan";
+import { mask, takeWithRepeats } from "./utils";
+import { parse } from "./burn";
+import { axiosImageFetcher, ImageFetcher } from "./images";
+import { JWTSmapiLoginTokens, SmapiAuthTokens } from "./smapi_auth";
 
-export const BONOB_ACCESS_TOKEN_HEADER = "bonob-access-token";
+export const BONOB_ACCESS_TOKEN_HEADER = "bat";
-
-const icon = (name: string) =>
-  fs
-    .readFileSync(path.resolve(".", "web", "icons", name))
-    .toString();
-
-export type Icon = { svg: string; size: number };
-
-export const ICONS: Record<ICON, Icon> = {
-  artists: { svg: icon("navidrome-artists.svg"), size: 24 },
-  albums: { svg: icon("navidrome-all.svg"), size: 24 },
-  playlists: { svg: icon("navidrome-playlists.svg"), size: 24 },
-  genres: { svg: icon("Theatre-Mask-111172.svg"), size: 128 },
-  random: { svg: icon("navidrome-random.svg"), size: 24 },
-  starred: { svg: icon("navidrome-topRated.svg"), size: 24 },
-  recentlyAdded: { svg: icon("navidrome-recentlyAdded.svg"), size: 24 },
-  recentlyPlayed: { svg: icon("navidrome-recentlyPlayed.svg"), size: 24 },
-  mostPlayed: { svg: icon("navidrome-mostPlayed.svg"), size: 24 },
-  discover: { svg: icon("Binoculars-14310.svg"), size: 32 },
-};
 
 interface RangeFilter extends Transform {
   range: (length: number) => string;
@@ -89,28 +77,68 @@ export class RangeBytesFromFilter extends Transform {
   range = (number: number) => `${this.from}-${number - 1}/${number}`;
 }
 
+export type ServerOpts = {
+  linkCodes: () => LinkCodes;
+  apiTokens: () => APITokens;
+  clock: Clock;
+  iconColors: {
+    foregroundColor: string | undefined;
+    backgroundColor: string | undefined;
+  };
+  applyContextPath: boolean;
+  logRequests: boolean;
+  version: string;
+  smapiAuthTokens: SmapiAuthTokens;
+  externalImageResolver: ImageFetcher;
+};
+
+const DEFAULT_SERVER_OPTS: ServerOpts = {
+  linkCodes: () => new InMemoryLinkCodes(),
+  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(
   sonos: Sonos,
   service: Service,
   bonobUrl: URLBuilder,
   musicService: MusicService,
-  linkCodes: LinkCodes = new InMemoryLinkCodes(),
+  opts: Partial<ServerOpts> = {}
-  accessTokens: AccessTokens = new AccessTokenPerAuthToken(),
-  clock: Clock = SystemClock,
-  applyContextPath = true
 ): Express {
+  const serverOpts = { ...DEFAULT_SERVER_OPTS, ...opts };
+
+  const linkCodes = serverOpts.linkCodes();
+  const smapiAuthTokens = serverOpts.smapiAuthTokens;
+  const apiTokens = serverOpts.apiTokens();
+  const clock = serverOpts.clock;
+
+  const startUpTime = dayjs();
+
   const app = express();
   const i8n = makeI8N(service.name);
 
+  if (serverOpts.logRequests) {
     app.use(morgan("combined"));
+  }
   app.use(express.urlencoded({ extended: false }));
 
-  // todo: pass options in here?
+  app.use(express.static(path.resolve(__dirname, "..", "web", "public")));
-  app.use(express.static("./web/public"));
   app.engine("eta", Eta.renderFile);
 
   app.set("view engine", "eta");
-  app.set("views", "./web/views");
+  app.set("views", path.resolve(__dirname, "..", "web", "views"));
+
+  app.set("query parser", "simple");
 
   const langFor = (req: Request) => {
     logger.debug(
@@ -138,6 +166,7 @@ function server(
           removeRegistrationRoute: bonobUrl
             .append({ pathname: REMOVE_REGISTRATION_ROUTE })
             .pathname(),
+          version: serverOpts.version || DEFAULT_SERVER_OPTS.version,
         });
       }
     );
@@ -199,28 +228,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({
+      return pipe(
+        musicService.generateToken({
           username,
           password,
-      });
+        }),
-      if (isSuccess(authResult)) {
+        TE.match(
-        linkCodes.associate(linkCode, authResult);
+          (e: AuthFailure) => ({
-        res.render("success", {
+            status: 403,
-          lang,
+            template: "failure",
-          message: lang("loginSuccessful"),
+            params: {
-        });
-      } else {
-        res.status(403).render("failure", {
               lang,
               message: lang("loginFailed"),
-          cause: authResult.message,
+              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)
+      );
     }
   });
 
@@ -240,8 +282,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>
@@ -272,25 +350,58 @@ 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(mask(req.headers, ["bnbt", "bnbk"]))}`
     );
-    const authToken = pipe(
+
-      req.header(BONOB_ACCESS_TOKEN_HEADER),
+    const serviceToken = pipe(
-      O.fromNullable,
+      E.fromNullable("Missing bnbt header")(req.headers["bnbt"] as string),
-      O.map((accessToken) => accessTokens.authTokenFor(accessToken)),
+      E.chain((token) =>
-      O.getOrElseW(() => undefined)
+        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((e: string) => {
+        logger.error(`Failed to get serviceToken for stream: ${e}`);
+        return undefined;
+      })
     );
-    if (!authToken) {
+
+    if (!serviceToken) {
       return res.status(401).send();
     } else {
       return musicService
-        .login(authToken)
+        .login(serviceToken)
         .then((it) =>
           it
             .stream({
@@ -301,11 +412,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,
@@ -315,23 +433,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(
+              `${trace} bnb-> ${
-                headers
+                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();
             });
@@ -342,7 +462,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"],
               },
@@ -354,7 +476,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"],
@@ -387,62 +511,133 @@ function server(
     ) {
       return res.status(400).send();
     } else {
-      const icon = (ICONS as any)[type]! as Icon;
+      let icon = (ICONS as any)[type]! as Icon;
       const spec =
         size == "legacy"
           ? {
-              outputSize: 80,
               mimeType: "image/png",
               responseFormatter: (svg: string): Promise<Buffer | string> =>
-                sharp(Buffer.from(svg)).png().toBuffer(),
+                sharp(Buffer.from(svg)).resize(80).png().toBuffer(),
             }
           : {
-              outputSize: Number.parseInt(size),
               mimeType: "image/svg+xml",
               responseFormatter: (svg: string): Promise<Buffer | string> =>
                 Promise.resolve(svg),
             };
 
-      return Promise.resolve(icon.svg)
+      return Promise.resolve(
-        .then((svg) => scale(svg, { scale: spec.outputSize / icon.size }))
+        icon
+          .apply(
+            features({
+              viewPortIncreasePercent: 80,
+              ...serverOpts.iconColors,
+            })
+          )
+          .apply(festivals(clock))
+          .toString()
+      )
         .then(spec.responseFormatter)
         .then((data) => res.status(200).type(spec.mimeType).send(data));
     }
   });
 
-  app.get("/art/:type/:id/size/:size", (req, res) => {
+  app.get("/icons", (_, res) => {
-    const authToken = accessTokens.authTokenFor(
+    res.render("icons", {
+      icons: Object.keys(ICONS).map((k) => [
+        k,
+        ((ICONS as any)[k] as Icon)
+          .apply(
+            features({
+              viewPortIncreasePercent: 80,
+              ...serverOpts.iconColors,
+            })
+          )
+          .toString()
+          .replace('<?xml version="1.0" encoding="UTF-8"?>', ""),
+      ]),
+    });
+  });
+
+  const GRAVITY_9 = [
+    "north",
+    "northeast",
+    "east",
+    "southeast",
+    "south",
+    "southwest",
+    "west",
+    "northwest",
+    "centre",
+  ];
+
+  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 urns = req.params["burns"]!.split("&").map(parse);
-    const id = req.params["id"]!;
+    const size = Number.parseInt(req.params["size"]!);
-    const size = req.params["size"]!;
+
-    if (!authToken) {
+    if (!serviceToken) {
       return res.status(401).send();
-    } else if (type != "artist" && type != "album") {
+    } else if (!(size > 0)) {
       return res.status(400).send();
-    } else if (!(size.match(/^\d+$/) && Number.parseInt(size) > 0)) {
+    }
-      return res.status(400).send();
+
-    } else {
     return musicService
-        .login(authToken)
+      .login(serviceToken)
-        .then((it) => it.coverArt(id, type, Number.parseInt(size)))
+      .then((musicLibrary) =>
-        .then((coverArt) => {
+        Promise.all(
-          if (coverArt) {
+          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) => {
+        if (coverArts.length == 1) {
+          const coverArt = coverArts[0]!;
           res.status(200);
           res.setHeader("content-type", coverArt.contentType);
           return res.send(coverArt.data);
+        } else if (coverArts.length > 1) {
+          const gravity = [...GRAVITY_9];
+          return sharp({
+            create: {
+              width: size * 3,
+              height: size * 3,
+              channels: 3,
+              background: { r: 255, g: 255, b: 255 },
+            },
+          })
+            .composite(
+              takeWithRepeats(coverArts, 9).map((art) => ({
+                input: art?.data,
+                gravity: gravity.pop(),
+              }))
+            )
+            .png()
+            .toBuffer()
+            .then((image) => sharp(image).resize(size).png().toBuffer())
+            .then((image) => {
+              res.status(200);
+              res.setHeader("content-type", "image/png");
+              return res.send(image);
+            });
         } else {
           return res.status(404).send();
         }
       })
       .catch((e: Error) => {
-          logger.error(
+        logger.error(`Failed fetching image ${urns.join("&")}/size/${size}`, {
-            `Failed fetching image ${type}/${id}/size/${size}`, { cause: e }
+          cause: e,
-          );
+        });
         return res.status(500).send();
       });
-    }
   });
 
   bindSmapiSoapServiceToExpress(
@@ -451,12 +646,13 @@ function server(
     bonobUrl,
     linkCodes,
     musicService,
-    accessTokens,
+    apiTokens,
     clock,
-    i8n
+    i8n,
+    serverOpts.smapiAuthTokens
   );
 
-  if (applyContextPath) {
+  if (serverOpts.applyContextPath) {
     const container = express();
     container.use(bonobUrl.path(), app);
     return container;

src/smapi.ts

@@ -3,8 +3,10 @@ import { Express, Request } from "express";
 import { listen } from "soap";
 import { readFileSync } from "fs";
 import path from "path";
-import logger from "./logger";
+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";
 import {
@@ -14,15 +16,26 @@ import {
   ArtistSummary,
   Genre,
   MusicService,
-  PlaylistSummary,
+  Playlist,
+  Rating,
   slice2,
+  Sortable,
   Track,
 } from "./music_service";
-import { AccessTokens } from "./access_tokens";
+import { APITokens } from "./api_tokens";
-import { BONOB_ACCESS_TOKEN_HEADER } from "./server";
 import { Clock } from "./clock";
 import { URLBuilder } from "./url_builder";
 import { asLANGs, I8N } from "./i8n";
+import { ICON, iconForGenre } from "./icon";
+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";
@@ -46,8 +59,6 @@ export const SONOS_RECOMMENDED_IMAGE_SIZES = [
   "1500",
 ];
 
-export type ICON = "artists" | "albums" | "playlists" | "genres" | "random" | "starred" | "recentlyAdded" | "recentlyPlayed" | "mostPlayed" | "discover"
-
 const WSDL_FILE = path.resolve(
   __dirname,
   "Sonoswsdl-1.19.4-20190411.142401-3.wsdl"
@@ -56,6 +67,7 @@ const WSDL_FILE = path.resolve(
 export type Credentials = {
   loginToken: {
     token: string;
+    key: string;
     householdId: string;
   };
   deviceId: string;
@@ -82,6 +94,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";
@@ -139,10 +158,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 {
@@ -171,10 +199,13 @@ class SonosSoap {
   }): GetDeviceAuthTokenResult {
     const association = this.linkCodes.associationFor(linkCode);
     if (association) {
+      const smapiAuthToken = this.smapiAuthTokens.issue(
+        association.serviceToken
+      );
       return {
         getDeviceAuthTokenResult: {
-          authToken: association.authToken,
+          authToken: smapiAuthToken.token,
-          privateKey: "",
+          privateKey: smapiAuthToken.key,
           userInfo: {
             nickname: association.nickname,
             userIdHashCode: crypto
@@ -185,11 +216,14 @@ class SonosSoap {
         },
       };
     } else {
-      logger.info("Client not linked, awaiting user to associate account with link code by logging in.")
+      logger.info(
+        "Client not linked, awaiting user to associate account with link code by logging in."
+      );
       throw {
         Fault: {
           faultcode: "Client.NOT_LINKED_RETRY",
-          faultstring: "Link Code not found yet, sonos app will keep polling until you log in to bonob",
+          faultstring:
+            "Link Code not found yet, sonos app will keep polling until you log in to bonob",
           detail: {
             ExceptionInfo: "NOT_LINKED_RETRY",
             SonosError: "5",
@@ -209,16 +243,18 @@ export type Container = {
   displayType: string | undefined;
 };
 
-const genre = (genre: Genre) => ({
+const genre = (bonobUrl: URLBuilder, genre: Genre) => ({
   itemType: "container",
   id: `genre:${genre.id}`,
   title: genre.name,
+  albumArtURI: iconArtURI(bonobUrl, iconForGenre(genre.name)).href(),
 });
 
-const playlist = (playlist: PlaylistSummary) => ({
+const playlist = (bonobUrl: URLBuilder, playlist: Playlist) => ({
   itemType: "playlist",
   id: `playlist:${playlist.id}`,
   title: playlist.name,
+  albumArtURI: playlistAlbumArtURL(bonobUrl, playlist).href(),
   canPlay: true,
   attributes: {
     readOnly: false,
@@ -227,22 +263,69 @@ const playlist = (playlist: PlaylistSummary) => ({
   },
 });
 
-export const defaultAlbumArtURI = (bonobUrl: URLBuilder, album: AlbumSummary) =>
+export const playlistAlbumArtURL = (
-  bonobUrl.append({ pathname: `/art/album/${album.id}/size/180` });
+  bonobUrl: URLBuilder,
+  playlist: Playlist
+) => {
+  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/${burns
+        .slice(0, 9)
+        .map((it) => encodeURIComponent(formatForURL(it)))
+        .join("&")}/size/180`,
+    });
+  }
+};
+
+export const defaultAlbumArtURI = (
+  bonobUrl: URLBuilder,
+  { 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` });
+  bonobUrl.append({
+    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",
   id: `album:${album.id}`,
   artist: album.artistName,
-  artistId: album.artistId,
+  artistId: `artist:${album.artistId}`,
   title: album.name,
   albumArtURI: defaultAlbumArtURI(bonobUrl, album).href(),
   canPlay: true,
@@ -255,22 +338,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,
+    albumArtistId: track.artist.id ? `artist:${track.artist.id}` : undefined,
-    albumArtURI: defaultAlbumArtURI(bonobUrl, track.album).href(),
+    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) => ({
@@ -281,38 +367,53 @@ export const artist = (bonobUrl: URLBuilder, artist: ArtistSummary) => ({
   albumArtURI: defaultArtistArtURI(bonobUrl, artist).href(),
 });
 
-const auth = async (
+export const scrollIndicesFrom = (things: Sortable[]) => {
-  musicService: MusicService,
+  const indicies: Record<string, number | undefined> = {
-  accessTokens: AccessTokens,
+    "A":undefined,
-  credentials?: Credentials
+    "B":undefined,
-) => {
+    "C":undefined,
-  if (!credentials) {
+    "D":undefined,
-    throw {
+    "E":undefined,
-      Fault: {
+    "F":undefined,
-        faultcode: "Client.LoginUnsupported",
+    "G":undefined,
-        faultstring: "Missing credentials...",
+    "H":undefined,
-      },
+    "I":undefined,
-    };
+    "J":undefined,
+    "K":undefined,
+    "L":undefined,
+    "M":undefined,
+    "N":undefined,
+    "O":undefined,
+    "P":undefined,
+    "Q":undefined,
+    "R":undefined,
+    "S":undefined,
+    "T":undefined,
+    "U":undefined,
+    "V":undefined,
+    "W":undefined,
+    "X":undefined,
+    "Y":undefined,
+    "Z":undefined,
   }
-  const authToken = credentials.loginToken.token;
+  const upperNames = things.map(thing => thing.sortName.toUpperCase());
-  const accessToken = accessTokens.mint(authToken);
+  for(var i = 0; i < upperNames.length; i++) {
-
+    const char = upperNames[i]![0]!;
-  return musicService
+    if(Object.keys(indicies).includes(char) && indicies[char] == undefined) {
-    .login(authToken)
+      indicies[char] = i;
-    .then((musicLibrary) => ({
+    }
-      musicLibrary,
+  }
-      authToken,
+  var lastIndex = 0;
-      accessToken,
+  const result: string[] = [];
-    }))
+  Object.entries(indicies).forEach(([letter, index]) => {
-    .catch((_) => {
+    result.push(letter);
-      throw {
+    if(index) {
-        Fault: {
+      lastIndex = index;
-          faultcode: "Client.LoginUnauthorized",
+    }
-          faultstring: "Credentials not found...",
+    result.push(`${lastIndex}`);
-        },
+  })
-      };
+  return result.join(",")
-    });
+}
-};
 
 function splitId<T>(id: string) {
   const [type, typeId] = id.split(":");
@@ -327,25 +428,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: {
-        "bonob-access-token": 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,
@@ -363,14 +536,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,
+            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}`,
@@ -378,41 +579,46 @@ function bindSmapiSoapServiceToExpress(
                   .href(),
                 httpHeaders: [
                   {
-                    header: BONOB_ACCESS_TOKEN_HEADER,
+                    httpHeader: {
-                    value: accessToken,
+                      header: "bnbt",
+                      value: credentials.loginToken.token,
+                    },
+                  },
+                  {
+                    httpHeader: {
+                      header: "bnbk",
+                      value: credentials.loginToken.key,
+                    },
                   },
                 ],
               })),
           getMediaMetadata: async (
             { id }: { id: string },
             _,
-            soapyHeaders: SoapyHeaders,
+            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(
+                  getMediaMetadataResult: track(urlWithToken(apiKey), it),
-                    urlWithToken(accessToken),
-                    it
-                  ),
                 }))
               ),
           search: async (
             { id, term }: { id: string; term: string },
             _,
-            soapyHeaders: SoapyHeaders,
+            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)
                         ),
                       })
                     );
@@ -421,7 +627,7 @@ function bindSmapiSoapServiceToExpress(
                       searchResult({
                         count: it.length,
                         mediaCollection: it.map((artistSummary) =>
-                          artist(urlWithToken(accessToken), artistSummary)
+                          artist(urlWithToken(apiKey), artistSummary)
                         ),
                       })
                     );
@@ -430,7 +636,7 @@ function bindSmapiSoapServiceToExpress(
                       searchResult({
                         count: it.length,
                         mediaCollection: it.map((aTrack) =>
-                          album(urlWithToken(accessToken), aTrack.album)
+                          album(urlWithToken(apiKey), aTrack.album)
                         ),
                       })
                     );
@@ -446,11 +652,11 @@ function bindSmapiSoapServiceToExpress(
             }: // recursive,
             { id: string; index: number; count: number; recursive: boolean },
             _,
-            soapyHeaders: SoapyHeaders,
+            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":
@@ -464,10 +670,11 @@ 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).length > 0
+                            artist.similarArtists.filter((it) => it.inLibrary)
+                              .length > 0
                               ? [
                                   {
                                     id: `relatedArtists:${artist.id}`,
@@ -481,25 +688,7 @@ function bindSmapiSoapServiceToExpress(
                   case "track":
                     return musicLibrary.track(typeId).then((it) => ({
                       getExtendedMetadataResult: {
-                        mediaMetadata: {
+                        mediaMetadata: track(urlWithToken(apiKey), it),
-                          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(),
-                          },
-                        },
                       },
                     }));
                   case "album":
@@ -511,7 +700,7 @@ function bindSmapiSoapServiceToExpress(
                             userContent: false,
                             renameable: false,
                           },
-                          ...album(urlWithToken(accessToken), it),
+                          ...album(urlWithToken(apiKey), it),
                         },
                         // <mediaCollection readonly="true">
                         //   </mediaCollection>
@@ -535,11 +724,11 @@ function bindSmapiSoapServiceToExpress(
             { id: string; index: number; count: number; recursive: boolean },
             _,
             soapyHeaders: SoapyHeaders,
-            { headers }: Pick<Request, 'headers'>
+            { 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(
@@ -551,7 +740,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,
@@ -567,6 +756,7 @@ function bindSmapiSoapServiceToExpress(
                           title: lang("artists"),
                           albumArtURI: iconArtURI(bonobUrl, "artists").href(),
                           itemType: "container",
+                          canScroll: true,
                         },
                         {
                           id: "albums",
@@ -574,6 +764,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"),
@@ -591,55 +799,60 @@ 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"),
-                          albumArtURI: iconArtURI(bonobUrl, "recentlyAdded").href(),
+                          albumArtURI: iconArtURI(
+                            bonobUrl,
+                            "recentlyAdded"
+                          ).href(),
                           itemType: "albumList",
                         },
                         {
                           id: "recentlyPlayed",
                           title: lang("recentlyPlayed"),
-                          albumArtURI: iconArtURI(bonobUrl, "recentlyPlayed").href(),
+                          albumArtURI: iconArtURI(
+                            bonobUrl,
+                            "recentlyPlayed"
+                          ).href(),
                           itemType: "albumList",
                         },
                         {
                           id: "mostPlayed",
                           title: lang("mostPlayed"),
-                          albumArtURI: iconArtURI(bonobUrl, "mostPlayed").href(),
+                          albumArtURI: iconArtURI(
+                            bonobUrl,
+                            "mostPlayed"
+                          ).href(),
                           itemType: "albumList",
                         },
                       ],
-                      index: 0,
-                      total: 9,
                     });
                   case "search":
                     return getMetadataResult({
                       mediaCollection: [
-                        { itemType: "search", id: "artists", title: lang("artists") },
+                        {
-                        { itemType: "search", id: "albums", title: lang("albums") },
+                          itemType: "search",
-                        { itemType: "search", id: "tracks", title: lang("tracks") },
+                          id: "artists",
+                          title: lang("artists"),
+                        },
+                        {
+                          itemType: "search",
+                          id: "albums",
+                          title: lang("albums"),
+                        },
+                        {
+                          itemType: "search",
+                          id: "tracks",
+                          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,
@@ -662,6 +875,11 @@ function bindSmapiSoapServiceToExpress(
                       type: "random",
                       ...paging,
                     });
+                  case "favouriteAlbums":
+                    return albums({
+                      type: "favourited",
+                      ...paging,
+                    });
                   case "starredAlbums":
                     return albums({
                       type: "starred",
@@ -669,17 +887,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":
@@ -688,7 +906,9 @@ function bindSmapiSoapServiceToExpress(
                       .then(slice2(paging))
                       .then(([page, total]) =>
                         getMetadataResult({
-                          mediaCollection: page.map(genre),
+                          mediaCollection: page.map((it) =>
+                            genre(bonobUrl, it)
+                          ),
                           index: paging._index,
                           total,
                         })
@@ -696,14 +916,23 @@ function bindSmapiSoapServiceToExpress(
                   case "playlists":
                     return musicLibrary
                       .playlists()
+                      .then((it) =>
+                        Promise.all(
+                          it.map((playlist) =>
+                            musicLibrary.playlist(playlist.id)
+                          )
+                        )
+                      )
                       .then(slice2(paging))
-                      .then(([page, total]) =>
+                      .then(([page, total]) => {
-                        getMetadataResult({
+                        return getMetadataResult({
-                          mediaCollection: page.map(playlist),
+                          mediaCollection: page.map((it) =>
+                            playlist(urlWithToken(apiKey), it)
+                          ),
                           index: paging._index,
                           total,
-                        })
+                        });
-                      );
+                      });
                   case "playlist":
                     return musicLibrary
                       .playlist(typeId!)
@@ -712,7 +941,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaMetadata: page.map((it) =>
-                            track(urlWithToken(accessToken), it)
+                            track(urlWithToken(apiKey), it)
                           ),
                           index: paging._index,
                           total,
@@ -726,7 +955,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaCollection: page.map((it) =>
-                            album(urlWithToken(accessToken), it)
+                            album(urlWithToken(apiKey), it)
                           ),
                           index: paging._index,
                           total,
@@ -736,12 +965,14 @@ function bindSmapiSoapServiceToExpress(
                     return musicLibrary
                       .artist(typeId!)
                       .then((artist) => artist.similarArtists)
-                      .then(similarArtists => similarArtists.filter(it => it.inLibrary))
+                      .then((similarArtists) =>
+                        similarArtists.filter((it) => it.inLibrary)
+                      )
                       .then(slice2(paging))
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaCollection: page.map((it) =>
-                            artist(urlWithToken(accessToken), it)
+                            artist(urlWithToken(apiKey), it)
                           ),
                           index: paging._index,
                           total,
@@ -754,7 +985,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaMetadata: page.map((it) =>
-                            track(urlWithToken(accessToken), it)
+                            track(urlWithToken(apiKey), it)
                           ),
                           index: paging._index,
                           total,
@@ -764,12 +995,29 @@ function bindSmapiSoapServiceToExpress(
                     throw `Unsupported getMetadata id=${id}`;
                 }
               }),
+          getScrollIndices: async (
+            { id }: { id: string },
+            _,
+            soapyHeaders: SoapyHeaders
+          ) => {
+            switch(id) {
+              case "artists": {
+                return login(soapyHeaders?.credentials)
+                  .then(({ musicLibrary }) => musicLibrary.artists({ _index: 0, _count: undefined }))
+                  .then((artists) => ({
+                    getScrollIndicesResult: scrollIndicesFrom(artists.results)
+                  }))
+                }
+              default: 
+                throw `Unsupported getScrollIndices id=${id}`;
+            }
+          },
           createContainer: async (
             { title, seedId }: { title: string; seedId: string | undefined },
             _,
-            soapyHeaders: SoapyHeaders,
+            soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(({ musicLibrary }) =>
                 musicLibrary
                   .createPlaylist(title)
@@ -793,17 +1041,17 @@ function bindSmapiSoapServiceToExpress(
           deleteContainer: async (
             { id }: { id: string },
             _,
-            soapyHeaders: SoapyHeaders,
+            soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(({ musicLibrary }) => musicLibrary.deletePlaylist(id))
               .then((_) => ({ deleteContainerResult: {} })),
           addToContainer: async (
             { id, parentId }: { id: string; parentId: string },
             _,
-            soapyHeaders: SoapyHeaders,
+            soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(splitId(id))
               .then(({ musicLibrary, typeId }) =>
                 musicLibrary.addToPlaylist(parentId.split(":")[1]!, typeId)
@@ -812,9 +1060,9 @@ function bindSmapiSoapServiceToExpress(
           removeFromContainer: async (
             { id, indices }: { id: string; indices: string },
             _,
-            soapyHeaders: SoapyHeaders,
+            soapyHeaders: SoapyHeaders
           ) =>
-            auth(musicService, accessTokens, soapyHeaders?.credentials)
+            login(soapyHeaders?.credentials)
               .then(splitId(id))
               .then((it) => ({
                 ...it,
@@ -832,28 +1080,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,
+            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

@@ -7,28 +7,42 @@ import logger from "./logger";
 import { SOAP_PATH, STRINGS_ROUTE, PRESENTATION_MAP_ROUTE } from "./smapi";
 import qs from "querystring";
 import { URLBuilder } from "./url_builder";
+import { LANG } from "./i8n";
 
-export const SONOS_LANG = ["en-US", "da-DK", "de-DE", "es-ES", "fr-FR", "it-IT", "ja-JP", "nb-NO", "nl-NL", "pt-BR", "sv-SE", "zh-CN"]
+export const SONOS_LANG: LANG[] = [
+  "en-US",
+  "da-DK",
+  "de-DE",
+  "es-ES",
+  "fr-FR",
+  "it-IT",
+  "ja-JP",
+  "nb-NO",
+  "nl-NL",
+  "pt-BR",
+  "sv-SE",
+  "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,
+// NOTE: manifest requires https for the URL, otherwise you will get an error trying to register
-// otherwise you will get an error trying to register
 export type Capability =
   | "search"
-  | "trFavorites"
+  | "trFavorites" // Favorites: Adding/Removing Tracks (deprecated)
-  | "alFavorites"
+  | "alFavorites" // Favorites: Adding/Removing Albums (deprecated)
-  | "ucPlaylists"
+  | "ucPlaylists" // User Content Playlists
-  | "extendedMD"
+  | "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",
@@ -87,8 +101,8 @@ export interface Sonos {
 export const SONOS_DISABLED: Sonos = {
   devices: () => Promise.resolve([]),
   services: () => Promise.resolve([]),
-  remove: (_: number) => Promise.resolve(true),
+  remove: (_: number) => Promise.resolve(false),
-  register: (_: Service) => Promise.resolve(true),
+  register: (_: Service) => Promise.resolve(false),
 };
 
 export const asService = (musicService: MusicService): Service => ({
@@ -117,7 +131,7 @@ export const asDevice = (sonosDevice: SonosDevice): Device => ({
 
 export const asRemoveCustomdForm = (csrfToken: string, sid: number) => ({
   csrfToken,
-  sid: `${sid}`
+  sid: `${sid}`,
 });
 
 export const asCustomdForm = (csrfToken: string, service: Service) => ({
@@ -167,7 +181,10 @@ export function autoDiscoverySonos(sonosSeedHost?: string): Sonos {
       });
   };
 
-  const post = async (action: string, customdForm: (csrfToken: string) => any) => {
+  const post = async (
+    action: string,
+    customdForm: (csrfToken: string) => any
+  ) => {
     const anyDevice = await sonosDevices().then((devices) => head(devices));
 
     if (!anyDevice) {
@@ -194,7 +211,7 @@ export function autoDiscoverySonos(sonosSeedHost?: string): Sonos {
       );
       return false;
     }
-    const form = customdForm(csrfToken)
+    const form = customdForm(csrfToken);
     logger.info(`${action} with sonos @ ${customd}`, { form });
     return axios
       .post(customd, new URLSearchParams(qs.stringify(form)), {
@@ -217,16 +234,20 @@ export function autoDiscoverySonos(sonosSeedHost?: string): Sonos {
         )
         .then((it) => it.map(asService)),
 
-    remove: async (sid: number) => post("remove", (csrfToken) => asRemoveCustomdForm(csrfToken, sid)),
+    remove: async (sid: number) =>
+      post("remove", (csrfToken) => asRemoveCustomdForm(csrfToken, sid)),
 
-    register: async (service: Service) => post("register", (csrfToken) => asCustomdForm(csrfToken, service)),
+    register: async (service: Service) =>
+      post("register", (csrfToken) => asCustomdForm(csrfToken, service)),
   };
 }
 
-const sonos = (
+export type Discovery = {
-  discoveryEnabled: boolean = true,
+  enabled: boolean;
-  sonosSeedHost: string | undefined = undefined
+  seedHost?: string;
-): Sonos =>
+};
-  discoveryEnabled ? autoDiscoverySonos(sonosSeedHost) : SONOS_DISABLED;
 
-export default sonos;
+export default (sonosDiscovery: Discovery = { enabled: true }): Sonos =>
+  sonosDiscovery.enabled
+    ? autoDiscoverySonos(sonosDiscovery.seedHost)
+    : SONOS_DISABLED;

src/subsonic/generic.ts

@@ -0,0 +1,770 @@
+import { option as O, taskEither as TE } from "fp-ts";
+import * as A from "fp-ts/Array";
+import { pipe } from "fp-ts/lib/function";
+import { ordString } from "fp-ts/lib/Ord";
+import { inject } from "underscore";
+import _ from "underscore";
+
+import logger from "../logger";
+import { b64Decode, b64Encode } from "../b64";
+import { assertSystem, BUrn, format } from "../burn";
+
+import {
+  Album,
+  AlbumQuery,
+  AlbumQueryType,
+  AlbumSummary,
+  Artist,
+  ArtistQuery,
+  ArtistSummary,
+  AuthFailure,
+  Credentials,
+  Genre,
+  IdName,
+  Rating,
+  Result,
+  slice2,
+  Sortable,
+  Track,
+} from "../music_service";
+import {
+  DODGY_IMAGE_NAME,
+  StreamClientApplication,
+  SubsonicCredentials,
+  SubsonicMusicLibrary,
+  SubsonicResponse,
+  USER_AGENT,
+} from ".";
+import axios from "axios";
+import { asURLSearchParams } from "../utils";
+import { artistSummaryFromNDArtist, NDArtist } from "./navidrome";
+import { Http2, RequestParams } from "../http";
+import { client } from "./subsonic_http";
+
+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 GetArtistInfoResponse = SubsonicResponse & {
+  artistInfo2: artistInfo;
+};
+
+type GetArtistResponse = SubsonicResponse & {
+  artist: artist & {
+    album: album[];
+  };
+};
+
+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[];
+};
+
+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 Search3Response = SubsonicResponse & {
+  searchResult3: {
+    artist: artist[];
+    album: album[];
+    song: song[];
+  };
+};
+
+const AlbumQueryTypeToSubsonicType: Record<AlbumQueryType, string> = {
+  alphabeticalByArtist: "alphabeticalByArtist",
+  alphabeticalByName: "alphabeticalByName",
+  byGenre: "byGenre",
+  random: "random",
+  recentlyPlayed: "recent",
+  mostPlayed: "frequent",
+  recentlyAdded: "newest",
+  favourited: "starred",
+  starred: "highest",
+};
+
+export const isValidImage = (url: string | undefined) =>
+  url != undefined && !url.endsWith(DODGY_IMAGE_NAME);
+
+const artistIsInLibrary = (artistId: string | undefined) =>
+  artistId != undefined && artistId != "-1";
+
+const coverArtURN = (coverArt: string | undefined): BUrn | undefined =>
+  pipe(
+    coverArt,
+    O.fromNullable,
+    O.map((it: string) => ({ system: "subsonic", resource: `art:${it}` })),
+    O.getOrElseW(() => undefined)
+  );
+
+// todo: is this the right place for this??
+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 class SubsonicGenericMusicLibrary implements SubsonicMusicLibrary {
+  streamClientApplication: StreamClientApplication;
+  subsonicHttp: Http2;
+
+  constructor(
+    streamClientApplication: StreamClientApplication,
+    subsonicHttp: Http2
+  ) {
+    this.streamClientApplication = streamClientApplication;
+    this.subsonicHttp = subsonicHttp;
+  }
+
+  GET = (query: Partial<RequestParams>) => client(this.subsonicHttp)({ method: 'get', ...query });
+
+  flavour = () => "subsonic";
+
+  bearerToken = (_: Credentials): TE.TaskEither<Error, string | undefined> =>
+    TE.right(undefined);
+
+  artists = async (q: ArtistQuery): Promise<Result<ArtistSummary & Sortable>> =>
+    this.getArtists()
+      .then(slice2(q))
+      .then(([page, total]) => ({
+        total,
+        results: page.map((it) => ({
+          id: it.id,
+          name: it.name,
+          sortName: it.name,
+          image: it.image,
+        })),
+      }));
+
+  artist = async (id: string): Promise<Artist> => this.getArtistWithInfo(id);
+
+  albums = async (q: AlbumQuery): Promise<Result<AlbumSummary>> =>
+    this.getAlbumList2(q);
+
+  album = (id: string): Promise<Album> => this.getAlbum(id);
+
+  genres = () =>
+    this.GET({
+      url: "/rest/getGenres",
+    })
+      .asJSON<GetGenresResponse>()
+      .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) =>
+    this.GET({
+      url: "/rest/getAlbum",
+      params: {
+        id: albumId,
+      },
+    })
+      .asJSON<GetAlbumResponse>()
+      .then((it) => it.album)
+      .then((album) =>
+        (album.song || []).map((song) => asTrack(asAlbum(album), song))
+      );
+
+  track = (trackId: string) => this.getTrack(trackId);
+
+  rate = (trackId: string, rating: Rating) =>
+    Promise.resolve(true)
+      .then(() => {
+        if (rating.stars >= 0 && rating.stars <= 5) {
+          return this.getTrack(trackId);
+        } else {
+          throw `Invalid rating.stars value of ${rating.stars}`;
+        }
+      })
+      .then((track) => {
+        const thingsToUpdate = [];
+        if (track.rating.love != rating.love) {
+          thingsToUpdate.push(
+            this.GET({
+              url: `/rest/${rating.love ? "star" : "unstar"}`,
+              params: {
+                id: trackId,
+              },
+            }).asJSON()
+          );
+        }
+        if (track.rating.stars != rating.stars) {
+          thingsToUpdate.push(
+            this.GET({
+              url: `/rest/setRating`,
+              params: {
+                id: trackId,
+                rating: rating.stars,
+              },
+            }).asJSON()
+          );
+        }
+        return Promise.all(thingsToUpdate);
+      })
+      .then(() => true)
+      .catch(() => false);
+
+  stream = async ({
+    trackId,
+    range,
+  }: {
+    trackId: string;
+    range: string | undefined;
+  }) =>
+    this.getTrack(trackId).then((track) =>
+      this.GET({
+        url: "/rest/stream",
+        params: {
+          id: trackId,
+          c: this.streamClientApplication(track),
+        },
+        headers: range != undefined ? { Range: range } : {},
+        responseType: "stream",
+      })
+        .asRaw()
+        .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) => this.getCoverArt(it, size))
+      .then((res) => ({
+        contentType: res.headers["content-type"],
+        data: Buffer.from(res.data, "binary"),
+      }))
+      .catch((e) => {
+        logger.error(
+          `Failed getting coverArt for '${format(coverArtURN)}': ${e}`
+        );
+        return undefined;
+      });
+
+  scrobble = async (id: string) =>
+    this.GET({
+      url: `/rest/scrobble`,
+      params: {
+        id,
+        submission: true,
+      },
+    })
+      .asJSON()
+      .then((_) => true)
+      .catch(() => false);
+
+  nowPlaying = async (id: string) =>
+    this.GET({
+      url: `/rest/scrobble`,
+      params: {
+        id,
+        submission: false,
+      },
+    })
+      .asJSON()
+      .then((_) => true)
+      .catch(() => false);
+
+  searchArtists = async (query: string) =>
+    this.search3({ 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) =>
+    this.search3({ query, albumCount: 20 }).then(({ albums }) =>
+      this.toAlbumSummary(albums)
+    );
+
+  searchTracks = async (query: string) =>
+    this.search3({ query, songCount: 20 }).then(({ songs }) =>
+      Promise.all(songs.map((it) => this.getTrack(it.id)))
+    );
+
+  playlists = async () =>
+    this.GET({ url: "/rest/getPlaylists" })
+      .asJSON<GetPlaylistsResponse>()
+      .then((it) => it.playlists.playlist || [])
+      .then((playlists) =>
+        playlists.map((it) => ({ id: it.id, name: it.name }))
+      );
+
+  playlist = async (id: string) =>
+    this.GET({
+      url: "/rest/getPlaylist",
+      params: {
+        id,
+      },
+    })
+      .asJSON<GetPlaylistResponse>()
+      .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) =>
+    this.GET({
+      url: "/rest/createPlaylist",
+      params: {
+        name,
+      },
+    })
+      .asJSON<GetPlaylistResponse>()
+      .then((it) => it.playlist)
+      .then((it) => ({ id: it.id, name: it.name }));
+
+  deletePlaylist = async (id: string) =>
+    this.GET({
+      url: "/rest/deletePlaylist",
+      params: {
+        id,
+      },
+    })
+      .asJSON<GetPlaylistResponse>()
+      .then((_) => true);
+
+  addToPlaylist = async (playlistId: string, trackId: string) =>
+    this.GET({
+      url: "/rest/updatePlaylist",
+      params: {
+        playlistId,
+        songIdToAdd: trackId,
+      },
+    })
+      .asJSON<GetPlaylistResponse>()
+      .then((_) => true);
+
+  removeFromPlaylist = async (playlistId: string, indicies: number[]) =>
+    this.GET({
+      url: "/rest/updatePlaylist",
+      params: {
+        playlistId,
+        songIndexToRemove: indicies,
+      },
+    })
+      .asJSON<GetPlaylistResponse>()
+      .then((_) => true);
+
+  similarSongs = async (id: string) =>
+    this.GET({
+      url: "/rest/getSimilarSongs2",
+      params: { id, count: 50 },
+    })
+      .asJSON<GetSimilarSongsResponse>()
+      .then((it) => it.similarSongs2.song || [])
+      .then((songs) =>
+        Promise.all(
+          songs.map((song) =>
+            this.getAlbum(song.albumId!).then((album) => asTrack(album, song))
+          )
+        )
+      );
+
+  topSongs = async (artistId: string) =>
+    this.getArtist(artistId).then(({ name }) =>
+      this.GET({
+        url: "/rest/getTopSongs",
+        params: {
+          artist: name,
+          count: 50,
+        },
+      })
+        .asJSON<GetTopSongsResponse>()
+        .then((it) => it.topSongs.song || [])
+        .then((songs) =>
+          Promise.all(
+            songs.map((song) =>
+              this.getAlbum(song.albumId!).then((album) => asTrack(album, song))
+            )
+          )
+        )
+    );
+
+  private getArtists = (): Promise<
+    (IdName & { albumCount: number; image: BUrn | undefined })[]
+  > =>
+    this.GET({ url: "/rest/getArtists" })
+      .asJSON<GetArtistsResponse>()
+      .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,
+          }),
+        }))
+      );
+
+  private getArtistInfo = (
+    id: string
+  ): Promise<{
+    similarArtist: (ArtistSummary & { inLibrary: boolean })[];
+    images: {
+      s: string | undefined;
+      m: string | undefined;
+      l: string | undefined;
+    };
+  }> =>
+    this.GET({
+      url: "/rest/getArtistInfo2",
+      params: {
+        id,
+        count: 50,
+        includeNotPresent: true,
+      },
+    })
+      .asJSON<GetArtistInfoResponse>()
+      .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,
+          }),
+        })),
+      }));
+
+  private getAlbum = (id: string): Promise<Album> =>
+    this.GET({ url: "/rest/getAlbum", params: { id } })
+      .asJSON<GetAlbumResponse>()
+      .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),
+      }));
+
+  private getArtist = (
+    id: string
+  ): Promise<
+    IdName & { artistImageUrl: string | undefined; albums: AlbumSummary[] }
+  > =>
+    this.GET({
+      url: "/rest/getArtist",
+      params: {
+        id,
+      },
+    })
+      .asJSON<GetArtistResponse>()
+      .then((it) => it.artist)
+      .then((it) => ({
+        id: it.id,
+        name: it.name,
+        artistImageUrl: it.artistImageUrl,
+        albums: this.toAlbumSummary(it.album || []),
+      }));
+
+  private getArtistWithInfo = (id: string) =>
+    Promise.all([this.getArtist(id), this.getArtistInfo(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,
+      })
+    );
+
+  private getCoverArt = (id: string, size?: number) =>
+    this.GET({
+      url: "/rest/getCoverArt",
+      params: { id, size },
+      responseType: "arraybuffer",
+    }).asRaw();
+
+  private getTrack = (id: string) =>
+    this.GET({
+      url: "/rest/getSong",
+      params: {
+        id,
+      },
+    })
+      .asJSON<GetSongResponse>()
+      .then((it) => it.song)
+      .then((song) =>
+        this.getAlbum(song.albumId!).then((album) => asTrack(album, song))
+      );
+
+  private 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),
+    }));
+
+  private search3 = (q: any) =>
+    this.GET({
+      url: "/rest/search3",
+      params: {
+        artistCount: 0,
+        albumCount: 0,
+        songCount: 0,
+        ...q,
+      },
+    })
+      .asJSON<Search3Response>()
+      .then((it) => ({
+        artists: it.searchResult3.artist || [],
+        albums: it.searchResult3.album || [],
+        songs: it.searchResult3.song || [],
+      }));
+
+  private getAlbumList2 = (q: AlbumQuery) =>
+    Promise.all([
+      this.getArtists().then((it) =>
+        inject(it, (total, artist) => total + artist.albumCount, 0)
+      ),
+      this.GET({
+        url: "/rest/getAlbumList2",
+        params: {
+          type: AlbumQueryTypeToSubsonicType[q.type],
+          ...(q.genre ? { genre: b64Decode(q.genre) } : {}),
+          size: 500,
+          offset: q._index,
+        },
+      })
+        .asJSON<GetAlbumListResponse>()
+        .then((response) => response.albumList2.album || [])
+        .then(this.toAlbumSummary),
+    ]).then(([total, albums]) => ({
+      results: albums.slice(0, q._count),
+      total: albums.length == 500 ? total : (q._index || 0) + albums.length,
+    }));
+}

src/subsonic/index.ts

@@ -0,0 +1,176 @@
+import { taskEither as TE } from "fp-ts";
+import { pipe } from "fp-ts/lib/function";
+import { Md5 } from "ts-md5/dist/md5";
+import axios from "axios";
+import randomstring from "randomstring";
+import _ from "underscore";
+// todo: rename http2 to http
+import { Http2, http2From } from "../http";
+
+import {
+  Credentials,
+  MusicService,
+  MusicLibrary,
+  Track,
+  AuthFailure,
+} from "../music_service";
+import { b64Encode, b64Decode } from "../b64";
+import { axiosImageFetcher, ImageFetcher } from "../images";
+import { navidromeMusicLibrary, SubsonicGenericMusicLibrary } from "./generic";
+import { client } from "./subsonic_http";
+
+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,
+  };
+};
+
+// todo: this is an ND thing
+export const DODGY_IMAGE_NAME = "2a96cbd8b46e442fc41c2b86b821562f.png";
+
+export type SubsonicEnvelope = {
+  "subsonic-response": SubsonicResponse;
+};
+
+export type SubsonicResponse = {
+  status: string;
+};
+
+export type SubsonicError = SubsonicResponse & {
+  error: {
+    code: string;
+    message: string;
+  };
+};
+
+export type PingResponse = {
+  status: string;
+  version: string;
+  type: string;
+  serverVersion: string;
+};
+
+export function isError(
+  subsonicResponse: SubsonicResponse
+): subsonicResponse is SubsonicError {
+  return (subsonicResponse as SubsonicError).error !== undefined;
+}
+
+// todo: is this a good name?
+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 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));
+
+export interface SubsonicMusicLibrary extends MusicLibrary {
+  flavour(): string;
+  bearerToken(
+    credentials: Credentials
+  ): TE.TaskEither<Error, string | undefined>;
+}
+
+export class Subsonic implements MusicService {
+  url: string;
+
+  // todo: does this need to be in here now?
+  streamClientApplication: StreamClientApplication;
+  // todo: why is this in here?
+  externalImageFetcher: ImageFetcher;
+
+  subsonicHttp: Http2;
+
+  constructor(
+    url: string,
+    streamClientApplication: StreamClientApplication = DEFAULT,
+    externalImageFetcher: ImageFetcher = axiosImageFetcher
+  ) {
+    this.url = url;
+    this.streamClientApplication = streamClientApplication;
+    this.externalImageFetcher = externalImageFetcher;
+    this.subsonicHttp = http2From(axios).with({
+      baseURL: this.url,
+      params: { v: "1.16.1", c: DEFAULT_CLIENT_APPLICATION },
+      headers: { "User-Agent": "bonob" },
+    });
+  }
+
+  asAuthParams = (credentials: Credentials) => ({
+    u: credentials.username,
+    ...t_and_s(credentials.password),
+  })
+
+  generateToken = (credentials: Credentials) =>
+    pipe(
+      TE.tryCatch(
+        () => client(this.subsonicHttp.with({ params: this.asAuthParams(credentials) } ))({ method: 'get', url: "/rest/ping.view" }).asJSON<PingResponse>(),
+        (e) => new AuthFailure(e as string)
+      ),
+      TE.chain(({ type }) =>
+        pipe(
+          TE.tryCatch(
+            () => this.libraryFor({ ...credentials, type, bearer: undefined }),
+            () => 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));
+
+  login = async (token: string) => this.libraryFor(parseToken(token));
+
+  private libraryFor = (
+    credentials: SubsonicCredentials
+  ): Promise<SubsonicMusicLibrary> => {
+    const subsonicGenericLibrary = new SubsonicGenericMusicLibrary(
+      this.streamClientApplication,
+      this.subsonicHttp.with({ params: this.asAuthParams(credentials) } )
+    );
+    if (credentials.type == "navidrome") {
+      return Promise.resolve(
+        navidromeMusicLibrary(this.url, subsonicGenericLibrary, credentials)
+      );
+    } else {
+      return Promise.resolve(subsonicGenericLibrary);
+    }
+  };
+}
+
+export default Subsonic;

src/subsonic/navidrome.ts

@@ -0,0 +1,95 @@
+import { option as O, taskEither as TE } from "fp-ts";
+import * as A from "fp-ts/Array";
+import { pipe } from "fp-ts/lib/function";
+import { ordString } from "fp-ts/lib/Ord";
+import { inject } from "underscore";
+import _ from "underscore";
+import axios from "axios";
+
+import { SubsonicCredentials, SubsonicMusicLibrary } from ".";
+import { ArtistQuery, ArtistSummary, AuthFailure, Credentials, Result, Sortable } from "../music_service";
+import { artistImageURN } from "./generic";
+
+export type NDArtist = {
+  id: string;
+  name: string;
+  orderArtistName: string | undefined;
+  largeImageUrl: string | undefined;
+};
+
+export const artistSummaryFromNDArtist = (
+  artist: NDArtist
+): ArtistSummary & Sortable => ({
+  id: artist.id,
+  name: artist.name,
+  sortName: artist.orderArtistName || artist.name,
+  image: artistImageURN({
+    artistId: artist.id,
+    artistImageURL: artist.largeImageUrl,
+  }),
+});
+
+
+export const navidromeMusicLibrary = (
+  url: string,
+  subsonicLibrary: SubsonicMusicLibrary,
+  subsonicCredentials: SubsonicCredentials
+): SubsonicMusicLibrary => ({
+  ...subsonicLibrary,
+  flavour: () => "navidrome",
+  bearerToken: (
+    credentials: Credentials
+  ): TE.TaskEither<Error, string | undefined> =>
+    pipe(
+      TE.tryCatch(
+        () =>
+          // todo: not hardcode axios in here
+          axios({
+            method: "post",
+            baseURL: url,
+            url: `/auth/login`,
+            data: _.pick(credentials, "username", "password"),
+          }),
+        () => new AuthFailure("Failed to get bearerToken")
+      ),
+      TE.map((it) => it.data.token as string | undefined)
+    ),
+  artists: async (
+    q: ArtistQuery
+  ): Promise<Result<ArtistSummary & Sortable>> => {
+    let params: any = {
+      _sort: "name",
+      _order: "ASC",
+      _start: q._index || "0",
+    };
+    if (q._count) {
+      params = {
+        ...params,
+        _end: (q._index || 0) + q._count,
+      };
+    }
+
+    const x: Promise<Result<ArtistSummary & Sortable>> = axios
+      .get(`${url}/api/artist`, {
+        params: asURLSearchParams(params),
+        headers: {
+          "User-Agent": USER_AGENT,
+          "x-nd-authorization": `Bearer ${subsonicCredentials.bearer}`,
+        },
+      })
+      .catch((e) => {
+        throw `Navidrome failed with: ${e}`;
+      })
+      .then((response) => {
+        if (response.status != 200 && response.status != 206) {
+          throw `Navidrome failed with a ${response.status || "no!"} status`;
+        } else return response;
+      })
+      .then((it) => ({
+        results: (it.data as NDArtist[]).map(artistSummaryFromNDArtist),
+        total: Number.parseInt(it.headers["x-total-count"] || "0"),
+      }));
+
+    return x;
+  },
+});

src/subsonic/subsonic_http.ts

@@ -0,0 +1,51 @@
+import { AxiosResponse } from "axios";
+import { isError, SubsonicEnvelope } from ".";
+// todo: rename http2 to http
+import { Http2, RequestParams } from "../http";
+
+export type HttpResponse = {
+  data: any;
+  status: number;
+  headers: any;
+};
+
+const asJSON = <T>(response: HttpResponse): T => {
+  const subsonicResponse = (response.data as SubsonicEnvelope)[
+    "subsonic-response"
+  ];
+  if (isError(subsonicResponse))
+    throw `Subsonic error:${subsonicResponse.error.message}`;
+  else return subsonicResponse as unknown as T;
+};
+const throwUp = (error: any) => {
+  throw `Subsonic failed with: ${error}`;
+};
+const verifyResponse = (response: AxiosResponse<any>) => {
+  if (response.status != 200 && response.status != 206) {
+    throw `Subsonic failed with a ${response.status || "no!"} status`;
+  } else return response;
+};
+
+export interface SubsonicHttpResponse {
+  asRaw(): Promise<AxiosResponse<any>>;
+  asJSON<T>(): Promise<T>;
+}
+
+export interface SubsonicHttp {
+  (query: Partial<RequestParams>): SubsonicHttpResponse;
+}
+
+export const client = (http: Http2): SubsonicHttp => {
+  return (query: Partial<RequestParams>): SubsonicHttpResponse => {
+    return {
+      asRaw: () => http(query).catch(throwUp).then(verifyResponse),
+
+      asJSON: <T>() =>
+        http
+          .with({ params: { f: "json" } })(query)
+          .catch(throwUp)
+          .then(verifyResponse)
+          .then(asJSON) as Promise<T>,
+    };
+  };
+};

src/utils.ts

@@ -0,0 +1,42 @@
+import { flatten } from "underscore";
+
+// todo: move this
+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",
+};
+
+// todo: move this
+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 function takeWithRepeats<T>(things: T[], count: number) {
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(things[i % things.length]);
+  }
+  return result;
+}
+
+export const mask = (thing: any, fields: string[]) =>
+  fields.reduce(
+    (res: any, key: string) => {
+      if (Object.keys(res).includes(key)) {
+        res[key] = "****";
+      }
+      return res;
+    },
+    { ...thing }
+  );

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 {
-import randomString from "../src/random_string";
+  Album,
+  Artist,
+  Track,
+  albumToAlbumSummary,
+  artistToArtistSummary,
+  PlaylistSummary,
+  Playlist,
+  SimilarArtist,
+  AlbumSummary,
+} from "../src/music_service";
+
+import { b64Encode } from "../src/b64";
+import { artistImageURN } from "../src/subsonic/generic";
 
 const randomInt = (max: number) => Math.floor(Math.random() * Math.floor(max));
 const randomIpAddress = () => `127.0.${randomInt(255)}.${randomInt(255)}`;
@@ -28,21 +41,23 @@ 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()}`,
+    name: `playlistname-${randomstring.generate()}`,
-    ...fields
+    ...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 {
@@ -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: {
+    image: { system: "subsonic", resource: `art:${id}` },
-      small: `/artist/art/${id}/small`,
-      medium: `/artist/art/${id}/small`,
-      large: `/artist/art/${id}/large`,
-    },
     similarArtists: [
-      { id: uuid(), name: "Similar artist1", inLibrary: true },
+      aSimilarArtist({ id: uuid(), name: "Similar artist1", inLibrary: true }),
-      { id: uuid(), name: "Similar artist2", inLibrary: true },
+      aSimilarArtist({ id: uuid(), name: "Similar artist2", inLibrary: true }),
-      { id: "-1", name: "Artist not in library", inLibrary: false },
+      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 aGenre = (name: string) => ({ id: b64Encode(name), name });
-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 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: {
+  image: { system: "external", resource: "http://localhost:1234/images/blondie.jpg" },
-    small: undefined,
-    medium: undefined,
-    large: undefined,
-  },
   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(),
-    { id: uuid(), name: "Kaya", year: "1978", genre: SKA, artistId: BOB_MARLEY_ID, artistName: BOB_MARLEY_NAME },
+      name: "Burin'",
-  ],
+      year: "1973",
-  image: {
+      genre: REGGAE,
-    small: "http://localhost/BOB_MARLEY/sml",
+      artistId: BOB_MARLEY_ID,
-    medium: "http://localhost/BOB_MARLEY/med",
+      artistName: BOB_MARLEY_NAME,
-    large: "http://localhost/BOB_MARLEY/lge",
+      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: { 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",
+    system: "external",
-    medium: undefined,
+    resource: "http://localhost:1234/images/madonna.jpg",
-    large: "http://localhost/MADONNA/lge",
   },
   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: {
+  image: { system: "subsonic", resource: METALLICA_ID },
-    small: "http://localhost/METALLICA/sml",
-    medium: "http://localhost/METALLICA/med",
-    large: "http://localhost/METALLICA/lge",
-  },
   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/clock.test.ts

@@ -0,0 +1,85 @@
+import { randomInt } from "crypto";
+import dayjs, { Dayjs } from "dayjs";
+import timezone from "dayjs/plugin/timezone";
+dayjs.extend(timezone);
+
+import { Clock, isChristmas, isCNY, isCNY_2022, isCNY_2023, isCNY_2024, isCNY_2025, isHalloween, isHoli, isMay4 } from "../src/clock";
+
+
+
+const randomDate = () => dayjs().subtract(randomInt(1, 1000), 'days');
+const randomDates = (count: number, exclude: string[]) => {
+  const result: Dayjs[] = [];
+  while(result.length < count) {
+    const next = randomDate();
+    if(!exclude.find(it => dayjs(it).isSame(next, 'date'))) {
+      result.push(next)
+    }
+  }
+  return result
+}
+
+function describeFixedDateMonthEvent(
+  name: string, 
+  dateMonth: string,
+  f: (clock: Clock) => boolean
+) {
+  const randomYear = randomInt(2020, 3000);
+  const date = dateMonth.split("/")[0];
+  const month = dateMonth.split("/")[1];
+
+  describe(name, () => {
+    it(`should return true for ${randomYear}-${month}-${date}T00:00:00 ragardless of year`, () => {
+      expect(f({ now: () => dayjs(`${randomYear}-${month}-${date}T00:00:00Z`) })).toEqual(true);
+    });
+  
+    it(`should return true for ${randomYear}-${month}-${date}T12:00:00 regardless of year`, () => {
+      expect(f({ now: () => dayjs(`${randomYear}-${month}-${date}T12:00:00Z`) })).toEqual(true);
+    });
+  
+    it(`should return true for ${randomYear}-${month}-${date}T23:59:00 regardless of year`, () => {
+      expect(f({ now: () => dayjs(`${randomYear}-${month}-${date}T23:59:00`) })).toEqual(true);
+    });
+  
+    ["2000/12/24", "2000/12/26", "2021/01/01"].forEach((date) => {
+      it(`should return false for ${date}`, () => {
+        expect(f({ now: () => dayjs(date) })).toEqual(false);
+      });
+    });
+  });
+}
+
+function describeFixedDateEvent(
+  name: string,
+  dates: string[],
+  f: (clock: Clock) => boolean
+) {
+  describe(name, () => {
+    dates.forEach((date) => {
+      it(`should return true for ${date}T00:00:00`, () => {
+        expect(f({ now: () => dayjs(`${date}T00:00:00`) })).toEqual(true);
+      });
+  
+      it(`should return true for ${date}T23:59:59`, () => {
+        expect(f({ now: () => dayjs(`${date}T23:59:59`) })).toEqual(true);
+      });
+    });
+    
+    randomDates(10, dates).forEach((date) => {
+      it(`should return false for ${date}`, () => {
+        expect(f({ now: () => dayjs(date) })).toEqual(false);
+      });
+    });
+  });
+}
+
+describeFixedDateMonthEvent("christmas", "25/12", isChristmas);
+describeFixedDateMonthEvent("halloween", "31/10", isHalloween);
+describeFixedDateMonthEvent("may4", "04/05", isMay4);
+
+describeFixedDateEvent("holi", ["2022-03-18", "2023-03-07", "2024-03-25", "2025-03-14"], isHoli);
+describeFixedDateEvent("cny", ["2022-02-01", "2023-01-22", "2024-02-10", "2025-02-29"], isCNY);
+describeFixedDateEvent("cny 2022", ["2022-02-01"], isCNY_2022);
+describeFixedDateEvent("cny 2023", ["2023/01/22"], isCNY_2023);
+describeFixedDateEvent("cny 2024", ["2024/02/10"], isCNY_2024);
+describeFixedDateEvent("cny 2025", ["2025/02/29"], isCNY_2025);

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;
@@ -20,49 +96,38 @@ describe("config", () => {
     propertyGetter: (config: any) => any
   ) {
     describe(name, () => {
-      function expecting({
+      it.each([
-        value,
+        [expectedDefault, ""],
-        expected,
+        [expectedDefault, undefined],
-      }: {
+        [true, "true"],
-        value: string;
+        [false, "false"],
-        expected: boolean;
+        [false, "foo"],
-      }) {
+      ])("should be %s when env var is '%s'", (expected, value) => {
-        describe(`when value is '${value}'`, () => {
-          it(`should be ${expected}`, () => {
         process.env[envVar] = value;
         expect(propertyGetter(config())).toEqual(expected);
-          });
+      })
-        });
-      }
-
-      expecting({ value: "", expected: expectedDefault });
-      expecting({ value: "true", expected: true });
-      expecting({ value: "false", expected: false });
-      expecting({ value: "foo", expected: false });
     });
   }
 
   describe("bonobUrl", () => {
-    describe("when BONOB_URL is specified", () => {
+      describe.each([
+        "BNB_URL", 
+        "BONOB_URL", 
+        "BONOB_WEB_ADDRESS"
+      ])("when %s is specified", (k) => {
         it("should be used", () => {
           const url = "http://bonob1.example.com:8877/";
-        process.env["BONOB_URL"] = url;
 
-        expect(config().bonobUrl.href()).toEqual(url);
+          process.env["BNB_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;
+          process.env["BONOB_WEB_ADDRESS"] = "";
+          process.env[k] = 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 +136,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,26 +156,89 @@ describe("config", () => {
     });
   });
 
-  describe("navidrome", () => {
+  describe("icons", () => {
-    describe("url", () => {
+    describe("foregroundColor", () => {
-      describe("when BONOB_NAVIDROME_URL is not specified", () => {
+      describe.each([
-        it(`should default to http://${hostname()}:4533`, () => {
+        "BNB_ICON_FOREGROUND_COLOR",
-          expect(config().navidrome.url).toEqual(`http://${hostname()}:4533`);
+        "BONOB_ICON_FOREGROUND_COLOR",
+      ])("%s", (k) => {
+        describe(`when ${k} is not specified`, () => {
+          it(`should default to undefined`, () => {
+            expect(config().icons.foregroundColor).toEqual(undefined);
           });
         });
 
-      describe("when BONOB_NAVIDROME_URL is ''", () => {
+        describe(`when ${k} is ''`, () => {
-        it(`should default to http://${hostname()}:4533`, () => {
+          it(`should default to undefined`, () => {
-          process.env["BONOB_NAVIDROME_URL"] = "";
+            process.env[k] = "";
-          expect(config().navidrome.url).toEqual(`http://${hostname()}:4533`);
+            expect(config().icons.foregroundColor).toEqual(undefined);
           });
         });
 
-      describe("when BONOB_NAVIDROME_URL is specified", () => {
+        describe(`when ${k} is specified as a color`, () => {
           it(`should use it`, () => {
-          const url = "http://navidrome.example.com:1234";
+            process.env[k] = "pink";
-          process.env["BONOB_NAVIDROME_URL"] = url;
+            expect(config().icons.foregroundColor).toEqual("pink");
-          expect(config().navidrome.url).toEqual(url);
+          });
+        });
+
+        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.each([
+        "BNB_ICON_BACKGROUND_COLOR",
+        "BONOB_ICON_BACKGROUND_COLOR",
+      ])("%s", (k) => {
+        describe(`when ${k} is not specified`, () => {
+          it(`should default to undefined`, () => {
+            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 ${k} is specified as a color`, () => {
+          it(`should use it`, () => {
+            process.env[k] = "blue";
+            expect(config().icons.backgroundColor).toEqual("blue");
+          });
+        });
+
+        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}`
+            );
+          });
         });
       });
     });
@@ -112,11 +249,27 @@ describe("config", () => {
       expect(config().secret).toEqual("bonob");
     });
 
-    it("should be overridable", () => {
+    describe.each([
-      process.env["BONOB_SECRET"] = "new secret";
+      "BNB_SECRET", 
+      "BONOB_SECRET"
+    ])("%s", (k) => {
+      it(`should be overridable using ${k}`, () => {
+        process.env[k] = "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", () => {
@@ -124,83 +277,169 @@ describe("config", () => {
         expect(config().sonos.serviceName).toEqual("bonob");
       });
 
+      describe.each([
+        "BNB_SONOS_SERVICE_NAME", 
+        "BONOB_SONOS_SERVICE_NAME"
+      ])(
+        "%s",
+        (k) => {
           it("should be overridable", () => {
-        process.env["BONOB_SONOS_SERVICE_NAME"] = "foobar1000";
+            process.env[k] = "foobar1000";
             expect(config().sonos.serviceName).toEqual("foobar1000");
           });
+        }
+      );
     });
 
+    describe.each([
+      "BNB_SONOS_DEVICE_DISCOVERY",
+      "BONOB_SONOS_DEVICE_DISCOVERY",
+    ])("%s", (k) => {
       describeBooleanConfigValue(
         "deviceDiscovery",
-      "BONOB_SONOS_DEVICE_DISCOVERY",
+        k,
         true,
-      (config) => config.sonos.deviceDiscovery
+        (config) => config.sonos.discovery.enabled
       );
+    });
 
     describe("seedHost", () => {
       it("should default to undefined", () => {
-        expect(config().sonos.seedHost).toBeUndefined();
+        expect(config().sonos.discovery.seedHost).toBeUndefined();
       });
 
+      describe.each([
+        "BNB_SONOS_SEED_HOST", 
+        "BONOB_SONOS_SEED_HOST"
+      ])(
+        "%s",
+        (k) => {
           it("should be overridable", () => {
-        process.env["BONOB_SONOS_SEED_HOST"] = "123.456.789.0";
+            process.env[k] = "123.456.789.0";
-        expect(config().sonos.seedHost).toEqual("123.456.789.0");
+            expect(config().sonos.discovery.seedHost).toEqual("123.456.789.0");
           });
+        }
+      );
     });
 
+    describe.each([
+      "BNB_SONOS_AUTO_REGISTER", 
+      "BONOB_SONOS_AUTO_REGISTER"
+    ])(
+      "%s",
+      (k) => {
         describeBooleanConfigValue(
           "autoRegister",
-      "BONOB_SONOS_AUTO_REGISTER",
+          k,
           false,
           (config) => config.sonos.autoRegister
         );
+      }
+    );
 
     describe("sid", () => {
       it("should default to 246", () => {
         expect(config().sonos.sid).toEqual(246);
       });
 
+      describe.each([
+        "BNB_SONOS_SERVICE_ID", 
+        "BONOB_SONOS_SERVICE_ID"
+      ])(
+        "%s",
+        (k) => {
           it("should be overridable", () => {
-        process.env["BONOB_SONOS_SERVICE_ID"] = "786";
+            process.env[k] = "786";
             expect(config().sonos.sid).toEqual(786);
           });
+        }
+      );
     });
   });
 
-  describe("navidrome", () => {
+  describe("subsonic", () => {
     describe("url", () => {
-      it("should default to http://${hostname()}:4533", () => {
+      describe.each([
-        expect(config().navidrome.url).toEqual(`http://${hostname()}:4533`);
+        "BNB_SUBSONIC_URL",
+        "BONOB_SUBSONIC_URL",
+        "BONOB_NAVIDROME_URL",
+      ])("%s", (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", () => {
+        describe(`when ${k} is ''`, () => {
-        process.env["BONOB_NAVIDROME_URL"] = "http://farfaraway.com";
+          it(`should default to http://${hostname()}:4533`, () => {
-        expect(config().navidrome.url).toEqual("http://farfaraway.com");
+            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", () => {
+      describe.each([
-        process.env["BONOB_NAVIDROME_CUSTOM_CLIENTS"] = "whoop/whoop";
+        "BNB_SUBSONIC_CUSTOM_CLIENTS",
-        expect(config().navidrome.customClientsFor).toEqual("whoop/whoop");
+        "BONOB_SUBSONIC_CUSTOM_CLIENTS",
+        "BONOB_NAVIDROME_CUSTOM_CLIENTS",
+      ])("%s", (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");
+      });
+    });
+  });
+
+  describe.each([
+    "BNB_SCROBBLE_TRACKS", 
+    "BONOB_SCROBBLE_TRACKS"
+  ])("%s", (k) => {
     describeBooleanConfigValue(
       "scrobbleTracks",
-    "BONOB_SCROBBLE_TRACKS",
+      k,
       true,
       (config) => config.scrobbleTracks
     );
+  });
+
+  describe.each([
+    "BNB_REPORT_NOW_PLAYING", 
+    "BONOB_REPORT_NOW_PLAYING"
+  ])(
+    "%s",
+    (k) => {
       describeBooleanConfigValue(
         "reportNowPlaying",
-    "BONOB_REPORT_NOW_PLAYING",
+        k,
         true,
         (config) => config.reportNowPlaying
       );
+    }
+  );
 });

tests/encryption.test.ts

@@ -1,12 +1,45 @@
-import encryption from '../src/encryption';
+import { cryptoEncryption, jwsEncryption } from '../src/encryption';
-
-describe("encrypt", () => {
-  const e = encryption("secret squirrel");
 
+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/http.test.ts

@@ -0,0 +1,277 @@
+import { http, http2From, } from "../src/http";
+
+describe("http", () => {
+  const mockAxios = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+  });
+
+  describe.each([
+    ["baseURL"],
+    ["url"],
+    ["method"],
+  ])('%s', (field) => {
+    const getValue = (value: string) => {
+      const thing = {} as any;
+      thing[field] = value;
+      return thing;
+    };
+
+    const base = http(mockAxios, getValue('base'));
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({})
+        expect(mockAxios).toHaveBeenCalledWith(getValue('base'));
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base(getValue('override'))
+        expect(mockAxios).toHaveBeenCalledWith(getValue('override'));
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = http(base, getValue('level1'));
+      const secondLayer = http(firstLayer, getValue('level2'));
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer(getValue('outter'))
+          expect(mockAxios).toHaveBeenCalledWith(getValue('outter'));
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ })
+          expect(mockAxios).toHaveBeenCalledWith(getValue('level2'));
+        });
+      });
+    });
+  });
+
+  describe("requestType", () => {
+    const base = http(mockAxios, { responseType: 'stream' });
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({})
+        expect(mockAxios).toHaveBeenCalledWith({ responseType: 'stream' });
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base({ responseType: 'arraybuffer' })
+        expect(mockAxios).toHaveBeenCalledWith({ responseType: 'arraybuffer' });
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = http(base, { responseType: 'arraybuffer' });
+      const secondLayer = http(firstLayer, { responseType: 'blob' });
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer({ responseType: 'text' })
+          expect(mockAxios).toHaveBeenCalledWith({ responseType: 'text' });
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ })
+          expect(mockAxios).toHaveBeenCalledWith({ responseType: 'blob' });
+        });
+      });
+    });
+  });  
+
+  describe.each([
+    ["params"],
+    ["headers"],
+  ])('%s', (field) => {
+    const getValues = (values: any) => {
+      const thing = {} as any;
+      thing[field] = values;
+      return thing;
+    }
+    const base = http(mockAxios, getValues({ a: 1, b: 2, c: 3, d: 4 }));
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({});
+        expect(mockAxios).toHaveBeenCalledWith(getValues({ a: 1, b: 2, c: 3, d: 4 }));
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base(getValues({ b: 22, e: 5 }));
+        expect(mockAxios).toHaveBeenCalledWith(getValues({ a: 1, b: 22, c: 3, d: 4, e: 5 }));
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = http(base, getValues({ b: 22 }));
+      const secondLayer = http(firstLayer, getValues({ c: 33 }));
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer(getValues({ a: 11, e: 5 }));
+          expect(mockAxios).toHaveBeenCalledWith(getValues({ a: 11, b: 22, c: 33, d: 4, e: 5 }));
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ });
+          expect(mockAxios).toHaveBeenCalledWith(getValues({ a: 1, b: 22, c: 33, d: 4 }));
+        });
+      });
+    });
+  })
+});
+
+describe("http2", () => {
+  const mockAxios = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+  });
+
+  describe.each([
+    ["baseURL"],
+    ["url"],
+    ["method"],
+  ])('%s', (field) => {
+    const fieldWithValue = (value: string) => {
+      const thing = {} as any;
+      thing[field] = value;
+      return thing;
+    };
+
+    const base = http2From(mockAxios).with(fieldWithValue('default'));
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({})
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('default'));
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base(fieldWithValue('override'))
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('override'));
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = http2From(base).with(fieldWithValue('level1'));
+      const secondLayer = firstLayer.with(fieldWithValue('level2'));
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer(fieldWithValue('outter'))
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('outter'));
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ })
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('level2'));
+        });
+      });
+    });
+  });
+
+  describe("requestType", () => {
+    const base = http2From(mockAxios).with({ responseType: 'stream' });
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({})
+        expect(mockAxios).toHaveBeenCalledWith({ responseType: 'stream' });
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base({ responseType: 'arraybuffer' })
+        expect(mockAxios).toHaveBeenCalledWith({ responseType: 'arraybuffer' });
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = base.with({ responseType: 'arraybuffer' });
+      const secondLayer = firstLayer.with({ responseType: 'blob' });
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer({ responseType: 'text' })
+          expect(mockAxios).toHaveBeenCalledWith({ responseType: 'text' });
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ })
+          expect(mockAxios).toHaveBeenCalledWith({ responseType: 'blob' });
+        });
+      });
+    });
+  });  
+
+  describe.each([
+    ["params"],
+    ["headers"],
+  ])('%s', (field) => {
+    const fieldWithValues = (values: any) => {
+      const thing = {} as any;
+      thing[field] = values;
+      return thing;
+    }
+    const base = http2From(mockAxios).with(fieldWithValues({ a: 1, b: 2, c: 3, d: 4 }));
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({});
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 1, b: 2, c: 3, d: 4 }));
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base(fieldWithValues({ b: 22, e: 5 }));
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 1, b: 22, c: 3, d: 4, e: 5 }));
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = base.with(fieldWithValues({ b: 22 }));
+      const secondLayer = firstLayer.with(fieldWithValues({ c: 33 }));
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer(fieldWithValues({ a: 11, e: 5 }));
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 11, b: 22, c: 33, d: 4, e: 5 }));
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ });
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 1, b: 22, c: 33, d: 4 }));
+        });
+      });
+    });
+  })
+});

tests/i8n.test.ts

@@ -1,4 +1,4 @@
-import i8n, { langs, LANG, KEY, keys, asLANGs } from "../src/i8n";
+import i8n, { langs, LANG, KEY, keys, asLANGs, SUPPORTED_LANG } from "../src/i8n";
 
 describe("i8n", () => {
   describe("asLANGs", () => {
@@ -41,7 +41,7 @@ describe("i8n", () => {
   describe("validity of translations", () => {
     it("all langs should have same keys as US", () => {
       langs().forEach((l) => {
-        expect(keys(l as LANG)).toEqual(keys("en-US"));
+        expect(keys(l as SUPPORTED_LANG)).toEqual(keys("en-US"));
       });
     });
   });

tests/icon.test.ts

@@ -0,0 +1,836 @@
+import dayjs from "dayjs";
+import libxmljs from "libxmljs2";
+import { FixedClock } from "../src/clock";
+
+import {
+  contains,
+  containsWord,
+  eq,
+  HOLI_COLORS,
+  Icon,
+  iconForGenre,
+  SvgIcon,
+  IconFeatures,
+  IconSpec,
+  ICONS,
+  Transformer,
+  transform,
+  maybeTransform,
+  festivals,
+  allOf,
+  features,
+  STAR_WARS,
+} from "../src/icon";
+
+describe("SvgIcon", () => {
+  const xmlTidy = (xml: string) =>
+    libxmljs.parseXmlString(xml, { noblanks: true, net: false }).toString();
+
+  const svgIcon24 = `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+  <path d="path1"/>
+  <path d="path2" fill="none" stroke="#000"/>
+  <path d="path3"/>
+</svg>
+`;
+
+  const svgIcon128 = `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128">
+  <path d="path1"/>
+  <path d="path2" fill="none" stroke="#000"/>
+  <path d="path3"/>
+</svg>
+`;
+
+  describe("with no features", () => {
+    it("should be the same", () => {
+      expect(new SvgIcon(svgIcon24).toString()).toEqual(xmlTidy(svgIcon24));
+    });
+  });
+
+  describe("with a view port increase", () => {
+    describe("of 50%", () => {
+      describe("when the viewPort is of size 0 0 24 24", () => {
+        it("should resize the viewPort", () => {
+          expect(
+            new SvgIcon(svgIcon24)
+              .with({ features: { viewPortIncreasePercent: 50 } })
+              .toString()
+          ).toEqual(
+            xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="-4 -4 32 32">
+              <path d="path1"/>
+              <path d="path2" fill="none" stroke="#000"/>
+              <path d="path3"/>
+            </svg>
+          `)
+          );
+        });
+      });
+      describe("when the viewPort is of size 0 0 128 128", () => {
+        it("should resize the viewPort", () => {
+          expect(
+            new SvgIcon(svgIcon128)
+              .with({ features: { viewPortIncreasePercent: 50 } })
+              .toString()
+          ).toEqual(
+            xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="-21 -21 170 170">
+              <path d="path1"/>
+              <path d="path2" fill="none" stroke="#000"/>
+              <path d="path3"/>
+            </svg>
+          `)
+          );
+        });
+      });
+    });
+
+    describe("of 0%", () => {
+      it("should do nothing", () => {
+        expect(
+          new SvgIcon(svgIcon24)
+            .with({ features: { viewPortIncreasePercent: 0 } })
+            .toString()
+        ).toEqual(xmlTidy(svgIcon24));
+      });
+    });
+  });
+
+  describe("background color", () => {
+    describe("with no viewPort increase", () => {
+      it("should add a rectangle the same size as the original viewPort", () => {
+        expect(
+          new SvgIcon(svgIcon24)
+            .with({ features: { backgroundColor: "red" } })
+            .toString()
+        ).toEqual(
+          xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+              <rect x="0" y="0" width="24" height="24" fill="red"/>
+              <path d="path1"/>
+              <path d="path2" fill="none" stroke="#000"/>
+              <path d="path3"/>
+            </svg>
+        `)
+        );
+      });
+    });
+
+    describe("with a viewPort increase", () => {
+      it("should add a rectangle the same size as the original viewPort", () => {
+        expect(
+          new SvgIcon(svgIcon24)
+            .with({
+              features: {
+                backgroundColor: "pink",
+                viewPortIncreasePercent: 50,
+              },
+            })
+            .toString()
+        ).toEqual(
+          xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="-4 -4 32 32">
+              <rect x="-4" y="-4" width="36" height="36" fill="pink"/>
+              <path d="path1"/>
+              <path d="path2" fill="none" stroke="#000"/>
+              <path d="path3"/>
+            </svg>
+        `)
+        );
+      });
+    });
+
+    describe("of undefined", () => {
+      it("should not do anything", () => {
+        expect(
+          new SvgIcon(svgIcon24)
+            .with({ features: { backgroundColor: undefined } })
+            .toString()
+        ).toEqual(
+          xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+              <path d="path1"/>
+              <path d="path2" fill="none" stroke="#000"/>
+              <path d="path3"/>
+            </svg>
+        `)
+        );
+      });
+    });
+
+    describe("multiple times", () => {
+      it("should use the most recent", () => {
+        expect(
+          new SvgIcon(svgIcon24)
+            .with({ features: { backgroundColor: "green" } })
+            .with({ features: { backgroundColor: "red" } })
+            .toString()
+        ).toEqual(
+          xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+              <rect x="0" y="0" width="24" height="24" fill="red"/>
+              <path d="path1"/>
+              <path d="path2" fill="none" stroke="#000"/>
+              <path d="path3"/>
+            </svg>
+        `)
+        );
+      });
+    });
+  });
+
+  describe("foreground color", () => {
+    describe("with no viewPort increase", () => {
+      it("should add a rectangle the same size as the original viewPort", () => {
+        expect(
+          new SvgIcon(svgIcon24)
+            .with({ features: { foregroundColor: "red" } })
+            .toString()
+        ).toEqual(
+          xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+              <path d="path1" fill="red"/>
+              <path d="path2" fill="none" stroke="red"/>
+              <path d="path3" fill="red"/>
+            </svg>
+        `)
+        );
+      });
+    });
+
+    describe("with a viewPort increase", () => {
+      it("should add a rectangle the same size as the original viewPort", () => {
+        expect(
+          new SvgIcon(svgIcon24)
+            .with({
+              features: {
+                foregroundColor: "pink",
+                viewPortIncreasePercent: 50,
+              },
+            })
+            .toString()
+        ).toEqual(
+          xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="-4 -4 32 32">
+              <path d="path1" fill="pink"/>
+              <path d="path2" fill="none" stroke="pink"/>
+              <path d="path3" fill="pink"/>
+            </svg>
+        `)
+        );
+      });
+    });
+
+    describe("of undefined", () => {
+      it("should not do anything", () => {
+        expect(
+          new SvgIcon(svgIcon24)
+            .with({ features: { foregroundColor: undefined } })
+            .toString()
+        ).toEqual(
+          xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+              <path d="path1"/>
+              <path d="path2" fill="none" stroke="#000"/>
+              <path d="path3"/>
+            </svg>
+        `)
+        );
+      });
+    });
+
+    describe("mutliple times", () => {
+      it("should use the most recent", () => {
+        expect(
+          new SvgIcon(svgIcon24)
+            .with({ features: { foregroundColor: "blue" } })
+            .with({ features: { foregroundColor: "red" } })
+            .toString()
+        ).toEqual(
+          xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+              <path d="path1" fill="red"/>
+              <path d="path2" fill="none" stroke="red"/>
+              <path d="path3" fill="red"/>
+            </svg>
+        `)
+        );
+      });
+    });
+  });
+
+  describe("swapping the svg", () => {
+    describe("with no other changes", () => {
+      it("should swap out the svg, but maintain the IconFeatures", () => {
+        expect(
+          new SvgIcon(svgIcon24, {
+            foregroundColor: "blue",
+            backgroundColor: "green",
+            viewPortIncreasePercent: 50,
+          })
+            .with({ svg: svgIcon128 })
+            .toString()
+        ).toEqual(
+          xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="-21 -21 170 170">
+            <rect x="-21" y="-21" width="191" height="191" fill="green"/>
+            <path d="path1" fill="blue"/>
+            <path d="path2" fill="none" stroke="blue"/>
+            <path d="path3" fill="blue"/>
+          </svg>
+        `)
+        );
+      });
+    });
+
+    describe("with no other changes", () => {
+      it("should swap out the svg, but maintain the IconFeatures", () => {
+        expect(
+          new SvgIcon(svgIcon24, {
+            foregroundColor: "blue",
+            backgroundColor: "green",
+            viewPortIncreasePercent: 50,
+          })
+            .with({
+              svg: svgIcon128,
+              features: {
+                foregroundColor: "pink",
+                backgroundColor: "red",
+                viewPortIncreasePercent: 0,
+              },
+            })
+            .toString()
+        ).toEqual(
+          xmlTidy(`<?xml version="1.0" encoding="UTF-8"?>
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128">
+            <rect x="0" y="0" width="128" height="128" fill="red"/>
+            <path d="path1" fill="pink"/>
+            <path d="path2" fill="none" stroke="pink"/>
+            <path d="path3" fill="pink"/>
+          </svg>
+        `)
+        );
+      });
+    });
+  });
+});
+
+class DummyIcon implements Icon {
+  svg: string;
+  features: Partial<IconFeatures>;
+  constructor(svg: string, features: Partial<IconFeatures>) {
+    this.svg = svg;
+    this.features = features;
+  }
+
+  public apply = (transformer: Transformer): Icon => transformer(this);
+
+  public with = ({ svg, features }: Partial<IconSpec>) => {
+    return new DummyIcon(svg || this.svg, {
+      ...this.features,
+      ...(features || {}),
+    });
+  };
+
+  public toString = () =>
+    JSON.stringify({ svg: this.svg, features: this.features });
+}
+
+describe("transform", () => {
+  describe("when the features contains no svg", () => {
+    it("should apply the overriding transform ontop of the requested transform", () => {
+      const original = new DummyIcon("original", {
+        backgroundColor: "black",
+        foregroundColor: "black",
+      });
+      const result = original
+        .with({
+          features: {
+            viewPortIncreasePercent: 100,
+            foregroundColor: "blue",
+            backgroundColor: "blue",
+          },
+        })
+        .apply(
+          transform({
+            features: {
+              foregroundColor: "override1",
+              backgroundColor: "override2",
+            },
+          })
+        ) as DummyIcon;
+
+      expect(result.svg).toEqual("original");
+      expect(result.features).toEqual({
+        viewPortIncreasePercent: 100,
+        foregroundColor: "override1",
+        backgroundColor: "override2",
+      });
+    });
+  });
+
+  describe("when the features contains an svg", () => {
+    it("should use the newly provided svg", () => {
+      const original = new DummyIcon("original", {
+        backgroundColor: "black",
+        foregroundColor: "black",
+      });
+      const result = original
+        .with({
+          features: {
+            viewPortIncreasePercent: 100,
+            foregroundColor: "blue",
+            backgroundColor: "blue",
+          },
+        })
+        .apply(
+          transform({
+            svg: "new",
+          })
+        ) as DummyIcon;
+
+      expect(result.svg).toEqual("new");
+      expect(result.features).toEqual({
+        viewPortIncreasePercent: 100,
+        foregroundColor: "blue",
+        backgroundColor: "blue",
+      });
+    });
+  });
+});
+
+describe("features", () => {
+  it("should apply the features", () => {
+    const original = new DummyIcon("original", {
+      backgroundColor: "black",
+      foregroundColor: "black",
+    });
+    const result = original.apply(
+      features({
+        viewPortIncreasePercent: 100,
+        foregroundColor: "blue",
+        backgroundColor: "blue",
+      })
+    ) as DummyIcon;
+
+    expect(result.features).toEqual({
+      viewPortIncreasePercent: 100,
+      foregroundColor: "blue",
+      backgroundColor: "blue",
+    });
+  });
+});
+
+describe("allOf", () => {
+  it("should apply all composed transforms", () => {
+    const result = new DummyIcon("original", {
+      foregroundColor: "black",
+      backgroundColor: "black",
+      viewPortIncreasePercent: 0,
+    }).apply(
+      allOf(
+        (icon: Icon) => icon.with({ svg: "foo" }),
+        (icon: Icon) => icon.with({ features: { backgroundColor: "red" } }),
+        (icon: Icon) => icon.with({ features: { foregroundColor: "blue" } })
+      )
+    ) as DummyIcon;
+
+    expect(result.svg).toEqual("foo");
+    expect(result.features).toEqual({
+      foregroundColor: "blue",
+      backgroundColor: "red",
+      viewPortIncreasePercent: 0,
+    });
+  });
+});
+
+describe("maybeTransform", () => {
+  describe("when the rule matches", () => {
+    const original = new DummyIcon("original", {
+      backgroundColor: "black",
+      foregroundColor: "black",
+    });
+
+    describe("transforming the color", () => {
+      const result = original
+        .with({
+          features: {
+            viewPortIncreasePercent: 99,
+            backgroundColor: "shouldBeIgnored",
+            foregroundColor: "shouldBeIgnored",
+          },
+        })
+        .apply(
+          maybeTransform(
+            () => true,
+            transform({
+              features: {
+                backgroundColor: "blue",
+                foregroundColor: "red",
+              },
+            })
+          )
+        ) as DummyIcon;
+
+      describe("with", () => {
+        it("should be the with of the underlieing icon with the overriden colors", () => {
+          expect(result.svg).toEqual("original");
+          expect(result.features).toEqual({
+            viewPortIncreasePercent: 99,
+            backgroundColor: "blue",
+            foregroundColor: "red",
+          });
+        });
+      });
+    });
+
+    describe("overriding all options", () => {
+      const result = original
+        .with({
+          features: {
+            viewPortIncreasePercent: 99,
+            backgroundColor: "shouldBeIgnored",
+            foregroundColor: "shouldBeIgnored",
+          },
+        })
+        .apply(
+          maybeTransform(
+            () => true,
+            transform({
+              features: {
+                backgroundColor: "blue",
+                foregroundColor: "red",
+              },
+            })
+          )
+        ) as DummyIcon;
+
+      describe("with", () => {
+        it("should be the with of the underlieing icon with the overriden colors", () => {
+          expect(result.features).toEqual({
+            viewPortIncreasePercent: 99,
+            backgroundColor: "blue",
+            foregroundColor: "red",
+          });
+        });
+      });
+    });
+  });
+
+  describe("when the rule doesnt match", () => {
+    const original = new DummyIcon("original", {
+      backgroundColor: "black",
+      foregroundColor: "black",
+    });
+    const result = original
+      .with({
+        features: {
+          viewPortIncreasePercent: 88,
+          backgroundColor: "shouldBeUsed",
+          foregroundColor: "shouldBeUsed",
+        },
+      })
+      .apply(
+        maybeTransform(
+          () => false,
+          transform({
+            features: { backgroundColor: "blue", foregroundColor: "red" },
+          })
+        )
+      ) as DummyIcon;
+
+    describe("with", () => {
+      it("should use the provided features", () => {
+        expect(result.features).toEqual({
+          viewPortIncreasePercent: 88,
+          backgroundColor: "shouldBeUsed",
+          foregroundColor: "shouldBeUsed",
+        });
+      });
+    });
+  });
+});
+
+describe("festivals", () => {
+  const original = new DummyIcon("original", {
+    backgroundColor: "black",
+    foregroundColor: "black",
+  });
+  const clock = new FixedClock(dayjs());
+
+  describe("on a day that isn't festive", () => {
+    beforeEach(() => {
+      clock.time = dayjs("2022/10/12");
+    });
+
+    it("should use the given colors", () => {
+      const result = original
+        .apply(
+          features({
+            viewPortIncreasePercent: 88,
+            backgroundColor: "shouldBeUsed",
+            foregroundColor: "shouldBeUsed",
+          })
+        )
+        .apply(festivals(clock)) as DummyIcon;
+
+      expect(result.toString()).toEqual(
+        new DummyIcon("original", {
+          backgroundColor: "shouldBeUsed",
+          foregroundColor: "shouldBeUsed",
+          viewPortIncreasePercent: 88,
+        }).toString()
+      );
+    });
+  });
+
+  describe("on christmas day", () => {
+    beforeEach(() => {
+      clock.time = dayjs("2022/12/25");
+    });
+
+    it("should use the christmas theme colors", () => {
+      const result = original.apply(
+        allOf(
+          features({
+            viewPortIncreasePercent: 25,
+            backgroundColor: "shouldNotBeUsed",
+            foregroundColor: "shouldNotBeUsed",
+          }),
+          festivals(clock)
+        )
+      ) as DummyIcon;
+
+      expect(result.svg).toEqual(ICONS.christmas.svg);
+      expect(result.features).toEqual({
+        backgroundColor: "green",
+        foregroundColor: "red",
+        viewPortIncreasePercent: 25,
+      });
+    });
+  });
+
+  describe("on halloween", () => {
+    beforeEach(() => {
+      clock.time = dayjs("2022/10/31");
+    });
+
+    it("should use the given colors", () => {
+      const result = original
+        .apply(
+          features({
+            viewPortIncreasePercent: 12,
+            backgroundColor: "shouldNotBeUsed",
+            foregroundColor: "shouldNotBeUsed",
+          })
+        )
+        .apply(festivals(clock)) as DummyIcon;
+
+      expect(result.svg).toEqual(ICONS.halloween.svg);
+      expect(result.features).toEqual({
+        viewPortIncreasePercent: 12,
+        backgroundColor: "black",
+        foregroundColor: "orange",
+      });
+    });
+  });
+
+  describe("on may 4", () => {
+    beforeEach(() => {
+      clock.time = dayjs("2022/5/4");
+    });
+
+    it("should use the undefined colors, so no color", () => {
+      const result = original
+        .apply(
+          features({
+            viewPortIncreasePercent: 12,
+            backgroundColor: "shouldNotBeUsed",
+            foregroundColor: "shouldNotBeUsed",
+          })
+        )
+        .apply(festivals(clock)) as DummyIcon;
+
+      expect(STAR_WARS.map(it => it.svg)).toContain(result.svg);
+      expect(result.features).toEqual({
+        viewPortIncreasePercent: 12,
+        backgroundColor: undefined,
+        foregroundColor: undefined,
+      });
+    });
+  });
+
+  describe("on cny", () => {
+    describe("2022", () => {
+      beforeEach(() => {
+        clock.time = dayjs("2022/02/01");
+      });
+
+      it("should use the cny theme", () => {
+        const result = original
+          .apply(
+            features({
+              viewPortIncreasePercent: 12,
+              backgroundColor: "shouldNotBeUsed",
+              foregroundColor: "shouldNotBeUsed",
+            })
+          )
+          .apply(festivals(clock)) as DummyIcon;
+
+        expect(result.svg).toEqual(ICONS.yoTiger.svg);
+        expect(result.features).toEqual({
+          viewPortIncreasePercent: 12,
+          backgroundColor: "red",
+          foregroundColor: "yellow",
+        });
+      });
+    });
+
+    describe("2023", () => {
+      beforeEach(() => {
+        clock.time = dayjs("2023/01/22");
+      });
+
+      it("should use the cny theme", () => {
+        const result = original
+          .apply(
+            features({
+              viewPortIncreasePercent: 12,
+              backgroundColor: "shouldNotBeUsed",
+              foregroundColor: "shouldNotBeUsed",
+            })
+          )
+          .apply(festivals(clock)) as DummyIcon;
+
+        expect(result.svg).toEqual(ICONS.yoRabbit.svg);
+        expect(result.features).toEqual({
+          viewPortIncreasePercent: 12,
+          backgroundColor: "red",
+          foregroundColor: "yellow",
+        });
+      });
+    });
+
+    describe("2024", () => {
+      beforeEach(() => {
+        clock.time = dayjs("2024/02/10");
+      });
+
+      it("should use the cny theme", () => {
+        const result = original
+          .apply(
+            features({
+              viewPortIncreasePercent: 12,
+              backgroundColor: "shouldNotBeUsed",
+              foregroundColor: "shouldNotBeUsed",
+            })
+          )
+          .apply(festivals(clock)) as DummyIcon;
+
+        expect(result.svg).toEqual(ICONS.yoDragon.svg);
+        expect(result.features).toEqual({
+          viewPortIncreasePercent: 12,
+          backgroundColor: "red",
+          foregroundColor: "yellow",
+        });
+      });
+    });
+  });
+
+  describe("on holi", () => {
+    beforeEach(() => {
+      clock.time = dayjs("2022/03/18");
+    });
+
+    it("should use the given colors", () => {
+      const result = original
+        .apply(
+          features({
+            viewPortIncreasePercent: 12,
+            backgroundColor: "shouldNotBeUsed",
+            foregroundColor: "shouldNotBeUsed",
+          })
+        )
+        .apply(festivals(clock)) as DummyIcon;
+
+      expect(result.features.viewPortIncreasePercent).toEqual(12);
+      expect(HOLI_COLORS.includes(result.features.backgroundColor!)).toEqual(
+        true
+      );
+      expect(HOLI_COLORS.includes(result.features.foregroundColor!)).toEqual(
+        true
+      );
+      expect(result.features.backgroundColor).not.toEqual(
+        result.features.foregroundColor
+      );
+    });
+  });
+});
+
+describe("eq", () => {
+  it("should be true when ===", () => {
+    expect(eq("Foo")("foo")).toEqual(true);
+  });
+
+  it("should be false when not ===", () => {
+    expect(eq("Foo")("bar")).toEqual(false);
+  });
+});
+
+describe("contains", () => {
+  it("should be true word is a substring", () => {
+    expect(contains("Foo")("some foo bar")).toEqual(true);
+  });
+
+  it("should be false when not ===", () => {
+    expect(contains("Foo")("some bar")).toEqual(false);
+  });
+});
+
+describe("containsWord", () => {
+  it("should be true word is a substring with space delim", () => {
+    expect(containsWord("Foo")("some   foo   bar")).toEqual(true);
+  });
+
+  it("should be true word is a substring with hyphen delim", () => {
+    expect(containsWord("Foo")("some----foo-bar")).toEqual(true);
+  });
+
+  it("should be false when not ===", () => {
+    expect(containsWord("Foo")("somefoobar")).toEqual(false);
+  });
+});
+
+describe("iconForGenre", () => {
+  [
+    ["Acid House", "mushroom"],
+    ["African", "african"],
+    ["Alternative Rock", "rock"],
+    ["Americana", "americana"],
+    ["Anti-Folk", "guitar"],
+    ["Audio-Book", "book"],
+    ["Australian Hip Hop", "oz"],
+    ["Rap", "rap"],
+    ["Hip Hop", "hipHop"],
+    ["Hip-Hop", "hipHop"],
+    ["Metal", "metal"],
+    ["Horrorcore", "horror"],
+    ["Punk", "punk"],
+    ["blah", "music"],
+  ].forEach(([genre, expected]) => {
+    describe(`a genre of ${genre}`, () => {
+      it(`should have an icon of ${expected}`, () => {
+        const name = iconForGenre(genre!)!;
+        expect(name).toEqual(expected);
+      });
+    });
+
+    describe(`a genre of ${genre!.toLowerCase()}`, () => {
+      it(`should have an icon of ${expected}`, () => {
+        const name = iconForGenre(genre!)!;
+        expect(name).toEqual(expected);
+      });
+    });
+  });
+});

tests/images.test.ts

@@ -0,0 +1,78 @@
+
+import tmp from "tmp";
+import fse from "fs-extra";
+import path from "path";
+import { Md5 } from "ts-md5";
+
+import sharp from "sharp";
+jest.mock("sharp");
+
+import { cachingImageFetcher } from "../src/images";
+
+describe("cachingImageFetcher", () => {
+  const delegate = jest.fn();
+  const url = "http://test.example.com/someimage.jpg";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+  });
+
+  describe("when there is no image in the cache", () => {
+    it("should fetch the image from the source and then cache and return it", async () => {
+      const dir = tmp.dirSync();
+      const cacheFile = path.join(dir.name, `${Md5.hashStr(url)}.png`);
+      const jpgImage = Buffer.from("jpg-image", "utf-8");
+      const pngImage = Buffer.from("png-image", "utf-8");
+
+      delegate.mockResolvedValue({ contentType: "image/jpeg", data: jpgImage });
+      const png = jest.fn();
+      (sharp as unknown as jest.Mock).mockReturnValue({ png });
+      png.mockReturnValue({
+        toBuffer: () => Promise.resolve(pngImage),
+      });
+
+      const result = await cachingImageFetcher(dir.name, delegate)(url);
+
+      expect(result!.contentType).toEqual("image/png");
+      expect(result!.data).toEqual(pngImage);
+
+      expect(delegate).toHaveBeenCalledWith(url);
+      expect(fse.existsSync(cacheFile)).toEqual(true);
+      expect(fse.readFileSync(cacheFile)).toEqual(pngImage);
+    });
+  });
+
+  describe("when the image is already in the cache", () => {
+    it("should fetch the image from the cache and return it", async () => {
+      const dir = tmp.dirSync();
+      const cacheFile = path.join(dir.name, `${Md5.hashStr(url)}.png`);
+      const data = Buffer.from("foobar2", "utf-8");
+
+      fse.writeFileSync(cacheFile, data);
+
+      const result = await cachingImageFetcher(dir.name, delegate)(url);
+
+      expect(result!.contentType).toEqual("image/png");
+      expect(result!.data).toEqual(data);
+
+      expect(delegate).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("when the delegate returns undefined", () => {
+    it("should return undefined", async () => {
+      const dir = tmp.dirSync();
+      const cacheFile = path.join(dir.name, `${Md5.hashStr(url)}.png`);
+
+      delegate.mockResolvedValue(undefined);
+
+      const result = await cachingImageFetcher(dir.name, delegate)(url);
+
+      expect(result).toBeUndefined();
+
+      expect(delegate).toHaveBeenCalledWith(url);
+      expect(fse.existsSync(cacheFile)).toEqual(false);
+    });
+  });
+});

tests/in_memory_music_service.test.ts

@@ -1,9 +1,12 @@
+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,
+  Artist,
 } from "../src/music_service";
 import { v4 as uuid } from "uuid";
 import {
@@ -18,6 +21,7 @@ import {
 } from "./builders";
 import _ from "underscore";
 
+
 describe("InMemoryMusicService", () => {
   const service = new InMemoryMusicService();
 
@@ -27,12 +31,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 +49,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,10 +71,19 @@ describe("InMemoryMusicService", () => {
 
       service.hasUser(user);
 
-      const token = (await service.generateToken(user)) as AuthSuccess;
+      const token = await pipe(
-      musicLibrary = (await service.login(token.authToken)) as MusicLibrary;
+        service.generateToken(user),
+        TE.getOrElse(e => { throw e })
+      )();
+
+      musicLibrary = (await service.login(token.serviceToken)) as MusicLibrary;
     });
 
+    const artistToArtistSummaryWithSortName = (artist: Artist) => ({
+      ...artistToArtistSummary(artist),
+      sortName: artist.name
+    })
+
     describe("artists", () => {
       const artist1 = anArtist();
       const artist2 = anArtist();
@@ -100,11 +101,11 @@ describe("InMemoryMusicService", () => {
             await musicLibrary.artists({ _index: 0, _count: 100 })
           ).toEqual({
             results: [
-              artistToArtistSummary(artist1),
+              artistToArtistSummaryWithSortName(artist1),
-              artistToArtistSummary(artist2),
+              artistToArtistSummaryWithSortName(artist2),
-              artistToArtistSummary(artist3),
+              artistToArtistSummaryWithSortName(artist3),
-              artistToArtistSummary(artist4),
+              artistToArtistSummaryWithSortName(artist4),
-              artistToArtistSummary(artist5),
+              artistToArtistSummaryWithSortName(artist5),
             ],
             total: 5,
           });
@@ -115,8 +116,8 @@ describe("InMemoryMusicService", () => {
         it("should provide an array of artists", async () => {
           expect(await musicLibrary.artists({ _index: 2, _count: 2 })).toEqual({
             results: [
-              artistToArtistSummary(artist3),
+              artistToArtistSummaryWithSortName(artist3),
-              artistToArtistSummary(artist4),
+              artistToArtistSummaryWithSortName(artist4),
             ],
             total: 5,
           });
@@ -126,7 +127,7 @@ describe("InMemoryMusicService", () => {
       describe("fetching the last page", () => {
         it("should provide an array of artists", async () => {
           expect(await musicLibrary.artists({ _index: 4, _count: 2 })).toEqual({
-            results: [artistToArtistSummary(artist5)],
+            results: [artistToArtistSummaryWithSortName(artist5)],
             total: 5,
           });
         });
@@ -143,8 +144,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(artist1.id!)).toEqual(artist1);
-          expect(await musicLibrary.artist(artist2.id)).toEqual(artist2);
+          expect(await musicLibrary.artist(artist2.id!)).toEqual(artist2);
         });
       });
 
@@ -175,8 +176,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,
+            { ...track1, rating: { love: false, stars: 0 } },
-            track2,
+            { ...track2, rating: { love: false, stars: 0 } },
           ]);
         });
       });
@@ -192,7 +193,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 +222,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 +262,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
           });
         });
@@ -302,13 +306,11 @@ describe("InMemoryMusicService", () => {
                     type: "alphabeticalByName",
                   })
                 ).toEqual({
-                  results:                   
+                  results: _.sortBy(allAlbums, "name").map(albumToAlbumSummary),
-                  _.sortBy(allAlbums, 'name').map(albumToAlbumSummary),
                   total: totalAlbumCount,
                 });
               });
             });
-
           });
 
           describe("fetching a page", () => {
@@ -467,9 +469,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,34 +34,35 @@ 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({
+      return TE.right({
-        authToken: Buffer.from(JSON.stringify({ username, password })).toString(
+        serviceToken: b64Encode(JSON.stringify({ username, password })),
-          "base64"
-        ),
         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> {
+  refreshToken(serviceToken: string): TE.TaskEither<AuthFailure, AuthSuccess> {
-    const credentials = JSON.parse(
+    return this.generateToken(JSON.parse(b64Decode(serviceToken)))
-      Buffer.from(token, "base64").toString("ascii")
+  }
-    ) as Credentials;
+
+  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");
 
     return Promise.resolve({
       artists: (q: ArtistQuery) =>
-        Promise.resolve(this.artists.map(artistToArtistSummary))
+        Promise.resolve(this.artists.map(artistToArtistSummary).map(it => ({ ...it, sortName: it.name })))
           .then(slice2(q))
           .then(asResult),
       artist: (id: string) =>
@@ -78,7 +83,9 @@ export class InMemoryMusicService implements MusicService {
               case "alphabeticalByArtist":
                 return artist2Album;
               case "alphabeticalByName":
-                  return artist2Album.sort((a, b) => a.album.name.localeCompare(b.album.name));
+                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(
+            A.sort(fromCompare<Genre>((x, y) => ordString.compare(x.id, y.id)))
-              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) =>
+      coverArt: (coverArtURN: BUrn, size?: number) =>
-        Promise.reject(`Cannot retrieve coverArt for ${id}, size ${size}`),
+        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"),
+      createPlaylist: async (_: string) =>
-      deletePlaylist: async (_: string) => Promise.reject("Unsupported operation"),
+        Promise.reject("Unsupported operation"),
-      addToPlaylist: async (_: string) => Promise.reject("Unsupported operation"),
+      deletePlaylist: async (_: string) =>
-      removeFromPlaylist: async (_: string, _2: number[]) => Promise.reject("Unsupported operation"),
+        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,72 @@
+import { v4 as uuid } from "uuid";
+
+import { anArtist } from "./builders";
+import { artistToArtistSummary, slice2 } from "../src/music_service";
+
+
+describe("slice2", () => {
+  const things = ["a", "b", "c", "d", "e", "f", "g", "h", "i"];
+  
+  describe("when slice is a subset of the things", () => {
+    it("should return the page", () => {
+      expect(slice2({ _index: 3, _count: 4 })(things)).toEqual([
+        ["d", "e", "f", "g"],
+        things.length
+      ])
+    });
+  });
+
+  describe("when slice goes off the end of the things", () => {
+    it("should return the page", () => {
+      expect(slice2({ _index: 5, _count: 100 })(things)).toEqual([
+        ["f", "g", "h", "i"],
+        things.length
+      ])
+    });
+  });
+
+  describe("when no _count is provided", () => {
+    it("should return from the index", () => {
+      expect(slice2({ _index: 5 })(things)).toEqual([
+        ["f", "g", "h", "i"],
+        things.length
+      ])
+    });
+  });
+
+  describe("when no _index is provided", () => {
+    it("should assume from the start", () => {
+      expect(slice2({ _count: 3 })(things)).toEqual([
+        ["a", "b", "c"],
+        things.length
+      ])
+    });
+  });
+
+  describe("when no _index or _count is provided", () => {
+    it("should return all the things", () => {
+      expect(slice2()(things)).toEqual([
+        things,
+        things.length
+      ])
+    });
+  });
+});
+
+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

@@ -0,0 +1,137 @@
+import axios from "axios";
+jest.mock("axios");
+
+const fakeSonos = {
+  register: jest.fn(),
+};
+
+import sonos, { bonobService } from "../src/sonos";
+jest.mock("../src/sonos");
+
+import registrar from "../src/registrar";
+import { URLBuilder } from "../src/url_builder";
+
+describe("registrar", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+  });
+
+  describe("when the bonob service can not be found", () => {
+    it("should fail", async () => {
+      const status = 409;
+
+      (axios.get as jest.Mock).mockResolvedValue({
+        status,
+      });
+
+      const bonobUrl = new URLBuilder("http://fail.example.com/bonob");
+
+      return expect(registrar(bonobUrl)()).rejects.toEqual(
+        `Unexpected response status ${status} from ${bonobUrl
+          .append({ pathname: "/about" })
+          .href()}`
+      );
+    });
+  });
+
+  describe("when the bonob service returns unexpected content", () => {
+    it("should fail", async () => {
+      (axios.get as jest.Mock).mockResolvedValue({
+        status: 200,
+        // invalid response from /about as does not have name and sid
+        data: {}
+      });
+
+      const bonobUrl = new URLBuilder("http://fail.example.com/bonob");
+
+      return expect(registrar(bonobUrl)()).rejects.toEqual(
+        `Unexpected response from ${bonobUrl
+          .append({ pathname: "/about" })
+          .href()}, expected service.name and service.sid`
+      );
+    });
+  });
+
+  describe("when the bonob service can be found", () => {
+    const bonobUrl = new URLBuilder("http://success.example.com/bonob");
+
+    const serviceDetails = {
+      name: "bob",
+      sid: 123,
+    };
+
+    const service = "service";
+
+    beforeEach(() => {
+      (axios.get as jest.Mock).mockResolvedValue({
+        status: 200,
+        data: {
+          service: serviceDetails,
+        },
+      });
+
+      (bonobService as jest.Mock).mockResolvedValue(service);
+      (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);
+
+        expect(await registrar(bonobUrl)()).toEqual(
+          true
+        );
+      });
+    });
+
+    describe("when registration fails", () => {
+      it("should fetch the service details and register", async () => {
+        fakeSonos.register.mockResolvedValue(false);
+
+        expect(await registrar(bonobUrl)()).toEqual(
+          false
+        );
+      });
+    });
+  });
+});

tests/scenarios.test.ts

@@ -9,6 +9,7 @@ import {
   GetMetadataResponse,
 } from "../src/smapi";
 import {
+  aDevice,
   BLONDIE,
   BOB_MARLEY,
   getAppLinkMessage,
@@ -19,7 +20,7 @@ import { InMemoryMusicService } from "./in_memory_music_service";
 import { InMemoryLinkCodes } from "../src/link_codes";
 import { Credentials } from "../src/music_service";
 import makeServer from "../src/server";
-import { Service, bonobService, SONOS_DISABLED } from "../src/sonos";
+import { Service, bonobService, Sonos } from "../src/sonos";
 import supersoap from "./supersoap";
 import url, { URLBuilder } from "../src/url_builder";
 
@@ -32,9 +33,10 @@ class LoggedInSonosDriver {
     this.client = client;
     this.token = token;
     this.client.addSoapHeader({
-      credentials: someCredentials(
+      credentials: someCredentials({
-        this.token.getDeviceAuthTokenResult.authToken
+        token: this.token.getDeviceAuthTokenResult.authToken,
-      ),
+        key: this.token.getDeviceAuthTokenResult.privateKey
+      }),
     });
   }
 
@@ -171,6 +173,17 @@ describe("scenarios", () => {
   );
   const linkCodes = new InMemoryLinkCodes();
 
+  const fakeSonos: Sonos = {
+    devices: () => Promise.resolve([aDevice({
+      name: "device1",
+      ip: "172.0.0.1",
+      port: 4301,
+    })]),
+    services: () => Promise.resolve([]),
+    remove: () => Promise.resolve(true),
+    register: () => Promise.resolve(true),
+  };
+
   beforeEach(() => {
     musicService.clear();
     linkCodes.clear();
@@ -255,11 +268,13 @@ describe("scenarios", () => {
     const bonobUrl = url("http://localhost:1234");
     const bonob = bonobService("bonob", 123, bonobUrl);
     const server = makeServer(
-      SONOS_DISABLED,
+      fakeSonos,
       bonob,
       bonobUrl,
       musicService,
-      linkCodes
+      {
+        linkCodes: () => linkCodes,
+      }
     );
 
     const sonosDriver = new SonosDriver(server, bonobUrl, bonob);
@@ -271,11 +286,13 @@ describe("scenarios", () => {
     const bonobUrl = url("http://localhost:1234/");
     const bonob = bonobService("bonob", 123, bonobUrl);
     const server = makeServer(
-      SONOS_DISABLED,
+      fakeSonos,
       bonob,
       bonobUrl,
       musicService,
-      linkCodes
+      {
+        linkCodes: () => linkCodes
+      }
     );
 
     const sonosDriver = new SonosDriver(server, bonobUrl, bonob);
@@ -287,11 +304,13 @@ describe("scenarios", () => {
     const bonobUrl = url("http://localhost:1234/context-for-bonob");
     const bonob = bonobService("bonob", 123, bonobUrl);
     const server = makeServer(
-      SONOS_DISABLED,
+      fakeSonos,
       bonob,
       bonobUrl,
       musicService,
-      linkCodes
+      {
+        linkCodes: () => linkCodes
+      }
     );
 
     const sonosDriver = new SonosDriver(server, bonobUrl, bonob);

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(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(true, undefined).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(true, "").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(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(true, 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(true, "").devices()).toEqual([]);
+        expect(await sonos({ enabled: true, seedHost: "" }).devices()).toEqual([]);
       });
     });
   });

tests/subsonic.test.ts

@@ -0,0 +1,398 @@
+import { Md5 } from "ts-md5/dist/md5";
+import { v4 as uuid } from "uuid";
+
+import {  pipe } from "fp-ts/lib/function";
+import { taskEither as TE, task as T, either as E } from "fp-ts";
+
+import {
+  Subsonic,
+  t,
+  appendMimeTypeToClientFor,
+  PingResponse,
+  parseToken,
+  asToken,
+  SubsonicCredentials,
+} from "../src/subsonic";
+
+import axios from "axios";
+jest.mock("axios");
+
+import randomstring from "randomstring";
+jest.mock("randomstring");
+
+import {
+  AuthFailure,
+} from "../src/music_service";
+import {
+  aTrack,
+} from "./builders";
+
+describe("t", () => {
+  it("should be an md5 of the password and the salt", () => {
+    const p = "password123";
+    const s = "saltydog";
+    expect(t(p, s)).toEqual(Md5.hashStr(`${p}${s}`));
+  });
+});
+
+describe("appendMimeTypeToUserAgentFor", () => {
+  describe("when empty array", () => {
+    it("should return bonob", () => {
+      expect(appendMimeTypeToClientFor([])(aTrack())).toEqual("bonob");
+    });
+  });
+
+  describe("when contains some mimeTypes", () => {
+    const streamUserAgent = appendMimeTypeToClientFor([
+      "audio/flac",
+      "audio/ogg",
+    ]);
+
+    describe("and the track mimeType is in the array", () => {
+      it("should return bonob+mimeType", () => {
+        expect(streamUserAgent(aTrack({ mimeType: "audio/flac" }))).toEqual(
+          "bonob+audio/flac"
+        );
+        expect(streamUserAgent(aTrack({ mimeType: "audio/ogg" }))).toEqual(
+          "bonob+audio/ogg"
+        );
+      });
+    });
+
+    describe("and the track mimeType is not in the array", () => {
+      it("should return bonob", () => {
+        expect(streamUserAgent(aTrack({ mimeType: "audio/mp3" }))).toEqual(
+          "bonob"
+        );
+      });
+    });
+  });
+});
+
+export const ok = (data: string | object) => ({
+  status: 200,
+  data,
+});
+
+export const subsonicOK = (body: any = {}) => ({
+  "subsonic-response": {
+    status: "ok",
+    version: "1.16.1",
+    type: "subsonic",
+    serverVersion: "0.45.1 (c55e6590)",
+    ...body,
+  },
+});
+
+
+export const error = (code: string, message: string) => ({
+  "subsonic-response": {
+    status: "failed",
+    version: "1.16.1",
+    type: "subsonic",
+    serverVersion: "0.45.1 (c55e6590)",
+    error: { code, message },
+  },
+});
+
+export const EMPTY = {
+  "subsonic-response": {
+    status: "ok",
+    version: "1.16.1",
+    type: "subsonic",
+    serverVersion: "0.45.1 (c55e6590)",
+  },
+};
+
+export const FAILURE = {
+  "subsonic-response": {
+    status: "failed",
+    version: "1.16.1",
+    type: "subsonic",
+    serverVersion: "0.45.1 (c55e6590)",
+    error: { code: 10, message: 'Missing required parameter "v"' },
+  },
+};
+
+const pingJson = (pingResponse: Partial<PingResponse> = {}) => ({
+  "subsonic-response": {
+    status: "ok",
+    version: "1.16.1",
+    type: "subsonic",
+    serverVersion: "0.45.1 (c55e6590)",
+    ...pingResponse
+  }
+})
+
+const PING_OK = pingJson({ status: "ok" });
+
+describe("Subsonic", () => {
+  const mockAxios = axios as unknown as jest.Mock;
+
+  const url = "http://127.0.0.22:4567";
+  const baseURL = url;
+  const username = `user1-${uuid()}`;
+  const password = `pass1-${uuid()}`;
+  const salt = "saltysalty";
+
+  const streamClientApplication = jest.fn();
+  const subsonic = new Subsonic(
+    url,
+    streamClientApplication
+  );
+
+  const mockRandomstring = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+
+    randomstring.generate = mockRandomstring;
+
+    mockRandomstring.mockReturnValue(salt);
+  });
+
+  const authParams = {
+    u: username,
+    v: "1.16.1",
+    c: "bonob",
+    t: t(password, salt),
+    s: salt,
+  };
+
+  const authParamsPlusJson = {
+    ...authParams,
+    f: "json",
+  };
+
+  const headers = {
+    "User-Agent": "bonob",
+  };
+
+  const tokenFor = (credentials: Partial<SubsonicCredentials>) => pipe(
+    subsonic.generateToken({
+      username: "some username",
+      password: "some password",
+      bearer: undefined,
+      type: "subsonic",
+      ...credentials
+    }),
+    TE.fold(e => { throw e }, T.of)
+  )
+
+  describe("generateToken", () => {
+    describe("when the credentials are valid", () => {
+      describe("when the backend is generic subsonic", () => {
+        it("should be able to generate a token and then login using it", async () => {
+          (mockAxios as jest.Mock).mockResolvedValue(ok(PING_OK));
+  
+          const token = await tokenFor({
+            username,
+            password,
+          })()
+  
+          expect(token.serviceToken).toBeDefined();
+          expect(token.nickname).toEqual(username);
+          expect(token.userId).toEqual(username);
+  
+          expect(parseToken(token.serviceToken)).toEqual({ username, password, type: PING_OK["subsonic-response"].type })
+  
+          expect(mockAxios).toHaveBeenCalledWith({
+            method: 'get',
+            baseURL,
+            url: `/rest/ping.view`,
+            params: authParamsPlusJson,
+            headers,
+          });
+        });
+
+        it("should store the type of the subsonic server on the token", async () => {
+          const type = "someSubsonicClone";
+          mockAxios.mockResolvedValue(ok(pingJson({ type })));
+  
+          const token = await tokenFor({
+            username,
+            password,
+          })()
+  
+          expect(token.serviceToken).toBeDefined();
+          expect(token.nickname).toEqual(username);
+          expect(token.userId).toEqual(username);
+  
+          expect(parseToken(token.serviceToken)).toEqual({ username, password, type })
+  
+          expect(mockAxios).toHaveBeenCalledWith({
+            method: 'get',
+            baseURL,
+            url: `/rest/ping.view`,
+            params: authParamsPlusJson,
+            headers,
+          });
+        });
+      });
+
+      describe("when the backend is navidrome", () => {
+        it("should login to nd and get the nd bearer token", async () => {
+          const navidromeToken = `nd-${uuid()}`;
+
+          mockAxios
+            .mockResolvedValueOnce(ok(pingJson({ type: "navidrome" })))
+            .mockResolvedValueOnce(ok({ token: navidromeToken }));
+  
+          const token = await tokenFor({
+            username,
+            password,
+          })()
+  
+          expect(token.serviceToken).toBeDefined();
+          expect(token.nickname).toEqual(username);
+          expect(token.userId).toEqual(username);
+  
+          expect(parseToken(token.serviceToken)).toEqual({ username, password, type: "navidrome", bearer: navidromeToken })
+  
+          expect(mockAxios).toHaveBeenCalledWith({
+            method: 'get',
+            baseURL,
+            url: `/rest/ping.view`,
+            params: authParamsPlusJson,
+            headers,
+          });
+          expect(mockAxios).toHaveBeenCalledWith({
+            method: 'post',
+            baseURL,
+            url: `/auth/login`,
+            data: {
+              username,
+              password,
+            }
+          });
+        });
+      });
+    });
+
+    describe("when the credentials are not valid", () => {
+      it("should be able to generate a token and then login using it", async () => {
+        mockAxios.mockResolvedValue({
+          status: 200,
+          data: error("40", "Wrong username or password"),
+        });
+
+        const token = await subsonic.generateToken({ username, password })();
+        expect(token).toEqual(E.left(new AuthFailure("Subsonic error:Wrong username or password")));
+      });
+    });
+  });
+
+  describe("refreshToken", () => {
+    describe("when the credentials are valid", () => {
+      describe("when the backend is generic subsonic", () => {
+        it("should be able to generate a token and then login using it", async () => {
+          const type = `subsonic-clone-${uuid()}`;
+          mockAxios.mockResolvedValue(ok(pingJson({ type })));
+  
+          const credentials = { username, password, type: "foo", bearer: undefined };
+          const originalToken = asToken(credentials)
+
+          const refreshedToken = await pipe(
+            subsonic.refreshToken(originalToken),
+            TE.fold(e => { throw e }, T.of)
+          )();
+  
+          expect(refreshedToken.serviceToken).toBeDefined();
+          expect(refreshedToken.nickname).toEqual(credentials.username);
+          expect(refreshedToken.userId).toEqual(credentials.username);
+  
+          expect(parseToken(refreshedToken.serviceToken)).toEqual({ username, password, type })
+  
+          expect(mockAxios).toHaveBeenCalledWith({
+            method:'get',
+            baseURL,
+            url: `/rest/ping.view`,
+            params: authParamsPlusJson,
+            headers,
+          });
+        });
+      });
+
+      describe("when the backend is navidrome", () => {
+        it("should login to nd and get the nd bearer token", async () => {
+          const navidromeToken = `nd-${uuid()}`;
+
+          mockAxios
+            .mockResolvedValueOnce(ok(pingJson({ type: "navidrome" })))
+            .mockResolvedValueOnce(ok({ token: navidromeToken }));
+  
+          const credentials = { username, password, type: "navidrome", bearer: undefined };
+          const originalToken = asToken(credentials)
+
+          const refreshedToken = await pipe(
+            subsonic.refreshToken(originalToken),
+            TE.fold(e => { throw e }, T.of)
+          )();
+  
+          expect(refreshedToken.serviceToken).toBeDefined();
+          expect(refreshedToken.nickname).toEqual(username);
+          expect(refreshedToken.userId).toEqual(username);
+  
+          expect(parseToken(refreshedToken.serviceToken)).toEqual({ username, password, type: "navidrome", bearer: navidromeToken })
+  
+          expect(mockAxios).toHaveBeenCalledWith({
+            method: 'get',
+            baseURL,
+            url: `/rest/ping.view`,
+            params: authParamsPlusJson,
+            headers,
+          });
+          expect(mockAxios).toHaveBeenCalledWith({
+            method: 'post',
+            baseURL,
+            url: `/auth/login`,
+            data: {
+              username,
+              password,
+            }
+          });
+        });
+      });
+    });
+
+    describe("when the credentials are not valid", () => {
+      it("should be able to generate a token and then login using it", async () => {
+        mockAxios.mockResolvedValue({
+          status: 200,
+          data: error("40", "Wrong username or password"),
+        });
+
+        const credentials = { username, password, type: "foo", bearer: undefined };
+        const originalToken = asToken(credentials)
+
+        const token = await subsonic.refreshToken(originalToken)();
+        expect(token).toEqual(E.left(new AuthFailure("Subsonic error:Wrong username or password")));
+      });
+    });
+  });
+
+  describe("login", () => {
+    describe("when the token is for generic subsonic", () => {
+      it("should return a subsonic client", async () => {
+        const client = await subsonic.login(asToken({ username: "foo", password: "bar", type: "subsonic", bearer: undefined }));
+        expect(client.flavour()).toEqual("subsonic");
+      });
+    });
+
+    describe("when the token is for navidrome", () => {
+      it("should return a navidrome client", async () => {
+        const client = await subsonic.login(asToken({ username: "foo", password: "bar", type: "navidrome", bearer: undefined }));
+        expect(client.flavour()).toEqual("navidrome");
+      });
+    });
+
+    describe("when the token is for gonic", () => {
+      it("should return a subsonic client", async () => {
+        const client = await subsonic.login(asToken({ username: "foo", password: "bar", type: "gonic", bearer: undefined }));
+        expect(client.flavour()).toEqual("subsonic");
+      });
+    });
+  });
+
+});

tests/subsonic/navidrome.test.ts

@@ -0,0 +1,78 @@
+import { v4 as uuid } from "uuid";
+import { DODGY_IMAGE_NAME } from "../../src/subsonic";
+import { artistImageURN } from "../../src/subsonic/generic";
+import { artistSummaryFromNDArtist } from "../../src/subsonic/navidrome";
+
+
+describe("artistSummaryFromNDArtist", () => {
+  describe("when the orderArtistName is undefined", () => {
+    it("should use name", () => {
+      const artist = {
+        id: uuid(),
+        name: `name ${uuid()}`,
+        orderArtistName: undefined,
+        largeImageUrl: 'http://example.com/something.jpg'
+      }
+      expect(artistSummaryFromNDArtist(artist)).toEqual({
+        id: artist.id,
+        name: artist.name,
+        sortName: artist.name,
+        image: artistImageURN({ artistId: artist.id, artistImageURL: artist.largeImageUrl })
+      })
+    });
+  });
+
+  describe("when the artist image is valid", () => {
+    it("should create an ArtistSummary with Sortable", () => {
+      const artist = {
+        id: uuid(),
+        name: `name ${uuid()}`,
+        orderArtistName: `orderArtistName ${uuid()}`,
+        largeImageUrl: 'http://example.com/something.jpg'
+      }
+      expect(artistSummaryFromNDArtist(artist)).toEqual({
+        id: artist.id,
+        name: artist.name,
+        sortName: artist.orderArtistName,
+        image: artistImageURN({ artistId: artist.id, artistImageURL: artist.largeImageUrl })
+      })
+    });
+  });
+
+  describe("when the artist image is not valid", () => {
+    it("should create an ArtistSummary with Sortable", () => {
+      const artist = {
+        id: uuid(),
+        name: `name ${uuid()}`,
+        orderArtistName: `orderArtistName ${uuid()}`,
+        largeImageUrl: `http://example.com/${DODGY_IMAGE_NAME}`
+      }
+
+      expect(artistSummaryFromNDArtist(artist)).toEqual({
+        id: artist.id,
+        name: artist.name,
+        sortName: artist.orderArtistName,
+        image: artistImageURN({ artistId: artist.id, artistImageURL: artist.largeImageUrl })
+      });
+    });
+  });
+
+  describe("when the artist image is missing", () => {
+    it("should create an ArtistSummary with Sortable", () => {
+      const artist = {
+        id: uuid(),
+        name: `name ${uuid()}`,
+        orderArtistName: `orderArtistName ${uuid()}`,
+        largeImageUrl: undefined
+      }
+
+      expect(artistSummaryFromNDArtist(artist)).toEqual({
+        id: artist.id,
+        name: artist.name,
+        sortName: artist.orderArtistName,
+        image: artistImageURN({ artistId: artist.id, artistImageURL: artist.largeImageUrl })
+      });
+    });
+  });
+});
+

tests/supersoap.ts

@@ -1,7 +1,10 @@
 import { Express } from "express";
+import { ReadStream } from "fs";
+import { IHttpClient } from "soap";
 import request from "supertest";
+import * as req from "axios";
 
-function supersoap(server: Express) {
+function supersoap(server: Express): IHttpClient {
   return {
     request: (
       rurl: string,
@@ -15,12 +18,19 @@ function supersoap(server: Express) {
         data == null
           ? request(server).get(withoutHost).send()
           : request(server).post(withoutHost).send(data);
-      req
+      return req
         .set(exheaders || {})
         .then((response) => callback(null, response, response.text))
         .catch(callback);
     },
-  }
+
+    requestStream: (
+      _: string,
+      _2: any
+    ): req.AxiosPromise<ReadStream> => {
+      throw "Not Implemented!!";
+    },
+  };
 }
 
-export default supersoap
+export default supersoap;

tests/tsconfig.json

@@ -20,4 +20,4 @@
   "include": [
     "./**/*.ts"
   ]
-  }
+}

tests/url_builder.test.ts

@@ -138,15 +138,19 @@ describe("URLBuilder", () => {
       describe("with URLSearchParams", () => {
         it("should return a new URLBuilder with the new search params appended", () => {
           const original = url("https://example.com/some-path?a=b&c=d");
+          const searchParams = new URLSearchParams({ x: "y" });
+          searchParams.append("z", "1");
+          searchParams.append("z", "2");
+
           const updated = original.append({
-            searchParams: new URLSearchParams({ x: "y", z: "1" }),
+            searchParams,
           });
     
           expect(original.href()).toEqual("https://example.com/some-path?a=b&c=d");
           expect(`${original.searchParams()}`).toEqual("a=b&c=d")
     
-          expect(updated.href()).toEqual("https://example.com/some-path?a=b&c=d&x=y&z=1");
+          expect(updated.href()).toEqual("https://example.com/some-path?a=b&c=d&x=y&z=1&z=2");
-          expect(`${updated.searchParams()}`).toEqual("a=b&c=d&x=y&z=1")
+          expect(`${updated.searchParams()}`).toEqual("a=b&c=d&x=y&z=1&z=2")
         });
       });
     });
@@ -168,15 +172,19 @@ describe("URLBuilder", () => {
     
         it("should return a new URLBuilder with the new search params", () => {
           const original = url("https://example.com/some-path?a=b&c=d");
+          const searchParams = new URLSearchParams({ x: "y" });
+          searchParams.append("z", "1");
+          searchParams.append("z", "2");
+
           const updated = original.with({
-            searchParams: { x: "y", z: "1" },
+            searchParams,
           });
     
           expect(original.href()).toEqual("https://example.com/some-path?a=b&c=d");
           expect(`${original.searchParams()}`).toEqual("a=b&c=d")
     
-          expect(updated.href()).toEqual("https://example.com/some-path?x=y&z=1");
+          expect(updated.href()).toEqual("https://example.com/some-path?x=y&z=1&z=2");
-          expect(`${updated.searchParams()}`).toEqual("x=y&z=1")
+          expect(`${updated.searchParams()}`).toEqual("x=y&z=1&z=2")
         });
       });
 
@@ -196,15 +204,19 @@ describe("URLBuilder", () => {
     
         it("should return a new URLBuilder with the new search params", () => {
           const original = url("https://example.com/some-path?a=b&c=d");
+          const searchParams = new URLSearchParams({ x: "y" });
+          searchParams.append("z", "1");
+          searchParams.append("z", "2");
+
           const updated = original.with({
-            searchParams: new URLSearchParams({ x: "y", z: "1" }),
+            searchParams,
           });
     
           expect(original.href()).toEqual("https://example.com/some-path?a=b&c=d");
           expect(`${original.searchParams()}`).toEqual("a=b&c=d")
     
-          expect(updated.href()).toEqual("https://example.com/some-path?x=y&z=1");
+          expect(updated.href()).toEqual("https://example.com/some-path?x=y&z=1&z=2");
-          expect(`${updated.searchParams()}`).toEqual("x=y&z=1")
+          expect(`${updated.searchParams()}`).toEqual("x=y&z=1&z=2")
         });
       });
     });

tests/utils.test.ts

@@ -0,0 +1,106 @@
+import { asURLSearchParams, mask, takeWithRepeats } from "../src/utils";
+
+describe("asURLSearchParams", () => {
+  describe("empty q", () => {
+    it("should return empty params", () => {
+      const q = {};
+      const expected = new URLSearchParams();
+      expect(asURLSearchParams(q)).toEqual(expected);
+    });
+  });
+
+  describe("singular params", () => {
+    it("should append each", () => {
+      const q = {
+        a: 1,
+        b: "bee",
+        c: false,
+        d: true,
+      };
+      const expected = new URLSearchParams();
+      expected.append("a", "1");
+      expected.append("b", "bee");
+      expected.append("c", "false");
+      expected.append("d", "true");
+
+      expect(asURLSearchParams(q)).toEqual(expected);
+    });
+  });
+
+  describe("list params", () => {
+    it("should append each", () => {
+      const q = {
+        a: [1, "two", false, true],
+        b: "yippee",
+      };
+
+      const expected = new URLSearchParams();
+      expected.append("a", "1");
+      expected.append("a", "two");
+      expected.append("a", "false");
+      expected.append("a", "true");
+      expected.append("b", "yippee");
+
+      expect(asURLSearchParams(q)).toEqual(expected);
+    });
+  });
+});
+
+describe("takeWithRepeat", () => {
+  describe("when there is nothing in the input", () => {
+    it("should return an array of undefineds", () => {
+      expect(takeWithRepeats([], 3)).toEqual([undefined, undefined, undefined]);
+    });
+  });
+
+  describe("when there are exactly the amount required", () => {
+    it("should return them all", () => {
+      expect(takeWithRepeats(["a", undefined, "c"], 3)).toEqual([
+        "a",
+        undefined,
+        "c",
+      ]);
+      expect(takeWithRepeats(["a"], 1)).toEqual(["a"]);
+      expect(takeWithRepeats([undefined], 1)).toEqual([undefined]);
+    });
+  });
+
+  describe("when there are less than the amount required", () => {
+    it("should cycle through the ones available", () => {
+      expect(takeWithRepeats(["a", "b"], 3)).toEqual(["a", "b", "a"]);
+      expect(takeWithRepeats(["a", "b"], 5)).toEqual(["a", "b", "a", "b", "a"]);
+    });
+  });
+
+  describe("when there more than the amount required", () => {
+    it("should return the first n items", () => {
+      expect(takeWithRepeats(["a", "b", "c"], 2)).toEqual(["a", "b"]);
+      expect(takeWithRepeats(["a", undefined, "c"], 2)).toEqual([
+        "a",
+        undefined,
+      ]);
+    });
+  });
+});
+
+describe("mask", () => {
+  it.each([
+    [{}, ["a", "b"], {}],
+    [{ foo: "bar" }, ["a", "b"], { foo: "bar" }],
+    [{ a: 1 }, ["a", "b"], { a: "****" }],
+    [{ a: 1, b: "dog" }, ["a", "b"], { a: "****", b: "****" }],
+    [
+      { a: 1, b: "dog", foo: "bar" },
+      ["a", "b"],
+      { a: "****", b: "****", foo: "bar" },
+    ],
+  ])(
+    "masking of %s, keys = %s, should result in %s",
+    (original: any, keys: string[], expected: any) => {
+      const copyOfOrig = JSON.parse(JSON.stringify(original));
+      const masked = mask(original, keys);
+      expect(masked).toEqual(expected);
+      expect(original).toEqual(copyOfOrig);
+    }
+  );
+});

tsconfig.json

@@ -54,7 +54,7 @@
     ]
      /* List of folders to include type definitions from. */,
     // "types": ["src/customTypes/scale-that-svg.d.ts"],                           /* Type declaration files to be included in compilation. */
-    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
     // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */

web/icons/Africa-48087.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16">
+  <path d="M4.96 2.126l.613.416c.301.204.663.321.982.425.158.051.396.128.466.173l.035.023.01.006c.13.084.309.2.535.272C7.748 3.488 7.906 3.513 8.06 3.513c.339 0 .651-.12.881-.339.274.105.601.224.972.25.038.135.068.273.1.423.057.267.122.569.239.889.089.259.208.609.491.91.17.203.355.324.48.407l.031.021c.029.04.076.119.111.179.075.128.166.282.29.437.124.187.296.347.49.456-.088.076-.18.15-.278.222-.365.24-.64.498-.839.788L11.004 8.19l-.02.035-.027.047c-.217.377-.542.941-.423 1.627.034.285.108.529.174.745.017.055.034.11.05.166l-.022.011-.034.02c-.096.056-.938.57-.938 1.369 0 .095.01.182.027.262-.218.2-.351.476-.354.785-.104.14-.181.278-.247.397-.023.042-.046.085-.071.126-.071.037-.216.084-.395.12-.093-.214-.222-.361-.308-.457-.158-.228-.362-.396-.544-.545-.039-.032-.089-.073-.131-.109-.014-.118-.032-.235-.059-.34-.099-.385-.315-.667-.489-.894-.032-.041-.073-.095-.105-.14.02-.049.046-.108.068-.156.099-.221.234-.523.265-.894l.004-.043v-.043c0-.499-.127-.942-.395-1.371.057-.163.105-.375.093-.624C7.139 8.2 7.158 8.088 7.158 7.957c0-.008-.022-.643-.291-1.164C6.855 6.754 6.841 6.716 6.825 6.678 6.626 6.218 6.181 5.985 5.5 5.985c-.04 0-.09 0-.148 0-.586 0-1.988 0-2.326-.001C2.999 5.971 2.972 5.955 2.946 5.94L2.741 5.824C2.63 5.762 2.451 5.662 2.269 5.557c.006-.015.011-.03.016-.045.221-.641.094-1.106-.069-1.397.039-.033.081-.064.126-.094l.06-.034c.237-.13.73-.402.92-1.048.023-.09.036-.175.042-.252.069-.054.145-.12.219-.201.005 0 .01 0 .014 0 .419 0 .775-.15 1.034-.259C4.678 2.209 4.72 2.191 4.761 2.175 4.827 2.156 4.893 2.14 4.96 2.126M5.889 1C5.382 1.035 4.911 1.071 4.441 1.211c-.25.091-.553.26-.841.26-.046 0-.092-.004-.137-.014-.109-.035-.181-.105-.29-.105-.109 0-.217.035-.254.105-.036.071 0 .105 0 .176C2.883 1.913 2.448 1.984 2.376 2.23c-.036.141 0 .316-.036.457C2.268 2.932 2.014 3.038 1.833 3.144c-.326.211-.579.457-.76.808C1.036 4.022 1 4.093 1 4.162c0 .141.217.281.29.386C1.434 4.725 1.398 4.97 1.326 5.181c-.073.211-.217.386-.29.562C1 5.814 1 5.885 1 5.919c.036.035.073.07.109.106.326.246 1.145.686 1.326.792.157.091.341.18.505.182C3 7 5 7 5.5 7c0 0 .5 0 .375.133C6.02 7.238 6.142 7.817 6.142 7.957c0 .14-.073.246-.036.352.036.387-.349.597-.096.913.254.316.398.632.398 1.054-.036.422-.362.773-.362 1.194 0 .457.543.808.652 1.23.036.141.036.316.073.457.073.316.639.597.82.878.073.106.181.175.217.316 0 .071 0 .141 0 .211 0 .175.145.351.326.422C8.166 14.995 8.201 15 8.238 15c.09 0 .192-.025.294-.05.398-.035 1.123-.175 1.376-.527.158-.219.254-.492.434-.668.109-.105.217-.211.181-.351-.036-.071-.073-.106-.073-.141 0-.071.145-.106.217-.106.073 0 .145 0 .217 0 .181-.035.254-.246.217-.386-.036-.175-.217-.281-.29-.457-.036-.035-.036-.07-.036-.105 0-.141.254-.387.434-.492.217-.105.471-.211.579-.422.073-.175.073-.351 0-.527-.073-.352-.217-.668-.254-1.019-.073-.351.145-.703.326-1.019.145-.211.362-.387.579-.527C13.167 7.677 13.891 6.878 14 6c-.254.211-.688.272-1.05.306-.109 0-.217 0-.29-.035-.073-.035-.145-.106-.181-.175C12.262 5.85 12.153 5.498 11.9 5.288c-.145-.106-.29-.175-.398-.317-.145-.141-.217-.352-.29-.563-.217-.598-.217-1.09-.471-1.687-.073-.14-.145-.316-.29-.316-.073 0-.145 0-.254 0-.045.007-.091.009-.136.009-.456 0-.912-.296-1.373-.391C8.645 2.009 8.594 2 8.544 2c-.07 0-.138.017-.18.058C8.256 2.164 8.348 2.335 8.24 2.44 8.197 2.481 8.13 2.498 8.06 2.498c-.049 0-.101-.008-.146-.023C7.805 2.44 7.701 2.369 7.592 2.299 7.23 2.053 6.506 1.948 6.144 1.702c.073-.105.109-.211.145-.317.036-.105-.038-.28-.146-.35C6.07 1 5.961 1 5.889 1L5.889 1zM13.875 10c-.099.215-.232.465-.398.571-.132.071-.299.143-.365.285-.099.179 0 .393-.033.571 0 .071-.033.143-.066.215-.033.179 0 .393.066.571.033.107.099.25.199.285.066 0 .166-.035.232-.107.066-.071.132-.215.166-.321s.033-.215.033-.321c.033-.321.199-.643.266-.965.033-.215.033-.429 0-.643C13.942 10.071 13.909 10 13.875 10l.017.035c.009.009.017.018.017.035l-.017-.035C13.884 10.027 13.875 10.018 13.875 10L13.875 10z"/>
+</svg>

web/icons/Audio-Wave-1892.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26">
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="1.9" d="M19 3L19 22M22 9L22 16M25 11L25 14M16 7L16 18M10 9L10 16M13 11L13 14M7 4L7 21M1 11L1 14M4 8L4 17"/>
+</svg>

web/icons/Binoculars-14310.svg

@@ -1 +0,0 @@
-<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="M7 15A6 6 0 1 0 7 27 6 6 0 1 0 7 15zM25 15A6 6 0 1 0 25 27 6 6 0 1 0 25 15zM16 18A2 2 0 1 0 16 22 2 2 0 1 0 16 18z"/><path fill="none" stroke="#000" stroke-miterlimit="10" stroke-width="2" d="M30.5,18.6l-2.3-6.4C27.5,10.5,25.9,9.2,24,9v0c0-1.7-1.3-3-3-3s-3,1.3-3,3h-4c0-1.7-1.3-3-3-3S8,7.3,8,9v0c-1.9,0.2-3.5,1.4-4.2,3.3l-2.3,6.4"/></svg>

web/icons/Blues-113548.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 30 30">
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M4,14c0,0.691,4.925,1,11,1s11-0.309,11-1"/>
+  <path d="M15 12c5.66 0 8-.588 8-.588S22.07 3 19.5 3 17.436 4 15 4s-1.991-1-4.5-1S7 11.412 7 11.412 9.34 12 15 12zM12 24h-2c-1.657 0-3-1.343-3-3v-1c0-1.105.895-2 2-2h3c1.105 0 2 .895 2 2v2C14 23.105 13.105 24 12 24zM16 22v-2c0-1.105.895-2 2-2h3c1.105 0 2 .895 2 2v1c0 1.657-1.343 3-3 3h-2C16.895 24 16 23.105 16 22z"/>
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M13 20L17 20"/>
+</svg>

web/icons/Book-22940.svg

@@ -0,0 +1,4 @@
+<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="M25,27H9c-1.105,0-2-0.895-2-2V7c0-1.105,0.895-2,2-2h16V27z"/>
+  <path fill="none" stroke="#000" stroke-miterlimit="10" stroke-width="2" d="M7 25c0-1.105.895-2 2-2h16M11 10L22 10"/>
+</svg>

web/icons/C-3PO-31823.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" id="c3po" viewBox="0 0 48 48">
+  <path fill="#f4b10b" d="M16 39h16v6H16V39zM39 18C39 18 39 18.1 39 18c-.3-3.8-1.8-7.2-4.2-9.8-1.8-1.9-4.1-3.1-6.8-3.8-.8-.4-1.6-.8-2.3-1.4l-1.1-.9c-.4-.3-.9-.3-1.3 0l-1.1.9c-.7.6-1.5 1-2.3 1.4-2.6.6-4.9 1.9-6.7 3.8-2.5 2.5-3.9 5.9-4.2 9.7 0 0 0 0-.1 0 0 0-2 1.7-2 2 .1 2.6.4 4.8.8 7 .1.3 2.3 1 2.3 1 .2 1 .5 2 .8 3l1.1 2h24l1.1-2c.3-1 .5-2 .8-3 0 0 2.2-.7 2.3-1 .5-2.2.8-4.4.9-7C41 19.7 39 18 39 18z"/>
+  <path fill="#b57f08" d="M12,32h24v4H12V32z"/>
+  <path fill="#ffd600" d="M24,42c-3.7,0-6.2-1.5-7.7-2.7c-0.8-0.7-1.4-1.6-1.7-2.6c-1.3-4.9-3.5-10.6-3.6-17 C10.8,12.5,15.3,6,24,6s13.2,6.5,13,13.7c-0.2,6.3-2.3,12.1-3.6,17c-0.3,1-0.8,2-1.7,2.6C30.2,40.5,27.7,42,24,42z"/>
+  <path fill="#684903" d="M26,36h-4c-0.6,0-1-0.4-1-1s0.4-1,1-1h4c0.6,0,1,0.4,1,1S26.6,36,26,36z"/>
+  <path fill="#ffc107" d="M27,32l-3-3l-3,3l-6-6l4-2h10l4,2L27,32z"/>
+  <path fill="#f4b10b" d="M29,18c-2.8,0-4.3,2.3-5,3c-0.7-0.7-2.2-3-5-3s-5,2.2-5,5s2.2,5,5,5c2.9,0,5-3,5-3s2.1,3,5,3 c2.8,0,5-2.2,5-5S31.8,18,29,18z"/>
+  <path fill="#ffea00" d="M22 23c0 1.7-1.3 3-3 3s-3-1.3-3-3 1.3-3 3-3S22 21.3 22 23zM32 23c0 1.7-1.3 3-3 3s-3-1.3-3-3 1.3-3 3-3S32 21.3 32 23z"/>
+  <path fill="#684903" d="M30,23c0,0.6-0.4,1-1,1s-1-0.4-1-1s0.4-1,1-1S30,22.4,30,23z"/>
+  <path fill="#ffd600" d="M25,4c0,0.6-0.4,1-1,1s-1-0.4-1-1s0.4-1,1-1S25,3.4,25,4z"/>
+  <path fill="#684903" d="M20,23c0,0.6-0.4,1-1,1s-1-0.4-1-1s0.4-1,1-1S20,22.4,20,23z"/>
+  <path fill="#dd9f05" d="M12,38c-0.6,0-1-0.4-1-1v-6c0-0.6,0.4-1,1-1s1,0.4,1,1v6C13,37.6,12.6,38,12,38z"/>
+  <path fill="#ffd600" d="M33,46H15c-0.6,0-1-0.4-1-1s0.4-1,1-1h18c0.6,0,1,0.4,1,1S33.6,46,33,46z"/>
+  <path fill="#dd9f05" d="M36,38c-0.6,0-1-0.4-1-1v-6c0-0.6,0.4-1,1-1s1,0.4,1,1v6C37,37.6,36.6,38,36,38z"/>
+</svg>

web/icons/Cannabis-33270.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <path d="M28,18.77v-2.557l-1.875-0.256c-0.092-0.013-1.249-0.121-2.58-0.127c1.445-2.708,2-5.083,2.006-5.111l0.311-1.358l-1.166-0.762l-0.071-0.046l-0.993-0.649l-1.046,0.56c-0.252,0.135-1.802,0.987-3.357,2.336c-0.293-2.623-0.967-4.824-1.245-5.53L17.488,4h-1.363h-0.219h-1.33l-0.514,1.226c-0.058,0.138-1.26,3.041-1.557,6.491c-1.651-1.342-4.443-2.884-4.443-2.884l-2.107,1.644l0.201,1.035C6.373,12.529,7.453,15,7.453,15C6.333,15,4,15.393,4,15.393v2.644c0,0,1.875,1.587,4.036,2.731c-0.092,0.087-0.152,0.149-0.179,0.177l-0.94,0.804l0.279,1.075l0.296,1.142L8.645,24.3c0.167,0.043,1.237,0.258,2.41,0.258c0.827,0,1.61-0.106,2.328-0.314c0.075-0.02,0.15-0.041,0.223-0.063c0.211,1.205,0.468,2.166,0.517,2.346L14.527,28H21c-1.292-1.333-2.18-3.417-2.18-3.417c-0.01-0.013-0.019-0.027-0.029-0.042c0.792,0.333,1.833,0.458,2.803,0.481l1.362-0.083l0.547-0.895l0.538-0.919c0,0-0.458-1.083-0.979-1.549c1.541-0.57,3.388-1.408,4.172-2.155L28,18.77z M21.5,19.986c-0.583,0.167-2.268,0.396-2.896,0.473c0,0,2.415,1.398,2.811,2.44c-0.001,0.01,0.006,0.023,0.005,0.034c-0.023-0.001-0.044-0.015-0.068-0.013c-1.875,0.146-4.823-1.502-5.161-1.79c0.072,1.068,0.455,3.57,1.356,4.838L17.519,26h-1.467c0,0-1.095-2.928-1.021-4.969c-0.513,0.437-1.105,1.001-2.205,1.293c-0.609,0.177-1.226,0.235-1.771,0.235c-0.858,0-1.715-0.144-1.913-0.195l-0.01-0.04c0,0,1.422-1.311,3.255-1.748c0.22-0.073,0.44-0.146,0.66-0.146c-0.733-0.146-1.466-0.291-2.273-0.583c-2.406-0.888-4.471-2.46-4.665-2.656L6.105,17.15c0,0,0.767-0.042,1.348-0.042c0.944,0,2.493,0.112,4.127,0.698c0.44,0.146,0.88,0.292,1.247,0.51c-0.607-0.536-3.639-3.066-4.539-6.874l0,0c0,0,4.4,2.266,6.691,5.891c-0.333-1.583-0.539-3.305-0.539-4.131C14.44,9.496,15.906,6,15.906,6h0.219c0.345,0.88,1.246,3.995,1.246,7.203c0,1.087-0.303,3.604-0.365,4.093c0.163-0.388,0.777-1.594,1.607-2.858c1.599-2.434,4.919-4.211,4.919-4.211l0.071,0.046c-0.115,0.501-0.891,3.306-2.637,6.002c-0.435,0.672-1.79,1.949-1.906,2.041c0.205-0.052,0.911-0.329,3.007-0.447c0.504-0.029,0.965-0.039,1.375-0.039c1.295,0,2.411,0.108,2.411,0.108l0.003,0.035C25.244,18.554,23.259,19.482,21.5,19.986z"/>
+</svg>

web/icons/Chapel-69791.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16">
+  <path fill="none" stroke="#000" stroke-linejoin="round" stroke-miterlimit="10" d="M10.5 7.125L10.494 3.529 7.494 0.5 4.5 3.5 4.5 7.125"/>
+  <path fill="none" stroke="#000" stroke-linejoin="round" stroke-miterlimit="10" d="M2.5 13.5L2.5 8.5 7.5 5.5 12.5 8.5 12.5 13.5M7 13.5L2 13.5"/>
+  <path fill="none" stroke="#000" stroke-linejoin="round" stroke-miterlimit="10" d="M8.5 13.5v-3c0-.552-.448-1-1-1s-1 .448-1 1v3M13 13.5L8 13.5"/>
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M10.5 10.5L10.5 13.5M4.5 10.5L4.5 13.5M7.5 3.5L7.5 5.5"/>
+</svg>

web/icons/Chewbacca-89771.svg

@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" id="chewy" viewBox="0 0 48 48">
+  <path fill="#6d4c41" d="M39,25c0-2,0-0.216,0-2C39,9,34,2,24,2S9,10,9,22c0,1.784,0,1,0,3H39z"/>
+  <path fill="#a1887f" d="M39,25L39,25c0-7-4-12-7-12v-3c-3,0-4,2-4,2V8c0,0-3,1-4,3c-1-2-4-3-4-3s0,1,0,3c0,0-1-1-4-1v3 c-3,0-7,5-7,12v0c0,9-2.375,14.125-3,15h5v5l6-3l3,4l4-3l4,3l3-4l6,3v-5h5C41.375,39.125,39,34,39,25z"/>
+  <path fill="#8d6e63" d="M23 29c-.127 0-.877 0-1 0-6 0-7 6-7 6s2-3 4-3 3 0 3 0c.552 0 1-.448 1-1V29zM25 29c.127 0 .877 0 1 0 6 0 7 6 7 6s-2-3-4-3-3 0-3 0c-.552 0-1-.448-1-1V29z"/>
+  <path fill="#212121" d="M29,36H19c-1.1,0-2-0.9-2-2v0c0-1.1,0.9-2,2-2h10c1.1,0,2,0.9,2,2v0C31,35.1,30.1,36,29,36z"/>
+  <path fill="#fff" d="M19 32L20 34 21 32zM27 32L28 34 29 32zM27 36L26 34 25 36zM23 36L22 34 21 36z"/>
+  <path fill="#424242" d="M27,28c0,0.82-0.67,1.63-2,1.9c-0.3,0.07-0.63,0.1-1,0.1s-0.7-0.03-1-0.1c-1.33-0.27-2-1.08-2-1.9 c0-0.5,1-3,3-3S27,27.5,27,28z"/>
+  <path fill="#212121" d="M23 29.5v.4c-1.33-.27-2-1.08-2-1.9h.5C22.33 28 23 28.67 23 29.5zM27 28c0 .82-.67 1.63-2 1.9v-.4c0-.83.67-1.5 1.5-1.5H27z"/>
+  <path fill="#6d4c41" d="M29,18c-1.657,0-3,1.343-3,3s1.343,3,3,3c5,0,6,2,6,2S35,18,29,18z"/>
+  <path fill="#212121" d="M29 20A1 1 0 1 0 29 22A1 1 0 1 0 29 20Z"/>
+  <path fill="#6d4c41" d="M19,18c1.657,0,3,1.343,3,3s-1.343,3-3,3c-5,0-6,2-6,2S13,18,19,18z"/>
+  <path fill="#212121" d="M19 20A1 1 0 1 0 19 22A1 1 0 1 0 19 20Z"/>
+</svg>

web/icons/Children-78186.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 30 30">
+  <path d="M9 2A3 3 0 1 0 9 8 3 3 0 1 0 9 2zM6 25.967C6 26.537 6.463 27 7.033 27c.544 0 .995-.422 1.031-.965L8.466 20H6V25.967zM9.936 26.036C9.972 26.578 10.423 27 10.967 27 11.537 27 12 26.537 12 25.967V20H9.534L9.936 26.036zM11 10h-.277C10.376 10.595 9.738 11 9 11s-1.376-.405-1.723-1H7c-1.654 0-3 1.346-3 3v6c0 .553.447 1 1 1s1-.447 1-1v-2h6v2c0 .553.447 1 1 1s1-.447 1-1v-6C14 11.346 12.654 10 11 10zM24 19v-6c0-1.657-1.343-3-3-3s-3 1.343-3 3v6H24zM18 22v3.967C18 26.537 18.463 27 19.033 27c.544 0 .995-.422 1.031-.964L20.333 22H18zM21.667 22l.269 4.035C21.972 26.578 22.423 27 22.967 27 23.537 27 24 26.537 24 25.967V22H21.667zM21 2A3 3 0 1 0 21 8 3 3 0 1 0 21 2z"/>
+  <path d="M26.249 6.751c.827.827.749 2.247.749 2.247s-1.42.078-2.247-.749-.749-2.247-.749-2.247S25.422 5.924 26.249 6.751zM17.998 6.002c0 0 .078 1.42-.749 2.247s-2.247.749-2.247.749-.078-1.42.749-2.247S17.998 6.002 17.998 6.002z"/>
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M25,19l-1.515-6.06C23.2,11.8,22.175,11,21,11h0c-1.175,0-2.2,0.8-2.485,1.94L17,19"/>
+  <path d="M24 17L18 17 17 20 25 20z"/>
+</svg>

web/icons/Christmas-Tree-63332.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 30 30" id="christmas">
+    <path d="M21.5 17A1.5 1.5 0 1 0 21.5 20 1.5 1.5 0 1 0 21.5 17zM15 12A2 2 0 1 0 15 16 2 2 0 1 0 15 12zM8.5 17A1.5 1.5 0 1 0 8.5 20 1.5 1.5 0 1 0 8.5 17z"/>
+    <path d="M15 14L13.679 12.498 7.634 17.276 8.5 20 15 20zM23.5 25A1.5 1.5 0 1 0 23.5 28 1.5 1.5 0 1 0 23.5 25z"/>
+    <path d="M15 18A2 2 0 1 0 15 22 2 2 0 1 0 15 18zM6.5 25A1.5 1.5 0 1 0 6.5 28 1.5 1.5 0 1 0 6.5 25zM15 6A1 1 0 1 0 15 8 1 1 0 1 0 15 6zM20 11A1 1 0 1 0 20 13 1 1 0 1 0 20 11z"/>
+    <path d="M15 7L15.645 6.241 20.613 11.21 20 13 15 13zM10 11A1 1 0 1 0 10 13 1 1 0 1 0 10 11zM15.146 1.091l.559 1.133 1.25.182c.133.019.187.183.09.277l-.905.882.214 1.245c.023.133-.117.234-.236.171L15 4.393l-1.118.588c-.119.063-.259-.039-.236-.171l.214-1.245-.905-.882c-.096-.094-.043-.258.09-.277l1.25-.182.559-1.133C14.914.97 15.086.97 15.146 1.091zM16.321 18.5L15 21v7h8.5l.869-2.722L16.321 18.5zM18 26c-.552 0-1-.448-1-1 0-.552.448-1 1-1s1 .448 1 1C19 25.552 18.552 26 18 26zM13.679 18.5l-8.049 6.778L6.5 28H15v-7L13.679 18.5zM13 24c-.552 0-1-.448-1-1 0-.552.448-1 1-1s1 .448 1 1C14 23.552 13.552 24 13 24z"/>
+    <path d="M16.32 12.498L15 14v6h6.5l.866-2.724L16.32 12.498zM17 18c-.552 0-1-.448-1-1 0-.552.448-1 1-1s1 .448 1 1C18 17.552 17.552 18 17 18zM14.355 6.241L9.388 11.21 10 13h5v-3c0 .552-.448 1-1 1s-1-.448-1-1c0-.552.448-1 1-1s1 .448 1 1V7L14.355 6.241z"/>
+</svg>

web/icons/Christmas-Tree-66793.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" id="christmas">
+    <path d="M17 51c-.552 0-1 .448-1 1v2c0 .552.448 1 1 1s1-.448 1-1v-2C18 51.448 17.552 51 17 51zM22 51c-.552 0-1 .448-1 1v2c0 .552.448 1 1 1s1-.448 1-1v-2C23 51.448 22.552 51 22 51zM27 51c-.552 0-1 .448-1 1v2c0 .552.448 1 1 1s1-.448 1-1v-2C28 51.448 27.552 51 27 51zM32 51c-.552 0-1 .448-1 1v2c0 .552.448 1 1 1s1-.448 1-1v-2C33 51.448 32.552 51 32 51zM37 51c-.552 0-1 .448-1 1v2c0 .552.448 1 1 1s1-.448 1-1v-2C38 51.448 37.552 51 37 51zM42 51c-.552 0-1 .448-1 1v2c0 .552.448 1 1 1s1-.448 1-1v-2C43 51.448 42.552 51 42 51zM48 52c0-.552-.448-1-1-1s-1 .448-1 1v2c0 .552.448 1 1 1s1-.448 1-1V52z"/>
+    <path d="M54.641,55.858L46.417,44h1.576c0.776,0,1.469-0.434,1.807-1.131c0.336-0.695,0.247-1.503-0.233-2.109L41.036,30h1.946c0.806,0,1.51-0.453,1.84-1.182c0.325-0.721,0.202-1.539-0.321-2.133l-10.769-12.23l2.399,1.359c0.28,0.175,0.625,0.229,0.945,0.146c0.321-0.082,0.601-0.296,0.761-0.582c0.146-0.255,0.196-0.556,0.143-0.848c-0.01-0.053-0.023-0.104-0.042-0.155l-1.492-4.18l3.097-2.849c0.378-0.307,0.541-0.81,0.416-1.283c-0.004-0.016-0.009-0.031-0.014-0.046c-0.148-0.468-0.558-0.804-1.051-0.855l-4.198-0.401L33.143,0.77c-0.125-0.31-0.374-0.558-0.682-0.682c-0.307-0.123-0.653-0.115-0.945,0.017c-0.293,0.129-0.521,0.366-0.648,0.678L29.32,4.76l-4.218,0.4c-0.667,0.068-1.159,0.673-1.097,1.343c0.027,0.306,0.166,0.589,0.395,0.802l3.148,2.895l-1.45,4.185c-0.015,0.043-0.027,0.088-0.036,0.133c-0.13,0.658,0.292,1.309,0.94,1.452C27.092,15.99,27.183,16,27.271,16c0.221,0,0.434-0.059,0.606-0.167l2.373-1.36L19.5,26.685c-0.524,0.595-0.647,1.413-0.321,2.133c0.33,0.729,1.035,1.182,1.84,1.182h1.895l-8.482,10.764c-0.478,0.605-0.566,1.413-0.229,2.107C14.54,43.567,15.231,44,16.006,44h1.544L9.356,55.862c-0.424,0.614-0.472,1.408-0.125,2.069C9.577,58.591,10.254,59,10.998,59H24v3c0,1.103,0.897,2,2,2h12c1.103,0,2-0.897,2-2v-3h13.002c0.744,0,1.422-0.41,1.768-1.071C55.116,57.267,55.067,56.473,54.641,55.858z M28.669,13.075l0.983-2.839c0.13-0.376,0.025-0.794-0.268-1.063L27.01,6.989l3.113-0.295c0.376-0.036,0.701-0.281,0.838-0.633l1.047-2.691l1.047,2.691c0.137,0.353,0.46,0.597,0.837,0.633l3.088,0.295l-2.375,2.184c-0.296,0.272-0.4,0.694-0.265,1.073l1.01,2.828l-2.862-1.622c-0.308-0.173-0.684-0.173-0.991,0.002L28.669,13.075z M26,62v-3h12l0.002,3H26z M10.969,57.046L19.98,44H28c0.552,0,1-0.447,1-1s-0.448-1-1-1l-11.998,0.002L25.46,30h3.492c0.552,0,1-0.448,1-1s-0.448-1-1-1L21,28.006l10.999-12.492L42.982,28h-3.871c-0.152,0-0.292,0.039-0.421,0.1c-0.109,0.036-0.216,0.083-0.311,0.159c-0.433,0.343-0.506,0.972-0.162,1.405L47.992,42h-5.975c-0.553,0-1,0.447-1,1s0.447,1,1,1h1.965l9.019,13L10.969,57.046z"/>
+</svg>

web/icons/Classic-Music-17728.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="M6 20L26 20M12 20L12 24M9 20L9 24M20 20L20 24M23 20L23 24M17 20L17 24M20 12l-3.801-4.561C15.439 6.527 14.314 6 13.127 6H10c-2.209 0-4 1.791-4 4v16h20V16c0-2.209-1.791-4-4-4H20z"/>
+</svg>

web/icons/Comedy-5937.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" version="1.0" viewBox="0 0 24 24">
+  <path d="M6,7.5C6,7.5,7.4,7,8.5,7S11,7.5,11,7.5s-0.9,2.1-2.5,2.1S6,7.5,6,7.5z"/>
+  <path d="M19,4v7c0,4.5-5,7.7-7,8.8c-2-1.1-7-4.2-7-8.8V4H19 M19,2H5C3.9,2,3,2.9,3,4c0,0,0,3,0,7c0,7.1,9,11,9,11s9-4,9-11 c0-3.9,0-7,0-7C21,2.9,20.1,2,19,2L19,2z"/>
+  <path d="M15.3,13c0,0-1.8,0.8-3.3,0.8c-1.5,0-3.3-0.8-3.3-0.8s1.2,3,3.3,3C14.2,16,15.3,13,15.3,13L15.3,13z"/>
+  <path d="M19,2h-7v20c0,0,9-4,9-11c0-3.9,0-7,0-7C21,2.9,20.1,2,19,2z M15.5,9.6c-1.6,0-2.5-2.1-2.5-2.1S14.4,7,15.5,7 S18,7.5,18,7.5S17.1,9.6,15.5,9.6z"/>
+</svg>

web/icons/Country-Music-113286.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 30 30">
+  <path d="M26,14c-1.7,0-3,1.3-3,3c0,3.56-5.5,4-8,4s-8,0-8-4c0-1.7-1.3-3-3-3s-3,1.3-3,3c0,3.9,3.8,7,14,7s14-3.2,14-7C29,15.3,27.7,14,26,14z"/>
+  <path d="M21,8.5C20.296,6.221,19.572,5,18,5c-1.152,0-1.726,1-3,1s-1.848-1-3-1c-1.572,0-2.296,1.221-3,3.5c-0.677,2.19-2,8.144-2,8.144S10.018,18,15,18s8-1.356,8-1.356S21.677,10.69,21,8.5z"/>
+</svg>

web/icons/Darth-Vader-35734.svg

@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" id="darth" viewBox="0 0 48 48">
+  <path fill="#263238" d="M13,16h11h11l8,20v2c0,0-4.813,4-8,4c-3.438,2-11,2.017-11,2.017S16.062,43.75,13,42c-1.438,0-8-2.563-8-4s0-2,0-2L13,16z"/>
+  <path fill="#455a64" d="M44,37c0-2.825-2.049-7.746-4.029-12.504c-0.453-1.089-0.907-2.182-1.323-3.222c-0.02-0.067-0.039-0.128-0.06-0.2c-0.003-0.01-0.006-0.022-0.009-0.032c-0.04-0.135-0.082-0.28-0.126-0.43c-0.014-0.047-0.028-0.096-0.042-0.145c-0.039-0.135-0.079-0.275-0.119-0.418c-0.011-0.039-0.022-0.077-0.033-0.117c-0.051-0.181-0.102-0.368-0.154-0.56c-0.011-0.042-0.023-0.085-0.034-0.127c-0.042-0.155-0.084-0.313-0.126-0.473c-0.015-0.057-0.03-0.113-0.044-0.17c-0.053-0.203-0.105-0.408-0.156-0.615c-0.003-0.013-0.006-0.026-0.009-0.039c-0.048-0.193-0.094-0.387-0.14-0.581c-0.014-0.06-0.028-0.119-0.041-0.179C37.292,16.05,37.076,14.913,37,14c-0.009-0.107-0.039-0.177-0.062-0.262c-0.036-0.345-0.089-0.646-0.156-0.906C35.768,7.811,31.308,4,26,4h-4c-5.308,0-9.768,3.811-10.782,8.832c-0.068,0.261-0.12,0.561-0.156,0.906C11.039,13.823,11.009,13.893,11,14c-0.076,0.913-0.292,2.05-0.554,3.189c-0.014,0.06-0.027,0.119-0.041,0.179c-0.046,0.194-0.092,0.388-0.14,0.581c-0.003,0.013-0.006,0.026-0.009,0.039c-0.051,0.207-0.104,0.413-0.156,0.615c-0.015,0.057-0.03,0.113-0.044,0.17c-0.042,0.16-0.084,0.318-0.126,0.473c-0.011,0.042-0.023,0.085-0.034,0.127c-0.052,0.192-0.104,0.379-0.154,0.56c-0.011,0.04-0.022,0.078-0.033,0.117c-0.041,0.144-0.08,0.284-0.119,0.418c-0.014,0.049-0.028,0.097-0.042,0.145c-0.043,0.15-0.086,0.294-0.126,0.43c-0.003,0.01-0.006,0.022-0.009,0.032c-0.044,0.149-0.085,0.286-0.124,0.414c-0.01,0.032-0.019,0.063-0.028,0.093c-0.031,0.102-0.06,0.197-0.086,0.282c-0.005,0.016-0.01,0.033-0.015,0.048c-0.03,0.096-0.056,0.179-0.078,0.25c-0.006,0.021-0.011,0.036-0.017,0.054c-0.016,0.052-0.032,0.1-0.042,0.131c-0.002,0.006-0.005,0.014-0.006,0.02C9.007,22.393,9,22.417,9,22.417l2.219-0.385c0.21-0.639,0.451-1.182,0.691-1.675c1.466-3.023,3.434-3.272,4.448-3.356H17c2.417,0,5,1,5,1h4c0,0,2.667-1,5-1h0.642c1.014,0.084,2.858,0.25,4.448,3.356c0.104,0.202,0.202,0.423,0.299,0.648c0.06,0.155,0.127,0.32,0.189,0.479c0.068,0.18,0.138,0.353,0.203,0.549l0.016,0.003c0.408,1.019,0.856,2.099,1.327,3.231c1.816,4.363,3.876,9.31,3.879,11.679c-0.005,0.033-0.717,4.041-10.169,5.518C29.726,42.578,26.878,42.509,24,42c-2.91-0.514-5.781-2.536-8-5c0,0-1,3.063-3,5c0,2.209,4.925,3,11,3c5.853,0,10.625-0.7,10.967-2.764c4.615-0.783,6.887-2.043,7.993-3.168C43.966,38.046,44.003,37.152,44,37z"/>
+  <path fill="#546e7a" d="M29,19c-3.625,0-5,3-5,3l1,3c1.031,1.031,5,1,5,1s4,0.125,4-2S32.625,19,29,19z M19,18.999c-3.625,0-5,2.875-5,5s4,2,4,2s3.969,0.031,5-1l1-3C24,21.998,22.625,18.999,19,18.999z M29.978,27.999l-0.016,0c-1.126,0-2.324-0.089-3.482-0.34c0.902,1.35,2.019,3.03,3.147,4.728c0.297,0.447,0.593,0.894,0.886,1.335c0.589-1.479,1.575-3.981,2.349-6.094C32.074,27.866,31.16,28,30.124,28C30.059,28,30.01,27.999,29.978,27.999z M20,33.552V35h1v-2.953c-0.317,0.477-0.637,0.959-0.961,1.446L20,33.552z M28,35h0.961c-0.324-0.488-0.644-0.971-0.961-1.448V35z M29,35.059V35h-0.039C28.974,35.02,28.987,35.039,29,35.059z M22,35h1v-4h-1V35z M26,31v4h1v-2.954c-0.24-0.361-0.467-0.703-0.696-1.046H26z M24,35h1v-4h-1V35z"/>
+  <path fill="#455a64" d="M19 18.999c-.507 0-.965.061-1.387.164 3.448.756 5.258 3.989 5.387 4.839.159-.125.302-.236.449-.351L24 21.999C24 21.998 22.625 18.999 19 18.999zM29 19c-.307 0-.591.028-.866.067 2.86 1.276 3.691 5.761 3.838 6.735C32.981 25.571 34 25.072 34 24 34 21.875 32.625 19 29 19z"/>
+  <path fill="#78909c" d="M26,29h-4v-9.188l0.636,0.489c1.011,0.496,1.699,0.534,2.702,0.022L26,19.813V29z"/>
+  <path fill="#37474f" d="M38.984,22.366c-0.002-0.005-0.004-0.013-0.006-0.02c-0.01-0.031-0.025-0.08-0.042-0.131c-0.006-0.018-0.011-0.034-0.017-0.054c-0.022-0.07-0.048-0.154-0.078-0.25c-0.005-0.015-0.01-0.033-0.015-0.048c-0.026-0.085-0.055-0.181-0.086-0.282c-0.009-0.031-0.019-0.061-0.028-0.093c-0.039-0.128-0.08-0.265-0.124-0.414c-0.003-0.01-0.006-0.022-0.009-0.032c-0.04-0.135-0.082-0.28-0.126-0.43c-0.014-0.047-0.028-0.096-0.042-0.145c-0.039-0.135-0.079-0.275-0.119-0.418c-0.011-0.039-0.022-0.077-0.033-0.117c-0.051-0.181-0.102-0.368-0.154-0.56c-0.011-0.042-0.023-0.085-0.034-0.127c-0.042-0.155-0.084-0.313-0.126-0.473c-0.015-0.057-0.03-0.113-0.044-0.17c-0.053-0.203-0.105-0.408-0.156-0.615c-0.003-0.013-0.006-0.026-0.009-0.039c-0.048-0.193-0.094-0.387-0.14-0.581c-0.014-0.06-0.028-0.119-0.041-0.179C37.292,16.05,37.076,14.913,37,14c-0.009-0.107-0.039-0.177-0.062-0.262c-0.036-0.345-0.089-0.646-0.156-0.906C35.768,7.811,31.308,4,26,4c3.463,1.079,6.733,3.241,7.707,6.189c0.296,0.897-0.436,1.811-1.38,1.805C28.838,11.975,29.132,11.956,26,13v5c0,0,2.667-1,5-1c0.204,0,0.421,0,0.642,0c1.014,0.084,2.941,0.333,4.448,3.356c0.245,0.491,0.481,1.036,0.691,1.675L39,22.417C39,22.417,38.993,22.393,38.984,22.366z"/>
+  <path fill="#455a64" d="M23,22v1h2v-1H23z M23,25h2v-1h-2V25z"/>
+  <path fill="#c5cae9" d="M18,34c-0.552,0-1,0.448-1,1c0,0.552,0.448,1,1,1s1-0.448,1-1C19,34.448,18.552,34,18,34z M24,26c-1.1,0-2,0.9-2,2v2h4v-2C26,26.9,25.1,26,24,26z M30,34c-0.552,0-1,0.448-1,1c0,0.552,0.448,1,1,1s1-0.448,1-1C31,34.448,30.552,34,30,34z"/>
+  <path fill="#607d8b" d="M25,3h-2c-0.552,0-1,0.448-1,1v14h4V4C26,3.448,25.552,3,25,3z M15.677,11.994c1.657-0.009,2.461-0.017,3.185,0.088C19.464,12.171,20,11.705,20,11.098V6.102c0-0.622-0.671-1.022-1.214-0.719c-2.075,1.159-3.769,2.748-4.455,4.695C14.001,11.014,14.684,12,15.677,11.994z M18.022,27.999C17.99,27.999,17.941,28,17.876,28c-1.037,0-1.95-0.134-2.739-0.372c0.775,2.113,1.76,4.615,2.349,6.094c0.292-0.441,0.589-0.888,0.886-1.335c1.128-1.699,2.245-3.379,3.147-4.728c-1.158,0.251-2.356,0.34-3.482,0.34L18.022,27.999z M11.203,22.034l0.016-0.003c0.092-0.276,0.191-0.523,0.29-0.77c0.035-0.09,0.073-0.185,0.108-0.274C13.605,16.383,16.913,16.988,17,17c1.043,0,2.116,0.186,3,0.398v-2.266c0-0.506-0.38-0.937-0.883-0.994C17.89,14.001,17,14,17,14c-5,0-6.268,1.924-6.51,3c-0.361,1.6-0.824,3.225-1.137,4.273c-0.416,1.041-0.87,2.134-1.323,3.223C6.049,29.254,4,34.175,4,37c-0.003,0.152,0.034,1.046,1.04,2.068c1.107,1.125,3.378,2.385,7.994,3.168C13.02,42.158,13,42.082,13,42c0.053-0.051,0.103-0.107,0.154-0.16c-6.602-1.75-7.153-4.868-7.157-4.897C6,34.574,8.06,29.628,9.876,25.265C10.347,24.133,10.795,23.053,11.203,22.034z"/>
+  <path fill="#455a64" d="M37.51,17C37.268,15.924,36,14,31,14c0,0-2.568,0-5,0.677V18c0,0,2.583-1,5-1c0.093-0.013,3.75-0.75,5.781,5.031L39,22.417C39,22.417,38.111,19.666,37.51,17z"/>
+</svg>

web/icons/Disco-Ball-25777.svg

@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 50 50">
+  <path fill="none" stroke="#000" stroke-miterlimit="10" stroke-width="2" d="M10.128,33.863C13.609,34.555,18.971,35,25,35c6.029,0,11.392-0.445,14.872-1.136"/>
+  <path fill="none" stroke="#000" stroke-miterlimit="10" stroke-width="2" d="M23.136 17.128C22.445 20.608 22 25.971 22 32c0 6.029.445 11.392 1.136 14.872M26.864 46.872C27.555 43.392 28 38.029 28 32c0-6.029-.445-11.391-1.136-14.872"/>
+  <path d="M33,38.102c0,0,2.563,3.496,3.688,4.949C35.563,44.504,33,48,33,48s3.496-2.563,4.949-3.684C39.402,45.438,42.902,48,42.902,48s-2.566-3.496-3.688-4.949c1.121-1.453,3.688-4.949,3.688-4.949s-3.5,2.563-4.953,3.684C36.496,40.664,33,38.102,33,38.102z"/>
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M11.387,38.271C14.839,39.952,19.658,41,25,41c2.121,0,4.154-0.171,6.057-0.476"/>
+  <path fill="none" stroke="#000" stroke-miterlimit="10" stroke-width="2" d="M25 17L25 7M27 7h-4c-1.105 0-2-.895-2-2V3h8v2C29 6.105 28.105 7 27 7z"/>
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M33.903,34.649C33.963,33.783,34,32.901,34,32c0-5.342-1.048-10.161-2.729-13.613"/>
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M39.051 37.211C39.654 35.586 40 33.835 40 32c0-8.284-6.716-15-15-15-2.367 0-4.597.563-6.588 1.539M10.03 31.399C10.022 31.6 10 31.797 10 32c0 8.284 6.716 15 15 15 2.095 0 4.088-.432 5.899-1.208"/>
+  <path d="M8 13c0 0 2.563 3.496 3.688 4.949C10.563 19.402 8 22.898 8 22.898s3.496-2.563 4.949-3.684c1.453 1.121 4.953 3.684 4.953 3.684s-2.566-3.496-3.688-4.949C15.336 16.496 17.902 13 17.902 13s-3.5 2.563-4.953 3.684C11.496 15.563 8 13 8 13zM13 25c0 0 1.098 1.938 1.797 3.043C14.098 29.117 13 31 13 31s1.91-1.07 3-1.754C17.09 29.93 19 31 19 31s-1.098-1.883-1.797-2.957C17.902 26.938 19 25 19 25s-1.91 1.125-3 1.84C14.91 26.125 13 25 13 25z"/>
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M16.018,32.752c0.094,5.039,1.109,9.573,2.711,12.861"/>
+  <path fill="none" stroke="#000" stroke-miterlimit="10" stroke-width="2" d="M39.872 30.136C36.391 29.444 31.029 29 25 29c-1.256 0-2.473.023-3.66.06M38.613 25.728C35.161 24.047 30.342 23 25 23c-1.055 0-2.087.045-3.094.124"/>
+</svg>

web/icons/Electronic-Music-17745.svg

@@ -0,0 +1,4 @@
+<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="M5 19L27 19M8 14L15 14M12 19L12 23M9 19L9 23M20 19L20 23M23 19L23 23M17 19L17 23M5 9H27V25H5z"/>
+  <path d="M22.5 13A1.5 1.5 0 1 0 22.5 16 1.5 1.5 0 1 0 22.5 13zM18.5 13A1.5 1.5 0 1 0 18.5 16 1.5 1.5 0 1 0 18.5 13z"/>
+</svg>

web/icons/Error-82783.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M21.382,18.967L12.585,4.331c-0.265-0.441-0.904-0.441-1.169,0L2.618,18.967C2.345,19.421,2.672,20,3.202,20h17.595C21.328,20,21.655,19.421,21.382,18.967z"/>
+  <path d="M13,18h-2v-2h2V18z M13,14h-2V9h2V14z"/>
+</svg>

web/icons/Film-Reel-3230.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M9,0C4.029,0,0,4.029,0,9s4.029,9,9,9s9-4.029,9-9S13.971,0,9,0z M9,1.751c1.39,0,2.037,0.345,2.037,1.441 c0,1.096-1.612,2.127-2.037,2.127c-0.427,0-2.039-1.031-2.039-2.127C6.961,2.096,7.61,1.751,9,1.751z M2.991,9.299 c-1.043-0.338-1.172-1.06-0.744-2.381c0.429-1.323,0.956-1.834,2-1.497c1.04,0.338,1.527,2.189,1.394,2.594 C5.511,8.42,4.034,9.636,2.991,9.299z M7.345,14.868c-0.602,0.918-1.332,0.856-2.498,0.097c-1.161-0.759-1.516-1.402-0.918-2.319 c0.598-0.919,2.51-0.902,2.867-0.669C7.154,12.209,7.94,13.956,7.345,14.868z M9,10.35c-0.746,0-1.35-0.604-1.35-1.35 S8.254,7.65,9,7.65c0.747,0,1.35,0.604,1.35,1.35S9.747,10.35,9,10.35z M13.231,14.844c-1.132,0.803-1.861,0.899-2.494,0.005 c-0.636-0.893,0.083-2.667,0.427-2.912c0.348-0.249,2.261-0.339,2.893,0.548C14.692,13.381,14.365,14.038,13.231,14.844z M15.005,9.299c-1.042,0.337-2.519-0.879-2.649-1.284c-0.134-0.405,0.354-2.256,1.393-2.594c1.045-0.337,1.572,0.174,2,1.497 C16.177,8.238,16.048,8.961,15.005,9.299z"/><path d="M21,19.489c0-1.499,0.618-2.416,1.335-3.479c0.78-1.157,1.664-2.468,1.664-4.548 c0-3.251-3.609-6.168-6.73-8.084c0.711,1.044,1.227,2.23,1.502,3.505c1.808,1.433,3.228,3.054,3.228,4.579 c0,3.352-2.999,4.243-2.999,8.027c0,3.204,3.535,4.411,3.686,4.46l0.629-1.898C23.291,22.043,21,21.236,21,19.489z"/></svg>

web/icons/Fridge-282.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26">
+  <path d="M19,2c0.552,0,1,0.448,1,1v19c0,0.552-0.448,1-1,1H7c-0.552,0-1-0.448-1-1V3c0-0.552,0.448-1,1-1H19 M19,0 H7C5.344,0,4,1.344,4,3v19c0,1.656,1.344,3,3,3h12c1.656,0,3-1.344,3-3V3C22,1.344,20.656,0,19,0L19,0z"/>
+  <path d="M9 9C8.449 9 8 8.551 8 8V6c0-.551.449-1 1-1l0 0c.551 0 1 .449 1 1v2C10 8.551 9.551 9 9 9L9 9zM9 18c-.551 0-1-.449-1-1v-3c0-.551.449-1 1-1l0 0c.551 0 1 .449 1 1v3C10 17.551 9.551 18 9 18L9 18zM7 26c-.551 0-1-.448-1-1v-.469h3V25c0 .552-.449 1-1 1H7zM18 26c-.551 0-1-.448-1-1v-.469h3V25c0 .552-.449 1-1 1H18zM5 10H21V12H5z"/>
+</svg>

web/icons/Guitar-110433.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128">
+  <path d="M51.7 69.2A7 7 0 1 0 51.7 83.2A7 7 0 1 0 51.7 69.2Z"/>
+  <path d="M110.8,21.1l-4-4c-0.4-0.4-0.9-0.8-1.4-1c-2.6-1.4-5.6-0.7-7.4,1.3L90,26.4c-1,1.1-1.5,2.5-1.5,3.8L67.9,50.8c-3.1-2.2-6.7-3.4-10.4-3.4c-4.6,0-8.8,1.8-11.9,5c-0.7,0.7-1.3,1.4-1.8,2.1c-3.3,4.5-8.3,6.7-11.8,7.7c-4.3,1.2-8.2,3.5-11.4,6.7c-7.9,7.9-8.6,20.6-1.7,30.2c6.7,9.4,19,17.9,27.9,17.9h0c7.3,0,14-3.8,18.8-10.8c1.5-2.1,2.4-4.6,3.2-7c1.5-5.2,4.3-9.4,7.9-12.2c0.7-0.6,1.4-1.2,2.1-1.8c3.5-3.5,5.2-7.9,4.9-12.5c-0.1-1.6-1.2-4-2.6-6.4c-2.2-3.8-1.6-8.7,1.5-11.8l15.1-15.1c1.4,0,2.8-0.6,3.9-1.5l9.1-8.1c1.2-1.1,1.9-2.7,2-4.3C112.6,23.9,112,22.3,110.8,21.1z M71.5,77.9c-0.5,0.5-1,0.9-1.5,1.3c-4.7,3.6-8.2,8.9-10.1,15.4c-1,3.3-2.7,6.2-5.1,8.6c-3.2,3.2-6.9,4.8-11.1,4.8c-6.9,0-14.4-4.6-20-12.4c-5.2-7.2-4.7-16.7,1.1-22.5c2.4-2.4,5.5-4.2,8.8-5.1c6.4-1.8,11.6-5.2,15-9.9c0.4-0.5,0.8-1,1.3-1.5c2-2,4.7-3.1,7.6-3.1c2.5,0,5.1,0.8,7.2,2.4c5.9,4.4,9.6,9.7,10,14.3C74.8,73,73.8,75.6,71.5,77.9z M73.2,55.4c-0.2-0.2-0.5-0.5-0.7-0.7l18.8-18.8l0.7,0.7L73.2,55.4z M97.5,33.5C97.5,33.5,97.5,33.5,97.5,33.5l-3.1-3.1l8.1-9.1l4,4L97.5,33.5z"/>
+  <path d="M39,80.4c-1.2-1.2-3.1-1.2-4.2,0c-1.2,1.2-1.2,3.1,0,4.2l8.5,8.5c0.6,0.6,1.4,0.9,2.1,0.9s1.5-0.3,2.1-0.9c1.2-1.2,1.2-3.1,0-4.2L39,80.4z"/>
+</svg>

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/Hip-Hop Music-17757.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M6,19c0,1.725,0.818,7,3.318,7C11,26,12.5,25,16,25c3.455,0,5,1,6.682,1C25.136,26,26,20.725,26,19"/>
+  <path d="M17.818,6.136C17.818,6.773,17,6.455,16,6.455s-1.818,0.273-1.818-0.318C14.182,5.5,15,5,16,5S17.818,5.5,17.818,6.136z"/>
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M16,7C10.5,7,6,9.409,6,14.409c0,0.545,0,4,0,4.591c0,0,4.455-1,10-1c5.5,0,10,1,10,1c0-0.727,0-3.682,0-4.591C26,9.409,21.5,7,16,7z"/>
+  <path fill="none" stroke="#000" stroke-miterlimit="10" stroke-width="2" d="M18 11.123C18 10.503 17.497 10 16.877 10h-1.754C14.503 10 14 10.503 14 11.123v0c0 .515.351.965.851 1.09l2.299.575c.5.125.851.574.851 1.09v0C18 14.497 17.497 15 16.877 15h-1.754C14.503 15 14 14.497 14 13.877M16 10L16 8M16 17L16 15"/>
+</svg>

web/icons/Horror-88855.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+  <path d="M17 20c0 .6-.4 1-1 1s-1-.4-1-1 1-2 1-2S17 19.4 17 20zM21 15.5c0 .8-.7 1.5-1.5 1.5S18 16.3 18 15.5c0-.8 1.5-4 1.5-4S21 14.7 21 15.5z"/>
+  <path fill="none" stroke="#000" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M9,12l4.5,4c5-5,5.5-11.5,5.5-13L3,17.5L7,21c0,0,3-2,5-6"/>
+</svg>

web/icons/Ice-Pop Yellow-94532.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 30 30">
+  <path d="M17,21h-4v5c0,1.105,0.895,2,2,2h0c1.105,0,2-0.895,2-2V21z"/>
+  <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M8 10v10c0 .552.448 1 1 1h12c.552 0 1-.448 1-1V10c0-3.866-3.134-7-7-7h0C11.134 3 8 6.134 8 10zM12 10c0-1.657 1.343-3 3-3"/>
+</svg>

web/icons/Jack-o' Lantern-107512.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" id="halloween" viewBox="0 0 30 30">
+    <path d="M17.532,5c-2.517,0-3.596,0.966-4.435,1.265c-0.779,0.3-2.037,0.12-4.375,0.479c-6.472,1.079-5.693,8.648-5.693,8.648C3.029,23.124,10.64,26,12.498,26c1.258,0,1.318-0.599,1.918-0.599c0.599,0,1.258,0.599,2.517,0.599C21.307,26,27,22.165,27,14.554C27,6.284,20.049,5,17.532,5z M19.721,7.572l1.765,2.353l-1.176,1.765l-4.118,0.588L19.721,7.572z M16.191,14.042l-1.765,1.765l-1.765-1.765H16.191z M9.132,9.336l3.529,2.941H8.544l-1.176-1.176L9.132,9.336z M23.25,20.513c0-0.588-0.588-1.765-0.588-1.765c0,1.176-0.588,2.353-1.177,2.941c-0.176-0.588-0.588-1.176-0.588-1.176c-0.588,1.176-1.177,1.765-1.177,1.765c-0.412-0.647-1.176-1.176-1.176-1.176c0,0.882-0.588,1.765-0.588,1.765c-0.706-0.471-1.177-1.177-1.177-1.177s-0.588,0.824-0.588,1.765c-0.353-0.412-0.941-1.235-1.177-1.765c0,0-0.588,0.588-0.588,1.765c-0.588-0.471-1.765-1.765-1.765-1.765s-0.588,1.177-0.588,1.765c0,0-0.765-0.706-1.176-1.765c0,0-0.588,0.588-0.588,1.177c-1.765-1.177-1.765-2.353-1.765-2.353s-0.588,0.588-0.588,1.765c-1.765-1.765-2.941-3.529-2.941-6.471c0-1.118,0.588-2.941,1.177-3.529c-0.588,4.118,0.588,5.294,0.588,5.294c0-0.235,0-1.177,1.177-2.353c0,2.353,0.588,3.529,0.588,3.529c0-0.588,0.588-1.765,1.176-2.353c0,2.353,1.765,3.529,1.765,3.529c0-0.588,0.588-1.765,1.177-2.353c0,0.588,1.765,2.941,1.765,2.941s0-1.765,0.588-2.941c0.588,1.176,1.765,2.353,1.765,2.353s0.588-1.176,0.588-2.941c0,0,1.765,1.176,2.353,2.941c0,0,1.177-1.176,1.177-4.118c0,0,1.176,1.176,1.176,2.353c0,0,1.176-2.941,0.588-4.118c0,0,1.176,1.176,1.176,2.353c0,0,0.588-2.353-0.588-5.882c1.235,1.176,1.765,2.941,1.765,5.294C25.015,18.16,23.838,19.925,23.25,20.513z"/>
+    <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M12.795,7.572C10.998,3.317,15,3,15,3"/>
+</svg>

web/icons/Jack-o' Lantern-66580.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" id="halloween" viewBox="0 0 16 16">
+    <path fill="#ffab40" d="M4.41,8.67c0-0.008-0.001-0.014-0.001-0.022c-0.006,0.006-0.01,0.012-0.016,0.018C4.399,8.668,4.405,8.669,4.41,8.67z"/>
+    <path fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M5.496,2.5C7.5,2.5,7.5,4.25,7.5,4.25"/>
+    <path d="M9.274,3c-1.26,0-1.819,0.553-2.221,0.71C6.65,3.867,6.039,3.779,4.863,3.943C1.619,4.482,2.015,8.736,2.015,8.736C1.999,12.575,5.808,14,6.754,14c0.63,0,0.63-0.297,0.945-0.297c0.315,0,0.63,0.297,1.26,0.297C11.164,14,14,12.097,14,8.326C14,4.226,10.534,3,9.274,3z M11,5l1,2h-1H9L11,5z M9.5,8L8,9.5L6.5,8H9.5z M5,5l2,2H5H4L5,5z M11,12h-1v-1H9v1H7v-1H6v1H5c0,0-1-0.75-1-2h1v1h1v-1h2v1h1v-1h1v1h1v-1h1C12,11.25,11,12,11,12z"/>
+</svg>