Update index.js

index.js

@@ -793,290 +793,289 @@ app.post('/api/auth/register', checkBanned, authRateLimit, async (req, res) => {
                             </div>
                         </div>
                         <div style="background: #f8f9fa; padding: 25px 30px; text-align: center; border-top: 1px solid #e9ecef;">
-                            <p style="color: #6c757d;
-                            margin: 0 0 10px 0; font-size: 14px;">
+                            <p style="color: #6c757d; margin: 0 0 10px 0; font-size: 14px;">
                                 Need help? Contact our support team
                             </p>
                             <p style="color: #adb5bd; margin: 0; font-size: 12px;">
                                 © 2025 DashX. All rights reserved.
                             </p>
-                            </div>
-                            </div>
-                            </div>
-                            </body>
-                            </html>
-                            `;
-
-                            await transporter.sendMail({
-                            from: 'dashxapi@gmail.com',
-                            to: email,
-                            subject: 'DashX - Email Verification',
-                            html: emailTemplate
-                            });
-
-                            res.json({ 
-                            success: true, 
-                            message: 'Verification code sent to your email. Please verify within 15 minutes.',
-                            expiresIn: '15 minutes'
-                            });
-
-                            } catch (error) {
-                            console.error('Registration error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.post('/api/auth/verify', checkBanned, authRateLimit, async (req, res) => {
-                            try {
-                            const { email, code } = req.body;
-
-                            if (!email || !code) {
-                            return res.status(400).json({ 
-                            success: false, 
-                            error: 'Email and verification code are required' 
-                            });
-                            }
+                        </div>
+                    </div>
+                </div>
+            </body>
+            </html>
+        `;
+
+        await transporter.sendMail({
+            from: 'dashxapi@gmail.com',
+            to: email,
+            subject: 'DashX - Email Verification',
+            html: emailTemplate
+        });
 
-                            const pendingVerification = await PendingVerification.findOne({ 
-                            email, 
-                            verificationCode: code 
-                            });
+        res.json({ 
+            success: true, 
+            message: 'Verification code sent to your email. Please verify within 15 minutes.',
+            expiresIn: '15 minutes'
+        });
 
-                            if (!pendingVerification) {
-                            return res.status(400).json({ 
-                            success: false, 
-                            error: 'Invalid verification code or code has expired' 
-                            });
-                            }
+    } catch (error) {
+        console.error('Registration error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
 
-                            const existingUser = await User.findOne({
-                            $or: [{ email: pendingVerification.email }, { username: pendingVerification.username }]
-                            });
+app.post('/api/auth/verify', checkBanned, authRateLimit, async (req, res) => {
+    try {
+        const { email, code } = req.body;
 
-                            if (existingUser) {
-                            await PendingVerification.deleteOne({ _id: pendingVerification._id });
-                            return res.status(400).json({ 
-                            success: false, 
-                            error: 'User already exists in database' 
-                            });
-                            }
-
-                            const apikey = generateApiKey();
-
-                            const user = new User({
-                            username: pendingVerification.username,
-                            email: pendingVerification.email,
-                            password: pendingVerification.password,
-                            apikey: apikey,
-                            profileUrl: 'https://files.catbox.moe/8l6hhm',
-                            verified: true,
-                            ipAddress: pendingVerification.ipAddress,
-                            role: 'user',
-                            premium: false,
-                            limit: 30,
-                            requests: 0,
-                            requestsToday: 0,
-                            lastReset: new Date(),
-                            banned: false
-                            });
-
-                            await user.save();
-                            await PendingVerification.deleteOne({ _id: pendingVerification._id });
-
-                            await logActivity(user._id, user.username, 'api_key_generated', 'Account created and verified successfully', {
-                            apikey: user.apikey,
-                            registrationIP: pendingVerification.ipAddress
-                            });
-
-                            const token = jwt.sign({ userId: user._id }, JWT_SECRET, { expiresIn: '30d' });
-
-                            res.json({ 
-                            success: true, 
-                            token, 
-                            user: { 
-                            id: user._id,
-                            username: user.username, 
-                            email: user.email, 
-                            apikey: user.apikey,
-                            profileUrl: user.profileUrl,
-                            premium: user.premium,
-                            limit: user.limit
-                            },
-                            message: 'Account created and verified successfully!'
-                            });
-
-                            } catch (error) {
-                            console.error('Verification error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.get('/api/admin/search-users', authenticate, async (req, res) => {
-                            try {
-                            if (req.user.role !== 'admin') {
-                            return res.status(403).json({ success: false, error: 'Admin access required' });
-                            }
-
-                            const { query } = req.query;
-                            if (!query) {
-                            return res.json({ success: true, users: [] });
-                            }
-
-                            const users = await User.find({
-                            $or: [
-                            { username: { $regex: query, $options: 'i' } },
-                            { email: { $regex: query, $options: 'i' } }
-                            ],
-                            role: { $ne: 'admin' }
-                            }).limit(10).select('username email limit premium role');
-
-                            res.json({ success: true, users });
-                            } catch (error) {
-                            console.error('Search users error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.get('/api/admin/user-role/:userId', authenticate, async (req, res) => {
-                            try {
-                            if (req.user.role !== 'admin') {
-                            return res.status(403).json({ success: false, error: 'Admin access required' });
-                            }
-
-                            const userRole = await UserRole.findOne({ userId: req.params.userId });
-                            res.json({ success: true, role: userRole });
-                            } catch (error) {
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.post('/api/auth/login', checkBanned, authRateLimit, async (req, res) => {
-                            try {
-                            const { email, password } = req.body;
-
-                            if (!email || !password) {
-                            return res.status(400).json({ 
-                            success: false, 
-                            error: 'Email and password are required'
-                            });
-                            }
-
-                            const user = await User.findOne({ email });
-                            if (!user) {
-                            return res.status(400).json({ success: false, error: 'Invalid credentials' });
-                            }
-
-                            const isValidPassword = await bcrypt.compare(password, user.password);
-                            if (!isValidPassword) {
-                            return res.status(400).json({ success: false, error: 'Invalid credentials' });
-                            }
-
-                            if (user.banned) {
-                            return res.status(403).json({ success: false, error: 'Account is permanently banned' });
-                            }
-
-                            await checkPremiumExpiry(user);
-                            await checkRoleExpiry(user);
-                            await resetUserLimitIfNeeded(user);
-
-                            const isTempBanned = await checkTempBan(user);
-                            if (isTempBanned) {
-                            const banUntil = new Date(user.tempBanUntil);
-                            return res.status(403).json({ 
-                            success: false, 
-                            error: `Account temporarily banned until ${banUntil.toLocaleString()}. Reason: ${user.tempBanReason || 'No reason provided'}` 
-                            });
-                            }
-
-                            const token = jwt.sign({ userId: user._id }, JWT_SECRET, { expiresIn: '30d' });
-
-                            res.json({ 
-                            success: true, 
-                            token, 
-                            user: { 
-                            id: user._id,
-                            username: user.username, 
-                            email: user.email, 
-                            apikey: user.apikey,
-                            profileUrl: user.profileUrl,
-                            premium: user.premium,
-                            premiumExpiredAt: user.premiumExpiredAt,
-                            limit: user.limit,
-                            role: user.role
-                            } 
-                            });
-                            } catch (error) {
-                            console.error('Login error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.post('/api/auth/admin-login', checkBanned, authRateLimit, async (req, res) => {
-                            try {
-                            const { username, password } = req.body;
-
-                            if (username === 'HERXA' && password === 'BTXHZ') {
-                            let admin = await User.findOne({ username: 'HERXA' });
-                            if (!admin) {
-                            admin = new User({
-                            username: 'HERXA',
-                            email: 'admin@dashx.com',
-                            password: await bcrypt.hash('BTXHZ', 12),
-                            apikey: 'DHX-M3SA',
-                            profileUrl: 'https://files.catbox.moe/8l6hhm',
-                            verified: true,
-                            role: 'admin',
-                            premium: true,
-                            limit: 9999,
-                            ipAddress: req.realIP
-                            });
-                            await admin.save();
-                            } else {
-                            admin.apikey = 'DHX-M3SA';
-                            admin.limit = 9999;
-                            admin.role = 'admin';
-                            admin.premium = true;
-                            await admin.save();
-                            }
-
-                            const token = jwt.sign({ userId: admin._id }, JWT_SECRET, { expiresIn: '30d' });
-                            return res.json({ 
-                            success: true, 
-                            token, 
-                            user: { 
-                            id: admin._id,
-                            username: admin.username, 
-                            role: admin.role, 
-                            apikey: admin.apikey,
-                            profileUrl: admin.profileUrl,
-                            limit: admin.limit
-                            } 
-                            });
-                            }
-
-                            const admin = await User.findOne({ username, role: 'admin' });
-                            if (!admin || !await bcrypt.compare(password, admin.password)) {
-                            return res.status(400).json({ success: false, error: 'Invalid admin credentials' });
-                            }
-
-                            const token = jwt.sign({ userId: admin._id }, JWT_SECRET, { expiresIn: '30d' });
-                            res.json({ 
-                            success: true, 
-                            token, 
-                            user: { 
-                            id: admin._id,
-                            username: admin.username, 
-                            role: admin.role, 
-                            apikey: admin.apikey,
-                            profileUrl: admin.profileUrl,
-                            limit: admin.limit
-                            } 
-                            });
-                            } catch (error) {
-                            console.error('Admin login error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
+        if (!email || !code) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Email and verification code are required' 
+            });
+        }
+
+        const pendingVerification = await PendingVerification.findOne({ 
+            email, 
+            verificationCode: code 
+        });
+
+        if (!pendingVerification) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Invalid verification code or code has expired' 
+            });
+        }
+
+        const existingUser = await User.findOne({
+            $or: [{ email: pendingVerification.email }, { username: pendingVerification.username }]
+        });
+
+        if (existingUser) {
+            await PendingVerification.deleteOne({ _id: pendingVerification._id });
+            return res.status(400).json({ 
+                success: false, 
+                error: 'User already exists in database' 
+            });
+        }
+
+        const apikey = generateApiKey();
+
+        const user = new User({
+            username: pendingVerification.username,
+            email: pendingVerification.email,
+            password: pendingVerification.password,
+            apikey: apikey,
+            profileUrl: 'https://files.catbox.moe/8l6hhm',
+            verified: true,
+            ipAddress: pendingVerification.ipAddress,
+            role: 'user',
+            premium: false,
+            limit: 30,
+            requests: 0,
+            requestsToday: 0,
+            lastReset: new Date(),
+            banned: false
+        });
+
+        await user.save();
+        await PendingVerification.deleteOne({ _id: pendingVerification._id });
+
+        await logActivity(user._id, user.username, 'api_key_generated', 'Account created and verified successfully', {
+            apikey: user.apikey,
+            registrationIP: pendingVerification.ipAddress
+        });
+
+        const token = jwt.sign({ userId: user._id }, JWT_SECRET, { expiresIn: '30d' });
+
+        res.json({ 
+            success: true, 
+            token, 
+            user: { 
+                id: user._id,
+                username: user.username, 
+                email: user.email, 
+                apikey: user.apikey,
+                profileUrl: user.profileUrl,
+                premium: user.premium,
+                limit: user.limit
+            },
+            message: 'Account created and verified successfully!'
+        });
+
+    } catch (error) {
+        console.error('Verification error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.get('/api/admin/search-users', authenticate, async (req, res) => {
+    try {
+        if (req.user.role !== 'admin') {
+            return res.status(403).json({ success: false, error: 'Admin access required' });
+        }
+
+        const { query } = req.query;
+        if (!query) {
+            return res.json({ success: true, users: [] });
+        }
+
+        const users = await User.find({
+            $or: [
+                { username: { $regex: query, $options: 'i' } },
+                { email: { $regex: query, $options: 'i' } }
+            ],
+            role: { $ne: 'admin' }
+        }).limit(10).select('username email limit premium role');
+
+        res.json({ success: true, users });
+    } catch (error) {
+        console.error('Search users error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.get('/api/admin/user-role/:userId', authenticate, async (req, res) => {
+    try {
+        if (req.user.role !== 'admin') {
+            return res.status(403).json({ success: false, error: 'Admin access required' });
+        }
+
+        const userRole = await UserRole.findOne({ userId: req.params.userId });
+        res.json({ success: true, role: userRole });
+    } catch (error) {
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.post('/api/auth/login', checkBanned, authRateLimit, async (req, res) => {
+    try {
+        const { email, password } = req.body;
+
+        if (!email || !password) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Email and password are required'
+            });
+        }
+
+        const user = await User.findOne({ email });
+        if (!user) {
+            return res.status(400).json({ success: false, error: 'Invalid credentials' });
+        }
+
+        const isValidPassword = await bcrypt.compare(password, user.password);
+        if (!isValidPassword) {
+            return res.status(400).json({ success: false, error: 'Invalid credentials' });
+        }
+
+        if (user.banned) {
+            return res.status(403).json({ success: false, error: 'Account is permanently banned' });
+        }
+
+        await checkPremiumExpiry(user);
+        await checkRoleExpiry(user);
+        await resetUserLimitIfNeeded(user);
+
+        const isTempBanned = await checkTempBan(user);
+        if (isTempBanned) {
+            const banUntil = new Date(user.tempBanUntil);
+            return res.status(403).json({ 
+                success: false, 
+                error: `Account temporarily banned until ${banUntil.toLocaleString()}. Reason: ${user.tempBanReason || 'No reason provided'}` 
+            });
+        }
+
+        const token = jwt.sign({ userId: user._id }, JWT_SECRET, { expiresIn: '30d' });
+
+        res.json({ 
+            success: true, 
+            token, 
+            user: { 
+                id: user._id,
+                username: user.username, 
+                email: user.email, 
+                apikey: user.apikey,
+                profileUrl: user.profileUrl,
+                premium: user.premium,
+                premiumExpiredAt: user.premiumExpiredAt,
+                limit: user.limit,
+                role: user.role
+            } 
+        });
+    } catch (error) {
+        console.error('Login error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.post('/api/auth/admin-login', checkBanned, authRateLimit, async (req, res) => {
+    try {
+        const { username, password } = req.body;
+
+        if (username === 'HERXA' && password === 'BTXHZ') {
+            let admin = await User.findOne({ username: 'HERXA' });
+            if (!admin) {
+                admin = new User({
+                    username: 'HERXA',
+                    email: 'admin@dashx.com',
+                    password: await bcrypt.hash('BTXHZ', 12),
+                    apikey: 'DHX-M3SA',
+                    profileUrl: 'https://files.catbox.moe/8l6hhm',
+                    verified: true,
+                    role: 'admin',
+                    premium: true,
+                    limit: 9999,
+                    ipAddress: req.realIP
+                });
+                await admin.save();
+            } else {
+                admin.apikey = 'DHX-M3SA';
+                admin.limit = 9999;
+                admin.role = 'admin';
+                admin.premium = true;
+                await admin.save();
+            }
+
+            const token = jwt.sign({ userId: admin._id }, JWT_SECRET, { expiresIn: '30d' });
+            return res.json({ 
+                success: true, 
+                token, 
+                user: { 
+                    id: admin._id,
+                    username: admin.username, 
+                    role: admin.role, 
+                    apikey: admin.apikey,
+                    profileUrl: admin.profileUrl,
+                    limit: admin.limit
+                } 
+            });
+        }
+
+        const admin = await User.findOne({ username, role: 'admin' });
+        if (!admin || !await bcrypt.compare(password, admin.password)) {
+            return res.status(400).json({ success: false, error: 'Invalid admin credentials' });
+        }
+
+        const token = jwt.sign({ userId: admin._id }, JWT_SECRET, { expiresIn: '30d' });
+        res.json({ 
+            success: true, 
+            token, 
+            user: { 
+                id: admin._id,
+                username: admin.username, 
+                role: admin.role, 
+                apikey: admin.apikey,
+                profileUrl: admin.profileUrl,
+                limit: admin.limit
+            } 
+        });
+    } catch (error) {
+        console.error('Admin login error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
 
 app.get('/api/user/profile', authenticate, async (req, res) => {
     try {
@@ -1136,45 +1135,44 @@ app.get('/api/user/profile', authenticate, async (req, res) => {
     }
 });
 
-                            app.get('/api/user/activities', authenticate, async (req, res) => {
-                            try {
-                            const activities = await Activity.find({ userId: req.user._id })
-                            .sort({ timestamp: -1 })
-                            .limit(50);
-
-                            const requestLogs = await RequestLog.find({ userId: req.user._id })
-                            .sort({ timestamp: -1 })
-                            .limit(20);
-
-                            res.json({
-                            success: true,
-                            activities: activities.map(activity => ({
-                            type: activity.type,
-                            description: activity.description,
-                            timestamp: activity.timestamp,
-                            timeAgo: getTimeAgo(activity.timestamp),
-                            metadata: activity.metadata
-                            })),
-                            requestLogs: requestLogs.map(log => ({
-                            endpoint: log.endpoint,
-                            timestamp: log.timestamp,
-                            timeAgo: getTimeAgo(log.timestamp),
-                            success: log.success,
-                            ipAddress: log.ipAddress,
-                            limitDeducted: log.limitDeducted
-                            }))
-                            });
-                            } catch (error) {
-                            console.error('Activities fetch error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                     app.get('/api/user/usage-stats', authenticate, async (req, res) => {
+app.get('/api/user/activities', authenticate, async (req, res) => {
+    try {
+        const activities = await Activity.find({ userId: req.user._id })
+            .sort({ timestamp: -1 })
+            .limit(50);
+
+        const requestLogs = await RequestLog.find({ userId: req.user._id })
+            .sort({ timestamp: -1 })
+            .limit(20);
+
+        res.json({
+            success: true,
+            activities: activities.map(activity => ({
+                type: activity.type,
+                description: activity.description,
+                timestamp: activity.timestamp,
+                timeAgo: getTimeAgo(activity.timestamp),
+                metadata: activity.metadata
+            })),
+            requestLogs: requestLogs.map(log => ({
+                endpoint: log.endpoint,
+                timestamp: log.timestamp,
+                timeAgo: getTimeAgo(log.timestamp),
+                success: log.success,
+                ipAddress: log.ipAddress,
+                limitDeducted: log.limitDeducted
+            }))
+        });
+    } catch (error) {
+        console.error('Activities fetch error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.get('/api/user/usage-stats', authenticate, async (req, res) => {
     try {
         const userId = req.user._id.toString();
 
-        // Hitung request hari ini untuk user ini
         const todayStart = new Date();
         todayStart.setHours(0, 0, 0, 0);
 
@@ -1183,7 +1181,6 @@ app.get('/api/user/profile', authenticate, async (req, res) => {
             timestamp: { $gte: todayStart }
         });
 
-        // Hitung total request untuk user ini
         const userTotalRequests = await RequestLog.countDocuments({
             userId
         });
@@ -1247,79 +1244,79 @@ app.get('/api/user/profile', authenticate, async (req, res) => {
     }
 });
 
-                            app.put('/api/user/profile', authenticate, async (req, res) => {
-                            try {
-                            const { username, profileUrl, customApiKey } = req.body;
-                            let updated = false;
-
-                            if (username && username !== req.user.username) {
-                            const existing = await User.findOne({ username });
-                            if (existing) {
-                            return res.status(400).json({ success: false, error: 'Username already taken' });
-                            }
-
-                            const oldUsername = req.user.username;
-                            req.user.username = username;
-                            updated = true;
-
-                            await logActivity(req.user._id, req.user.username, 'profile_updated', `Username changed from ${oldUsername} to ${username}`, {
-                            oldUsername,
-                            newUsername: username
-                            });
-                            }
-
-                            if (profileUrl !== undefined && profileUrl !== req.user.profileUrl) {
-                            req.user.profileUrl = profileUrl;
-                            updated = true;
-
-                            await logActivity(req.user._id, req.user.username, 'profile_updated', 'Profile URL updated', {
-                            newProfileUrl: profileUrl
-                            });
-                            }
-
-                            if (customApiKey && (req.user.premium || req.user.role === 'admin')) {
-                            const existing = await User.findOne({ apikey: customApiKey });
-                            if (existing && existing._id.toString() !== req.user._id.toString()) {
-                            return res.status(400).json({ success: false, error: 'API key already in use' });
-                            }
-
-                            const oldApiKey = req.user.apikey;
-                            req.user.apikey = customApiKey;
-                            updated = true;
-
-                            await logActivity(req.user._id, req.user.username, 'api_key_updated', 'Custom API key set', {
-                            oldApiKey,
-                            newApiKey: customApiKey
-                            });
-                            }
-
-                            if (updated) {
-                            await req.user.save();
-                            }
-
-                            res.json({ success: true, message: 'Profile updated successfully' });
-                            } catch (error) {
-                            console.error('Profile update error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.delete('/api/user/account', authenticate, async (req, res) => {
-                            try {
-                            if (req.user.role === 'admin') {
-                            return res.status(403).json({ success: false, error: 'Cannot delete admin account' });
-                            }
-
-                            await User.deleteOne({ _id: req.user._id });
-                            await Activity.deleteMany({ userId: req.user._id });
-                            res.json({ success: true, message: 'Account deleted successfully' });
-                            } catch (error) {
-                            console.error('Account deletion error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.get('/api/stats/all', async (req, res) => {
+app.put('/api/user/profile', authenticate, async (req, res) => {
+    try {
+        const { username, profileUrl, customApiKey } = req.body;
+        let updated = false;
+
+        if (username && username !== req.user.username) {
+            const existing = await User.findOne({ username });
+            if (existing) {
+                return res.status(400).json({ success: false, error: 'Username already taken' });
+            }
+
+            const oldUsername = req.user.username;
+            req.user.username = username;
+            updated = true;
+
+            await logActivity(req.user._id, req.user.username, 'profile_updated', `Username changed from ${oldUsername} to ${username}`, {
+                oldUsername,
+                newUsername: username
+            });
+        }
+
+        if (profileUrl !== undefined && profileUrl !== req.user.profileUrl) {
+            req.user.profileUrl = profileUrl;
+            updated = true;
+
+            await logActivity(req.user._id, req.user.username, 'profile_updated', 'Profile URL updated', {
+                newProfileUrl: profileUrl
+            });
+        }
+
+        if (customApiKey && (req.user.premium || req.user.role === 'admin')) {
+            const existing = await User.findOne({ apikey: customApiKey });
+            if (existing && existing._id.toString() !== req.user._id.toString()) {
+                return res.status(400).json({ success: false, error: 'API key already in use' });
+            }
+
+            const oldApiKey = req.user.apikey;
+            req.user.apikey = customApiKey;
+            updated = true;
+
+            await logActivity(req.user._id, req.user.username, 'api_key_updated', 'Custom API key set', {
+                oldApiKey,
+                newApiKey: customApiKey
+            });
+        }
+
+        if (updated) {
+            await req.user.save();
+        }
+
+        res.json({ success: true, message: 'Profile updated successfully' });
+    } catch (error) {
+        console.error('Profile update error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.delete('/api/user/account', authenticate, async (req, res) => {
+    try {
+        if (req.user.role === 'admin') {
+            return res.status(403).json({ success: false, error: 'Cannot delete admin account' });
+        }
+
+        await User.deleteOne({ _id: req.user._id });
+        await Activity.deleteMany({ userId: req.user._id });
+        res.json({ success: true, message: 'Account deleted successfully' });
+    } catch (error) {
+        console.error('Account deletion error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.get('/api/stats/all', async (req, res) => {
     try {
         const totalUsers = await User.countDocuments();
         const totalRequests = await RequestLog.countDocuments();
@@ -1426,692 +1423,690 @@ app.get('/api/user/profile', authenticate, async (req, res) => {
     }
 });
 
-                            app.post('/api/user/regenerate-key', authenticate, async (req, res) => {
-                            try {
-                            if (!req.user.premium && req.user.role !== 'admin') {
-                            return res.status(403).json({ success: false, error: 'Premium feature only' });
-                            }
+app.post('/api/user/regenerate-key', authenticate, async (req, res) => {
+    try {
+        if (!req.user.premium && req.user.role !== 'admin') {
+            return res.status(403).json({ success: false, error: 'Premium feature only' });
+        }
+
+        const oldApikey = req.user.apikey;
+
+        if (req.user.role === 'admin') {
+            req.user.apikey = 'DHX-M3SA';
+        } else {
+            req.user.apikey = generateApiKey();
+        }
+
+        await req.user.save();
+
+        await logActivity(req.user._id, req.user.username, 'api_key_generated', 'API key regenerated', {
+            oldApikey,
+            newApikey: req.user.apikey
+        });
+
+        res.json({ success: true, apikey: req.user.apikey });
+    } catch (error) {
+        console.error('API key regeneration error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.post('/api/user/redeem', authenticate, async (req, res) => {
+    try {
+        const { code } = req.body;
 
-                            const oldApikey = req.user.apikey;
+        if (!code) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Redeem code is required' 
+            });
+        }
 
-                            if (req.user.role === 'admin') {
-                            req.user.apikey = 'DHX-M3SA';
-                            } else {
-                            req.user.apikey = generateApiKey();
-                            }
+        const redeemCode = await RedeemCode.findOne({ code });
 
-                            await req.user.save();
+        if (!redeemCode) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'This redeem code is not available anymore or never exist' 
+            });
+        }
 
-                            await logActivity(req.user._id, req.user.username, 'api_key_generated', 'API key regenerated', {
-                            oldApikey,
-                            newApikey: req.user.apikey
-                            });
+        if (redeemCode.used) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'This redeem code has already been used' 
+            });
+        }
 
-                            res.json({ success: true, apikey: req.user.apikey });
-                            } catch (error) {
-                            console.error('API key regeneration error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
+        if (new Date() > redeemCode.codeExpired) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'This redeem code is not available anymore or never exist' 
+            });
+        }
 
-                            app.post('/api/user/redeem', authenticate, async (req, res) => {
-                            try {
-                            const { code } = req.body;
+        let benefits = [];
 
-                            if (!code) {
-                            return res.status(400).json({ 
-                            success: false, 
-                            error: 'Redeem code is required' 
-                            });
-                            }
+        if (redeemCode.type === 'limit' || redeemCode.type === 'both') {
+            req.user.limit += redeemCode.limitValue;
+            benefits.push(`+${redeemCode.limitValue} API requests`);
+        }
 
-                            const redeemCode = await RedeemCode.findOne({ code });
+        if (redeemCode.type === 'premium' || redeemCode.type === 'both') {
+            req.user.premium = true;
+            req.user.premiumExpiredAt = redeemCode.premiumExpired;
+            benefits.push(`Premium activated until ${redeemCode.premiumExpired.toLocaleString()}`);
+        }
 
-                            if (!redeemCode) {
-                            return res.status(400).json({ 
-                            success: false, 
-                            error: 'This redeem code is not available anymore or never exist' 
-                            });
-                            }
+        if (redeemCode.type === 'premium' && redeemCode.limitValue > 0) {
+            req.user.limit += redeemCode.limitValue;
+            benefits.push(`+${redeemCode.limitValue} API requests (bonus)`);
+        }
 
-                            if (redeemCode.used) {
-                            return res.status(400).json({ 
-                            success: false, 
-                            error: 'This redeem code has already been used' 
-                            });
-                            }
+        redeemCode.used = true;
+        redeemCode.usedBy = req.user.username;
 
-                            if (new Date() > redeemCode.codeExpired) {
-                            return res.status(400).json({ 
-                            success: false, 
-                            error: 'This redeem code is not available anymore or never exist' 
-                            });
-                            }
-
-                            let benefits = [];
-
-                            if (redeemCode.type === 'limit' || redeemCode.type === 'both') {
-                            req.user.limit += redeemCode.limitValue;
-                            benefits.push(`+${redeemCode.limitValue} API requests`);
-                            }
-
-                            if (redeemCode.type === 'premium' || redeemCode.type === 'both') {
-                            req.user.premium = true;
-                            req.user.premiumExpiredAt = redeemCode.premiumExpired;
-                            benefits.push(`Premium activated until ${redeemCode.premiumExpired.toLocaleString()}`);
-                            }
-
-                            if (redeemCode.type === 'premium' && redeemCode.limitValue > 0) {
-                            req.user.limit += redeemCode.limitValue;
-                            benefits.push(`+${redeemCode.limitValue} API requests (bonus)`);
-                            }
-
-                            redeemCode.used = true;
-                            redeemCode.usedBy = req.user.username;
-
-                            await req.user.save();
-                            await redeemCode.save();
-
-                            await logActivity(req.user._id, req.user.username, 'redeem_code_used', `Redeem code used: ${benefits.join(', ')}`, {
-                            code: code,
-                            type: redeemCode.type,
-                            benefits
-                            });
-
-                            res.json({ 
-                            success: true, 
-                            message: 'Redeem code used successfully',
-                            benefits 
-                            });
-                            } catch (error) {
-                            console.error('Redeem code error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.get('/api/admin/stats', authenticate, async (req, res) => {
-                            try {
-                            if (req.user.role !== 'admin') {
-                            return res.status(403).json({ success: false, error: 'Admin access required' });
-                            }
-
-                            const totalUsers = await User.countDocuments();
-                            const pendingUsers = await PendingVerification.countDocuments();
-                            const totalRequests = await RequestLog.countDocuments();
-
-                            const todayStart = new Date();
-                            todayStart.setHours(0, 0, 0, 0);
-
-                            const todayRequests = await RequestLog.countDocuments({
-                            timestamp: { $gte: todayStart }
-                            });
-
-                            res.json({
-                            success: true,
-                            stats: { 
-                            totalUsers, 
-                            pendingUsers, 
-                            totalRequests, 
-                            todayRequests 
-                            }
-                            });
-                            } catch (error) {
-                            console.error('Admin stats error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.get('/api/server-stats', async (req, res) => {
-                            try {
-
-                            const totalUsers = await User.countDocuments();
-                            const regularUsers = await User.countDocuments({ 
-                            $and: [
-                            { premium: false },
-                            { $or: [{ userRole: null }, { userRole: { $exists: false } }] }
-                            ]
-                            });
-                            const premiumUsers = await User.countDocuments({ premium: true });
-
-                            const cheapCount = await User.countDocuments({ userRole: 'cheap' });
-                            const premiumRoleCount = await User.countDocuments({ userRole: 'premium' });
-                            const vipCount = await User.countDocuments({ userRole: 'vip' });
-                            const supremeCount = await User.countDocuments({ userRole: 'supreme' });
-
-                            let dbSize = '0 MB';
-                            let storageSize = '0 GB';
-
-                            try {
-                            const dbStats = await mongoose.connection.db.stats();
-                            dbSize = (dbStats.dataSize / 1024 / 1024).toFixed(2) + ' MB';
-                            storageSize = (dbStats.storageSize / 1024 / 1024 / 1024).toFixed(2) + ' GB';
-                            } catch (dbError) {
-                            console.log('DB stats not available:', dbError.message);
-                            }
-
-                            const memUsage = process.memoryUsage();
-                            const ramUsage = (memUsage.heapUsed / 1024 / 1024).toFixed(2) + ' MB';
-
-                            const cpuUsage = process.cpuUsage();
-                            const cpuPercent = ((cpuUsage.user + cpuUsage.system) / 1000000).toFixed(2);
-
-                            res.json({
-                            success: true,
-                            stats: {
-                            totalUsers,
-                            regularUsers,
-                            premiumUsers,
-                            roleDistribution: {
-                            regular: regularUsers,
-                            cheap: cheapCount,
-                            premium: premiumRoleCount,
-                            vip: vipCount,
-                            supreme: supremeCount
-                            },
-                            database: {
-                            size: dbSize
-                            },
-                            system: {
-                            ramUsage: ramUsage,
-                            cpuUsage: cpuPercent,
-                            storageUsed: storageSize
-                            }
-                            }
-                            });
-                            } catch (error) {
-                            console.error('Server stats error:', error);
-                            res.status(500).json({ 
+        await req.user.save();
+        await redeemCode.save();
+
+        await logActivity(req.user._id, req.user.username, 'redeem_code_used', `Redeem code used: ${benefits.join(', ')}`, {
+            code: code,
+            type: redeemCode.type,
+            benefits
+        });
+
+        res.json({ 
+            success: true, 
+            message: 'Redeem code used successfully',
+            benefits 
+        });
+    } catch (error) {
+        console.error('Redeem code error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.get('/api/admin/stats', authenticate, async (req, res) => {
+    try {
+        if (req.user.role !== 'admin') {
+            return res.status(403).json({ success: false, error: 'Admin access required' });
+        }
+
+        const totalUsers = await User.countDocuments();
+        const pendingUsers = await PendingVerification.countDocuments();
+        const totalRequests = await RequestLog.countDocuments();
+
+        const todayStart = new Date();
+        todayStart.setHours(0, 0, 0, 0);
+
+        const todayRequests = await RequestLog.countDocuments({
+            timestamp: { $gte: todayStart }
+        });
+
+        res.json({
+            success: true,
+            stats: { 
+                totalUsers, 
+                pendingUsers, 
+                totalRequests, 
+                todayRequests 
+            }
+        });
+    } catch (error) {
+        console.error('Admin stats error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.get('/api/server-stats', async (req, res) => {
+    try {
+        const totalUsers = await User.countDocuments();
+        const regularUsers = await User.countDocuments({ 
+            $and: [
+                { premium: false },
+                { $or: [{ userRole: null }, { userRole: { $exists: false } }] }
+            ]
+        });
+        const premiumUsers = await User.countDocuments({ premium: true });
+
+        const cheapCount = await User.countDocuments({ userRole: 'cheap' });
+        const premiumRoleCount = await User.countDocuments({ userRole: 'premium' });
+        const vipCount = await User.countDocuments({ userRole: 'vip' });
+        const supremeCount = await User.countDocuments({ userRole: 'supreme' });
+
+        let dbSize = '0 MB';
+        let storageSize = '0 GB';
+
+        try {
+            const dbStats = await mongoose.connection.db.stats();
+            dbSize = (dbStats.dataSize / 1024 / 1024).toFixed(2) + ' MB';
+            storageSize = (dbStats.storageSize / 1024 / 1024 / 1024).toFixed(2) + ' GB';
+        } catch (dbError) {
+            console.log('DB stats not available:', dbError.message);
+        }
+
+        const memUsage = process.memoryUsage();
+        const ramUsage = (memUsage.heapUsed / 1024 / 1024).toFixed(2) + ' MB';
+
+        const cpuUsage = process.cpuUsage();
+        const cpuPercent = ((cpuUsage.user + cpuUsage.system) / 1000000).toFixed(2);
+
+        res.json({
+            success: true,
+            stats: {
+                totalUsers,
+                regularUsers,
+                premiumUsers,
+                roleDistribution: {
+                    regular: regularUsers,
+                    cheap: cheapCount,
+                    premium: premiumRoleCount,
+                    vip: vipCount,
+                    supreme: supremeCount
+                },
+                database: {
+                    size: dbSize
+                },
+                system: {
+                    ramUsage: ramUsage,
+                    cpuUsage: cpuPercent,
+                    storageUsed: storageSize
+                }
+            }
+        });
+    } catch (error) {
+        console.error('Server stats error:', error);
+        res.status(500).json({ 
+            success: false, 
+            error: 'Internal server error',
+            details: error.message 
+        });
+    }
+});
+
+app.post('/api/admin/set-role', authenticate, async (req, res) => {
+    try {
+        if (req.user.role !== 'admin') {
+            return res.status(403).json({ success: false, error: 'Admin access required' });
+        }
+
+        const { userId, roleName, customApiKey } = req.body;
+
+        if (!userId || !roleName) {
+            return res.status(400).json({ success: false, error: 'User ID and role name required' });
+        }
+
+        const user = await User.findById(userId);
+        if (!user) {
+            return res.status(404).json({ success: false, error: 'User not found' });
+        }
+
+        if (user.role === 'admin') {
+            return res.status(403).json({ success: false, error: 'Cannot modify admin users' });
+        }
+
+        const roleConfig = {
+            cheap: { limit: 500, premium: true },
+            premium: { limit: 1500, premium: true },
+            vip: { limit: 2500, premium: true },
+            supreme: { limit: 3000, premium: true }
+        };
+
+        if (!roleConfig[roleName]) {
+            return res.status(400).json({ success: false, error: 'Invalid role name' });
+        }
+
+        const expiresAt = new Date();
+        expiresAt.setMonth(expiresAt.getMonth() + 1);
+
+        let finalApiKey = user.apikey;
+        if (customApiKey && customApiKey.trim()) {
+            const existing = await User.findOne({ apikey: customApiKey });
+            if (existing && existing._id.toString() !== userId) {
+                return res.status(400).json({ success: false, error: 'API key already in use' });
+            }
+            user.apikey = customApiKey;
+            finalApiKey = customApiKey;
+        }
+
+        user.userRole = roleName;
+        user.userRoleExpiresAt = expiresAt;
+        user.limit = roleConfig[roleName].limit;
+        user.premium = roleConfig[roleName].premium;
+        user.premiumExpiredAt = expiresAt;
+
+        await user.save();
+
+        const userRole = await UserRole.findOne({ userId: user._id });
+        if (userRole) {
+            userRole.roleName = roleName;
+            userRole.customApiKey = customApiKey || null;
+            userRole.expiresAt = expiresAt;
+            userRole.createdBy = req.user.username;
+            await userRole.save();
+        } else {
+            await UserRole.create({
+                userId: user._id,
+                roleName,
+                customApiKey: customApiKey || null,
+                expiresAt,
+                createdBy: req.user.username
+            });
+        }
+
+        await logActivity(user._id, user.username, 'role_assigned', `Role ${roleName} assigned by admin`, {
+            roleName,
+            limit: user.limit,
+            expiresAt,
+            customApiKey: customApiKey || 'none',
+            assignedBy: req.user.username
+        });
+
+        res.json({ 
+            success: true, 
+            message: `Role ${roleName} assigned successfully`,
+            expiresAt,
+            newLimit: user.limit,
+            apiKey: user.apikey
+        });
+    } catch (error) {
+        console.error('Set role error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.get('/api/admin/users', authenticate, async (req, res) => {
+    try {
+        if (req.user.role !== 'admin') {
+            return res.status(403).json({ success: false, error: 'Admin access required' });
+        }
+
+        const users = await User.find({}, {
+            password: 0
+        }).sort({ createdAt: -1 });
+
+        res.json({
+            success: true,
+            users: users.map(user => ({
+                id: user._id,
+                username: user.username,
+                email: user.email,
+                role: user.role,
+                userRole: user.userRole,
+                userRoleExpiresAt: user.userRoleExpiresAt,
+                premium: user.premium,
+                premiumExpiredAt: user.premiumExpiredAt,
+                banned: user.banned,
+                tempBanned: user.tempBanned,
+                tempBanUntil: user.tempBanUntil,
+                tempBanReason: user.tempBanReason,
+                limit: user.limit,
+                requests: user.requests,
+                requestsToday: user.requestsToday,
+                createdAt: user.createdAt,
+                ipAddress: user.ipAddress
+            }))
+        });
+    } catch (error) {
+        console.error('Admin users fetch error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.post('/api/admin/temp-ban', authenticate, async (req, res) => {
+    try {
+        if (req.user.role !== 'admin') {
+            return res.status(403).json({ success: false, error: 'Admin access required' });
+        }
+
+        const { userId, banUntil, reason } = req.body;
+
+        if (!userId || !banUntil) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'User ID and ban until date are required' 
+            });
+        }
+
+        const user = await User.findById(userId);
+        if (!user) {
+            return res.status(404).json({ success: false, error: 'User not found' });
+        }
+
+        if (user.role === 'admin') {
+            return res.status(403).json({ success: false, error: 'Cannot ban admin users' });
+        }
+
+        const banUntilDate = new Date(banUntil);
+        if (banUntilDate <= new Date()) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Ban until date must be in the future' 
+            });
+        }
+
+        user.tempBanned = true;
+        user.tempBanUntil = banUntilDate;
+        user.tempBanReason = reason || 'No reason provided';
+
+        await user.save();
+
+        await logActivity(user._id, user.username, 'temp_banned', `User temporarily banned until ${banUntilDate.toLocaleString()}`, {
+            bannedBy: req.user.username,
+            banUntil: banUntilDate,
+            reason: user.tempBanReason
+        });
+
+        res.json({ 
+            success: true, 
+            message: `User ${user.username} temporarily banned until ${banUntilDate.toLocaleString()}` 
+        });
+    } catch (error) {
+        console.error('Temp ban error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.post('/api/admin/remove-temp-ban', authenticate, async (req, res) => {
+    try {
+        if (req.user.role !== 'admin') {
+            return res.status(403).json({ success: false, error: 'Admin access required' });
+        }
+
+        const { userId } = req.body;
+
+        if (!userId) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'User ID is required' 
+            });
+        }
+
+        const user = await User.findById(userId);
+        if (!user) {
+            return res.status(404).json({ success: false, error: 'User not found' });
+        }
+
+        user.tempBanned = false;
+        user.tempBanUntil = null;
+        user.tempBanReason = null;
+
+        await user.save();
+
+        await logActivity(user._id, user.username, 'ban_removed', 'Temporary ban removed by admin', {
+            removedBy: req.user.username
+        });
+
+        res.json({ 
+            success: true, 
+            message: `Temporary ban removed for user ${user.username}` 
+        });
+    } catch (error) {
+        console.error('Remove temp ban error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.post('/api/admin/redeem-code', authenticate, async (req, res) => {
+    try {
+        if (req.user.role !== 'admin') {
+            return res.status(403).json({ success: false, error: 'Admin access required' });
+        }
+
+        const { type, limitValue, codeExpired, premiumExpired } = req.body;
+
+        if (!type || !codeExpired) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Type and code expiration date are required' 
+            });
+        }
+
+        const codeExpiredDate = new Date(codeExpired);
+        if (codeExpiredDate <= new Date()) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Code expiration date must be in the future' 
+            });
+        }
+
+        if (type === 'limit' && (!limitValue || limitValue <= 0)) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Limit value must be greater than 0 for Limit Only type' 
+            });
+        }
+
+        if (type === 'premium' && !premiumExpired) {
+            return res.status(400).json({ 
+                success: false, 
+                error: 'Premium expiration date is required for Premium Only type' 
+            });
+        }
+
+        if (type === 'both') {
+            if (!limitValue || limitValue <= 0) {
+                return res.status(400).json({ 
+                    success: false, 
+                    error: 'Limit value must be greater than 0 for Both type' 
+                });
+            }
+            if (!premiumExpired) {
+                return res.status(400).json({ 
+                    success: false, 
+                    error: 'Premium expiration date is required for Both type' 
+                });
+            }
+        }
+
+        let premiumExpiredDate = null;
+        if (premiumExpired) {
+            premiumExpiredDate = new Date(premiumExpired);
+            if (premiumExpiredDate <= new Date()) {
+                return res.status(400).json({ 
+                    success: false, 
+                    error: 'Premium expiration date must be in the future' 
+                });
+            }
+        }
+
+        const code = crypto.randomBytes(4).toString('hex').toUpperCase();
+
+        const redeemCode = new RedeemCode({
+            code,
+            type,
+            limitValue: parseInt(limitValue) || 0,
+            codeExpired: codeExpiredDate,
+            premiumExpired: premiumExpiredDate,
+            createdBy: req.user.username
+        });
+
+        await redeemCode.save();
+
+        await logActivity(req.user._id, req.user.username, 'redeem_code_created', `Created redeem code: ${code}`, {
+            code,
+            type,
+            limitValue,
+            codeExpired: codeExpiredDate,
+            premiumExpired: premiumExpiredDate
+        });
+
+        res.json({ success: true, code });
+    } catch (error) {
+        console.error('Redeem code creation error:', error);
+        res.status(500).json({ success: false, error: 'Internal server error' });
+    }
+});
+
+app.use('/api', checkBanned);
+app.use('/api', apiRateLimit);
+
+let pluginsDir = path.join(__dirname, "plugins");
+let isJavaScriptFile = (fileName) => /\.js$/.test(fileName);
+global.plugins = {};
+
+const loadPlugins = () => {
+    if (!fs.existsSync(pluginsDir)) {
+        console.log('Plugins directory not found, creating...');
+        try {
+            fs.mkdirSync(pluginsDir, { recursive: true });
+        } catch (error) {
+            console.error('Error creating plugins directory:', error);
+        }
+        return;
+    }
+
+    for (let pluginFile of fs.readdirSync(pluginsDir).filter(isJavaScriptFile)) {
+        try {
+            delete require.cache[require.resolve(path.join(pluginsDir, pluginFile))];
+            global.plugins[pluginFile] = require(path.join(pluginsDir, pluginFile));
+        } catch (error) {
+            console.error(`Error loading plugin ${pluginFile}:`, error.message);
+            delete global.plugins[pluginFile];
+        }
+    }
+
+    console.log('Loaded plugins:', Object.keys(global.plugins));
+};
+
+global.reload = (event, filename) => {
+    if (/\.js$/.test(filename)) {
+        let fullFilePath = path.join(pluginsDir, filename);
+        if (fullFilePath in require.cache) {
+            delete require.cache[fullFilePath];
+            if (fs.existsSync(fullFilePath)) {
+                console.log(`♻️ Re-requiring plugin '${filename}'`);
+            } else {
+                console.log(`🗑️ Deleted plugin '${filename}'`);
+                return delete global.plugins[filename];
+            }
+        } else {
+            console.log(`🔁 Requiring new plugin '${filename}'`);
+        }
+
+        let errorCheck = syntaxError(fs.readFileSync(fullFilePath), filename);
+        if (errorCheck) {
+            console.error(`❌ Syntax error while loading '${filename}':\n${errorCheck}`);
+        } else {
+            try {
+                global.plugins[filename] = require(fullFilePath);
+                reloadHandler();
+            } catch (error) {
+                console.error(`Error loading plugin ${filename}:`, error);
+            } finally {
+                global.plugins = Object.fromEntries(Object.entries(global.plugins).sort(([a], [b]) => a.localeCompare(b)));
+            }
+        }
+    }
+};
+
+const reloadHandler = () => {
+    const routes = [];
+
+    Object.keys(global.plugins).forEach(file => {
+        const plugin = global.plugins[file];
+        if (plugin && plugin.enabled && plugin.routes && plugin.handler) {
+            plugin.routes.forEach(route => {
+                routes.push({ route, plugin, file });
+            });
+        }
+    });
+
+    routes.forEach(({ route, plugin, file }) => {
+        const method = (plugin.type || 'get').toLowerCase();
+        if (app[method] && typeof app[method] === 'function') {
+            app[method](`/${route}`, (req, res, next) => {
+                req.limitDeduction = plugin.limit || 1;
+                next();
+            }, validateApiKey, async (req, res) => {
+                const startTime = Date.now();
+                try {
+                    await plugin.handler(req, res);
+
+                    await RequestLog.create({
+                        userId: req.apiUser._id,
+                        username: req.apiUser.username,
+                        apikey: req.apiUser.apikey,
+                        endpoint: route,
+                        ipAddress: req.realIP,
+                        userAgent: req.get('User-Agent'),
+                        success: true,
+                        responseTime: Date.now() - startTime,
+                        limitDeducted: req.limitDeducted || 1
+                    });
+                } catch (error) {
+                    console.error(`Plugin ${plugin.name} error:`, error);
+
+                    await RequestLog.create({
+                        userId: req.apiUser._id,
+                        username: req.apiUser.username,
+                        apikey: req.apiUser.apikey,
+                        endpoint: route,
+                        ipAddress: req.realIP,
+                        userAgent: req.get('User-Agent'),
+                        success: false,
+                        responseTime: Date.now() - startTime,
+                        limitDeducted: req.limitDeducted || 1
+                    });
+
+                    if (!res.headersSent) {
+                        res.status(500).json({ 
                             success: false, 
-                            error: 'Internal server error',
-                            details: error.message 
-                            });
-                            }
-                            });
-
-                            app.post('/api/admin/set-role', authenticate, async (req, res) => {
-                            try {
-                            if (req.user.role !== 'admin') {
-                            return res.status(403).json({ success: false, error: 'Admin access required' });
-                            }
-
-                            const { userId, roleName, customApiKey } = req.body;
-
-                            if (!userId || !roleName) {
-                            return res.status(400).json({ success: false, error: 'User ID and role name required' });
-                            }
-
-                            const user = await User.findById(userId);
-                            if (!user) {
-                            return res.status(404).json({ success: false, error: 'User not found' });
-                            }
-
-                            if (user.role === 'admin') {
-                            return res.status(403).json({ success: false, error: 'Cannot modify admin users' });
-                            }
-
-                            const roleConfig = {
-                            cheap: { limit: 500, premium: true },
-                            premium: { limit: 1500, premium: true },
-                            vip: { limit: 2500, premium: true },
-                            supreme: { limit: 3000, premium: true }
-                            };
-
-                            if (!roleConfig[roleName]) {
-                            return res.status(400).json({ success: false, error: 'Invalid role name' });
-                            }
-
-                            const expiresAt = new Date();
-                            expiresAt.setMonth(expiresAt.getMonth() + 1);
-
-                            let finalApiKey = user.apikey;
-                            if (customApiKey && customApiKey.trim()) {
-                            const existing = await User.findOne({ apikey: customApiKey });
-                            if (existing && existing._id.toString() !== userId) {
-                            return res.status(400).json({ success: false, error: 'API key already in use' });
-                            }
-                            user.apikey = customApiKey;
-                            finalApiKey = customApiKey;
-                            }
-
-                            user.userRole = roleName;
-                            user.userRoleExpiresAt = expiresAt;
-                            user.limit = roleConfig[roleName].limit;
-                            user.premium = roleConfig[roleName].premium;
-                            user.premiumExpiredAt = expiresAt;
-
-                            await user.save();
-
-                            const userRole = await UserRole.findOne({ userId: user._id });
-                            if (userRole) {
-                            userRole.roleName = roleName;
-                            userRole.customApiKey = customApiKey || null;
-                            userRole.expiresAt = expiresAt;
-                            userRole.createdBy = req.user.username;
-                            await userRole.save();
-                            } else {
-                            await UserRole.create({
-                            userId: user._id,
-                            roleName,
-                            customApiKey: customApiKey || null,
-                            expiresAt,
-                            createdBy: req.user.username
-                            });
-                            }
-
-                            await logActivity(user._id, user.username, 'role_assigned', `Role ${roleName} assigned by admin`, {
-                            roleName,
-                            limit: user.limit,
-                            expiresAt,
-                            customApiKey: customApiKey || 'none',
-                            assignedBy: req.user.username
-                            });
-
-                            res.json({ 
-                            success: true, 
-                            message: `Role ${roleName} assigned successfully`,
-                            expiresAt,
-                            newLimit: user.limit,
-                            apiKey: user.apikey
-                            });
-                            } catch (error) {
-                            console.error('Set role error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.get('/api/admin/users', authenticate, async (req, res) => {
-                            try {
-                            if (req.user.role !== 'admin') {
-                            return res.status(403).json({ success: false, error: 'Admin access required' });
-                            }
-
-                            const users = await User.find({}, {
-                            password: 0
-                            }).sort({ createdAt: -1 });
-
-                            res.json({
-                            success: true,
-                            users: users.map(user => ({
-                            id: user._id,
-                            username: user.username,
-                            email: user.email,
-                            role: user.role,
-                            userRole: user.userRole,
-                            userRoleExpiresAt: user.userRoleExpiresAt,
-                            premium: user.premium,
-                            premiumExpiredAt: user.premiumExpiredAt,
-                            banned: user.banned,
-                            tempBanned: user.tempBanned,
-                            tempBanUntil: user.tempBanUntil,
-                            tempBanReason: user.tempBanReason,
-                            limit: user.limit,
-                            requests: user.requests,
-                            requestsToday: user.requestsToday,
-                            createdAt: user.createdAt,
-                            ipAddress: user.ipAddress
-                            }))
-                            });
-                            } catch (error) {
-                            console.error('Admin users fetch error:', error);
-                            res.status(500).json({ success: false, error: 'Internal server error' });
-                            }
-                            });
-
-                            app.post('/api/admin/temp-ban', authenticate, async (req, res) => {
-                            try {
-                            if (req.user.role !== 'admin') {
-                            return res.status(403).json({
-                                success: false, error: 'Admin access required' });
-                                        }
-
-                                        const { userId, banUntil, reason } = req.body;
-
-                                        if (!userId || !banUntil) {
-                                            return res.status(400).json({ 
-                                                success: false, 
-                                                error: 'User ID and ban until date are required' 
-                                            });
-                                        }
-
-                                        const user = await User.findById(userId);
-                                        if (!user) {
-                                            return res.status(404).json({ success: false, error: 'User not found' });
-                                        }
-
-                                        if (user.role === 'admin') {
-                                            return res.status(403).json({ success: false, error: 'Cannot ban admin users' });
-                                        }
-
-                                        const banUntilDate = new Date(banUntil);
-                                        if (banUntilDate <= new Date()) {
-                                            return res.status(400).json({ 
-                                                success: false, 
-                                                error: 'Ban until date must be in the future' 
-                                            });
-                                        }
-
-                                        user.tempBanned = true;
-                                        user.tempBanUntil = banUntilDate;
-                                        user.tempBanReason = reason || 'No reason provided';
-
-                                        await user.save();
-
-                                        await logActivity(user._id, user.username, 'temp_banned', `User temporarily banned until ${banUntilDate.toLocaleString()}`, {
-                                            bannedBy: req.user.username,
-                                            banUntil: banUntilDate,
-                                            reason: user.tempBanReason
-                                        });
-
-                                        res.json({ 
-                                            success: true, 
-                                            message: `User ${user.username} temporarily banned until ${banUntilDate.toLocaleString()}` 
-                                        });
-                                    } catch (error) {
-                                        console.error('Temp ban error:', error);
-                                        res.status(500).json({ success: false, error: 'Internal server error' });
-                                    }
-                                });
-
-                                app.post('/api/admin/remove-temp-ban', authenticate, async (req, res) => {
-                                    try {
-                                        if (req.user.role !== 'admin') {
-                                            return res.status(403).json({ success: false, error: 'Admin access required' });
-                                        }
-
-                                        const { userId } = req.body;
-
-                                        if (!userId) {
-                                            return res.status(400).json({ 
-                                                success: false, 
-                                                error: 'User ID is required' 
-                                            });
-                                        }
-
-                                        const user = await User.findById(userId);
-                                        if (!user) {
-                                            return res.status(404).json({ success: false, error: 'User not found' });
-                                        }
-
-                                        user.tempBanned = false;
-                                        user.tempBanUntil = null;
-                                        user.tempBanReason = null;
-
-                                        await user.save();
-
-                                        await logActivity(user._id, user.username, 'ban_removed', 'Temporary ban removed by admin', {
-                                            removedBy: req.user.username
-                                        });
-
-                                        res.json({ 
-                                            success: true, 
-                                            message: `Temporary ban removed for user ${user.username}` 
-                                        });
-                                    } catch (error) {
-                                        console.error('Remove temp ban error:', error);
-                                        res.status(500).json({ success: false, error: 'Internal server error' });
-                                    }
-                                });
-
-                                app.post('/api/admin/redeem-code', authenticate, async (req, res) => {
-                                    try {
-                                        if (req.user.role !== 'admin') {
-                                            return res.status(403).json({ success: false, error: 'Admin access required' });
-                                        }
-
-                                        const { type, limitValue, codeExpired, premiumExpired } = req.body;
-
-                                        if (!type || !codeExpired) {
-                                            return res.status(400).json({ 
-                                                success: false, 
-                                                error: 'Type and code expiration date are required' 
-                                            });
-                                        }
-
-                                        const codeExpiredDate = new Date(codeExpired);
-                                        if (codeExpiredDate <= new Date()) {
-                                            return res.status(400).json({ 
-                                                success: false, 
-                                                error: 'Code expiration date must be in the future' 
-                                            });
-                                        }
-
-                                        if (type === 'limit' && (!limitValue || limitValue <= 0)) {
-                                            return res.status(400).json({ 
-                                                success: false, 
-                                                error: 'Limit value must be greater than 0 for Limit Only type' 
-                                            });
-                                        }
-
-                                        if (type === 'premium' && !premiumExpired) {
-                                            return res.status(400).json({ 
-                                                success: false, 
-                                                error: 'Premium expiration date is required for Premium Only type' 
-                                            });
-                                        }
-
-                                        if (type === 'both') {
-                                            if (!limitValue || limitValue <= 0) {
-                                                return res.status(400).json({ 
-                                                    success: false, 
-                                                    error: 'Limit value must be greater than 0 for Both type' 
-                                                });
-                                            }
-                                            if (!premiumExpired) {
-                                                return res.status(400).json({ 
-                                                    success: false, 
-                                                    error: 'Premium expiration date is required for Both type' 
-                                                });
-                                            }
-                                        }
-
-                                        let premiumExpiredDate = null;
-                                        if (premiumExpired) {
-                                            premiumExpiredDate = new Date(premiumExpired);
-                                            if (premiumExpiredDate <= new Date()) {
-                                                return res.status(400).json({ 
-                                                    success: false, 
-                                                    error: 'Premium expiration date must be in the future' 
-                                                });
-                                            }
-                                        }
-
-                                        const code = crypto.randomBytes(4).toString('hex').toUpperCase();
-
-                                        const redeemCode = new RedeemCode({
-                                            code,
-                                            type,
-                                            limitValue: parseInt(limitValue) || 0,
-                                            codeExpired: codeExpiredDate,
-                                            premiumExpired: premiumExpiredDate,
-                                            createdBy: req.user.username
-                                        });
-
-                                        await redeemCode.save();
-
-                                        await logActivity(req.user._id, req.user.username, 'redeem_code_created', `Created redeem code: ${code}`, {
-                                            code,
-                                            type,
-                                            limitValue,
-                                            codeExpired: codeExpiredDate,
-                                            premiumExpired: premiumExpiredDate
-                                        });
-
-                                        res.json({ success: true, code });
-                                    } catch (error) {
-                                        console.error('Redeem code creation error:', error);
-                                        res.status(500).json({ success: false, error: 'Internal server error' });
-                                    }
-                                });
-
-                                app.use('/api', checkBanned);
-                                app.use('/api', apiRateLimit);
-
-                                let pluginsDir = path.join(__dirname, "plugins");
-                                let isJavaScriptFile = (fileName) => /\.js$/.test(fileName);
-                                global.plugins = {};
-
-                                const loadPlugins = () => {
-                                    if (!fs.existsSync(pluginsDir)) {
-                                        console.log('Plugins directory not found, creating...');
-                                        try {
-                                            fs.mkdirSync(pluginsDir, { recursive: true });
-                                        } catch (error) {
-                                            console.error('Error creating plugins directory:', error);
-                                        }
-                                        return;
-                                    }
-
-                                    for (let pluginFile of fs.readdirSync(pluginsDir).filter(isJavaScriptFile)) {
-                                        try {
-                                            delete require.cache[require.resolve(path.join(pluginsDir, pluginFile))];
-                                            global.plugins[pluginFile] = require(path.join(pluginsDir, pluginFile));
-                                        } catch (error) {
-                                            console.error(`Error loading plugin ${pluginFile}:`, error.message);
-                                            delete global.plugins[pluginFile];
-                                        }
-                                    }
-
-                                    console.log('Loaded plugins:', Object.keys(global.plugins));
-                                };
-
-                                global.reload = (event, filename) => {
-                                    if (/\.js$/.test(filename)) {
-                                        let fullFilePath = path.join(pluginsDir, filename);
-                                        if (fullFilePath in require.cache) {
-                                            delete require.cache[fullFilePath];
-                                            if (fs.existsSync(fullFilePath)) {
-                                                console.log(`♻️ Re-requiring plugin '${filename}'`);
-                                            } else {
-                                                console.log(`🗑️ Deleted plugin '${filename}'`);
-                                                return delete global.plugins[filename];
-                                            }
-                                        } else {
-                                            console.log(`🔁 Requiring new plugin '${filename}'`);
-                                        }
-
-                                        let errorCheck = syntaxError(fs.readFileSync(fullFilePath), filename);
-                                        if (errorCheck) {
-                                            console.error(`❌ Syntax error while loading '${filename}':\n${errorCheck}`);
-                                        } else {
-                                            try {
-                                                global.plugins[filename] = require(fullFilePath);
-                                                reloadHandler();
-                                            } catch (error) {
-                                                console.error(`Error loading plugin ${filename}:`, error);
-                                            } finally {
-                                                global.plugins = Object.fromEntries(Object.entries(global.plugins).sort(([a], [b]) => a.localeCompare(b)));
-                                            }
-                                        }
-                                    }
-                                };
-
-                                const reloadHandler = () => {
-                                    const routes = [];
-
-                                    Object.keys(global.plugins).forEach(file => {
-                                        const plugin = global.plugins[file];
-                                        if (plugin && plugin.enabled && plugin.routes && plugin.handler) {
-                                            plugin.routes.forEach(route => {
-                                                routes.push({ route, plugin, file });
-                                            });
-                                        }
-                                    });
-
-                                    routes.forEach(({ route, plugin, file }) => {
-                                        const method = (plugin.type || 'get').toLowerCase();
-                                        if (app[method] && typeof app[method] === 'function') {
-                                            app[method](`/${route}`, (req, res, next) => {
-                                                req.limitDeduction = plugin.limit || 1;
-                                                next();
-                                            }, validateApiKey, async (req, res) => {
-                                                const startTime = Date.now();
-                                                try {
-                                                    await plugin.handler(req, res);
-
-                                                    await RequestLog.create({
-                                                        userId: req.apiUser._id,
-                                                        username: req.apiUser.username,
-                                                        apikey: req.apiUser.apikey,
-                                                        endpoint: route,
-                                                        ipAddress: req.realIP,
-                                                        userAgent: req.get('User-Agent'),
-                                                        success: true,
-                                                        responseTime: Date.now() - startTime,
-                                                        limitDeducted: req.limitDeducted || 1
-                                                    });
-                                                } catch (error) {
-                                                    console.error(`Plugin ${plugin.name} error:`, error);
-
-                                                    await RequestLog.create({
-                                                        userId: req.apiUser._id,
-                                                        username: req.apiUser.username,
-                                                        apikey: req.apiUser.apikey,
-                                                        endpoint: route,
-                                                        ipAddress: req.realIP,
-                                                        userAgent: req.get('User-Agent'),
-                                                        success: false,
-                                                        responseTime: Date.now() - startTime,
-                                                        limitDeducted: req.limitDeducted || 1
-                                                    });
-
-                                                    if (!res.headersSent) {
-                                                        res.status(500).json({ 
-                                                            success: false, 
-                                                            error: 'Plugin execution failed' 
-                                                        });
-                                                    }
-                                                }
-                                            });
-                                            console.log(`✅ Registered route: ${method.toUpperCase()} /${route} from ${file}`);
-                                        }
-                                    });
-                                };
-
-                                Object.freeze(global.reload);
-                                fs.watch(pluginsDir, global.reload);
-
-                                setInterval(async () => {
-                                    const now = new Date();
-
-                                    if (now.getHours() === 0 && now.getMinutes() === 0) {
-                                        console.log('Running daily limit reset at midnight...');
-
-                                        try {
-                                            const users = await User.find({});
-
-                                            for (const user of users) {
-                                                await resetUserLimitIfNeeded(user);
-                                            }
-
-                                            console.log('Daily limit reset completed for all users');
-                                        } catch (error) {
-                                            console.error('Daily reset error:', error);
-                                        }
-                                    }
-                                }, 60000);
-
-                                initializeAdmin();
-                                loadPlugins();
-                                reloadHandler();
-
-                                app.use((err, req, res, next) => {
-                                    console.error('Unhandled error:', err);
-                                    res.status(500).json({ 
-                                        success: false, 
-                                        error: 'Internal server error' 
-                                    });
-                                });
-
-                                const PORT = process.env.PORT || 7860;
-                                app.listen(PORT, () => {
-                                    console.log(`DashX API Server running on port ${PORT}`);
-                                    console.log('=== ADMIN ACCOUNT INFO ===');
-                                    console.log('Username: HERXA');
-                                    console.log('Password: BTXHZ');
-                                    console.log('API Key: DHX-M3SA');
-                                    console.log('Limit: 9999');
-                                    console.log('=========================');
-                                    console.log('Database connected successfully');
-                                    console.log('Plugin auto-reload enabled');
-                                    console.log('Daily reset cron job started');
-                                });
+                            error: 'Plugin execution failed' 
+                        });
+                    }
+                }
+            });
+            console.log(`✅ Registered route: ${method.toUpperCase()} /${route} from ${file}`);
+        }
+    });
+};
+
+Object.freeze(global.reload);
+fs.watch(pluginsDir, global.reload);
+
+setInterval(async () => {
+    const now = new Date();
+
+    if (now.getHours() === 0 && now.getMinutes() === 0) {
+        console.log('Running daily limit reset at midnight...');
+
+        try {
+            const users = await User.find({});
+
+            for (const user of users) {
+                await resetUserLimitIfNeeded(user);
+            }
+
+            console.log('Daily limit reset completed for all users');
+        } catch (error) {
+            console.error('Daily reset error:', error);
+        }
+    }
+}, 60000);
+
+initializeAdmin();
+loadPlugins();
+reloadHandler();
+
+app.use((err, req, res, next) => {
+    console.error('Unhandled error:', err);
+    res.status(500).json({ 
+        success: false, 
+        error: 'Internal server error' 
+    });
+});
+
+const PORT = process.env.PORT || 7860;
+app.listen(PORT, () => {
+    console.log(`DashX API Server running on port ${PORT}`);
+    console.log('=== ADMIN ACCOUNT INFO ===');
+    console.log('Username: HERXA');
+    console.log('Password: BTXHZ');
+    console.log('API Key: DHX-M3SA');
+    console.log('Limit: 9999');
+    console.log('=========================');
+    console.log('Database connected successfully');
+    console.log('Plugin auto-reload enabled');
+    console.log('Daily reset cron job started');
+});