Update server.js

server.js

@@ -5,225 +5,202 @@ const path = require('path');
 const app = express();
 const http = require('http').createServer(app);
 const io = require('socket.io')(http, {
-  cors: {
-    origin: "*",
-    methods: ["GET", "POST"]
-  }
+    cors: {
+        origin: "*",
+        methods: ["GET", "POST"]
+    }
 });
 const crypto = require('crypto');
-const fetch = require('node-fetch');
+const fs = require('fs');
 
-// Connect to MongoDB
+// MongoDB Connection
 const MONGO_URI = process.env.MONGO_URI || "mongodb://localhost:27017";
 let db;
 
 async function connectDB() {
-  try {
-    const client = new MongoClient(MONGO_URI);
-    await client.connect();
-    db = client.db('whatsapp-bots');
-    console.log("✅ Connected to MongoDB");
-    
-    // Create collections if they don't exist
-    const collections = ['users', 'bots', 'settings'];
-    for (const colName of collections) {
-      if (!(await db.listCollections({name: colName}).hasNext())) {
-        await db.createCollection(colName);
-        console.log(`Created collection: ${colName}`);
-      }
-    }
-    
-    // Create admin user if not exists
-    const adminExists = await db.collection('users').findOne({username: 'admin'});
-    if (!adminExists) {
-      await db.collection('users').insertOne({
-        username: 'admin',
-        password: crypto.createHash('sha256').update('admin2008').digest('hex'),
-        isAdmin: true,
-        createdAt: new Date()
-      });
-      console.log("👑 Created admin user (password: admin123)");
-    }
-    
-    // Restart all bots that were running
-    const runningBots = await db.collection('bots').find({status: 'running'}).toArray();
-    runningBots.forEach(bot => {
-      startBotProcess(bot.userId, bot.repoUrl, bot.entryFile);
-    });
-  } catch (err) {
-    console.error("❌ MongoDB connection error:", err);
-  }
-}
-
-// Start a bot process
-function startBotProcess(userId, repoUrl, entryFile) {
-  const botDir = `/persistent/storage/${userId}`;
-  
-  // Clone repo if not exists
-  if (!require('fs').existsSync(botDir)) {
-    const clone = spawn('git', ['clone', repoUrl, botDir]);
-    clone.on('close', (code) => {
-      if (code === 0) {
-        console.log(`✅ Cloned ${repoUrl} for user ${userId}`);
-        installDependencies(botDir, userId, repoUrl, entryFile);
-      } else {
-        console.error(`❌ Failed to clone ${repoUrl} for user ${userId}`);
-      }
-    });
-  } else {
-    installDependencies(botDir, userId, repoUrl, entryFile);
-  }
-}
-
-function installDependencies(botDir, userId, repoUrl, entryFile) {
-  const install = spawn('npm', ['install'], { cwd: botDir });
-  install.on('close', (code) => {
-    if (code === 0) {
-      console.log(`✅ Installed dependencies for ${userId}`);
-      runBot(botDir, userId, repoUrl, entryFile);
-    } else {
-      console.error(`❌ Failed to install dependencies for ${userId}`);
+    try {
+        const client = new MongoClient(MONGO_URI);
+        await client.connect();
+        db = client.db('whatsapp-bots');
+        console.log("✅ Connected to MongoDB");
+        
+        // Initialize collections
+        const collections = ['users', 'bots', 'sessions'];
+        for (const colName of collections) {
+            if (!(await db.listCollections({ name: colName }).hasNext()) {
+                await db.createCollection(colName);
+                console.log(`Created collection: ${colName}`);
+            }
+        }
+        
+        // Create admin user if not exists
+        const adminExists = await db.collection('users').findOne({ username: 'admin' });
+        if (!adminExists) {
+            await db.collection('users').insertOne({
+                username: 'admin',
+                password: hashPassword('admin123'),
+                isAdmin: true,
+                createdAt: new Date()
+            });
+            console.log("👑 Created admin user (password: admin123)");
+        }
+    } catch (err) {
+        console.error("❌ MongoDB connection error:", err);
+        process.exit(1);
     }
-  });
 }
 
-function runBot(botDir, userId, repoUrl, entryFile) {
-  const botProcess = spawn('node', [entryFile], { 
-    cwd: botDir,
-    stdio: ['pipe', 'pipe', 'pipe', 'ipc'] 
-  });
-  
-  // Save to database
-  db.collection('bots').updateOne(
-    { userId },
-    { $set: { 
-      status: 'running',
-      repoUrl,
-      entryFile,
-      startedAt: new Date(),
-      pid: botProcess.pid 
-    }},
-    { upsert: true }
-  );
-  
-  botProcess.stdout.on('data', (data) => {
-    io.to(userId).emit('bot-output', data.toString());
-  });
-  
-  botProcess.stderr.on('data', (data) => {
-    io.to(userId).emit('bot-error', data.toString());
-  });
-  
-  botProcess.on('close', (code) => {
-    console.log(`Bot ${userId} exited with code ${code}`);
-    db.collection('bots').updateOne(
-      { userId },
-      { $set: { status: 'stopped', exitCode: code } }
-    );
-  });
+function hashPassword(password) {
+    return crypto
+        .createHash('sha256')
+        .update(password + (process.env.PEPPER || 'defaultPepper'))
+        .digest('hex');
 }
 
-// Web server setup
-app.use(express.static('public'));
-app.use(express.json());
-
-// API endpoints
-app.post('/api/deploy', async (req, res) => {
-  const { userId, repoUrl, entryFile } = req.body;
-  
-  if (!userId || !repoUrl || !entryFile) {
-    return res.status(400).json({ error: "Missing parameters" });
-  }
-  
-  try {
-    startBotProcess(userId, repoUrl, entryFile);
-    res.json({ success: true, message: "Bot deployment started" });
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
-});
-
 // Socket.IO
 io.on('connection', (socket) => {
-  console.log(`User connected: ${socket.id}`);
-  
-  socket.on('register', async (data) => {
-    const { username, password } = data;
-    const hashedPassword = crypto.createHash('sha256').update(password).digest('hex');
+    console.log(`New connection: ${socket.id}`);
     
-    try {
-      await db.collection('users').insertOne({
-        username,
-        password: hashedPassword,
-        createdAt: new Date()
-      });
-      socket.emit('register-success');
-    } catch (err) {
-      socket.emit('register-error', 'Username already exists');
-    }
-  });
-  
-  socket.on('login', async (data) => {
-    const { username, password } = data;
-    const hashedPassword = crypto.createHash('sha256').update(password).digest('hex');
+    // Force terminal initialization
+    socket.emit('terminal-init', { 
+        status: 'ready',
+        timestamp: Date.now() 
+    });
     
-    const user = await db.collection('users').findOne({ 
-      username, 
-      password: hashedPassword 
+    // Terminal command handler
+    socket.on('terminal-command', async (data) => {
+        try {
+            const { command, userId } = data;
+            console.log(`Command from ${userId}: ${command}`);
+            
+            // Execute command in user's directory
+            const userDir = `/persistent/storage/${userId}`;
+            const child = spawn(command.split(' ')[0], command.split(' ').slice(1), {
+                cwd: userDir
+            });
+            
+            child.stdout.on('data', (data) => {
+                socket.emit('terminal-output', data.toString());
+            });
+            
+            child.stderr.on('data', (data) => {
+                socket.emit('terminal-output', `ERROR: ${data.toString()}`);
+            });
+            
+            child.on('close', (code) => {
+                socket.emit('terminal-output', `Process exited with code ${code}\n`);
+            });
+        } catch (err) {
+            socket.emit('terminal-output', `ERROR: ${err.message}\n`);
+        }
     });
     
-    if (user) {
-      socket.emit('login-success', { userId: user._id.toString(), isAdmin: user.isAdmin });
-      socket.join(user._id.toString());
-    } else {
-      socket.emit('login-error', 'Invalid credentials');
-    }
-  });
-  
-  socket.on('deploy-bot', (data) => {
-    const { userId, repoUrl, entryFile } = data;
-    startBotProcess(userId, repoUrl, entryFile);
-  });
+    // Authentication handlers
+    socket.on('login', async (data) => {
+        try {
+            const { username, password } = data;
+            const user = await db.collection('users').findOne({ 
+                username,
+                password: hashPassword(password)
+            });
+            
+            if (user) {
+                currentUser = user._id.toString();
+                socket.emit('login-success', { 
+                    userId: currentUser,
+                    isAdmin: user.isAdmin 
+                });
+                
+                // Ensure user directory exists
+                const userDir = `/persistent/storage/${currentUser}`;
+                if (!fs.existsSync(userDir)) {
+                    fs.mkdirSync(userDir, { recursive: true });
+                }
+            } else {
+                socket.emit('login-error', 'Invalid credentials');
+            }
+        } catch (err) {
+            socket.emit('login-error', 'Authentication failed');
+        }
+    });
 });
 
-// Add this to your Socket.IO setup
-io.on('connection', (socket) => {
-    console.log(`New connection: ${socket.id}`);
-    
-    // Force terminal to be visible
-    socket.emit('terminal-init', {
-        ready: true,
-        timestamp: Date.now()
-    });
+// Express middleware
+app.use(express.static('public'));
+app.use(express.json());
 
-    // New event to force terminal visibility
-    socket.on('force-terminal-visible', () => {
-        socket.emit('terminal-output', 'Terminal session activated\n');
-        socket.emit('terminal-output', 'Ready for commands\n');
+// Health check endpoint
+app.get('/health', (req, res) => {
+    res.status(200).json({ 
+        status: 'healthy',
+        timestamp: Date.now() 
     });
+});
 
-
-// Add this error handling middleware
+// Error handling
 app.use((err, req, res, next) => {
     console.error('Global error:', err);
-    io.emit('terminal-output', `ERROR: ${err.message}\n`);
-    next();
-});
+    io.emit('terminal-output', `SYSTEM ERROR: ${err.message}\n`);
+    res.status(500).json({ error: err.message });
 });
+
 // Start server
 const PORT = process.env.PORT || 7860;
 connectDB().then(() => {
-  http.listen(PORT, () => {
-    console.log(`🚀 Server running on port ${PORT}`);
-    console.log(`🌐 Open: http://localhost:${PORT}`);
-  });
+    http.listen(PORT, () => {
+        console.log(`🚀 Server running on port ${PORT}`);
+        
+        // Restart any previously running bots
+        db.collection('bots').find({ status: 'running' }).forEach(bot => {
+            console.log(`Restarting bot for user ${bot.userId}`);
+            startBotProcess(bot.userId, bot.repoUrl, bot.entryFile);
+        });
+    });
 });
 
-// Error handling
-process.on('uncaughtException', (err) => {
-  console.error('Uncaught Exception:', err);
-});
+// Helper function to start bot processes
+function startBotProcess(userId, repoUrl, entryFile) {
+    const botDir = `/persistent/storage/${userId}`;
+    
+    // Clone repo if needed
+    if (!fs.existsSync(botDir)) {
+        const clone = spawn('git', ['clone', repoUrl, botDir]);
+        clone.on('close', (code) => {
+            if (code === 0) installDependencies(botDir, userId, repoUrl, entryFile);
+        });
+    } else {
+        installDependencies(botDir, userId, repoUrl, entryFile);
+    }
+}
+
+function installDependencies(botDir, userId, repoUrl, entryFile) {
+    const install = spawn('npm', ['install'], { cwd: botDir });
+    install.on('close', (code) => {
+        if (code === 0) runBot(botDir, userId, repoUrl, entryFile);
+    });
+}
 
-process.on('unhandledRejection', (reason, promise) => {
-  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
-});
+function runBot(botDir, userId, repoUrl, entryFile) {
+    const botProcess = spawn('node', [entryFile], { cwd: botDir });
+    
+    // Save to database
+    db.collection('bots').updateOne(
+        { userId },
+        { $set: { 
+            status: 'running',
+            repoUrl,
+            entryFile,
+            pid: botProcess.pid,
+            lastStarted: new Date()
+        }},
+        { upsert: true }
+    );
+    
+    // Handle process events
+    botProcess.on('exit', (code) => {
+        db.collection('bots').updateOne(
+            { userId },
+            { $set: { status: 'stopped', exitCode: code } }
+        );
+    });
+}