node-red-contrib-fox-admin 1.0.0

package/README.md

@@ -0,0 +1,66 @@
+# Fox Control 系统管理控制台
+
+Node-RED 运行时插件，提供系统管理控制台功能。
+
+## 功能特性
+
+- **登录认证**：安全的密码登录系统
+- **设备管理**：修改主机名、查看系统信息
+- **网络管理**：查看网络接口、配置网络参数
+- **防火墙管理**：启用/禁用防火墙、添加防火墙规则
+- **站点部署**：上传 ZIP 包进行站点部署
+
+## 支持的系统
+
+- Debian 11/12
+- Ubuntu 20.04/22.04
+- Kylin V10
+- openEuler 22.03
+
+## 安装
+
+插件已安装在 Node-RED 的 node_modules 目录中，无需额外安装。
+
+## 使用方法
+
+1. 启动 Node-RED
+2. 访问 `http://your-node-red-ip:port/foxcontroladmin_login/`
+3. 使用默认密码登录：`foxcontrol@123`
+4. 修改密码：设置环境变量 `FOX_ADMIN_PASSWORD`
+
+## 环境变量
+
+- `FOX_ADMIN_PASSWORD`：管理员密码（默认：foxcontrol@123）
+- `FOX_SESSION_SECRET`：会话密钥（默认：fox-admin-secret-key-2024）
+
+## API 接口
+
+### 认证相关
+- `POST /api/foxcontrol_admin/login`：登录
+- `POST /api/foxcontrol_admin/logout`：登出
+- `GET /api/foxcontrol_admin/check-auth`：检查认证状态
+
+### 系统管理
+- `GET /api/foxcontrol_admin/system/info`：获取系统信息
+- `PUT /api/foxcontrol_admin/hostname`：修改主机名
+
+### 网络管理
+- `GET /api/foxcontrol_admin/network/interfaces`：获取网络接口
+- `GET /api/foxcontrol_admin/network/connections`：获取网络连接
+- `PUT /api/foxcontrol_admin/network/config`：配置网络
+
+### 防火墙管理
+- `GET /api/foxcontrol_admin/firewall/status`：获取防火墙状态
+- `PUT /api/foxcontrol_admin/firewall/enable`：启用防火墙
+- `PUT /api/foxcontrol_admin/firewall/disable`：禁用防火墙
+- `POST /api/foxcontrol_admin/firewall/rule`：添加防火墙规则
+
+### 站点部署
+- `POST /api/foxcontrol_admin/deploy/upload`：上传并部署站点
+
+## 注意事项
+
+- Node-RED 需要以 root 用户运行才能执行系统管理命令
+- 网络配置修改后可能需要重启网络服务
+- 防火墙规则修改立即生效
+- 部署的站点会解压到 Node-RED 的 public/UI 目录

package/index.js

