Upload 3 files

Dockerfile

@@ -0,0 +1,7 @@
+FROM node:22-slim
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY . .
+EXPOSE 7860
+CMD ["node", "server.js"]

package.json

@@ -0,0 +1,28 @@
+{
+  "name": "vibelyy",
+  "version": "1.0.0",
+  "description": "random video chats with real peoples",
+  "keywords": [
+    "omegle",
+    "video",
+    "chat",
+    "vibe",
+    "random",
+    "people",
+    "dating"
+  ],
+  "license": "ISC",
+  "author": "Rohan Shaw",
+  "type": "commonjs",
+  "main": "server.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node server.js"
+  },
+  "dependencies": {
+    "axios": "^1.11.0",
+    "express": "^5.1.0",
+    "mongodb": "^6.18.0",
+    "socket.io": "^4.8.1"
+  }
+}

server.js

@@ -0,0 +1,260 @@
+const express = require('express');
+const http = require('http');
+const { Server } = require('socket.io');
+const { MongoClient, ObjectId } = require('mongodb');
+const axios = require('axios');
+
+const PORT = process.env.PORT || 7860;
+const MONGO_URI = process.env.MONGO_URI || '';
+const MONGO_DBNAME = process.env.MONGO_DBNAME || 'vibelyy';
+
+async function main() {
+  // MongoDB client
+  const mongoClient = new MongoClient(MONGO_URI, { useUnifiedTopology: true });
+  await mongoClient.connect();
+  const db = mongoClient.db(MONGO_DBNAME);
+  const blockedColl = db.collection('blocked'); // { blockerId, blockedId, at }
+  const sessionsColl = db.collection('sessions'); // { peerA, peerB, startTime, endTime, locationA, locationB }
+
+  const app = express();
+  const server = http.createServer(app);
+  const io = new Server(server, { cors: { origin: '*' } });
+
+  // In-memory waiting list of lightweight objects:
+  // { id, nickname, gender, blockedIds: [], location, socket }
+  let waitingUsers = [];
+
+  app.get('/health', (req, res) => res.send('ok'));
+
+  // Helper: fetch approx location for an IP (returns "City, Country")
+  async function getLocationForIp(ip) {
+    try {
+      // ipapi.co has no auth for basic lookup
+      const res = await axios.get(`https://ipapi.co/${ip}/json/`, { timeout: 4000 });
+      const city = res.data.city || null;
+      const country = res.data.country_name || res.data.country || null;
+      if (city && country) return `${city}, ${country}`;
+      if (country) return country;
+      return 'Unknown';
+    } catch (e) {
+      return 'Unknown';
+    }
+  }
+
+  // Find a match index in waitingUsers per preference: try opposite gender first
+  function findMatchIndex(newUser) {
+    // skip users that blocked newUser or are blocked by newUser
+    const blockedSet = new Set((newUser.blockedIds || []).map(String));
+    // 1) try opposite gender
+    let idx = waitingUsers.findIndex(u =>
+      u.id !== newUser.id &&
+      !blockedSet.has(String(u.id)) &&
+      !((u.blockedIds || []).map(String).includes(String(newUser.id))) &&
+      u.gender && newUser.gender && u.gender !== newUser.gender
+    );
+    if (idx !== -1) return idx;
+    // 2) fallback: any compatible user
+    idx = waitingUsers.findIndex(u =>
+      u.id !== newUser.id &&
+      !blockedSet.has(String(u.id)) &&
+      !((u.blockedIds || []).map(String).includes(String(newUser.id)))
+    );
+    return idx;
+  }
+
+  io.on('connection', (socket) => {
+    console.log('ws connect', socket.id);
+
+    // Data on this socket: socket.meta = { nickname, gender, blockedIds, location, peerId, sessionId }
+    socket.meta = {};
+
+    // Text chat messages
+    socket.on('message', ({ to, text, id } = {}) => {
+      if (!to || !text) return;
+      // Forward to peer (include id for receipts)
+      io.to(to).emit('message', { from: socket.id, text, id });
+      // Acknowledge delivery to sender
+      if (id) socket.emit('delivered', id);
+    });
+
+    socket.on('seen', ({ to, id } = {}) => {
+      if (!to || !id) return;
+      io.to(to).emit('seen', id);
+    });
+
+    socket.on('join', async (payload = {}) => {
+      // payload: { nickname, gender, blockedIds }
+      const nickname = (payload.nickname || 'Anon').slice(0, 64);
+      const gender = payload.gender || '';
+      const blockedIds = Array.isArray(payload.blockedIds) ? payload.blockedIds.map(String) : [];
+
+      // Attempt to get client IP (respect X-Forwarded-For if present)
+      // let ip = socket.handshake.headers['x-forwarded-for'] || socket.handshake.address || '';
+      // if (typeof ip === 'string' && ip.includes(',')) ip = ip.split(',')[0].trim();
+
+      const ip = payload.ip || socket.handshake.address || '';
+
+      console.log('join', socket.id, nickname, gender, blockedIds, ip);
+
+      const location = await getLocationForIp(ip);
+
+      // set meta
+      socket.meta = { nickname, gender, blockedIds, location, peerId: null, sessionId: null };
+
+      // Build newUser object
+      const newUser = { id: socket.id, nickname, gender, blockedIds, location, socket };
+
+      // Try to find match
+      const idx = findMatchIndex(newUser);
+      if (idx === -1) {
+        // push to waiting
+        waitingUsers.push(newUser);
+        socket.emit('waiting');
+        console.log('waitingUsers add', socket.id);
+        return;
+      }
+
+      // Pop matched user
+      const peer = waitingUsers.splice(idx, 1)[0];
+
+      // mark each other's peerId
+      socket.meta.peerId = peer.id;
+      peer.socket.meta.peerId = socket.id;
+
+      // Create session doc in DB
+      const sessionDoc = {
+        peerA: socket.id,
+        peerB: peer.id,
+        nicknameA: socket.meta.nickname,
+        nicknameB: peer.nickname,
+        startTime: new Date(),
+        endTime: null,
+        locationA: socket.meta.location,
+        locationB: peer.location
+      };
+      const r = await sessionsColl.insertOne(sessionDoc);
+      const sessionId = r.insertedId.toString();
+      socket.meta.sessionId = sessionId;
+      peer.socket.meta.sessionId = sessionId;
+
+      // Inform both peers (include profile info and location)
+      socket.emit('paired', { id: peer.id, nickname: peer.nickname, location: peer.location, sessionId });
+      peer.socket.emit('paired', { id: socket.id, nickname: socket.meta.nickname, location: socket.meta.location, sessionId });
+
+      // Set up session auto-end timer (30 minutes)
+      const END_MS = 30 * 60 * 1000;
+      setTimeout(async () => {
+        try {
+          // Double-check that session still exists and both sockets still connected and sessionId matches
+          if (socket.meta.sessionId === sessionId) {
+            // Notify both
+            socket.emit('session_end', { reason: 'time_limit' });
+          }
+          if (peer.socket && peer.socket.meta.sessionId === sessionId) {
+            peer.socket.emit('session_end', { reason: 'time_limit' });
+          }
+          // Update DB endTime
+          await sessionsColl.updateOne({ _id: new ObjectId(sessionId) }, { $set: { endTime: new Date() } });
+        } catch (e) {
+          console.warn('session end error', e);
+        }
+      }, END_MS);
+
+      console.log('paired', socket.id, '↔', peer.id);
+    }); // join
+
+    // Signaling messages: forward to `to`
+    socket.on('signal', ({ to, data } = {}) => {
+      if (!to || !data) return;
+      io.to(to).emit('signal', { from: socket.id, data });
+    });
+
+    // Typing indicator
+    socket.on('typing', (to) => {
+      if (!to) return;
+      io.to(to).emit('typing');
+    });
+
+    // Report: store minimal info in sessions collection as a report array (optional)
+    socket.on('report', async ({ peerId, reason } = {}) => {
+      try {
+        const doc = { reporter: socket.id, peerId: peerId || null, reason: reason || null, time: new Date() };
+        // Append to a `reports` array in sessions if session exists; else insert into `reports` collection
+        if (socket.meta && socket.meta.sessionId) {
+          await sessionsColl.updateOne({ _id: new ObjectId(socket.meta.sessionId) }, { $push: { reports: doc } });
+        } else {
+          await db.collection('reports').insertOne(doc);
+        }
+        console.log('report saved', doc);
+      } catch (e) {
+        console.warn('report save failed', e);
+      }
+    });
+
+    // Block a peer: persist blocked relationship
+    socket.on('block', async (blockedPeerId) => {
+      if (!blockedPeerId) return;
+      try {
+        await blockedColl.insertOne({ blockerId: socket.id, blockedId: String(blockedPeerId), at: new Date() });
+        // Also update in-memory meta so matchmaking uses it if the client remains connected
+        socket.meta.blockedIds = Array.from(new Set([...(socket.meta.blockedIds || []), String(blockedPeerId)]));
+        console.log(`${socket.id} blocked ${blockedPeerId}`);
+      } catch (e) {
+        console.warn('block save failed', e);
+      }
+    });
+
+    // Leave current chat and try to rejoin (or just leave)
+    socket.on('leave', async () => {
+      try {
+        const peerId = socket.meta.peerId;
+        if (peerId) {
+          // notify peer
+          io.to(peerId).emit('peer_left');
+          // close session in DB
+          if (socket.meta.sessionId) {
+            await sessionsColl.updateOne({ _id: new ObjectId(socket.meta.sessionId) }, { $set: { endTime: new Date() } });
+            // clear session ids
+            const sessId = socket.meta.sessionId;
+            // clear session meta for both sides if connected
+            socket.meta.sessionId = null;
+            socket.meta.peerId = null;
+            const s = io.sockets.sockets.get(peerId);
+            if (s && s.meta) { s.meta.sessionId = null; s.meta.peerId = null; }
+          }
+        } else {
+          // If user was waiting, remove from waiting list
+          waitingUsers = waitingUsers.filter(u => u.id !== socket.id);
+        }
+      } catch (e) {
+        console.warn('leave error', e);
+      }
+    });
+
+    socket.on('disconnect', async (reason) => {
+      console.log('disconnect', socket.id, reason);
+      // If user was in waitingUsers remove them
+      waitingUsers = waitingUsers.filter(u => u.id !== socket.id);
+
+      // If in a session, notify peer and update DB endTime
+      if (socket.meta && socket.meta.peerId) {
+        io.to(socket.meta.peerId).emit('peer_left');
+      }
+      if (socket.meta && socket.meta.sessionId) {
+        try {
+          await sessionsColl.updateOne({ _id: new ObjectId(socket.meta.sessionId) }, { $set: { endTime: new Date() } });
+        } catch (e) {
+          console.warn('session end on disconnect failed', e);
+        }
+      }
+    });
+
+  }); // io.on(connection)
+
+  server.listen(PORT, () => console.log(`Vibelyy backend listening on ${PORT}`));
+}
+
+main().catch(err => {
+  console.error('Fatal server error', err);
+  process.exit(1);
+});