Fix deadlock and auto leave voice channel after 3 min (#4)

* Fix for thread being busy handling discord commands blocking audioplayer to timeout
* Auto leave if alone in voice channel after 3 min

Co-authored-by: Myx <info@azaaxin.com>

Bot/Handler/GoodByeCommand/GoodbyeHandler.cs

@@ -1,14 +0,0 @@
-using Discord.WebSocket;
-using MediatR;
-
-namespace Lunaris2.Handler.GoodByeCommand;
-
-public record GoodbyeCommand(SocketSlashCommand Message) : IRequest;
-
-public class GoodbyeHandler : IRequestHandler<GoodbyeCommand>
-{
-    public async Task Handle(GoodbyeCommand message, CancellationToken cancellationToken)
-    {
-        await message.Message.RespondAsync($"Goodbye, {message.Message.User.Username}! :c");
-    }
-}

Bot/Handler/HelloCommand/HelloHandler.cs

@@ -1,18 +0,0 @@
-using Discord.WebSocket;
-using Lunaris2.SlashCommand;
-using MediatR;
-using Newtonsoft.Json;
-
-namespace Lunaris2.Handler.HelloCommand;
-
-public record HelloCommand(SocketSlashCommand Message) : IRequest;
-
-public class HelloHandler : IRequestHandler<HelloCommand>
-{
-    public async Task Handle(HelloCommand message, CancellationToken cancellationToken)
-    {
-        Console.WriteLine(JsonConvert.SerializeObject(Command.GetAllCommands()));
-            
-        await message.Message.RespondAsync($"Hello, {message.Message.User.Username}!");
-    }
-}

Bot/Handler/MusicPlayer/DisconnectCommand/DisconnectHandler.cs

@@ -0,0 +1,22 @@
+using Discord.WebSocket;
+using Lavalink4NET;
+using MediatR;
+
+namespace Lunaris2.Handler.MusicPlayer.DisconnectCommand;
+
+public record DisconnectCommand(SocketSlashCommand Message) : IRequest;
+
+public class DisconnectHandler(DiscordSocketClient client, IAudioService audioService) : IRequestHandler<DisconnectCommand>
+{
+    public async Task Handle(DisconnectCommand command, CancellationToken cancellationToken)
+    {
+        var context = command.Message;
+        var player = await audioService.GetPlayerAsync(client, context, connectToVoiceChannel: true);
+
+        if (player is null)
+            return;
+
+        await player.DisconnectAsync(cancellationToken).ConfigureAwait(false);
+        await context.RespondAsync("Disconnected.").ConfigureAwait(false);
+    }
+}

Bot/Handler/MusicPlayer/Extensions.cs

@@ -1,11 +1,46 @@
 using Discord;
 using Discord.WebSocket;
-using Victoria.Node;
+using Lavalink4NET;
+using Lavalink4NET.Players;
+using Lavalink4NET.Players.Queued;
+using Microsoft.Extensions.Options;
 
 namespace Lunaris2.Handler.MusicPlayer;
 
 public static class Extensions
 {
+    public static async ValueTask<QueuedLavalinkPlayer?> GetPlayerAsync(
+        this IAudioService audioService, 
+        DiscordSocketClient client, 
+        SocketSlashCommand context, 
+        bool connectToVoiceChannel = true)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+
+        var retrieveOptions = new PlayerRetrieveOptions(
+            ChannelBehavior: connectToVoiceChannel ? PlayerChannelBehavior.Join : PlayerChannelBehavior.None);
+
+        var playerOptions = new QueuedLavalinkPlayerOptions { HistoryCapacity = 10000 };
+
+        var result = await audioService.Players
+            .RetrieveAsync(context.GetGuild(client).Id, context.GetGuild(client).GetUser(context.User.Id).VoiceChannel.Id, playerFactory: PlayerFactory.Queued, Options.Create(playerOptions), retrieveOptions)
+            .ConfigureAwait(false);
+
+        if (!result.IsSuccess)
+        {
+            var errorMessage = result.Status switch
+            {
+                PlayerRetrieveStatus.UserNotInVoiceChannel => "You are not connected to a voice channel.",
+                PlayerRetrieveStatus.BotNotConnected => "The bot is currently not connected.",
+                _ => "Unknown error.",
+            };
+
+            return null;
+        }
+        
+        return result.Player;
+    }
+    
     public static SocketGuild GetGuild(this SocketSlashCommand message, DiscordSocketClient client)
     {
         if (message.GuildId == null)
@@ -33,24 +68,6 @@ public static class Extensions
         await message.RespondAsync(content, ephemeral: true);
     }
     
-    public static async Task EnsureConnected(this LavaNode lavaNode)
-    {
-        if(!lavaNode.IsConnected)
-            await lavaNode.ConnectAsync();
-    }
-        
-    public static async Task JoinVoiceChannel(this SocketSlashCommand context, LavaNode lavaNode)
-    {
-        try
-        {
-            var textChannel = context.Channel as ITextChannel;
-            await lavaNode.JoinAsync(context.GetVoiceState().VoiceChannel, textChannel);
-            await context.RespondAsync($"Joined {context.GetVoiceState().VoiceChannel.Name}!");
-        }
-        catch (Exception exception) {
-            Console.WriteLine(exception);
-        }
-    }
         
     public static string GetOptionValueByName(this SocketSlashCommand command, string optionName)
     {

Bot/Handler/MusicPlayer/JoinCommand/JoinHandler.cs

@@ -1,33 +0,0 @@
-using Discord.WebSocket;
-using MediatR;
-using Victoria.Node;
-
-namespace Lunaris2.Handler.MusicPlayer.JoinCommand;
-
-public record JoinCommand(SocketSlashCommand Message) : IRequest;
-
-public class JoinHandler : IRequestHandler<JoinCommand>
-{
-    private readonly LavaNode _lavaNode;
-    private readonly DiscordSocketClient _client;
-    
-    public JoinHandler(LavaNode lavaNode, DiscordSocketClient client)
-    {
-        _lavaNode = lavaNode;
-        _client = client;
-    }
-    
-    public async Task Handle(JoinCommand command, CancellationToken cancellationToken)
-    {
-        var context = command.Message;
-        
-        await _lavaNode.EnsureConnected();
-
-        if (_lavaNode.HasPlayer(context.GetGuild(_client))) {
-            await context.RespondAsync("I'm already connected to a voice channel!");
-            return;
-        }
-        
-        await context.JoinVoiceChannel(_lavaNode);
-    }
-}

Bot/Handler/MusicPlayer/MessageModule.cs

@@ -1,50 +1,65 @@
 using Discord;
 using Discord.WebSocket;
-using Lunaris2.Handler.MusicPlayer;
+
+namespace Lunaris2.Handler.MusicPlayer;
 
 public static class MessageModule
 {
-    private static Dictionary<ulong, List<ulong>> guildMessageIds = new Dictionary<ulong, List<ulong>>();
+    private static readonly Dictionary<ulong, List<ulong>> GuildMessageIds = new();
 
     public static async Task SendMessageAsync(this SocketSlashCommand context, string message, DiscordSocketClient client)
+    {
+        try
         {
             var guildId = await StoreForRemoval(context, client);
 
-        await context.RespondAsync(message);
+            var sentMessage = await context.FollowupAsync(message);
-        var sentMessage = await context.GetOriginalResponseAsync();
+            GuildMessageIds[guildId].Add(sentMessage.Id);
-        
+        }
-        guildMessageIds[guildId].Add(sentMessage.Id);
+        catch (Exception e)
+        {
+            Console.WriteLine(e);
+            throw;
+        }
     }
 
     public static async Task SendMessageAsync(this SocketSlashCommand context, Embed message, DiscordSocketClient client)
+    {
+        try
         {
             var guildId = await StoreForRemoval(context, client);
 
-        await context.RespondAsync(embed: message);
+            var sentMessage = await context.FollowupAsync(embed: message);
-        
+            GuildMessageIds[guildId].Add(sentMessage.Id);
-        var sentMessage = await context.GetOriginalResponseAsync();
+        }
-
+        catch (Exception e)
-        guildMessageIds[guildId].Add(sentMessage.Id);
+        {
+            Console.WriteLine(e);
+            throw;
+        }
     }
 
     private static async Task<ulong> StoreForRemoval(SocketSlashCommand context, DiscordSocketClient client)
     {
         var guildId = context.GetGuild(client).Id;
 
-        if (guildMessageIds.ContainsKey(guildId))
+        if (GuildMessageIds.TryGetValue(guildId, out var value))
         {
-            foreach (var messageId in guildMessageIds[guildId])
+            if (value.Count <= 0) 
+                return guildId;
+            
+            foreach (var messageId in value)
             {
                 var messageToDelete = await context.Channel.GetMessageAsync(messageId);
                 if (messageToDelete != null)
                     await messageToDelete.DeleteAsync();
             }
 
-            guildMessageIds[guildId].Clear();
+            value.Clear();
         }
         else
         {
-            guildMessageIds.Add(guildId, []);
+            GuildMessageIds.Add(guildId, new List<ulong>());
         }
 
         return guildId;

Bot/Handler/MusicPlayer/MusicEmbed.cs

@@ -1,7 +1,6 @@
 using Discord;
 using Discord.WebSocket;
-using Victoria;
+using Lavalink4NET.Tracks;
-using Victoria.Player;
 
 namespace Lunaris2.Handler.MusicPlayer;
 
@@ -12,32 +11,29 @@ public class MusicEmbed
         string title, 
         string length, 
         string artist, 
-        string queuedBy, 
+        string queuedBy)
-        string? nextInQueue)
     {
         return new EmbedBuilder()
             .WithAuthor("Lunaris", "https://media.tenor.com/GqAwMt01UXgAAAAi/cd.gif")
             .WithTitle(title)
-            .WithDescription($"Length: {length}\nArtist: {artist}\nQueued by: {queuedBy}\nNext in queue: {nextInQueue}")
+            .WithDescription($"Length: {length}\nArtist: {artist}\nQueued by: {queuedBy}")
             .WithColor(Color.Magenta)
             .WithThumbnailUrl(imageUrl)
             .Build();
     }
     
     public async Task NowPlayingEmbed(
-        LavaPlayer<LavaTrack> player, 
+        LavalinkTrack player, 
         SocketSlashCommand context, 
         DiscordSocketClient client)
     {
-        var artwork = await player.Track.FetchArtworkAsync();
+        var artwork = player.ArtworkUri;
-        var getNextTrack = player.Vueue.Count > 1 ? player.Vueue.ToArray()[1].Title : "No songs in queue.";
         var embed = SendMusicEmbed(
-            artwork, 
+            artwork.ToString(), 
-            player.Track.Title, 
+            player.Title, 
-            player.Track.Duration.ToString(), 
+            player.Duration.ToString(), 
-            player.Track.Author, 
+            player.Author, 
-            context.User.Username, 
+            context.User.Username);
-            getNextTrack);
         
         await context.SendMessageAsync(embed, client);
     }

Bot/Handler/MusicPlayer/PauseCommand/PauseHandler.cs

@@ -0,0 +1,31 @@
+using Discord.WebSocket;
+using Lavalink4NET;
+using Lavalink4NET.Players;
+using MediatR;
+
+namespace Lunaris2.Handler.MusicPlayer.PauseCommand;
+
+public record PauseCommand(SocketSlashCommand Message) : IRequest;
+
+public class PauseHandler(DiscordSocketClient client, IAudioService audioService) : IRequestHandler<PauseCommand>
+{
+    public async Task Handle(PauseCommand command, CancellationToken cancellationToken)
+    {
+        var context = command.Message;
+        var player = await audioService.GetPlayerAsync(client, context, connectToVoiceChannel: true);
+
+        if (player is null)
+        {
+            return;
+        }
+
+        if (player.State is PlayerState.Paused)
+        {
+            await context.SendMessageAsync("Player is already paused.", client);
+            return;
+        }
+
+        await player.PauseAsync(cancellationToken);
+        await context.SendMessageAsync("Paused.", client);
+    }
+}

Bot/Handler/MusicPlayer/PlayCommand/PlayHandler.cs

@@ -1,12 +1,11 @@
-using Discord;
-using Discord.Commands;
 using Discord.WebSocket;
 using Lunaris2.SlashCommand;
 using MediatR;
-using Victoria.Node;
+using Lavalink4NET;
-using Victoria.Node.EventArgs;
+using Lavalink4NET.Events.Players;
-using Victoria.Player;
+using Lavalink4NET.Players.Queued;
-using Victoria.Responses.Search;
+using Lavalink4NET.Rest.Entities.Tracks;
+using System.Threading;
 
 namespace Lunaris2.Handler.MusicPlayer.PlayCommand;
 
@@ -15,105 +14,79 @@ public record PlayCommand(SocketSlashCommand Message) : IRequest;
 public class PlayHandler : IRequestHandler<PlayCommand>
 {
     private readonly MusicEmbed _musicEmbed;
-    private readonly LavaNode _lavaNode;
     private readonly DiscordSocketClient _client;
+    private readonly IAudioService _audioService;
     private SocketSlashCommand _context;
     
     public PlayHandler(
-        LavaNode lavaNode, 
         DiscordSocketClient client, 
-        MusicEmbed musicEmbed)
+        MusicEmbed musicEmbed, 
+        IAudioService audioService)
     {
-        _lavaNode = lavaNode;
         _client = client;
         _musicEmbed = musicEmbed;
+        _audioService = audioService;
+        _audioService.TrackStarted += OnTrackStarted;
     }
 
-    [Command(RunMode = RunMode.Async)]
+    private async Task OnTrackStarted(object sender, TrackStartedEventArgs eventargs)
-    public async Task Handle(PlayCommand command, CancellationToken cancellationToken)
     {
-        _context = command.Message;
+        var player = sender as QueuedLavalinkPlayer;
+        var track = player?.CurrentTrack;
 
-        await _lavaNode.EnsureConnected();
+        if (track != null) 
+            await _musicEmbed.NowPlayingEmbed(track, _context, _client);
+    }
 
-        var songName = _context.GetOptionValueByName(Option.Input);
+    public Task Handle(PlayCommand command, CancellationToken cancellationToken)
+    {
+        new Thread(PlayMusic).Start();
+        return Task.CompletedTask;
 
-        if (string.IsNullOrWhiteSpace(songName)) {
+        async void PlayMusic()
-            await _context.RespondAsync("Please provide search terms.");
+        {
+            await _audioService.StartAsync(cancellationToken);
+            var context = command.Message;
+            _context = context;
+
+            var searchQuery = context.GetOptionValueByName(Option.Input);
+
+            if (string.IsNullOrWhiteSpace(searchQuery))
+            {
+                await context.SendMessageAsync("Please provide search terms.", _client);
                 return;
             }
 
-        var player = await GetPlayer();
+            var player = await _audioService.GetPlayerAsync(_client, context, connectToVoiceChannel: true);
 
-        if (player == null) 
+            if (player is null) return;
-            return;
 
-        var searchResponse = await _lavaNode.SearchAsync(
+            var trackLoadOptions = new TrackLoadOptions { SearchMode = TrackSearchMode.YouTube, };
-            Uri.IsWellFormedUriString(songName, UriKind.Absolute)
-                ? SearchType.Direct
-                : SearchType.YouTube, songName);
 
-        if (!await SearchResponse(searchResponse, player, songName)) 
+            var track = await _audioService.Tracks.LoadTrackAsync(searchQuery, trackLoadOptions, cancellationToken: cancellationToken);
-            return;
 
-        await PlayTrack(player);
+            if (track is null) await context.SendMessageAsync("😖 No results.", _client);
 
-        await _musicEmbed.NowPlayingEmbed(player, _context, _client);
+            if (player.CurrentTrack is null)
-
-        _lavaNode.OnTrackEnd += OnTrackEnd;
-    }
-
-    private async Task OnTrackEnd(TrackEndEventArg<LavaPlayer<LavaTrack>, LavaTrack> arg)
             {
-        var player = arg.Player;
+                await player.PlayAsync(track, cancellationToken: cancellationToken)
-        if (!player.Vueue.TryDequeue(out var nextTrack))
+                    .ConfigureAwait(false);
-            return;
 
-        await player.PlayAsync(nextTrack);
+                await _musicEmbed.NowPlayingEmbed(track, context, _client);
-        
-        await _musicEmbed.NowPlayingEmbed(player, _context, _client);
             }
-    
+            else
-    private static async Task PlayTrack(LavaPlayer<LavaTrack> player)
             {
-        if (player.PlayerState is PlayerState.Playing or PlayerState.Paused) {
+                if (track != null)
-            return;
-        }
-
-        player.Vueue.TryDequeue(out var lavaTrack);
-        await player.PlayAsync(lavaTrack);
-    }
-    
-    private async Task<LavaPlayer<LavaTrack>?> GetPlayer()
                 {
-        var voiceState = _context.User as IVoiceState;
+                    var queueTracks = new[] { new TrackQueueItem(track) };
-
+                    await player.Queue.AddRangeAsync(queueTracks, cancellationToken);
-        if (voiceState?.VoiceChannel != null)
+                    await context.SendMessageAsync($"🔈 Added to queue: {track.Title}", _client);
-            return await _lavaNode.JoinAsync(voiceState.VoiceChannel, _context.Channel as ITextChannel);
-        
-        await _context.RespondAsync("You must be connected to a voice channel!");
-        return null;
                 }
-    
+                else
-    private async Task<bool> SearchResponse(
-        SearchResponse searchResponse, LavaPlayer<LavaTrack> player, 
-        string songName)
                 {
-        if (searchResponse.Status is SearchStatus.LoadFailed or SearchStatus.NoMatches) {
+                    await context.SendMessageAsync($"Couldn't read song information", _client);
-            await _context.RespondAsync($"I wasn't able to find anything for `{songName}`.");
+                }
-            return false;
+            }
-        }
+        }
-
-        if (!string.IsNullOrWhiteSpace(searchResponse.Playlist.Name)) {
-            player.Vueue.Enqueue(searchResponse.Tracks);
-            
-            await _context.RespondAsync($"Enqueued {searchResponse.Tracks.Count} songs.");
-        }
-        else {
-            var track = searchResponse.Tracks.FirstOrDefault()!;
-            player.Vueue.Enqueue(track);
-        }
-
-        return true;
     }
 }

