add: youtube live chat support via websocket

Author: 1Lucas1apk

src/index.js

@@ -952,11 +952,16 @@ class NodelinkServer extends EventEmitter {
 
           let eventName = '/v4/websocket'
           let guildId = null
+          let liveId = null
           try {
             const url = new URL(ws.data.url)
             const voiceMatch = url.pathname.match(
               /^\/v4\/websocket\/voice\/([A-Za-z0-9]+)\/?$/
             )
+            const liveMatch = url.pathname.match(
+              /^\/v4\/websocket\/youtube\/live\/([^/]+)\/?$/
+            )
+
             if (voiceMatch) {
               if (!self.options.voiceReceive?.enabled) {
                 try {
@@ -966,6 +971,9 @@ class NodelinkServer extends EventEmitter {
               }
               eventName = '/v4/websocket/voice'
               guildId = voiceMatch[1]
+            } else if (liveMatch) {
+              eventName = '/v4/websocket/youtube/live'
+              liveId = liveMatch[1]
             }
           } catch {}
 
@@ -975,7 +983,7 @@ class NodelinkServer extends EventEmitter {
             reqShim,
             clientInfo,
             sessionId,
-            guildId
+            guildId || liveId
           )
         },
         message(ws, message) {
@@ -1073,8 +1081,11 @@ class NodelinkServer extends EventEmitter {
       const voiceMatch = pathname.match(
         /^\/v4\/websocket\/voice\/([A-Za-z0-9]+)\/?$/
       )
+      const liveMatch = pathname.match(
+        /^\/v4\/websocket\/youtube\/live\/([^/]+)\/?$/
+      )
 
-      if (pathname === '/v4/websocket' || voiceMatch) {
+      if (pathname === '/v4/websocket' || voiceMatch || liveMatch) {
         if (!headers['user-id']) {
           logger(
             'warn',
@@ -1110,8 +1121,16 @@ class NodelinkServer extends EventEmitter {
           } connected from ${clientAddress} | \x1b[33mURL:\x1b[0m ${request.url}`
         )
 
-        const eventName = voiceMatch ? '/v4/websocket/voice' : '/v4/websocket'
-        const guildId = voiceMatch ? voiceMatch[1] : null
+        let eventName = '/v4/websocket'
+        let routeId = null
+
+        if (voiceMatch) {
+          eventName = '/v4/websocket/voice'
+          routeId = voiceMatch[1]
+        } else if (liveMatch) {
+          eventName = '/v4/websocket/youtube/live'
+          routeId = liveMatch[1]
+        }
 
         if (isBun && !this._usingBunServer) {
           this.socket.handleUpgrade(request, socket, head, (ws) => {
@@ -1121,7 +1140,7 @@ class NodelinkServer extends EventEmitter {
               request,
               clientInfo,
               sessionId,
-              guildId
+              routeId
             )
           })
         } else {
@@ -1132,7 +1151,7 @@ class NodelinkServer extends EventEmitter {
               request,
               clientInfo,
               sessionId,
-              guildId
+              routeId
             )
           )
         }
@@ -1169,6 +1188,65 @@ class NodelinkServer extends EventEmitter {
         this.registerVoiceSocket(guildId, socket)
       }
     )
+
+    this.socket.on(
+      '/v4/websocket/youtube/live',
+      (socket, request, _clientInfo, _sessionId, id) => {
+        let videoId = id
+
+        if (/^\d{17,20}$/.test(id)) {
+          const player = this.sessions.getPlayer(id)
+          if (player?.track?.info?.sourceName?.includes('youtube')) {
+            videoId = player.track.info.identifier
+          }
+        } 
+        else if (id.length > 50) {
+          try {
+            const decoded = decodeTrack(id)
+            if (decoded?.info?.sourceName?.includes('youtube')) {
+              videoId = decoded.info.identifier
+            }
+          } catch (_e) {}
+        }
+
+        if (!this.sourceWorkerManager) {
+          const yt = this.sources.getSource('youtube')
+          if (!yt) {
+            socket.close(1008, 'YouTube source not enabled')
+            return
+          }
+          yt.handleLiveChat(socket, videoId)
+          return
+        }
+
+        logger('info', 'YouTube-LiveChat', `Delegating live chat for video: ${videoId} to worker`)
+
+        const resShim = {
+          headersSent: false,
+          send: (data) => {
+            const payload = Buffer.isBuffer(data) ? data : Buffer.from(String(data))
+            socket.sendFrame(payload, { len: payload.length, fin: true, opcode: Buffer.isBuffer(data) ? 0x02 : 0x01 })
+          },
+          writeHead: (status) => {
+            if (status !== 200) socket.close(1011, 'Worker failed')
+          },
+          write: (data) => {
+            const payload = Buffer.isBuffer(data) ? data : Buffer.from(String(data))
+            socket.sendFrame(payload, { len: payload.length, fin: true, opcode: Buffer.isBuffer(data) ? 0x02 : 0x01 })
+          },
+          end: () => socket.close(1000, 'Finished'),
+          on: (event, cb) => socket.on(event, cb)
+        }
+
+        this.sourceWorkerManager.delegate(
+          request,
+          resShim,
+          'loadLiveChat',
+          { videoId },
+          { isWebSocket: true }
+        )
+      }
+    )
   }
 
   _listen() {

src/managers/sessionManager.js

@@ -138,4 +138,12 @@ export default class SessionManager {
   values() {
     return this.activeSessions.values()
   }
+
+  getPlayer(guildId) {
+    for (const session of this.activeSessions.values()) {
+      const player = session.players.get(guildId)
+      if (player) return player
+    }
+    return null
+  }
 }

src/managers/sourceWorkerManager.js

@@ -58,6 +58,20 @@ class SourceWorkerManager {
             } else if (type === 1) {
               request.res.end()
               this._cleanupRequest(id, request)
+            } else if (type === 3) {
+              if (request.timeout) {
+                clearTimeout(request.timeout)
+                request.timeout = null
+              }
+              if (!request.res.headersSent && request.options?.isWebSocket) {
+                request.res.send(payload)
+              } else if (!request.res.headersSent) {
+                request.res.setHeader('Content-Type', 'application/json')
+                request.res.writeHead(200)
+                request.res.write(payload)
+              } else {
+                request.res.write(payload)
+              }
             } else if (type === 2) {
               const errorMsg = payload.toString('utf8')
               if (!request.res.headersSent) {
@@ -150,6 +164,20 @@ class SourceWorkerManager {
     if (!request || request.cleaned) return
     request.cleaned = true
     if (request.timeout) clearTimeout(request.timeout)
+
+    if (request.task === 'loadLiveChat') {
+      const worker = this.workers.find((w) => w.id === request.workerId)
+      if (worker) {
+        worker.send({
+          type: 'sourceTask',
+          payload: {
+            task: 'cancelLiveChat',
+            payload: { id }
+          }
+        })
+      }
+    }
+
     this._decrementLoad(request.workerId)
     this.requests.delete(id)
   }
@@ -173,6 +201,7 @@ class SourceWorkerManager {
     const request = {
       req,
       res,
+      task,
       timeout: null,
       workerId: bestWorker.id,
       options,

src/managers/workerManager.js

@@ -410,6 +410,12 @@ export default class WorkerManager {
                   100
                 )
               }
+            } else if (type === 9) {
+              if (global.nodelink)
+                global.nodelink.handleIPCMessage({
+                  type: 'liveChatAction',
+                  payload: data
+                })
             }
           } catch (e) {
             logger('error', 'Cluster', `Socket event parse error: ${e.message}`)

src/sourceWorker.js

@@ -64,6 +64,8 @@ if (isMainThread) {
         processNextTask()
       } else if (msg.type === 'stream') {
         sendStreamChunk(msg.socketPath, msg.id, msg.chunk)
+      } else if (msg.type === 'chatAction') {
+        sendChatAction(msg.socketPath, msg.id, msg.data)
       } else if (msg.type === 'end') {
         sendStreamEnd(msg.socketPath, msg.id)
         worker.load = Math.max(0, worker.load - 1)
@@ -134,6 +136,11 @@ if (isMainThread) {
     withSocket(socketPath, (socket) => sendFrame(socket, id, 0, payload))
   }
 
+  function sendChatAction(socketPath, id, data) {
+    const payload = Buffer.from(JSON.stringify(data), 'utf8')
+    withSocket(socketPath, (socket) => sendFrame(socket, id, 3, payload))
+  }
+
   function sendStreamEnd(socketPath, id) {
     withSocket(socketPath, (socket) =>
       sendFrame(socket, id, 1, Buffer.alloc(0))
@@ -228,6 +235,8 @@ if (isMainThread) {
   await nodelink.sources.loadFolder()
   await nodelink.lyrics.loadFolder()
 
+  const activeChats = new Map()
+
   parentPort.postMessage({ type: 'ready' })
 
   const sendStreamChunkFromWorker = (id, socketPath, chunk) => {
@@ -247,6 +256,48 @@ if (isMainThread) {
     })
   }
 
+  const handleLiveChat = async (id, socketPath, payload) => {
+    const videoId = payload.videoId
+    const yt = nodelink.sources.getSource('youtube')
+    if (!yt) throw new Error('YouTube source not available in worker')
+
+    activeChats.set(id, true)
+
+    try {
+      const chat = await yt.liveChat.getLiveChat(videoId)
+      if (!chat) throw new Error('Could not initialize live chat')
+
+      const pollLoop = async () => {
+        while (activeChats.has(id)) {
+          try {
+            const result = await chat.poll()
+            if (!result) break
+
+            const { actions, timeoutMs } = result
+
+            if (actions.length > 0 && activeChats.has(id)) {
+              utils.logger('debug', 'SourceWorker', `[${id}] Sending ${actions.length} actions for ${videoId}`)
+              parentPort.postMessage({ type: 'chatAction', id, socketPath, data: { op: 'actions', actions } })
+            }
+
+            await new Promise(resolve => setTimeout(resolve, timeoutMs || 5000))
+          } catch (e) {
+            utils.logger('error', 'SourceWorker', `[${id}] Polling exception for ${videoId}: ${e.message}`)
+            break
+          }
+        }
+      }
+
+      await pollLoop()
+
+      parentPort.postMessage({ type: 'end', id, socketPath })
+    } catch (e) {
+      sendStreamErrorFromWorker(id, socketPath, e.message)
+    } finally {
+      activeChats.delete(id)
+    }
+  }
+
   const handleLoadStream = async (id, socketPath, payload) => {
     let fetched = null
     let pcmStream = null
@@ -329,6 +380,20 @@ if (isMainThread) {
       return
     }
 
+    if (task === 'loadLiveChat') {
+      try {
+        await handleLiveChat(id, socketPath, payload)
+      } catch (e) {
+        sendStreamErrorFromWorker(id, socketPath, e.message || e)
+      }
+      return
+    }
+
+    if (task === 'cancelLiveChat') {
+      activeChats.delete(payload.id)
+      return
+    }
+
     try {
       let result
       switch (task) {