Update server/server.js

server/server.js

@@ -1,7 +1,3 @@
-// server/server.js
-// Complete server with Vidfly.ai primary YouTube resolver, yt-dlp fallback, CORS media proxy,
-// JioSaavn routes, static client, and full Socket.IO room sync logic.
-
 import express from 'express';
 import http from 'http';
 import cors from 'cors';
@@ -28,368 +24,169 @@ const app = express();
 app.use(cors());
 app.use(express.json());
 
-// Health
-app.get('/healthz', (_req, res) => res.send('OK'));
-
-// Cache for YouTube resolution results (5 minutes)
+// Cache for Vidfly results
 const formatCache = new NodeCache({ stdTTL: 300, checkperiod: 60 });
 
-// ========== Media proxy to bypass CORS on remote media URLs ==========
+// Proxy endpoint with Range support
 app.get('/api/proxy', async (req, res) => {
+  const target = req.query.url;
+  if (!target) return res.status(400).send('Missing url');
   try {
-    const target = req.query.url;
-    if (!target) return res.status(400).send('Missing url');
-    // Forward common streaming headers (Range is crucial for video seeking)
-    const fwdHeaders = {};
-    if (req.headers.range) fwdHeaders.Range = req.headers.range;
-    if (req.headers['user-agent']) fwdHeaders['User-Agent'] = req.headers['user-agent'];
-    if (req.headers['accept']) fwdHeaders['Accept'] = req.headers['accept'];
-    if (req.headers['accept-encoding']) fwdHeaders['Accept-Encoding'] = req.headers['accept-encoding'];
-    if (req.headers['accept-language']) fwdHeaders['Accept-Language'] = req.headers['accept-language'];
-    if (req.headers['referer']) fwdHeaders['Referer'] = req.headers['referer'];
-    // You can also set a generic Referer if some CDNs require it
+    const headers = {};
+    if (req.headers.range) headers.Range = req.headers.range;
     const upstream = await axios.get(target, {
       responseType: 'stream',
-      headers: fwdHeaders,
-      validateStatus: () => true, // pass-through non-200s
-      maxRedirects: 5
+      headers,
+      validateStatus: () => true
     });
-
-    // Mirror status and selected headers
     res.status(upstream.status);
-    const passthroughHeaders = [
-      'content-type',
-      'content-length',
-      'content-range',
-      'accept-ranges',
-      'etag',
-      'last-modified',
-      'cache-control',
-      'expires',
-      'date',
-      'server'
-    ];
-    for (const h of passthroughHeaders) {
-      const v = upstream.headers[h];
-      if (v) res.setHeader(h, v);
+    for (const h of ['content-type','content-length','content-range','accept-ranges']) {
+      if (upstream.headers[h]) res.setHeader(h, upstream.headers[h]);
     }
-    // Stream body
     upstream.data.pipe(res);
-  } catch (_e) {
+  } catch {
     res.status(502).send('Proxy fetch failed');
   }
 });
 
-// ========== YouTube resolver: Vidfly.ai primary, yt-dlp fallback ==========
-// Supports ?url=<id|full-url>&api=vidfly|yt-dlp (api param optional; default is Vidfly then fallback)
+// YouTube resolver
 app.get('/api/yt/source', async (req, res) => {
-  try {
-    const raw = (req.query.url || '').trim();
-    const apiPref = (req.query.api || '').trim().toLowerCase(); // optional: 'vidfly' or 'yt-dlp'
-    if (!raw) return res.status(400).json({ error: 'Missing url' });
-
-    // Normalize 11-char YouTube ID to full watch URL
-    let watchUrl = raw;
-    if (/^[A-Za-z0-9_-]{11}$/.test(raw)) {
-      watchUrl = `https://www.youtube.com/watch?v=${raw}`;
-    }
+  const raw = (req.query.url || '').trim();
+  const apiPref = (req.query.api || '').trim().toLowerCase();
+  if (!raw) return res.status(400).json({ error: 'Missing url' });
 
-    // Helper: respond from Vidfly.ai
-    const tryVidfly = async () => {
-      const cacheKey = `vidfly:${watchUrl}`;
-      let info = formatCache.get(cacheKey);
-      if (!info) {
-        const resp = await axios.get('https://api.vidfly.ai/api/media/youtube/download', {
-          params: { url: watchUrl },
-          timeout: 25000
-        });
-        info = resp.data;
-        formatCache.set(cacheKey, info);
-      }
-      // Adjust parsing to Vidfly.ai response shape if needed
-      // Expected generic shape assumption:
-      // { title, thumbnail, duration, video: [{quality, url, mimeType}], audio: [{bitrate, url, mimeType}] }
-      const videos = Array.isArray(info?.video) ? info.video : [];
-      const audios = Array.isArray(info?.audio) ? info.audio : [];
-
-      // Prefer MP4 progressive-like URLs for browser playback
-      const pickVideo = videos
-        .filter(f => f?.url && /mp4/i.test(f?.mimeType || '') || (typeof f?.url === 'string' && f.url.endsWith('.mp4')))
-        .sort((a, b) => {
-          const qa = parseInt(String(a.quality || '').replace(/\D/g, '') || '0', 10);
-          const qb = parseInt(String(b.quality || '').replace(/\D/g, '') || '0', 10);
-          return qb - qa;
-        })[0];
-
-      const pickAudio = audios
-        .filter(f => f?.url)
-        .sort((a, b) => {
-          const ba = parseInt(String(a.bitrate || '').replace(/\D/g, '') || '0', 10);
-          const bb = parseInt(String(b.bitrate || '').replace(/\D/g, '') || '0', 10);
-          return bb - ba;
-        })[0];
-
-      const chosen = pickVideo || pickAudio;
-      if (!chosen?.url) throw new Error('Vidfly: No playable stream');
-
-      return {
-        url: chosen.url,
-        title: info?.title || watchUrl,
-        thumbnail: info?.thumbnail || null,
-        duration: info?.duration || null,
-        kind: pickVideo ? 'video' : 'audio',
-        source: 'vidfly'
-      };
+  let watchUrl = raw;
+  if (/^[A-Za-z0-9_-]{11}$/.test(raw)) {
+    watchUrl = `https://www.youtube.com/watch?v=${raw}`;
+  }
+
+  const tryVidfly = async () => {
+    const cacheKey = `vidfly:${watchUrl}`;
+    let info = formatCache.get(cacheKey);
+    if (!info) {
+      const resp = await axios.get('https://api.vidfly.ai/api/media/youtube/download', {
+        params: { url: watchUrl },
+        timeout: 20000
+      });
+      info = resp.data;
+      formatCache.set(cacheKey, info);
+    }
+    if (info.code !== 0 || !info.data?.items?.length) {
+      throw new Error('Vidfly: No playable stream');
+    }
+    const items = info.data.items;
+    // Prefer video_with_audio mp4
+    const muxed = items
+      .filter(i => i.type === 'video_with_audio' && i.ext === 'mp4')
+      .sort((a,b) => (b.height||0) - (a.height||0))[0];
+    const audio = items
+      .filter(i => i.type === 'audio')
+      .sort((a,b) => (parseInt(b.bitrate||'0') - parseInt(a.bitrate||'0')))[0];
+    const chosen = muxed || audio;
+    if (!chosen?.url) throw new Error('Vidfly: No playable stream');
+    return {
+      url: chosen.url,
+      title: info.data.title || watchUrl,
+      thumbnail: info.data.cover || null,
+      duration: info.data.duration || null,
+      kind: muxed ? 'video' : 'audio',
+      source: 'vidfly'
     };
+  };
 
-    // Helper: respond from local yt-dlp CLI
-    const tryYtDlp = async () => {
-      // -g prints direct URL(s)
-      // -f best first tries progressive best; if not, it may output separate URLs (video, audio)
-      const { stdout } = await exec(`yt-dlp -f best -g "${watchUrl}"`);
-      const lines = stdout.trim().split('\n').filter(Boolean);
-      // If two lines, first is video-only URL then audio-only; we'll prefer the first
-      const direct = lines[0];
-      if (!direct) throw new Error('yt-dlp: No URL output');
-      return {
-        url: direct,
-        title: watchUrl,
-        thumbnail: null,
-        duration: null,
-        kind: 'video',
-        source: 'yt-dlp'
-      };
+  const tryYtDlp = async () => {
+    const { stdout } = await exec(`yt-dlp -f best -g "${watchUrl}"`);
+    const lines = stdout.trim().split('\n').filter(Boolean);
+    const direct = lines[0];
+    if (!direct) throw new Error('yt-dlp: No URL output');
+    return {
+      url: direct,
+      title: watchUrl,
+      thumbnail: null,
+      duration: null,
+      kind: 'video',
+      source: 'yt-dlp'
     };
+  };
 
-    // Route based on api preference or attempt Vidfly then fallback
-    if (apiPref === 'vidfly') {
-      try {
-        const r = await tryVidfly();
-        return res.json(r);
-      } catch (e) {
-        return res.status(502).json({ error: String(e.message || e), source: 'vidfly' });
-      }
-    }
-    if (apiPref === 'yt-dlp') {
-      try {
-        const r = await tryYtDlp();
-        return res.json(r);
-      } catch (e) {
-        return res.status(502).json({ error: String(e.message || e), source: 'yt-dlp' });
-      }
-    }
+  if (apiPref === 'vidfly') {
+    try { return res.json(await tryVidfly()); }
+    catch (e) { return res.status(502).json({ error: e.message, source: 'vidfly' }); }
+  }
+  if (apiPref === 'yt-dlp') {
+    try { return res.json(await tryYtDlp()); }
+    catch (e) { return res.status(502).json({ error: e.message, source: 'yt-dlp' }); }
+  }
 
-    // Default behavior: Vidfly first, then yt-dlp fallback
-    try {
-      const r = await tryVidfly();
-      return res.json(r);
-    } catch (_e) {
-      // swallow and try fallback
-    }
-    try {
-      const r = await tryYtDlp();
-      return res.json(r);
-    } catch (e) {
-      return res.status(500).json({
-        error: 'Both Vidfly.ai and yt-dlp fallback failed',
-        details: String(e.message || e)
-      });
-    }
-  } catch (e) {
-    return res.status(500).json({ error: String(e.message || e) });
+  try { return res.json(await tryVidfly()); }
+  catch {}
+  try { return res.json(await tryYtDlp()); }
+  catch (e) {
+    return res.status(500).json({ error: 'Both Vidfly.ai and yt-dlp failed', details: e.message });
   }
 });
 
-// ========== JioSaavn routes ==========
+// JioSaavn routes
 app.get('/api/result', async (req, res) => {
-  try {
-    const q = req.query.q || '';
-    res.json(await searchUniversal(q));
-  } catch (e) {
-    res.status(500).json({ error: e.message });
-  }
+  try { res.json(await searchUniversal(req.query.q || '')); }
+  catch (e) { res.status(500).json({ error: e.message }); }
 });
 app.get('/api/song', async (req, res) => {
-  try {
-    res.json(await getSong(req.query.q || ''));
-  } catch (e) {
-    res.status(500).json({ error: e.message });
-  }
+  try { res.json(await getSong(req.query.q || '')); }
+  catch (e) { res.status(500).json({ error: e.message }); }
 });
 app.get('/api/album', async (req, res) => {
-  try {
-    res.json(await getAlbum(req.query.q || ''));
-  } catch (e) {
-    res.status(500).json({ error: e.message });
-  }
+  try { res.json(await getAlbum(req.query.q || '')); }
+  catch (e) { res.status(500).json({ error: e.message }); }
 });
 app.get('/api/playlist', async (req, res) => {
-  try {
-    res.json(await getPlaylist(req.query.q || ''));
-  } catch (e) {
-    res.status(500).json({ error: e.message });
-  }
+  try { res.json(await getPlaylist(req.query.q || '')); }
+  catch (e) { res.status(500).json({ error: e.message }); }
 });
 app.get('/api/lyrics', async (req, res) => {
-  try {
-    res.json(await getLyrics(req.query.q || ''));
-  } catch (e) {
-    res.status(500).json({ error: e.message });
-  }
+  try { res.json(await getLyrics(req.query.q || '')); }
+  catch (e) { res.status(500).json({ error: e.message }); }
 });
 
-// ========== Optional YouTube Data API search (set YT_API_KEY to enable) ==========
-app.get('/api/ytsearch', async (req, res) => {
-  try {
-    const key = process.env.YT_API_KEY;
-    if (!key) return res.status(501).json({ error: 'YouTube search unavailable: set YT_API_KEY' });
-    const q = req.query.q || '';
-    const resp = await axios.get('https://www.googleapis.com/youtube/v3/search', {
-      params: { key, q, part: 'snippet', type: 'video', maxResults: 12 },
-      timeout: 12000
-    });
-    const items = (resp.data.items || []).map(it => ({
-      videoId: it.id?.videoId,
-      title: it.snippet?.title,
-      channelTitle: it.snippet?.channelTitle,
-      thumb: it.snippet?.thumbnails?.medium?.url || it.snippet?.thumbnails?.default?.url
-    })).filter(Boolean);
-    res.json({ items });
-  } catch (e) {
-    res.status(500).json({ error: e.message });
-  }
-});
-
-// ========== In-memory room state and helpers ==========
-/*
-room = {
-  id, name, hostId,
-  users: Map<socketId, { name, role: 'host'|'cohost'|'member', muted?: boolean }>,
-  track: { url, title, meta, kind, thumb? },
-  isPlaying, anchor, anchorAt,
-  queue: Array<track>
-}
-*/
+// Lobby
 const rooms = new Map();
-
-function ensureRoom(roomId) {
-  if (!rooms.has(roomId)) {
-    rooms.set(roomId, {
-      id: roomId,
-      name: null,
-      hostId: null,
-      users: new Map(),
-      track: null,
-      isPlaying: false,
-      anchor: 0,
-      anchorAt: 0,
-      queue: []
-    });
+function ensureRoom(id) {
+  if (!rooms.has(id)) {
+    rooms.set(id, { id, name: null, hostId: null, users: new Map(), track: null, isPlaying: false, anchor: 0, anchorAt: 0, queue: [] });
   }
-  return rooms.get(roomId);
+  return rooms.get(id);
 }
-
-function currentState(room) {
-  return {
-    track: room.track,
-    isPlaying: room.isPlaying,
-    anchor: room.anchor,
-    anchorAt: room.anchorAt,
-    queue: room.queue
-  };
-}
-
-function membersPayload(room) {
-  return [...room.users.entries()].map(([id, u]) => ({
-    id,
-    name: u.name || 'Guest',
-    role: u.role || 'member',
-    muted: !!u.muted,
-    isHost: id === room.hostId
-  }));
-}
-
-function broadcastMembers(roomId) {
-  const room = rooms.get(roomId);
-  if (!room) return;
-  const members = membersPayload(room);
-  io.to(roomId).emit('members', { members, roomName: room.name || room.id });
-}
-
-function requireHostOrCohost(room, socketId) {
-  const u = room.users.get(socketId);
-  return (socketId === room.hostId) || (u && u.role === 'cohost');
-}
-
-function normalizeThumb(meta) {
-  const candidates = [
-    meta?.thumb,
-    meta?.image,
-    meta?.thumbnail,
-    meta?.song_image,
-    meta?.album_image,
-    meta?.image_url,
-    meta?.images?.cover,
-    meta?.images?.[0]
-  ].filter(Boolean);
-  return candidates[0] || null;
-}
-
-function findUserByName(room, targetNameRaw) {
-  if (!targetNameRaw) return null;
-  const targetName = String(targetNameRaw).replace(/^@/, '').trim().toLowerCase();
-  let candidate = null;
-  for (const [id, u] of room.users.entries()) {
-    const n = (u.name || '').toLowerCase();
-    if (n === targetName) return { id, u };
-    if (!candidate && n.startsWith(targetName)) candidate = { id, u };
-  }
-  if (candidate) return candidate;
-  for (const [id, u] of room.users.entries()) {
-    const n = (u.name || '').toLowerCase();
-    if (n.includes(targetName)) return { id, u };
-  }
-  return null;
-}
-
-// ========== Lobby ==========
-app.get('/api/rooms', (_req, res) => {
-  const data = [...rooms.values()]
-    .filter(r => r.users.size > 0)
-    .map(r => ({
-      id: r.id,
-      name: r.name || r.id,
-      members: r.users.size,
-      isPlaying: r.isPlaying
-    }));
-  res.json({ rooms: data });
+function currentState(r) { return { track: r.track, isPlaying: r.isPlaying, anchor: r.anchor, anchorAt: r.anchorAt, queue: r.queue }; }
+function membersPayload(r) { return [...r.users.entries()].map(([id,u]) => ({ id, name: u.name, role: u.role, muted: !!u.muted, isHost: id===r.hostId })); }
+function broadcastMembers(id) { const r=rooms.get(id); if(r) io.to(id).emit('members',{members:membersPayload(r),roomName:r.name||r.id}); }
+function requireHostOrCohost(r,sid){const u=r.users.get(sid);return sid===r.hostId||(u&&u.role==='cohost');}
+function normalizeThumb(meta){return meta?.thumb||meta?.image||null;}
+function findUserByName(r,n){if(!n)return null;const t=n.replace(/^@/,'').toLowerCase();for(const [id,u] of r.users){if(u.name.toLowerCase()===t)return{id,u};}return null;}
+
+app.get('/api/rooms', (_req,res) => {
+  res.json({ rooms: [...rooms.values()].filter(r=>r.users.size>0).map(r=>({id:r.id,name:r.name||r.id,members:r.users.size,isPlaying:r.isPlaying})) });
 });
+app.get('/api/ping', (_req,res) => res.json({ ok:true }));
 
-app.get('/api/ping', (_req, res) => res.json({ ok: true }));
-
-// ========== Static client ==========
+// Static client
 const clientDir = path.resolve(__dirname, '../client/dist');
 app.use(express.static(clientDir));
-app.get('*', (_req, res) => res.sendFile(path.join(clientDir, 'index.html')));
+app.get('*', (_req,res) => res.sendFile(path.join(clientDir, 'index.html')));
 
-// ========== Socket.IO realtime ==========
+// Socket.IO
 const server = http.createServer(app);
-const io = new SocketIOServer(server, {
-  cors: { origin: '*', methods: ['GET', 'POST'] }
-});
+const io = new SocketIOServer(server, { cors: { origin: '*', methods: ['GET','POST'] } });
 
-io.on('connection', (socket) => {
+io.on('connection', socket => {
   let joinedRoom = null;
-
-  socket.on('join_room', ({ roomId, name, asHost = false, roomName = null }, ack) => {
+  socket.on('join_room', ({ roomId, name, asHost=false, roomName=null }, ack) => {
     const room = ensureRoom(roomId);
-
     if (asHost || !room.hostId) room.hostId = socket.id;
-    if (!room.name && roomName) room.name = String(roomName).trim().slice(0, 60) || null;
+    if (!room.name && roomName) room.name = roomName;
+    
 
     const role = socket.id === room.hostId ? 'host' : 'member';
-    const cleanName = String(name || 'Guest').slice(0, 40);
-    room.users.set(socket.id, { name: cleanName, role });
+    room.users.set(socket.id, { name: name || 'Guest', role });
 
     socket.join(roomId);
     joinedRoom = roomId;
@@ -398,86 +195,82 @@ io.on('connection', (socket) => {
       roomId,
       isHost: socket.id === room.hostId,
       state: currentState(room),
-      roomName: room.name || room.id
+      roomName: room.name
     });
 
-    io.to(roomId).emit('system', { text: `System: ${cleanName} has joined the chat` });
+    io.to(roomId).emit('system', { text: `System: ${name} has joined the chat` });
     broadcastMembers(roomId);
   });
 
   socket.on('rename', ({ roomId, newName }) => {
     const room = rooms.get(roomId);
-    if (!room) return;
-    const u = room.users.get(socket.id);
-    if (!u) return;
-    u.name = String(newName || 'Guest').slice(0, 40);
-    broadcastMembers(roomId);
+    const u = room?.users.get(socket.id);
+    if (u) {
+      u.name = newName || 'Guest';
+      broadcastMembers(roomId);
+    }
   });
 
   socket.on('chat_message', ({ roomId, name, text }) => {
     const room = rooms.get(roomId);
-    if (!room) return;
-    const u = room.users.get(socket.id);
+    const u = room?.users.get(socket.id);
     if (!u) return;
     if (u.muted) {
-      socket.emit('system', { text: 'System: You are muted by the host' });
-      return;
+      return socket.emit('system', { text: 'System: You are muted' });
     }
     socket.to(roomId).emit('chat_message', { name, text, at: Date.now() });
   });
 
-  // Requests: user asks host to play something
   socket.on('song_request', ({ roomId, requester, query }) => {
     const room = rooms.get(roomId);
     if (!room) return;
-    const payload = { requester, query, at: Date.now(), requestId: `${Date.now()}_${Math.random().toString(36).slice(2)}` };
-    for (const [id, usr] of room.users.entries()) {
-      if (id === room.hostId || usr.role === 'cohost') io.to(id).emit('song_request', payload);
+    const requestId = `${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    const payload = { requester, query, at: Date.now(), requestId };
+    for (const [id, u] of room.users.entries()) {
+      if (id === room.hostId || u.role === 'cohost') {
+        io.to(id).emit('song_request', payload);
+      }
     }
     io.to(roomId).emit('system', { text: `System: ${requester} requested /play ${query}` });
   });
 
-  // Host handles request
   socket.on('song_request_action', ({ roomId, action, track }) => {
     const room = rooms.get(roomId);
-    if (!room) return;
-    if (!requireHostOrCohost(room, socket.id)) return;
-    if ((action === 'accept' || action === 'queue') && track) {
-      const t = {
-        url: track.url,
-        title: track.title || track.url,
-        meta: track.meta || {},
-        kind: track.kind || 'audio',
-        thumb: track.thumb || normalizeThumb(track.meta || {})
-      };
-      if (action === 'accept') {
-        room.track = t;
-        room.isPlaying = false;
-        room.anchor = 0;
-        room.anchorAt = Date.now();
-        io.to(roomId).emit('set_track', { track: room.track });
-        io.to(roomId).emit('pause', { anchor: 0, anchorAt: room.anchorAt });
-        io.to(roomId).emit('system', { text: `System: Now playing ${room.track.title}` });
-      } else {
-        room.queue.push(t);
-        io.to(roomId).emit('queue_update', { queue: room.queue });
-        io.to(roomId).emit('system', { text: `System: Queued ${t.title}` });
-      }
+    if (!room || !requireHostOrCohost(room, socket.id) || !track) return;
+    const t = {
+      url: track.url,
+      title: track.title || track.url,
+      meta: track.meta || {},
+      kind: track.kind || 'audio',
+      thumb: track.thumb || normalizeThumb(track.meta)
+    };
+    if (action === 'accept') {
+      room.track = t;
+      room.isPlaying = false;
+      room.anchor = 0;
+      room.anchorAt = Date.now();
+      io.to(roomId).emit('set_track', { track: t });
+      io.to(roomId).emit('pause', { anchor: 0, anchorAt: room.anchorAt });
+      io.to(roomId).emit('system', { text: `System: Now playing ${t.title}` });
+    } else if (action === 'queue') {
+      room.queue.push(t);
+      io.to(roomId).emit('queue_update', { queue: room.queue });
+      io.to(roomId).emit('system', { text: `System: Queued ${t.title}` });
     }
   });
 
-  // Host/co-host selects a track directly
   socket.on('set_track', ({ roomId, track }) => {
     const room = rooms.get(roomId);
     if (!room || !requireHostOrCohost(room, socket.id)) return;
-    const thumb = track.thumb || normalizeThumb(track.meta || {});
-    room.track = { ...track, thumb };
+    const thumb = track.thumb || normalizeThumb(track.meta);
+    const t = { ...track, thumb };
+    room.track = t;
     room.isPlaying = false;
     room.anchor = 0;
     room.anchorAt = Date.now();
-    io.to(roomId).emit('set_track', { track: room.track });
+    io.to(roomId).emit('set_track', { track: t });
     io.to(roomId).emit('pause', { anchor: 0, anchorAt: room.anchorAt });
-    io.to(roomId).emit('system', { text: `System: Selected ${room.track.title || room.track.url}` });
+    io.to(roomId).emit('system', { text: `System: Selected ${t.title}` });
   });
 
   socket.on('play', ({ roomId }) => {
@@ -491,7 +284,7 @@ io.on('connection', (socket) => {
   socket.on('pause', ({ roomId }) => {
     const room = rooms.get(roomId);
     if (!room || !requireHostOrCohost(room, socket.id)) return;
-    const elapsed = Math.max(0, Date.now() - room.anchorAt) / 1000;
+    const elapsed = (Date.now() - room.anchorAt) / 1000;
     if (room.isPlaying) room.anchor += elapsed;
     room.isPlaying = false;
     room.anchorAt = Date.now();
@@ -511,75 +304,64 @@ io.on('connection', (socket) => {
     if (!room || !requireHostOrCohost(room, socket.id)) return;
     const next = room.queue.shift();
     if (next) {
-      const thumb = next.thumb || normalizeThumb(next.meta || {});
-      room.track = { ...next, thumb };
+      room.track = next;
       room.isPlaying = false;
       room.anchor = 0;
       room.anchorAt = Date.now();
-      io.to(roomId).emit('set_track', { track: room.track });
+      io.to(roomId).emit('set_track', { track: next });
       io.to(roomId).emit('pause', { anchor: 0, anchorAt: room.anchorAt });
       io.to(roomId).emit('queue_update', { queue: room.queue });
-      io.to(roomId).emit('system', { text: `System: Now playing ${room.track.title}` });
+      io.to(roomId).emit('system', { text: `System: Now playing ${next.title}` });
     } else {
       io.to(roomId).emit('system', { text: 'System: Queue ended' });
     }
   });
 
-  // Admin commands: kick, promote, mute
   socket.on('admin_command', ({ roomId, cmd, targetName }) => {
     const room = rooms.get(roomId);
-    if (!room) return;
-    const actor = room.users.get(socket.id);
+    const actor = room?.users.get(socket.id);
     if (!actor || !(socket.id === room.hostId || actor.role === 'cohost')) return;
-
     const found = findUserByName(room, targetName);
     if (!found) {
-      io.to(socket.id).emit('system', { text: `System: User @${targetName} not found` });
-      return;
+      return io.to(socket.id).emit('system', { text: `System: @${targetName} not found` });
     }
-
+    const { id, u } = found;
     if (cmd === 'kick') {
-      const { id } = found;
-      io.to(id).emit('system', { text: 'System: You were kicked by the host' });
+      io.to(id).emit('system', { text: 'System: You were kicked' });
       io.sockets.sockets.get(id)?.leave(roomId);
       room.users.delete(id);
-      io.to(roomId).emit('system', { text: `System: ${found.u.name} was kicked` });
+      io.to(roomId).emit('system', { text: `System: ${u.name} was kicked` });
       broadcastMembers(roomId);
     } else if (cmd === 'promote') {
-      found.u.role = 'cohost';
-      io.to(roomId).emit('system', { text: `System: ${found.u.name} was promoted to co-host` });
+      u.role = 'cohost';
+      io.to(roomId).emit('system', { text: `System: ${u.name} promoted to co-host` });
       broadcastMembers(roomId);
     } else if (cmd === 'mute') {
-      found.u.muted = true;
-      io.to(roomId).emit('system', { text: `System: ${found.u.name} was muted` });
+      u.muted = true;
+      io.to(roomId).emit('system', { text: `System: ${u.name} was muted` });
       broadcastMembers(roomId);
     }
   });
 
   socket.on('sync_request', ({ roomId }, ack) => {
     const room = rooms.get(roomId);
-    if (!room) return;
-    ack?.(currentState(room));
+    if (room) ack(currentState(room));
   });
 
   socket.on('disconnect', () => {
     if (!joinedRoom) return;
     const room = rooms.get(joinedRoom);
     if (!room) return;
-    const leftUser = room.users.get(socket.id);
+    const u = room.users.get(socket.id);
     room.users.delete(socket.id);
     if (socket.id === room.hostId) {
-      const nextHost = [...room.users.keys()][0] || null;
-      room.hostId = nextHost;
-      if (nextHost) {
-        const u = room.users.get(nextHost);
-        if (u) u.role = 'host';
-      }
-      io.to(joinedRoom).emit('host_changed', { hostId: room.hostId });
+      const next = [...room.users.keys()][0] || null;
+      room.hostId = next;
+      if (next) room.users.get(next).role = 'host';
+      io.to(joinedRoom).emit('host_changed', { hostId: next });
     }
-    if (leftUser) {
-      const nm = leftUser.name || 'User';
-      io.to(joinedRoom).emit('system', { text: `System: ${nm} has left the chat` });
+    if (u) {
+      io.to(joinedRoom).emit('system', { text: `System: ${u.name} has left` });
     }
     if (room.users.size === 0) rooms.delete(joinedRoom);
     else broadcastMembers(joinedRoom);