blockmine 1.6.3 → 1.13.0

package/backend/src/core/PluginLoader.js

@@ -1,8 +1,36 @@
 
 const path = require('path');
 const fs = require('fs/promises');
+const { execSync } = require('child_process');
+const fssync = require('fs');
+const PluginStore = require('../plugins/PluginStore');
 
-async function initializePlugins(bot, installedPlugins = []) {
+const projectRoot = path.resolve(__dirname, '..');
+
+async function ensurePluginDependencies(pluginPath, pluginName) {
+    const packageJsonPath = path.join(pluginPath, 'package.json');
+    try {
+        if (fssync.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+            if (packageJson.dependencies && Object.keys(packageJson.dependencies).length > 0) {
+                console.log(`[PluginLoader] У плагина ${pluginName} есть зависимости, устанавливаем их...`);
+                try {
+                    execSync('npm install', { 
+                        cwd: pluginPath, 
+                        stdio: 'pipe' 
+                    });
+                    console.log(`[PluginLoader] Зависимости для плагина ${pluginName} установлены`);
+                } catch (installError) {
+                    console.error(`[PluginLoader] Ошибка установки зависимостей для ${pluginName}:`, installError.message);
+                }
+            }
+        }
+    } catch (error) {
+        console.error(`[PluginLoader] Ошибка чтения package.json для ${pluginName}:`, error.message);
+    }
+}
+
+async function initializePlugins(bot, installedPlugins = [], prisma) {
     if (!installedPlugins || installedPlugins.length === 0) return;
     
     const sendLog = bot.sendLog || console.log;
@@ -11,6 +39,8 @@ async function initializePlugins(bot, installedPlugins = []) {
     for (const plugin of installedPlugins) {
         if (plugin && plugin.path) {
             try {
+                await ensurePluginDependencies(plugin.path, plugin.name);
+
                 const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
                 const savedSettings = plugin.settings ? JSON.parse(plugin.settings) : {};
                 const defaultSettings = {};
@@ -38,20 +68,54 @@ async function initializePlugins(bot, installedPlugins = []) {
                 }
                 
                 const finalSettings = { ...defaultSettings, ...savedSettings };
+                const store = new PluginStore(prisma, bot.config.id, plugin.name);
                 
                 const mainFile = manifest.main || 'index.js';
                 const entryPointPath = path.join(plugin.path, mainFile);
                 const normalizedPath = entryPointPath.replace(/\\/g, '/');
                 
                 sendLog(`[PluginLoader] Загрузка: ${plugin.name} (v${plugin.version}) из ${normalizedPath}`);
-                const pluginModule = require(normalizedPath);
                 
-                if (typeof pluginModule === 'function') {
-                    pluginModule(bot, { settings: finalSettings });
-                } else if (pluginModule && typeof pluginModule.onLoad === 'function') {
-                    pluginModule.onLoad(bot, { settings: finalSettings });
-                } else {
-                    sendLog(`[PluginLoader] [ERROR] ${plugin.name} не экспортирует функцию или объект с методом onLoad.`);
+                try {
+                    const pluginModule = require(normalizedPath);
+                    
+                    if (typeof pluginModule === 'function') {
+                        pluginModule(bot, { settings: finalSettings, store });
+                    } else if (pluginModule && typeof pluginModule.onLoad === 'function') {
+                        pluginModule.onLoad(bot, { settings: finalSettings, store });
+                    } else {
+                        sendLog(`[PluginLoader] [ERROR] ${plugin.name} не экспортирует функцию или объект с методом onLoad.`);
+                    }
+                } catch (error) {
+                    if (error.message.includes('Cannot find module')) {
+                        const moduleMatch = error.message.match(/Cannot find module '([^']+)'/);
+                        if (moduleMatch) {
+                            const missingModule = moduleMatch[1];
+                            sendLog(`[PluginLoader] Попытка установки недостающего модуля ${missingModule} в папку плагина ${plugin.name}`);
+                            try {
+                                execSync(`npm install ${missingModule}`, { 
+                                    cwd: plugin.path, 
+                                    stdio: 'pipe' 
+                                });
+                                sendLog(`[PluginLoader] Модуль ${missingModule} успешно установлен в папку плагина ${plugin.name}, повторная попытка загрузки`);
+                                
+                                // Повторная попытка загрузки
+                                const pluginModule = require(normalizedPath);
+                                if (typeof pluginModule === 'function') {
+                                    pluginModule(bot, { settings: finalSettings, store });
+                                } else if (pluginModule && typeof pluginModule.onLoad === 'function') {
+                                    pluginModule.onLoad(bot, { settings: finalSettings, store });
+                                }
+                            } catch (installError) {
+                                sendLog(`[PluginLoader] Не удалось установить модуль ${missingModule} в папку плагина ${plugin.name}: ${installError.message}`);
+                                throw error; // Пробрасываем оригинальную ошибку
+                            }
+                        } else {
+                            throw error;
+                        }
+                    } else {
+                        throw error;
+                    }
                 }
 
             } catch (error) {

package/backend/src/core/PluginManager.js

@@ -277,6 +277,25 @@ class PluginManager {
         
         return await this.installFromGithub(botId, repoUrl, prisma, true);
     }
+
+    async clearPluginData(pluginId) {
+        const plugin = await prisma.installedPlugin.findUnique({ where: { id: pluginId } });
+        if (!plugin) {
+            throw new Error('Плагин не найден.');
+        }
+
+        console.log(`[PluginManager] Очистка данных для плагина ${plugin.name} (Bot ID: ${plugin.botId})`);
+
+        const { count } = await prisma.pluginDataStore.deleteMany({
+            where: {
+                pluginName: plugin.name,
+                botId: plugin.botId,
+            },
+        });
+
+        console.log(`[PluginManager] Удалено ${count} записей из хранилища.`);
+        return { count };
+    }
 }
 
 module.exports = PluginManager;

package/backend/src/plugins/PluginStore.js

@@ -0,0 +1,87 @@
+class PluginStore {
+    constructor(prisma, botId, pluginName) {
+        this.prisma = prisma;
+        this.botId = botId;
+        this.pluginName = pluginName;
+    }
+
+    async set(key, value) {
+        const jsonValue = JSON.stringify(value);
+        await this.prisma.pluginDataStore.upsert({
+            where: {
+                pluginName_botId_key: {
+                    pluginName: this.pluginName,
+                    botId: this.botId,
+                    key: key
+                }
+            },
+            update: {
+                value: jsonValue
+            },
+            create: {
+                pluginName: this.pluginName,
+                botId: this.botId,
+                key: key,
+                value: jsonValue
+            }
+        });
+    }
+
+    async get(key) {
+        const data = await this.prisma.pluginDataStore.findUnique({
+            where: {
+                pluginName_botId_key: {
+                    pluginName: this.pluginName,
+                    botId: this.botId,
+                    key: key
+                }
+            }
+        });
+        return data ? JSON.parse(data.value) : null;
+    }
+
+    async delete(key) {
+        try {
+            await this.prisma.pluginDataStore.delete({
+                where: {
+                    pluginName_botId_key: {
+                        pluginName: this.pluginName,
+                        botId: this.botId,
+                        key: key
+                    }
+                }
+            });
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async has(key) {
+        const count = await this.prisma.pluginDataStore.count({
+            where: {
+                pluginName: this.pluginName,
+                botId: this.botId,
+                key: key
+            }
+        });
+        return count > 0;
+    }
+
+    async getAll() {
+        const allData = await this.prisma.pluginDataStore.findMany({
+            where: {
+                pluginName: this.pluginName,
+                botId: this.botId
+            }
+        });
+        const map = new Map();
+        for (const item of allData) {
+            map.set(item.key, JSON.parse(item.value));
+        }
+        return map;
+    }
+}
+
+module.exports = PluginStore;
+

package/backend/src/real-time/socketHandler.js

@@ -1,6 +1,8 @@
 const { Server } = require('socket.io');
 const config = require('../config');
 
+const { botManager } = require('../core/services');
+
 let io;
 
 function initializeSocket(httpServer) {
@@ -16,14 +18,20 @@ function initializeSocket(httpServer) {
     });
 
     io.on('connection', (socket) => {
-        // console.log(`[Socket.IO] Пользователь подключен: ${socket.id}. Всего клиентов: ${io.engine.clientsCount}`);
         
         socket.on('disconnect', () => {
-            // console.log(`[Socket.IO] Пользователь отключен: ${socket.id}. Всего клиентов: ${io.engine.clientsCount}`);
+            botManager.handleSocketDisconnect(socket);
+        });
+
+        socket.on('plugin:ui:subscribe', ({ botId, pluginName }) => {
+            botManager.subscribeToPluginUi(botId, pluginName, socket);
+        });
+
+        socket.on('plugin:ui:unsubscribe', ({ botId, pluginName }) => {
+            botManager.unsubscribeFromPluginUi(botId, pluginName, socket);
         });
     });
     
-    // console.log('Socket.IO инициализирован с динамическим CORS.');
     return io;
 }
 

package/backend/src/server.js

@@ -19,6 +19,7 @@ const searchRoutes = require('./api/routes/search');
 const eventGraphsRouter = require('./api/routes/eventGraphs');
 const TaskScheduler = require('./core/TaskScheduler');
 const panelRoutes = require('./api/routes/panel');
+const changelogRoutes = require('./api/routes/changelog');
 
 const app = express();
 const server = http.createServer(app);
@@ -59,6 +60,7 @@ app.use('/api/servers', serverRoutes);
 app.use('/api/permissions', permissionsRoutes);
 app.use('/api/search', searchRoutes);
 app.use('/api/panel', panelRoutes);
+app.use('/api/changelog', changelogRoutes);
 
 app.use(express.static(frontendPath));
 

package/commitlint.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  extends: ['@commitlint/config-conventional']
+};