blockmine 1.16.1 → 1.16.3

package/backend/src/api/routes/logs.js

@@ -0,0 +1,245 @@
+const express = require('express');
+const router = express.Router();
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const debugOnly = (req, res, next) => {
+    if (process.env.DEBUG === 'true' || process.env.NODE_ENV === 'development') {
+        next();
+    } else {
+        res.status(403).json({
+            success: false,
+            error: 'Доступ к логам разрешен только в режиме отладки'
+        });
+    }
+};
+
+let logBuffer = [];
+const MAX_LOG_BUFFER = 1000;
+
+const originalConsoleLog = console.log;
+const originalConsoleError = console.error;
+const originalConsoleWarn = console.warn;
+const originalConsoleInfo = console.info;
+
+function addToLogBuffer(level, ...args) {
+    const timestamp = new Date().toISOString();
+    const message = args.map(arg => 
+        typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+    ).join(' ');
+    
+    const logEntry = {
+        timestamp,
+        level,
+        message,
+        pid: process.pid
+    };
+    
+    logBuffer.push(logEntry);
+    
+    if (logBuffer.length > MAX_LOG_BUFFER) {
+        logBuffer = logBuffer.slice(-MAX_LOG_BUFFER);
+    }
+}
+
+console.log = (...args) => {
+    addToLogBuffer('log', ...args);
+    originalConsoleLog.apply(console, args);
+};
+
+console.error = (...args) => {
+    addToLogBuffer('error', ...args);
+    originalConsoleError.apply(console, args);
+};
+
+console.warn = (...args) => {
+    addToLogBuffer('warn', ...args);
+    originalConsoleWarn.apply(console, args);
+};
+
+console.info = (...args) => {
+    addToLogBuffer('info', ...args);
+    originalConsoleInfo.apply(console, args);
+};
+
+router.get('/', debugOnly, (req, res) => {
+    try {
+        const { 
+            level, 
+            limit = 100, 
+            offset = 0, 
+            search,
+            from,
+            to 
+        } = req.query;
+        
+        let filteredLogs = [...logBuffer];
+        
+        if (level && level !== 'all') {
+            filteredLogs = filteredLogs.filter(log => log.level === level);
+        }
+        
+        if (search) {
+            const searchLower = search.toLowerCase();
+            filteredLogs = filteredLogs.filter(log => 
+                log.message.toLowerCase().includes(searchLower)
+            );
+        }
+        
+        if (from) {
+            const fromDate = new Date(from);
+            filteredLogs = filteredLogs.filter(log => 
+                new Date(log.timestamp) >= fromDate
+            );
+        }
+        
+        if (to) {
+            const toDate = new Date(to);
+            filteredLogs = filteredLogs.filter(log => 
+                new Date(log.timestamp) <= toDate
+            );
+        }
+        
+        const total = filteredLogs.length;
+        const logs = filteredLogs
+            .slice(parseInt(offset), parseInt(offset) + parseInt(limit))
+            .reverse();
+        
+        res.json({
+            success: true,
+            data: {
+                logs,
+                pagination: {
+                    total,
+                    limit: parseInt(limit),
+                    offset: parseInt(offset),
+                    hasMore: parseInt(offset) + parseInt(limit) < total
+                }
+            }
+        });
+        
+    } catch (error) {
+        console.error('Ошибка при получении логов:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Ошибка при получении логов'
+        });
+    }
+});
+
+router.delete('/', debugOnly, (req, res) => {
+    try {
+        logBuffer = [];
+        res.json({
+            success: true,
+            message: 'Логи очищены'
+        });
+    } catch (error) {
+        console.error('Ошибка при очистке логов:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Ошибка при очистке логов'
+        });
+    }
+});
+
+router.get('/stats', debugOnly, (req, res) => {
+    try {
+        const stats = {
+            total: logBuffer.length,
+            byLevel: {
+                log: logBuffer.filter(log => log.level === 'log').length,
+                error: logBuffer.filter(log => log.level === 'error').length,
+                warn: logBuffer.filter(log => log.level === 'warn').length,
+                info: logBuffer.filter(log => log.level === 'info').length
+            },
+            timeRange: {
+                oldest: logBuffer.length > 0 ? logBuffer[0].timestamp : null,
+                newest: logBuffer.length > 0 ? logBuffer[logBuffer.length - 1].timestamp : null
+            }
+        };
+        
+        res.json({
+            success: true,
+            data: stats
+        });
+        
+    } catch (error) {
+        console.error('Ошибка при получении статистики логов:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Ошибка при получении статистики логов'
+        });
+    }
+});
+
+router.get('/stream', debugOnly, (req, res) => {
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Headers': 'Cache-Control'
+    });
+    
+    const sendLog = (log) => {
+        res.write(`data: ${JSON.stringify(log)}\n\n`);
+    };
+    
+    const recentLogs = logBuffer.slice(-10);
+    recentLogs.forEach(sendLog);
+    
+    const logHandler = (log) => {
+        sendLog(log);
+    };
+    
+    if (!global.logStreamHandlers) {
+        global.logStreamHandlers = [];
+    }
+    global.logStreamHandlers.push(logHandler);
+    
+    req.on('close', () => {
+        const index = global.logStreamHandlers.indexOf(logHandler);
+        if (index > -1) {
+            global.logStreamHandlers.splice(index, 1);
+        }
+    });
+});
+
+function broadcastLog(log) {
+    if (global.logStreamHandlers) {
+        global.logStreamHandlers.forEach(handler => {
+            try {
+                handler(log);
+            } catch (error) {
+                console.error('Ошибка при отправке лога клиенту:', error);
+            }
+        });
+    }
+}
+
+const originalAddToLogBuffer = addToLogBuffer;
+addToLogBuffer = function(level, ...args) {
+    const timestamp = new Date().toISOString();
+    const message = args.map(arg => 
+        typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+    ).join(' ');
+    
+    const logEntry = {
+        timestamp,
+        level,
+        message,
+        pid: process.pid
+    };
+    
+    logBuffer.push(logEntry);
+    
+    if (logBuffer.length > MAX_LOG_BUFFER) {
+        logBuffer = logBuffer.slice(-MAX_LOG_BUFFER);
+    }
+    
+    broadcastLog(logEntry);
+};
+
+module.exports = router; 