Bot/Handler/MusicPlayer/ResumeCommand/ResumeHandler.cs

@@ -0,0 +1,29 @@
+using Discord.WebSocket;
+using Lavalink4NET;
+using Lavalink4NET.Players;
+using MediatR;
+
+namespace Lunaris2.Handler.MusicPlayer.ResumeCommand;
+
+public record ResumeCommand(SocketSlashCommand Message) : IRequest;
+
+public class ResumeHandler(DiscordSocketClient client, IAudioService audioService) : IRequestHandler<ResumeCommand>
+{
+    public async Task Handle(ResumeCommand command, CancellationToken cancellationToken)
+    {
+        var context = command.Message;
+        var player = await audioService.GetPlayerAsync(client, context, connectToVoiceChannel: true);
+
+        if (player is null)
+            return;
+
+        if (player.State is not PlayerState.Paused)
+        {
+            await context.SendMessageAsync("Player is not paused.", client);
+            return;
+        }
+
+        await player.ResumeAsync(cancellationToken);
+        await context.SendMessageAsync("Resumed.", client);
+    }
+}

Bot/Handler/MusicPlayer/SkipCommand/SkipHandler.cs

@@ -1,48 +1,34 @@
 using Discord.WebSocket;
+using Lavalink4NET;
 using MediatR;
