🔀 Merge branch 'master' of https://github.com/manuel-rw/jellyfin-discord-music-bot

2024-10-18 19:35:04 +02:00 · 2023-04-10 10:38:40 +02:00 · 2023-04-10 10:38:40 +02:00 · 24cfcb9369
commit 24cfcb9369
parent ec553c8be3 e1060af34e
40 changed files with 1350 additions and 682 deletions
--- a/.deepsource.toml
+++ b/.deepsource.toml
@ -0,0 +1,14 @@
+version = 1
+
+[[analyzers]]
+name = "javascript"
+
+  [analyzers.meta]
+  plugins = ["react"]
+
+[[analyzers]]
+name = "docker"
+
+[[analyzers]]
+name = "test-coverage"
+enabled = true
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@ -1,84 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ "master" ]
-    paths-ignore:
-      - '.github/**'
-      - 'images/'
-      - '*.md'
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ "master" ]
-    paths-ignore:
-      - '.github/**'
-      - 'images/'
-      - '*.md'
-  schedule:
-    - cron: '31 2 * * 1'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'javascript' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Use only 'java' to analyze code written in Java, Kotlin or both
-        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #   echo "Run, Build Application using script"
-    #   ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
-      with:
-        category: "/language:${{matrix.language}}"
--- a/.github/workflows/deepsource-tests.yml
+++ b/.github/workflows/deepsource-tests.yml
@ -0,0 +1,58 @@
+name: Deepsource report test coverage
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+on:
+  push:
+    branches: [dev,master]
+    paths-ignore:
+      - '.github/**'
+      - 'images/'
+      - '*.md'
+  pull_request:
+    branches:
+      - master
+      - dev
+
+  workflow_dispatch:
+
+env:
+  # Use docker.io for Docker Hub if empty
+  REGISTRY: ghcr.io
+  # github.repository as <account>/<repo>
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  report-test-coverage:
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - name: Setup
+        uses: actions/setup-node@v3
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Get yarn cache directory path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn config get cacheFolder)"
+      - uses: actions/cache@v3
+        id: yarn-cache
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+      - run: yarn install --immutable
+      - run: yarn test:cov
+      - run: curl https://deepsource.io/cli | sh
+      - name: Report test-coverage to DeepSource
+        run: |
+          # Install the CLI
+          curl https://deepsource.io/cli | sh
+
+          # Send the report to DeepSource
+          ./bin/deepsource report --analyzer test-coverage --key javascript --value-file ./coverage/lcov.info
+        env:
+          DEEPSOURCE_DSN: ${{ secrets.DEEPSOURCE_DSN }}
--- a/README.md
+++ b/README.md
@ -18,6 +18,7 @@
  <br/>
  <br/>
  <img src="https://github.com/manuel-rw/jellyfin-discord-music-bot/actions/workflows/docker.yml/badge.svg?branch=master" />
+  <img src="https://deepsource.io/gh/manuel-rw/jellyfin-discord-music-bot.svg/?label=active+issues&show_trend=true&token=vhfm8cbHaoCyXTf7Gfs9FweR)](https://deepsource.io/gh/manuel-rw/jellyfin-discord-music-bot/?ref=repository-badge" />
 </p>

 <br/>
--- a/package.json
+++ b/package.json
@ -1,7 +1,7 @@
 {
  "name": "jellyfin-discord-music-bot",
-  "version": "0.0.5",
-  "description": "",
+  "version": "0.0.7",
+  "description": "A simple and leightweight Discord Bot, that integrates with your Jellyfin Media server and enables you to listen to your favourite music directly from discord.",
  "author": "manuel-rw",
  "private": true,
  "license": "MIT",
@ -21,51 +21,53 @@
    "test:e2e": "jest --config ./test/jest-e2e.json"
  },
  "dependencies": {
-    "@discord-nestjs/common": "^5.2.2",
-    "@discord-nestjs/core": "^5.3.4",
+    "@discord-nestjs/common": "^5.2.3",
+    "@discord-nestjs/core": "^5.3.5",
    "@discordjs/opus": "^0.9.0",
-    "@discordjs/voice": "^0.15.0",
-    "@jellyfin/sdk": "^0.7.0",
-    "@nestjs/common": "^9.0.0",
+    "@discordjs/voice": "^0.16.0",
+    "@jellyfin/sdk": "^0.8.1",
+    "@nestjs/common": "^9.4.0",
    "@nestjs/config": "^2.2.0",
-    "@nestjs/core": "^9.0.0",
+    "@nestjs/core": "^9.4.0",
    "@nestjs/event-emitter": "^1.3.1",
-    "@nestjs/platform-express": "^9.0.0",
+    "@nestjs/platform-express": "^9.3.12",
    "@nestjs/schedule": "^2.1.0",
    "@nestjs/serve-static": "^3.0.1",
-    "@nestjs/terminus": "^9.1.4",
+    "@nestjs/terminus": "^9.2.2",
    "date-fns": "^2.29.3",
-    "discord.js": "^14.8.0",
-    "joi": "^17.8.4",
+    "discord.js": "^14.9.0",
+    "joi": "^17.9.1",
    "libsodium-wrappers": "^0.7.10",
+    "opusscript": "^0.0.8",
    "reflect-metadata": "^0.1.13",
-    "rimraf": "^4.4.0",
+    "rimraf": "^5.0.0",
    "rxjs": "^7.2.0",
    "uuid": "^9.0.0",
-    "ws": "^8.13.0"
+    "ws": "^8.13.0",
+    "zod": "^3.21.4"
  },
  "devDependencies": {
-    "@nestjs/cli": "^9.2.0",
-    "@nestjs/schematics": "^9.0.0",
-    "@nestjs/testing": "^9.3.9",
-    "@types/cron": "^2.0.0",
+    "@nestjs/cli": "^9.3.0",
+    "@nestjs/schematics": "^9.1.0",
+    "@nestjs/testing": "^9.4.0",
+    "@types/cron": "^2.0.1",
    "@types/express": "^4.17.13",
    "@types/jest": "28.1.8",
-    "@types/node": "^18.15.0",
+    "@types/node": "^18.15.11",
    "@types/supertest": "^2.0.11",
-    "@typescript-eslint/eslint-plugin": "^5.53.0",
-    "@typescript-eslint/parser": "^5.55.0",
-    "eslint": "^8.35.0",
-    "eslint-config-prettier": "^8.6.0",
+    "@typescript-eslint/eslint-plugin": "^5.57.0",
+    "@typescript-eslint/parser": "^5.57.0",
+    "eslint": "^8.38.0",
+    "eslint-config-prettier": "^8.8.0",
    "eslint-plugin-prettier": "^4.0.0",
    "jest": "28.1.3",
-    "prettier": "^2.8.4",
+    "prettier": "^2.8.7",
    "source-map-support": "^0.5.20",
    "supertest": "^6.1.3",
    "ts-jest": "28.0.8",
    "ts-loader": "^9.2.3",
    "ts-node": "^10.0.0",
-    "tsconfig-paths": "4.1.2",
+    "tsconfig-paths": "4.2.0",
    "typescript": "^4.7.4"
  },
  "jest": {
--- a/src/app.module.ts
+++ b/src/app.module.ts
@ -28,6 +28,7 @@ import { UpdatesModule } from './updates/updates.module';
        UPDATER_DISABLE_NOTIFICATIONS: Joi.boolean(),
        LOG_LEVEL: Joi.string()
          .valid('error', 'warn', 'log', 'debug', 'verbose')
+          .insensitive()
          .default('log'),
        PORT: Joi.number().min(1),
      }),
