add: implement lyrics subscription and unsubscription endpoints

Author: 1Lucas1apk

src/api/sessions.id.players.id.lyrics.subscribe.js

@@ -0,0 +1,82 @@
+import myzod from 'myzod'
+import { logger, sendErrorResponse } from '../utils.js'
+
+const querySchema = myzod.object({
+  skipTrackSource: myzod.string().optional()
+})
+
+const pathSchema = myzod.object({
+  sessionId: myzod.string(),
+  guildId: myzod
+    .string()
+    .withPredicate(
+      (val) => /^\d{17,20}$/.test(val),
+      'guildId must be 17-20 digits'
+    )
+})
+
+async function handler(nodelink, req, res, _sendResponse, parsedUrl) {
+  const method = req.method
+  const pathParts = parsedUrl.pathname.split('/')
+  const sessionId = pathParts[3]
+  const guildId = pathParts[5]
+
+  try {
+    pathSchema.parse({ sessionId, guildId })
+  } catch (error) {
+    if (error instanceof myzod.ValidationError) {
+      return sendErrorResponse(req, res, 400, error.message)
+    }
+    return sendErrorResponse(req, res, 400, 'Invalid path parameters')
+  }
+
+  const session = nodelink.sessions.get(sessionId)
+  if (!session) {
+    return sendErrorResponse(req, res, 404, 'Session not found')
+  }
+
+  if (!session.players) {
+    return sendErrorResponse(req, res, 500, 'Player manager not initialized')
+  }
+
+  if (method === 'POST') {
+    const result = querySchema.try({
+        skipTrackSource: parsedUrl.searchParams.get('skipTrackSource')
+    })
+
+    if (result instanceof myzod.ValidationError) {
+        return sendErrorResponse(req, res, 400, result.message)
+    }
+
+    const skipTrackSource = result.skipTrackSource === 'true'
+
+    try {
+        await session.players.subscribeLyrics(guildId, skipTrackSource)
+        res.writeHead(204)
+        res.end()
+    } catch (error) {
+        logger('error', 'LyricsAPI', `Error subscribing to lyrics: ${error.message}`)
+        return sendErrorResponse(req, res, 500, error.message)
+    }
+    return
+  }
+
+  if (method === 'DELETE') {
+    try {
+        await session.players.unsubscribeLyrics(guildId)
+        res.writeHead(204)
+        res.end()
+    } catch (error) {
+        logger('error', 'LyricsAPI', `Error unsubscribing from lyrics: ${error.message}`)
+        return sendErrorResponse(req, res, 500, error.message)
+    }
+    return
+  }
+
+  return sendErrorResponse(req, res, 405, 'Method Not Allowed')
+}
+
+export default {
+  handler,
+  methods: ['POST', 'DELETE']
+}

src/managers/lyricsManager.js

@@ -84,7 +84,7 @@ export default class LyricsManager {
     }
   }
 