package/backend/src/core/BotManager.js

@@ -335,6 +335,10 @@ class BotManager {
         getIO().emit('bot:log', { botId, log: logEntry });
     }
 
+    getBotLogs(botId) {
+        return this.logCache.get(botId) || [];
+    }
+
     async startBot(botConfig) {
         if (this.bots.has(botConfig.id) && !this.bots.get(botConfig.id).killed) {
             this.appendLog(botConfig.id, `[SYSTEM-ERROR] Попытка повторного запуска. Запуск отменен.`);
@@ -765,6 +769,23 @@ class BotManager {
         return { success: true };
     }
 
+    invalidateAllUserCache(botId) {
+        for (const [cacheKey, user] of UserService.cache.entries()) {
+            if (cacheKey.startsWith(`${botId}:`)) {
+                UserService.cache.delete(cacheKey);
+            }
+        }
+        console.log(`[BotManager] Кэш пользователей очищен для бота ${botId}`);
+        
+        const child = this.bots.get(botId);
+        if (child && !child.killed) {
+            child.send({ type: 'invalidate_all_user_cache' });
+            console.log(`[BotManager] Отправлено сообщение об очистке кэша в процесс бота ${botId}`);
+        }
+        
+        return { success: true };
+    }
+
     async getPlayerList(botId) {
         const PLAYER_LIST_CACHE_TTL = 2000;
 
@@ -837,6 +858,7 @@ class BotManager {
         if (child && !child.killed) {
             child.send({ type: 'plugins:reload' });
             console.log(`[BotManager] Sent plugins:reload to bot process ${botId}`);
+            const { getIO } = require('../real-time/socketHandler');
             getIO().emit('bot:plugins_reloaded', { botId });
             return { success: true, message: 'Команда на перезагрузку плагинов отправлена.' };
         }

package/backend/src/core/BotProcess.js

@@ -699,6 +699,15 @@ process.on('message', async (message) => {
         if (message.username && bot && bot.config) {
             UserService.clearCache(message.username, bot.config.id);
         }
+    } else if (message.type === 'invalidate_all_user_cache') {
+        if (bot && bot.config) {
+            for (const [cacheKey, user] of UserService.cache.entries()) {
+                if (cacheKey.startsWith(`${bot.config.id}:`)) {
+                    UserService.cache.delete(cacheKey);
+                }
+            }
+            sendLog(`[BotProcess] Кэш пользователей очищен для бота ${bot.config.id}`);
+        }
     } else if (message.type === 'handle_permission_error') {
         const { commandName, username, typeChat } = message;
         const commandInstance = bot.commands.get(commandName);
@@ -787,10 +796,6 @@ process.on('SIGINT', () => {
     setTimeout(() => process.exit(0), 100);
 });
 
-// process.on('SIGKILL', () => {
-//     sendLog('[System] Получен сигнал SIGKILL. Принудительное завершение...');
-//     process.exit(0);
-// });
 
 function serializeEntity(entity) {
     if (!entity) return null;

package/backend/src/server.js

@@ -20,6 +20,7 @@ const eventGraphsRouter = require('./api/routes/eventGraphs');
 const TaskScheduler = require('./core/TaskScheduler');
 const panelRoutes = require('./api/routes/panel');
 const changelogRoutes = require('./api/routes/changelog');
+const logsRoutes = require('./api/routes/logs');
 
 const app = express();
 const server = http.createServer(app);
@@ -61,6 +62,7 @@ app.use('/api/permissions', permissionsRoutes);
 app.use('/api/search', searchRoutes);
 app.use('/api/panel', panelRoutes);
 app.use('/api/changelog', changelogRoutes);
+app.use('/api/logs', logsRoutes);
 
 app.use(express.static(frontendPath));