-using Victoria.Node;
-using Victoria.Player;
 
 namespace Lunaris2.Handler.MusicPlayer.SkipCommand;
 
 public record SkipCommand(SocketSlashCommand Message) : IRequest;
 
-public class SkipHandler : IRequestHandler<SkipCommand>
+public class SkipHandler(DiscordSocketClient client, IAudioService audioService) : IRequestHandler<SkipCommand>
 {
-    private readonly LavaNode _lavaNode;
+    public async Task Handle(SkipCommand command, CancellationToken cancellationToken)
-    private readonly DiscordSocketClient _client;
-    private readonly MusicEmbed _musicEmbed;
-
-    public SkipHandler(LavaNode lavaNode, DiscordSocketClient client, MusicEmbed musicEmbed)
     {
-        _lavaNode = lavaNode;
+        var context = command.Message;
-        _client = client;
+        var player = await audioService.GetPlayerAsync(client, context, connectToVoiceChannel: true);
-        _musicEmbed = musicEmbed;
-    }
 
-    public async Task Handle(SkipCommand message, CancellationToken cancellationToken)
+        if (player is null)
+            return;
+
+        if (player.CurrentItem is null)
         {
-        var context = message.Message;
+            await context.SendMessageAsync("Nothing playing!", client).ConfigureAwait(false);
-        
-        await _lavaNode.EnsureConnected();
-        
-        if (!_lavaNode.TryGetPlayer(context.GetGuild(_client), out var player)) {
-            await context.RespondAsync("I'm not connected to a voice channel.");
             return;
         }
 
-        if (player.PlayerState != PlayerState.Playing) {
+        await player.SkipAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
-            await context.RespondAsync("Woaaah there, I can't skip when nothing is playing.");
-            return;
-        }
 
-        try {
+        var track = player.CurrentItem;
-            await player.SkipAsync();
+
-            await _musicEmbed.NowPlayingEmbed(player, context, _client);
+        if (track is not null)
-        }
+            await context.SendMessageAsync($"Skipped. Now playing: {track.Track!.Title}", client).ConfigureAwait(false);
-        catch (Exception exception) {
+        else
-            await context.RespondAsync("There is not more tracks to skip.");
+            await context.SendMessageAsync("Skipped. Stopped playing because the queue is now empty.", client).ConfigureAwait(false);
-            Console.WriteLine(exception);
-        }
     }
 }

