blockmine 1.22.0 → 1.23.1

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

@@ -1,5 +1,5 @@
 const express = require('express');
-const { authenticate, authorize } = require('../middleware/auth');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
 const { PrismaClient } = require('@prisma/client');
 const router = express.Router();
 const { pluginManager } = require('../../core/services');
@@ -27,7 +27,7 @@ router.get('/catalog', async (req, res) => {
     }
 });
 
-router.post('/check-updates/:botId', authenticate, authorize('plugin:update'), async (req, res) => {
+router.post('/check-updates/:botId', authenticateUniversal, authorize('plugin:update'), async (req, res) => {
     try {
         const botId = parseInt(req.params.botId);
         
@@ -43,7 +43,7 @@ router.post('/check-updates/:botId', authenticate, authorize('plugin:update'), a
     }
 });
 
-router.post('/update/:pluginId', authenticate, authorize('plugin:update'), async (req, res) => {
+router.post('/update/:pluginId', authenticateUniversal, authorize('plugin:update'), async (req, res) => {
     try {
         const pluginId = parseInt(req.params.pluginId);
         const { targetTag } = req.body; // Получаем тег из тела запроса (если указан)
@@ -54,7 +54,7 @@ router.post('/update/:pluginId', authenticate, authorize('plugin:update'), async
     }
 });
 
-router.post('/:id/clear-data', authenticate, authorize('plugin:settings:edit'), async (req, res) => {
+router.post('/:id/clear-data', authenticateUniversal, authorize('plugin:settings:edit'), async (req, res) => {
     try {
         const pluginId = parseInt(req.params.id);
         await pluginManager.clearPluginData(pluginId);
@@ -65,7 +65,21 @@ router.post('/:id/clear-data', authenticate, authorize('plugin:settings:edit'),
     }
 });
 
-router.get('/:id/info', authenticate, authorize('plugin:list'), async (req, res) => {
+router.post('/:id/reload', authenticateUniversal, authorize('plugin:settings:edit'), async (req, res) => {
+    try {
+        const pluginId = parseInt(req.params.id);
+        const updatedPlugin = await pluginManager.reloadLocalPlugin(pluginId);
+        res.status(200).json({
+            message: 'Плагин перезагружен, настройки сброшены.',
+            plugin: updatedPlugin
+        });
+    } catch (error) {
+        console.error(`[API Error] /plugins/:id/reload:`, error);
+        res.status(500).json({ error: error.message || 'Не удалось перезагрузить плагин.' });
+    }
+});
+
+router.get('/:id/info', authenticateUniversal, authorize('plugin:list'), async (req, res) => {
     try {
         const pluginId = parseInt(req.params.id);
         
@@ -115,7 +129,7 @@ router.get('/:id/info', authenticate, authorize('plugin:list'), async (req, res)
     }
 });
 
-router.get('/bot/:botId', authenticate, authorize('plugin:list'), async (req, res) => {
+router.get('/bot/:botId', authenticateUniversal, authorize('plugin:list'), async (req, res) => {
     try {
         const botId = parseInt(req.params.botId);
         
@@ -165,23 +179,23 @@ router.get('/bot/:botId', authenticate, authorize('plugin:list'), async (req, re
 router.get('/catalog/:name', async (req, res) => {
     try {
         const pluginName = req.params.name;
-        
+
         const catalogResponse = await fetch(getCacheBustedUrl(OFFICIAL_CATALOG_URL));
         if (!catalogResponse.ok) throw new Error(`Failed to fetch catalog, status: ${catalogResponse.status}`);
-        
+
         const catalog = await catalogResponse.json();
         const pluginInfo = catalog.find(p => p.name === pluginName);
-        
+
         if (!pluginInfo) {
             return res.status(404).json({ error: 'Плагин с таким именем не найден в каталоге.' });
         }
 
         let readmeContent = pluginInfo.description || 'Описание для этого плагина не предоставлено.';
-        
+
         try {
             const urlParts = new URL(pluginInfo.repoUrl);
             const pathParts = urlParts.pathname.split('/').filter(p => p);
-            
+
             if (pathParts.length >= 2) {
                 const owner = pathParts[0];
                 const repo = pathParts[1].replace('.git', '');
@@ -204,10 +218,10 @@ router.get('/catalog/:name', async (req, res) => {
         } catch (readmeError) {
             console.error(`[API] Не удалось загрузить README для ${pluginName}:`, readmeError.message);
         }
-        
+
         const finalPluginData = {
             ...pluginInfo,
-            fullDescription: readmeContent 
+            fullDescription: readmeContent
         };
 
         res.json(finalPluginData);
@@ -217,4 +231,147 @@ router.get('/catalog/:name', async (req, res) => {
     }
 });
 
+router.get('/bot/:botId/:pluginName/store', authenticateUniversal, authorize('plugin:list'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId);
+        const pluginName = req.params.pluginName;
+
+        const storeData = await prisma.pluginDataStore.findMany({
+            where: {
+                botId,
+                pluginName
+            },
+            select: {
+                key: true,
+                value: true,
+                createdAt: true,
+                updatedAt: true
+            }
+        });
+
+        const result = {};
+        storeData.forEach(item => {
+            try {
+                result[item.key] = JSON.parse(item.value);
+            } catch (e) {
+                result[item.key] = item.value;
+            }
+        });
+
+        res.json(result);
+    } catch (error) {
+        console.error(`[API Error] GET /plugins/bot/:botId/:pluginName/store:`, error);
+        res.status(500).json({ error: 'Не удалось получить данные store плагина.' });
+    }
+});
+
+router.get('/bot/:botId/:pluginName/store/:key', authenticateUniversal, authorize('plugin:list'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId);
+        const pluginName = req.params.pluginName;
+        const key = req.params.key;
+
+        const storeItem = await prisma.pluginDataStore.findUnique({
+            where: {
+                pluginName_botId_key: {
+                    pluginName,
+                    botId,
+                    key
+                }
+            },
+            select: {
+                value: true,
+                createdAt: true,
+                updatedAt: true
+            }
+        });
+
+        if (!storeItem) {
+            return res.status(404).json({ error: 'Ключ не найден в store.' });
+        }
+
+        let parsedValue;
+        try {
+            parsedValue = JSON.parse(storeItem.value);
+        } catch (e) {
+            parsedValue = storeItem.value;
+        }
+
+        res.json({
+            key,
+            value: parsedValue,
+            createdAt: storeItem.createdAt,
+            updatedAt: storeItem.updatedAt
+        });
+    } catch (error) {
+        console.error(`[API Error] GET /plugins/bot/:botId/:pluginName/store/:key:`, error);
+        res.status(500).json({ error: 'Не удалось получить значение из store.' });
+    }
+});
+
+router.put('/bot/:botId/:pluginName/store/:key', authenticateUniversal, authorize('plugin:settings:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId);
+        const pluginName = req.params.pluginName;
+        const key = req.params.key;
+        const { value } = req.body;
+
+        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+
+        const storeItem = await prisma.pluginDataStore.upsert({
+            where: {
+                pluginName_botId_key: {
+                    pluginName,
+                    botId,
+                    key
+                }
+            },
+            update: {
+                value: stringValue
+            },
+            create: {
+                pluginName,
+                botId,
+                key,
+                value: stringValue
+            }
+        });
+
+        res.json({
+            key,
+            value: value,
+            updatedAt: storeItem.updatedAt
+        });
+    } catch (error) {
+        console.error(`[API Error] PUT /plugins/bot/:botId/:pluginName/store/:key:`, error);
+        res.status(500).json({ error: 'Не удалось сохранить значение в store.' });
+    }
+});
+
+router.delete('/bot/:botId/:pluginName/store/:key', authenticateUniversal, authorize('plugin:settings:edit'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId);
+        const pluginName = req.params.pluginName;
+        const key = req.params.key;
+
+        await prisma.pluginDataStore.delete({
+            where: {
+                pluginName_botId_key: {
+                    pluginName,
+                    botId,
+                    key
+                }
+            }
+        });
+
+        res.json({ message: 'Значение удалено из store.' });
+    } catch (error) {
+        if (error.code === 'P2025') {
+            return res.status(404).json({ error: 'Ключ не найден в store.' });
+        }
+        console.error(`[API Error] DELETE /plugins/bot/:botId/:pluginName/store/:key:`, error);
+        res.status(500).json({ error: 'Не удалось удалить значение из store.' });
+    }
+});
+
 module.exports = router;

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

@@ -0,0 +1,130 @@
+const express = require('express');
+const router = express.Router();
+const { PrismaClient } = require('@prisma/client');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
+const prisma = new PrismaClient();
+
+router.use(authenticateUniversal);
+
+router.get('/', authorize('proxy:list'), async (req, res) => {
+    try {
+        const proxies = await prisma.proxy.findMany({
+            orderBy: { name: 'asc' },
+            include: {
+                _count: {
+                    select: { bots: true }
+                }
+            }
+        });
+        res.json({
+            items: proxies,
+            total: proxies.length
+        });
+    } catch (error) {
+        console.error("[API /api/proxies] Ошибка получения списка прокси:", error);
+        res.status(500).json({ error: 'Не удалось получить список прокси' });
+    }
+});
+
+router.get('/:id', authorize('proxy:list'), async (req, res) => {
+    try {
+        const proxyId = parseInt(req.params.id, 10);
+        const proxy = await prisma.proxy.findUnique({
+            where: { id: proxyId },
+            include: {
+                _count: {
+                    select: { bots: true }
+                }
+            }
+        });
+        if (!proxy) {
+            return res.status(404).json({ error: 'Прокси не найден' });
+        }
+        res.json(proxy);
+    } catch (error) {
+        console.error("[API /api/proxies/:id] Ошибка получения прокси:", error);
+        res.status(500).json({ error: 'Не удалось получить прокси' });
+    }
+});
+
+router.post('/', authorize('proxy:create'), async (req, res) => {
+    try {
+        const { name, type, host, port, username, password, note } = req.body;
+        if (!name || !host || !port) {
+            return res.status(400).json({ error: 'Имя, хост и порт прокси обязательны' });
+        }
+        if (type && !['socks5', 'http'].includes(type)) {
+            return res.status(400).json({ error: 'Тип прокси должен быть socks5 или http' });
+        }
+        const newProxy = await prisma.proxy.create({
+            data: {
+                name,
+                type: type || 'socks5',
+                host,
+                port: parseInt(port, 10),
+                username: username || null,
+                password: password || null,
+                note: note || null
+            },
+        });
+        res.status(201).json(newProxy);
+    } catch (error) {
+        if (error.code === 'P2002') return res.status(409).json({ error: 'Прокси с таким именем уже существует' });
+        console.error("[API /api/proxies] Ошибка создания прокси:", error);
+        res.status(500).json({ error: 'Не удалось создать прокси' });
+    }
+});
+
+router.put('/:id', authorize('proxy:create'), async (req, res) => {
+    try {
+        const proxyId = parseInt(req.params.id, 10);
+        if (isNaN(proxyId)) return res.status(400).json({ error: 'Некорректный ID прокси' });
+
+        const { name, type, host, port, username, password, note } = req.body;
+
+        if (type && !['socks5', 'http'].includes(type)) {
+            return res.status(400).json({ error: 'Тип прокси должен быть socks5 или http' });
+        }
+
+        const dataToUpdate = {};
+        if (name !== undefined) dataToUpdate.name = name;
+        if (type !== undefined) dataToUpdate.type = type;
+        if (host !== undefined) dataToUpdate.host = host;
+        if (port !== undefined && port !== '') dataToUpdate.port = parseInt(port, 10);
+        if (username !== undefined) dataToUpdate.username = username || null;
+        if (password !== undefined) dataToUpdate.password = password || null;
+        if (note !== undefined) dataToUpdate.note = note || null;
+
+        Object.keys(dataToUpdate).forEach(k => { if (dataToUpdate[k] === undefined) delete dataToUpdate[k]; });
+
+        if (dataToUpdate.name) {
+            const existing = await prisma.proxy.findFirst({ where: { name: dataToUpdate.name, id: { not: proxyId } } });
+            if (existing) return res.status(409).json({ error: 'Прокси с таким именем уже существует' });
+        }
+
+        const updated = await prisma.proxy.update({ where: { id: proxyId }, data: dataToUpdate });
+        res.json(updated);
+    } catch (error) {
+        console.error('[API /api/proxies] Ошибка обновления прокси:', error);
+        res.status(500).json({ error: 'Не удалось обновить прокси' });
+    }
+});
+
+router.delete('/:id', authorize('proxy:delete'), async (req, res) => {
+    try {
+        const proxyId = parseInt(req.params.id, 10);
+
+        const botsUsingProxy = await prisma.bot.count({ where: { proxyId } });
+        if (botsUsingProxy > 0) {
+            return res.status(400).json({ error: `Нельзя удалить прокси, так как он используется ${botsUsingProxy} ботом(ами).` });
+        }
+
+        await prisma.proxy.delete({ where: { id: proxyId } });
+        res.status(204).send();
+    } catch (error) {
+        console.error('[API /api/proxies] Ошибка удаления прокси:', error);
+        res.status(500).json({ error: 'Не удалось удалить прокси' });
+    }
+});
+
+module.exports = router;

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

@@ -1,8 +1,12 @@
 const express = require('express');
+const { authenticate } = require('../middleware/auth');
 const router = express.Router();
 const { PrismaClient } = require('@prisma/client');
 const prisma = new PrismaClient();
 
+// Все роуты требуют аутентификации
+router.use(authenticate);
+
 router.get('/', async (req, res) => {
   const { query } = req.query;
 

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

@@ -1,21 +1,38 @@
 const express = require('express');
 const router = express.Router();
 const { PrismaClient } = require('@prisma/client');
-const { authenticate, authorize } = require('../middleware/auth');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
 const prisma = new PrismaClient();
 
-router.use(authenticate);
+router.use(authenticateUniversal);
 
 router.get('/', authorize('server:list'), async (req, res) => {
     try {
         const servers = await prisma.server.findMany({ orderBy: { name: 'asc' } });
-        res.json(servers);
+        res.json({
+            items: servers,
+            total: servers.length
+        });
     } catch (error) {
         console.error("[API /api/servers] Ошибка получения списка серверов:", error);
         res.status(500).json({ error: 'Не удалось получить список серверов' });
     }
 });
 
+router.get('/:id', authorize('server:list'), async (req, res) => {
+    try {
+        const serverId = parseInt(req.params.id, 10);
+        const server = await prisma.server.findUnique({ where: { id: serverId } });
+        if (!server) {
+            return res.status(404).json({ error: 'Сервер не найден' });
+        }
+        res.json(server);
+    } catch (error) {
+        console.error("[API /api/servers/:id] Ошибка получения сервера:", error);
+        res.status(500).json({ error: 'Не удалось получить сервер' });
+    }
+});
+
 router.post('/', authorize('server:create'), async (req, res) => {
     try {
         const { name, host, port, version } = req.body;

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

@@ -1,10 +1,15 @@
 const express = require('express');
+const { authenticate, authorize } = require('../middleware/auth');
 const router = express.Router();
 const { PrismaClient } = require('@prisma/client');
 const PluginService = require('../../core/PluginService');
 
 const prisma = new PrismaClient();
 
+// Все роуты требуют аутентификации и прав администратора
+router.use(authenticate);
+router.use(authorize('system:settings'));
+
 router.get('/plugin-directories', async (req, res) => {
     try {
         const setting = await prisma.setting.findUnique({

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

@@ -1,5 +1,5 @@
 const express = require('express');
-const { authenticate } = require('../middleware/auth');
+const { authenticate, authenticateUniversal } = require('../middleware/auth');
 const os = require('os');
 const pidusage = require('pidusage');
 const rateLimit = require('express-rate-limit');
@@ -27,7 +27,7 @@ function getSystemCpuUsage() {
  * @desc Получить информацию о здоровье системы
  * @access Требуется авторизация
  */
-router.get('/health', authenticate, async (req, res) => {
+router.get('/health', authenticateUniversal, async (req, res) => {
     try {
         const uptime = process.uptime();
         const serverUptime = (Date.now() - serverStartTime) / 1000;
@@ -135,7 +135,7 @@ router.get('/health', authenticate, async (req, res) => {
  * @desc Получить статистику системы
  * @access Требуется авторизация
  */
-router.get('/stats', authenticate, async (req, res) => {
+router.get('/stats', authenticateUniversal, async (req, res) => {
     try {
         const prisma = req.app.get('prisma') || require('../../lib/prisma');
         

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

@@ -0,0 +1,131 @@
+const express = require('express');
+const { authenticate, authorize } = require('../middleware/auth');
+const router = express.Router();
+const { getTraceCollector } = require('../../core/services/TraceCollectorService');
+
+router.use(authenticate);
+
+/**
+ * GET /api/traces/:botId
+ * Получить трассировки для бота
+ */
+router.get('/:botId', authorize('management:view'), async (req, res) => {
+  try {
+    const botId = parseInt(req.params.botId);
+    const { limit, status, graphId } = req.query;
+
+    const options = {
+      limit: limit ? parseInt(limit) : 150,
+      status: status || null,
+      graphId: graphId ? parseInt(graphId) : null,
+    };
+
+    const traceCollector = getTraceCollector();
+    const traces = traceCollector.getTracesForBot(botId, options);
+
+    res.json({
+      success: true,
+      traces,
+    });
+  } catch (error) {
+    console.error('[API /traces/:botId] Ошибка:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+});
+
+/**
+ * GET /api/traces/:botId/:traceId
+ * Получить конкретную трассировку по ID
+ */
+router.get('/:botId/:traceId', authorize('management:view'), async (req, res) => {
+  try {
+    const { traceId } = req.params;
+
+    const traceCollector = getTraceCollector();
+    let trace = traceCollector.getTrace(traceId);
+
+    // Если не нашли в памяти, пытаемся загрузить из БД
+    if (!trace) {
+      trace = await traceCollector.loadTraceFromDb(traceId);
+    }
+
+    if (!trace) {
+      return res.status(404).json({
+        success: false,
+        error: 'Трассировка не найдена',
+      });
+    }
+
+    res.json({
+      success: true,
+      trace,
+    });
+  } catch (error) {
+    console.error('[API /traces/:botId/:traceId] Ошибка:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+});
+
+/**
+ * GET /api/traces/:botId/graph/:graphId/last
+ * Получить последнюю трассировку для графа
+ * Query params: eventType (опционально) - фильтр по типу события
+ */
+router.get('/:botId/graph/:graphId/last', authorize('management:view'), async (req, res) => {
+  try {
+    const botId = parseInt(req.params.botId);
+    const graphId = parseInt(req.params.graphId);
+    const { eventType } = req.query;
+
+    const traceCollector = getTraceCollector();
+    const trace = await traceCollector.getLastTraceForGraph(botId, graphId, eventType);
+
+    if (!trace) {
+      return res.status(404).json({
+        success: false,
+        error: 'Трассировка не найдена',
+      });
+    }
+
+    res.json({
+      success: true,
+      trace,
+    });
+  } catch (error) {
+    console.error('[API /traces/:botId/graph/:graphId/last] Ошибка:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+});
+
+/**
+ * GET /api/traces/stats
+ * Получить статистику трассировок
+ */
+router.get('/stats', authorize('management:view'), async (req, res) => {
+  try {
+    const traceCollector = getTraceCollector();
+    const stats = traceCollector.getStats();
+
+    res.json({
+      success: true,
+      stats,
+    });
+  } catch (error) {
+    console.error('[API /traces/stats] Ошибка:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+});
+
+module.exports = router;

package/backend/src/config/debug.config.js

@@ -0,0 +1,36 @@
+/**
+ * Конфигурация для Live Debug системы
+ */
+
+module.exports = {
+    // Таймауты (в миллисекундах)
+    BREAKPOINT_TIMEOUT: 30000,        // 30 секунд - максимальное время ожидания breakpoint response
+    STEP_MODE_TIMEOUT: 30000,         // 30 секунд - максимальное время ожидания step mode response
+    TRACE_CLEANUP_DELAY: 5000,        // 5 секунд - задержка перед удалением completed trace
+
+    // Лимиты
+    MAX_TRACE_STEPS: 10000,           // Максимальное количество шагов в одном trace
+    MAX_COMPLETED_TRACES: 100,        // Максимальное количество хранимых completed traces
+    MAX_OUTPUT_LENGTH: 30000,         // Максимальная длина output при передаче через IPC
+
+    // IPC Message Types (для type safety)
+    IPC_TYPES: {
+        EXECUTE_EVENT_GRAPH: 'execute_event_graph',
+        EXECUTE_HANDLER: 'execute_handler',
+        EXECUTE_COMMAND_REQUEST: 'execute_command_request',
+
+        DEBUG_CHECK_BREAKPOINT: 'debug:check_breakpoint',
+        DEBUG_CHECK_STEP_MODE: 'debug:check_step_mode',
+        DEBUG_BREAKPOINT_RESPONSE: 'debug:breakpoint_response',
+
+        TRACE_COMPLETED: 'trace:completed',
+        TRACE_ERROR: 'trace:error',
+    },
+
+    // Debug Session
+    DEBUG_SESSION_IDLE_TIMEOUT: 300000, // 5 минут - таймаут неактивной debug сессии
+
+    // Trace Storage
+    TRACE_RETENTION_TIME: 3600000,    // 1 час - время хранения completed traces
+    ACTIVE_TRACE_MAX_AGE: 600000,     // 10 минут - максимальный возраст active trace
+};