blockmine 1.2.0 → 1.3.0

package/backend/src/core/BotManager.js

@@ -28,6 +28,9 @@ const DATA_DIR = path.join(os.homedir(), '.blockmine');
 if (TELEMETRY_ENABLED && STATS_SERVER_URL) {
     const idPath = path.join(DATA_DIR, '.instance_id');
     try {
+        if (!fs.existsSync(DATA_DIR)) {
+            fs.mkdirSync(DATA_DIR, { recursive: true });
+        }
         instanceId = fs.readFileSync(idPath, 'utf-8');
     } catch (e) {
         instanceId = uuidv4();
@@ -348,6 +351,11 @@ class BotManager {
     
             const allowedTypes = JSON.parse(dbCommand.allowedChatTypes || '[]');
             if (!allowedTypes.includes(typeChat) && !user.isOwner) {
+                
+                if (typeChat === 'global') {
+                    return;
+                }
+
                 this._sendThrottledWarning(
                     botConfig.id, 
                     username, 

package/backend/src/core/PluginManager.js

@@ -1,5 +1,5 @@
 const path = require('path');
-const fs = require('fs/promises');
+const fse = require('fs-extra');
 const os = require('os');
 const { PrismaClient } = require('@prisma/client');
 const AdmZip = require('adm-zip');
@@ -42,13 +42,13 @@ class PluginManager {
     }
 
     async ensureBaseDirExists() {
-        await fs.mkdir(PLUGINS_BASE_DIR, { recursive: true }).catch(console.error);
+        await fse.mkdir(PLUGINS_BASE_DIR, { recursive: true }).catch(console.error);
     }
 
     async installFromLocalPath(botId, 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'));
+            const packageJson = JSON.parse(await fse.readFile(path.join(directoryPath, 'package.json'), 'utf-8'));
             reportPluginDownload(packageJson.name);
         } catch(e) {
             console.error('Не удалось прочитать package.json для отправки статистики локального плагина');
@@ -58,7 +58,7 @@ class PluginManager {
 
     async installFromGithub(botId, repoUrl, prismaClient = prisma) {
         const botPluginsDir = path.join(PLUGINS_BASE_DIR, `bot_${botId}`);
-        await fs.mkdir(botPluginsDir, { recursive: true });
+        await fse.mkdir(botPluginsDir, { recursive: true });
 
         const existing = await prismaClient.installedPlugin.findFirst({ where: { botId, sourceUri: repoUrl } });
         if (existing) throw new Error(`Плагин из ${repoUrl} уже установлен.`);
@@ -88,13 +88,21 @@ class PluginManager {
             const repoName = path.basename(repoPath);
             const localPath = path.join(botPluginsDir, repoName);
             
+            if (await fse.pathExists(localPath)) {
+                await fse.remove(localPath);
+            }
+            const tempExtractPath = path.join(botPluginsDir, rootFolderName);
+            if (await fse.pathExists(tempExtractPath)) {
+                await fse.remove(tempExtractPath);
+            }
+            
             zip.extractAllTo(botPluginsDir, true);
             
-            await fs.rename(path.join(botPluginsDir, rootFolderName), localPath);
+            await fse.move(tempExtractPath, localPath, { overwrite: true });
 
             const newPlugin = await this.registerPlugin(botId, localPath, 'GITHUB', repoUrl, prismaClient);
             
-            const packageJson = JSON.parse(await fs.readFile(path.join(localPath, 'package.json'), 'utf-8'));
+            const packageJson = JSON.parse(await fse.readFile(path.join(localPath, 'package.json'), 'utf-8'));
             reportPluginDownload(packageJson.name);
             
             return newPlugin;
@@ -112,7 +120,7 @@ class PluginManager {
         const packageJsonPath = path.join(directoryPath, 'package.json');
         let packageJson;
         try {
-            packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+            packageJson = JSON.parse(await fse.readFile(packageJsonPath, 'utf-8'));
         } catch (e) {
             throw new Error(`Не удалось прочитать или распарсить package.json в плагине по пути: ${directoryPath}`);
         }
@@ -138,29 +146,67 @@ class PluginManager {
         const plugin = await prisma.installedPlugin.findUnique({ where: { id: pluginId } });
         if (!plugin) throw new Error('Плагин не найден');
 
+        const pluginOwnerId = `plugin:${plugin.name}`;
+        console.log(`[PluginManager] Начало удаления плагина ${plugin.name} (ID: ${plugin.id}) и его ресурсов.`);
+        console.log(`[PluginManager] Идентификатор владельца для очистки: ${pluginOwnerId}`);
+
         try {
             const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
             const mainFile = manifest.main || 'index.js';
             const entryPointPath = path.join(plugin.path, mainFile);
             
-            await fs.access(entryPointPath); 
-            const pluginModule = require(entryPointPath);
+            if (await fse.pathExists(entryPointPath)) {
+                if (require.cache[require.resolve(entryPointPath)]) {
+                    delete require.cache[require.resolve(entryPointPath)];
+                }
+                
+                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} успешно выполнен.`);
+                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} успешно выполнен.`);
+                }
+            } else {
+                 console.warn(`[PluginManager] Главный файл плагина ${entryPointPath} не найден. Хук onUnload пропущен.`);
             }
         } 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 }).catch(err => {
-                console.error(`Не удалось удалить папку плагина ${plugin.path}:`, err);
+        try {
+            await prisma.$transaction(async (tx) => {
+                const deletedCommands = await tx.command.deleteMany({
+                    where: { botId: plugin.botId, owner: pluginOwnerId },
+                });
+                if (deletedCommands.count > 0) console.log(`[DB Cleanup] Удалено команд: ${deletedCommands.count}`);
+
+                const deletedPermissions = await tx.permission.deleteMany({
+                    where: { botId: plugin.botId, owner: pluginOwnerId },
+                });
+                 if (deletedPermissions.count > 0) console.log(`[DB Cleanup] Удалено прав: ${deletedPermissions.count}`);
+
+                const deletedGroups = await tx.group.deleteMany({
+                    where: { botId: plugin.botId, owner: pluginOwnerId },
+                });
+                if (deletedGroups.count > 0) console.log(`[DB Cleanup] Удалено групп: ${deletedGroups.count}`);
+
+                await tx.installedPlugin.delete({ where: { id: pluginId } });
+                console.log(`[DB Cleanup] Запись о плагине ${plugin.name} удалена.`);
             });
+        } catch (dbError) {
+             console.error(`[PluginManager] Ошибка при очистке БД для плагина ${plugin.name}:`, dbError);
+             throw new Error('Ошибка при удалении данных плагина из БД. Файлы не были удалены.');
+        }
+
+        if (plugin.sourceType === 'GITHUB' || plugin.sourceType === 'IMPORTED') {
+            try {
+                await fse.remove(plugin.path);
+                console.log(`[PluginManager] Папка плагина ${plugin.path} успешно удалена.`);
+            } catch (fileError) {
+                console.error(`Не удалось удалить папку плагина ${plugin.path}:`, fileError);
+            }
         }
-        await prisma.installedPlugin.delete({ where: { id: pluginId } });
     }
 
     async checkForUpdates(botId, catalog) {

package/backend/src/core/TaskScheduler.js

@@ -0,0 +1,117 @@
+const cron = require('node-cron');
+const { PrismaClient } = require('@prisma/client');
+const BotManager = require('./BotManager');
+
+const prisma = new PrismaClient();
+
+class TaskScheduler {
+    constructor() {
+        this.scheduledJobs = new Map();
+        console.log('[TaskScheduler] Сервис планировщика инициализирован.');
+    }
+
+    async initialize() {
+        console.log('[TaskScheduler] Загрузка и планирование активных задач из БД...');
+        const tasks = await prisma.scheduledTask.findMany({ where: { isEnabled: true } });
+        
+        tasks.forEach(task => {
+            this.scheduleTask(task);
+        });
+
+        console.log(`[TaskScheduler] Запланировано ${this.scheduledJobs.size} задач.`);
+    }
+
+    async executeTask(task) {
+        console.log(`[TaskScheduler] Выполнение задачи: "${task.name}" (ID: ${task.id})`);
+        let botIds = [];
+        
+        try {
+            const targetIds = JSON.parse(task.targetBotIds);
+            if (Array.isArray(targetIds) && targetIds[0] === 'ALL') {
+                const allBots = await prisma.bot.findMany({ select: { id: true } });
+                botIds = allBots.map(b => b.id);
+            } else {
+                botIds = targetIds.map(id => parseInt(id, 10));
+            }
+        } catch (e) {
+            console.error(`[TaskScheduler] Ошибка парсинга targetBotIds для задачи ${task.id}:`, e.message);
+            return;
+        }
+
+        for (const botId of botIds) {
+            try {
+                const botConfig = await prisma.bot.findUnique({ where: { id: botId }, include: { server: true } });
+                if (!botConfig) continue;
+
+                switch (task.action) {
+                    case 'START_BOT':
+                        console.log(` -> Запуск бота ${botConfig.username}`);
+                        if (!BotManager.bots.has(botId)) await BotManager.startBot(botConfig);
+                        break;
+                    case 'STOP_BOT':
+                        console.log(` -> Остановка бота ${botConfig.username}`);
+                        if (BotManager.bots.has(botId)) BotManager.stopBot(botId);
+                        break;
+                    case 'RESTART_BOT':
+                        console.log(` -> Перезапуск бота ${botConfig.username}`);
+                        if (BotManager.bots.has(botId)) {
+                            BotManager.stopBot(botId);
+                            setTimeout(() => BotManager.startBot(botConfig), 5000); 
+                        } else {
+                            await BotManager.startBot(botConfig);
+                        }
+                        break;
+                    case 'SEND_COMMAND':
+                        if (BotManager.bots.has(botId)) {
+                            const payload = JSON.parse(task.payload || '{}');
+                            if (payload.command) {
+                                console.log(` -> Отправка команды "${payload.command}" боту ${botConfig.username}`);
+                                BotManager.sendMessageToBot(botId, payload.command);
+                            }
+                        }
+                        break;
+                }
+            } catch (error) {
+                console.error(`[TaskScheduler] Ошибка выполнения действия для бота ID ${botId}:`, error);
+            }
+        }
+        await prisma.scheduledTask.update({ where: { id: task.id }, data: { lastRun: new Date() } });
+    }
+
+    scheduleTask(task) {
+        if (this.scheduledJobs.has(task.id)) {
+            this.unscheduleTask(task.id);
+        }
+
+        if (!cron.validate(task.cronPattern)) {
+            console.error(`[TaskScheduler] Неверный cron-паттерн для задачи ID ${task.id}: ${task.cronPattern}`);
+            return;
+        }
+
+        const job = cron.schedule(task.cronPattern, () => this.executeTask(task), {
+            scheduled: true,
+            timezone: "Europe/Moscow"
+        });
+
+        this.scheduledJobs.set(task.id, job);
+        console.log(`[TaskScheduler] Задача "${task.name}" запланирована с паттерном: ${task.cronPattern}`);
+    }
+
+    unscheduleTask(taskId) {
+        const job = this.scheduledJobs.get(taskId);
+        if (job) {
+            job.stop();
+            this.scheduledJobs.delete(taskId);
+            console.log(`[TaskScheduler] Задача ID ${taskId} снята с планирования.`);
+        }
+    }
+
+    async updateTask(updatedTask) {
+        this.unscheduleTask(updatedTask.id);
+        if (updatedTask.isEnabled) {
+            this.scheduleTask(updatedTask);
+        }
+    }
+}
+
+module.exports = new TaskScheduler();

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

@@ -1,31 +1,31 @@
-const { Server } = require('socket.io');
-
-let io;
-
-function initializeSocket(httpServer) {
-    io = new Server(httpServer, {
-        cors: {
-            origin: "http://localhost:5173",
-            methods: ["GET", "POST"]
-        }
-    });
-
-    io.on('connection', (socket) => {
-        console.log('A user connected to Socket.IO');
-        socket.on('disconnect', () => {
-            console.log('User disconnected');
-        });
-    });
-    
-    console.log('Socket.IO initialized');
-    return io;
-}
-
-function getIO() {
-    if (!io) {
-        throw new Error("Socket.IO not initialized!");
-    }
-    return io;
-}
-
+const { Server } = require('socket.io');
+
+let io;
+
+function initializeSocket(httpServer) {
+    io = new Server(httpServer, {
+        cors: {
+            origin: "http://localhost:5173",
+            methods: ["GET", "POST"]
+        }
+    });
+
+    io.on('connection', (socket) => {
+        console.log('A user connected to Socket.IO');
+        socket.on('disconnect', () => {
+            console.log('User disconnected');
+        });
+    });
+    
+    console.log('Socket.IO initialized');
+    return io;
+}
+
+function getIO() {
+    if (!io) {
+        throw new Error("Socket.IO not initialized!");
+    }
+    return io;
+}
+
 module.exports = { initializeSocket, getIO };

package/backend/src/server.js

@@ -2,22 +2,15 @@ const express = require('express');
 const http = require('http');
 const path = require('path');
 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');
 const serverRoutes = require('./api/routes/servers');
 const permissionsRoutes = require('./api/routes/permissions');
+const taskRoutes = require('./api/routes/tasks');
 const BotManager = require('./core/BotManager');
+const TaskScheduler = require('./core/TaskScheduler');
 
 const app = express();
 const server = http.createServer(app);
@@ -28,8 +21,10 @@ const PORT = process.env.PORT || 3001;
 
 app.use(express.json());
 
-const frontendPath = path.join(__dirname, '..', '..', 'frontend', 'dist');
-const rootPath = path.join(__dirname, '..', '..');
+
+const frontendPath = path.resolve(__dirname, '..', '..', 'frontend', 'dist');
+const rootPath = path.resolve(__dirname, '..', '..');
+
 
 app.get('/api/version', async (req, res) => {
     try {
@@ -43,27 +38,35 @@ app.get('/api/version', async (req, res) => {
     }
 });
 
+app.use('/api/tasks', taskRoutes);
 app.use('/api/bots', botRoutes);
 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) => {
-    res.sendFile(path.join(frontendPath, 'index.html'), (err) => {
-        if (err && !res.headersSent) {
-            console.error(`Ошибка при отправке index.html для пути ${req.path}:`, err);
-            res.status(500).send("Не удалось загрузить приложение.");
-        }
-    });
+    const indexPath = path.join(frontendPath, 'index.html');
+    
+    if (fs.existsSync(indexPath)) {
+        res.sendFile(indexPath);
+    } else {
+        console.error(`Критическая ошибка: файл index.html не найден по пути ${indexPath}`);
+        res.status(404).send(
+            '<h1>Файлы фронтенда не найдены!1!!!!111</h1>'
+        );
+    }
 });
 
 async function startServer() {
     return new Promise((resolve) => {
-        server.listen(PORT, () => {
+        server.listen(PORT, async () => {
             console.log(`Backend сервер успешно запущен на http://localhost:${PORT}`);
             console.log(`Панель управления доступна по адресу: http://localhost:${PORT}`);
+            await TaskScheduler.initialize();
             resolve(server);
         });
     });
@@ -101,5 +104,4 @@ module.exports = { startServer, app, server };
 
 if (require.main === module) {
     startServer();
-}
-
+}