blockmine 1.3.21 → 1.4.0

package/backend/src/core/BotManager.js

@@ -4,11 +4,14 @@ const { getIO } = require('../real-time/socketHandler');
 const { PrismaClient } = require('@prisma/client');
 const pidusage = require('pidusage');
 const DependencyService = require('./DependencyService');
+const config = require('../config');
 
 const fs = require('fs');
 const os = require('os');
 const { v4: uuidv4 } = require('uuid');
 const crypto = require('crypto');
+const { decrypt } = require('./utils/crypto');
+
 
 const RealPermissionManager = require('./PermissionManager');
 const RealUserService = require('./UserService');
@@ -19,23 +22,10 @@ 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 {
-        if (!fs.existsSync(DATA_DIR)) {
-            fs.mkdirSync(DATA_DIR, { recursive: true });
-        }
-        instanceId = fs.readFileSync(idPath, 'utf-8');
-    } catch (e) {
-        instanceId = uuidv4();
-        fs.writeFileSync(idPath, instanceId, 'utf-8');
-    }
-}
 
 class BotManager {
     constructor() {
@@ -47,7 +37,7 @@ class BotManager {
         setInterval(() => this.updateAllResourceUsage(), 5000);
         
 
-        if (TELEMETRY_ENABLED && STATS_SERVER_URL) {
+        if (config.telemetry?.enabled) {
             setInterval(() => this.sendHeartbeat(), 5 * 60 * 1000);
         }
     }
@@ -90,6 +80,8 @@ class BotManager {
     }
 
     triggerHeartbeat() {
+        if (!config.telemetry?.enabled) return;
+
         if (this.heartbeatDebounceTimer) {
             clearTimeout(this.heartbeatDebounceTimer);
         }
@@ -112,6 +104,8 @@ class BotManager {
 
 
     async sendHeartbeat() {
+        if (!config.telemetry?.enabled) return;
+
         if (!instanceId) return;
 
         try {
@@ -325,7 +319,15 @@ class BotManager {
             return { success: false, message: 'Критические ошибки в зависимостях плагинов.' };
         }
         
-        const fullBotConfig = { ...botConfig, plugins: sortedPlugins };
+        const decryptedConfig = { ...botConfig };
+        if (decryptedConfig.password) {
+            decryptedConfig.password = decrypt(decryptedConfig.password);
+        }
+        if (decryptedConfig.proxyPassword) {
+            decryptedConfig.proxyPassword = decrypt(decryptedConfig.proxyPassword);
+        }
+
+        const fullBotConfig = { ...decryptedConfig, plugins: sortedPlugins };
         
         const botProcessPath = path.resolve(__dirname, 'BotProcess.js');
         const child = fork(botProcessPath, [], { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] });

package/backend/src/core/utils/crypto.js

@@ -0,0 +1,49 @@
+
+const crypto = require('crypto');
+const config = require('../../config');
+
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 16;
+const AUTH_TAG_LENGTH = 16;
+const KEY = Buffer.from(config.security.encryptionKey, 'hex');
+
+function encrypt(text) {
+    if (!text) return null;
+    try {
+        const iv = crypto.randomBytes(IV_LENGTH);
+        const cipher = crypto.createCipheriv(ALGORITHM, KEY, iv);
+        const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+        const authTag = cipher.getAuthTag();
+        
+        return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted.toString('hex')}`;
+    } catch (error) {
+        console.error('[Crypto] Ошибка шифрования:', error);
+        return null;
+    }
+}
+
+function decrypt(hash) {
+    if (!hash) return null;
+    try {
+        const parts = hash.split(':');
+        if (parts.length !== 3) {
+            console.error('[Crypto] Неверный формат зашифрованных данных. Возвращаем как есть.');
+            return hash;
+        }
+
+        const iv = Buffer.from(parts[0], 'hex');
+        const authTag = Buffer.from(parts[1], 'hex');
+        const encrypted = Buffer.from(parts[2], 'hex');
+
+        const decipher = crypto.createDecipheriv(ALGORITHM, KEY, iv);
+        decipher.setAuthTag(authTag);
+        
+        const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+        return decrypted.toString('utf8');
+    } catch (error) {
+        console.error('[Crypto] Ошибка дешифрования. Возможно, ключ был изменен или данные повреждены.', error);
+        return null;
+    }
+}
+
+module.exports = { encrypt, decrypt };

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

@@ -1,23 +1,31 @@
 const { Server } = require('socket.io');
+const config = require('../config');
 
 let io;
 
 function initializeSocket(httpServer) {
+    const corsOptions = {
+        methods: ["GET", "POST"]
+    };
+
+    if (config.server.allowExternalAccess) {
+        corsOptions.origin = "*";
+    } else {
+        corsOptions.origin = "http://localhost:5173";
+    }
+
     io = new Server(httpServer, {
-        cors: {
-            origin: "http://localhost:5173",
-            methods: ["GET", "POST"]
-        }
+        cors: corsOptions
     });
 
     io.on('connection', (socket) => {
-        console.log('A user connected to Socket.IO');
+        console.log('Socket.IO: Пользователь подключен -', socket.id);
         socket.on('disconnect', () => {
-            console.log('User disconnected');
+            console.log('Socket.IO: Пользователь отключен -', socket.id);
         });
     });
     
-    console.log('Socket.IO initialized');
+    console.log('Socket.IO инициализирован с CORS для:', corsOptions.origin);
     return io;
 }
 

package/backend/src/server.js

@@ -2,49 +2,56 @@ const express = require('express');
 const http = require('http');
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 
+const config = require('./config'); 
 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 authRoutes = require('./api/routes/auth');
 const BotManager = require('./core/BotManager');
 const TaskScheduler = require('./core/TaskScheduler');
+const panelRoutes = require('./api/routes/panel');
+
 
 const app = express();
 const server = http.createServer(app);
 
-initializeSocket(server);
+initializeSocket(server); 
 
-const PORT = process.env.PORT || 3001;
+const PORT = config.server.port;
+const HOST = config.server.host;
 
 app.use(express.json());
 
-
 const frontendPath = path.resolve(__dirname, '..', '..', 'frontend', 'dist');
 const rootPath = path.resolve(__dirname, '..', '..');
 
-
-app.get('/api/version', async (req, res) => {
-    try {
-        const packageJsonPath = path.join(rootPath, 'package.json');
-        const packageJsonData = await fs.promises.readFile(packageJsonPath, 'utf-8');
-        const { version } = JSON.parse(packageJsonData);
-        res.json({ version });
-    } catch (error) {
-        console.error("Failed to read app version:", error);
-        res.status(500).json({ error: 'Could not retrieve app version.' });
+app.use('/api/auth', authRoutes);
+
+app.use('/api/version', (req, res, next) => {
+    async function getVersion() {
+        try {
+            const packageJsonPath = path.join(rootPath, 'package.json');
+            const packageJsonData = await fs.promises.readFile(packageJsonPath, 'utf-8');
+            const { version } = JSON.parse(packageJsonData);
+            res.json({ version });
+        } catch (error) {
+            console.error("Failed to read app version:", error);
+            res.status(500).json({ error: 'Could not retrieve app version.' });
+        }
     }
+    getVersion();
 });
-
 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('/api/panel', panelRoutes);
 
 app.use(express.static(frontendPath));
 
@@ -56,23 +63,39 @@ app.get(/^(?!\/api).*/, (req, res) => {
     } else {
         console.error(`Критическая ошибка: файл index.html не найден по пути ${indexPath}`);
         res.status(404).send(
-            '<h1>Файлы фронтенда не найдены!1!!!!111</h1>'
+            '<h1>Файлы фронтенда не найдены! Соберите фронтенд командой "npm run build --workspace=frontend"</h1>'
         );
     }
 });
 
 async function startServer() {
     return new Promise((resolve) => {
-        server.listen(PORT, async () => {
-            console.log(`Backend сервер успешно запущен на http://localhost:${PORT}`);
-            console.log(`Панель управления доступна по адресу: http://localhost:${PORT}`);
+        server.listen(PORT, HOST, async () => {
+            console.log(`\nBackend сервер успешно запущен на http://${HOST}:${PORT}`);
+            
+            if (HOST === '0.0.0.0') {
+                const networkInterfaces = os.networkInterfaces();
+                console.log('Панель управления доступна по следующим адресам:');
+                console.log(`  - Локально: http://localhost:${PORT}`);
+                Object.keys(networkInterfaces).forEach(ifaceName => {
+                    networkInterfaces[ifaceName].forEach(iface => {
+                        if (iface.family === 'IPv4' && !iface.internal) {
+                            console.log(`  - В сети: http://${iface.address}:${PORT}`);
+                        }
+                    });
+                });
+                console.log('  - А также по вашему внешнему IP адресу.');
+
+            } else {
+                console.log(`Панель управления доступна по адресу: http://localhost:${PORT}`);
+            }
+            
             await TaskScheduler.initialize();
             resolve(server);
         });
     });
 }
 
-
 const gracefulShutdown = (signal) => {
     console.log(`[Shutdown] Получен сигнал ${signal}. Начинаем завершение...`);