blockmine 1.3.22 → 1.4.1

package/backend/cli.js

@@ -1,25 +1,23 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execSync } = require('child_process');
+
+const config = require('./src/config.js'); 
 const { startServer } = require('./src/server.js');
 
 const DATA_DIR = path.join(os.homedir(), '.blockmine');
 if (!fs.existsSync(DATA_DIR)) {
     fs.mkdirSync(DATA_DIR, { recursive: true });
 }
-process.env.DATABASE_URL = `file:${path.join(DATA_DIR, 'blockmine.db')}`;
-
-if (os.platform() === 'android') {
-    process.env.PRISMA_CLI_BINARY_TARGETS = 'linux-arm64-openssl-1.1.x';
-}
 
+process.env.DATABASE_URL = `file:${path.join(DATA_DIR, 'blockmine.db')}`;
 
 function runCommand(command) {
     try {
         console.log(`> ${command}`);
-        execSync(command, { stdio: 'inherit', cwd: __dirname, env: process.env });
+        execSync(command, { stdio: 'inherit', cwd: __dirname });
     } catch (e) {
         console.error(`Команда "${command}" не удалась:`, e);
         process.exit(1);

package/backend/package.json

@@ -18,6 +18,7 @@
     "@prisma/client": "^5.14.0",
     "adm-zip": "^0.5.16",
     "archiver": "^7.0.1",
+    "bcryptjs": "^3.0.2",
     "cron-parser": "^5.3.0",
     "express": "^4.19.2",
     "fs-extra": "^11.3.0",
@@ -34,4 +35,4 @@
     "nodemon": "^3.1.2",
     "prisma": "^5.14.0"
   }
-}
+}

package/backend/prisma/migrations/20250617133815_add_panel_users_and_roles/migration.sql

@@ -0,0 +1,26 @@
+-- CreateTable
+CREATE TABLE "PanelUser" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "uuid" TEXT NOT NULL,
+    "username" TEXT NOT NULL,
+    "passwordHash" TEXT NOT NULL,
+    "roleId" INTEGER NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "PanelUser_roleId_fkey" FOREIGN KEY ("roleId") REFERENCES "PanelRole" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "PanelRole" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "name" TEXT NOT NULL,
+    "permissions" TEXT NOT NULL DEFAULT '[]'
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "PanelUser_uuid_key" ON "PanelUser"("uuid");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "PanelUser_username_key" ON "PanelUser"("username");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "PanelRole_name_key" ON "PanelRole"("name");

package/backend/prisma/schema.prisma

