blockmine 1.0.8 → 1.1.0

package/backend/cli.js

@@ -1,26 +1,18 @@
-
+#!/usr/bin/env node
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 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) {
     try {
         console.log(`> ${command}`);
-        execSync(command, { stdio: 'inherit', cwd: __dirname });
+        const shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/sh';
+        execSync(command, { stdio: 'inherit', cwd: __dirname, shell: shell });
     } catch (e) {
         console.error(`Команда "${command}" не удалась:`, e);
         process.exit(1);
@@ -29,12 +21,17 @@ function runCommand(command) {
 
 async function main() {
     console.log('Запуск панели управления BlockMine...');
-    console.log(`[BlockMine] Хранилище данных: ${DATA_DIR}`);
     
-    const migrationsPath = path.join(__dirname, 'prisma', 'migrations');
-    if (!fs.existsSync(path.join(DATA_DIR, 'blockmine.db'))) {
+    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/src/api/routes/bots.js

@@ -55,7 +55,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

@@ -111,27 +111,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: 'Критические ошибки в зависимостях плагинов.' };
         }
@@ -156,6 +149,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 +175,39 @@ 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.sendMessageToBot(botConfig.id, `Команду ${dbCommand.name} нельзя использовать в этом типе чата.`, 'private', username);
                 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.sendMessageToBot(botConfig.id, `У вас нет прав для выполнения команды ${dbCommand.name}.`, 'private', username);
                 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.sendMessageToBot(botConfig.id, `Команду ${dbCommand.name} можно будет использовать через ${timeLeft} сек.`, typeChat, username);
                     return;
                 }
                 cooldowns.set(cooldownKey, now);
@@ -222,13 +215,54 @@ 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;
+            }
+
+            await prisma.command.upsert({
+                where: { botId_name: { botId, name: commandConfig.name } },
+                update: {
+                    description: commandConfig.description,
+                    aliases: JSON.stringify(commandConfig.aliases || []),
+                    owner: commandConfig.owner,
+                    permissionId: permissionId,
+                    allowedChatTypes: JSON.stringify(commandConfig.allowedChatTypes || ['chat', 'private']),
+                },
+                create: {
+                    ...commandConfig,
+                    botId,
+                    aliases: JSON.stringify(commandConfig.aliases || []),
+                    allowedChatTypes: JSON.stringify(commandConfig.allowedChatTypes || ['chat', 'private']),
+                    permissionId: permissionId,
+                }
+            });
+        } catch (error) {
+            console.error(`[BotManager] Ошибка при регистрации команды '${commandConfig.name}' от плагина:`, error);
         }
     }
 
@@ -244,7 +278,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
             });
         }
