blockmine 1.3.1 → 1.3.21

package/README.md

@@ -5,24 +5,24 @@
     <strong>Мощная и удобная панель управления для ваших Minecraft-ботов на базе Mineflayer.</strong>
   </p>
   <p>
-    <img src="https://img.shields.io/github/stars/blockmineJS/blockmine?style=for-the-badge&logo=github" alt="Stars">
-    <img src="https://img.shields.io/github/last-commit/blockmineJS/blockmine?style=for-the-badge&logo=git" alt="Last Commit">
+    <a href="https://github.com/blockmineJS/blockmine/stargazers"><img src="https://img.shields.io/github/stars/blockmineJS/blockmine?style=for-the-badge&logo=github" alt="Stars"></a>
+    <a href="https://github.com/blockmineJS/blockmine/commits/main"><img src="https://img.shields.io/github/last-commit/blockmineJS/blockmine?style=for-the-badge&logo=git" alt="Last Commit"></a>
     <a href="http://185.65.200.184:3000/api/stats" target="_blank">
       <img src="https://img.shields.io/endpoint?url=https://blockmine-proxy.vercel.app/api/shield&style=for-the-badge&logo=minecraft&logoColor=white" alt="Ботов онлайн">
+    </a>
   </p>
 </div>
 
-BlockMine — это open-source решение для централизованного управления и автоматизации ботов Minecraft. Запускайте ботов, управляйте ими в реальном времени через удобный веб-интерфейс, расширяйте их возможности с помощью плагинов и настраивайте всё под свои нужды.
+**BlockMine** — это open-source решение для централизованного управления и автоматизации ботов Minecraft. Запускайте ботов, управляйте ими в реальном времени через удобный веб-интерфейс, расширяйте их возможности с помощью плагинов и настраивайте всё под свои нужды.
 
 ---
 
-
 <table align="center">
   <tr>
     <td align="center">
-      <p><strong>Консоль</strong></p>
+      <p><strong>Дашборд</strong></p>
       <img src="./image/1.png" alt="Скриншот дашборда" width="100%">
-      <em>Консоль бота</em>
+      <em>Общая сводка и быстрое управление всеми ботами.</em>
     </td>
     <td align="center">
       <p><strong>Магазин плагинов</strong></p>
@@ -30,9 +30,9 @@ BlockMine — это open-source решение для централизова
       <em>Расширяйте возможности с помощью удобного браузера плагинов.</em>
     </td>
     <td align="center">
-      <p><strong>Управление</strong></p>
+      <p><strong>Управление командами</strong></p>
       <img src="./image/3.png" alt="Скриншот страницы управления" width="100%">
-      <em>Настраивайте роли, права и так далее</em>
+      <em>Настраивайте права, алиасы и кулдауны для каждой команды.</em>
     </td>
   </tr>
 </table>
@@ -67,7 +67,7 @@ BlockMine — это open-source решение для централизова
 
 ## ✨ Быстрый старт с `npx`
 
-Это самый простой способ запустить панель у себя на компьютере или сервере. Убедитесь, что у вас установлен **Node.js v18+**.
+Это самый простой способ запустить панель. Убедитесь, что у вас установлен **Node.js v18+**.
 
 1.  Откройте терминал (командную строку).
 2.  Выполните одну команду:
@@ -77,8 +77,7 @@ BlockMine — это open-source решение для централизова
     ```
 3.  Готово! Скрипт автоматически скачает все необходимое, настроит базу данных и запустит сервер.
 
-
-> ⚠️ **Важно**: Если выскакивает ошибка - Невозможно загрузить файл C:\Program Files\nodejs\npx.ps1, так как выполнение сценариев отключено в этой системе. - Выполните `Set-ExecutionPolicy RemoteSigned -Scope CurrentUser`
+> ⚠️ **Для пользователей Windows**: Если появляется ошибка `Невозможно загрузить файл ... npx.ps1, так как выполнение сценариев отключено`, откройте PowerShell от имени администратора и выполните `Set-ExecutionPolicy RemoteSigned -Scope CurrentUser`. Нажмите 'Y' для подтверждения.
 
 После успешного запуска вы увидите в консоли:
 ```
@@ -86,20 +85,45 @@ BlockMine — это open-source решение для централизова
 ```
 Откройте этот адрес в вашем браузере, чтобы начать работу.
 
+---
+
+## 💡 Основные концепции BlockMine
+
+Чтобы максимально эффективно использовать панель, важно понимать её ключевые компоненты.
+
+### 🔌 Плагины
+Плагины — это основа функциональности вашего бота. Они добавляют новые команды, автоматизируют действия и интегрируются с другими системами.
+
+*   **Магазин плагинов**: Встроенный браузер позволяет легко находить и устанавливать плагины в один клик.
+*   **Зависимости**: Система автоматически определит и предложит установить плагины, необходимые для работы выбранного вами.
+*   **Настройка**: Большинство плагинов можно настроить прямо в веб-интерфейсе, не редактируя файлы конфигурации вручную.
+
+### ⚙️ Команды
+Каждый плагин может регистрировать в системе свои команды. BlockMine предоставляет мощный интерфейс для управления ими.
+
+*   **Алиасы**: Назначайте командам короткие псевдонимы (например, `@p` для `@ping`).
+*   **Кулдауны**: Устанавливайте задержку между использованиями команды для предотвращения спама.
+*   **Включение/выключение**: Временно отключайте команды, не удаляя плагин.
+*   **Аргументы**: Панель автоматически обрабатывает аргументы команд, делая их использование предсказуемым.
+
+### 🔐 Права и Группы (Permissions)
+Это гибкая система, позволяющая точно контролировать, кто и что может делать с вашим ботом.
+
+*   **Права (Permissions)**: Каждое действие (например, использование команды `@fly`) защищено правом (`user.fly`). Права обычно создаются плагинами.
+*   **Группы (Groups)**: Группы объединяют несколько прав. Например, группа `Member` может иметь право `member.say`, а группа `Admin` — право `admin.*` (доступ ко всем командам у admin.).
+*   **Пользователи**: Каждый игрок, взаимодействующий с ботом, становится пользователем в системе. Вы можете добавлять пользователей в разные группы, выдавая им соответствующие права.
+
+Эта система позволяет создавать сложные иерархии доступа, например: обычные игроки, участники клана, модераторы и администраторы, каждый со своим набором возможностей.
+
 ## 🧑‍💻 Для разработчиков и контрибьюторов
 
 Если вы хотите внести свой вклад в проект или запустить его в режиме разработки.
 
 ### 1. Установка
 
-Сначала клонируйте репозиторий и установите все зависимости.
-
 ```bash
-# 1. Клонировать репозиторий
 git clone https://github.com/blockmineJS/blockmine.git
 cd blockmine
-
-# 2. Установить все зависимости для всех частей проекта (backend, frontend)
 npm install
 ```
 

package/backend/prisma/schema.prisma

@@ -1,5 +1,6 @@
 generator client {
   provider = "prisma-client-js"
+  binaryTargets = ["native", "linux-arm64-openssl-1.1.x"] 
 }
 
 datasource db {

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

@@ -8,6 +8,7 @@ const PluginManager = require('../../core/PluginManager');
 const UserService = require('../../core/UserService');
 const commandManager = require('../../core/system/CommandManager');
 
+
 const multer = require('multer');
 const archiver = require('archiver');
 const AdmZip = require('adm-zip');
@@ -443,71 +444,65 @@ router.get('/:botId/management-data', async (req, res) => {
         const botId = parseInt(req.params.botId);
         
         const commandTemplates = commandManager.getCommandTemplates();
-        let permissions = await prisma.permission.findMany({ where: { botId } });
+        const templatesMap = new Map(commandTemplates.map(t => [t.name, t]));
 
-        for (const template of commandTemplates) {
-            const exists = await prisma.command.findUnique({
-                where: { botId_name: { botId, name: template.name } }
-            });
+        let dbCommands = await prisma.command.findMany({ where: { botId }, orderBy: [{ owner: 'asc' }, { name: 'asc' }] });
 
-            if (!exists) {
+        const dbCommandNames = new Set(dbCommands.map(cmd => cmd.name));
+        const commandsToCreate = [];
+
+        for (const template of commandTemplates) {
+            if (!dbCommandNames.has(template.name)) {
                 let permissionId = null;
                 if (template.permissions) {
-                    let requiredPermission = permissions.find(p => p.name === template.permissions);
-                    if (!requiredPermission) {
-                        requiredPermission = await prisma.permission.create({
-                            data: {
-                                botId,
-                                name: template.permissions,
-                                description: `Авто-создано для команды ${template.name}`,
-                                owner: template.owner || 'system',
-                            }
-                        });
-                        permissions.push(requiredPermission);
-                    }
-                    permissionId = requiredPermission.id;
+                    const permission = await prisma.permission.upsert({
+                        where: { botId_name: { botId, name: template.permissions } },
+                        update: { description: `Авто-создано для команды ${template.name}` },
+                        create: {
+                            botId,
+                            name: template.permissions,
+                            description: `Авто-создано для команды ${template.name}`,
+                            owner: template.owner || 'system',
+                        }
+                    });
+                    permissionId = permission.id;
                 }
 
-                await prisma.command.create({
-                    data: {
-                        botId,
-                        name: template.name,
-                        isEnabled: template.isActive !== undefined ? template.isActive : true,
-                        cooldown: template.cooldown || 0,
-                        aliases: JSON.stringify(template.aliases || []),
-                        description: template.description,
-                        owner: template.owner,
-                        permissionId: permissionId,
-                        allowedChatTypes: JSON.stringify(template.allowedChatTypes || ['chat', 'private']),
-                    }
+                commandsToCreate.push({
+                    botId,
+                    name: template.name,
+                    isEnabled: template.isActive,
+                    cooldown: template.cooldown,
+                    aliases: JSON.stringify(template.aliases),
+                    description: template.description,
+                    owner: template.owner,
+                    permissionId: permissionId,
+                    allowedChatTypes: JSON.stringify(template.allowedChatTypes),
                 });
             }
         }
-        
-        const [groups, users, dbCommands, allPermissions] = await Promise.all([
+
+        if (commandsToCreate.length > 0) {
+            await prisma.command.createMany({ data: commandsToCreate });
+            dbCommands = await prisma.command.findMany({ where: { botId }, orderBy: [{ owner: 'asc' }, { name: 'asc' }] });
+        }
+
+        const finalCommands = dbCommands.map(cmd => {
+            const template = templatesMap.get(cmd.name);
+            return {
+                ...cmd,
+                args: template ? template.args : [],
+                aliases: JSON.parse(cmd.aliases || '[]'),
+                allowedChatTypes: JSON.parse(cmd.allowedChatTypes || '[]')
+            };
+        })
+
+        const [groups, users, allPermissions] = await Promise.all([
             prisma.group.findMany({ where: { botId }, include: { permissions: { include: { permission: true } } }, orderBy: { name: 'asc' } }),
             prisma.user.findMany({ where: { botId }, include: { groups: { include: { group: true } } }, orderBy: { username: 'asc' } }),
-            prisma.command.findMany({ where: { botId }, orderBy: [{ owner: 'asc' }, { name: 'asc' }] }),
             prisma.permission.findMany({ where: { botId }, orderBy: { name: 'asc' } })
         ]);
 
-        const finalCommands = dbCommands.map(cmd => {
-            try {
-                return {
-                    ...cmd,
-                    aliases: JSON.parse(cmd.aliases || '[]'),
-                    allowedChatTypes: JSON.parse(cmd.allowedChatTypes || '[]')
-                };
-            } catch (e) {
-                console.error(`Ошибка парсинга JSON для команды ${cmd.name} (ID: ${cmd.id})`, e);
-                return {
-                    ...cmd,
-                    aliases: [],
-                    allowedChatTypes: []
-                };
-            }
-        });
-
         res.json({ groups, permissions: allPermissions, users, commands: finalCommands });
         
     } catch (error) {
@@ -542,6 +537,8 @@ router.put('/:botId/commands/:commandId', async (req, res) => {
             data: dataToUpdate,
         });
 
+        BotManager.invalidateConfigCache(botId);
+
         res.json(updatedCommand);
     } catch (error) {
         console.error(`[API Error] /commands/:commandId PUT:`, error);
@@ -563,6 +560,10 @@ router.post('/:botId/groups', async (req, res) => {
                 permissions: { create: (permissionIds || []).map(id => ({ permissionId: id })) }
             }
         });
+
+        BotManager.invalidateConfigCache(botId);
+
+
         res.status(201).json(newGroup);
     } catch (error) {
         if (error.code === 'P2002') return res.status(409).json({ error: 'Группа с таким именем уже существует для этого бота.' });
@@ -596,6 +597,8 @@ router.put('/:botId/groups/:groupId', async (req, res) => {
             BotManager.invalidateUserCache(botId, user.username);
         }
 
+        BotManager.invalidateConfigCache(botId);
+
         res.status(200).send();
     } catch (error) {
         if (error.code === 'P2002') return res.status(409).json({ error: 'Группа с таким именем уже существует для этого бота.' });
@@ -605,12 +608,16 @@ router.put('/:botId/groups/:groupId', async (req, res) => {
 
 router.delete('/:botId/groups/:groupId', async (req, res) => {
     try {
+        const botId = parseInt(req.params.botId, 10);
         const groupId = parseInt(req.params.groupId);
         const group = await prisma.group.findUnique({ where: { id: groupId } });
         if (group && group.owner !== 'admin') {
             return res.status(403).json({ error: `Нельзя удалить группу с источником "${group.owner}".` });
         }
         await prisma.group.delete({ where: { id: groupId } });
+        BotManager.invalidateConfigCache(botId);
+
+
         res.status(204).send();
     } catch (error) { res.status(500).json({ error: 'Не удалось удалить группу.' }); }
 });
@@ -623,6 +630,9 @@ router.post('/:botId/permissions', async (req, res) => {
         const newPermission = await prisma.permission.create({
             data: { name, description, botId, owner: 'admin' }
         });
+
+        BotManager.invalidateConfigCache(botId);
+        
         res.status(201).json(newPermission);
     } catch (error) {
         if (error.code === 'P2002') return res.status(409).json({ error: 'Право с таким именем уже существует для этого бота.' });

package/backend/src/core/BotManager.js

@@ -1,4 +1,3 @@
-
 const { fork } = require('child_process');
 const path = require('path');
 const { getIO } = require('../real-time/socketHandler');
@@ -43,7 +42,8 @@ class BotManager {
         this.bots = new Map();
         this.logCache = new Map();
         this.resourceUsage = new Map();
-        
+        this.botConfigs = new Map();
+
         setInterval(() => this.updateAllResourceUsage(), 5000);
         
 
@@ -52,6 +52,42 @@ class BotManager {
         }
     }
 
+    async loadConfigForBot(botId) {
+        console.log(`[BotManager] Caching configuration for bot ID ${botId}...`);
+        try {
+            const [commands, permissions] = await Promise.all([
+                prisma.command.findMany({ where: { botId } }),
+                prisma.permission.findMany({ where: { botId } }),
+            ]);
+            
+            const config = {
+                commands: new Map(commands.map(cmd => [cmd.name, cmd])),
+                permissionsById: new Map(permissions.map(p => [p.id, p])),
+                commandAliases: new Map()
+            };
+
+            for (const cmd of commands) {
+                const aliases = JSON.parse(cmd.aliases || '[]');
+                for (const alias of aliases) {
+                    config.commandAliases.set(alias, cmd.name);
+                }
+            }
+
+            this.botConfigs.set(botId, config);
+            console.log(`[BotManager] Configuration for bot ID ${botId} cached successfully.`);
+            return config;
+        } catch (error) {
+            console.error(`[BotManager] Failed to cache configuration for bot ${botId}:`, error);
+            throw new Error(`Failed to load/cache bot configuration for botId ${botId}: ${error.message}`);
+        }
+    }
+
+    invalidateConfigCache(botId) {
+        if (this.botConfigs.has(botId)) {
+            this.botConfigs.delete(botId);
+            console.log(`[BotManager] Invalidated config cache for bot ID ${botId}. It will be reloaded on next command.`);
+        }
+    }
 
     triggerHeartbeat() {
         if (this.heartbeatDebounceTimer) {
@@ -260,6 +296,7 @@ class BotManager {
         }
 
         await this._syncSystemPermissions(botConfig.id);
+        await this.loadConfigForBot(botConfig.id);
 
         this.logCache.set(botConfig.id, []);
         this.emitStatusUpdate(botConfig.id, 'starting', '');
@@ -319,6 +356,7 @@ class BotManager {
             const botId = botConfig.id;
             this.bots.delete(botId);
             this.resourceUsage.delete(botId);
+            this.botConfigs.delete(botId);
             this.emitStatusUpdate(botId, 'stopped', `Процесс завершился с кодом ${code} (сигнал: ${signal || 'none'}).`);
             this.updateAllResourceUsage();
         });
@@ -334,83 +372,78 @@ class BotManager {
 
     async handleCommandValidation(botConfig, message) {
         const { commandName, username, args, typeChat } = message;
-        
+        const botId = botConfig.id;
+
         try {
-            const user = await RealUserService.getUser(username, botConfig.id, botConfig);
-    
-            if (user.isBlacklisted) return;
+            let botConfigCache = this.botConfigs.get(botId);
+            if (!botConfigCache) {
+                botConfigCache = await this.loadConfigForBot(botId);
+            }
             
-            const dbCommand = await prisma.command.findFirst({
-                where: {
-                    botId: botConfig.id,
-                    OR: [ { name: commandName }, { aliases: { contains: `"${commandName}"` } } ]
-                }
-            });
+            const user = await RealUserService.getUser(username, botId, botConfig);
+            const child = this.bots.get(botId);
             
-            if (!dbCommand || (!dbCommand.isEnabled && !user.isOwner)) return;
+            if (!child) {
+                console.warn(`[BotManager] No running bot process found for botId: ${botId} during command validation. Aborting.`);
+                return;
+            }
+
+            if (user.isBlacklisted) {
+                child.send({ type: 'handle_blacklist', commandName, username, typeChat });
+                return;
+            }
+            
+            const mainCommandName = botConfigCache.commandAliases.get(commandName) || commandName;
+            const dbCommand = botConfigCache.commands.get(mainCommandName);
+            
+            if (!dbCommand || (!dbCommand.isEnabled && !user.isOwner)) {
+                return;
+            }
     
             const allowedTypes = JSON.parse(dbCommand.allowedChatTypes || '[]');
             if (!allowedTypes.includes(typeChat) && !user.isOwner) {
-                
                 if (typeChat === 'global') {
                     return;
                 }
-
-                this._sendThrottledWarning(
-                    botConfig.id, 
-                    username, 
-                    `wrong_chat:${dbCommand.name}:${typeChat}`,
-                    `Команду ${dbCommand.name} нельзя использовать в этом типе чата.`,
-                    typeChat
-                );
+                child.send({ type: 'handle_wrong_chat', commandName: dbCommand.name, username, typeChat });
                 return;
             }
             
-            const permission = dbCommand.permissionId ? await prisma.permission.findUnique({ where: { id: dbCommand.permissionId } }) : null;
+            const permission = dbCommand.permissionId ? botConfigCache.permissionsById.get(dbCommand.permissionId) : null;
             if (permission && !user.hasPermission(permission.name)) {
-                this._sendThrottledWarning(
-                    botConfig.id,
-                    username,
-                    `no_permission:${dbCommand.name}`,
-                    `У вас нет прав для выполнения команды ${dbCommand.name}.`,
-                    typeChat
-                );
+                child.send({ type: 'handle_permission_error', commandName: dbCommand.name, username, 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}:${dbCommand.name}:${user.id}`;
+                const cooldownKey = `${botId}:${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);
-                    
-                    this._sendThrottledWarning(
-                        botConfig.id,
-                        username,
-                        `cooldown:${dbCommand.name}`,
-                        `Команду ${dbCommand.name} можно будет использовать через ${timeLeft} сек.`,
-                        typeChat
-                    );
+                    child.send({ type: 'handle_cooldown', commandName: dbCommand.name, username, typeChat, timeLeft });
                     return;
                 }
                 cooldowns.set(cooldownKey, now);
             }
 
-            const child = this.bots.get(botConfig.id);
-            if (child) {
-                child.send({ type: 'execute_handler', commandName: dbCommand.name, username, args, typeChat });
-            }
+            child.send({ type: 'execute_handler', commandName: dbCommand.name, username, args, typeChat });
 
         } catch (error) {
-            console.error(`[BotManager] Ошибка валидации команды ${commandName}:`, error);
-            this.sendMessageToBot(botConfig.id, `Произошла внутренняя ошибка при выполнении команды.`, 'private', username);
+            console.error(`[BotManager] Command validation error for botId: ${botId}`, {
+                command: commandName,
+                user: username,
+                error: error.message,
+                stack: error.stack
+            });
+            this.sendMessageToBot(botId, `Произошла внутренняя ошибка при выполнении команды.`, 'private', username);
         }
     }
 
+
     async handleCommandRegistration(botId, commandConfig) {
         try {
             let permissionId = null;
@@ -431,7 +464,10 @@ class BotManager {
                 permissionId = permission.id;
             }
     
-            const data = {
+
+            const createData = {
+                botId,
+                name: commandConfig.name,
                 description: commandConfig.description,
                 aliases: JSON.stringify(commandConfig.aliases || []),
                 owner: commandConfig.owner,
@@ -439,16 +475,20 @@ class BotManager {
                 allowedChatTypes: JSON.stringify(commandConfig.allowedChatTypes || []),
                 cooldown: commandConfig.cooldown || 0,
             };
-    
+
+            const updateData = {
+                description: commandConfig.description,
+                owner: commandConfig.owner,
+            };
+
             await prisma.command.upsert({
                 where: { botId_name: { botId, name: commandConfig.name } },
-                update: data,
-                create: {
-                    botId,
-                    name: commandConfig.name,
-                    ...data
-                }
+                update: updateData,
+                create: createData,
             });
+
+            this.invalidateConfigCache(botId);
+
         } catch (error) {
             console.error(`[BotManager] Ошибка при регистрации команды '${commandConfig.name}':`, error);
         }
@@ -458,6 +498,7 @@ class BotManager {
         const child = this.bots.get(botId);
         if (child) {
             child.send({ type: 'stop' });
+            this.botConfigs.delete(botId);
             return { success: true };
         }
         return { success: false, message: 'Бот не найден или уже остановлен' };

package/backend/src/core/BotProcess.js

@@ -50,7 +50,7 @@ function handleIncomingCommand(type, username, message) {
                 if (argDef.type === 'number') {
                     const numValue = parseFloat(value);
                     if (isNaN(numValue)) {
-                        bot.api.sendMessage(type, `Ошибка: Неверный тип аргумента "${argDef.description}". Ожидалось число.`, username);
+                        bot.api.sendMessage(type, `Ошибка: Аргумент "${argDef.description}" должен быть числом.`, username);
                         return;
                     }
                     value = numValue;
@@ -61,7 +61,12 @@ function handleIncomingCommand(type, username, message) {
 
             if (processedArgs[argDef.name] === undefined) {
                 if (argDef.required) {
+                    const usage = commandInstance.args.map(arg => {
+                        return arg.required ? `<${arg.description}>` : `[${arg.description}]`;
+                    }).join(' ');
+
                     bot.api.sendMessage(type, `Ошибка: Необходимо указать: ${argDef.description}`, username);
+                    bot.api.sendMessage(type, `Использование: ${bot.config.prefix}${commandInstance.name} ${usage}`, username);
                     return;
                 }
                 if (argDef.default !== undefined) {
@@ -271,6 +276,34 @@ process.on('message', async (message) => {
         if (message.username && bot && bot.config) {
             UserService.clearCache(message.username, bot.config.id);
         }
+    } else if (message.type === 'handle_permission_error') {
+        const { commandName, username, typeChat } = message;
+        const commandInstance = bot.commands.get(commandName);
+        if (commandInstance) {
+            commandInstance.onInsufficientPermissions(bot, typeChat, { username });
+        }
+    } else if (message.type === 'handle_wrong_chat') {
+        const { commandName, username, typeChat } = message;
+        const commandInstance = bot.commands.get(commandName);
+        if (commandInstance) {
+            commandInstance.onWrongChatType(bot, typeChat, { username });
+        }
+    } else if (message.type === 'handle_cooldown') {
+        const { commandName, username, typeChat, timeLeft } = message;
+        const commandInstance = bot.commands.get(commandName);
+        if (commandInstance) {
+            commandInstance.onCooldown(bot, typeChat, { username }, timeLeft);
+        }
+    } else if (message.type === 'handle_blacklist') {
+        const { commandName, username, typeChat } = message;
+        const commandInstance = bot.commands.get(commandName);
+        if (commandInstance) {
+            commandInstance.onBlacklisted(bot, typeChat, { username });
+        }
+    } else if (message.type === 'invalidate_user_cache') {
+        if (message.username && bot && bot.config) {
+            UserService.clearCache(message.username, bot.config.id);
+        }
     }
 });
 

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

@@ -19,17 +19,6 @@ class Command {
         this.allowedChatTypes = allowedChatTypes;
     }
 
-    onInvalidArguments(bot, typeChat, user, error) {
-        bot.api.sendMessage(typeChat, `Ошибка: ${error.message}`, user.username);
-        
-        const usage = this.args.map(arg => {
-            const part = arg.required ? `<${arg.description}>` : `[${arg.description}]`;
-            return part;
-        }).join(' ');
-
-        bot.api.sendMessage(typeChat, `Использование: ${bot.config.prefix}${this.name} ${usage}`, user.username);
-    }
-
     onInsufficientPermissions(bot, typeChat, user) {
         bot.api.sendMessage(typeChat, `У вас нет прав для выполнения команды ${this.name}.`, user.username);
     }

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

@@ -26,13 +26,14 @@ class CommandManager {
                     const commandInstance = new CommandClass();
                     const config = {
                         name: commandInstance.name,
-                        argsCount: commandInstance.argsCount,
-                        permissions: commandInstance.permissions,
-                        cooldown: commandInstance.cooldown,
-                        isActive: commandInstance.isActive,
                         description: commandInstance.description || '',
                         aliases: commandInstance.aliases || [],
                         owner: commandInstance.owner || 'system',
+                        permissions: commandInstance.permissions,
+                        allowedChatTypes: commandInstance.allowedChatTypes || ['chat', 'private'],
+                        cooldown: commandInstance.cooldown || 0,
+                        args: commandInstance.args || [],
+                        isActive: commandInstance.isActive !== undefined ? commandInstance.isActive : true,
                     };
 
                     if (config.name) {