--- a/src/clients/discord/discord.config.service.ts
+++ b/src/clients/discord/discord.config.service.ts
@ -9,7 +9,7 @@ import { GatewayIntentBits } from 'discord.js';
 export class DiscordConfigService implements DiscordOptionsFactory {
  createDiscordOptions(): DiscordModuleOption {
    return {
-      token: process.env.DISCORD_CLIENT_TOKEN,
+      token: process.env.DISCORD_CLIENT_TOKEN ?? '',
      discordClientOptions: {
        intents: [
          GatewayIntentBits.Guilds,
--- a/src/clients/discord/discord.voice.service.ts
+++ b/src/clients/discord/discord.voice.service.ts
@ -9,28 +9,29 @@ import {
  joinVoiceChannel,
  NoSubscriberBehavior,
  VoiceConnection,
-  VoiceConnectionStatus,
 } from '@discordjs/voice';

 import { Injectable } from '@nestjs/common';
 import { Logger } from '@nestjs/common/services';
 import { EventEmitter2, OnEvent } from '@nestjs/event-emitter';
+import { Interval } from '@nestjs/schedule';

 import { GuildMember } from 'discord.js';

+import { GenericTryHandler } from '../../models/generic-try-handler';
+import { Track } from '../../models/shared/Track';
+import { PlaybackService } from '../../playback/playback.service';
 import { JellyfinStreamBuilderService } from '../jellyfin/jellyfin.stream.builder.service';
 import { JellyfinWebSocketService } from '../jellyfin/jellyfin.websocket.service';
-import { GenericTryHandler } from '../../models/generic-try-handler';
-import { PlaybackService } from '../../playback/playback.service';
-import { Track } from '../../models/shared/Track';

 import { DiscordMessageService } from './discord.message.service';

@Injectable()
 export class DiscordVoiceService {
  private readonly logger = new Logger(DiscordVoiceService.name);
-  private audioPlayer: AudioPlayer;
-  private voiceConnection: VoiceConnection;
+  private audioPlayer: AudioPlayer | undefined;
+  private voiceConnection: VoiceConnection | undefined;
+  private audioResource: AudioResource | undefined;

  constructor(
    private readonly discordMessageService: DiscordMessageService,
@ -40,10 +41,13 @@ export class DiscordVoiceService {
    private readonly eventEmitter: EventEmitter2,
  ) {}

-  @OnEvent('internal.audio.announce')
+  @OnEvent('internal.audio.track.announce')
  handleOnNewTrack(track: Track) {
    const resource = createAudioResource(
      track.getStreamUrl(this.jellyfinStreamBuilder),
+      {
+        inlineVolume: true,
+      },
    );
    this.playResource(resource);
  }
@ -89,7 +93,7 @@ export class DiscordVoiceService {

    this.jellyfinWebSocketService.initializeAndConnect();

-    if (this.voiceConnection == undefined) {
+    if (this.voiceConnection === undefined) {
      this.voiceConnection = getVoiceConnection(member.guild.id);
    }

@ -99,14 +103,26 @@ export class DiscordVoiceService {
    };
  }

+  changeVolume(volume: number) {
+    if (!this.audioResource || !this.audioResource.volume) {
+      this.logger.error(
+        `Failed to change audio volume, AudioResource or volume was undefined`,
+      );
+      return;
+    }
+    this.audioResource.volume.setVolume(volume);
+  }
+
  playResource(resource: AudioResource<unknown>) {
    this.logger.debug(`Playing audio resource with volume ${resource.volume}`);
    this.createAndReturnOrGetAudioPlayer().play(resource);
+    this.audioResource = resource;
  }

  /**
   * Pauses the current audio player
   */
+  @OnEvent('internal.voice.controls.pause')
  pause() {
    this.createAndReturnOrGetAudioPlayer().pause();
    this.eventEmitter.emit('playback.state.pause', true);
@ -115,6 +131,7 @@ export class DiscordVoiceService {
  /**
   * Stops the audio player
   */
+  @OnEvent('internal.voice.controls.stop')
  stop(force: boolean): boolean {
    const stopped = this.createAndReturnOrGetAudioPlayer().stop(force);
    this.eventEmitter.emit('playback.state.stop');
@ -152,6 +169,7 @@ export class DiscordVoiceService {
   * Checks if the current state is paused or not and toggles the states to the opposite.
   * @returns The new paused state - true: paused, false: unpaused
   */
+  @OnEvent('internal.voice.controls.togglePause')
  togglePaused(): boolean {
    if (this.isPaused()) {
      this.unpause();
@ -207,7 +225,7 @@ export class DiscordVoiceService {

    if (this.audioPlayer === undefined) {
      this.logger.debug(
-        `Initialized new instance of AudioPlayer because it has not been defined yet`,
+        'Initialized new instance of AudioPlayer because it has not been defined yet',
      );
      this.audioPlayer = createAudioPlayer({
        debug: process.env.DEBUG?.toLowerCase() === 'true',
@ -224,6 +242,20 @@ export class DiscordVoiceService {
  }

  private attachEventListenersToAudioPlayer() {
+    if (!this.voiceConnection) {
+      this.logger.error(
+        `Unable to attach listener events, because the VoiceConnection was undefined`,
+      );
+      return;
+    }
+
+    if (!this.audioPlayer) {
+      this.logger.error(
+        `Unable to attach listener events, because the AudioPlayer was undefined`,
+      );
+      return;
+    }
+
    this.voiceConnection.on('debug', (message) => {
      if (process.env.DEBUG?.toLowerCase() !== 'true') {
        return;
@ -241,6 +273,13 @@ export class DiscordVoiceService {
      this.logger.error(message);
    });
    this.audioPlayer.on('stateChange', (previousState) => {
+      if (!this.audioPlayer) {
+        this.logger.error(
+          `Unable to process state change from audio player, because the current audio player in the callback was undefined`,
+        );
+        return;
+      }
+
      this.logger.debug(
        `Audio player changed state from ${previousState.status} to ${this.audioPlayer.state.status}`,
      );
@ -253,22 +292,60 @@ export class DiscordVoiceService {
        return;
      }

-      this.logger.debug(`Audio player finished playing old resource`);
+      this.logger.debug('Audio player finished playing old resource');

-      const hasNextTrack = this.playbackService
-        .getPlaylistOrDefault()
-        .hasNextTrackInPlaylist();
+      const playlist = this.playbackService.getPlaylistOrDefault();
+      const finishedTrack = playlist.getActiveTrack();
+
+      if (finishedTrack) {
+        finishedTrack.playing = false;
+        this.eventEmitter.emit('internal.audio.track.finish', finishedTrack);
+      }
+
+      const hasNextTrack = playlist.hasNextTrackInPlaylist();

      this.logger.debug(
        `Playlist has next track: ${hasNextTrack ? 'yes' : 'no'}`,
      );

      if (!hasNextTrack) {
-        this.logger.debug(`Reached the end of the playlist`);
+        this.logger.debug('Reached the end of the playlist');
        return;
      }

      this.playbackService.getPlaylistOrDefault().setNextTrackAsActiveTrack();
    });
  }
+
+  @Interval(500)
+  private checkAudioResourcePlayback() {
+    if (!this.audioResource) {
+      return;
+    }
+
+    const progress = this.audioResource.playbackDuration;
+
+    const playlist = this.playbackService.getPlaylistOrDefault();
+
+    if (!playlist) {
+      this.logger.error(
+        `Failed to update ellapsed audio time because playlist was unexpectitly undefined`,
+      );
+      return;
+    }
+
+    const activeTrack = playlist.getActiveTrack();
+
+    if (!activeTrack) {
+      this.logger.error(
+        `Failed to update ellapsed audio time because active track was unexpectitly undefined`,
+      );
+      return;
+    }
+
+    activeTrack.updatePlaybackProgress(progress);
+    this.logger.verbose(
+      `Reporting progress: ${progress} on track ${activeTrack.id}`,
+    );
+  }
 }
--- a/src/clients/jellyfin/jellyfin.playstate.service.ts
+++ b/src/clients/jellyfin/jellyfin.playstate.service.ts
@ -10,9 +10,10 @@ import { getSessionApi } from '@jellyfin/sdk/lib/utils/api/session-api';

 import { Injectable, Logger } from '@nestjs/common';
 import { OnEvent } from '@nestjs/event-emitter';
+import { Interval } from '@nestjs/schedule';
+import { Track } from '../../models/shared/Track';

 import { PlaybackService } from '../../playback/playback.service';
-import { Track } from '../../types/track';

@Injectable()
 export class JellyinPlaystateService {
@ -46,12 +47,71 @@ export class JellyinPlaystateService {
    this.logger.debug('Reported playback capabilities sucessfully');
  }

-  @OnEvent('playback.newTrack')
+  @OnEvent('internal.audio.track.announce')
  private async onPlaybackNewTrack(track: Track) {
+    this.logger.debug(`Reporting playback start on track '${track.id}'`);
    await this.playstateApi.reportPlaybackStart({
      playbackStartInfo: {
-        ItemId: track.jellyfinId,
+        ItemId: track.id,
+        PositionTicks: 0,
      },
    });
  }
+
+  @OnEvent('internal.audio.track.finish')
+  private async onPlaybackFinished(track: Track) {
+    if (!track) {
+      this.logger.error(
+        'Unable to report playback because finished track was undefined',
+      );
+      return;
+    }
+    this.logger.debug(`Reporting playback finish on track '${track.id}'`);
+    await this.playstateApi.reportPlaybackStopped({
+      playbackStopInfo: {
+        ItemId: track.id,
+        PositionTicks: track.playbackProgress * 10000,
+      },
+    });
+  }
+
+  @OnEvent('playback.state.pause')
+  private async onPlaybackPause(paused: boolean) {
+    const track = this.playbackService.getPlaylistOrDefault().getActiveTrack();
+
+    if (!track) {
+      this.logger.error(
+        'Unable to report changed playstate to Jellyfin because no track was active',
+      );
+      return;
+    }
+
+    this.playstateApi.reportPlaybackProgress({
+      playbackProgressInfo: {
+        IsPaused: paused,
+        ItemId: track.id,
+        PositionTicks: track.playbackProgress * 10000,
+      },
+    });
+  }
+
+  @Interval(1000)
+  private async onPlaybackProgress() {
+    const track = this.playbackService.getPlaylistOrDefault().getActiveTrack();
+
+    if (!track) {
+      return;
+    }
+
+    await this.playstateApi.reportPlaybackProgress({
+      playbackProgressInfo: {
+        ItemId: track.id,
+        PositionTicks: track.playbackProgress * 10000,
+      },
+    });
+
+    this.logger.verbose(
+      `Reported playback progress ${track.playbackProgress} to Jellyfin for item ${track.id}`,
+    );
+  }
 }
--- a/src/clients/jellyfin/jellyfin.search.service.ts
+++ b/src/clients/jellyfin/jellyfin.search.service.ts
@ -1,4 +1,5 @@
 import {
+  BaseItemDto,
  BaseItemKind,
  RemoteImageResult,
  SearchHint as JellyfinSearchHint,
@ -37,7 +38,7 @@ export class JellyfinSearchService {

    if (includeItemTypes.length === 0) {
      this.logger.warn(
-        `Included item types are empty. This may lead to unwanted results`,
+        "Included item types are empty. This may lead to unwanted results",
      );
    }

@ -57,9 +58,13 @@ export class JellyfinSearchService {

      const { SearchHints } = data;

-      return SearchHints.map((hint) => this.transformToSearchHint(hint)).filter(
-        (x) => x !== null,
-      );
+      if (!SearchHints) {
+        throw new Error('SearchHints were undefined');
+      }
+
+      return SearchHints.map((hint) =>
+        this.transformToSearchHintFromHint(hint),
+      ).filter((x) => x !== null) as SearchHint[];
    } catch (err) {
      this.logger.error(`Failed to search on Jellyfin: ${err}`);
      return [];
@ -82,8 +87,15 @@ export class JellyfinSearchService {
      return [];
    }

+    if (!axiosResponse.data.Items) {
+      this.logger.error(
+        `Jellyfin search returned no items: ${axiosResponse.data}`,
+      );
+      return [];
+    }
+
    return axiosResponse.data.Items.map((hint) =>
-      SearchHint.constructFromHint(hint),
+      SearchHint.constructFromBaseItem(hint),
    );
  }

@ -104,15 +116,22 @@ export class JellyfinSearchService {
      return [];
    }

-    return axiosResponse.data.SearchHints.map((hint) =>
-      SearchHint.constructFromHint(hint),
-    );
+    if (!axiosResponse.data.SearchHints) {
+      this.logger.error(
+        `Received an unexpected empty list but expected a list of tracks of the album`,
+      );
+      return [];
+    }
+
+    return [...axiosResponse.data.SearchHints]
+      .reverse()
+      .map((hint) => SearchHint.constructFromHint(hint));
  }

  async getById(
    id: string,
    includeItemTypes: BaseItemKind[],
-  ): Promise<SearchHint> | undefined {
+  ): Promise<SearchHint | undefined> {
    const api = this.jellyfinService.getApi();

    const searchApi = getItemsApi(api);
@ -122,12 +141,35 @@ export class JellyfinSearchService {
      includeItemTypes: includeItemTypes,
    });

-    if (data.Items.length !== 1) {
+    if (!data.Items || data.Items.length !== 1) {
      this.logger.warn(`Failed to retrieve item via id '${id}'`);
-      return null;
+      return undefined;
    }

-    return this.transformToSearchHint(data.Items[0]);
+    return this.transformToSearchHintFromBaseItemDto(data.Items[0]);
+  }
+
+  async getAllById(
+    ids: string[],
+    includeItemTypes: BaseItemKind[] = [BaseItemKind.Audio],
+  ): Promise<SearchHint[]> {
+    const api = this.jellyfinService.getApi();
+
+    const searchApi = getItemsApi(api);
+    const { data } = await searchApi.getItems({
+      ids: ids,
+      userId: this.jellyfinService.getUserId(),
+      includeItemTypes: includeItemTypes,
+    });
+
+    if (!data.Items || data.Items.length !== 1) {
+      this.logger.warn(`Failed to retrieve item via id '${ids}'`);
+      return [];
+    }
+
+    return data.Items.map((item) =>
+      this.transformToSearchHintFromBaseItemDto(item),
+    ).filter((searchHint) => searchHint !== undefined) as SearchHint[];
  }

  async getRemoteImageById(id: string, limit = 20): Promise<RemoteImageResult> {
@ -170,7 +212,38 @@ export class JellyfinSearchService {
    }
  }

-  private transformToSearchHint(jellyifnHint: JellyfinSearchHint) {
+  async getRandomTracks(limit: number) {
+    const api = this.jellyfinService.getApi();
+    const searchApi = getItemsApi(api);
+
+    try {
+      const response = await searchApi.getItems({
+        includeItemTypes: [BaseItemKind.Audio],
+        limit: limit,
+        sortBy: ['random'],
+        userId: this.jellyfinService.getUserId(),
+        recursive: true,
+      });
+
+      if (!response.data.Items) {
+        this.logger.error(
+          `Received empty list of items but expected a random list of tracks`,
+        );
+        return [];
+      }
+
+      return response.data.Items.map((item) => {
+        return SearchHint.constructFromBaseItem(item);
+      });
+    } catch (err) {
+      this.logger.error(
+        `Unable to retrieve random items from Jellyfin: ${err}`,
+      );
+      return [];
+    }
+  }
+
+  private transformToSearchHintFromHint(jellyifnHint: JellyfinSearchHint) {
    switch (jellyifnHint.Type) {
      case BaseItemKind[BaseItemKind.Audio]:
        return SearchHint.constructFromHint(jellyifnHint);
@ -182,7 +255,23 @@ export class JellyfinSearchService {
        this.logger.warn(
          `Received unexpected item type from Jellyfin search: ${jellyifnHint.Type}`,
        );
-        return null;
+        return undefined;
+    }
+  }
+
+  private transformToSearchHintFromBaseItemDto(baseItemDto: BaseItemDto) {
+    switch (baseItemDto.Type) {
+      case BaseItemKind[BaseItemKind.Audio]:
+        return SearchHint.constructFromBaseItem(baseItemDto);
+      case BaseItemKind[BaseItemKind.MusicAlbum]:
+        return AlbumSearchHint.constructFromBaseItem(baseItemDto);
+      case BaseItemKind[BaseItemKind.Playlist]:
+        return PlaylistSearchHint.constructFromBaseItem(baseItemDto);
+      default:
+        this.logger.warn(
+          `Received unexpected item type from Jellyfin search: ${baseItemDto.Type}`,
+        );
+        return undefined;
    }
  }
 }
--- a/src/clients/jellyfin/jellyfin.service.ts
+++ b/src/clients/jellyfin/jellyfin.service.ts
@ -33,18 +33,20 @@ export class JellyfinService {
      },
    });

-    this.api = this.jellyfin.createApi(process.env.JELLYFIN_SERVER_ADDRESS);
+    this.api = this.jellyfin.createApi(
+      process.env.JELLYFIN_SERVER_ADDRESS ?? '',
+    );
    this.logger.debug('Created Jellyfin Client and Api');
  }

  authenticate() {
    this.api
      .authenticateUserByName(
-        process.env.JELLYFIN_AUTHENTICATION_USERNAME,
+        process.env.JELLYFIN_AUTHENTICATION_USERNAME ?? '',
        process.env.JELLYFIN_AUTHENTICATION_PASSWORD,
      )
      .then(async (response) => {
-        if (response.data.SessionInfo === undefined) {
+        if (response.data.SessionInfo?.UserId === undefined) {
          this.logger.error(
            `Failed to authenticate with response code ${response.status}: '${response.data}'`,
          );
--- a/src/clients/jellyfin/jellyfin.websocket.service.ts
+++ b/src/clients/jellyfin/jellyfin.websocket.service.ts
@ -4,8 +4,9 @@ import {
 } from '@jellyfin/sdk/lib/generated-client/models';

 import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
-import { Cron } from '@nestjs/schedule';
 import { EventEmitter2 } from '@nestjs/event-emitter';
+import { Cron } from '@nestjs/schedule';
+import { convertToTracks } from 'src/utils/trackConverter';

 import { WebSocket } from 'ws';

@ -14,11 +15,9 @@ import {
  PlayNowCommand,
  SessionApiSendPlaystateCommandRequest,
 } from '../../types/websocket';
-import { Track } from '../../models/shared/Track';

 import { JellyfinSearchService } from './jellyfin.search.service';
 import { JellyfinService } from './jellyfin.service';
-import { JellyfinStreamBuilderService } from './jellyfin.stream.builder.service';

@Injectable()
 export class JellyfinWebSocketService implements OnModuleDestroy {
@ -28,9 +27,8 @@ export class JellyfinWebSocketService implements OnModuleDestroy {

  constructor(
    private readonly jellyfinService: JellyfinService,
-    private readonly jellyfinSearchService: JellyfinSearchService,
    private readonly playbackService: PlaybackService,
-    private readonly jellyfinStreamBuilderService: JellyfinStreamBuilderService,
+    private readonly jellyfinSearchService: JellyfinSearchService,
    private readonly eventEmitter: EventEmitter2,
  ) {}

@ -103,8 +101,12 @@ export class JellyfinWebSocketService implements OnModuleDestroy {
        data.hasSelection = PlayNowCommand.prototype.hasSelection;
        data.getSelection = PlayNowCommand.prototype.getSelection;
        const ids = data.getSelection();
-
-        // TODO: Implement this again
+        this.logger.log(
+          `Processing ${ids.length} ids received via websocket and adding them to the queue`,
+        );
+        const searchHints = await this.jellyfinSearchService.getAllById(ids);
+        const tracks = convertToTracks(searchHints, this.jellyfinSearchService);
+        this.playbackService.getPlaylistOrDefault().enqueueTracks(tracks);
        break;
      case SessionMessageType[SessionMessageType.Playstate]:
        const sendPlaystateCommandRequest =
@ -124,13 +126,19 @@ export class JellyfinWebSocketService implements OnModuleDestroy {
  ) {
    switch (request.Command) {
      case PlaystateCommand.PlayPause:
-        this.eventEmitter.emitAsync('playback.control.togglePause');
+        this.eventEmitter.emit('internal.voice.controls.togglePause');
        break;
      case PlaystateCommand.Pause:
-        this.eventEmitter.emitAsync('playback.control.pause');
+        this.eventEmitter.emit('internal.voice.controls.pause');
        break;
      case PlaystateCommand.Stop:
-        this.eventEmitter.emitAsync('playback.control.stop');
+        this.eventEmitter.emit('internal.voice.controls.stop');
+        break;
+      case PlaystateCommand.NextTrack:
+        this.eventEmitter.emit('internal.audio.track.next');
+        break;
+      case PlaystateCommand.PreviousTrack:
+        this.eventEmitter.emit('internal.audio.track.previous');
        break;
      default:
        this.logger.warn(
--- a/src/commands/command.module.ts
+++ b/src/commands/command.module.ts
@ -15,6 +15,8 @@ import { StatusCommand } from './status.command';
 import { StopPlaybackCommand } from './stop.command';
 import { SummonCommand } from './summon.command';
 import { PlaylistInteractionCollector } from './playlist/playlist.interaction-collector';
+import { EnqueueRandomItemsCommand } from './random/random.command';
+import { VolumeCommand } from './volume/volume.command';

@Module({
  imports: [
@ -28,6 +30,7 @@ import { PlaylistInteractionCollector } from './playlist/playlist.interaction-co
    PlaylistInteractionCollector,
    HelpCommand,
    StatusCommand,
+    EnqueueRandomItemsCommand,
    PlaylistCommand,
    DisconnectCommand,
    PausePlaybackCommand,
@ -36,6 +39,7 @@ import { PlaylistInteractionCollector } from './playlist/playlist.interaction-co
    SummonCommand,
    PlayItemCommand,
    PreviousTrackCommand,
+    VolumeCommand,
  ],
  exports: [],
 })
--- a/src/commands/play/play.comands.ts
+++ b/src/commands/play/play.comands.ts
@ -27,7 +27,7 @@ import { DiscordVoiceService } from '../../clients/discord/discord.voice.service
 import { JellyfinSearchService } from '../../clients/jellyfin/jellyfin.search.service';
 import { SearchHint } from '../../models/search/SearchHint';

-import { SearchType, PlayCommandParams } from './play.params.ts';
+import { PlayCommandParams, SearchType } from './play.params.ts';

@Injectable()
@Command({
@ -48,12 +48,12 @@ export class PlayItemCommand {
  async handler(
    @InteractionEvent(SlashCommandPipe) dto: PlayCommandParams,
    @IA() interaction: CommandInteraction,
-  ): Promise<InteractionReplyOptions | string> {
+  ) {
    await interaction.deferReply({ ephemeral: true });

    const baseItems = PlayCommandParams.getBaseItemKinds(dto.type);

-    let item: SearchHint;
+    let item: SearchHint | undefined;
    if (dto.name.startsWith('native-')) {
      item = await this.jellyfinSearchService.getById(
        dto.name.replace('native-', ''),
@ -70,7 +70,8 @@ export class PlayItemCommand {
        embeds: [
          this.discordMessageService.buildMessage({
            title: 'No results found',
-            description: `- Check for any misspellings\n- Grant me access to your desired libraries\n- Avoid special characters`,
+            description:
+              '- Check for any misspellings\n- Grant me access to your desired libraries\n- Avoid special characters',
          }),
        ],
        ephemeral: true,
@ -94,15 +95,19 @@ export class PlayItemCommand {
    }

    const tracks = await item.toTracks(this.jellyfinSearchService);
+    this.logger.debug(`Extracted ${tracks.length} tracks from the search item`);
    const reducedDuration = tracks.reduce(
      (sum, item) => sum + item.duration,
      0,
    );
+    this.logger.debug(
+      `Adding ${tracks.length} tracks with a duration of ${reducedDuration} ticks`,
+    );
    this.playbackService.getPlaylistOrDefault().enqueueTracks(tracks);

-    const remoteImage: RemoteImageInfo | undefined = tracks
-      .flatMap((x) => x.getRemoteImages())
-      .find((x) => true);
+    const remoteImages = tracks.flatMap((track) => track.getRemoteImages());
+    const remoteImage: RemoteImageInfo | undefined =
+      remoteImages.length > 0 ? remoteImages[0] : undefined;

    await interaction.followUp({
      embeds: [
@ -113,7 +118,7 @@ export class PlayItemCommand {
            reducedDuration,
          )})`,
          mixin(embedBuilder) {
-            if (!remoteImage) {
+            if (!remoteImage?.Url) {
              return embedBuilder;
            }
            return embedBuilder.setThumbnail(remoteImage.Url);
@ -131,8 +136,9 @@ export class PlayItemCommand {
    }

    const focusedAutoCompleteAction = interaction.options.getFocused(true);
-    const typeIndex: number | null = interaction.options.getInteger('type');
-    const type = Object.values(SearchType)[typeIndex] as SearchType;
+    const typeIndex = interaction.options.getInteger('type');
+    const type =
+      typeIndex !== null ? Object.values(SearchType)[typeIndex] : undefined;
    const searchQuery = focusedAutoCompleteAction.value;

    if (!searchQuery || searchQuery.length < 1) {
@ -150,7 +156,7 @@ export class PlayItemCommand {
    const hints = await this.jellyfinSearchService.searchItem(
      searchQuery,
      20,
-      PlayCommandParams.getBaseItemKinds(type),
+      PlayCommandParams.getBaseItemKinds(type as SearchType),
    );

    if (hints.length === 0) {
--- a/src/commands/playlist/playlist.command.ts
+++ b/src/commands/playlist/playlist.command.ts
@ -22,16 +22,19 @@ import {
  InteractionUpdateOptions,
 } from 'discord.js';

-import { PlaybackService } from '../../playback/playback.service';
-import { chunkArray } from '../../utils/arrayUtils';
-import { Constants } from '../../utils/constants';
-import { formatMillisecondsAsHumanReadable } from '../../utils/timeUtils';
 import { DiscordMessageService } from '../../clients/discord/discord.message.service';
 import { Track } from '../../models/shared/Track';
-import { trimStringToFixedLength } from '../../utils/stringUtils/stringUtils';
+import { PlaybackService } from '../../playback/playback.service';
+import { chunkArray } from '../../utils/arrayUtils';
+import { trimStringToFixedLength, zeroPad } from '../../utils/stringUtils/stringUtils';

+import { Interval } from '@nestjs/schedule';
+import { lightFormat } from 'date-fns';
 import { PlaylistInteractionCollector } from './playlist.interaction-collector';
 import { PlaylistCommandParams } from './playlist.params';
+import { PlaylistTempCommandData } from './playlist.types';
+import { tr } from 'date-fns/locale';
+import { takeCoverage } from 'v8';

@Injectable()
@Command({
@ -41,7 +44,7 @@ import { PlaylistCommandParams } from './playlist.params';
@UseInterceptors(CollectorInterceptor)
@UseCollectors(PlaylistInteractionCollector)
 export class PlaylistCommand {
-  public pageData: Map<string, number> = new Map();
+  public pageData: Map<string, PlaylistTempCommandData> = new Map();
  private readonly logger = new Logger(PlaylistCommand.name);

  constructor(
@ -61,7 +64,10 @@ export class PlaylistCommand {
      this.getReplyForPage(page) as InteractionReplyOptions,
    );

-    this.pageData.set(interaction.id, page);
+    this.pageData.set(interaction.id, {
+      page,
+      interaction,
+    });
    this.logger.debug(
      `Added '${interaction.id}' as a message id for page storage`,
    );
@ -82,6 +88,36 @@ export class PlaylistCommand {
    return chunkArray(playlist.tracks, 10);
  }

+  private createInterval(interaction: CommandInteraction) {
+    return setInterval(async () => {
+      const tempData = this.pageData.get(interaction.id);
+
+      if (!tempData) {
+        this.logger.warn(
+          `Failed to update from interval, because temp data was not found`,
+        );
+        return;
+      }
+
+      await interaction.editReply(this.getReplyForPage(tempData.page));
+    }, 2000);
+  }
+
+  @Interval(2 * 1000)
+  private async updatePlaylists() {
+    if (this.pageData.size === 0) {
+      return;
+    }
+
+    this.logger.verbose(
+      `Updating playlist for ${this.pageData.size} playlist datas`,
+    );
+
+    this.pageData.forEach(async (value) => {
+      await value.interaction.editReply(this.getReplyForPage(value.page));
+    });
+  }
+
  public getReplyForPage(
    page: number,
  ): InteractionReplyOptions | InteractionUpdateOptions {
@ -176,26 +212,34 @@ export class PlaylistCommand {
      );
    }

+    const paddingNumber = playlist.getLength() >= 100 ? 3 : 2;
+
    const content = chunk
      .map((track, index) => {
        const isCurrent = track === playlist.getActiveTrack();

-        // use the offset for the page, add the current index and offset by one because the array index is used
-        let point = `${offset + index + 1}. `;
-        point += `**${trimStringToFixedLength(track.name, 30)}**`;
-
+        let line = `\`\`${zeroPad(offset + index + 1, paddingNumber)}.\`\` `;
+        line += this.getTrackName(track, isCurrent) + ' • ';
        if (isCurrent) {
-          point += ' :loud_sound:';
+          line += lightFormat(track.getPlaybackProgress(), 'mm:ss') + ' / ';
        }
-
-        point += '\n';
-        point += Constants.Design.InvisibleSpace.repeat(2);
-        point += formatMillisecondsAsHumanReadable(track.getDuration());
-
-        return point;
+        line += lightFormat(track.getDuration(), 'mm:ss');
+        if (isCurrent) {
+          line += ' • (:play_pause:)';
+        }
+        return line;
      })
      .join('\n');

    return new EmbedBuilder().setTitle('Your playlist').setDescription(content);
  }
+
+  private getTrackName(track: Track, active: boolean) {
+    const trimmedTitle = trimStringToFixedLength(track.name, 30);
+    if (active) {
+      return `**${trimmedTitle}**`;
+    }
+
+    return trimmedTitle;
+  }
 }
--- a/src/commands/playlist/playlist.interaction-collector.ts
+++ b/src/commands/playlist/playlist.interaction-collector.ts
@ -15,6 +15,7 @@ import {
 } from 'discord.js';

 import { PlaylistCommand } from './playlist.command';
+import { PlaylistTempCommandData } from './playlist.types';

@Injectable({ scope: Scope.REQUEST })
@InteractionEventCollector({ time: 60 * 1000 })
@ -30,14 +31,17 @@ export class PlaylistInteractionCollector {

  @Filter()
  filter(interaction: ButtonInteraction): boolean {
-    return this.causeInteraction.id === interaction.message.interaction.id;
+    return (
+      interaction.message.interaction !== null &&
+      this.causeInteraction.id === interaction.message.interaction.id
+    );
  }

  @On('collect')
  async onCollect(interaction: ButtonInteraction): Promise<void> {
    const targetPage = this.getInteraction(interaction);
    this.logger.verbose(
-      `Extracted the target page ${targetPage} from the button interaction`,
+      `Extracted the target page '${targetPage?.page}' from the button interaction`,
    );

    if (targetPage === undefined) {
@ -48,14 +52,16 @@ export class PlaylistInteractionCollector {
    }

    this.logger.debug(
-      `Updating current page for interaction ${this.causeInteraction.id} to ${targetPage}`,
+      `Updating current page for interaction ${this.causeInteraction.id} to ${targetPage.page}`,
    );
    this.playlistCommand.pageData.set(this.causeInteraction.id, targetPage);
-    const reply = this.playlistCommand.getReplyForPage(targetPage);
+    const reply = this.playlistCommand.getReplyForPage(targetPage.page);
    await interaction.update(reply as InteractionUpdateOptions);
  }

-  private getInteraction(interaction: ButtonInteraction): number | null {
+  private getInteraction(
+    interaction: ButtonInteraction,
+  ): PlaylistTempCommandData | undefined {
    const current = this.playlistCommand.pageData.get(this.causeInteraction.id);

    if (current === undefined) {
@ -75,12 +81,18 @@ export class PlaylistInteractionCollector {

    switch (interaction.customId) {
      case 'playlist-controls-next':
-        return current + 1;
+        return {
+          ...current,
+          page: current.page + 1,
+        };
      case 'playlist-controls-previous':
-        return current - 1;
+        return {
+          ...current,
+          page: current.page - 1,
+        };
      default:
        this.logger.error(
-          `Unable to map button interaction from collector to target page`,
+          'Unable to map button interaction from collector to target page',
        );
        return undefined;
    }
--- a/src/commands/playlist/playlist.types.ts
+++ b/src/commands/playlist/playlist.types.ts
@ -0,0 +1,6 @@
+import { CommandInteraction } from 'discord.js';
+
+export type PlaylistTempCommandData = {
+  page: number;
+  interaction: CommandInteraction;
+};
--- a/src/commands/random/random.command.ts
+++ b/src/commands/random/random.command.ts
@ -0,0 +1,76 @@
+import { SlashCommandPipe } from '@discord-nestjs/common';
+import { Command, Handler, IA, InteractionEvent } from '@discord-nestjs/core';
+import { Injectable } from '@nestjs/common';
+import {
+  CommandInteraction,
+  GuildMember,
+  InteractionReplyOptions,
+} from 'discord.js';
+import { DiscordMessageService } from 'src/clients/discord/discord.message.service';
+import { DiscordVoiceService } from 'src/clients/discord/discord.voice.service';
+import { JellyfinSearchService } from 'src/clients/jellyfin/jellyfin.search.service';
+import { SearchHint } from 'src/models/search/SearchHint';
+import { PlaybackService } from 'src/playback/playback.service';
+import { RandomCommandParams } from './random.params';
+
+@Command({
+  name: 'random',
+  description: 'Enqueues a random selection of tracks to your playlist',
+})
+@Injectable()
+export class EnqueueRandomItemsCommand {
+  constructor(
+    private readonly playbackService: PlaybackService,
+    private readonly discordVoiceService: DiscordVoiceService,
+    private readonly discordMessageService: DiscordMessageService,
+    private readonly jellyfinSearchService: JellyfinSearchService,
+  ) {}
+
+  @Handler()
+  async handler(
+    @InteractionEvent(SlashCommandPipe) dto: RandomCommandParams,
+    @IA() interaction: CommandInteraction,
+  ): Promise<void> {
+    await interaction.deferReply();
+
+    const guildMember = interaction.member as GuildMember;
+
+    const tryResult =
+      this.discordVoiceService.tryJoinChannelAndEstablishVoiceConnection(
+        guildMember,
+      );
+
+    if (!tryResult.success) {
+      const replyOptions = tryResult.reply as InteractionReplyOptions;
+      await interaction.editReply({
+        embeds: replyOptions.embeds,
+      });
+      return;
+    }
+
+    const items = await this.jellyfinSearchService.getRandomTracks(dto.count);
+    const tracks = await this.getTracks(items);
+
+    this.playbackService.getPlaylistOrDefault().enqueueTracks(tracks);
+
+    await interaction.editReply({
+      embeds: [
+        this.discordMessageService.buildMessage({
+          title: `Added ${tracks.length} tracks to your playlist`,
+          description: 'Use ``/playlist`` to see them',
+        }),
+      ],
+    });
+  }
+
+  private async getTracks(hints: SearchHint[]) {
+    const promises = await Promise.all(
+      hints.flatMap(async (item) => {
+        const tracks = await item.toTracks(this.jellyfinSearchService);
+        return tracks;
+      }),
+    );
+
+    return promises.flatMap((x) => x);
+  }
+}
--- a/src/commands/random/random.params.ts
+++ b/src/commands/random/random.params.ts
@ -0,0 +1,12 @@
+import { Param, ParamType } from '@discord-nestjs/core';
+
+export class RandomCommandParams {
+  @Param({
+    required: false,
+    description: 'Count of items to search for',
+    type: ParamType.INTEGER,
+    minValue: 0,
+    maxValue: 10000,
+  })
+  count = 20;
+}
--- a/src/commands/status.command.ts
+++ b/src/commands/status.command.ts
@ -39,7 +39,7 @@ export class StatusCommand {
    const status = Status[this.client.ws.status];

    const interval = intervalToDuration({
-      start: this.client.uptime,
+      start: this.client.uptime ?? 0,
      end: 0,
    });
    const formattedDuration = formatDuration(interval);
--- a/src/commands/stop.command.ts
+++ b/src/commands/stop.command.ts
@ -30,8 +30,8 @@ export class StopPlaybackCommand {
      ? 'In addition, your playlist has been cleared'
      : 'There is no active track in the queue';
    if (hasActiveTrack) {
-      this.playbackService.getPlaylistOrDefault().clear();
      this.discordVoiceService.stop(false);
+      // this.playbackService.getPlaylistOrDefault().clear();
    }

    await interaction.reply({
--- a/src/commands/volume/volume.command.ts
+++ b/src/commands/volume/volume.command.ts
@ -0,0 +1,69 @@
+import { SlashCommandPipe } from '@discord-nestjs/common';
+import { Command, Handler, IA, InteractionEvent } from '@discord-nestjs/core';
+import { Logger } from '@nestjs/common';
+
+import { Injectable } from '@nestjs/common/decorators';
+
+import { CommandInteraction } from 'discord.js';
+import { DiscordMessageService } from 'src/clients/discord/discord.message.service';
+import { DiscordVoiceService } from 'src/clients/discord/discord.voice.service';
+import { PlaybackService } from 'src/playback/playback.service';
+import { sleep } from 'src/utils/timeUtils';
+import { VolumeCommandParams } from './volume.params';
+
+@Injectable()
+@Command({
+  name: 'volume',
+  description: 'Change the volume',
+})
+export class VolumeCommand {
+  private readonly logger = new Logger(VolumeCommand.name);
+
+  constructor(
+    private readonly discordVoiceService: DiscordVoiceService,
+    private readonly discordMessageService: DiscordMessageService,
+    private readonly playbackService: PlaybackService,
+  ) {}
+
+  @Handler()
+  async handler(
+    @InteractionEvent(SlashCommandPipe) dto: VolumeCommandParams,
+    @IA() interaction: CommandInteraction,
+  ): Promise<void> {
+    await interaction.deferReply();
+
+    if (!this.playbackService.getPlaylistOrDefault().hasActiveTrack()) {
+      await interaction.editReply({
+        embeds: [
+          this.discordMessageService.buildMessage({
+            title: "Unable to change your volume",
+            description:
+              'The bot is not playing any music or is not straming to a channel',
+          }),
+        ],
+      });
+      return;
+    }
+
+    const volume = dto.volume / 100;
+
+    this.logger.debug(
+      `Calculated volume ${volume} from dto param ${dto.volume}`,
+    );
+
+    this.discordVoiceService.changeVolume(volume);
+
+    // Discord takes some time to react. Confirmation message should appear after actual change
+    await sleep(1500);
+
+    await interaction.editReply({
+      embeds: [
+        this.discordMessageService.buildMessage({
+          title: `Sucessfully set volume to ${dto.volume.toFixed(0)}%`,
+          description:
+            'Updating may take a few seconds to take effect.\nPlease note that listening at a high volume for a long time may damage your hearing',
+        }),
+      ],
+    });
+  }
+}
--- a/src/commands/volume/volume.params.ts
+++ b/src/commands/volume/volume.params.ts
@ -0,0 +1,12 @@
+import { Param, ParamType } from '@discord-nestjs/core';
+
+export class VolumeCommandParams {
+  @Param({
+    required: true,
+    description: 'The desired volume',
+    type: ParamType.INTEGER,
+    minValue: 0,
+    maxValue: 150,
+  })
+  volume: number;
+}
--- a/src/health/health.controller.spec.ts
+++ b/src/health/health.controller.spec.ts
@ -1,3 +1,4 @@
+import { InjectionToken } from '@nestjs/common';
 import {
  HealthCheckResult,
  HealthCheckService,
@ -42,10 +43,14 @@ describe('HealthController', () => {
        }

        if (token === HealthCheckService) {
-          return new HealthCheckService(new HealthCheckExecutor(), null, null);
+          return new HealthCheckService(
+            new HealthCheckExecutor(),
+            { getErrorMessage: jest.fn() },
+            { log: jest.fn(), error: jest.fn(), warn: jest.fn() },
+          );
        }

-        return useDefaultMockerToken(token);
+        return useDefaultMockerToken(token as InjectionToken);
      })
      .compile();

--- a/src/health/indicators/jeyllfin.indicator.spec.ts
+++ b/src/health/indicators/jeyllfin.indicator.spec.ts
@ -1,3 +1,4 @@
+import { InjectionToken } from '@nestjs/common';
 import { HealthIndicatorResult } from '@nestjs/terminus';
 import { Test } from '@nestjs/testing';
 import { JellyfinService } from '../../clients/jellyfin/jellyfin.service';
@ -16,7 +17,7 @@ describe('JellyfinHealthIndicator', () => {
        if (token === JellyfinService) {
          return { isConnected: jest.fn() };
        }
-        return useDefaultMockerToken(token);
+        return useDefaultMockerToken(token as InjectionToken);
      })
      .compile();

--- a/src/main.ts
+++ b/src/main.ts
@ -4,6 +4,10 @@ import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';

 function getLoggingLevels(): LogLevel[] {
+  if (!process.env.LOG_LEVEL) {
+    return ['error', 'warn', 'log'];
+  }
+
  switch (process.env.LOG_LEVEL.toLowerCase()) {
    case 'error':
      return ['error'];
--- a/src/models/search/AlbumSearchHint.ts
+++ b/src/models/search/AlbumSearchHint.ts
@ -11,16 +11,28 @@ export class AlbumSearchHint extends SearchHint {
  }

  static constructFromHint(hint: JellyfinSearchHint) {
+    if (hint.Id === undefined || !hint.Name || !hint.RunTimeTicks) {
+      throw new Error(
+        'Unable to construct playlist search hint, required properties were undefined',
+      );
+    }
+
    return new AlbumSearchHint(hint.Id, hint.Name, hint.RunTimeTicks / 10000);
  }

  override async toTracks(
    searchService: JellyfinSearchService,
  ): Promise<Track[]> {
+    const remoteImages = await searchService.getRemoteImageById(this.id);
    const albumItems = await searchService.getAlbumItems(this.id);
-    const tracks = albumItems.map(async (x) =>
-      (await x.toTracks(searchService)).find((x) => x !== null),
+    const tracks = await Promise.all(
+      albumItems.map(async (x) =>
+        (await x.toTracks(searchService)).find((x) => x !== null),
+      ),
    );
-    return await Promise.all(tracks);
+    return tracks.map((track: Track): Track => {
+      track.remoteImages = remoteImages;
+      return track;
+    });
  }
 }
--- a/src/models/search/PlaylistSearchHint.ts
+++ b/src/models/search/PlaylistSearchHint.ts
@ -4,6 +4,7 @@ import { Track } from '../shared/Track';
 import { JellyfinSearchService } from '../../clients/jellyfin/jellyfin.search.service';

 import { SearchHint } from './SearchHint';
+import { convertToTracks } from 'src/utils/trackConverter';

 export class PlaylistSearchHint extends SearchHint {
  override toString(): string {
@ -11,6 +12,12 @@ export class PlaylistSearchHint extends SearchHint {
  }

  static constructFromHint(hint: JellyfinSearchHint) {
+    if (hint.Id === undefined || !hint.Name || !hint.RunTimeTicks) {
+      throw new Error(
+        'Unable to construct playlist search hint, required properties were undefined',
+      );
+    }
+
    return new PlaylistSearchHint(
      hint.Id,
      hint.Name,
@ -22,9 +29,6 @@ export class PlaylistSearchHint extends SearchHint {
    searchService: JellyfinSearchService,
  ): Promise<Track[]> {
    const playlistItems = await searchService.getPlaylistitems(this.id);
-    const tracks = playlistItems.map(async (x) =>
-      (await x.toTracks(searchService)).find((x) => x !== null),
-    );
-    return await Promise.all(tracks);
+    return convertToTracks(playlistItems, searchService);
  }
 }
--- a/src/models/search/SearchHint.ts
+++ b/src/models/search/SearchHint.ts
@ -1,7 +1,11 @@
-import { SearchHint as JellyfinSearchHint } from '@jellyfin/sdk/lib/generated-client/models';
+import {
+  BaseItemDto,
+  SearchHint as JellyfinSearchHint,
+} from '@jellyfin/sdk/lib/generated-client/models';
+import { z } from 'zod';

-import { Track } from '../shared/Track';
 import { JellyfinSearchService } from '../../clients/jellyfin/jellyfin.search.service';
+import { Track } from '../shared/Track';

 export class SearchHint {
  constructor(
@ -15,10 +19,7 @@ export class SearchHint {
  }

  async toTracks(searchService: JellyfinSearchService): Promise<Track[]> {
-    const remoteImages = await searchService.getRemoteImageById(this.id);
-    return [
-      new Track(this.id, this.name, this.runtimeInMilliseconds, remoteImages),
-    ];
+    return [new Track(this.id, this.name, this.runtimeInMilliseconds, {})];
  }

  getId(): string {
@ -26,6 +27,39 @@ export class SearchHint {
  }

  static constructFromHint(hint: JellyfinSearchHint) {
-    return new SearchHint(hint.Id, hint.Name, hint.RunTimeTicks / 10000);
+    const schema = z.object({
+      Id: z.string(),
+      Name: z.string(),
+      RunTimeTicks: z.number(),
+    });
+
+    const result = schema.safeParse(hint);
+
+    if (!result.success) {
+      throw new Error(
+        `Unable to construct search hint, required properties were undefined: ${JSON.stringify(
+          hint,
+        )}`,
+      );
+    }
+
+    return new SearchHint(
+      result.data.Id,
+      result.data.Name,
+      result.data.RunTimeTicks / 10000,
+    );
+  }
+
+  static constructFromBaseItem(baseItem: BaseItemDto) {
+    if (baseItem.Id === undefined || !baseItem.Name || !baseItem.RunTimeTicks) {
+      throw new Error(
+        'Unable to construct search hint from base item, required properties were undefined',
+      );
+    }
+    return new SearchHint(
+      baseItem.Id,
+      baseItem.Name,
+      baseItem.RunTimeTicks / 10000,
+    );
  }
 }
--- a/src/models/shared/Playlist.ts
+++ b/src/models/shared/Playlist.ts
@ -1,4 +1,4 @@
-import { EventEmitter2 } from '@nestjs/event-emitter';
+import { EventEmitter2, OnEvent } from '@nestjs/event-emitter';

 import { Track } from './Track';

@ -24,7 +24,7 @@ export class Playlist {
   * @returns active track or undefined if there's none
   */
  getActiveTrack(): Track | undefined {
-    if (this.isActiveTrackOutOfSync()) {
+    if (this.isActiveTrackOutOfSync() || this.activeTrackIndex === undefined) {
      return undefined;
    }
    return this.tracks[this.activeTrackIndex];
@ -49,7 +49,12 @@ export class Playlist {
   * @returns if the track has been changed successfully
   */
  setNextTrackAsActiveTrack(): boolean {
-    if (this.activeTrackIndex >= this.tracks.length) {
+    this.announceTrackFinishIfSet();
+
+    if (
+      this.activeTrackIndex === undefined ||
+      this.activeTrackIndex >= this.tracks.length
+    ) {
      return false;
    }

@ -66,7 +71,9 @@ export class Playlist {
   * @returns if the track has been changed successfully
   */
  setPreviousTrackAsActiveTrack(): boolean {
-    if (this.activeTrackIndex <= 0) {
+    this.announceTrackFinishIfSet();
+
+    if (this.activeTrackIndex === undefined || this.activeTrackIndex <= 0) {
      return false;
    }

@ -84,12 +91,25 @@ export class Playlist {
   * @returns the new lendth of the tracks in the playlist
   */
  enqueueTracks(tracks: Track[]) {
+    if (tracks.length === 0) {
+      return 0;
+    }
+
+    const previousTrackLength = this.tracks.length;
+
    this.eventEmitter.emit('controls.playlist.tracks.enqueued', {
      count: tracks.length,
      activeTrack: this.activeTrackIndex,
    });
    const length = this.tracks.push(...tracks);

+    // existing tracks are in the playlist, but none are playing. play the first track out of the new tracks
+    if (!this.hasAnyPlaying() && tracks.length > 0) {
+      this.activeTrackIndex = previousTrackLength;
+      this.announceTrackChange();
+      return length;
+    }
+
    // emit a track change if there is no item
    if (this.activeTrackIndex === undefined) {
      this.announceTrackChange();
@ -103,7 +123,7 @@ export class Playlist {
   * @returns if there is a track next in the playlist
   */
  hasNextTrackInPlaylist() {
-    return this.activeTrackIndex + 1 < this.tracks.length;
+    return (this.activeTrackIndex ?? 0) + 1 < this.tracks.length;
  }

  /**
@ -111,7 +131,7 @@ export class Playlist {
   * @returns if there is a previous track in the playlist
   */
  hasPreviousTrackInPlaylist() {
-    return this.activeTrackIndex > 0;
+    return this.activeTrackIndex !== undefined && this.activeTrackIndex > 0;
  }

  clear() {
@ -120,17 +140,39 @@ export class Playlist {
    this.activeTrackIndex = undefined;
  }

+  private hasAnyPlaying() {
+    return this.tracks.some((track) => track.playing);
+  }
+
+  private announceTrackFinishIfSet() {
+    if (this.activeTrackIndex === undefined) {
+      return;
+    }
+
+    const currentTrack = this.getActiveTrack();
+    this.eventEmitter.emit('internal.audio.track.finish', currentTrack);
+  }
+
  private announceTrackChange() {
    if (!this.activeTrackIndex) {
      this.activeTrackIndex = 0;
    }

-    this.eventEmitter.emit('internal.audio.announce', this.getActiveTrack());
+    const activeTrack = this.getActiveTrack();
+
+    if (!activeTrack) {
+      return;
+    }
+
+    activeTrack.playing = true;
+    this.eventEmitter.emit('internal.audio.track.announce', activeTrack);
  }

  private isActiveTrackOutOfSync(): boolean {
    return (
-      this.activeTrackIndex < 0 || this.activeTrackIndex >= this.tracks.length
+      this.activeTrackIndex === undefined ||
+      this.activeTrackIndex < 0 ||
+      this.activeTrackIndex >= this.tracks.length
    );
  }
 }
--- a/src/models/shared/Track.ts
+++ b/src/models/shared/Track.ts
@ -25,7 +25,11 @@ export class Track {
  /**
   * A result object that contains a collection of images that are available outside the current network.
   */
-  readonly remoteImages?: RemoteImageResult;
+  remoteImages?: RemoteImageResult;
+
+  playing: boolean;
+
+  playbackProgress: number;

  constructor(
    id: string,
@ -37,6 +41,8 @@ export class Track {
    this.name = name;
    this.duration = duration;
    this.remoteImages = remoteImages;
+    this.playing = false;
+    this.playbackProgress = 0;
  }

  getDuration() {
@ -48,6 +54,14 @@ export class Track {
  }

  getRemoteImages(): RemoteImageInfo[] {
-    return this.remoteImages.Images;
+    return this.remoteImages?.Images ?? [];
+  }
+
+  getPlaybackProgress() {
+    return this.playbackProgress;
+  }
+
+  updatePlaybackProgress(progress: number) {
+    this.playbackProgress = progress;
  }
 }
--- a/src/playback/playback.service.ts
+++ b/src/playback/playback.service.ts
@ -1,5 +1,5 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { EventEmitter2 } from '@nestjs/event-emitter';
+import { EventEmitter2, OnEvent } from '@nestjs/event-emitter';

 import { Playlist } from '../models/shared/Playlist';

@ -18,4 +18,14 @@ export class PlaybackService {
    this.playlist = new Playlist(this.eventEmitter);
    return this.playlist;
  }
+
+  @OnEvent('internal.audio.track.previous')
+  private handlePreviousTrackEvent() {
+    this.getPlaylistOrDefault().setPreviousTrackAsActiveTrack();
+  }
+
+  @OnEvent('internal.audio.track.next')
+  private handleNextTrackEvent() {
+    this.getPlaylistOrDefault().setNextTrackAsActiveTrack();
+  }
 }
--- a/src/types/websocket.ts
+++ b/src/types/websocket.ts
@ -30,7 +30,7 @@ export class PlayNowCommand {
  }

  getSelection(): string[] {
-    if (this.hasSelection()) {
+    if (this.hasSelection() && this.StartIndex !== undefined) {
      return [this.ItemIds[this.StartIndex]];
    }

--- a/src/updates/updates.service.spec.ts
+++ b/src/updates/updates.service.spec.ts
@ -1,10 +1,12 @@
 import { Test } from '@nestjs/testing';
 import axios from 'axios';
 import { Client, GuildMember } from 'discord.js';
+import { Constants } from '../utils/constants';
 import { DiscordMessageService } from '../clients/discord/discord.message.service';
 import { GithubRelease } from '../models/github-release';
 import { useDefaultMockerToken } from '../utils/tests/defaultMockerToken';
 import { UpdatesService } from './updates.service';
+import { InjectionToken } from '@nestjs/common';

 // mock axios: https://stackoverflow.com/questions/51275434/type-of-axios-mock-using-jest-typescript/55351900#55351900
 jest.mock('axios');
@ -14,7 +16,6 @@ describe('UpdatesService', () => {
  const OLD_ENV = process.env;

  let updatesService: UpdatesService;
-  let discordClient: Client;
  let discordMessageService: DiscordMessageService;

  beforeEach(async () => {
@ -33,7 +34,7 @@ describe('UpdatesService', () => {
          } as DiscordMessageService;
        }

-        if (token === Client || token == '__inject_discord_client__') {
+        if (token === Client || token === '__inject_discord_client__') {
          return {
            guilds: {
              cache: [
@ -49,12 +50,11 @@ describe('UpdatesService', () => {
          };
        }

-        return useDefaultMockerToken(token);
+        return useDefaultMockerToken(token as InjectionToken);
      })
      .compile();

    updatesService = moduleRef.get<UpdatesService>(UpdatesService);
-    discordClient = moduleRef.get<Client>('__inject_discord_client__');
    discordMessageService = moduleRef.get<DiscordMessageService>(
      DiscordMessageService,
    );
@ -88,6 +88,12 @@ describe('UpdatesService', () => {

  it('handleCronShouldNotifyWhenNewRelease', async () => {
    process.env.UPDATER_DISABLE_NOTIFICATIONS = 'false';
+    Constants.Metadata.Version = {
+      All: () => '0.0.5',
+      Major: 0,
+      Minor: 0,
+      Patch: 5,
+    };

    mockedAxios.mockResolvedValue({
      data: {
--- a/src/updates/updates.service.ts
+++ b/src/updates/updates.service.ts
@ -30,6 +30,14 @@ export class UpdatesService {
    this.logger.debug('Checking for available updates...');

    const latestGitHubRelease = await this.fetchLatestGithubRelease();
+
+    if (!latestGitHubRelease) {
+      this.logger.warn(
+        `Aborting update check because api request failed. Please check your internet connection or disable the check`,
+      );
+      return;
+    }
+
    const currentVersion = Constants.Metadata.Version.All();

    if (latestGitHubRelease.tag_name <= currentVersion) {
@ -95,21 +103,21 @@ export class UpdatesService {
    });
  }

-  private async fetchLatestGithubRelease(): Promise<null | GithubRelease> {
+  private async fetchLatestGithubRelease(): Promise<GithubRelease | undefined> {
    return axios({
      method: 'GET',
      url: Constants.Links.Api.GetLatestRelease,
    })
      .then((response) => {
        if (response.status !== 200) {
-          return null;
+          return undefined;
        }

        return response.data as GithubRelease;
      })
      .catch((err) => {
        this.logger.error('Error while checking for updates', err);
-        return null;
+        return undefined;
      });
  }
 }
--- a/src/utils/stringUtils/stringUtils.ts
+++ b/src/utils/stringUtils/stringUtils.ts
@ -11,3 +11,6 @@ export const trimStringToFixedLength = (value: string, maxLength: number) => {

  return value.substring(0, upperBound) + '...';
 };
+
+export const zeroPad = (num: number, places: number) =>
+  String(num).padStart(places, '0');
--- a/src/utils/timeUtils.ts
+++ b/src/utils/timeUtils.ts
@ -15,3 +15,7 @@ export const formatMillisecondsAsHumanReadable = (
  );
  return duration;
 };
+
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
--- a/src/utils/trackConverter.ts
+++ b/src/utils/trackConverter.ts
@ -0,0 +1,15 @@
+import { JellyfinSearchService } from 'src/clients/jellyfin/jellyfin.search.service';
+import { SearchHint } from 'src/models/search/SearchHint';
+import { Track } from 'src/models/shared/Track';
+
+export const convertToTracks = (
+  hints: SearchHint[],
+  jellyfinSearchService: JellyfinSearchService,
+): Track[] => {
+  let tracks: Track[] = [];
+  hints.forEach(async (hint) => {
+    const searchedTracks = await hint.toTracks(jellyfinSearchService);
+    tracks = [...tracks, ...searchedTracks];
+  });
+  return tracks;
+};
--- a/tsconfig.json
+++ b/tsconfig.json
@ -12,7 +12,7 @@
    "baseUrl": "./",
    "incremental": true,
    "skipLibCheck": true,
-    "strictNullChecks": false,
+    "strictNullChecks": true,
    "noImplicitAny": false,
    "strictBindCallApply": false,
    "forceConsistentCasingInFileNames": false,
--- a/yarn.lock
+++ b/yarn.lock