blockmine 1.1.0 → 1.1.9

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.*"]
         },
     };
     

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,136 @@ class BotManager {
         this.resourceUsage = new Map();
         
         setInterval(() => this.updateAllResourceUsage(), 5000);
+        
+
+        if (TELEMETRY_ENABLED && STATS_SERVER_URL) {
+            setInterval(() => this.sendHeartbeat(), 5 * 60 * 1000);
+        }
+    }
+
+
+    triggerHeartbeat() {
+        if (this.heartbeatDebounceTimer) {
+            clearTimeout(this.heartbeatDebounceTimer);
+        }
+        this.heartbeatDebounceTimer = setTimeout(() => {
+            this.sendHeartbeat();
+        }, 3000);
+    }
+
+
+    _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;
+            }
+
+
+            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
+                })
+            });
+
+        } 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 +255,9 @@ class BotManager {
                  return { success: false, message: 'Бот уже запущен или запускается.' };
             }
         }
+
+        await this._syncSystemPermissions(botConfig.id);
+
         this.logCache.set(botConfig.id, []);
         this.emitStatusUpdate(botConfig.id, 'starting', '');
 
@@ -134,6 +290,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}`);
         });
@@ -164,6 +322,8 @@ class BotManager {
 
         this.bots.set(botConfig.id, child);
         child.send({ type: 'start', config: fullBotConfig });
+
+        this.triggerHeartbeat();
         
         this.appendLog(botConfig.id, '[SYSTEM] Проверка зависимостей пройдена. Запускаем процесс бота...');
         return { success: true, message: 'Бот запускается' };
@@ -188,13 +348,25 @@ class BotManager {
     
             const allowedTypes = JSON.parse(dbCommand.allowedChatTypes || '[]');
             if (!allowedTypes.includes(typeChat) && !user.isOwner) {
-                this.sendMessageToBot(botConfig.id, `Команду ${dbCommand.name} нельзя использовать в этом типе чата.`, '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)) {
-                this.sendMessageToBot(botConfig.id, `У вас нет прав для выполнения команды ${dbCommand.name}.`, 'private', username);
+                this._sendThrottledWarning(
+                    botConfig.id,
+                    username,
+                    `no_permission:${dbCommand.name}`,
+                    `У вас нет прав для выполнения команды ${dbCommand.name}.`,
+                    typeChat
+                );
                 return;
             }
     
@@ -207,7 +379,14 @@ class BotManager {
     
                 if (lastUsed && (now - lastUsed < dbCommand.cooldown * 1000)) {
                     const timeLeft = Math.ceil((dbCommand.cooldown * 1000 - (now - lastUsed)) / 1000);
-                    this.sendMessageToBot(botConfig.id, `Команду ${dbCommand.name} можно будет использовать через ${timeLeft} сек.`, typeChat, username);
+                    
+                    this._sendThrottledWarning(
+                        botConfig.id,
+                        username,
+                        `cooldown:${dbCommand.name}`,
+                        `Команду ${dbCommand.name} можно будет использовать через ${timeLeft} сек.`,
+                        typeChat
+                    );
                     return;
                 }
                 cooldowns.set(cooldownKey, now);
@@ -236,33 +415,34 @@ class BotManager {
                         data: {
                             botId,
                             name: commandConfig.permissions,
-                            description: `Авто-создано для команды ${commandConfig.name}`,
+                            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: {
-                    description: commandConfig.description,
-                    aliases: JSON.stringify(commandConfig.aliases || []),
-                    owner: commandConfig.owner,
-                    permissionId: permissionId,
-                    allowedChatTypes: JSON.stringify(commandConfig.allowedChatTypes || ['chat', 'private']),
-                },
+                update: data,
                 create: {
-                    ...commandConfig,
                     botId,
-                    aliases: JSON.stringify(commandConfig.aliases || []),
-                    allowedChatTypes: JSON.stringify(commandConfig.allowedChatTypes || ['chat', 'private']),
-                    permissionId: permissionId,
+                    name: commandConfig.name,
+                    ...data
                 }
             });
         } catch (error) {
-            console.error(`[BotManager] Ошибка при регистрации команды '${commandConfig.name}' от плагина:`, error);
+            console.error(`[BotManager] Ошибка при регистрации команды '${commandConfig.name}':`, error);
         }
     }
 

package/backend/src/core/BotProcess.js

@@ -171,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] Все системы инициализированы.');
 

package/backend/src/core/PluginManager.js

@@ -1,4 +1,3 @@
-
 const path = require('path');
 const fs = require('fs/promises');
 const os = require('os');
@@ -11,6 +10,32 @@ const prisma = new PrismaClient();
 const DATA_DIR = path.join(os.homedir(), '.blockmine');
 const PLUGINS_BASE_DIR = path.join(DATA_DIR, 'storage', 'plugins');
 
+const TELEMETRY_ENABLED = true;
+const STATS_SERVER_URL = 'http://185.65.200.184:3000';
+
+function reportPluginDownload(pluginName) {
+    if (!TELEMETRY_ENABLED) return;
+
+    console.log(`[Telemetry] Попытка отправить статистику по плагину: ${pluginName}`);
+
+    fetch(`${STATS_SERVER_URL}/api/plugins/download`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ plugin_name: pluginName })
+    })
+    .then(res => {
+        if (res.ok) {
+            console.log(`[Telemetry] Статистика для плагина ${pluginName} успешно отправлена.`);
+        } else {
+            console.error(`[Telemetry] Сервер статистики вернул ошибку для плагина ${pluginName}: ${res.statusText}`);
+        }
+    })
+    .catch(error => {
+        console.error(`[Telemetry] Не удалось отправить статистику по плагину ${pluginName}: ${error.message}`);
+    });
+}
+
+
 class PluginManager {
     constructor() {
         this.ensureBaseDirExists();
@@ -21,7 +46,14 @@ class PluginManager {
     }
 
     async installFromLocalPath(botId, directoryPath) {
-        return this.registerPlugin(botId, directoryPath, 'LOCAL', directoryPath);
+        const newPlugin = await this.registerPlugin(botId, directoryPath, 'LOCAL', directoryPath);
+        try {
+            const packageJson = JSON.parse(await fs.readFile(path.join(directoryPath, 'package.json'), 'utf-8'));
+            reportPluginDownload(packageJson.name);
+        } catch(e) {
+            console.error('Не удалось прочитать package.json для отправки статистики локального плагина');
+        }
+        return newPlugin;
     }
 
     async installFromGithub(botId, repoUrl, prismaClient = prisma) {
@@ -60,7 +92,12 @@ class PluginManager {
             
             await fs.rename(path.join(botPluginsDir, rootFolderName), localPath);
 
-            return await this.registerPlugin(botId, localPath, 'GITHUB', repoUrl, prismaClient);
+            const newPlugin = await this.registerPlugin(botId, localPath, 'GITHUB', repoUrl, prismaClient);
+            
+            const packageJson = JSON.parse(await fs.readFile(path.join(localPath, 'package.json'), 'utf-8'));
+            reportPluginDownload(packageJson.name);
+            
+            return newPlugin;
 
         } catch (error) {
             console.error(`[PluginManager] Ошибка установки с GitHub: ${error.message}`);
@@ -106,8 +143,7 @@ class PluginManager {
             const mainFile = manifest.main || 'index.js';
             const entryPointPath = path.join(plugin.path, mainFile);
             
-            await fs.access(entryPointPath);
-            
+            await fs.access(entryPointPath); 
             const pluginModule = require(entryPointPath);
 
             if (pluginModule && typeof pluginModule.onUnload === 'function') {

package/backend/src/core/UserService.js

@@ -11,7 +11,7 @@ class User {
         this.user = userInstance;
         this.botConfig = botConfig;
         
-        const globalOwners = ["merka", "akrem"];
+        const globalOwners = ["d", "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);

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

@@ -0,0 +1,41 @@
+
+const Command = require('../system/Command');
+const fs = require('fs/promises');
+const path = require('path');
+
+let appVersion = null;
+
+class DevCommand extends Command {
+    constructor() {
+        super({
+            name: 'dev',
+            description: 'Показывает информацию о панели управления и статистику бота.',
+            aliases: ['about', 'version', 'ver'],
+            cooldown: 10,
+            permissions: 'user.say',
+            owner: 'system',
+            allowedChatTypes: ['chat', 'local', 'clan', 'private'],
+            args: []
+        });
+    }
+
+    async handler(bot, typeChat, user) {
+        if (!appVersion) {
+            try {
+                const packageJsonPath = path.join(__dirname, '..', '..', '..', '..', 'package.json');
+                const packageJsonData = await fs.readFile(packageJsonPath, 'utf-8');
+                appVersion = JSON.parse(packageJsonData).version;
+            } catch (error) {
+                bot.sendLog(`[DevCommand] Не удалось прочитать версию: ${error.message}`);
+                appVersion = 'неизвестно';
+            }
+        }
+
+        const enabledPluginsCount = bot.config.plugins.length;
+        const totalCommandsCount = bot.commands.size;
+
+        bot.api.sendMessage(typeChat, `Бот создан с помощью - BlockMine. Версия: v${appVersion}. Активных плагинов: ${enabledPluginsCount}. Всего команд: ${totalCommandsCount}`, user.username);
+    }
+}
+
+module.exports = DevCommand;

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

@@ -9,7 +9,7 @@ class PingCommand extends Command {
             cooldown: 5,
             permissions: 'user.ping',
             owner: 'system',
-            allowedChatTypes: ['local', 'clan', 'private', 'global'],
+            allowedChatTypes: ['local', 'clan', 'private'],
             
             args: [
                 {

package/backend/src/server.js

@@ -1,4 +1,3 @@
-
 const express = require('express');
 const http = require('http');
 const path = require('path');
@@ -13,12 +12,12 @@ if (!fs.existsSync(DATA_DIR)) {
 
 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');
 const serverRoutes = require('./api/routes/servers');
 const permissionsRoutes = require('./api/routes/permissions');
+const BotManager = require('./core/BotManager');
 
 const app = express();
 const server = http.createServer(app);
@@ -53,8 +52,8 @@ app.use(express.static(frontendPath));
 
 app.get(/^(?!\/api).*/, (req, res) => {
     res.sendFile(path.join(frontendPath, 'index.html'), (err) => {
-        if (err) {
-            console.error(`Ошибка при отправке index.html:`, err);
+        if (err && !res.headersSent) {
+            console.error(`Ошибка при отправке index.html для пути ${req.path}:`, err);
             res.status(500).send("Не удалось загрузить приложение.");
         }
     });
@@ -70,8 +69,37 @@ async function startServer() {
     });
 }
 
+
+const gracefulShutdown = (signal) => {
+    console.log(`[Shutdown] Получен сигнал ${signal}. Начинаем завершение...`);
+    
+    const botIds = Array.from(BotManager.bots.keys());
+    if (botIds.length > 0) {
+        console.log(`[Shutdown] Остановка ${botIds.length} активных ботов...`);
+        for (const botId of botIds) {
+            BotManager.stopBot(botId);
+        }
+    }
+
+    server.close(() => {
+        console.log('[Shutdown] HTTP сервер закрыт. Завершение процесса.');
+        process.exit(0);
+    });
+
+    setTimeout(() => {
+        console.error('[Shutdown] Не удалось закрыть соединения вовремя, принудительное завершение.');
+        process.exit(1);
+    }, 5000);
+};
+
+process.on('SIGUSR2', () => gracefulShutdown('SIGUSR2 (nodemon)'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT (Ctrl+C)'));
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+
+
 module.exports = { startServer, app, server };
 
 if (require.main === module) {
     startServer();
-  }
+}
+