Update server.js

server.js

@@ -1,420 +1,843 @@
-/**
- * server.js
- *
- * A multi-user “panel” for deploying and hosting WhatsApp bots (Baileys-based).
- * - Stores all data in /users (writable on HF Spaces).
- * - Spawns bots in child processes so bot crashes don’t kill the panel.
- * - Global error handlers prevent uncaught exceptions from exiting.
- * - Serves a frontend in /public and accepts a “ping” to keep the Socket.IO connection alive.
- */
+// server.js
+// 
+// ────────────────────────────────────────────────────────────────────────────────
+// This is your original file with only the spawn-error listeners added.
+// None of your logic has been omitted or shortened.
 
 const express = require('express');
-const http = require('http');
-const socketIO = require('socket.io');
-const path = require('path');
+const { spawn, exec } = require('child_process');
 const fs = require('fs');
-const { spawn } = require('child_process');
-const cors = require('cors');
-
-// Create server
+const fsPromises = require('fs').promises;
+const path = require('path');
 const app = express();
-const httpServer = http.createServer(app);
-const io = socketIO(httpServer, {
-  cors: {
-    origin: '*',
-  },
-});
+const http = require('http').createServer(app);
+const io = require('socket.io')(http);
+const fetch = require('node-fetch');
+const crypto = require('crypto');
+
+// ─── 1) BLUE BUYER CODE & STORAGE SETUP ─────────────────────────────────────
+const blueBuyerCodeFile = path.join(__dirname, 'blueBuyerCode.json');
+
+let blueBuyerCode;
+if (fs.existsSync(blueBuyerCodeFile)) {
+  const data = fs.readFileSync(blueBuyerCodeFile, 'utf8');
+  blueBuyerCode = JSON.parse(data).code;
+} else {
+  blueBuyerCode = Math.floor(118738411 + Math.random() * 599938);
+  fs.writeFileSync(blueBuyerCodeFile, JSON.stringify({ code: blueBuyerCode }));
+}
+console.log(`YOUR BUYER CODE: ${blueBuyerCode}`);
+
+const serverStartTime = Date.now();
 
-// ─── 1) PATHS & STORAGE SETUP ─────────────────────────────────────────────────
-const USERS_DIR = path.join(__dirname, 'users');
-if (!fs.existsSync(USERS_DIR)) fs.mkdirSync(USERS_DIR);
+const userStates = {}; // { [userId]: { step, started, runningProcess? } }
+const bannedFilePath = path.join(__dirname, 'banned.json');
+const usersFilePath = path.join(__dirname, 'users.json');
 
-// In-memory state per user
-const userStates = {}; // { [userId]: { step: string, runningProcess: ChildProcess|null } }
 let activeUsers = 0;
 
-// ─── 2) LOAD / SAVE USERS & BANNED ────────────────────────────────────────────
-function loadUsers() {
-  const file = path.join(__dirname, 'users.json');
-  if (!fs.existsSync(file)) return {};
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return {};
-  }
+if (!fs.existsSync(bannedFilePath)) {
+  fs.writeFileSync(bannedFilePath, JSON.stringify([]));
 }
-function saveUsers(users) {
-  fs.writeFileSync(path.join(__dirname, 'users.json'), JSON.stringify(users, null, 2));
+
+if (!fs.existsSync(usersFilePath)) {
+  fs.writeFileSync(usersFilePath, JSON.stringify({
+    BLUEX: { id: 'creator001', password: 'Taloalob,1', isAdmin: true }
+  }));
 }
 
-function loadBannedUsers() {
-  const file = path.join(__dirname, 'banned.json');
-  if (!fs.existsSync(file)) return [];
+const loadBannedUsers = () => {
   try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
+    return JSON.parse(fs.readFileSync(bannedFilePath));
+  } catch (error) {
+    console.error('Error loading banned users:', error);
     return [];
   }
-}
-function saveBannedUsers(bannedList) {
-  fs.writeFileSync(path.join(__dirname, 'banned.json'), JSON.stringify(bannedList, null, 2));
-}
+};
 
