feat(bot): add playtop, playskip, skipto, seek, replay and pause/resume toggle

packages/bot/src/functions/music/commands/pause.spec.ts

@@ -5,7 +5,6 @@ const requireQueueMock = jest.fn()
 const requireVoiceChannelMock = jest.fn()
 const interactionReplyMock = jest.fn()
 const createSuccessEmbedMock = jest.fn((title: string, desc?: string) => ({ title, description: desc }))
-const createWarningEmbedMock = jest.fn((title: string, desc?: string) => ({ title, description: desc }))
 const buildCommandTrackEmbedMock = jest.fn(() => ({}))
 const resolveGuildQueueMock = jest.fn()
 
@@ -20,7 +19,6 @@ jest.mock('../../../utils/general/interactionReply', () => ({
 
 jest.mock('../../../utils/general/embeds', () => ({
     createSuccessEmbed: (...args: unknown[]) => createSuccessEmbedMock(...args),
-    createWarningEmbed: (...args: unknown[]) => createWarningEmbedMock(...args),
 }))
 
 jest.mock('../../../utils/general/responseEmbeds', () => ({
@@ -43,6 +41,7 @@ function createQueue(isPaused = false, currentTrack: unknown = null) {
         node: {
             isPaused: jest.fn().mockReturnValue(isPaused),
             pause: jest.fn(),
+            resume: jest.fn(),
         },
         currentTrack,
     } as any
@@ -52,7 +51,7 @@ function createClient() {
     return {} as any
 }
 
-describe('pause command', () => {
+describe('pause command (toggle)', () => {
     beforeEach(() => {
         jest.clearAllMocks()
         requireVoiceChannelMock.mockResolvedValue(true)
@@ -68,6 +67,7 @@ describe('pause command', () => {
         await pauseCommand.execute({ client: createClient(), interaction: createInteraction() } as any)
 
         expect(queue.node.pause).not.toHaveBeenCalled()
+        expect(queue.node.resume).not.toHaveBeenCalled()
     })
 
     it('returns early when queue validation fails', async () => {
@@ -78,37 +78,52 @@ describe('pause command', () => {
         await pauseCommand.execute({ client: createClient(), interaction: createInteraction() } as any)
 
         expect(queue.node.pause).not.toHaveBeenCalled()
+        expect(queue.node.resume).not.toHaveBeenCalled()
     })
 
-    it('shows warning when already paused', async () => {
-        const queue = createQueue(true)
+    it('resumes when currently paused with no track', async () => {
+        const queue = createQueue(true, null)
         resolveGuildQueueMock.mockReturnValue({ queue })
 
         await pauseCommand.execute({ client: createClient(), interaction: createInteraction() } as any)
 
+        expect(queue.node.resume).toHaveBeenCalled()
         expect(queue.node.pause).not.toHaveBeenCalled()
-        expect(createWarningEmbedMock).toHaveBeenCalledWith('Already paused', expect.any(String))
+        expect(createSuccessEmbedMock).toHaveBeenCalledWith('▶️ Resumed', 'Music has been resumed.')
     })
 
-    it('shows simple success embed when no current track', async () => {
+    it('pauses when currently playing with no track', async () => {
         const queue = createQueue(false, null)
         resolveGuildQueueMock.mockReturnValue({ queue })
 
         await pauseCommand.execute({ client: createClient(), interaction: createInteraction() } as any)
 
         expect(queue.node.pause).toHaveBeenCalled()
+        expect(queue.node.resume).not.toHaveBeenCalled()
         expect(createSuccessEmbedMock).toHaveBeenCalledWith('⏸️ Paused', 'Music has been paused.')
     })
 
-    it('shows rich track embed when current track exists', async () => {
-        const track = { title: 'Test Song', author: 'Artist', url: 'http://x', duration: '3:00' }
-        const queue = createQueue(false, track)
+    it('resumes when currently paused with current track', async () => {
+        const currentTrack = { id: 'track-1', title: 'Test Song' }
+        const queue = createQueue(true, currentTrack)
+        resolveGuildQueueMock.mockReturnValue({ queue })
+
+        await pauseCommand.execute({ client: createClient(), interaction: createInteraction() } as any)
+
+        expect(queue.node.resume).toHaveBeenCalled()
+        expect(queue.node.pause).not.toHaveBeenCalled()
+        expect(buildCommandTrackEmbedMock).toHaveBeenCalledWith(currentTrack, '▶️ Resumed', expect.any(Object))
+    })
+
+    it('pauses when currently playing with current track', async () => {
+        const currentTrack = { id: 'track-1', title: 'Test Song' }
+        const queue = createQueue(false, currentTrack)
         resolveGuildQueueMock.mockReturnValue({ queue })
 
         await pauseCommand.execute({ client: createClient(), interaction: createInteraction() } as any)
 
         expect(queue.node.pause).toHaveBeenCalled()
-        expect(buildCommandTrackEmbedMock).toHaveBeenCalledWith(track, '⏸️ Paused', expect.any(Object))
-        expect(interactionReplyMock).toHaveBeenCalled()
+        expect(queue.node.resume).not.toHaveBeenCalled()
+        expect(buildCommandTrackEmbedMock).toHaveBeenCalledWith(currentTrack, '⏸️ Paused', expect.any(Object))
     })
 })

packages/bot/src/functions/music/commands/pause.ts

@@ -7,13 +7,13 @@ import {
     requireVoiceChannel,
 } from "../../../utils/command/commandValidations"
 import { resolveGuildQueue } from '../../../utils/music/queueResolver'
-import { createSuccessEmbed, createWarningEmbed } from '../../../utils/general/embeds'
+import { createSuccessEmbed } from '../../../utils/general/embeds'
 import { buildCommandTrackEmbed } from '../../../utils/general/responseEmbeds'
 
 export default new Command({
     data: new SlashCommandBuilder()
         .setName('pause')
-        .setDescription('⏸️ Pause the current music.'),
+        .setDescription('⏸️ Toggle pause/resume music.'),
     category: 'music',
     execute: async ({ client, interaction }: CommandExecuteParams) => {
         if (!(await requireVoiceChannel(interaction))) return
@@ -22,41 +22,33 @@ export default new Command({
 
         if (!(await requireQueue(queue, interaction))) return
 
-        if (queue?.node.isPaused() === true) {
-            await interactionReply({
-                interaction,
-                content: {
-                    embeds: [
-                        createWarningEmbed(
-                            'Already paused',
-                            '⏸️ Music is already paused.',
-                        ),
-                    ],
-                    ephemeral: true,
-                },
-            })
-            return
-        }
+        const isPaused = queue?.node.isPaused() === true
 
-        queue?.node.pause()
+        if (isPaused) {
+            queue?.node.resume()
+        } else {
+            queue?.node.pause()
+        }
 
         const currentTrack = queue?.currentTrack
+        const action = isPaused ? '▶️ Resumed' : '⏸️ Paused'
+
         if (!currentTrack) {
             await interactionReply({
                 interaction,
                 content: {
                     embeds: [
                         createSuccessEmbed(
-                            '⏸️ Paused',
-                            'Music has been paused.',
+                            action,
+                            `Music has been ${isPaused ? 'resumed' : 'paused'}.`,
                         ),
                     ],
                 },
             })
             return
         }
 
-        const trackEmbed = buildCommandTrackEmbed(currentTrack, '⏸️ Paused', interaction.user)
+        const trackEmbed = buildCommandTrackEmbed(currentTrack, action, interaction.user)
         await interactionReply({ interaction, content: { embeds: [trackEmbed] } })
     },
 })

packages/bot/src/functions/music/commands/play/index.ts

@@ -19,26 +19,12 @@
 } from '../../../../utils/music/queueManipulation'
 import { buildPlayResponseEmbed } from '../../../../utils/music/nowPlayingEmbed'
 import { createMusicControlButtons } from '../../../../utils/music/buttonComponents'
-
-const DISCORD_UNKNOWN_INTERACTION_CODE = 10062
-
-function isUnknownInteractionError(error: unknown): boolean {
-    return (
-        typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        (error as { code?: number }).code === DISCORD_UNKNOWN_INTERACTION_CODE
-    )
-}
-
-function isUrl(query: string): boolean {
-    return query.startsWith('http://') || query.startsWith('https://')
-}
-
-function resolveSearchEngine(query: string): QueryType {
-    if (isUrl(query)) return QueryType.AUTO
-    return QueryType.SPOTIFY_SEARCH
-}
+import {
+    DISCORD_UNKNOWN_INTERACTION_CODE,
+    isUnknownInteractionError,
+    isUrl,
+    resolveSearchEngine,
+} from './queryUtils'
 
 function isTrackAlreadyQueued(
     queue: { tracks: { toArray?: () => Array<{ id?: string; url?: string }> } },
@@ -66,6 +52,17 @@
                     'Song name, artist, YouTube URL, or Spotify URL',
                 )
                 .setRequired(true),
+        )
+        .addStringOption((option) =>
+            option
+                .setName('provider')
+                .setDescription('Music provider to search (default: spotify)')
+                .addChoices(
+                    { name: 'Spotify', value: 'spotify' },
+                    { name: 'YouTube', value: 'youtube' },
+                    { name: 'SoundCloud', value: 'soundcloud' },
+                )
+                .setRequired(false),
         ),
     category: 'music',
     execute: async ({
@@ -98,6 +95,7 @@
         }
 
         const query = interaction.options.getString('query', true)
+        const provider = interaction.options.getString('provider')
         const collaborativeCheck = collaborativePlaylistService.canAddTracks(
             interaction.guildId,
             interaction.user.id,
@@ -123,7 +121,7 @@
                 resolveGuildQueue(client, interaction.guildId ?? '').queue,
             )
 
-            const searchEngine = resolveSearchEngine(query)
+            const searchEngine = resolveSearchEngine(query, provider)
             const playOptions = {
                 nodeOptions: {
                     metadata: {