-  async loadLyrics(decodedTrack, language) {
+  async loadLyrics(decodedTrack, language, skipTrackSource = false) {
     if (
       !decodedTrack ||
       !decodedTrack.info?.sourceName ||
@@ -132,7 +132,7 @@ export default class LyricsManager {
     const sourceName = trackInfo?.sourceName
     const lyricsSource = this.lyricsSources.get(sourceName)
 
-    if (lyricsSource) {
+    if (lyricsSource && !skipTrackSource) {
       const lyrics = await lyricsSource.getLyrics(trackInfo, language)
       if (lyrics && lyrics.loadType !== 'empty') {
         return lyrics

src/managers/playerManager.js

@@ -515,4 +515,60 @@ export default class PlayerManager {
     if (!player) throw new Error('Player not found locally.')
     return player.getMixes()
   }
+
+  async subscribeLyrics(guildId, skipTrackSource) {
+    const session = this.nodelink.sessions.get(this.sessionId)
+    const playerKey = `${this.sessionId}:${guildId}`
+
+    if (this.isCluster) {
+      const worker = this.nodelink.workerManager.getWorkerForGuild(playerKey)
+      if (!worker) throw new Error('Player not assigned to a worker.')
+      const result = await this.nodelink.workerManager.execute(
+        worker,
+        'playerCommand',
+        {
+          sessionId: this.sessionId,
+          guildId,
+          userId: session.userId,
+          command: 'subscribeLyrics',
+          args: [skipTrackSource]
+        }
+      )
+      if (result?.playerNotFound) {
+        throw new Error('Player not found.')
+      }
+      return result
+    }
+    const player = this.players.get(playerKey)
+    if (!player) throw new Error('Player not found locally.')
+    return player.subscribeLyrics(skipTrackSource)
+  }
+
+  async unsubscribeLyrics(guildId) {
+    const session = this.nodelink.sessions.get(this.sessionId)
+    const playerKey = `${this.sessionId}:${guildId}`
+
+    if (this.isCluster) {
+      const worker = this.nodelink.workerManager.getWorkerForGuild(playerKey)
+      if (!worker) throw new Error('Player not assigned to a worker.')
+      const result = await this.nodelink.workerManager.execute(
+        worker,
+        'playerCommand',
+        {
+          sessionId: this.sessionId,
+          guildId,
+          userId: session.userId,
+          command: 'unsubscribeLyrics',
+          args: []
+        }
+      )
+      if (result?.playerNotFound) {
+        throw new Error('Player not found.')
+      }
+      return result
+    }
+    const player = this.players.get(playerKey)
+    if (!player) throw new Error('Player not found locally.')
+    return player.unsubscribeLyrics()
+  }
 }

src/playback/player.js

@@ -48,6 +48,11 @@ export class Player {
     this.audioMixer = null
     this._initAudioMixer()
 
+    this.isLyricsSubscribed = false
+    this.currentLyrics = null
+    this.lyricsLineIndex = -1
+    this.skipTrackSource = false
+
     logger(
       'debug',
       'Player',
@@ -182,6 +187,9 @@ export class Player {
     this.connection.on('audioStream', (audioStream) => {
       audioStream.on('data', () => {
         this._lastStreamDataTime = Date.now()
+        if (this.isLyricsSubscribed && !this.isPaused && this.track) {
+          this._syncLyrics()
+        }
       })
     })
 
@@ -381,6 +389,8 @@ export class Player {
     this.holoTrack = null
     this.isPaused = false
     this.position = 0
+    this.currentLyrics = null
+    this.lyricsLineIndex = -1
   }
 
   async _emitTrackStart() {
@@ -391,6 +401,10 @@ export class Player {
       track: trackToEmit,
       playingQuality: this.streamInfo?.format?.itag || null
     })
+
+    if (this.isLyricsSubscribed) {
+      this._loadLyrics()
+    }
   }
 
   _emitTrackEnd(reason) {
@@ -845,6 +859,7 @@ export class Player {
       const result = await seekPromise
       if (result) {
         this.emitEvent(GatewayEvents.SEEK, { position: this.position })
+        if (this.isLyricsSubscribed) this._recalculateLyricsIndex()
       }
       return result
     } finally {
@@ -1316,6 +1331,93 @@ export class Player {
     return this.audioMixer.getLayers()
   }
 
+  async subscribeLyrics(skipTrackSource) {
+    if (this.isLyricsSubscribed) return
+    this.isLyricsSubscribed = true
+    this.skipTrackSource = skipTrackSource === 'true' || skipTrackSource === true
+
+    if (this.track && !this.isPaused) {
+      this._loadLyrics()
+    }
+  }
+
+  unsubscribeLyrics() {
+    this.isLyricsSubscribed = false
+    this.skipTrackSource = false
+    this.currentLyrics = null
+    this.lyricsLineIndex = -1
+  }
+
+  async _loadLyrics() {
+    if (!this.track) return
+    
+    const lyricsData = await this.nodelink.lyrics.loadLyrics(
+      { info: this.track.info },
+      undefined,
+      this.skipTrackSource
+    )
+
+    if (lyricsData && lyricsData.loadType === 'lyrics') {
+      this.currentLyrics = lyricsData.data
+      this.lyricsLineIndex = -1
+      this.emitEvent('LyricsFoundEvent', { lyrics: this.currentLyrics })
+      this._recalculateLyricsIndex()
+    } else {
+      this.currentLyrics = null
+      this.emitEvent('LyricsNotFoundEvent')
+    }
+  }
+
+  _syncLyrics() {
+    if (!this.isLyricsSubscribed || !this.currentLyrics || !this.currentLyrics.lines) return
+
+    const position = this._realPosition()
+    const lines = this.currentLyrics.lines
+    const nextIndex = this.lyricsLineIndex + 1
+
+    if (nextIndex >= lines.length) return
+
+    if (position >= lines[nextIndex].time) {
+      this._recalculateLyricsIndex()
+    }
+  }
+
+  _recalculateLyricsIndex() {
+    if (!this.currentLyrics || !this.currentLyrics.lines) return
+
+    const position = this._realPosition()
+    const lines = this.currentLyrics.lines
+
+    let foundIndex = -1
+    // Efficiently find the current line
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].time <= position) {
+        foundIndex = i
+      } else {
+        break
+      }
+    }
+
+    if (foundIndex !== this.lyricsLineIndex) {
+      const skipped = foundIndex > this.lyricsLineIndex + 1
+      this.lyricsLineIndex = foundIndex
+
+      if (foundIndex !== -1) {
+        const line = lines[foundIndex]
+        this.emitEvent('LyricsLineEvent', {
+          lineIndex: foundIndex,
+          line: {
+            timestamp: line.time,
+            duration: line.duration,
+            line: line.text,
+            plugin: null
+          },
+          skipped
+        })
+      }
+    }
+  }
+
   toJSON() {
     return {
       guildId: this.guildId,