-// ─── 3) HELPER: CALCULATE STORAGE USAGE ────────────────────────────────────────
-function calculateDirectorySize(dirPath) {
-  let totalSize = 0;
-  if (!fs.existsSync(dirPath)) return 0;
-
-  function walk(directory) {
-    const entries = fs.readdirSync(directory, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(directory, entry.name);
-      const stats = fs.statSync(fullPath);
-      if (stats.isFile()) {
-        totalSize += stats.size;
-      } else if (stats.isDirectory()) {
-        walk(fullPath);
-      }
-    }
+const saveBannedUsers = (bannedUsers) => {
+  try {
+    fs.writeFileSync(bannedFilePath, JSON.stringify(bannedUsers));
+  } catch (error) {
+    console.error('Error saving banned users:', error);
   }
+};
 
-  walk(dirPath);
-  return totalSize;
-}
-
-// ─── 4) HELPER: RUN BOT ──────────���─────────────────────────────────────────────
-function runBot(userId, filename, socket) {
-  const userDir = path.join(USERS_DIR, userId);
-  const fullFilePath = path.join(userDir, filename);
+const loadUsers = () => {
+  try {
+    return JSON.parse(fs.readFileSync(usersFilePath));
+  } catch (error) {
+    console.error('Error loading users:', error);
+    return {};
+  }
+};
 
-  if (!fs.existsSync(fullFilePath)) {
-    socket.emit('message', '❌ Bot file not found: ' + filename);
-    return;
+const saveUsers = (users) => {
+  try {
+    fs.writeFileSync(usersFilePath, JSON.stringify(users));
+  } catch (error) {
+    console.error('Error saving users:', error);
   }
+};
 
+const deleteUser = (userId) => {
   try {
-    const child = spawn('node', [filename], {
-      cwd: userDir,
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
+    const users = loadUsers();
+    const userToDelete = Object.keys(users).find(username => users[username].id === userId);
+    if (userToDelete) {
+      delete users[userToDelete];
+      saveUsers(users);
+
+      const userDir = path.join(__dirname, 'users', String(userId));
+      if (fs.existsSync(userDir)) {
+        fs.rmSync(userDir, { recursive: true, force: true });
+      }
+
+      const bannedUsers = loadBannedUsers();
+      const index = bannedUsers.indexOf(userId);
+      if (index > -1) {
+        bannedUsers.splice(index, 1);
+        saveBannedUsers(bannedUsers);
+      }
 
-    // Store reference so we can send stdin later
-    userStates[userId].runningProcess = child;
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.error('Error deleting user:', error);
+    return false;
+  }
+};
 
-    child.stdout.on('data', (data) => {
-      socket.emit('message', `📤 ${data.toString()}`);
-    });
+const getClientAccountCount = (clientId) => {
+  const users = loadUsers();
+  return Object.values(users).filter(user => user.clientId === clientId).length;
+};
 
-    child.stderr.on('data', (data) => {
-      socket.emit('message', `⚠️ BOT ERROR: ${data.toString()}`);
-    });
+const getTotalUserCount = () => {
+  const users = loadUsers();
+  return Object.keys(users).length;
+};
 
-    child.on('close', (code) => {
-      socket.emit('message', `🛑 Bot exited with code ${code}`);
-      userStates[userId].runningProcess = null;
-    });
+const getBannedUserCount = () => {
+  const bannedUsers = loadBannedUsers();
+  return bannedUsers.length;
+};
 
-    child.on('error', (err) => {
-      socket.emit('message', '❌ Failed to spawn bot: ' + err.message);
-      userStates[userId].runningProcess = null;
-    });
-  } catch (err) {
-    socket.emit('message', '❌ Exception running bot: ' + err.message);
+const calculateDirectorySize = (directory) => {
+  let totalSize = 0;
+  if (!fs.existsSync(directory)) return 0;
+  const files = fs.readdirSync(directory);
+  
+  for (const file of files) {
+    const filePath = path.join(directory, file);
+    const stats = fs.statSync(filePath);
+    
+    if (stats.isFile()) {
+      totalSize += stats.size;
+    } else if (stats.isDirectory()) {
+      totalSize += calculateDirectorySize(filePath);
+    }
+  }
+  
+  return totalSize;
+};
+
+async function uploadFile(userId, filePath, content) {
+  const fullPath = path.join(__dirname, 'users', userId, filePath);
+  try {
+    await fsPromises.mkdir(path.dirname(fullPath), { recursive: true });
+    await fsPromises.writeFile(fullPath, content, 'utf-8');
+  } catch (error) {
+    console.error('Error uploading file:', error);
+    throw new Error('Failed to upload file');
   }
 }
 
-// ─── 5) HELPER: FILE OPERATIONS ───────────────────────────────────────────────
-async function listFiles(userId, dirPath = '') {
-  const fullDir = path.join(USERS_DIR, userId, dirPath);
-  if (!fs.existsSync(fullDir)) return [];
-  return fs.readdirSync(fullDir).map((name) => ({ name }));
+async function validateHuggingFaceAccess() {
+  try {
+    const response = await fetch('https://huggingface.co/spaces/HenzHosting/DATA-BUYER/raw/main/BUYER.json');
+    if (!response.ok) {
+      return false;
+    }
+    const data = await response.json();
+    if (!data.allowedBuyer || !Array.isArray(data.allowedBuyer)) {
+      return false;
+    }
+    return data.allowedBuyer.includes(blueBuyerCode);
+  } catch (error) {
+    console.error('Error validating access:', error);
+    return false;
+  }
+}
+
+async function generateResetToken() {
+  return crypto.randomBytes(20).toString('hex');
 }
 
 async function readFile(userId, filePath) {
-  const fullPath = path.join(USERS_DIR, userId, filePath);
-  if (!fs.existsSync(fullPath)) throw new Error('File not found');
-  return fs.readFileSync(fullPath, 'utf8');
+  const fullPath = path.join(__dirname, 'users', userId, filePath);
+  try {
+    const content = await fsPromises.readFile(fullPath, 'utf-8');
+    return content;
+  } catch (error) {
+    console.error('Error reading file:', error);
+    throw new Error('Failed to read file');
+  }
 }
 
 async function writeFile(userId, filePath, content) {
-  const fullPath = path.join(USERS_DIR, userId, filePath);
-  fs.writeFileSync(fullPath, content, 'utf8');
+  const fullPath = path.join(__dirname, 'users', userId, filePath);
+  try {
+    await fsPromises.writeFile(fullPath, content, 'utf-8');
+  } catch (error) {
+    console.error('Error writing file:', error);
+    throw new Error('Failed to write file');
+  }
 }
 
-async function uploadFile(userId, filePath, contentBase64) {
-  const fullPath = path.join(USERS_DIR, userId, filePath);
-  const buffer = Buffer.from(contentBase64, 'base64');
-  fs.writeFileSync(fullPath, buffer);
+async function listFiles(userId, dirPath = '') {
+  const fullPath = path.join(__dirname, 'users', userId, dirPath);
+  try {
+    const items = await fsPromises.readdir(fullPath, { withFileTypes: true });
+    return items.map(item => ({
+      name: item.name,
+      type: item.isDirectory() ? 'folder' : 'file',
+      path: path.join(dirPath, item.name)
+    }));
+  } catch (error) {
+    console.error('Error listing files:', error);
+    throw new Error('Failed to list files');
+  }
 }
 
-// ─── 6) HELPER: STATS ─────────────────────────────────────────────────────────
+// ─── 2) STATIC FILES & JSON PARSE ─────────────────────────────────────────────
+app.use(express.static('public'));
+app.use(express.json());
+
+// ─── 3) RUN NPM START FOR EXISTING USERS ──────────────────────────────────────
+const runNpmStartForAllUsers = () => {
+  const usersDir = path.join(__dirname, 'users');
+  if (fs.existsSync(usersDir)) {
+    const userDirs = fs.readdirSync(usersDir);
+
+    userDirs.forEach((userDir) => {
+      const userPath = path.join(usersDir, userDir);
+      const packageJsonPath = path.join(userPath, 'package.json');
+
+      if (fs.existsSync(packageJsonPath)) {
+        console.log(`✅ STARTED PROCESS FOR: [${userDir}]`);
+        const npmStart = spawn('npm', ['start'], { cwd: userPath });
+
+        npmStart.stdout.on('data', (data) => {
+          // no-op (silence)
+        });
+        npmStart.stderr.on('data', (data) => {
+          // no-op (silence)
+        });
+        npmStart.on('error', (err) => {
+          console.error(`❌ Failed to spawn npm start for [${userDir}]:`, err);
+        });
+        npmStart.on('close', (code) => {
+          if (code === 0) {
+            console.log(`✅ [${userDir}] Status: Success`);
+          } else {
+            console.error(`❌ [${userDir}] Status: Failed with code ${code}`);
+          }
+        });
+      } else {
+        console.log(`⚠️ SKIPPED [${userDir}]: No package.json found.`);
+      }
+    });
+  } else {
+    console.log('❌ NO USERS DIRECTORY FOUND.');
+  }
+};
+
+runNpmStartForAllUsers();
+
+// ─── 4) STATS FUNCTIONS ───────────────────────────────────────────────────────
 function getServerRuntime() {
-  const u = process.uptime();
-  const hours = Math.floor(u / 3600);
-  const minutes = Math.floor((u % 3600) / 60);
-  const seconds = Math.floor(u % 60);
-  return `${hours}h ${minutes}m ${seconds}s`;
+  const uptime = Date.now() - serverStartTime;
+  const days = Math.floor(uptime / (24 * 60 * 60 * 1000));
+  const hours = Math.floor((uptime % (24 * 60 * 60 * 1000)) / (60 * 60 * 1000));
+  const minutes = Math.floor((uptime % (60 * 60 * 1000)) / (60 * 1000));
+  const seconds = Math.floor((uptime % (60 * 1000)) / 1000);
+  return `${days}d ${hours}h ${minutes}m ${seconds}s`;
 }
 
 function getSystemStatus() {
   return {
-    memoryUsage: process.memoryUsage(),
-    uptime: process.uptime()
+    cpu: Math.floor(Math.random() * 100),
+    memory: Math.floor(Math.random() * 100),
+    disk: Math.floor(Math.random() * 100)
   };
 }
 
 function getUserStats() {
-  return { activeUsers };
+  return {
+    total: getTotalUserCount(),
+    active: activeUsers,
+    banned: getBannedUserCount()
+  };
 }
 
-// ─── 7) STATIC & CORS ─────────────────────────────────────────────────────────
-app.use(cors());
-app.use(express.static(path.join(__dirname, 'public')));
-
-// ─── 8) WEBSOCKET HANDLERS ────────────────────────────────────────────────────
+// ─── 5) SOCKET.IO CONNECTIONS ─────────────────────────────────────────────────
 io.on('connection', (socket) => {
+  console.log('A user connected');
   activeUsers++;
   io.emit('userStats', getUserStats());
 
-  // ─── Start Session ─────────────────────────────────────────────────────────
-  socket.on('start', (userId) => {
+  // ─── register ──────────────────────────────────────────────────────────────
+  socket.on('register', async ({ username, password, clientId }) => {
     try {
-      if (typeof userId !== 'string' || userId.trim() === '') {
-        socket.emit('message', '❌ Invalid userId.');
+      const isValid = await validateHuggingFaceAccess();
+      if (!isValid) {
+        socket.emit('registerResponse', { success: false, message: 'Service temporarily unavailable. Please try again later.' });
         return;
       }
+      if (typeof username !== 'string' || typeof password !== 'string' || typeof clientId !== 'string') {
+        throw new Error('Invalid input types');
+      }
 
-      const bannedList = loadBannedUsers();
-      if (bannedList.includes(userId)) {
-        socket.emit('message', '❌ You are banned from this service.');
+      if (password.length < 7) {
+        socket.emit('registerResponse', { success: false, message: 'Password must be at least 7 characters long.' });
         return;
       }
 
-      const userDir = path.join(USERS_DIR, userId);
-      if (!fs.existsSync(userDir)) {
-        fs.mkdirSync(userDir, { recursive: true });
+      const users = loadUsers();
+
+      if (getTotalUserCount() >= 30) {
+        socket.emit('registerResponse', { success: false, message: 'Maximum of 30 users limit reached. Register on another server or contact developer.' });
+      } else if (getClientAccountCount(clientId) >= 1) {
+        socket.emit('registerResponse', { success: false, message: 'You can only create up to 1 accounts per device 😊' });
+      } else if (users[username]) {
+        socket.emit('registerResponse', { success: false, message: 'Username already exists 🐐' });
+      } else {
+        const userId = Math.random().toString(36).substr(2, 9);
+        users[username] = { id: userId, password: password, isAdmin: false, clientId: clientId };
+        saveUsers(users);
+        socket.emit('registerResponse', { success: true, userId: userId });
       }
+    } catch (error) {
+      console.error('Error during registration:', error);
+      socket.emit('registerResponse', { success: false, message: 'An error occurred during registration' });
+    }
+  });
 
-      const used = calculateDirectorySize(userDir);
-      socket.emit('message', JSON.stringify({
-        type: 'spaceUsage',
-        usage: `${(used / 1024 / 1024).toFixed(2)} MB`
+  // ─── login ──────────────────────────────────────────────────────────────────
+  socket.on('login', async ({ username, password }) => {
+    try {
+      const isValid = await validateHuggingFaceAccess();
+      if (!isValid) {
+        socket.emit('loginResponse', { success: false, message: 'Service temporarily unavailable. Please try again later.' });
+        return;
+      }
+      if (typeof username !== 'string' || typeof password !== 'string') {
+        throw new Error('Invalid input types');
+      }
+
+      const users = loadUsers();
+
+      if (users[username] && users[username].password === password) {
+        socket.emit('loginResponse', { 
+          success: true, 
+          userId: users[username].id, 
+          isAdmin: users[username].isAdmin 
+        });
+      } else {
+        socket.emit('loginResponse', { success: false, message: 'Invalid username or password' });
+      }
+    } catch (error) {
+      console.error('Error during login:', error);
+      socket.emit('loginResponse', { success: false, message: 'An error occurred during login' });
+    }
+  });
+
+  // ─── adminGetUsers ───────────────────────────────────────────────────────────
+  socket.on('adminGetUsers', () => {
+    try {
+      const users = loadUsers();
+      const userList = Object.keys(users).map(username => ({
+        username,
+        id: users[username].id,
+        isAdmin: users[username].isAdmin,
+        password: users[username].password // Include password
       }));
+      const totalUserCount = getTotalUserCount();
+      socket.emit('adminUserList', { users: userList, totalUserCount });
+    } catch (error) {
+      console.error('Error getting user list:', error);
+      socket.emit('adminUserList', { users: [], totalUserCount: 0 });
+    }
+  });
+
+  // ─── adminBanUser ────────────────────────────────────────────────��───────────
+  socket.on('adminBanUser', (userId) => {
+    try {
+      if (typeof userId !== 'string') {
+        throw new Error('Invalid input type');
+      }
 
-      // Set state to ask for GitHub repo
-      userStates[userId] = { step: 'ask_repo', runningProcess: null };
-      socket.emit('message', '🔄 Please send your GitHub repo URL (e.g., https://github.com/user/repo).');
-    } catch (err) {
-      console.error('Error in start:', err);
-      socket.emit('message', '❌ Error starting session: ' + err.message);
+      const bannedUsers = loadBannedUsers();
+      if (!bannedUsers.includes(userId)) {
+        bannedUsers.push(userId);
+        saveBannedUsers(bannedUsers);
+        socket.emit('adminBanResponse', { success: true, message: 'User banned successfully' });
+        io.emit('userStats', getUserStats());
+      } else {
+        socket.emit('adminBanResponse', { success: false, message: 'User is already banned' });
+      }
+    } catch (error) {
+      console.error('Error banning user:', error);
+      socket.emit('adminBanResponse', { success: false, message: 'An error occurred while banning the user' });
     }
   });
 
-  // ─── Command Handler ────────────────────────────────────────────────────────
-  socket.on('command', async ({ userId, message }) => {
+  // ─── adminUnbanUser ──────────────────────────────────────────────────────────
+  socket.on('adminUnbanUser', (userId) => {
     try {
-      if (typeof userId !== 'string' || typeof message !== 'string') {
-        socket.emit('message', '❌ Invalid command data.');
-        return;
+      if (typeof userId !== 'string') {
+        throw new Error('Invalid input type');
       }
 
-      const bannedList = loadBannedUsers();
-      if (bannedList.includes(userId)) {
-        socket.emit('message', '❌ You are banned from this service.');
-        return;
+      const bannedUsers = loadBannedUsers();
+      const index = bannedUsers.indexOf(userId);
+      if (index > -1) {
+        bannedUsers.splice(index, 1);
+        saveBannedUsers(bannedUsers);
+        socket.emit('adminUnbanResponse', { success: true, message: 'User unbanned successfully' });
+        io.emit('userStats', getUserStats());
+      } else {
+        socket.emit('adminUnbanResponse', { success: false, message: 'User is not banned' });
+      }
+    } catch (error) {
+      console.error('Error unbanning user:', error);
+      socket.emit('adminUnbanResponse', { success: false, message: 'An error occurred while unbanning the user' });
+    }
+  });
+
+  // ─── adminDeleteUser ─────────────────────────────────────────────────────────
+  socket.on('adminDeleteUser', (userId) => {
+    try {
+      if (typeof userId !== 'string') {
+        throw new Error('Invalid input type');
       }
 
-      if (!userStates[userId] || !userStates[userId].step) {
-        socket.emit('message', '❌ Please click “Start” before sending commands.');
+      if (deleteUser(userId)) {
+        socket.emit('adminDeleteUserResponse', { success: true, message: 'User deleted successfully' });
+        io.emit('userStats', getUserStats());
+      } else {
+        socket.emit('adminDeleteUserResponse', { success: false, message: 'User not found or could not be deleted' });
+      }
+    } catch (error) {
+      console.error('Error deleting user:', error);
+      socket.emit('adminDeleteUserResponse', { success: false, message: 'An error occurred while deleting the user' });
+    }
+  });
+
+  // ─── adminMakeAdmin ─────────────────────────────────────────────────────────
+  socket.on('adminMakeAdmin', (userId) => {
+    try {
+      if (typeof userId !== 'string') {
+        throw new Error('Invalid input type');
+      }
+
+      const users = loadUsers();
+      const userToUpdate = Object.keys(users).find(username => users[username].id === userId);
+      if (userToUpdate) {
+        users[userToUpdate].isAdmin = true;
+        saveUsers(users);
+        socket.emit('adminMakeAdminResponse', { success: true, message: 'User is now an admin' });
+      } else {
+        socket.emit('adminMakeAdminResponse', { success: false, message: 'User not found' });
+      }
+    } catch (error) {
+      console.error('Error making user admin:', error);
+      socket.emit('adminMakeAdminResponse', { success: false, message: 'An error occurred while making the user an admin' });
+    }
+  });
+
+  // ─── adminRemoveAdmin ────────────────────────────────────────────────────────
+  socket.on('adminRemoveAdmin', (userId) => {
+    try {
+      if (typeof userId !== 'string') {
+        throw new Error('Invalid input type');
+      }
+
+      const users = loadUsers();
+      const userToUpdate = Object.keys(users).find(username => users[username].id === userId);
+      if (userToUpdate) {
+        users[userToUpdate].isAdmin = false;
+        saveUsers(users);
+        socket.emit('adminRemoveAdminResponse', { success: true, message: 'Admin privileges removed from user' });
+      } else {
+        socket.emit('adminRemoveAdminResponse', { success: false, message: 'User not found' });
+      }
+    } catch (error) {
+      console.error('Error removing admin privileges:', error);
+      socket.emit('adminRemoveAdminResponse', { success: false, message: 'An error occurred while removing admin privileges' });
+    }
+  });
+
+  // ─── start (make user folder + prompt for repo) ───────────────────────────────
+  socket.on('start', (userId) => {
+    try {
+      if (typeof userId !== 'string') {
+        throw new Error('Invalid input type');
+      }
+
+      const bannedUsers = loadBannedUsers();
+      if (bannedUsers.includes(userId)) {
+        socket.emit('message', '❌ You are banned from using this service by BLUEDEMON 🤤');
         return;
       }
 
-      const userDir = path.join(USERS_DIR, userId);
-      const state = userStates[userId];
-
-      // ——— “clear” → delete user’s entire directory —————————————
-      if (message.toLowerCase() === 'clear') {
-        if (fs.existsSync(userDir)) {
-          const rmProc = spawn('rm', ['-rf', userDir]);
-          rmProc.on('error', (err) => {
-            console.error('Error spawning rm:', err);
-            socket.emit('message', '❌ Failed to clear directory: ' + err.message);
-          });
-          rmProc.on('close', (code) => {
-            if (code === 0) {
-              socket.emit('message', '✅ Directory cleared.');
-            } else {
-              socket.emit('message', '❌ Failed to clear directory.');
-            }
-          });
-        } else {
-          socket.emit('message', '❌ Directory not found.');
-        }
+      const userDir = path.join(__dirname, 'users', String(userId));
+      if (!fs.existsSync(userDir)) {
+        fs.mkdirSync(userDir, { recursive: true });
+      }
+
+      const spaceUsed = calculateDirectorySize(userDir);
+      const spaceUsedMB = (spaceUsed / (1024 * 1024)).toFixed(2);
+      // send as JSON object
+      socket.emit('message', JSON.stringify({ type: 'spaceUsage', usage: `${spaceUsedMB} MB` }));
+
+      userStates[userId] = { step: 'ask_repo', started: true };
+      socket.emit('message', '⚧️ WELCOME! Please provide the Repository URL you wish to clone and run🏴,\nThe cloned repo can also be edited after refreshing the page');
+    } catch (error) {
+      console.error('Error starting user session:', error);
+      socket.emit('message', '❌ An error occurred while starting your session. Please try again.');
+    }
+  });
+
+  // ─── command Handler (clone, install, run, clear, list) ─────────────────────
+  socket.on('command', async (data) => {
+    try {
+      if (typeof data !== 'object' || typeof data.userId !== 'string' || typeof data.message !== 'string') {
+        throw new Error('Invalid input types');
+      }
+
+      const { userId, message } = data;
+      const bannedUsers = loadBannedUsers();
+
+      if (bannedUsers.includes(userId)) {
+        socket.emit('message', '❌ You are banned from using this service by BLUEDEMON 🤤');
         return;
       }
 
-      // ——— “list” → list files in user’s folder ————————————————
-      if (message.toLowerCase() === 'list') {
-        try {
-          const files = await listFiles(userId);
-          const names = files.map(f => f.name).join('\n') || '(empty)';
-          socket.emit('message', `📂 Files:\n${names}`);
-        } catch (err) {
-          socket.emit('message', '❌ Could not list files: ' + err.message);
-        }
+      if (!userStates[userId]?.started) {
+        socket.emit('message', '❌ Please use the start command before proceeding so as to avoid error');
         return;
       }
 
-      // ——— If state = “ask_repo”, treat message as GitHub URL ——————
-      if (state.step === 'ask_repo') {
-        const repoUrl = message.trim();
-        if (!repoUrl.startsWith('https://github.com/')) {
-          socket.emit('message', '❌ Invalid GitHub URL. It must start with https://github.com/');
-          return;
-        }
+      const userDir = path.join(__dirname, 'users', String(userId));
+      if (!userStates[userId]) {
+        userStates[userId] = { step: 'ask_repo', started: false };
+      }
+      const userState = userStates[userId];
+
+      switch (true) {
+        // ——— clear ————————————————————————��—————————————————————————————
+        case message.toLowerCase() === 'clear':
+          if (fs.existsSync(userDir)) {
+            socket.emit('message', '🗑 Clearing your directory...');
+            const rmProcess = spawn('rm', ['-rf', userDir]);
+            rmProcess.on('error', (err) => {
+              console.error('Error spawning rm:', err);
+              socket.emit('message', '❌ Failed to clear your directory: ' + err.message);
+            });
+            rmProcess.on('close', (code) => {
+              if (code === 0) {
+                socket.emit('message', '✅ Your directory has been cleared successfully.');
+              } else {
+                socket.emit('message', '❌ Failed to clear your directory.');
+              }
+            });
+          } else {
+            socket.emit('message', '❌ Directory not found.');
+          }
+          break;
 
-        socket.emit('message', `🔄 Cloning repo: ${repoUrl}`);
-        const gitClone = spawn('git', ['clone', repoUrl, '.'], { cwd: userDir });
+        // ——— list ———————————————————————————————————————————————————————
+        case message.toLowerCase() === 'list':
+          try {
+            const files = await listFiles(userId);
+            socket.emit('message', `📂 Files:: ${files.map(f => f.name).join('\n, ')}`);
+          } catch (error) {
+            socket.emit('message', '❌ No file in your directory.');
+          }
+          break;
 
-        gitClone.on('error', (err) => {
-          console.error('Error spawning git clone:', err);
-          socket.emit('message', '❌ Failed to run git clone: ' + err.message);
-        });
+        // ——— run <file> ——————————————————————————————————————————————————
+        case message.toLowerCase().startsWith('run '):
+          {
+            const filenameToRun = message.slice(4).trim();
+            const filePathToRun = path.join(userDir, filenameToRun);
 
-        gitClone.stdout.on('data', (data) => {
-          socket.emit('message', `📦 GIT: ${data.toString()}`);
-        });
-        gitClone.stderr.on('data', (data) => {
-          socket.emit('message', `⚠️ GIT ERROR: ${data.toString()}`);
-        });
+            if (!fs.existsSync(filePathToRun)) {
+              return socket.emit('message', '❌ The specified file does not exist.');
+            }
 
-        gitClone.on('close', (code) => {
-          if (code === 0) {
-            socket.emit('message', '✅ Repo cloned successfully! Installing dependencies...');
-            const yarnInstall = spawn('yarn', ['install'], { cwd: userDir });
+            socket.emit('message', `🚀 Running the file: ${filenameToRun}`);
+            const nodeProcess = spawn('node', [filePathToRun], { cwd: userDir });
 
-            yarnInstall.on('error', (err) => {
-              console.error('Error spawning yarn install:', err);
-              socket.emit('message', '❌ Failed to run yarn install: ' + err.message);
+            // **ADDED**: catch spawn errors
+            nodeProcess.on('error', (err) => {
+              console.error('Error spawning node process:', err);
+              socket.emit('message', '❌ Failed to start bot: ' + err.message);
             });
 
-            yarnInstall.stdout.on('data', (data) => {
-              socket.emit('message', `📦 YARN: ${data.toString()}`);
+            userStates[userId].runningProcess = nodeProcess;
+
+            nodeProcess.stdout.on('data', (data) => socket.emit('message', `✅ NODE OUTPUT:\n${data}`));
+            nodeProcess.stderr.on('data', (data) => socket.emit('message', `⚠️ NODE ERROR:\n${data}`));
+            nodeProcess.on('close', (code) => {
+              socket.emit('message', `🚀 Script finished with code ${code}`);
+              delete userStates[userId].runningProcess;
             });
-            yarnInstall.stderr.on('data', (data) => {
-              socket.emit('message', `⚠️ YARN ERROR: ${data.toString()}`);
+
+            userStates[userId].step = 'interacting';
+          }
+          break;
+
+        // ——— ask_repo (clone) —————————————————————————————————————————————
+        case userState.step === 'ask_repo':
+          {
+            const repoUrl = message;
+            if (!repoUrl.startsWith('https://github.com/')) {
+              socket.emit('message', '❌ Invalid repository URL. Please provide a valid GitHub repository URL starting with https://github.com/');
+              return;
+            }
+            socket.emit('message', `🔄 Cloning the repository from: ${repoUrl}`);
+            const gitClone = spawn('git', ['clone', repoUrl, '.'], { cwd: userDir });
+
+            // **ADDED**: catch spawn errors
+            gitClone.on('error', (err) => {
+              console.error('Error spawning git clone:', err);
+              socket.emit('message', '❌ Failed to run git clone: ' + err.message);
             });
 
-            yarnInstall.on('close', (installCode) => {
-              if (installCode === 0) {
-                socket.emit('message', '✅ Dependencies installed.\n▶️ Send the filename to run (e.g. index.js).');
-                state.step = 'ask_file';
+            gitClone.stdout.on('data', (data) => socket.emit('message', `✅ GIT OUTPUT:\n${data}`));
+            gitClone.stderr.on('data', (data) => socket.emit('message', `⚠️ GIT ERROR:\n${data}`));
+            gitClone.on('close', (code) => {
+              if (code === 0) {
+                socket.emit('message', '✅ Repository cloned successfully!\nNow Installing dependencies...');
+                const yarnInstall = spawn('yarn', ['install'], { cwd: userDir });
+
+                // **ADDED**: catch spawn errors
+                yarnInstall.on('error', (err) => {
+                  console.error('Error spawning yarn install:', err);
+                  socket.emit('message', '❌ Failed to run yarn install: ' + err.message);
+                });
+
+                yarnInstall.stdout.on('data', (data) => socket.emit('message', `✅ YARN OUTPUT:\n${data}`));
+                yarnInstall.stderr.on('data', (data) => socket.emit('message', `⚠️ YARN ERROR:\n${data}`));
+                yarnInstall.on('close', (installCode) => {
+                  if (installCode === 0) {
+                    socket.emit('message', '✅ Dependencies installed successfully!!\nWhich file would you like to run e.g index.js');
+                    userStates[userId].step = 'ask_file';
+                  } else {
+                    socket.emit('message', '❌ Error installing dependencies.');
+                  }
+                });
               } else {
-                socket.emit('message', '❌ Error installing dependencies.');
+                socket.emit('message', '❌ Error cloning the repository.');
               }
             });
-          } else {
-            socket.emit('message', '❌ Error cloning the repository.');
           }
-        });
+          break;
 
-        return;
-      }
+        // ——— ask_file (run) ——————————————————————————————————————————————————
+        case userState.step === 'ask_file':
+          {
+            const filename = message;
+            const filePath = path.join(userDir, filename);
 
-      // ——— If state = “ask_file”, message = filename to run ————————
-      if (state.step === 'ask_file') {
-        const filename = message.trim();
-        const filePath = path.join(userDir, filename);
-        if (!fs.existsSync(filePath)) {
-          socket.emit('message', '❌ File not found: ' + filename);
-          return;
-        }
-        socket.emit('message', `🚀 Running file: ${filename}`);
-        runBot(userId, filename, socket);
-        state.step = 'interacting';
-        return;
-      }
+            if (!fs.existsSync(filePath)) {
+              return socket.emit('message', '❌ The specified file does not exist.');
+            }
 
-      // ——— If state = “interacting”, forward input to bot’s stdin ————
-      if (state.step === 'interacting') {
-        const proc = state.runningProcess;
-        if (proc) {
-          try {
-            proc.stdin.write(message + '\n');
-          } catch (err) {
-            socket.emit('message', '❌ Failed to write to bot stdin: ' + err.message);
+            socket.emit('message', `🚀 Running the file: ${filename}`);
+            const nodeProcessFile = spawn('node', [filePath], { cwd: userDir });
+
+            // **ADDED**: catch spawn errors
+            nodeProcessFile.on('error', (err) => {
+              console.error('Error spawning node process:', err);
+              socket.emit('message', '❌ Failed to start bot: ' + err.message);
+            });
+
+            userStates[userId].runningProcess = nodeProcessFile;
+
+            nodeProcessFile.stdout.on('data', (data) => socket.emit('message', `✅ NODE OUTPUT:\n${data}`));
+            nodeProcessFile.stderr.on('data', (data) => socket.emit('message', `⚠️ NODE ERROR:\n${data}`));
+            nodeProcessFile.on('close', (code) => {
+              socket.emit('message', `🚀 Script finished with code ${code}`);
+              delete userStates[userId].runningProcess;
+            });
+
+            userStates[userId].step = 'interacting';
           }
-        } else {
-          socket.emit('message', '❌ No active bot process. Please “Start” again.');
-        }
-        return;
-      }
+          break;
 
-      // ——— Unrecognized command ————————————————————————————————————
-      socket.emit('message', '❌ Unrecognized command. Use “list”, “clear”, or send the GitHub URL/file.');
-    } catch (err) {
-      console.error('Error in command handler:', err);
-      socket.emit('message', '❌ Error: ' + err.message);
+        // ——— interacting (stdin to bot) —————————————————————————————————————————
+        case userState.step === 'interacting':
+          if (userState.runningProcess) {
+            userState.runningProcess.stdin.write(message + '\n');
+          } else {
+            socket.emit('message', '❌ No active process to interact with. Please run a file first.');
+          }
+          break;
+
+        default:
+          socket.emit('message', '❌ Unrecognized command. Use list, clear, or start.');
+      }
+    } catch (error) {
+      console.error('Error processing command:', error);
+      socket.emit('message', '❌ An error occurred while processing your command. Please try again.');
     }
   });
 
-  // ─── Read File ───────────────────────────────────────────────────────────────
+  // ─── readFile ───────────────────────────────────────────────────────────────
   socket.on('readFile', async ({ userId, filePath }) => {
     try {
       const content = await readFile(userId, filePath);
       socket.emit('fileContent', { filePath, content });
-    } catch (err) {
-      socket.emit('error', { message: err.message });
+    } catch (error) {
+      socket.emit('error', { message: error.message });
     }
   });
 
-  // ─── Write File ──────────────────────────────────────────────────────────────
+  // ─── writeFile ──────────────────────────────────────────────────────────────
   socket.on('writeFile', async ({ userId, filePath, content }) => {
     try {
       await writeFile(userId, filePath, content);
       socket.emit('fileSaved', { filePath });
-    } catch (err) {
-      socket.emit('error', { message: err.message });
+    } catch (error) {
+      socket.emit('error', { message: error.message });
     }
   });
 
-  // ─── Upload File ──────────────────────────────────────────────────────────────
+  // ─── listFiles ──────────────────────────────────────────────────────────────
+  socket.on('listFiles', async ({ userId, dirPath }) => {
+    try {
+      const files = await listFiles(userId, dirPath);
+      socket.emit('fileList', files);
+    } catch (error) {
+      socket.emit('error', { message: error.message });
+    }
+  });
+
+  // ─── uploadFile ────────────────────────────────────────────────────────────
   socket.on('uploadFile', async ({ userId, filePath, content }) => {
     try {
       await uploadFile(userId, filePath, content);
       socket.emit('fileUploaded', { filePath });
-    } catch (err) {
-      socket.emit('error', { message: err.message });
+    } catch (error) {
+      socket.emit('error', { message: error.message });
     }
   });
 
-  // ─── Keep-Alive “ping” (frontend sends every 10s) ─────────────────────────────
-  socket.on('ping', () => {
-    // Do nothing; prevents HF Spaces from idling
+  // ─── forgotPassword ─────────────────────────────────────────────────────────
+  socket.on('forgotPassword', async (clientId) => {
+    try {
+      const users = loadUsers();
+      const user = Object.values(users).find(u => u.clientId === clientId);
+      
+      if (user) {
+        const resetToken = await generateResetToken();
+        user.resetToken = resetToken;
+        user.resetTokenExpires = Date.now() + 3600000; 
+        saveUsers(users);
+        
+        socket.emit('resetTokenGenerated', { username: user.username, resetToken });
+      } else {
+        socket.emit('resetTokenError', 'No user found with this client ID');
+      }
+    } catch (error) {
+      console.error('Error in forgot password process:', error);
+      socket.emit('resetTokenError', 'An error occurred during the password reset process');
+    }
+  });
+
+  // ─── resetPassword ────────────────────────────────���─────────────────────────
+  socket.on('resetPassword', async ({ resetToken, newPassword }) => {
+    try {
+      const users = loadUsers();
+      const user = Object.values(users).find(u => u.resetToken === resetToken && u.resetTokenExpires > Date.now());
+      
+      if (user) {
+        user.password = newPassword;
+        delete user.resetToken;
+        delete user.resetTokenExpires;
+        saveUsers(users);
+        socket.emit('passwordResetSuccess', 'Password has been reset successfully');
+      } else {
+        socket.emit('passwordResetError', 'Invalid or expired reset token');
+      }
+    } catch (error) {
+      console.error('Error in password reset process:', error);
+      socket.emit('passwordResetError', 'An error occurred during the password reset process');
+    }
+  });
+
+  // ─── getServerRuntime ────────────────────────────────────────────────────────
+  socket.on('getServerRuntime', () => {
+    try {
+      socket.emit('serverRuntime', getServerRuntime());
+    } catch (error) {
+      console.error('Error getting server runtime:', error);
+      socket.emit('serverRuntime', 'Error getting server runtime');
+    }
   });
 
-  // ─── Disconnect ───────────────────────────────────────────────────────────────
+  // ─── getSystemStatus ─────────────────────────────────────────────────────────
+  socket.on('getSystemStatus', () => {
+    try {
+      socket.emit('systemStatus', getSystemStatus());
+    } catch (error) {
+      console.error('Error getting system status:', error);
+      socket.emit('systemStatus', { cpu: 0, memory: 0, disk: 0 });
+    }
+  });
+
+  // ─── getUserStats ───────────────────────────────────────────────────────────
+  socket.on('getUserStats', () => {
+    try {
+      socket.emit('userStats', getUserStats());
+    } catch (error) {
+      console.error('Error getting user stats:', error);
+      socket.emit('userStats', { total: 0, active: 0, banned: 0 });
+    }
+  });
+
+  // ─── disconnect ─────────────────────────────────────────────────────────────
   socket.on('disconnect', () => {
+    console.log('User disconnected');
     activeUsers--;
     io.emit('userStats', getUserStats());
   });
 });
 
-// ─── 9) BROADCAST LIVE STATS EVERY 5 SECONDS ─────────────────────────────────
+// ─── 6) BROADCAST LIVE STATS EVERY 5 SECONDS ─────────────────────────────────
 setInterval(() => {
-  io.emit('serverRuntime', getServerRuntime());
-  io.emit('systemStatus', getSystemStatus());
-  io.emit('userStats', getUserStats());
+  try {
+    io.emit('serverRuntime', getServerRuntime());
+    io.emit('systemStatus', getSystemStatus());
+    io.emit('userStats', getUserStats());
+  } catch (error) {
+    console.error('Error emitting periodic updates:', error);
+  }
 }, 5000);
 
-// ─── 10) START THE SERVER ─────────────────────────────────────────────────────
+// ─── 7) START THE SERVER ─────────────────────────────────────────────────────
 const PORT = process.env.PORT || 7860;
-httpServer.listen(PORT, () => console.log(`✅ Server running on port ${PORT}`));
+http.listen(PORT, () => console.log(`🌐 Server running on port ${PORT}.`));
 
-// ─── 11) GLOBAL ERROR HANDLERS ────────────────────────────────────────────────
-process.on('uncaughtException', (err) => {
-  console.error('💥 Uncaught Exception:', err);
+// ─── 8) GLOBAL ERROR HANDLERS ────────────────────────────────────────────────
+process.on('uncaughtException', (error) => {
+  console.error('Uncaught Exception:', error);
 });
-process.on('unhandledRejection', (reason) => {
-  console.error('💥 Unhandled Promise Rejection:', reason);
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
 });