Bot/Handler/SlashCommandReceivedHandler.cs

@@ -1,6 +1,7 @@
-using Lunaris2.Handler.GoodByeCommand;
+using Lunaris2.Handler.MusicPlayer.DisconnectCommand;
-using Lunaris2.Handler.MusicPlayer.JoinCommand;
+using Lunaris2.Handler.MusicPlayer.PauseCommand;
 using Lunaris2.Handler.MusicPlayer.PlayCommand;
+using Lunaris2.Handler.MusicPlayer.ResumeCommand;
 using Lunaris2.Handler.MusicPlayer.SkipCommand;
 using Lunaris2.Notification;
 using Lunaris2.SlashCommand;
@@ -12,16 +13,18 @@ public class SlashCommandReceivedHandler(ISender mediator) : INotificationHandle
 {
     public async Task Handle(SlashCommandReceivedNotification notification, CancellationToken cancellationToken)
     {
+        await notification.Message.DeferAsync();
+        
         switch (notification.Message.CommandName)
         {
-            case Command.Hello.Name:
+            case Command.Resume.Name:
-                await mediator.Send(new HelloCommand.HelloCommand(notification.Message), cancellationToken);
+                await mediator.Send(new ResumeCommand(notification.Message), cancellationToken);
                 break;
-            case Command.Goodbye.Name:
+            case Command.Pause.Name:
-                await mediator.Send(new GoodbyeCommand(notification.Message), cancellationToken);
+                await mediator.Send(new PauseCommand(notification.Message), cancellationToken);
                 break;
-            case Command.Join.Name:
+            case Command.Disconnect.Name:
-                await mediator.Send(new JoinCommand(notification.Message), cancellationToken);
+                await mediator.Send(new DisconnectCommand(notification.Message), cancellationToken);
                 break;
             case Command.Play.Name:
                 await mediator.Send(new PlayCommand(notification.Message), cancellationToken);

Bot/Helper/RunAsync.cs

@@ -1,9 +0,0 @@
-namespace Lunaris2.Helper;
-
-public static class Async
-{
-    public static void Run(Func<Task> task)
-    {
-        _ = Task.Run(task);
-    }
-}

Bot/Lunaris2.csproj

@@ -9,12 +9,15 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Discord.Net" Version="3.13.1" />
+    <PackageReference Include="Discord.Net" Version="3.15.3" />
-    <PackageReference Include="Discord.Net.Commands" Version="3.13.1" />
+    <PackageReference Include="Discord.Net.Commands" Version="3.15.3" />
-    <PackageReference Include="Discord.Net.Core" Version="3.13.1" />
+    <PackageReference Include="Discord.Net.Core" Version="3.15.3" />
-    <PackageReference Include="Discord.Net.Interactions" Version="3.13.1" />
+    <PackageReference Include="Discord.Net.Interactions" Version="3.15.3" />
-    <PackageReference Include="Discord.Net.Rest" Version="3.13.1" />
+    <PackageReference Include="Discord.Net.Rest" Version="3.15.3" />
-    <PackageReference Include="MediatR" Version="12.2.0" />
+    <PackageReference Include="Lavalink4NET" Version="4.0.20" />
+    <PackageReference Include="Lavalink4NET.Artwork" Version="4.0.20" />
+    <PackageReference Include="Lavalink4NET.Discord.NET" Version="4.0.20" />
+    <PackageReference Include="MediatR" Version="12.4.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration" Version="8.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="8.0.1" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="8.0.0" />

Bot/Notification/DiscordEventListener.cs

@@ -25,9 +25,10 @@ public class DiscordEventListener(DiscordSocketClient client, IServiceScopeFacto
         await Task.CompletedTask;
     }
 
-    private async Task OnMessageReceivedAsync(SocketMessage arg)
+    private Task OnMessageReceivedAsync(SocketMessage arg)
     {
-        await Mediator.Publish(new MessageReceivedNotification(arg), _cancellationToken);
+        _ = Task.Run(() => Mediator.Publish(new MessageReceivedNotification(arg), _cancellationToken), _cancellationToken);
+        return Task.CompletedTask;
     }
     
     private async Task OnSlashCommandRecievedAsync(SocketSlashCommand arg)

Bot/Program.cs

@@ -1,26 +1,28 @@
 using System.Reflection;
 using Discord;
-using Discord.Commands;
 using Discord.Interactions;
 using Discord.WebSocket;
 using Lunaris2.Handler.ChatCommand;
+using Lavalink4NET.Extensions;
 using Lunaris2.Handler.MusicPlayer;
 using Lunaris2.Notification;
+using Lunaris2.Service;
 using Lunaris2.SlashCommand;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
-using Victoria;
 using Victoria.Node;
-using RunMode = Discord.Commands.RunMode;
 
 namespace Lunaris2;
 
 public class Program
 {
-    private static LavaNode? _lavaNode;
     public static void Main(string[] args)
     {
+        AppDomain.CurrentDomain.UnhandledException += (sender, eventArgs) =>
+        {
+            Console.WriteLine(eventArgs.ExceptionObject);
+        };
         CreateHostBuilder(args).Build().Run();
     }
 
@@ -33,31 +35,31 @@ public class Program
                     GatewayIntents = GatewayIntents.All
                 };
                 
-                var commandServiceConfig = new CommandServiceConfig{ DefaultRunMode = RunMode.Async };
-
                 var client = new DiscordSocketClient(config);
-                var commands = new CommandService(commandServiceConfig);
                 var configuration = new ConfigurationBuilder()
                     .SetBasePath(AppContext.BaseDirectory)
                     .AddJsonFile("appsettings.json")
                     .Build();
 
                 services
-                    .AddSingleton(client)
+                    .AddMediatR(mediatRServiceConfiguration => mediatRServiceConfiguration.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()))
-                    .AddSingleton(commands)
+                    .AddLavalink()
-                    .AddMediatR(configuration => configuration.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()))
+                    .ConfigureLavalink(options =>
-                    .AddSingleton<DiscordEventListener>()
-                    .AddSingleton(service => new InteractionService(service.GetRequiredService<DiscordSocketClient>()))
-                    .AddLavaNode(nodeConfiguration =>
                     {
-                        nodeConfiguration.SelfDeaf = false;
+                        options.BaseAddress = new Uri(
-                        nodeConfiguration.Hostname = configuration["LavaLinkHostname"];
+                            $"http://{configuration["LavaLinkHostname"]}:{configuration["LavaLinkPort"]}"
-                        nodeConfiguration.Port = Convert.ToUInt16(configuration["LavaLinkPort"]);
+                        );
-                        nodeConfiguration.Authorization = configuration["LavaLinkPassword"];
+                        options.WebSocketUri = new Uri($"ws://{configuration["LavaLinkHostname"]}:{configuration["LavaLinkPort"]}/v4/websocket");
+                        options.Passphrase = configuration["LavaLinkPassword"] ?? "youshallnotpass";
+                        options.Label = "Node";
                     })
                     .AddSingleton<LavaNode>()
                     .AddSingleton<MusicEmbed>()
                     .AddSingleton<ChatSettings>()
+                    .AddSingleton(client)
+                    .AddSingleton<DiscordEventListener>()
+                    .AddSingleton<VoiceChannelMonitorService>()
+                    .AddSingleton(service => new InteractionService(service.GetRequiredService<DiscordSocketClient>()))
                     .Configure<ChatSettings>(configuration.GetSection("LLM"));
 
                 client.Ready += () => Client_Ready(client);
@@ -73,8 +75,6 @@ public class Program
                     .GetAwaiter()
                     .GetResult();
 
-                _lavaNode = services.BuildServiceProvider().GetRequiredService<LavaNode>();
-
                 var listener = services
                     .BuildServiceProvider()
                     .GetRequiredService<DiscordEventListener>();
@@ -85,10 +85,12 @@ public class Program
                     .GetResult();
             });
 
