blockmine 1.0.9 → 1.1.8

package/backend/cli.js

@@ -1,6 +1,4 @@
 #!/usr/bin/env node
-
-
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -8,12 +6,6 @@ const { execSync } = require('child_process');
 const { startServer } = require('./src/server.js');
 
 const DATA_DIR = path.join(os.homedir(), '.blockmine');
-if (!fs.existsSync(DATA_DIR)) {
-    console.log(`[BlockMine] Создание папки для данных: ${DATA_DIR}`);
-    fs.mkdirSync(DATA_DIR, { recursive: true });
-}
-
-process.env.DATABASE_URL = `file:${path.join(DATA_DIR, 'blockmine.db')}`;
 const prismaSchemaPath = path.join(__dirname, 'prisma', 'schema.prisma');
 
 function runCommand(command) {
@@ -29,13 +21,17 @@ function runCommand(command) {
 
 async function main() {
     console.log('Запуск панели управления BlockMine...');
-    console.log(`[BlockMine] Хранилище данных: ${DATA_DIR}`);
     
     const dbPath = path.join(DATA_DIR, 'blockmine.db');
     
     if (!fs.existsSync(dbPath)) {
         console.log('База данных не найдена. Создаем и применяем все миграции...');
         runCommand(`npx prisma migrate deploy --schema=${prismaSchemaPath}`);
+        
+        console.log('Заполнение базы данных начальными данными (серверами)...');
+        const seedScriptPath = path.join(__dirname, 'prisma', 'seed.js');
+        runCommand(`node ${seedScriptPath}`); 
+
         console.log('Первоначальная настройка базы данных завершена.');
     } else {
         console.log('Проверка и применение обновлений базы данных...');

package/backend/nodemon.json

@@ -1,12 +1,8 @@
 {
-    "watch": [
-      "src/"
-    ],
-    "ext": "js,mjs,cjs,json",
-    "ignore": [
-      "storage/",
-      "prisma/dev.db",
-      "prisma/dev.db-journal"
-    ],
-    "exec": "node src/server.js"
-  }
+  "watch": ["src/"],
+  "ext": "js,mjs,cjs,json",
+  "ignore": ["storage/", "prisma/dev.db", "prisma/dev.db-journal"],
+  "exec": "node src/server.js",
+  "signal": "SIGINT",
+  "delay": 1500
+}

package/backend/package.json

@@ -4,10 +4,10 @@
   "description": "",
   "main": "src/server.js",
   "scripts": {
-    "start": "node src/server.js",
-    "dev": "nodemon src/server.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
+  "start": "node src/server.js",
+  "dev": "nodemon",
+  "test": "echo \"Error: no test specified\" && exit 1"
+},
   "prisma": {
     "seed": "node prisma/seed.js"
   },

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

@@ -22,11 +22,12 @@ async function setupDefaultPermissionsForBot(botId, prismaClient = prisma) {
           { name: "admin.*", description: "Все права администратора" },
           { name: "admin.cooldown.bypass", description: "Обход кулдауна для админ-команд" },
           { name: "user.*", description: "Все права обычного пользователя" },
+          { name: "user.say", description: "Доступ к простым командам" },
           { name: "user.cooldown.bypass", description: "Обход кулдауна для юзер-команд" },
         ],
         groupPermissions: {
-          "User": ["user.*"],
-          "Admin": ["admin.*", "admin.cooldown.bypass", "user.cooldown.bypass"]
+          "User": ["user.say"],
+          "Admin": ["admin.*", "admin.cooldown.bypass", "user.cooldown.bypass", "user.*"]
         },
     };
     
@@ -55,7 +56,10 @@ router.get('/', async (req, res) => {
     try {
         const bots = await prisma.bot.findMany({ include: { server: true }, orderBy: { createdAt: 'asc' } });
         res.json(bots);
-    } catch (error) { res.status(500).json({ error: 'Не удалось получить список ботов' }); }
+    } catch (error) { 
+        console.error("[API /api/bots] Ошибка получения списка ботов:", error);
+        res.status(500).json({ error: 'Не удалось получить список ботов' }); 
+    }
 });
 
 router.get('/state', (req, res) => {

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

@@ -8,6 +8,7 @@ router.get('/', async (req, res) => {
         const servers = await prisma.server.findMany({ orderBy: { name: 'asc' } });
         res.json(servers);
     } catch (error) {
+        console.error("[API /api/servers] Ошибка получения списка серверов:", error);
         res.status(500).json({ error: 'Не удалось получить список серверов' });
     }
 });

package/backend/src/core/BotManager.js

@@ -6,11 +6,34 @@ const { PrismaClient } = require('@prisma/client');
 const pidusage = require('pidusage');
 const DependencyService = require('./DependencyService');
 
+const fs = require('fs');
+const os = require('os');
+const { v4: uuidv4 } = require('uuid');
+const crypto = require('crypto');
+
 const RealPermissionManager = require('./PermissionManager');
 const RealUserService = require('./UserService');
 
 const prisma = new PrismaClient();
 const cooldowns = new Map();
+const warningCache = new Map();
+const WARNING_COOLDOWN = 10 * 1000;
+
+
+const TELEMETRY_ENABLED = 'true';
+const STATS_SERVER_URL = 'http://185.65.200.184:3000';
+let instanceId = null;
+const DATA_DIR = path.join(os.homedir(), '.blockmine');
+
+if (TELEMETRY_ENABLED && STATS_SERVER_URL) {
+    const idPath = path.join(DATA_DIR, '.instance_id');
+    try {
+        instanceId = fs.readFileSync(idPath, 'utf-8');
+    } catch (e) {
+        instanceId = uuidv4();
+        fs.writeFileSync(idPath, instanceId, 'utf-8');
+    }
+}
 
 class BotManager {
     constructor() {
@@ -19,6 +42,129 @@ class BotManager {
         this.resourceUsage = new Map();
         
         setInterval(() => this.updateAllResourceUsage(), 5000);
+        
+
+        if (TELEMETRY_ENABLED && STATS_SERVER_URL) {
+            setTimeout(() => this.sendHeartbeat(), 10000);
+            setInterval(() => this.sendHeartbeat(), 5 * 60 * 1000);
+        }
+    }
+
+
+    _sendThrottledWarning(botId, username, warningType, message, typeChat = 'private') {
+        const cacheKey = `${botId}:${username}:${warningType}`;
+        const now = Date.now();
+        const lastWarning = warningCache.get(cacheKey);
+
+        if (!lastWarning || (now - lastWarning > WARNING_COOLDOWN)) {
+            this.sendMessageToBot(botId, message, typeChat, username);
+            warningCache.set(cacheKey, now);
+        }
+    }
+
+
+    async sendHeartbeat() {
+        if (!instanceId) return;
+
+        try {
+            const runningBots = [];
+            for (const botProcess of this.bots.values()) {
+                if (botProcess.botConfig) {
+                    runningBots.push({
+                        username: botProcess.botConfig.username,
+                        serverHost: botProcess.botConfig.server.host,
+                        serverPort: botProcess.botConfig.server.port
+                    });
+                }
+            }
+            
+            if (runningBots.length === 0) {
+                return;
+            }
+
+            console.log(`[Telemetry] Подготовка к отправке heartbeat для ${runningBots.length} ботов...`);
+
+            const challengeRes = await fetch(`${STATS_SERVER_URL}/api/challenge?uuid=${instanceId}`);
+            if (!challengeRes.ok) {
+                console.error(`[Telemetry] Сервер статистики вернул ошибку при получении challenge: ${challengeRes.statusText}`);
+                return;
+            }
+            const { challenge, difficulty, prefix } = await challengeRes.json();
+
+            let nonce = 0;
+            let hash = '';
+            do {
+                nonce++;
+                hash = crypto.createHash('sha256').update(prefix + challenge + nonce).digest('hex');
+            } while (!hash.startsWith('0'.repeat(difficulty)));
+            
+            const packageJson = require('../../../package.json');
+            await fetch(`${STATS_SERVER_URL}/api/heartbeat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    instanceUuid: instanceId,
+                    appVersion: packageJson.version,
+                    bots: runningBots,
+                    nonce: nonce
+                })
+            });
+            console.log(`[Telemetry] Heartbeat успешно отправлен.`);
+
+        } catch (error) {
+            console.error(`[Telemetry] Не удалось отправить heartbeat: ${error.message}`);
+        }
+    }
+
+
+    async _syncSystemPermissions(botId) {
+        const systemPermissions = [
+          { name: "admin.*", description: "Все права администратора" },
+          { name: "admin.cooldown.bypass", description: "Обход кулдауна для админ-команд" },
+          { name: "user.*", description: "Все права обычного пользователя" },
+          { name: "user.say", description: "Доступ к простым командам" },
+          { name: "user.cooldown.bypass", description: "Обход кулдауна для юзер-команд" },
+        ];
+        const systemGroups = ["User", "Admin"];
+        const systemGroupPermissions = {
+          "User": ["user.say"],
+          "Admin": ["admin.*", "admin.cooldown.bypass", "user.cooldown.bypass", "user.*"]
+        };
+        
+        console.log(`[Permission Sync] Синхронизация системных прав для бота ID ${botId}...`);
+
+        for (const perm of systemPermissions) {
+            await prisma.permission.upsert({
+                where: { botId_name: { botId, name: perm.name } },
+                update: { description: perm.description },
+                create: { ...perm, botId, owner: 'system' }
+            });
+        }
+
+        for (const groupName of systemGroups) {
+            await prisma.group.upsert({
+                where: { botId_name: { botId, name: groupName } },
+                update: {},
+                create: { name: groupName, botId, owner: 'system' }
+            });
+        }
+
+        for (const [groupName, permNames] of Object.entries(systemGroupPermissions)) {
+            const group = await prisma.group.findUnique({ where: { botId_name: { botId, name: groupName } } });
+            if (group) {
+                for (const permName of permNames) {
+                    const permission = await prisma.permission.findUnique({ where: { botId_name: { botId, name: permName } } });
+                    if (permission) {
+                        await prisma.groupPermission.upsert({
+                            where: { groupId_permissionId: { groupId: group.id, permissionId: permission.id } },
+                            update: {},
+                            create: { groupId: group.id, permissionId: permission.id }
+                        });
+                    }
+                }
+            }
+        }
+        console.log(`[Permission Sync] Синхронизация для бота ID ${botId} завершена.`);
     }
 
     async updateAllResourceUsage() {
@@ -102,6 +248,9 @@ class BotManager {
                  return { success: false, message: 'Бот уже запущен или запускается.' };
             }
         }
+
+        await this._syncSystemPermissions(botConfig.id);
+
         this.logCache.set(botConfig.id, []);
         this.emitStatusUpdate(botConfig.id, 'starting', '');
 
@@ -111,27 +260,20 @@ class BotManager {
 
         const enabledPlugins = allPluginsForBot.filter(p => p.isEnabled);
 
-        const { sortedPlugins, pluginInfo } = DependencyService.resolveDependencies(enabledPlugins, allPluginsForBot);
+        const { sortedPlugins, pluginInfo, hasCriticalIssues } = DependencyService.resolveDependencies(enabledPlugins, allPluginsForBot);
 
-        let canStart = true;
-        if (Object.values(pluginInfo).some(info => info.issues.length > 0)) {
-            this.appendLog(botConfig.id, '[DependencyManager] Обнаружены проблемы с зависимостями:');
+        if (hasCriticalIssues) {
+            this.appendLog(botConfig.id, '[DependencyManager] Обнаружены критические проблемы с зависимостями:');
             for (const plugin of Object.values(pluginInfo)) {
                 if (plugin.issues.length > 0) {
                     this.appendLog(botConfig.id, `  - Плагин "${plugin.name}":`);
                     for (const issue of plugin.issues) {
                         const logMessage = `    - [${issue.type.toUpperCase()}] ${issue.message}`;
                         this.appendLog(botConfig.id, logMessage);
-                        if (['missing_dependency', 'version_mismatch', 'circular_dependency'].includes(issue.type)) {
-                            canStart = false;
-                        }
                     }
                 }
             }
-        }
-
-        if (!canStart) {
-            this.appendLog(botConfig.id, '[DependencyManager] [FATAL] Запуск отменен из-за критических ошибок в зависимостях.');
+            this.appendLog(botConfig.id, '[DependencyManager] [FATAL] Запуск отменен.');
             this.emitStatusUpdate(botConfig.id, 'stopped', 'Ошибка зависимостей плагинов.');
             return { success: false, message: 'Критические ошибки в зависимостях плагинов.' };
         }
@@ -141,6 +283,8 @@ class BotManager {
         const botProcessPath = path.resolve(__dirname, 'BotProcess.js');
         const child = fork(botProcessPath, [], { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] });
 
+        child.botConfig = botConfig;
+
         child.on('error', (err) => {
             this.appendLog(botConfig.id, `[PROCESS FATAL] КРИТИЧЕСКАЯ ОШИБКА ПРОЦЕССА: ${err.stack}`);
         });
@@ -156,6 +300,8 @@ class BotManager {
                 this.emitStatusUpdate(botConfig.id, message.status); 
             } else if (message.type === 'validate_and_run_command') {
                 await this.handleCommandValidation(botConfig, message);
+            } else if (message.type === 'register_command') {
+                await this.handleCommandRegistration(botConfig.id, message.commandConfig);
             }
         });
 
@@ -180,41 +326,58 @@ class BotManager {
         try {
             const user = await RealUserService.getUser(username, botConfig.id, botConfig);
     
-            if (user.isBlacklisted) {
-                return;
-            }
+            if (user.isBlacklisted) return;
             
-            const dbCommand = await prisma.command.findUnique({ where: { botId_name: { botId: botConfig.id, name: commandName } } });
+            const dbCommand = await prisma.command.findFirst({
+                where: {
+                    botId: botConfig.id,
+                    OR: [ { name: commandName }, { aliases: { contains: `"${commandName}"` } } ]
+                }
+            });
             
-            if (!dbCommand || (!dbCommand.isEnabled && !user.isOwner)) {
-                return;
-            }
+            if (!dbCommand || (!dbCommand.isEnabled && !user.isOwner)) return;
     
             const allowedTypes = JSON.parse(dbCommand.allowedChatTypes || '[]');
             if (!allowedTypes.includes(typeChat) && !user.isOwner) {
-                const replyMessage = `Команду ${commandName} нельзя использовать в этом типе чата.`;
-                this.sendMessageToBot(botConfig.id, replyMessage, 'private', username);
+                this._sendThrottledWarning(
+                    botConfig.id, 
+                    username, 
+                    `wrong_chat:${dbCommand.name}:${typeChat}`,
+                    `Команду ${dbCommand.name} нельзя использовать в этом типе чата.`,
+                    typeChat
+                );
                 return;
             }
             
             const permission = dbCommand.permissionId ? await prisma.permission.findUnique({ where: { id: dbCommand.permissionId } }) : null;
             if (permission && !user.hasPermission(permission.name)) {
-                const replyMessage = `У вас нет прав для выполнения команды ${commandName}.`;
-                this.sendMessageToBot(botConfig.id, replyMessage, typeChat, username);
+                this._sendThrottledWarning(
+                    botConfig.id,
+                    username,
+                    `no_permission:${dbCommand.name}`,
+                    `У вас нет прав для выполнения команды ${dbCommand.name}.`,
+                    typeChat
+                );
                 return;
             }
     
             const domain = (permission?.name || '').split('.')[0] || 'user';
             const bypassCooldownPermission = `${domain}.cooldown.bypass`;
             if (dbCommand.cooldown > 0 && !user.isOwner && !user.hasPermission(bypassCooldownPermission)) {
-                const cooldownKey = `${botConfig.id}:${commandName}:${user.id}`;
+                const cooldownKey = `${botConfig.id}:${dbCommand.name}:${user.id}`;
                 const now = Date.now();
                 const lastUsed = cooldowns.get(cooldownKey);
     
                 if (lastUsed && (now - lastUsed < dbCommand.cooldown * 1000)) {
                     const timeLeft = Math.ceil((dbCommand.cooldown * 1000 - (now - lastUsed)) / 1000);
-                    const replyMessage = `Команду ${commandName} можно будет использовать через ${timeLeft} сек.`;
-                    this.sendMessageToBot(botConfig.id, replyMessage, typeChat, username);
+                    
+                    this._sendThrottledWarning(
+                        botConfig.id,
+                        username,
+                        `cooldown:${dbCommand.name}`,
+                        `Команду ${dbCommand.name} можно будет использовать через ${timeLeft} сек.`,
+                        typeChat
+                    );
                     return;
                 }
                 cooldowns.set(cooldownKey, now);
@@ -222,13 +385,55 @@ class BotManager {
 
             const child = this.bots.get(botConfig.id);
             if (child) {
-                child.send({ type: 'execute_handler', commandName, username, args, typeChat });
+                child.send({ type: 'execute_handler', commandName: dbCommand.name, username, args, typeChat });
             }
 
         } catch (error) {
             console.error(`[BotManager] Ошибка валидации команды ${commandName}:`, error);
-            const replyMessage = `Произошла внутренняя ошибка при выполнении команды.`;
-            this.sendMessageToBot(botConfig.id, replyMessage, 'private', username);
+            this.sendMessageToBot(botConfig.id, `Произошла внутренняя ошибка при выполнении команды.`, 'private', username);
+        }
+    }
+
+    async handleCommandRegistration(botId, commandConfig) {
+        try {
+            let permissionId = null;
+            if (commandConfig.permissions) {
+                let permission = await prisma.permission.findUnique({
+                    where: { botId_name: { botId, name: commandConfig.permissions } }
+                });
+                if (!permission) {
+                    permission = await prisma.permission.create({
+                        data: {
+                            botId,
+                            name: commandConfig.permissions,
+                            description: `Автоматически создано для команды ${commandConfig.name}`,
+                            owner: commandConfig.owner,
+                        }
+                    });
+                }
+                permissionId = permission.id;
+            }
+    
+            const data = {
+                description: commandConfig.description,
+                aliases: JSON.stringify(commandConfig.aliases || []),
+                owner: commandConfig.owner,
+                permissionId: permissionId,
+                allowedChatTypes: JSON.stringify(commandConfig.allowedChatTypes || []),
+                cooldown: commandConfig.cooldown || 0,
+            };
+    
+            await prisma.command.upsert({
+                where: { botId_name: { botId, name: commandConfig.name } },
+                update: data,
+                create: {
+                    botId,
+                    name: commandConfig.name,
+                    ...data
+                }
+            });
+        } catch (error) {
+            console.error(`[BotManager] Ошибка при регистрации команды '${commandConfig.name}':`, error);
         }
     }
 
@@ -244,7 +449,6 @@ class BotManager {
     sendMessageToBot(botId, message, chatType = 'command', username = null) {
         const child = this.bots.get(botId);
         if (child) {
-            // Отправляем объект с полной информацией
             child.send({ type: 'chat', payload: { message, chatType, username } });
             return { success: true };
         }

package/backend/src/core/BotProcess.js

@@ -21,10 +21,7 @@ function sendLog(content) {
     }
 }
 
-/**
- * Анализирует входящее сообщение и отправляет запрос на валидацию команды в главный процесс.
- */
-async function handleIncomingChat(type, username, message) {
+function handleIncomingCommand(type, username, message) {
     if (!message.startsWith(bot.config.prefix || '@')) return;
 
     const rawMessage = message.slice((bot.config.prefix || '@').length).trim();
@@ -38,13 +35,47 @@ async function handleIncomingChat(type, username, message) {
     if (!commandInstance) return;
 
     try {
-        const args = parseArguments(restOfMessage);
+        const processedArgs = {};
+        const parsedArgs = parseArguments(restOfMessage);
+        let currentArgIndex = 0;
+
+        for (const argDef of commandInstance.args) {
+            if (argDef.type === 'greedy_string') {
+                if (currentArgIndex < parsedArgs.length) {
+                    processedArgs[argDef.name] = parsedArgs.slice(currentArgIndex).join(' ');
+                    currentArgIndex = parsedArgs.length;
+                }
+            } else if (currentArgIndex < parsedArgs.length) {
+                let value = parsedArgs[currentArgIndex];
+                if (argDef.type === 'number') {
+                    const numValue = parseFloat(value);
+                    if (isNaN(numValue)) {
+                        bot.api.sendMessage(type, `Ошибка: Неверный тип аргумента "${argDef.description}". Ожидалось число.`, username);
+                        return;
+                    }
+                    value = numValue;
+                }
+                processedArgs[argDef.name] = value;
+                currentArgIndex++;
+            }
+
+            if (processedArgs[argDef.name] === undefined) {
+                if (argDef.required) {
+                    bot.api.sendMessage(type, `Ошибка: Необходимо указать: ${argDef.description}`, username);
+                    return;
+                }
+                if (argDef.default !== undefined) {
+                    processedArgs[argDef.name] = argDef.default;
+                }
+            }
+        }
+        
         if (process.send) {
             process.send({
                 type: 'validate_and_run_command',
                 commandName: commandInstance.name,
                 username,
-                args,
+                args: processedArgs,
                 typeChat: type
             });
         }
@@ -140,6 +171,24 @@ process.on('message', async (message) => {
             };
 
             bot.commands = await loadCommands();
+
+            if (process.send) {
+                for (const cmd of bot.commands.values()) {
+                    process.send({
+                        type: 'register_command',
+                        commandConfig: {
+                            name: cmd.name,
+                            description: cmd.description,
+                            aliases: cmd.aliases,
+                            owner: cmd.owner,
+                            permissions: cmd.permissions,
+                            cooldown: cmd.cooldown,
+                            allowedChatTypes: cmd.allowedChatTypes,
+                        }
+                    });
+                }
+            }
+            
             await initializePlugins(bot, config.plugins);
             sendLog('[System] Все системы инициализированы.');
 
@@ -147,12 +196,13 @@ process.on('message', async (message) => {
             let messageHandledByCustomParser = false;
 
             bot.events.on('chat:message', (data) => {
-                if (data && data.username && data.message) {
+                const { type, username, message } = data;
+                if (username && message) {
                     messageHandledByCustomParser = true;
-                    handleIncomingChat(data.type, data.username, data.message);
+                    handleIncomingCommand(type, username, message);
                 }
             });
-
+            
             bot.on('message', (jsonMsg) => {
                 const ansiMessage = jsonMsg.toAnsi();
                 if (ansiMessage.trim()) {
@@ -168,8 +218,7 @@ process.on('message', async (message) => {
                 if (messageHandledByCustomParser) {
                     return;
                 }
-                
-                handleIncomingChat('chat', username, message);
+                handleIncomingCommand('chat', username, message);
             });
 
             bot.on('login', () => {
@@ -205,11 +254,11 @@ process.on('message', async (message) => {
         if (bot) bot.quit();
         else process.exit(0);
     } else if (message.type === 'chat') {
-    if (bot && bot.entity) {
-        const { message: msg, chatType, username } = message.payload;
-        bot.messageQueue.enqueue(chatType, msg, username);
-    }
-} else if (message.type === 'execute_handler') {
+        if (bot && bot.entity) {
+            const { message: msg, chatType, username } = message.payload;
+            bot.messageQueue.enqueue(chatType, msg, username);
+        }
+    } else if (message.type === 'execute_handler') {
         const { commandName, username, args, typeChat } = message;
         const commandInstance = bot.commands.get(commandName);
         if (commandInstance) {