@@ -1,6 +1,5 @@
 generator client {
   provider = "prisma-client-js"
-  binaryTargets = ["native", "linux-arm64-openssl-1.1.x"] 
 }
 
 datasource db {
@@ -149,4 +148,25 @@ model ScheduledTask {
   lastRun      DateTime?
   createdAt    DateTime   @default(now())
   updatedAt    DateTime   @updatedAt
+}
+
+model PanelUser {
+  id           Int      @id @default(autoincrement())
+  uuid         String   @unique @default(uuid())
+  username     String   @unique
+  passwordHash String  
+  role         PanelRole @relation(fields: [roleId], references: [id])
+  roleId       Int
+  createdAt    DateTime @default(now())
+}
+
+// Роли пользователей (Admin, Moderator, Viewer)
+model PanelRole {
+  id          Int      @id @default(autoincrement())
+  name        String   @unique // Например, "Admin", "Moderator", "Viewer"
+  
+  // Храним права как джсон строку.  SQLite не поддерживает массивы.
+  // Пример: '["bot:create", "bot:delete", "user:manage"]'
+  permissions String   @default("[]") 
+  users       PanelUser[]
 }

package/backend/src/api/middleware/auth.js

@@ -0,0 +1,59 @@
+
+const jwt = require('jsonwebtoken');
+const config = require('../../config');
+
+const JWT_SECRET = config.security.jwtSecret;
+
+/**
+ * Middleware для проверки JWT-токена.
+ * Извлекает токен из заголовка Authorization, проверяет его подлинность
+ * и добавляет расшифрованные данные (payload) в req.user.
+ */
+function authenticate(req, res, next) {
+    const authHeader = req.header('Authorization');
+
+    if (!authHeader) {
+        return res.status(401).json({ error: 'Нет токена, доступ запрещен' });
+    }
+    
+    const tokenParts = authHeader.split(' ');
+    if (tokenParts.length !== 2 || tokenParts[0] !== 'Bearer') {
+        return res.status(401).json({ error: 'Неверный формат токена' });
+    }
+
+    const token = tokenParts[1];
+
+    try {
+        const decoded = jwt.verify(token, JWT_SECRET);
+        req.user = decoded;
+        next();
+    } catch (err) {
+        res.status(401).json({ error: 'Невалидный токен' });
+    }
+}
+
+/**
+ * Middleware-фабрика для проверки прав доступа.
+ * @param {string} requiredPermission - Право, необходимое для доступа к роуту (например, 'bot:delete').
+ * @returns {function} - Express middleware.
+ */
+function authorize(requiredPermission) {
+    return (req, res, next) => {
+        if (!req.user || !req.user.permissions) {
+            return res.status(403).json({ error: 'Ошибка прав доступа: пользователь не аутентифицирован.' });
+        }
+
+        const userPermissions = req.user.permissions;
+
+        if (userPermissions.includes('*') || userPermissions.includes(requiredPermission)) {
+            next();
+        } else {
+            res.status(403).json({ error: 'Доступ запрещен: недостаточно прав.' });
+        }
+    };
+}
+
+module.exports = {
+    authenticate,
+    authorize,
+};

package/backend/src/api/routes/auth.js

@@ -0,0 +1,445 @@
+
+const express = require('express');
+const bcrypt = require('bcryptjs');
+const jwt = require('jsonwebtoken');
+const { PrismaClient } = require('@prisma/client');
+const config = require('../../config');
+const { authenticate, authorize } = require('../middleware/auth');
+
+const router = express.Router();
+const prisma = new PrismaClient();
+
+const JWT_SECRET = config.security.jwtSecret;
+const JWT_EXPIRES_IN = '7d';
+
+/**
+ * @route   GET /api/auth/status
+ * @desc    Проверяет, была ли произведена первоначальная настройка (создан админ)
+ * @access  Public
+ */
+router.get('/status', async (req, res) => {
+    try {
+        const userCount = await prisma.panelUser.count();
+        res.json({ needsSetup: userCount === 0 });
+    } catch (error) {
+        console.error('[Auth Status Error]', error);
+        res.status(500).json({ error: 'Не удалось проверить статус сервера' });
+    }
+});
+
+/**
+ * @route   POST /api/auth/setup
+ * @desc    Создает первого пользователя с ролью администратора
+ * @access  Public (только если нет других пользователей)
+ */
+router.post('/setup', async (req, res) => {
+    try {
+        const userCount = await prisma.panelUser.count();
+        if (userCount > 0) {
+            return res.status(403).json({ error: 'Настройка уже произведена.' });
+        }
+
+        const { username, password } = req.body;
+        if (!username || !password || password.length < 4) {
+            return res.status(400).json({ error: 'Имя пользователя и пароль (минимум 4 символа) обязательны.' });
+        }
+
+        const hashedPassword = await bcrypt.hash(password, 12);
+        
+        let newUser; 
+
+        await prisma.$transaction(async (tx) => {
+            const adminRole = await tx.panelRole.upsert({
+                where: { name: 'Admin' },
+                update: {},
+                create: {
+                    name: 'Admin',
+                    permissions: JSON.stringify(['*'])
+                },
+            });
+
+            newUser = await tx.panelUser.create({
+                data: {
+                    username,
+                    passwordHash: hashedPassword,
+                    roleId: adminRole.id,
+                },
+                include: { role: true }
+            });
+        });
+
+
+        const permissions = JSON.parse(newUser.role.permissions || '[]');
+        
+        const payload = {
+            userId: newUser.id,
+            username: newUser.username,
+            permissions: permissions,
+        };
+
+        const token = jwt.sign(payload, JWT_SECRET, { expiresIn: JWT_EXPIRES_IN });
+
+        res.status(201).json({
+            token,
+            user: {
+                id: newUser.id,
+                username: newUser.username,
+                permissions: permissions,
+            }
+        });
+
+    } catch (error) {
+        if (error.code === 'P2002') {
+             return res.status(409).json({ error: 'Пользователь с таким именем уже существует.' });
+        }
+        console.error('[Setup Error]', error);
+        res.status(500).json({ error: 'Не удалось создать администратора' });
+    }
+});
+
+/**
+ * @route   POST /api/auth/login
+ * @desc    Аутентифицирует пользователя и возвращает токен
+ * @access  Public
+ */
+router.post('/login', async (req, res) => {
+    try {
+        const { username, password } = req.body;
+        if (!username || !password) {
+            return res.status(400).json({ error: 'Имя пользователя и пароль обязательны' });
+        }
+
+        const user = await prisma.panelUser.findUnique({
+            where: { username },
+            include: { role: true },
+        });
+
+        if (!user) {
+            return res.status(401).json({ error: 'Неверные учетные данные' });
+        }
+
+        const isMatch = await bcrypt.compare(password, user.passwordHash);
+        if (!isMatch) {
+            return res.status(401).json({ error: 'Неверные учетные данные' });
+        }
+
+        const permissions = JSON.parse(user.role.permissions || '[]');
+
+        const payload = {
+            userId: user.id,
+            username: user.username,
+            permissions: permissions,
+        };
+
+        const token = jwt.sign(payload, JWT_SECRET, { expiresIn: JWT_EXPIRES_IN });
+
+        res.json({
+            token,
+            user: {
+                id: user.id,
+                username: user.username,
+                permissions: permissions,
+            }
+        });
+
+    } catch (error) {
+        console.error('[Login Error]', error);
+        res.status(500).json({ error: 'Ошибка входа в систему' });
+    }
+});
+
+
+/**
+ * @route   GET /api/auth/me
+ * @desc    Получить данные текущего пользователя по токену
+ * @access  Private
+ */
+router.get('/me', authenticate, async (req, res) => {
+    try {
+        const user = await prisma.panelUser.findUnique({
+            where: { id: req.user.userId },
+            select: { id: true, username: true, role: { select: { permissions: true } } }
+        });
+
+        if (!user) {
+            return res.status(404).json({ error: "Пользователь не найден." });
+        }
+        
+        res.json({
+            id: user.id,
+            username: user.username,
+            permissions: JSON.parse(user.role.permissions || '[]')
+        });
+    } catch (error) {
+        res.status(500).json({ error: "Ошибка сервера" });
+    }
+});
+
+
+/**
+ * @route   GET /api/auth/users
+ * @desc    Получить всех пользователей и их роли
+ * @access  Private (Admin only)
+ */
+router.get('/users', authenticate, authorize('panel:user:list'), async (req, res) => {
+    try {
+        const users = await prisma.panelUser.findMany({
+            include: { role: true },
+            orderBy: { username: 'asc' }
+        });
+        res.json(users);
+    } catch (error) {
+        res.status(500).json({ error: 'Не удалось получить пользователей' });
+    }
+});
+
+/**
+ * @route   POST /api/auth/users
+ * @desc    Создать нового пользователя
+ * @access  Private (Admin only)
+ */
+router.post('/users', authenticate, authorize('panel:user:create'), async (req, res) => {
+    const { username, password, roleId } = req.body;
+    if (!username || !password || !roleId) {
+        return res.status(400).json({ error: 'Имя, пароль и роль обязательны' });
+    }
+     if (password.length < 4) {
+        return res.status(400).json({ error: 'Пароль должен быть не менее 4 символов' });
+    }
+
+    try {
+        const hashedPassword = await bcrypt.hash(password, 12);
+        const newUser = await prisma.panelUser.create({
+            data: {
+                username,
+                passwordHash: hashedPassword,
+                roleId: parseInt(roleId, 10)
+            },
+            include: { role: true }
+        });
+        const { passwordHash, ...userToReturn } = newUser;
+        res.status(201).json(userToReturn);
+    } catch (error) {
+        if (error.code === 'P2002') {
+            return res.status(409).json({ error: 'Пользователь с таким именем уже существует' });
+        }
+        res.status(500).json({ error: 'Не удалось создать пользователя' });
+    }
+});
+
+
+/**
+ * @route   GET /api/auth/roles
+ * @desc    Получить все роли
+ * @access  Private (Admin only)
+ */
+router.get('/roles', authenticate, authorize('panel:role:list'), async (req, res) => {
+    try {
+        const roles = await prisma.panelRole.findMany();
+        const rolesWithParsedPermissions = roles.map(role => ({
+            ...role,
+            permissions: JSON.parse(role.permissions || '[]')
+        }));
+        res.json(rolesWithParsedPermissions);
+    } catch (error) {
+        res.status(500).json({ error: 'Не удалось получить роли' });
+    }
+});
+
+const ALL_PERMISSIONS = [
+    { id: '*', label: 'Все права (Администратор)' },
+    { id: 'bot:list', label: 'Просмотр ботов' },
+    { id: 'bot:create', label: 'Создание ботов' },
+    { id: 'bot:update', label: 'Редактирование ботов' },
+    { id: 'bot:delete', label: 'Удаление ботов' },
+    { id: 'bot:start_stop', label: 'Запуск/остановка ботов' },
+    { id: 'bot:interact', label: 'Взаимодействие с ботом (консоль)' },
+    { id: 'bot:export', label: 'Экспорт ботов' },
+    { id: 'bot:import', label: 'Импорт ботов' },
+    { id: 'management:view', label: 'Просмотр вкладки "Управление" у бота' },
+    { id: 'management:edit', label: 'Редактирование на вкладке "Управление" у бота' },
+    { id: 'plugin:list', label: 'Просмотр плагинов' },
+    { id: 'plugin:install', label: 'Установка плагинов' },
+    { id: 'plugin:delete', label: 'Удаление плагинов' },
+    { id: 'plugin:update', label: 'Обновление плагинов' },
+    { id: 'plugin:settings:view', label: 'Просмотр настроек плагинов' },
+    { id: 'plugin:settings:edit', label: 'Редактирование настроек плагинов' },
+    { id: 'plugin:browse', label: 'Просмотр каталога плагинов' },
+    { id: 'server:list', label: 'Просмотр серверов' },
+    { id: 'server:create', label: 'Создание серверов' },
+    { id: 'server:delete', label: 'Удаление серверов' },
+    { id: 'task:list', label: 'Просмотр задач' },
+    { id: 'task:create', label: 'Создание задач' },
+    { id: 'task:edit', label: 'Редактирование задач' },
+    { id: 'task:delete', label: 'Удаление задач' },
+    { id: 'panel:user:list', label: 'Просмотр пользователей панели' },
+    { id: 'panel:user:create', label: 'Создание пользователей панели' },
+    { id: 'panel:user:edit', label: 'Редактирование пользователей панели' },
+    { id: 'panel:user:delete', label: 'Удаление пользователей панели' },
+    { id: 'panel:role:list', label: 'Просмотр ролей панели' },
+    { id: 'panel:role:create', label: 'Создание ролей панели' },
+    { id: 'panel:role:edit', label: 'Редактирование ролей панели' },
+    { id: 'panel:role:delete', label: 'Удаление ролей панели' },
+    { id: 'panel:settings:view', label: 'Просмотр глобальных настроек' },
+    { id: 'panel:settings:edit', label: 'Редактирование глобальных настроек' },
+];
+
+/**
+ * @route   GET /api/auth/permissions
+ * @desc    Получить список всех возможных прав в системе
+ * @access  Private
+ */
+router.get('/permissions', authenticate, (req, res) => {
+    res.json(ALL_PERMISSIONS);
+});
+
+
+/**
+ * @route   PUT /api/auth/users/:id
+ * @desc    Обновить пользователя (роль, пароль)
+ * @access  Private (Admin only)
+ */
+router.put('/users/:id', authenticate, authorize('panel:user:edit'), async (req, res) => {
+    const userId = parseInt(req.params.id, 10);
+    const { password, roleId } = req.body;
+
+    try {
+        const updateData = {};
+        if (password) {
+            if (password.length < 4) return res.status(400).json({ error: 'Пароль должен быть не менее 4 символов' });
+            updateData.passwordHash = await bcrypt.hash(password, 12);
+        }
+        if (roleId) {
+            updateData.roleId = parseInt(roleId, 10);
+        }
+
+        if (Object.keys(updateData).length === 0) {
+            return res.status(400).json({ error: 'Нет данных для обновления' });
+        }
+
+        const updatedUser = await prisma.panelUser.update({
+            where: { id: userId },
+            data: updateData,
+            include: { role: true }
+        });
+
+        const { passwordHash, ...userToReturn } = updatedUser;
+        res.json(userToReturn);
+
+    } catch (error) {
+        res.status(500).json({ error: 'Не удалось обновить пользователя' });
+    }
+});
+
+/**
+ * @route   DELETE /api/auth/users/:id
+ * @desc    Удалить пользователя
+ * @access  Private (Admin only)
+ */
+router.delete('/users/:id', authenticate, authorize('panel:user:delete'), async (req, res) => {
+    const userId = parseInt(req.params.id, 10);
+    
+    if (req.user.userId === userId) {
+        return res.status(403).json({ error: 'Вы не можете удалить свою собственную учетную запись.' });
+    }
+
+    try {
+        await prisma.panelUser.delete({ where: { id: userId } });
+        res.status(204).send();
+    } catch (error) {
+        if (error.code === 'P2025') {
+            return res.status(404).json({ error: 'Пользователь не найден' });
+        }
+        res.status(500).json({ error: 'Не удалось удалить пользователя' });
+    }
+});
+
+/**
+ * @route   POST /api/auth/roles
+ * @desc    Создать новую роль
+ * @access  Private (Admin only)
+ */
+router.post('/roles', authenticate, authorize('panel:role:create'), async (req, res) => {
+    const { name, permissions } = req.body;
+    if (!name || !Array.isArray(permissions)) {
+        return res.status(400).json({ error: 'Имя и массив прав обязательны' });
+    }
+    try {
+        const newRole = await prisma.panelRole.create({
+            data: {
+                name,
+                permissions: JSON.stringify(permissions)
+            }
+        });
+        res.status(201).json({
+            ...newRole,
+            permissions: JSON.parse(newRole.permissions)
+        });
+    } catch (error) {
+        if (error.code === 'P2002') {
+            return res.status(409).json({ error: 'Роль с таким именем уже существует' });
+        }
+        res.status(500).json({ error: 'Не удалось создать роль' });
+    }
+});
+
+/**
+ * @route   PUT /api/auth/roles/:id
+ * @desc    Обновить роль (имя и права)
+ * @access  Private (Admin only)
+ */
+router.put('/roles/:id', authenticate, authorize('panel:role:edit'), async (req, res) => {
+    const roleId = parseInt(req.params.id, 10);
+    const { name, permissions } = req.body;
+    if (!name || !Array.isArray(permissions)) {
+        return res.status(400).json({ error: 'Имя и массив прав обязательны' });
+    }
+    try {
+        const role = await prisma.panelRole.findUnique({ where: { id: roleId } });
+        if (role && role.name === 'Admin') {
+            return res.status(403).json({ error: 'Редактирование роли "Admin" запрещено.' });
+        }
+
+        const updatedRole = await prisma.panelRole.update({
+            where: { id: roleId },
+            data: {
+                name,
+                permissions: JSON.stringify(permissions)
+            }
+        });
+        res.json({
+            ...updatedRole,
+            permissions: JSON.parse(updatedRole.permissions)
+        });
+    } catch (error) {
+         if (error.code === 'P2002') {
+            return res.status(409).json({ error: 'Роль с таким именем уже существует' });
+        }
+        res.status(500).json({ error: 'Не удалось обновить роль' });
+    }
+});
+
+/**
+ * @route   DELETE /api/auth/roles/:id
+ * @desc    Удалить роль
+ * @access  Private (Admin only)
+ */
+router.delete('/roles/:id', authenticate, authorize('panel:role:delete'), async (req, res) => {
+    const roleId = parseInt(req.params.id, 10);
+    try {
+        const role = await prisma.panelRole.findUnique({ where: { id: roleId }, include: { users: true } });
+        if (!role) return res.status(404).json({ error: 'Роль не найдена' });
+        if (role.name === 'Admin') {
+            return res.status(403).json({ error: 'Удаление роли "Admin" запрещено.' });
+        }
+        if (role.users.length > 0) {
+            return res.status(400).json({ error: 'Нельзя удалить роль, которая назначена пользователям.' });
+        }
+        await prisma.panelRole.delete({ where: { id: roleId } });
+        res.status(204).send();
+    } catch (error) {
+        res.status(500).json({ error: 'Не удалось удалить роль' });
+    }
+});
+
+module.exports = router;