-    private static async Task Client_Ready(DiscordSocketClient client)
+    private static Task Client_Ready(DiscordSocketClient client)
     {
-        await _lavaNode.ConnectAsync();
         client.RegisterCommands();
+        
+        new VoiceChannelMonitorService(client).StartMonitoring();
+        return Task.CompletedTask;
     }
         
     private static Task Log(LogMessage arg)

Bot/Service/VoiceChannelMonitorService.cs

@@ -0,0 +1,59 @@
+using Discord.WebSocket;
+
+namespace Lunaris2.Service;
+
+public class VoiceChannelMonitorService
+{
+    private readonly DiscordSocketClient _client;
+    private readonly Dictionary<ulong, Timer> _timers = new();
+
+    public VoiceChannelMonitorService(DiscordSocketClient client)
+    {
+        _client = client;
+    }
+
+    public void StartMonitoring()
+    {
+        Task.Run(async () =>
+        {
+            while (true)
+            {
+                await CheckVoiceChannels();
+                await Task.Delay(TimeSpan.FromMinutes(1));
+            }
+        });
+    }
+
+    private async Task CheckVoiceChannels()
+    {
+        foreach (var guild in _client.Guilds)
+        {
+            var voiceChannel = guild.VoiceChannels.FirstOrDefault(vc => vc.ConnectedUsers.Count == 1);
+            if (voiceChannel != null)
+            {
+                if (!_timers.ContainsKey(voiceChannel.Id))
+                {
+                    _timers[voiceChannel.Id] = new Timer(async _ => await LeaveChannel(voiceChannel), null, TimeSpan.FromMinutes(3), Timeout.InfiniteTimeSpan);
+                }
+            }
+            else
+            {
+                if (voiceChannel == null || !_timers.ContainsKey(voiceChannel.Id)) 
+                    continue;
+                
+                await _timers[voiceChannel.Id].DisposeAsync();
+                _timers.Remove(voiceChannel.Id);
+            }
+        }
+    }
+
+    private async Task LeaveChannel(SocketVoiceChannel voiceChannel)
+    {
+        if (voiceChannel.ConnectedUsers.Count == 1 && voiceChannel.Users.Any(u => u.Id == _client.CurrentUser.Id))
+        {
+            await voiceChannel.DisconnectAsync();
+            await _timers[voiceChannel.Id].DisposeAsync();
+            _timers.Remove(voiceChannel.Id);
+        }
+    }
+}

