blockmine 1.0.0

package/backend/src/core/PluginManager.js

@@ -0,0 +1,161 @@
+
+const { simpleGit } = require('simple-git');
+const path = require('path');
+const fs = require('fs/promises');
+const { PrismaClient } = require('@prisma/client');
+const prisma = new PrismaClient();
+const semver = require('semver');
+
+const PLUGINS_BASE_DIR = path.resolve(__dirname, '../../storage/plugins');
+
+class PluginManager {
+    constructor() {
+        this.git = simpleGit();
+        this.ensureBaseDirExists();
+    }
+
+    async ensureBaseDirExists() {
+        await fs.mkdir(PLUGINS_BASE_DIR, { recursive: true }).catch(console.error);
+    }
+
+    async installFromLocalPath(botId, directoryPath) {
+        return this.registerPlugin(botId, directoryPath, 'LOCAL', directoryPath);
+    }
+
+    async installFromGithub(botId, repoUrl, prismaClient = prisma) {
+        const botPluginsDir = path.join(PLUGINS_BASE_DIR, `bot_${botId}`);
+        await fs.mkdir(botPluginsDir, { recursive: true });
+        const repoName = path.basename(repoUrl, '.git');
+        const localPath = path.join(botPluginsDir, repoName);
+        
+        const existing = await prismaClient.installedPlugin.findFirst({ where: { botId, sourceUri: repoUrl } });
+        if (existing) throw new Error(`Плагин из ${repoUrl} уже установлен.`);
+
+        try {
+            await this.git.clone(repoUrl, localPath);
+            const git = simpleGit(localPath);
+            const response = await fetch("https://raw.githubusercontent.com/blockmineJS/official-plugins-list/main/index.json");
+            const catalog = await response.json();
+            const catalogInfo = catalog.find(p => p.repoUrl === repoUrl);
+            if (catalogInfo && catalogInfo.latestTag) {
+                await git.fetch(['--tags', '--force']);
+                await git.checkout(catalogInfo.latestTag, ['-f']);
+            }
+            return await this.registerPlugin(botId, localPath, 'GITHUB', repoUrl, prismaClient);
+        } catch (error) {
+            await fs.rm(localPath, { recursive: true, force: true }).catch(() => {});
+            throw error;
+        }
+    }
+
+    async registerPlugin(botId, directoryPath, sourceType, sourceUri, prismaClient = prisma) {
+        const packageJsonPath = path.join(directoryPath, 'package.json');
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+        if (!packageJson.name || !packageJson.version) {
+            throw new Error('package.json не содержит name и version');
+        }
+        
+        const pluginData = {
+            botId,
+            name: packageJson.name,
+            version: packageJson.version,
+            description: packageJson.description || '',
+            path: directoryPath,
+            sourceType,
+            sourceUri: sourceUri || directoryPath,
+            manifest: JSON.stringify(packageJson.botpanel || {}),
+        };
+        return prismaClient.installedPlugin.create({ data: pluginData });
+    }
+
+    async deletePlugin(pluginId) {
+        const plugin = await prisma.installedPlugin.findUnique({ where: { id: pluginId } });
+        if (!plugin) throw new Error('Плагин не найден');
+
+        try {
+            const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+            const mainFile = manifest.main || 'index.js';
+            const entryPointPath = path.join(plugin.path, mainFile);
+            
+            const pluginModule = require(entryPointPath);
+
+            if (pluginModule && typeof pluginModule.onUnload === 'function') {
+                console.log(`[PluginManager] Вызов хука onUnload для плагина ${plugin.name}...`);
+                await pluginModule.onUnload({ botId: plugin.botId, prisma });
+                console.log(`[PluginManager] Хук onUnload для ${plugin.name} успешно выполнен.`);
+            }
+        } catch (error) {
+            console.error(`[PluginManager] Ошибка при выполнении хука onUnload для плагина ${plugin.name}:`, error);
+        }
+
+        if (plugin.sourceType === 'GITHUB' || plugin.sourceType === 'IMPORTED') {
+            await fs.rm(plugin.path, { recursive: true, force: true });
+        }
+        await prisma.installedPlugin.delete({ where: { id: pluginId } });
+    }
+
+    async checkForUpdates(botId, catalog) {
+        const githubPlugins = await prisma.installedPlugin.findMany({
+            where: { botId, sourceType: 'GITHUB' }
+        });
+        const updatesAvailable = [];
+        const catalogMap = new Map(catalog.map(item => [item.repoUrl, item]));
+
+        for (const plugin of githubPlugins) {
+            try {
+                const catalogInfo = catalogMap.get(plugin.sourceUri);
+                if (!catalogInfo || !catalogInfo.latestTag) continue;
+                
+                const localVersion = plugin.version;
+                const recommendedVersion = semver.clean(catalogInfo.latestTag);
+
+                if (semver.gt(recommendedVersion, localVersion)) {
+                    updatesAvailable.push({
+                        id: plugin.id,
+                        name: plugin.name,
+                        sourceUri: plugin.sourceUri,
+                        currentVersion: localVersion,
+                        recommendedVersion: recommendedVersion,
+                    });
+                }
+            } catch (error) {
+                console.error(`[PluginManager] Ошибка проверки обновлений для ${plugin.name}:`, error.message);
+            }
+        }
+        return updatesAvailable;
+    }
+
+    async updatePlugin(pluginId) {
+        const plugin = await prisma.installedPlugin.findUnique({ where: { id: pluginId } });
+        if (!plugin || plugin.sourceType !== 'GITHUB') {
+            throw new Error('Плагин не найден или не является GitHub-плагином.');
+        }
+
+        const pluginDirectory = plugin.path;
+        try {
+            const git = simpleGit(pluginDirectory);
+            const response = await fetch("https://raw.githubusercontent.com/blockmineJS/official-plugins-list/main/index.json");
+            const catalog = await response.json();
+            const catalogInfo = catalog.find(p => p.repoUrl === plugin.sourceUri);
+
+            if (!catalogInfo || !catalogInfo.latestTag) {
+                throw new Error('Не найдена информация о проверенной версии в каталоге.');
+            }
+            const recommendedTag = catalogInfo.latestTag;
+            await git.fetch(['--tags', '--force']);
+            await git.checkout(recommendedTag, ['-f']);
+            
+            console.log(`[PluginManager] Плагин ${plugin.name} успешно обновлен до версии ${recommendedTag}.`);
+            
+            await prisma.installedPlugin.delete({ where: { id: plugin.id } });
+            return await this.registerPlugin(plugin.botId, pluginDirectory, 'GITHUB', plugin.sourceUri);
+
+        } catch (error) {
+            console.error(`[PluginManager] Ошибка обновления плагина ${plugin.name}:`, error.message);
+            try { await simpleGit(pluginDirectory).checkout('main', ['-f']); } catch(e) { }
+            throw new Error(`Не удалось обновить плагин: ${error.message}`);
+        }
+    }
+}
+
+module.exports = new PluginManager();

package/backend/src/core/PluginService.js

@@ -0,0 +1,57 @@
+
+const fs = require('fs/promises');
+const path = require('path');
+const { PrismaClient } = require('@prisma/client');
+const prisma = new PrismaClient();
+
+class PluginService {
+    /**
+     * Регистрирует плагин по указанному пути к папке.
+     * Читает package.json, извлекает манифест и создает запись в БД.
+     * @param {string} directoryPath - Путь к папке с плагином.
+     * @returns {Promise<object>} - Созданный или обновленный объект плагина.
+     */
+    async registerPluginFromPath(directoryPath) {
+        console.log(`[PluginService] Попытка регистрации плагина из: ${directoryPath}`);
+        
+        const absolutePath = path.resolve(directoryPath);
+        const packageJsonPath = path.join(absolutePath, 'package.json');
+
+        try {
+            await fs.access(packageJsonPath);
+            const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
+            const packageJson = JSON.parse(packageJsonContent);
+
+            if (!packageJson.name || !packageJson.version || !packageJson.main) {
+                throw new Error('package.json не содержит обязательных полей: name, version, main');
+            }
+
+            const manifest = packageJson.botpanel || {};
+
+            const pluginData = {
+                name: packageJson.name,
+                description: packageJson.description || '',
+                version: packageJson.version,
+                path: path.join(absolutePath, packageJson.main),
+                sourceType: 'LOCAL',
+                sourceUri: absolutePath,
+                manifest: manifest,
+            };
+
+            const plugin = await prisma.plugin.upsert({
+                where: { name: pluginData.name },
+                update: { ...pluginData },
+                create: { ...pluginData },
+            });
+
+            console.log(`[PluginService] Плагин "${plugin.name}" успешно зарегистрирован/обновлен.`);
+            return plugin;
+
+        } catch (error) {
+            console.error(`[PluginService] Ошибка регистрации плагина из ${directoryPath}:`, error.message);
+            throw new Error(`Не удалось зарегистрировать плагин: ${error.message}`);
+        }
+    }
+}
+
+module.exports = new PluginService();

package/backend/src/core/UserService.js

@@ -0,0 +1,181 @@
+const { PrismaClient } = require('@prisma/client');
+const prisma = new PrismaClient();
+
+class User {
+    /**
+     * Конструктор не должен вызываться напрямую. Используйте статический метод User.getUser().
+     * @param {object} userInstance - Полный объект пользователя из Prisma.
+     * @param {object} botConfig - Полный объект конфигурации бота.
+     */
+    constructor(userInstance, botConfig = {}) {
+        this.user = userInstance;
+        this.botConfig = botConfig;
+        
+        const globalOwners = ["merka", "akrem"];
+        const keksikServers = ["mc.mineblaze.net", "mc.masedworld.net", "mc.cheatmine.net", "mc.dexland.org"];
+        
+        const botOwners = (this.botConfig.owners || '').toLowerCase().split(',').map(s => s.trim()).filter(Boolean);
+        const usernameLower = this.user.username.toLowerCase();
+
+        this.isOwner = botOwners.includes(usernameLower) || (keksikServers.includes(this.botConfig.server?.host) && globalOwners.includes(usernameLower));
+        
+        this.permissionsSet = new Set();
+        if (this.user.groups) {
+            this.user.groups.forEach(userGroup => {
+                if (userGroup.group && userGroup.group.permissions) {
+                    userGroup.group.permissions.forEach(groupPermission => {
+                        if (groupPermission.permission) {
+                            this.permissionsSet.add(groupPermission.permission.name);
+                        }
+                    });
+                }
+            });
+        }
+    }
+
+    get id() { return this.user.id; }
+    get username() { return this.user.username; }
+    get groups() { return this.user.groups; }
+    
+    get isBlacklisted() { 
+        return this.isOwner ? false : this.user.isBlacklisted; 
+    }
+
+    async setBlacklist(value) {
+        this.user = await prisma.user.update({
+            where: { id: this.id },
+            data: { isBlacklisted: value },
+        });
+        User.clearCache(this.username, this.user.botId);
+        return this;
+    }
+
+    hasPermission(permissionName) {
+        if (this.isOwner) return true;
+        if (!permissionName) return true;
+
+        if (this.permissionsSet.has(permissionName)) {
+            return true;
+        }
+
+        const permissionParts = permissionName.split('.');
+        if (permissionParts.length > 1) {
+            const domain = permissionParts[0];
+            const wildcard = `${domain}.*`;
+            if (this.permissionsSet.has(wildcard)) {
+                return true;
+            }
+        }
+        
+        if (this.permissionsSet.has('*')) {
+            return true;
+        }
+
+        return false;
+    }
+
+    async addGroup(groupName) {
+        const group = await prisma.group.findUnique({ where: { botId_name: { botId: this.user.botId, name: groupName } } });
+        if (!group) throw new Error(`Группа ${groupName} не найдена`);
+        await prisma.userGroup.create({ data: { userId: this.id, groupId: group.id } });
+        return this.refresh();
+    }
+
+    async removeGroup(groupName) {
+        const group = await prisma.group.findUnique({ where: { botId_name: { botId: this.user.botId, name: groupName } } });
+        if (!group) throw new Error(`Группа ${groupName} не найдена`);
+        await prisma.userGroup.delete({ where: { userId_groupId: { userId: this.id, groupId: group.id } } });
+        const remainingGroups = await prisma.userGroup.count({ where: { userId: this.id } });
+        if (remainingGroups === 0) {
+            const defaultGroup = await prisma.group.findUnique({ where: { botId_name: { botId: this.user.botId, name: 'User' } } });
+            if (defaultGroup) {
+                await prisma.userGroup.create({ data: { userId: this.id, groupId: defaultGroup.id } });
+            }
+        }
+        return this.refresh();
+    }
+    
+    async refresh() {
+        User.clearCache(this.username, this.user.botId);
+        return User.getUser(this.username, this.user.botId);
+    }
+
+    static cache = new Map();
+
+    static clearCache(username, botId) {
+        if (!username || !botId) return;
+        const lowerUsername = username.toLowerCase();
+        const cacheKey = `${botId}:${lowerUsername}`;
+        User.cache.delete(cacheKey);
+        console.log(`[UserService] Кэш для пользователя "${lowerUsername}" (Бот ID: ${botId}) был очищен.`);
+    }
+
+    hasGroup(groupName) {
+        if (!this.user.groups || this.user.groups.length === 0) {
+            return false;
+        }
+        return this.user.groups.some(userGroup => userGroup.group.name.toLowerCase() === groupName.toLowerCase());
+    }
+    
+    static async getUser(username, botId, botConfig = null) {
+        if (!username || !botId) {
+            throw new Error("Имя пользователя и ID бота обязательны.");
+        }
+        const lowerUsername = username.toLowerCase();
+        const cacheKey = `${botId}:${lowerUsername}`;
+
+        if (User.cache.has(cacheKey)) {
+            return User.cache.get(cacheKey);
+        }
+
+        if (!botConfig) {
+            botConfig = await prisma.bot.findUnique({ where: { id: botId }, include: { server: true } });
+        }
+
+        let userInstance = await prisma.user.findUnique({
+            where: { botId_username: { botId, username: lowerUsername } },
+            include: { 
+                groups: { 
+                    include: { 
+                        group: { 
+                            include: { 
+                                permissions: { 
+                                    include: { 
+                                        permission: true 
+                                    } 
+                                } 
+                            } 
+                        } 
+                    } 
+                } 
+            },
+        });
+
+        if (!userInstance) {
+            const defaultGroup = await prisma.group.findUnique({ where: { botId_name: { botId, name: 'User' } } });
+            
+            if (!defaultGroup) {
+                console.warn(`[UserService] Дефолтная группа 'User' не найдена для бота ID ${botId}. Пользователь будет создан без группы.`);
+                userInstance = await prisma.user.create({
+                    data: { username: lowerUsername, botId },
+                    include: { groups: { include: { group: { include: { permissions: { include: { permission: true } } } } } } },
+                });
+            } else {
+                 userInstance = await prisma.user.create({
+                    data: {
+                        username: lowerUsername,
+                        botId,
+                        groups: { create: { groupId: defaultGroup.id } }
+                    },
+                    include: { groups: { include: { group: { include: { permissions: { include: { permission: true } } } } } } },
+                });
+            }
+        }
+
+        const user = new User(userInstance, botConfig);
+        User.cache.set(cacheKey, user);
+        return user;
+    }
+}
+
+module.exports = User;

package/backend/src/core/commands/ping.js

@@ -0,0 +1,35 @@
+const Command = require('../system/Command');
+
+class PingCommand extends Command {
+    constructor() {
+        super({
+            name: 'ping',
+            description: 'Проверяет работоспособность бота и может пинговать игрока.',
+            aliases: ['пинг', 'p'],
+            cooldown: 5,
+            permissions: 'user.ping',
+            owner: 'system',
+            allowedChatTypes: ['local', 'clan', 'private', 'global'],
+            
+            args: [
+                {
+                    name: 'target',
+                    type: 'string',
+                    required: false,
+                    description: 'Ник игрока для пинга'
+                }
+            ]
+        });
+    }
+
+    async handler(bot, typeChat, user, { target }) {
+
+        if (target) {
+            bot.api.sendMessage(typeChat, `Понг, ${user.username}! Пингую игрока ${target}.`, user.username);
+        } else {
+            bot.api.sendMessage(typeChat, `В`, user.username);
+        }
+    }
+}
+
+module.exports = PingCommand;

package/backend/src/core/commands/warn.js

@@ -0,0 +1,40 @@
+const Command = require('../system/Command');
+
+class WarnCommand extends Command {
+    constructor() {
+        super({
+            name: 'warn',
+            description: 'Выдать предупреждение игроку.',
+            aliases: ['пред'],
+            cooldown: 10,
+            
+            permissions: 'admin.warn', 
+            
+            owner: 'system',
+            allowedChatTypes: ['chat', 'private'],
+            
+            args: [
+                {
+                    name: 'target',
+                    type: 'string',
+                    required: true,
+                    description: 'Ник игрока'
+                },
+                {
+                    name: 'reason',
+                    type: 'greedy_string',
+                    required: true,
+                    description: 'Причина предупреждения'
+                }
+            ]
+        });
+    }
+
+    async handler(bot, typeChat, user, { target, reason }) {
+        
+        bot.api.sendMessage(
+            typeChat, `${user.username} выдал предупреждение игроку ${target}. Причина: ${reason}`);
+    }
+}
+
+module.exports = WarnCommand;

package/backend/src/core/ipc/PermissionManager.stub.js

@@ -0,0 +1,24 @@
+
+function sendIpcMessage(type, payload) {
+    if (process.send) {
+        process.send({ type, ...payload });
+    }
+}
+
+async function registerPermissions(botId, permissions) {
+    sendIpcMessage('register_permissions', { botId, permissions });
+}
+
+async function registerGroup(botId, groupConfig) {
+    sendIpcMessage('register_group', { botId, groupConfig });
+}
+
+async function addPermissionsToGroup(botId, groupName, permissionNames) {
+    sendIpcMessage('add_permissions_to_group', { botId, groupName, permissionNames });
+}
+
+module.exports = {
+    registerPermissions,
+    registerGroup,
+    addPermissionsToGroup,
+};

package/backend/src/core/ipc/UserService.stub.js

@@ -0,0 +1,31 @@
+
+const userCache = new Map();
+
+function getUser(username, botId, botConfig) {
+    const cacheKey = `${botId}:${username.toLowerCase()}`;
+    if (userCache.has(cacheKey)) {
+        return userCache.get(cacheKey);
+    }
+    
+    const tempUser = {
+        username: username.toLowerCase(),
+        isOwner: (botConfig.owners || '').toLowerCase().split(',').includes(username.toLowerCase()),
+        hasPermission: () => true,
+        hasGroup: () => false,
+    };
+    userCache.set(cacheKey, tempUser);
+    return tempUser;
+}
+
+function clearCache(username, botId) {
+    const cacheKey = `${botId}:${username.toLowerCase()}`;
+    userCache.delete(cacheKey);
+    if (process.send) {
+        process.send({ type: 'invalidate_user_cache_main', username, botId });
+    }
+}
+
+module.exports = {
+    getUser,
+    clearCache
+};

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

@@ -0,0 +1,53 @@
+class Command {
+    constructor({
+        name,
+        description = '',
+        aliases = [],
+        owner = 'system',
+        permissions = '',
+        args = [],
+        cooldown = 0,
+        allowedChatTypes = ['chat', 'private'],
+    }) {
+        this.name = name;
+        this.description = description;
+        this.aliases = aliases;
+        this.owner = owner;
+        this.permissions = permissions;
+        this.args = args;
+        this.cooldown = cooldown;
+        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);
+    }
+
+    onWrongChatType(bot, typeChat, user) {
+        bot.api.sendMessage('private', `Команду ${this.name} нельзя использовать в этом типе чата - ${typeChat}.`, user.username);
+    }
+    
+    onCooldown(bot, typeChat, user, timeLeft) {
+        bot.api.sendMessage(typeChat, `Команду ${this.name} можно будет использовать через ${timeLeft} сек.`, user.username);
+    }
+
+    onBlacklisted(bot, typeChat, user) {
+    }
+
+    async handler(bot, typeChat, user, args) {
+        throw new Error(`Handler не реализован для команды ${this.name}`);
+    }
+}
+
+module.exports = Command;

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

@@ -0,0 +1,98 @@
+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 };