Update server/server.js

server/server.js

@@ -4,6 +4,7 @@ import cors from 'cors';
 import { Server as SocketIOServer } from 'socket.io';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import axios from 'axios';
 import {
   searchUniversal,
   getSong,
@@ -19,12 +20,17 @@ const app = express();
 app.use(cors());
 app.use(express.json());
 
-// ✅ Health check endpoint for Hugging Face
-app.get('/healthz', (req, res) => {
-  res.send('OK');
-});
+// Health check endpoint
+app.get('/healthz', (req, res) => res.send('OK'));
 
-// In-memory rooms
+// Room model:
+// {
+//   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>
+// }
 const rooms = new Map();
 
 function ensureRoom(roomId) {
@@ -37,33 +43,60 @@ function ensureRoom(roomId) {
       track: null,
       isPlaying: false,
       anchor: 0,
-      anchorAt: 0
+      anchorAt: 0,
+      queue: []
     });
   }
   return rooms.get(roomId);
 }
 
-function broadcastMembers(roomId) {
-  const room = rooms.get(roomId);
-  if (!room) return;
-  const members = [...room.users.entries()].map(([id, u]) => ({
+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 currentState(room) {
-  return {
-    track: room.track,
-    isPlaying: room.isPlaying,
-    anchor: room.anchor,
-    anchorAt: room.anchorAt
-  };
+function requireHostOrCohost(room, socketId) {
+  const u = room.users.get(socketId);
+  return (socketId === room.hostId) || (u && (u.role === 'cohost'));
 }
 
-// ---------- API endpoints ----------
+function normalizeThumb(meta) {
+  const candidates = [
+    meta?.image,
+    meta?.thumbnail,
+    meta?.song_image,
+    meta?.album_image,
+    meta?.image_url,
+    meta?.images?.[0],
+    meta?.images?.medium,
+    meta?.images?.cover
+  ].filter(Boolean);
+  return candidates[0] || null;
+}
+
+// ---------- API endpoints (JioSaavn proxy) ----------
 app.get('/api/result', async (req, res) => {
   try {
     const q = req.query.q || '';
@@ -114,8 +147,36 @@ app.get('/api/lyrics', async (req, res) => {
   }
 });
 
-// Active rooms list
-app.get('/api/rooms', (req, res) => {
+// ---------- YouTube search (requires YT_API_KEY env) ----------
+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 env' });
+    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: 10
+      },
+      timeout: 10000
+    });
+    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(x => x.videoId);
+    res.json({ items });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Active rooms for lobby
+app.get('/api/rooms', (_req, res) => {
   const data = [...rooms.values()]
     .filter(r => r.users.size > 0)
     .map(r => ({
@@ -127,14 +188,12 @@ app.get('/api/rooms', (req, res) => {
   res.json({ rooms: data });
 });
 
-app.get('/api/ping', (req, res) => res.json({ ok: true }));
+app.get('/api/ping', (_req, res) => res.json({ ok: true }));
 
-// ✅ Serve frontend build at root
+// Serve frontend build
 const clientDir = path.resolve(__dirname, '../client/dist');
 app.use(express.static(clientDir));
-app.get('*', (_, res) => {
-  res.sendFile(path.join(clientDir, 'index.html'));
-});
+app.get('*', (_req, res) => res.sendFile(path.join(clientDir, 'index.html')));
 
 // ---------- Socket.IO ----------
 const server = http.createServer(app);
@@ -147,11 +206,13 @@ io.on('connection', (socket) => {
 
   socket.on('join_room', ({ roomId, name, asHost = false, roomName = null }, ack) => {
     const room = ensureRoom(roomId);
-    room.users.set(socket.id, { name: name || 'Guest' });
 
     if (asHost || !room.hostId) room.hostId = socket.id;
     if (!room.name && roomName) room.name = String(roomName).trim().slice(0, 60) || null;
 
+    const role = socket.id === room.hostId ? 'host' : 'member';
+    room.users.set(socket.id, { name: String(name || 'Guest').slice(0, 40), role });
+
     socket.join(roomId);
     joinedRoom = roomId;
 
@@ -162,37 +223,93 @@ io.on('connection', (socket) => {
       roomName: room.name || room.id
     });
 
-    socket.to(roomId).emit('system', { type: 'join', name, id: socket.id });
+    io.to(roomId).emit('system', { text: `System: ${name || 'Guest'} has joined the chat` });
     broadcastMembers(roomId);
   });
 
   socket.on('rename', ({ roomId, newName }) => {
     const room = rooms.get(roomId);
     if (!room) return;
-    if (room.users.has(socket.id)) {
-      room.users.set(socket.id, { name: String(newName || 'Guest').slice(0, 40) });
-      broadcastMembers(roomId);
-    }
+    const u = room.users.get(socket.id);
+    if (!u) return;
+    u.name = String(newName || 'Guest').slice(0, 40);
+    broadcastMembers(roomId);
   });
 
   socket.on('chat_message', ({ roomId, name, text }) => {
+    const room = rooms.get(roomId);
+    if (!room) return;
+    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;
+    }
     socket.to(roomId).emit('chat_message', { name, text, at: Date.now() });
   });
 
+  // User /play request -> notify host/cohosts and room
+  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);
+      }
+    }
+    io.to(roomId).emit('system', { text: `System: ${requester} requested /play ${query}` });
+  });
+
+  // Host handles request action
+  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' && track) {
+      room.track = {
+        url: track.url,
+        title: track.title || track.url,
+        meta: track.meta || {},
+        kind: track.kind || 'audio',
+        thumb: track.thumb || normalizeThumb(track.meta || {})
+      };
+      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 if (action === 'queue' && track) {
+      room.queue.push({
+        url: track.url,
+        title: track.title || track.url,
+        meta: track.meta || {},
+        kind: track.kind || 'audio',
+        thumb: track.thumb || normalizeThumb(track.meta || {})
+      });
+      io.to(roomId).emit('queue_update', { queue: room.queue });
+      io.to(roomId).emit('system', { text: `System: Queued ${track.title || track.url}` });
+    }
+  });
+
+  // Host controls
   socket.on('set_track', ({ roomId, track }) => {
     const room = rooms.get(roomId);
-    if (!room || socket.id !== room.hostId) return;
-    room.track = track;
+    if (!room || !requireHostOrCohost(room, socket.id)) return;
+    const thumb = track.thumb || normalizeThumb(track.meta || {});
+    room.track = { ...track, thumb };
     room.isPlaying = false;
     room.anchor = 0;
     room.anchorAt = Date.now();
-    io.to(roomId).emit('set_track', { track });
+    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: Selected ${room.track.title || room.track.url}` });
   });
 
   socket.on('play', ({ roomId }) => {
     const room = rooms.get(roomId);
-    if (!room || socket.id !== room.hostId) return;
+    if (!room || !requireHostOrCohost(room, socket.id)) return;
     room.isPlaying = true;
     room.anchorAt = Date.now();
     io.to(roomId).emit('play', { anchor: room.anchor, anchorAt: room.anchorAt });
@@ -200,7 +317,7 @@ io.on('connection', (socket) => {
 
   socket.on('pause', ({ roomId }) => {
     const room = rooms.get(roomId);
-    if (!room || socket.id !== room.hostId) return;
+    if (!room || !requireHostOrCohost(room, socket.id)) return;
     const elapsed = Math.max(0, Date.now() - room.anchorAt) / 1000;
     if (room.isPlaying) room.anchor += elapsed;
     room.isPlaying = false;
@@ -210,12 +327,69 @@ io.on('connection', (socket) => {
 
   socket.on('seek', ({ roomId, to }) => {
     const room = rooms.get(roomId);
-    if (!room || socket.id !== room.hostId) return;
+    if (!room || !requireHostOrCohost(room, socket.id)) return;
     room.anchor = to;
     room.anchorAt = Date.now();
     io.to(roomId).emit('seek', { anchor: room.anchor, anchorAt: room.anchorAt, isPlaying: room.isPlaying });
   });
 
+  // Ended -> auto next from queue
+  socket.on('ended', ({ roomId }) => {
+    const room = rooms.get(roomId);
+    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.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('queue_update', { queue: room.queue });
+      io.to(roomId).emit('system', { text: `System: Now playing ${room.track.title || room.track.url}` });
+    } else {
+      io.to(roomId).emit('system', { text: 'System: Queue ended' });
+    }
+  });
+
+  // Admin commands
+  socket.on('admin_command', ({ roomId, cmd, targetName }) => {
+    const room = rooms.get(roomId);
+    if (!room) return;
+    const actor = room.users.get(socket.id);
+    if (!actor || !(socket.id === room.hostId || actor.role === 'cohost')) return;
+
+    let targetEntry = null;
+    for (const [id, u] of room.users.entries()) {
+      if (u.name && u.name.toLowerCase() === targetName.toLowerCase()) {
+        targetEntry = { id, u };
+        break;
+      }
+    }
+    if (!targetEntry) {
+      io.to(socket.id).emit('system', { text: `System: User @${targetName} not found` });
+      return;
+    }
+
+    if (cmd === 'kick') {
+      const { id } = targetEntry;
+      io.to(id).emit('system', { text: 'System: You were kicked by the host' });
+      io.sockets.sockets.get(id)?.leave(roomId);
+      room.users.delete(id);
+      io.to(roomId).emit('system', { text: `System: ${targetEntry.u.name} was kicked` });
+      broadcastMembers(roomId);
+    } else if (cmd === 'promote') {
+      targetEntry.u.role = 'cohost';
+      io.to(roomId).emit('system', { text: `System: ${targetEntry.u.name} was promoted to co-host` });
+      broadcastMembers(roomId);
+    } else if (cmd === 'mute') {
+      targetEntry.u.muted = true;
+      io.to(roomId).emit('system', { text: `System: ${targetEntry.u.name} was muted` });
+      broadcastMembers(roomId);
+    }
+  });
+
   socket.on('sync_request', ({ roomId }, ack) => {
     const room = rooms.get(roomId);
     if (!room) return;
@@ -226,12 +400,20 @@ io.on('connection', (socket) => {
     if (!joinedRoom) return;
     const room = rooms.get(joinedRoom);
     if (!room) return;
+    const leftUser = room.users.get(socket.id);
     room.users.delete(socket.id);
     if (socket.id === room.hostId) {
       const nextHost = [...room.users.keys()][0];
       room.hostId = nextHost || null;
+      if (room.hostId) {
+        const u = room.users.get(room.hostId);
+        if (u) u.role = 'host';
+      }
       io.to(joinedRoom).emit('host_changed', { hostId: room.hostId });
     }
+    if (leftUser) {
+      io.to(joinedRoom).emit('system', { text: `System: ${leftUser.name || 'User'} has left the chat` });
+    }
     if (room.users.size === 0) {
       rooms.delete(joinedRoom);
     } else {