Bot/SlashCommand/Command.cs

@@ -9,22 +9,10 @@ public static class Option
 
 public static class Command
 {
-    public static class Hello
+    public static class Disconnect
     {
-        public const string Name = "hello";
+        public const string Name = "disconnect";
-        public const string Description = "Say hello to the bot!";
+        public const string Description = "Disconnect from the voice channel!";
-    }
-
-    public static class Goodbye
-    {
-        public const string Name = "goodbye";
-        public const string Description = "Say goodbye to the bot!";
-    }
-    
-    public static class Join
-    {
-        public const string Name = "join";
-        public const string Description = "Join the voice channel!";
     }
     
     public static class Skip
@@ -33,10 +21,16 @@ public static class Command
         public const string Description = "Skip the current song!";
     }
     
-    public static class Stop
+    public static class Resume
     {
-        public const string Name = "stop";
+        public const string Name = "resume";
-        public const string Description = "Stop the music!";
+        public const string Description = "Resume the music!";
+    }
+    
+    public static class Pause
+    {
+        public const string Name = "pause";
+        public const string Description = "Pause the music!";
     }
     
     public static class Play

Bot/SlashCommand/SlashCommandBuilder.cs

@@ -42,7 +42,6 @@ public class SlashCommandBuilder(
 
     private static async Task RemoveUnusedCommands(string[] commands, IEnumerable<SocketApplicationCommand> registeredCommands)
     {
-        // Remove commands from Discord(registeredCommands) that are not in the list of commands
         foreach(var command in registeredCommands)
         {
             if (commands.Contains(command.Name)) 

Bot/SlashCommand/SlashCommandRegistration.cs

@@ -7,12 +7,12 @@ public static class SlashCommandRegistration
 {
     public static void RegisterCommands(this DiscordSocketClient client)
     {
-        RegisterCommand(client, Command.Hello.Name, Command.Hello.Description);
+        RegisterCommand(client, Command.Resume.Name, Command.Resume.Description);
-        RegisterCommand(client, Command.Goodbye.Name, Command.Goodbye.Description);
+        RegisterCommand(client, Command.Pause.Name, Command.Pause.Description);
-        RegisterCommand(client, Command.Join.Name, Command.Join.Description);
+        RegisterCommand(client, Command.Disconnect.Name, Command.Disconnect.Description);
         RegisterCommand(client, Command.Skip.Name, Command.Skip.Description);
         RegisterCommand(client, Command.Play.Name, Command.Play.Description, Command.Play.Options);
-        RegisterCommand(client, Command.Stop.Name, Command.Stop.Description); 
+        RegisterCommand(client, Command.Resume.Name, Command.Resume.Description);
     }
 
     private static void RegisterCommand(

Bot/appsettings.json

@@ -6,7 +6,7 @@
             "Microsoft": "Information"
         }
     },
-    "Token": "discordToken",
+    "Token": "TOKEN",
     "LavaLinkPassword": "youshallnotpass",
     "LavaLinkHostname": "127.0.0.1",
     "LavaLinkPort": 2333,

application.yml

@@ -2,6 +2,18 @@ server: # REST and WS server
   port: 2333
   address: 0.0.0.0
 plugins:
+  youtube:
+    enabled: true # Whether this source can be used.
+    allowSearch: true # Whether "ytsearch:" and "ytmsearch:" can be used.
+    allowDirectVideoIds: true # Whether just video IDs can match. If false, only complete URLs will be loaded.
+    allowDirectPlaylistIds: true # Whether just playlist IDs can match. If false, only complete URLs will be loaded.
+    # The clients to use for track loading. See below for a list of valid clients.
+    # Clients are queried in the order they are given (so the first client is queried first and so on...)
+    clients:
+      - MUSIC
+      - ANDROID_TESTSUITE
+      - WEB
+      - TVHTML5EMBEDDED
     #  name: # Name of the plugin
     #    some_key: some_value # Some key-value pair for the plugin
     #    another_key: another_value
@@ -9,10 +21,13 @@ lavalink:
   plugins:
 #    - dependency: "group:artifact:version"
 #      repository: "repository"
+      - dependency: "dev.lavalink.youtube:youtube-plugin:1.5.2"
+        snapshot: false # Set to true if you want to use a snapshot version.
+        
   server:
     password: "youshallnotpass"
     sources:
-      youtube: true
+      youtube: false
       bandcamp: true
       soundcloud: true
       twitch: true
@@ -30,9 +45,9 @@ lavalink:
       rotation: true
       channelMix: true
       lowPass: true
-    bufferDurationMs: 400 # The duration of the NAS buffer. Higher values fare better against longer GC pauses. Duration <= 0 to disable JDA-NAS. Minimum of 40ms, lower values may introduce pauses.
+    bufferDurationMs: 1000 # The duration of the NAS buffer. Higher values fare better against longer GC pauses. Duration <= 0 to disable JDA-NAS. Minimum of 40ms, lower values may introduce pauses.
-    frameBufferDurationMs: 5000 # How many milliseconds of audio to keep buffered
+    frameBufferDurationMs: 10000 # How many milliseconds of audio to keep buffered
-    opusEncodingQuality: 10 # Opus encoder quality. Valid values range from 0 to 10, where 10 is best quality but is the most expensive on the CPU.
+    opusEncodingQuality: 5 # Opus encoder quality. Valid values range from 0 to 10, where 10 is best quality but is the most expensive on the CPU.
     resamplingQuality: LOW # Quality of resampling operations. Valid values are LOW, MEDIUM and HIGH, where HIGH uses the most CPU.
     trackStuckThresholdMs: 10000 # The threshold for how long a track can be stuck. A track is stuck if does not return any audio data.
     useSeekGhosting: true # Seek ghosting is the effect where whilst a seek is in progress, the audio buffer is read from until empty, or until seek is ready.

docker-compose.yml

@@ -1,7 +1,7 @@
 services:
   lavalink:
     # pin the image version to Lavalink v4
-    image: ghcr.io/lavalink-devs/lavalink:3.7.11
+    image: ghcr.io/lavalink-devs/lavalink:4.0.7
     container_name: lavalink
     restart: unless-stopped
     environment: