Update server/server.js

server/server.js

@@ -4,8 +4,13 @@ import cors from 'cors';
 import { Server as SocketIOServer } from 'socket.io';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import axios from 'axios';
-import { searchSongs, resolveStreamUrl } from './jiosaavn.js';
+import {
+  searchUniversal,
+  getSong,
+  getAlbum,
+  getPlaylist,
+  getLyrics
+} from './jiosaavn.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -14,28 +19,22 @@ const app = express();
 app.use(cors());
 app.use(express.json());
 
-// In-memory rooms: swap to Redis for production
+// Health check for Hugging Face Spaces
+app.get('/', (req, res) => {
+  res.send('OK');
+});
+
+// In-memory rooms
+// room = { id, name, hostId, users: Map<socketId, {name}>, track, isPlaying, anchor, anchorAt }
 const rooms = new Map();
-/*
-room = {
-  id,
-  hostId,
-  users: Set<socketId>,
-  track: { url, title, meta },
-  isPlaying: false,
-  // hostTime bookkeeping:
-  // 'anchor' is the playback position at 'anchorAt' (ms, Date.now())
-  anchor: 0,
-  anchorAt: 0
-}
-*/
 
 function ensureRoom(roomId) {
   if (!rooms.has(roomId)) {
     rooms.set(roomId, {
       id: roomId,
+      name: null,
       hostId: null,
-      users: new Set(),
+      users: new Map(),
       track: null,
       isPlaying: false,
       anchor: 0,
@@ -45,18 +44,90 @@ function ensureRoom(roomId) {
   return rooms.get(roomId);
 }
 
-// Search proxy to avoid CORS issues on client
-app.get('/api/search', async (req, res) => {
+function broadcastMembers(roomId) {
+  const room = rooms.get(roomId);
+  if (!room) return;
+  const members = [...room.users.entries()].map(([id, u]) => ({
+    id,
+    name: u.name || 'Guest',
+    isHost: id === room.hostId
+  }));
+  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
+  };
+}
+
+// ---------- JioSaavn proxy endpoints ----------
+app.get('/api/result', async (req, res) => {
+  try {
+    const q = req.query.q || '';
+    const data = await searchUniversal(q);
+    res.json(data);
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+app.get('/api/song', async (req, res) => {
+  try {
+    const q = req.query.q || '';
+    const data = await getSong(q);
+    res.json(data);
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+app.get('/api/album', async (req, res) => {
   try {
     const q = req.query.q || '';
-    const results = await searchSongs(q);
-    res.json(results);
+    const data = await getAlbum(q);
+    res.json(data);
   } catch (e) {
     res.status(500).json({ error: e.message });
   }
 });
 
-// Optional: direct URL validation/proxy header check
+app.get('/api/playlist', async (req, res) => {
+  try {
+    const q = req.query.q || '';
+    const data = await getPlaylist(q);
+    res.json(data);
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+app.get('/api/lyrics', async (req, res) => {
+  try {
+    const q = req.query.q || '';
+    const data = await getLyrics(q);
+    res.json(data);
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Active rooms (lobby list)
+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 });
+});
+
 app.get('/api/ping', (req, res) => res.json({ ok: true }));
 
 // Serve frontend build
@@ -74,29 +145,37 @@ const io = new SocketIOServer(server, {
 io.on('connection', (socket) => {
   let joinedRoom = null;
 
-  socket.on('join_room', ({ roomId, name, asHost = false }, ack) => {
+  socket.on('join_room', ({ roomId, name, asHost = false, roomName = null }, ack) => {
     const room = ensureRoom(roomId);
-    room.users.add(socket.id);
+    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;
 
     socket.join(roomId);
     joinedRoom = roomId;
 
-    // Acknowledge with current state
     ack?.({
       roomId,
       isHost: socket.id === room.hostId,
-      state: {
-        track: room.track,
-        isPlaying: room.isPlaying,
-        anchor: room.anchor,
-        anchorAt: room.anchorAt
-      }
+      state: currentState(room),
+      roomName: room.name || room.id
     });
 
     socket.to(roomId).emit('system', { type: 'join', name, id: socket.id });
+    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);
+    }
+  });
+
+  // Chat
   socket.on('chat_message', ({ roomId, name, text }) => {
     socket.to(roomId).emit('chat_message', { name, text, at: Date.now() });
   });
@@ -116,16 +195,14 @@ io.on('connection', (socket) => {
   socket.on('play', ({ roomId }) => {
     const room = rooms.get(roomId);
     if (!room || socket.id !== room.hostId) return;
-    // Start from current anchor
     room.isPlaying = true;
-    room.anchorAt = Date.now(); // resume ticking
+    room.anchorAt = Date.now();
     io.to(roomId).emit('play', { anchor: room.anchor, anchorAt: room.anchorAt });
   });
 
   socket.on('pause', ({ roomId }) => {
     const room = rooms.get(roomId);
     if (!room || socket.id !== room.hostId) return;
-    // Freeze anchor at current logical time
     const elapsed = Math.max(0, Date.now() - room.anchorAt) / 1000;
     if (room.isPlaying) room.anchor += elapsed;
     room.isPlaying = false;
@@ -144,12 +221,7 @@ io.on('connection', (socket) => {
   socket.on('sync_request', ({ roomId }, ack) => {
     const room = rooms.get(roomId);
     if (!room) return;
-    ack?.({
-      track: room.track,
-      isPlaying: room.isPlaying,
-      anchor: room.anchor,
-      anchorAt: room.anchorAt
-    });
+    ack?.(currentState(room));
   });
 
   socket.on('disconnect', () => {
@@ -158,12 +230,15 @@ io.on('connection', (socket) => {
     if (!room) return;
     room.users.delete(socket.id);
     if (socket.id === room.hostId) {
-      // Promote next user as host if available
-      const [nextHost] = room.users;
+      const nextHost = [...room.users.keys()][0];
       room.hostId = nextHost || null;
       io.to(joinedRoom).emit('host_changed', { hostId: room.hostId });
     }
-    if (room.users.size === 0) rooms.delete(joinedRoom);
+    if (room.users.size === 0) {
+      rooms.delete(joinedRoom);
+    } else {
+      broadcastMembers(joinedRoom);
+    }
   });
 });