@@ -0,0 +1,492 @@
+const path = require('path');
+const fs = require('fs');
+const si = require('systeminformation');
+const multer = require('multer');
+const AdmZip = require('adm-zip');
+const { exec } = require('child_process');
+const bodyParser = require('body-parser');
+const express = require('express');
+const session = require('express-session');
+
+module.exports = function(RED) {
+    function FoxAdminPlugin() {
+        const app = RED.httpNode;
+        if (!app) return;
+
+        const htmlPath = path.join(__dirname, 'lib');
+        
+        const ADMIN_PASSWORD = process.env.FOX_ADMIN_PASSWORD || 'foxcontrol@123';
+        const SESSION_SECRET = process.env.FOX_SESSION_SECRET || 'fox-admin-secret-key-2024';
+        
+        const upload = multer({ storage: multer.memoryStorage() });
+        
+        const publicDir = path.join(RED.settings.userDir, '..', 'public', 'UI');
+
+        const serverPort = RED.settings.uiPort || 1880;
+        const serverHost = RED.settings.uiHost || '0.0.0.0';
+
+        app.use(bodyParser.json({ limit: '10mb' }));
+        app.use(bodyParser.urlencoded({ extended: true, limit: '10mb' }));
+        app.use(session({
+            secret: SESSION_SECRET,
+            resave: false,
+            saveUninitialized: false,
+            cookie: { maxAge: 3600000 }
+        }));
+
+        RED.log.info(">>> Fox Control 管理控制台插件已启动");
+        RED.log.info(">>> 访问管理后台: http://" + serverHost + ":" + serverPort + "/foxadmin/");
+        RED.log.info(">>> 默认密码: " + ADMIN_PASSWORD);
+
+        function execCommand(cmd) {
+            return new Promise((resolve, reject) => {
+                exec(cmd, { encoding: 'utf8' }, (error, stdout, stderr) => {
+                    if (error) {
+                        reject(error);
+                    } else {
+                        resolve(stdout.trim());
+                    }
+                });
+            });
+        }
+
+        function getSystemType() {
+            try {
+                const osRelease = fs.readFileSync('/etc/os-release', 'utf8');
+                if (osRelease.includes('Debian')) return 'debian';
+                if (osRelease.includes('Kylin')) return 'kylin';
+                if (osRelease.includes('openEuler')) return 'openEuler';
+                if (osRelease.includes('Ubuntu')) return 'ubuntu';
+                return 'unknown';
+            } catch (err) {
+                return 'unknown';
+            }
+        }
+
+        async function getDefaultGateway() {
+            try {
+                const osType = getSystemType();
+                const platform = process.platform;
+                let cmd = '';
+                
+                if (osType === 'debian' || osType === 'kylin' || osType === 'openEuler' || osType === 'ubuntu') {
+                    cmd = 'ip route | grep default | awk \'{print $3}\'';
+                } else if (osType === 'unknown') {
+                    if (platform === 'win32') {
+                        cmd = 'route print 0.0.0.0 | findstr "0.0.0.0"';
+                    } else {
+                        return '';
+                    }
+                } else {
+                    return '';
+                }
+                
+                const gateway = await execCommand(cmd);
+                if (platform === 'win32') {
+                    const match = gateway.match(/0\.0\.0\.0\s+(\d+\.\d+\.\d+\.\d+)/);
+                    return match ? match[1] : '';
+                }
+                return gateway || '';
+            } catch (err) {
+                return '';
+            }
+        }
+
+        app.get('/foxadmin', (req, res) => {
+            const loginPath = path.join(htmlPath, 'login.html');
+            if (fs.existsSync(loginPath)) {
+                res.sendFile(loginPath);
+            } else {
+                res.status(404).send("Fox Admin Error: 登录页面不存在");
+            }
+        });
+
+        app.get('/foxcontrol_edit', (req, res) => {
+            res.redirect('/red');
+        });
+
+        app.get('/foxcontroladmin_dashboard', (req, res) => {
+            const dashboardPath = path.join(htmlPath, 'dashboard.html');
+            if (fs.existsSync(dashboardPath)) {
+                res.sendFile(dashboardPath);
+            } else {
+                res.status(404).send("Fox Admin Error: 控制台页面不存在");
+            }
+        });
+
+        app.get('/foxcontroladmin_network', (req, res) => {
+            const networkPath = path.join(htmlPath, 'network.html');
+            if (fs.existsSync(networkPath)) {
+                res.sendFile(networkPath);
+            } else {
+                res.status(404).send("Fox Admin Error: 网络管理页面不存在");
+            }
+        });
+
+        app.get('/foxcontroladmin_firewall', (req, res) => {
+            const firewallPath = path.join(htmlPath, 'firewall.html');
+            if (fs.existsSync(firewallPath)) {
+                res.sendFile(firewallPath);
+            } else {
+                res.status(404).send("Fox Admin Error: 防火墙管理页面不存在");
+            }
+        });
+
+        app.get('/foxcontroladmin_deploy', (req, res) => {
+            const deployPath = path.join(htmlPath, 'deploy.html');
+            if (fs.existsSync(deployPath)) {
+                res.sendFile(deployPath);
+            } else {
+                res.status(404).send("Fox Admin Error: 部署页面不存在");
+            }
+        });
+
+        app.post('/foxcontrol_api/admin/login', (req, res) => {
+            try {
+                const { password } = req.body;
+                if (!password) {
+                    return res.status(400).json({ status: 'error', message: '未接收到密码数据' });
+                }
+                if (password === ADMIN_PASSWORD) {
+                    if (!req.session) {
+                        throw new Error("Session 中间件未正确初始化");
+                    }
+                    req.session.admin = true;
+                    res.json({ status: 'success', message: '登录成功' });
+                } else {
+                    res.status(401).json({ status: 'error', message: '密码错误' });
+                }
+            } catch (err) {
+                RED.log.error(`[Fox Admin] Login Error: ${err.message}`);
+                res.status(500).json({ status: 'error', message: `内部错误: ${err.message}` });
+            }
+        });
+
+        app.post('/foxcontrol_api/admin/logout', (req, res) => {
+            req.session.destroy();
+            res.json({ status: 'success', message: '已退出登录' });
+        });
+
+        app.get('/foxcontrol_api/admin/check-auth', (req, res) => {
+            if (req.session.admin) {
+                res.json({ status: 'success', authenticated: true });
+            } else {
+                res.json({ status: 'error', authenticated: false });
+            }
+        });
+
+        app.get('/foxcontrol_api/admin/system/info', async (req, res) => {
+            try {
+                const osInfo = await si.osInfo();
+                const cpu = await si.cpu();
+                const mem = await si.mem();
+                const systemType = getSystemType();
+                
+                let hostname = 'unknown';
+                try {
+                    hostname = await execCommand('hostname');
+                } catch (err) {}
+
+                res.json({
+                    status: 'success',
+                    data: {
+                        system: {
+                            type: systemType,
+                            hostname: hostname,
+                            os: osInfo.distro,
+                            version: osInfo.release,
+                            arch: osInfo.arch,
+                            kernel: osInfo.kernel
+                        },
+                        cpu: {
+                            manufacturer: cpu.manufacturer,
+                            brand: cpu.brand,
+                            cores: cpu.cores,
+                            speed: cpu.speed
+                        },
+                        memory: {
+                            total: Math.round(mem.total / 1024 / 1024 / 1024),
+                            used: Math.round(mem.used / 1024 / 1024 / 1024),
+                            free: Math.round(mem.free / 1024 / 1024 / 1024),
+                            usage: Math.round((mem.used / mem.total) * 100)
+                        }
+                    }
+                });
+            } catch (err) {
+                RED.log.error(`[Fox Admin] 获取系统信息失败: ${err.message}`);
+                res.status(500).json({ status: 'error', message: err.message });
+            }
+        });
+
+        app.put('/foxcontrol_api/admin/hostname', async (req, res) => {
+            try {
+                const { hostname } = req.body;
+                if (!hostname || hostname.length < 2) {
+                    return res.status(400).json({ status: 'error', message: '主机名无效' });
+                }
+                
+                await execCommand(`hostnamectl set-hostname ${hostname}`);
+                RED.log.info(`[Fox Admin] 主机名已修改为: ${hostname}`);
+                res.json({ status: 'success', message: '主机名修改成功' });
+            } catch (err) {
+                RED.log.error(`[Fox Admin] 修改主机名失败: ${err.message}`);
+                res.status(500).json({ status: 'error', message: err.message });
+            }
+        });
+
+        app.get('/foxcontrol_api/admin/network/interfaces', async (req, res) => {
+            try {
+                const networkInterfaces = await si.networkInterfaces();
+                const networkStats = await si.networkStats();
+                const defaultGateway = await getDefaultGateway();
+                
+                const interfaces = networkInterfaces.map(iface => {
+                    const stats = networkStats.find(s => s.iface === iface.iface) || {};
+                    
+                    return {
+                        iface: iface.iface,
+                        type: iface.type,
+                        ip4: iface.ip4,
+                        ip4_subnet: iface.ip4_subnet || '',
+                        ip6: iface.ip6,
+                        mac: iface.mac,
+                        internal: iface.internal,
+                        virtual: iface.virtual,
+                        operstate: iface.operstate,
+                        speed: iface.speed,
+                        duplex: iface.duplex,
+                        mtu: iface.mtu,
+                        gateway: iface.ip4 ? defaultGateway : '',
+                        rx_bytes: stats.rx_bytes || 0,
+                        tx_bytes: stats.tx_bytes || 0,
+                        rx_sec: stats.rx_sec || 0,
+                        tx_sec: stats.tx_sec || 0
+                    };
+                });
+
+                res.json({ status: 'success', data: interfaces });
+            } catch (err) {
+                RED.log.error(`[Fox Admin] 获取网络接口失败: ${err.message}`);
+                res.status(500).json({ status: 'error', message: err.message });
+            }
+        });
+
+        app.get('/foxcontrol_api/admin/network/connections', async (req, res) => {
+            try {
+                const connections = await si.networkConnections();
+                res.json({ status: 'success', data: connections });
+            } catch (err) {
+                RED.log.error(`[Fox Admin] 获取网络连接失败: ${err.message}`);
+                res.status(500).json({ status: 'error', message: err.message });
+            }
+        });
+
+        app.put('/foxcontrol_api/admin/network/config', async (req, res) => {
+            try {
+                const { iface, ip4, netmask, gateway, dns } = req.body;
+                const systemType = getSystemType();
+
+                if (systemType === 'unknown') {
+                    return res.status(400).json({ status: 'error', message: '不支持的系统' });
+                }
+
+                if (systemType === 'debian' || systemType === 'ubuntu') {
+                    const config = `
+auto ${iface}
+iface ${iface} inet static
+    address ${ip4}
+    netmask ${netmask}
+    gateway ${gateway}
+    dns-nameservers ${dns}
+`;
+                    const configPath = `/etc/network/interfaces.d/${iface}`;
+                    fs.writeFileSync(configPath, config);
+                    await execCommand('systemctl restart networking');
+                } else if (systemType === 'kylin' || systemType === 'openEuler') {
+                    const config = `
+TYPE=Ethernet
+BOOTPROTO=static
+DEFROUTE=yes
+IPV4_FAILURE_FATAL=no
+IPV6INIT=yes
+IPV6_AUTOCONF=yes
+IPV6_DEFROUTE=yes
+IPV6_FAILURE_FATAL=no
+NAME=${iface}
+DEVICE=${iface}
+ONBOOT=yes
+IPADDR=${ip4}
+NETMASK=${netmask}
+GATEWAY=${gateway}
+DNS1=${dns}
+`;
+                    const configPath = `/etc/sysconfig/network-scripts/ifcfg-${iface}`;
+                    fs.writeFileSync(configPath, config);
+                    await execCommand('systemctl restart network');
+                }
+
+                RED.log.info(`[Fox Admin] 网络配置已更新: ${iface}`);
+                res.json({ status: 'success', message: '网络配置已更新' });
+            } catch (err) {
+                RED.log.error(`[Fox Admin] 配置网络失败: ${err.message}`);
+                res.status(500).json({ status: 'error', message: err.message });
+            }
+        });
+
+        app.get('/foxcontrol_api/admin/firewall/status', async (req, res) => {
+            try {
+                const systemType = getSystemType();
+                let status = { enabled: false, rules: [] };
+
+                if (systemType === 'debian' || systemType === 'ubuntu') {
+                    try {
+                        const ufwStatus = await execCommand('ufw status verbose');
+                        status.enabled = ufwStatus.includes('Status: active');
+                        const rules = ufwStatus.split('\n').filter(line => line.includes('ALLOW') || line.includes('DENY'));
+                        status.rules = rules;
+                    } catch (err) {
+                        status.enabled = false;
+                    }
+                } else if (systemType === 'kylin' || systemType === 'openEuler') {
+                    try {
+                        const fwStatus = await execCommand('firewall-cmd --state');
+                        status.enabled = fwStatus === 'running';
+                        const rules = await execCommand('firewall-cmd --list-all');
+                        status.rules = [rules];
+                    } catch (err) {
+                        status.enabled = false;
+                    }
+                } else {
+                    return res.status(400).json({ status: 'error', message: '不支持的系统' });
+                }
+
+                res.json({ status: 'success', data: status });
+            } catch (err) {
+                RED.log.error(`[Fox Admin] 获取防火墙状态失败: ${err.message}`);
+                res.status(500).json({ status: 'error', message: err.message });
+            }
+        });
+
+        app.put('/foxcontrol_api/admin/firewall/enable', async (req, res) => {
+            try {
+                const systemType = getSystemType();
+
+                if (systemType === 'debian' || systemType === 'ubuntu') {
+                    await execCommand('ufw --force enable');
+                } else if (systemType === 'kylin' || systemType === 'openEuler') {
+                    await execCommand('systemctl enable firewalld');
+                    await execCommand('systemctl start firewalld');
+                } else {
+                    return res.status(400).json({ status: 'error', message: '不支持的系统' });
+                }
+
+                RED.log.info('[Fox Admin] 防火墙已启用');
+                res.json({ status: 'success', message: '防火墙已启用' });
+            } catch (err) {
+                RED.log.error(`[Fox Admin] 启用防火墙失败: ${err.message}`);
+                res.status(500).json({ status: 'error', message: err.message });
+            }
+        });
+
+        app.put('/foxcontrol_api/admin/firewall/disable', async (req, res) => {
+            try {
+                const systemType = getSystemType();
+
+                if (systemType === 'debian' || systemType === 'ubuntu') {
+                    await execCommand('ufw disable');
+                } else if (systemType === 'kylin' || systemType === 'openEuler') {
+                    await execCommand('systemctl stop firewalld');
+                    await execCommand('systemctl disable firewalld');
+                } else {
+                    return res.status(400).json({ status: 'error', message: '不支持的系统' });
+                }
+
+                RED.log.info('[Fox Admin] 防火墙已禁用');
+                res.json({ status: 'success', message: '防火墙已禁用' });
+            } catch (err) {
+                RED.log.error(`[Fox Admin] 禁用防火墙失败: ${err.message}`);
+                res.status(500).json({ status: 'error', message: err.message });
+            }
+        });
+
+        app.post('/foxcontrol_api/admin/firewall/rule', async (req, res) => {
+            try {
+                const { action, port, protocol, ip } = req.body;
+                const systemType = getSystemType();
+
+                if (systemType === 'debian' || systemType === 'ubuntu') {
+                    if (action === 'allow') {
+                        if (ip) {
+                            await execCommand(`ufw allow from ${ip} to any port ${port} proto ${protocol}`);
+                        } else {
+                            await execCommand(`ufw allow ${port}/${protocol}`);
+                        }
+                    } else if (action === 'deny') {
+                        if (ip) {
+                            await execCommand(`ufw deny from ${ip} to any port ${port} proto ${protocol}`);
+                        } else {
+                            await execCommand(`ufw deny ${port}/${protocol}`);
+                        }
+                    }
+
+                    RED.log.info(`[Fox Admin] 防火墙规则已添加: ${action} ${port}/${protocol}`);
+                    res.json({ status: 'success', message: '防火墙规则已添加' });
+                } else if (systemType === 'kylin' || systemType === 'openEuler') {
+                    if (action === 'allow') {
+                        if (ip) {
+                            await execCommand(`firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="${ip}" port protocol="${protocol}" port="${port}" accept'`);
+                        } else {
+                            await execCommand(`firewall-cmd --permanent --add-port=${port}/${protocol}`);
+                        }
+                    } else if (action === 'deny') {
+                        if (ip) {
+                            await execCommand(`firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="${ip}" port protocol="${protocol}" port="${port}" reject'`);
+                        } else {
+                            await execCommand(`firewall-cmd --permanent --remove-port=${port}/${protocol}`);
+                        }
+                    }
+                    await execCommand('firewall-cmd --reload');
+                    RED.log.info(`[Fox Admin] 防火墙规则已添加: ${action} ${port}/${protocol}`);
+                    res.json({ status: 'success', message: '防火墙规则已添加' });
+                } else {
+                    res.status(400).json({ status: 'error', message: '不支持的系统' });
+                }
+            } catch (err) {
+                RED.log.error(`[Fox Admin] 添加防火墙规则失败: ${err.message}`);
+                res.status(500).json({ status: 'error', message: err.message });
+            }
+        });
+
+        app.post('/foxcontrol_api/admin/deploy/upload', upload.single('site_zip'), async (req, res) => {
+            try {
+                if (!req.file) throw new Error("未选择有效的 ZIP 文件");
+                
+                fs.mkdirSync(publicDir, { recursive: true });
+                const files = fs.readdirSync(publicDir);
+                files.forEach(file => {
+                    const filePath = path.join(publicDir, file);
+                    const stat = fs.statSync(filePath);
+                    if (stat.isDirectory()) {
+                        fs.rmSync(filePath, { recursive: true, force: true });
+                    } else {
+                        fs.unlinkSync(filePath);
+                    }
+                });
+
+                const zip = new AdmZip(req.file.buffer);
+                zip.extractAllTo(publicDir, true);
+
+                RED.log.info(`[Fox Control] 站点已成功部署至: ${publicDir}`);
+                res.json({ status: 'success', url: '/UI/index.html' });
+            } catch (err) {
+                RED.log.error(`[Fox Control] 部署失败: ${err.message}`);
+                res.status(500).json({ status: 'error', message: err.message });
+            }
+        });
+    }
+
+    RED.plugins.registerPlugin("fox-admin", {
+        type: "runtime",
+        onadd: FoxAdminPlugin
+    });
+};