blockmine 1.6.3 → 1.13.0

package/.husky/commit-msg

@@ -0,0 +1 @@
+npx --no -- commitlint --edit $1

package/.husky/pre-commit

@@ -0,0 +1 @@
+# npm test

package/.versionrc.json

@@ -0,0 +1,17 @@
+{
+  "header": "# История версий\n\n",
+  "types": [
+    { "type": "feat",     "section": "✨ Новые возможности" },
+    { "type": "fix",      "section": "🐛 Исправления" },
+    { "type": "perf",     "section": "⚡ Производительность" },
+    { "type": "refactor", "section": "🛠 Рефакторинг" },
+    { "type": "build",    "section": "🏗 Сборка" },
+    { "type": "chore",    "hidden": true },
+    { "type": "docs",     "hidden": true },
+    { "type": "style",    "hidden": true },
+    { "type": "test",     "hidden": true }
+  ],
+  "writerOpts": {
+    "commitPartial": "* {{#if scope}}**{{scope}}:** {{/if}}{{#if subject}}{{subject}}{{/if}} ([{{shortHash}}](https://github.com/blockmineJS/blockmine/commit/{{hash}})) - _{{authorName}}_\n"
+  }
+}

package/CHANGELOG.md

@@ -0,0 +1,36 @@
+# История версий
+
+
+## [1.13.0](https://github.com/blockmineJS/blockmine/compare/v1.12.0...v1.13.0) (2025-07-18)
+
+
+### ✨ Новые возможности
+
+* возможность сбрасывать пароль рут аккаунта ([e23181d](https://github.com/blockmineJS/blockmine/commit/e23181d29dbe730ff882d654b8ec0e80a1f007bc))
+
+## [1.12.0](https://github.com/blockmineJS/blockmine/compare/v1.11.5...v1.12.0) (2025-07-18)
+
+
+### ✨ Новые возможности
+
+* плагины теперь могу делать свои странички что бы делать какие либо действия в панели ([2664c3c](https://github.com/blockmineJS/blockmine/commit/2664c3c1a02db4e650f8a5be7e96ebbcfe3ab0bb))
+* плагины теперь могуть хранить ингформацию в базе данных ([edb12fd](https://github.com/blockmineJS/blockmine/commit/edb12fd365603bc72c82ad159ffd734cec265dcb))
+
+
+### 🛠 Рефакторинг
+
+* очередь сообщений. теперь может принимать в себя массив и задержкой отправляет сообщения ([4f193c9](https://github.com/blockmineJS/blockmine/commit/4f193c9c1c76a53ff655e63f520aa83e16c35126))
+
+### [1.11.1](https://github.com/blockmineJS/blockmine/compare/v1.11.0...v1.11.1) (2025-07-17)
+
+
+### 🐛 Исправления
+
+* test2 ([3ada981](https://github.com/blockmineJS/blockmine/commit/3ada981363de10b9d38cf34f5eb3a00ef527d6b2))
+
+## 1.11.0 (2025-07-17)
+
+
+### ✨ Новые возможности
+
+* **commands:** Редизайн интерфейса управления командами ([f520049](https://github.com/blockmineJS/blockmine/commit/f520049196dad133ea7957398d512c0334e85917))

package/README.md

@@ -33,7 +33,7 @@
     <td align="center">
       <p><strong>Управление командами</strong></p>
       <img src="./image/3.png" alt="Скриншот страницы управления" width="100%">
-      <em>Настраивайте права, алиасы и кулдауны для каждой команды.</em>
+      <em>Настраивайте права алиасы и кулдауны для каждой команды.</em>
     </td>
   </tr>
 </table>

package/backend/package.json

@@ -19,6 +19,7 @@
   },
   "dependencies": {
     "express-validator": "^7.2.1",
+
     "pino": "^9.7.0",
     "pino-pretty": "^13.0.0"
   }

package/backend/prisma/migrations/20250718181335_add_plugin_data_store/migration.sql

@@ -0,0 +1,14 @@
+-- CreateTable
+CREATE TABLE "PluginDataStore" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "pluginName" TEXT NOT NULL,
+    "botId" INTEGER NOT NULL,
+    "key" TEXT NOT NULL,
+    "value" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "PluginDataStore_botId_fkey" FOREIGN KEY ("botId") REFERENCES "Bot" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "PluginDataStore_pluginName_botId_key_key" ON "PluginDataStore"("pluginName", "botId", "key");

package/backend/prisma/schema.prisma

@@ -38,6 +38,7 @@ model Bot {
   permissions      Permission[]
   commands         Command[]
   eventGraphs      EventGraph[]
+  pluginData       PluginDataStore[]
 
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
@@ -198,7 +199,21 @@ model PanelRole {
   name        String   @unique 
   
   // Храним права как джсон строку.  SQLite не поддерживает массивы.
-  // Пример: '["bot:create", "bot:delete", "user:manage"]'
+  // Пример: '[\"bot:create\", \"bot:delete\", \"user:manage\"]'
   permissions String   @default("[]") 
   users       PanelUser[]
-}
+}
+
+model PluginDataStore {
+  id         Int      @id @default(autoincrement())
+  pluginName String
+  botId      Int
+  key        String
+  value      String // в виде json
+  createdAt  DateTime @default(now())
+  updatedAt  DateTime @updatedAt
+
+  bot Bot @relation(fields: [botId], references: [id], onDelete: Cascade)
+
+  @@unique([pluginName, botId, key])
+}

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

@@ -1,9 +1,12 @@
 const express = require('express');
 const bcrypt = require('bcryptjs');
 const jwt = require('jsonwebtoken');
+const crypto = require('crypto');
 const { PrismaClient } = require('@prisma/client');
 const config = require('../../config');
 const { authenticate, authorize } = require('../middleware/auth');
+const path = require('path');
+const os = require('os');
 
 const router = express.Router();
 const prisma = new PrismaClient();
@@ -11,6 +14,8 @@ const prisma = new PrismaClient();
 const JWT_SECRET = config.security.jwtSecret;
 const JWT_EXPIRES_IN = '7d';
 
+const activeResetTokens = new Map();
+
 /**
  * @route   GET /api/auth/status
  * @desc    Проверяет, была ли произведена первоначальная настройка (создан админ)
@@ -26,6 +31,16 @@ router.get('/status', async (req, res) => {
     }
 });
 
+/**
+ * @route   GET /api/auth/config-path
+ * @desc    Получить путь к конфигурационному файлу
+ * @access  Public
+ */
+router.get('/config-path', (req, res) => {
+    const configPath = path.join(os.homedir(), '.blockmine', 'config.json');
+    res.json({ configPath });
+});
+
 /**
  * @route   POST /api/auth/setup
  * @desc    Создает первого пользователя с ролью администратора
@@ -100,6 +115,131 @@ router.post('/setup', async (req, res) => {
     }
 });
 
+/**
+ * @route   POST /api/auth/recovery/verify
+ * @desc    Проверка кода восстановления
+ * @access  Public
+ */
+router.post('/recovery/verify', async (req, res) => {
+    try {
+        const { recoveryCode } = req.body;
+        
+        if (!recoveryCode) {
+            return res.status(400).json({ error: 'Код восстановления обязателен' });
+        }
+        
+        if (recoveryCode !== config.security.adminRecoveryCode) {
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            return res.status(401).json({ error: 'Неверный код восстановления' });
+        }
+        
+        const rootUser = await prisma.panelUser.findFirst({
+            orderBy: { id: 'asc' },
+            include: { role: true }
+        });
+        
+        if (!rootUser) {
+            return res.status(404).json({ error: 'В системе нет ни одного пользователя. Выполните первоначальную настройку.' });
+        }
+        
+        const tokenId = crypto.randomBytes(16).toString('hex');
+        const resetToken = jwt.sign(
+            { 
+                userId: rootUser.id,
+                type: 'password-reset',
+                tokenId: tokenId,
+                timestamp: Date.now()
+            },
+            JWT_SECRET,
+            { expiresIn: '5m' }
+        );
+        
+        activeResetTokens.set(tokenId, {
+            userId: rootUser.id,
+            createdAt: Date.now(),
+            used: false
+        });
+        
+        setTimeout(() => {
+            activeResetTokens.delete(tokenId);
+        }, 5 * 60 * 1000);
+        
+        res.json({ 
+            success: true,
+            username: rootUser.username,
+            resetToken
+        });
+        
+    } catch (error) {
+        console.error('[Recovery Verify Error]', error);
+        res.status(500).json({ error: 'Ошибка при проверке кода восстановления' });
+    }
+});
+
+/**
+ * @route   POST /api/auth/recovery/reset
+ * @desc    Сброс пароля с использованием токена
+ * @access  Public (с валидным токеном сброса)
+ */
+router.post('/recovery/reset', async (req, res) => {
+    try {
+        const { resetToken, newPassword } = req.body;
+        
+        if (!resetToken || !newPassword) {
+            return res.status(400).json({ error: 'Токен и новый пароль обязательны' });
+        }
+        
+        if (newPassword.length < 4) {
+            return res.status(400).json({ error: 'Пароль должен быть не менее 4 символов' });
+        }
+        
+        let decoded;
+        try {
+            decoded = jwt.verify(resetToken, JWT_SECRET);
+            if (decoded.type !== 'password-reset') {
+                throw new Error('Invalid token type');
+            }
+            
+            const tokenInfo = activeResetTokens.get(decoded.tokenId);
+            if (!tokenInfo) {
+                throw new Error('Token not found in active tokens');
+            }
+            
+            if (tokenInfo.used) {
+                throw new Error('Token already used');
+            }
+            
+            if (tokenInfo.userId !== decoded.userId) {
+                throw new Error('Token userId mismatch');
+            }
+            
+        } catch (err) {
+            return res.status(401).json({ error: 'Недействительный или истекший токен' });
+        }
+        
+        const hashedPassword = await bcrypt.hash(newPassword, 12);
+        const updatedUser = await prisma.panelUser.update({
+            where: { id: decoded.userId },
+            data: { passwordHash: hashedPassword },
+            select: { username: true }
+        });
+        
+        const tokenInfo = activeResetTokens.get(decoded.tokenId);
+        tokenInfo.used = true;
+        
+        activeResetTokens.delete(decoded.tokenId);
+        
+        res.json({ 
+            message: 'Пароль успешно сброшен', 
+            username: updatedUser.username 
+        });
+        
+    } catch (error) {
+        console.error('[Recovery Reset Error]', error);
+        res.status(500).json({ error: 'Ошибка при сбросе пароля' });
+    }
+});
+
 /**
  * @route   POST /api/auth/login
  * @desc    Аутентифицирует пользователя и возвращает токен

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

@@ -1085,4 +1085,180 @@ router.put('/:botId/event-graphs/:graphId', authorize('management:edit'), async
 router.post('/:botId/visual-editor/save', authorize('management:edit'), async (req, res) => {
 });
 
+router.get('/:botId/ui-extensions', authorize('plugin:list'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const enabledPlugins = await prisma.installedPlugin.findMany({
+            where: { botId: botId, isEnabled: true }
+        });
+
+        const extensions = [];
+        for (const plugin of enabledPlugins) {
+            if (plugin.manifest) {
+                try {
+                    const manifest = JSON.parse(plugin.manifest);
+                    if (manifest.uiExtensions && Array.isArray(manifest.uiExtensions)) {
+                        manifest.uiExtensions.forEach(ext => {
+                            extensions.push({
+                                pluginName: plugin.name,
+                                ...ext
+                            });
+                        });
+                    }
+                } catch (e) {
+                    console.error(`Ошибка парсинга манифеста для плагина ${plugin.name}:`, e);
+                }
+            }
+        }
+        res.json(extensions);
+    } catch (error) {
+        res.status(500).json({ error: 'Не удалось получить расширения интерфейса' });
+    }
+});
+
+router.get('/:botId/plugins/:pluginName/ui-content/:path', authorize('plugin:list'), async (req, res) => {
+    const { botId, pluginName, path: uiPath } = req.params;
+    const numericBotId = parseInt(botId, 10);
+
+    try {
+        const plugin = await prisma.installedPlugin.findFirst({
+            where: { botId: numericBotId, name: pluginName, isEnabled: true }
+        });
+
+        if (!plugin) {
+            return res.status(404).json({ error: `Активный плагин "${pluginName}" не найден для этого бота.` });
+        }
+
+        const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+        const savedSettings = plugin.settings ? JSON.parse(plugin.settings) : {};
+        const defaultSettings = {};
+
+        if (manifest.settings) {
+            for (const key in manifest.settings) {
+                const config = manifest.settings[key];
+                if (config.type === 'json_file' && config.defaultPath) {
+                    const configFilePath = path.join(plugin.path, config.defaultPath);
+                    try {
+                        const fileContent = await fs.readFile(configFilePath, 'utf-8');
+                        defaultSettings[key] = JSON.parse(fileContent);
+                    } catch (e) { defaultSettings[key] = {}; }
+                } else {
+                    try { defaultSettings[key] = JSON.parse(config.default || 'null'); } 
+                    catch { defaultSettings[key] = config.default; }
+                }
+            }
+        }
+        const finalSettings = { ...defaultSettings, ...savedSettings };
+        
+        const mainFilePath = manifest.main || 'index.js';
+        const pluginEntryPoint = path.join(plugin.path, mainFilePath);
+        
+        delete require.cache[require.resolve(pluginEntryPoint)];
+        const pluginModule = require(pluginEntryPoint);
+
+        if (typeof pluginModule.getUiPageContent !== 'function') {
+            return res.status(501).json({ error: `Плагин "${pluginName}" не предоставляет кастомный UI контент.` });
+        }
+        
+        const botProcess = botManager.bots.get(numericBotId);
+        const botApi = botProcess ? botProcess.api : null;
+        
+        const content = await pluginModule.getUiPageContent({
+            path: uiPath,
+            bot: botApi,
+            botId: numericBotId,
+            settings: finalSettings
+        });
+
+        if (content === null) {
+            return res.status(404).json({ error: `Для пути "${uiPath}" не найдено содержимого в плагине "${pluginName}".` });
+        }
+
+        res.json(content);
+
+    } catch (error) {
+        console.error(`[UI Content] Ошибка при получении контента для плагина "${pluginName}":`, error);
+        res.status(500).json({ error: error.message || 'Внутренняя ошибка сервера.' });
+    }
+});
+
+
+router.post('/:botId/plugins/:pluginName/action', authorize('plugin:list'), async (req, res) => {
+    const { botId, pluginName } = req.params;
+    const { actionName, payload } = req.body;
+    const numericBotId = parseInt(botId, 10);
+
+    if (!actionName) {
+        return res.status(400).json({ error: 'Необходимо указать "actionName".' });
+    }
+
+    try {
+        const botProcess = botManager.bots.get(numericBotId);
+        
+        if (!botProcess) {
+            return res.status(404).json({ error: 'Бот не найден или не запущен.' });
+        }
+
+        const plugin = await prisma.installedPlugin.findFirst({
+            where: { botId: numericBotId, name: pluginName, isEnabled: true }
+        });
+
+        if (!plugin) {
+            return res.status(404).json({ error: `Активный плагин с таким именем "${pluginName}" не найден.` });
+        }
+
+        const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+        const savedSettings = plugin.settings ? JSON.parse(plugin.settings) : {};
+        const defaultSettings = {};
+
+        if (manifest.settings) {
+            for (const key in manifest.settings) {
+                const config = manifest.settings[key];
+                 if (config.type === 'json_file' && config.defaultPath) {
+                    const configFilePath = path.join(plugin.path, config.defaultPath);
+                    try {
+                        const fileContent = await fs.readFile(configFilePath, 'utf-8');
+                        defaultSettings[key] = JSON.parse(fileContent);
+                    } catch (e) { 
+                        console.error(`[Action] Не удалось прочитать defaultPath для ${pluginName}: ${e.message}`);
+                        defaultSettings[key] = {}; 
+                    }
+                } else {
+                    try { 
+                        defaultSettings[key] = JSON.parse(config.default || 'null'); 
+                    } catch { 
+                        defaultSettings[key] = config.default; 
+                    }
+                }
+            }
+        }
+        const finalSettings = { ...defaultSettings, ...savedSettings };
+
+        const mainFilePath = manifest.main || 'index.js';
+        const pluginPath = path.join(plugin.path, mainFilePath);
+        
+        delete require.cache[require.resolve(pluginPath)];
+        const pluginModule = require(pluginPath);
+
+        if (typeof pluginModule.handleAction !== 'function') {
+            return res.status(501).json({ error: `Плагин "${pluginName}" не поддерживает обработку действий.` });
+        }
+        
+        const result = await pluginModule.handleAction({
+            botProcess: botProcess,
+            botId: numericBotId,
+            action: actionName,
+            payload: payload,
+            settings: finalSettings
+        });
+
+        res.json({ success: true, message: 'Действие выполнено.', result: result || null });
+
+    } catch (error) {
+        console.error(`Ошибка выполнения действия "${actionName}" для плагина "${pluginName}":`, error);
+        res.status(500).json({ error: error.message || 'Внутренняя ошибка сервера.' });
+    }
+});
+
+
 module.exports = router;

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

@@ -0,0 +1,16 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const router = express.Router();
+
+router.get('/', async (req, res) => {
+  try {
+    const file = path.resolve(__dirname, '../../../../CHANGELOG.md');
+    const data = await fs.promises.readFile(file, 'utf8');
+    res.type('text/markdown').send(data);
+  } catch (e) {
+    res.status(500).json({ error: 'changelog_not_found' });
+  }
+});
+
+module.exports = router;

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

@@ -121,7 +121,17 @@ router.put('/:graphId',
 
           const parsedGraph = JSON.parse(graphJson);
           const eventNodes = parsedGraph.nodes.filter(node => node.type.startsWith('event:'));
-          const eventTypes = eventNodes.map(node => node.type.split(':')[1]);
+          const eventTypes = [...new Set(eventNodes.map(node => node.type.split(':')[1]))];
+          
+          const existingGraph = await prisma.eventGraph.findUnique({
+              where: { id: parseInt(graphId) },
+              include: { triggers: true }
+          });
+          
+          const existingEventTypes = existingGraph?.triggers?.map(t => t.eventType) || [];
+          
+          const eventTypesToDelete = existingEventTypes.filter(et => !eventTypes.includes(et));
+          const eventTypesToCreate = eventTypes.filter(et => !existingEventTypes.includes(et));
           
           dataToUpdate.triggers = {
               deleteMany: {},

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

@@ -53,6 +53,17 @@ router.post('/update/:pluginId', authenticate, authorize('plugin:update'), async
     }
 });
 
+router.post('/:id/clear-data', authenticate, authorize('plugin:settings:edit'), async (req, res) => {
+    try {
+        const pluginId = parseInt(req.params.id);
+        await pluginManager.clearPluginData(pluginId);
+        res.status(200).json({ message: 'Данные плагина успешно очищены.' });
+    } catch (error) {
+        console.error(`[API Error] /plugins/:id/clear-data:`, error);
+        res.status(500).json({ error: error.message || 'Не удалось очистить данные плагина.' });
+    }
+});
+
 router.get('/catalog/:name', async (req, res) => {
     try {
         const pluginName = req.params.name;