Update server/server.js

server/server.js

@@ -1,66 +1,173 @@
-const path = require('path');
-const http = require('http');
-const express = require('express');
-const WebSocket = require('ws');
+import express from 'express';
+import http from 'http';
+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';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 const app = express();
-const PORT = process.env.PORT || 7860;
+app.use(cors());
+app.use(express.json());
+
+// In-memory rooms: swap to Redis for production
+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,
+      hostId: null,
+      users: new Set(),
+      track: null,
+      isPlaying: false,
+      anchor: 0,
+      anchorAt: 0
+    });
+  }
+  return rooms.get(roomId);
+}
 
-// Serve static frontend
-const staticPath = path.join(__dirname, '..', 'app');
-app.use(express.static(staticPath));
+// Search proxy to avoid CORS issues on client
+app.get('/api/search', async (req, res) => {
+  try {
+    const q = req.query.q || '';
+    const results = await searchSongs(q);
+    res.json(results);
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Optional: direct URL validation/proxy header check
+app.get('/api/ping', (req, res) => res.json({ ok: true }));
 
-// Fallback to index.html for SPA behavior
-app.get('*', (req, res) => {
-  res.sendFile(path.join(staticPath, 'index.html'));
+// 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'));
 });
 
 const server = http.createServer(app);
-const wss = new WebSocket.Server({ server });
+const io = new SocketIOServer(server, {
+  cors: { origin: '*', methods: ['GET', 'POST'] }
+});
 
-console.log(`WebSocket + HTTP server starting on port ${PORT}`);
+io.on('connection', (socket) => {
+  let joinedRoom = null;
 
-// rooms: { roomId: Set<WebSocket> }
-const rooms = {};
+  socket.on('join_room', ({ roomId, name, asHost = false }, ack) => {
+    const room = ensureRoom(roomId);
+    room.users.add(socket.id);
+    if (asHost || !room.hostId) room.hostId = socket.id;
 
-wss.on('connection', (socket) => {
-  console.log('New WS connection');
+    socket.join(roomId);
+    joinedRoom = roomId;
 
-  socket.on('message', (raw) => {
-    let data;
-    try {
-      data = JSON.parse(raw);
-    } catch (e) {
-      console.warn('Invalid JSON received:', raw);
-      return;
-    }
+    // Acknowledge with current state
+    ack?.({
+      roomId,
+      isHost: socket.id === room.hostId,
+      state: {
+        track: room.track,
+        isPlaying: room.isPlaying,
+        anchor: room.anchor,
+        anchorAt: room.anchorAt
+      }
+    });
 
-    if (data.type === 'join') {
-      socket.roomId = data.room;
-      rooms[data.room] = rooms[data.room] || new Set();
-      rooms[data.room].add(socket);
-      console.log(`Client joined room: ${data.room}`);
-    }
+    socket.to(roomId).emit('system', { type: 'join', name, id: socket.id });
+  });
 
-    if (data.type === 'sync') {
-      const roomSet = rooms[socket.roomId] || new Set();
-      roomSet.forEach((client) => {
-        if (client !== socket && client.readyState === WebSocket.OPEN) {
-          client.send(JSON.stringify(data));
-        }
-      });
-    }
+  socket.on('chat_message', ({ roomId, name, text }) => {
+    socket.to(roomId).emit('chat_message', { name, text, at: Date.now() });
   });
 
-  socket.on('close', () => {
-    if (socket.roomId && rooms[socket.roomId]) {
-      rooms[socket.roomId].delete(socket);
-      if (rooms[socket.roomId].size === 0) delete rooms[socket.roomId];
+  // Host control events
+  socket.on('set_track', ({ roomId, track }) => {
+    const room = rooms.get(roomId);
+    if (!room || socket.id !== room.hostId) return;
+    room.track = track;
+    room.isPlaying = false;
+    room.anchor = 0;
+    room.anchorAt = Date.now();
+    io.to(roomId).emit('set_track', { track });
+    io.to(roomId).emit('pause', { anchor: 0, anchorAt: room.anchorAt });
+  });
+
+  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
+    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;
+    room.anchorAt = Date.now();
+    io.to(roomId).emit('pause', { anchor: room.anchor, anchorAt: room.anchorAt });
+  });
+
+  socket.on('seek', ({ roomId, to }) => {
+    const room = rooms.get(roomId);
+    if (!room || socket.id !== room.hostId) return;
+    room.anchor = to;
+    room.anchorAt = Date.now();
+    io.to(roomId).emit('seek', { anchor: room.anchor, anchorAt: room.anchorAt, isPlaying: room.isPlaying });
+  });
+
+  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
+    });
+  });
+
+  socket.on('disconnect', () => {
+    if (!joinedRoom) return;
+    const room = rooms.get(joinedRoom);
+    if (!room) return;
+    room.users.delete(socket.id);
+    if (socket.id === room.hostId) {
+      // Promote next user as host if available
+      const [nextHost] = room.users;
+      room.hostId = nextHost || null;
+      io.to(joinedRoom).emit('host_changed', { hostId: room.hostId });
     }
-    console.log('WS connection closed');
+    if (room.users.size === 0) rooms.delete(joinedRoom);
   });
 });
 
-server.listen(PORT, '0.0.0.0', () => {
-  console.log(`HTTP + WebSocket server listening on port ${PORT}`);
-});
+const PORT = process.env.PORT || 3000;
+server.listen(PORT, () => {
+  console.log(`Server on :${PORT}`);
+});