@@ -147,12 +178,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 +200,7 @@ process.on('message', async (message) => {
                 if (messageHandledByCustomParser) {
                     return;
                 }
-                
-                handleIncomingChat('chat', username, message);
+                handleIncomingCommand('chat', username, message);
             });
 
             bot.on('login', () => {
@@ -205,11 +236,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) {

package/backend/src/server.js

@@ -2,7 +2,18 @@
 const express = require('express');
 const http = require('http');
 const path = require('path');
-const fs = require('fs/promises');
+const fs = require('fs');
+const os = require('os');
+
+const DATA_DIR = path.join(os.homedir(), '.blockmine');
+if (!fs.existsSync(DATA_DIR)) {
+    console.log(`[Server] Создание папки для данных: ${DATA_DIR}`);
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+
+process.env.DATABASE_URL = `file:${path.join(DATA_DIR, 'blockmine.db')}`;
+
+
 const { initializeSocket } = require('./real-time/socketHandler');
 const botRoutes = require('./api/routes/bots');
 const pluginRoutes = require('./api/routes/plugins');
@@ -24,7 +35,7 @@ const rootPath = path.join(__dirname, '..', '..');
 app.get('/api/version', async (req, res) => {
     try {
         const packageJsonPath = path.join(rootPath, 'package.json');
-        const packageJsonData = await fs.readFile(packageJsonPath, 'utf-8');
+        const packageJsonData = await fs.promises.readFile(packageJsonPath, 'utf-8');
         const { version } = JSON.parse(packageJsonData);
         res.json({ version });
     } catch (error) {
@@ -38,7 +49,6 @@ app.use('/api/plugins', pluginRoutes);
 app.use('/api/servers', serverRoutes);
 app.use('/api/permissions', permissionsRoutes);
 
-
 app.use(express.static(frontendPath));
 
 app.get(/^(?!\/api).*/, (req, res) => {
@@ -50,7 +60,6 @@ app.get(/^(?!\/api).*/, (req, res) => {
     });
 });
 
-
 async function startServer() {
     return new Promise((resolve) => {
         server.listen(PORT, () => {

package/package.json

@@ -1,7 +1,7 @@
 
 {
   "name": "blockmine",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "Мощная панель управления ботами для Майнкрафта.",
   "author": "merka",
   "license": "MIT",

package/backend/src/core/system/CommandHandler.js

@@ -1,98 +0,0 @@
-const { PrismaClient } = require('@prisma/client');
-const prisma = new PrismaClient();
-const User = require('../UserService');
-const { parseArguments } = require('./parseArguments');
-
-const cooldowns = new Map();
-
-async function commandHandler(bot, typeChat, username, message) {
-    if (!message.startsWith(bot.config.prefix || '@')) return;
-
-    const rawMessage = message.slice((bot.config.prefix || '@').length).trim();
-    
-    const commandParts = rawMessage.split(/ +/);
-    const commandName = commandParts.shift().toLowerCase();
-    const restOfMessage = commandParts.join(' ');
-
-    const commandInstance = bot.commands.get(commandName);
-
-    if (!commandInstance) return;
-
-    try {
-        const user = await User.getUser(username, bot.config.id, bot.config);
-
-        if (user.isBlacklisted) {
-            return commandInstance.onBlacklisted(bot, typeChat, user);
-        }
-        
-        const dbCommand = await prisma.command.findUnique({ where: { botId_name: { botId: bot.config.id, name: commandInstance.name } } });
-        
-        if (!dbCommand || (!dbCommand.isEnabled && !user.isOwner)) {
-            return;
-        }
-
-        const allowedTypes = JSON.parse(dbCommand.allowedChatTypes || '[]');
-        if (!allowedTypes.includes(typeChat) && !user.isOwner) {
-            return commandInstance.onWrongChatType(bot, typeChat, user);
-        }
-
-        if (!user.hasPermission(commandInstance.permissions)) {
-            return commandInstance.onInsufficientPermissions(bot, typeChat, user);
-        }
-
-        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)) {
-                        return commandInstance.onInvalidArguments(bot, typeChat, user, { message: `Неверный тип аргумента "${argDef.description}". Ожидалось число.` });
-                    }
-                    value = numValue;
-                }
-                processedArgs[argDef.name] = value;
-                currentArgIndex++;
-            }
-
-            if (processedArgs[argDef.name] === undefined) {
-                if (argDef.required) {
-                    return commandInstance.onInvalidArguments(bot, typeChat, user, { message: `Необходимо указать: ${argDef.description}` });
-                }
-                if (argDef.default !== undefined) {
-                    processedArgs[argDef.name] = argDef.default;
-                }
-            }
-        }
-        
-        const domain = (commandInstance.permissions || '').split('.')[0] || 'user';
-        const bypassCooldownPermission = `${domain}.cooldown.bypass`;
-        if (dbCommand.cooldown > 0 && !user.isOwner && !user.hasPermission(bypassCooldownPermission)) {
-            const cooldownKey = `${bot.config.id}:${commandName}:${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);
-                return commandInstance.onCooldown(bot, typeChat, user, timeLeft);
-            }
-            cooldowns.set(cooldownKey, now);
-        }
-        
-        await commandInstance.handler(bot, typeChat, user, processedArgs);
-
-    } catch (error) {
-        console.error(`[CommandHandler] Ошибка выполнения команды ${commandName}:`, error);
-        bot.api.sendMessage('private', `Произошла ошибка при выполнении команды.`, username);
-    }
-}
-
-module.exports = { commandHandler };