auto_error_fixer 0.1.1

package/index.js

@@ -0,0 +1,603 @@
+const express = require('express');
+const fs = require('fs-extra');
+const path = require('path');
+const nodemailer = require('nodemailer');
+const yaml = require('yaml');
+const { createServer } = require('http');
+const { Server } = require('socket.io');
+
+// AEF - Auto Error Fixer 主模块
+class AEF {
+  constructor(options = {}) {
+    this.options = options;
+    this.app = express();
+    this.server = null;
+    this.io = null;
+    this.logFilePath = './DLZstudio/AEF/log/log.txt';
+    this.configPath = './DLZstudio/AEF/config/setting.cfg';
+    this.isEnabled = true;
+    this.transporter = null;
+
+    // 统计信息
+    this.stats = {
+      fixCount: 0,
+      restartCount: 0,
+      lastErrorTime: null,
+      errorHistory: []
+    };
+
+    // 确保目录存在
+    this.ensureDirectories();
+
+    // 初始化配置
+    this.loadConfig();
+
+    // 设置邮件传输器
+    this.setupMailTransporter();
+
+    // 初始化日志
+    this.initLog();
+  }
+
+  // 确保必要目录存在
+  ensureDirectories() {
+    const dirs = [
+      './DLZstudio',
+      './DLZstudio/AEF',
+      './DLZstudio/AEF/config',
+      './DLZstudio/AEF/log',
+      './DLZstudio/AEF/views',
+      './DLZstudio/AEF/public'
+    ];
+    
+    dirs.forEach(dir => {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirpSync(dir);
+      }
+    });
+  }
+
+  // 加载配置文件
+  loadConfig() {
+    try {
+      if (!fs.existsSync(this.configPath)) {
+        // 创建默认配置文件
+        const defaultConfig = {
+          password: '123456', // 默认密码
+          enablePanel: true,
+          email: {
+            enabled: false,
+            host: '',
+            port: 587,
+            secure: false,
+            user: '',
+            pass: '',
+            to: '' // 接收邮箱
+          },
+          autoRestart: true,
+          logLevel: 'info'
+        };
+        
+        fs.writeFileSync(this.configPath, yaml.stringify(defaultConfig));
+      }
+      
+      const configContent = fs.readFileSync(this.configPath, 'utf8');
+      this.config = yaml.parse(configContent);
+      
+      // 如果密码为空，使用默认密码
+      if (!this.config.password || this.config.password.trim() === '') {
+        this.config.password = '123456';
+      }
+      
+      // 监听配置文件变化，实现热重载
+      fs.watch(this.configPath, (eventType, filename) => {
+        if (eventType === 'change') {
+          setTimeout(() => {
+            this.reloadConfig();
+          }, 100); // 延迟加载，避免文件写入未完成
+        }
+      });
+    } catch (error) {
+      console.error('加载配置文件失败:', error.message);
+      this.config = { password: '123456' }; // 使用默认配置
+    }
+  }
+
+  // 重新加载配置
+  reloadConfig() {
+    try {
+      const configContent = fs.readFileSync(this.configPath, 'utf8');
+      this.config = yaml.parse(configContent);
+      
+      if (!this.config.password || this.config.password.trim() === '') {
+        this.config.password = '123456';
+      }
+      
+      console.log('配置文件已重新加载');
+      
+      // 重新设置邮件传输器
+      this.setupMailTransporter();
+    } catch (error) {
+      console.error('重新加载配置文件失败:', error.message);
+    }
+  }
+
+  // 设置邮件传输器
+  setupMailTransporter() {
+    if (this.config.email && this.config.email.enabled) {
+      this.transporter = nodemailer.createTransporter({
+        host: this.config.email.host,
+        port: this.config.email.port,
+        secure: this.config.email.secure,
+        auth: {
+          user: this.config.email.user,
+          pass: this.config.email.pass
+        }
+      });
+    }
+  }
+
+  // 初始化日志
+  initLog() {
+    if (!fs.existsSync(this.logFilePath)) {
+      fs.writeFileSync(this.logFilePath, `# AEF 日志文件\n\n${new Date().toISOString()} - AEF 已启动\n`);
+    }
+  }
+
+  // 写入日志
+  log(message, level = 'info') {
+    const timestamp = new Date().toISOString();
+    const logEntry = `${timestamp} [${level.toUpperCase()}] ${message}\n`;
+    
+    // 输出到控制台
+    console.log(logEntry.trim());
+    
+    // 写入日志文件
+    try {
+      fs.appendFileSync(this.logFilePath, logEntry);
+    } catch (error) {
+      console.error('写入日志文件失败:', error.message);
+    }
+  }
+
+  // 检测错误类型
+  detectError(error) {
+    // 这里可以扩展更多错误类型的检测
+    const errorPatterns = [
+      { type: 'port_in_use', pattern: /EADDRINUSE|address already in use/i },
+      { type: 'connection_refused', pattern: /ECONNREFUSED|connect ECONNREFUSED/i },
+      { type: 'file_not_found', pattern: /ENOENT|no such file or directory/i },
+      { type: 'permission_denied', pattern: /EACCES|permission denied/i },
+      { type: 'memory_limit', pattern: /JavaScript heap out of memory/i },
+      { type: 'disk_full', pattern: /ENOSPC|no space left on device/i },
+      { type: 'database_connection', pattern: /ECONNRESET|database connection|failed to connect/i },
+      { type: 'timeout_error', pattern: /ETIMEDOUT|timeout|request timed out/i },
+      { type: 'invalid_syntax', pattern: /SyntaxError/i },
+      { type: 'missing_dependency', pattern: /Cannot find module|Module not found/i },
+      { type: 'stack_overflow', pattern: /Maximum call stack size exceeded/i },
+      { type: 'network_error', pattern: /NetworkError|fetch failed/i },
+      { type: 'authentication_failed', pattern: /Authentication failed|Invalid credentials/i }
+    ];
+
+    for (const pattern of errorPatterns) {
+      if (pattern.pattern.test(error.message || error.toString())) {
+        return pattern.type;
+      }
+    }
+
+    return 'unknown';
+  }
+
+  // 尝试修复错误
+  async attemptFix(errorType, error) {
+    this.log(`尝试修复错误: ${errorType}`, 'info');
+
+    switch (errorType) {
+      case 'port_in_use':
+        // 尝试获取占用端口的进程并终止它
+        try {
+          const port = (error.message.match(/port (\d+)/) || [])[1];
+          if (port) {
+            const { exec } = require('child_process');
+            const util = require('util');
+            const execAsync = util.promisify(exec);
+
+            if (process.platform === 'win32') {
+              const { stdout } = await execAsync(`netstat -ano | findstr :${port}`);
+              const pidMatch = stdout.match(/^\s*TCP\s+.*:(\d+)\s+.*:(\d+)\s+LISTENING\s+(\d+)/m);
+              if (pidMatch) {
+                const pid = pidMatch[3];
+                await execAsync(`taskkill /PID ${pid} /F`);
+                this.log(`终止了占用端口 ${port} 的进程 PID: ${pid}`, 'info');
+                return true;
+              }
+            } else {
+              // Linux/Mac
+              const { stdout } = await execAsync(`lsof -i :${port} | grep LISTEN`);
+              const pidMatch = stdout.match(/\s*(\d+)\s+/);
+              if (pidMatch) {
+                const pid = pidMatch[1];
+                await execAsync(`kill -9 ${pid}`);
+                this.log(`终止了占用端口 ${port} 的进程 PID: ${pid}`, 'info');
+                return true;
+              }
+            }
+          }
+        } catch (fixError) {
+          this.log(`修复端口占用错误失败: ${fixError.message}`, 'error');
+        }
+        break;
+
+      case 'file_not_found':
+        // 尝试创建缺失的文件或目录
+        try {
+          const filePath = (error.message.match(/'([^']+)'/) || [])[1]; // 提取文件路径
+          if (filePath && !fs.existsSync(filePath)) {
+            const dirPath = path.dirname(filePath);
+            if (!fs.existsSync(dirPath)) {
+              fs.mkdirpSync(dirPath); // 创建缺失的目录
+            }
+
+            // 根据文件扩展名创建适当的默认内容
+            if (filePath.endsWith('.json')) {
+              fs.writeFileSync(filePath, '{}');
+            } else if (filePath.endsWith('.txt') || filePath.endsWith('.log')) {
+              fs.writeFileSync(filePath, '');
+            } else if (filePath.endsWith('.js')) {
+              fs.writeFileSync(filePath, '// 新建的JavaScript文件\n');
+            } else {
+              // 对于其他文件类型，创建空文件
+              fs.writeFileSync(filePath, '');
+            }
+
+            this.log(`创建了缺失的文件: ${filePath}`, 'info');
+            return true;
+          }
+        } catch (fixError) {
+          this.log(`修复文件未找到错误失败: ${fixError.message}`, 'error');
+        }
+        break;
+
+      case 'permission_denied':
+        // 尝试修改文件权限
+        try {
+          const filePath = (error.message.match(/'([^']+)'/) || [])[1];
+          if (filePath && fs.existsSync(filePath)) {
+            if (process.platform !== 'win32') {
+              const { exec } = require('child_process');
+              const util = require('util');
+              const execAsync = util.promisify(exec);
+
+              await execAsync(`chmod 755 "${filePath}"`);
+              this.log(`修改了文件权限: ${filePath}`, 'info');
+              return true;
+            } else {
+              // Windows上无法轻易修改权限，记录信息
+              this.log(`在Windows上无法自动修改文件权限: ${filePath}`, 'info');
+            }
+          }
+        } catch (fixError) {
+          this.log(`修复权限错误失败: ${fixError.message}`, 'error');
+        }
+        break;
+
+      case 'database_connection':
+        // 尝试重新连接数据库
+        try {
+          // 这里可以添加特定数据库的重连逻辑
+          this.log('尝试重新连接数据库...', 'info');
+
+          // 延迟一段时间后重试
+          await new Promise(resolve => setTimeout(resolve, 2000));
+
+          // 这里可以根据具体的数据库类型实现重连逻辑
+          // 比如对于MongoDB, MySQL等
+          return true;
+        } catch (fixError) {
+          this.log(`修复数据库连接错误失败: ${fixError.message}`, 'error');
+        }
+        break;
+
+      case 'timeout_error':
+        // 尝试增加超时时间或重试
+        try {
+          this.log('检测到超时错误，增加重试机制', 'info');
+          // 可以在这里实现重试逻辑
+          return true;
+        } catch (fixError) {
+          this.log(`修复超时错误失败: ${fixError.message}`, 'error');
+        }
+        break;
+
+      case 'missing_dependency':
+        // 尝试安装缺失的依赖
+        try {
+          const moduleName = (error.message.match(/'([^']+)'/) || [])[1];
+          if (moduleName) {
+            this.log(`检测到缺失的模块: ${moduleName}`, 'info');
+            // 注意：实际生产环境中不建议自动安装依赖
+            // 这里只是记录，实际应由开发者处理
+          }
+        } catch (fixError) {
+          this.log(`处理缺失依赖错误失败: ${fixError.message}`, 'error');
+        }
+        break;
+
+      case 'network_error':
+        // 尝试重连网络资源
+        try {
+          this.log('检测到网络错误，尝试重连...', 'info');
+          // 实现重连逻辑
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          return true;
+        } catch (fixError) {
+          this.log(`修复网络错误失败: ${fixError.message}`, 'error');
+        }
+        break;
+
+      default:
+        this.log(`无法自动修复错误类型: ${errorType}`, 'warning');
+        return false;
+    }
+
+    return false;
+  }
+
+  // 处理错误
+  async handleError(error) {
+    if (!this.isEnabled) {
+      // 如果AEF被禁用，则直接抛出错误
+      throw error;
+    }
+
+    const errorType = this.detectError(error);
+    this.log(`检测到错误类型: ${errorType}`, 'error');
+    this.log(`错误详情: ${error.stack || error.message || error}`, 'error');
+
+    // 更新最后错误时间
+    this.stats.lastErrorTime = new Date().toISOString();
+
+    // 尝试修复错误
+    const fixed = await this.attemptFix(errorType, error);
+
+    if (!fixed) {
+      this.log('无法自动修复错误', 'error');
+
+      // 对于某些非致命错误，我们不需要重启服务器，只需记录即可
+      const nonFatalErrors = ['unknown', 'timeout_error', 'network_error', 'authentication_failed'];
+
+      if (nonFatalErrors.includes(errorType)) {
+        // 对于非致命错误，记录但不重启
+        this.log(`检测到非致命错误 ${errorType}，继续运行服务`, 'warning');
+
+        // 发送邮件通知（如果启用）
+        if (this.config.email && this.config.email.enabled) {
+          await this.sendErrorNotification(error, errorType);
+        }
+
+        // 抛出错误，让调用者处理
+        throw error;
+      } else {
+        // 对于致命错误，发送邮件通知并重启服务器
+        this.log('准备重启服务器', 'error');
+
+        // 发送邮件通知
+        if (this.config.email && this.config.email.enabled) {
+          await this.sendErrorNotification(error, errorType);
+        }
+
+        // 如果启用了自动重启，则重启服务器
+        if (this.config.autoRestart !== false) {
+          this.stats.restartCount++;
+          this.restartServer();
+        } else {
+          // 否则抛出错误
+          throw error;
+        }
+      }
+    } else {
+      this.stats.fixCount++;
+      this.log('错误已修复，继续运行', 'info');
+    }
+  }
+
+  // 发送错误通知邮件
+  async sendErrorNotification(error, errorType) {
+    if (!this.transporter) {
+      this.log('邮件传输器未初始化', 'error');
+      return;
+    }
+
+    try {
+      // 默认邮件内容
+      const defaultContent = '# 服务器发生错误\n\n### AEF遇到了一个无法自动处理的错误,请手动修复\n### AEF正在尝试重启服务器';
+      const mailContent = (this.config.email && this.config.email.content) ?
+        this.config.email.content : defaultContent;
+
+      const mailOptions = {
+        from: this.config.email.user,
+        to: this.config.email.to,
+        subject: `AEF错误通知 - ${errorType}`,
+        text: mailContent,
+        html: this.markdownToHtml(mailContent)
+      };
+
+      await this.transporter.sendMail(mailOptions);
+      this.log('错误通知邮件已发送', 'info');
+    } catch (emailError) {
+      this.log(`发送错误通知邮件失败: ${emailError.message}`, 'error');
+    }
+  }
+
+  // 简单的Markdown转HTML转换器
+  markdownToHtml(md) {
+    let html = md
+      // 转换标题
+      .replace(/^### (.*$)/gm, '<h3>$1</h3>')
+      .replace(/^## (.*$)/gm, '<h2>$1</h2>')
+      .replace(/^# (.*$)/gm, '<h1>$1</h1>')
+      // 转换换行
+      .replace(/\n\n/g, '<br/><br/>')
+      .replace(/\n/g, '<br/>')
+      // 确保段落之间有间距
+      .replace(/<br\/><br\/>/g, '</p><p>')
+      .replace(/^(.+)$/gm, '<p>$1</p>');
+
+    // 清理多余的段落标签
+    html = html.replace(/<p><\/p>/g, '');
+
+    // 添加整体包装
+    html = `<div>${html}</div>`;
+
+    return html;
+  }
+
+  // 重启服务器
+  restartServer() {
+    this.log('正在重启服务器...', 'info');
+    
+    // 先关闭当前服务器
+    if (this.server) {
+      this.server.close(() => {
+        this.log('服务器已关闭，准备重启', 'info');
+        // 这里实际重启逻辑取决于如何集成到应用中
+        // 在实际部署中，可能需要配合pm2或其他进程管理工具
+        process.exit(1); // 退出进程，依赖外部进程管理器重启
+      });
+    } else {
+      // 如果没有服务器实例，直接退出
+      process.exit(1);
+    }
+  }
+
+  // 启动AEF控制面板
+  async startPanel() {
+    if (this.config.enablePanel === false) {
+      this.log('控制面板已被禁用', 'info');
+      return;
+    }
+
+    this.app.use(express.static('./DLZstudio/AEF/public'));
+    this.app.use(express.json());
+
+    // 控制面板路由
+    this.app.get('/panel/AEF', (req, res) => {
+      res.sendFile(path.join(__dirname, 'views', 'panel.html'));
+    });
+
+    // 验证密码接口
+    this.app.post('/panel/AEF/login', (req, res) => {
+      const { password } = req.body;
+      if (password === this.config.password) {
+        res.json({ success: true });
+      } else {
+        res.status(401).json({ success: false, message: '密码错误' });
+      }
+    });
+
+    // 获取状态接口
+    this.app.get('/panel/AEF/status', (req, res) => {
+      res.json({
+        isEnabled: this.isEnabled,
+        config: this.config,
+        log: this.getLog(),
+        ...this.stats,
+        memoryInfo: process.memoryUsage()
+      });
+    });
+
+    // 切换AEF状态接口
+    this.app.post('/panel/AEF/toggle', (req, res) => {
+      this.isEnabled = !this.isEnabled;
+      res.json({ success: true, isEnabled: this.isEnabled });
+    });
+
+    // 获取日志接口
+    this.app.get('/panel/AEF/log', (req, res) => {
+      res.json({ log: this.getLog() });
+    });
+
+    // 获取配置文件内容
+    this.app.get('/panel/AEF/config', (req, res) => {
+      try {
+        const configContent = fs.readFileSync(this.configPath, 'utf8');
+        res.json({ content: configContent });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    // 更新配置文件内容
+    this.app.post('/panel/AEF/config', (req, res) => {
+      try {
+        const { content } = req.body;
+        fs.writeFileSync(this.configPath, content);
+        res.json({ success: true });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    // 启动HTTP服务器
+    this.server = createServer(this.app);
+    this.io = new Server(this.server);
+
+    // Socket.IO连接
+    this.io.on('connection', (socket) => {
+      this.log('控制面板客户端已连接', 'info');
+      
+      // 定期发送日志更新
+      const logInterval = setInterval(() => {
+        socket.emit('logUpdate', this.getLog());
+      }, 2000);
+
+      socket.on('disconnect', () => {
+        clearInterval(logInterval);
+        this.log('控制面板客户端已断开连接', 'info');
+      });
+    });
+
+    const port = process.env.AEF_PANEL_PORT || 3001;
+    this.server.listen(port, () => {
+      this.log(`AEF控制面板已在端口 ${port} 上启动`, 'info');
+    });
+  }
+
+  // 获取最近的日志
+  getLog() {
+    try {
+      if (fs.existsSync(this.logFilePath)) {
+        const logContent = fs.readFileSync(this.logFilePath, 'utf8');
+        // 返回最后100行日志
+        const lines = logContent.split('\n');
+        return lines.slice(Math.max(lines.length - 100, 0)).join('\n');
+      }
+      return '';
+    } catch (error) {
+      return `获取日志失败: ${error.message}`;
+    }
+  }
+
+  // 中间件函数
+  middleware() {
+    return async (err, req, res, next) => {
+      await this.handleError(err);
+      next(err);
+    };
+  }
+
+  // 捕获未处理的异常
+  handleUncaughtExceptions() {
+    process.on('uncaughtException', async (error) => {
+      this.log('捕获到未处理的异常', 'error');
+      await this.handleError(error);
+    });
+
+    process.on('unhandledRejection', async (reason, promise) => {
+      this.log('捕获到未处理的Promise拒绝', 'error');
+      await this.handleError(reason instanceof Error ? reason : new Error(reason));
+    });
+  }
+}
+
+module.exports = AEF;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "auto_error_fixer",
+  "version": "0.1.1",
+  "description": "AEF (Auto Error Fixer) - 自动故障修复系统，能够自动检测、修复服务器错误并在必要时重启服务器",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": [
+    "error-handling",
+    "auto-fix",
+    "server-monitoring",
+    "error-recovery",
+    "automatic-restart",
+    "server-management"
+  ],
+  "author": "DLZstudio",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DLZstudio/AEF.git"
+  },
+  "bugs": {
+    "url": "https://github.com/DLZstudio/AEF/issues"
+  },
+  "homepage": "https://github.com/DLZstudio/AEF#readme",
+  "files": [
+    "index.js",
+    "README.md",
+    "package.json",
+    "examples/**/*",
+    "DLZstudio/AEF/views/**/*",
+    "DLZstudio/AEF/config/**/*",
+    "DLZstudio/AEF/log/**/*",
+    "DLZstudio/AEF/public/**/*"
+  ],
+  "dependencies": {
+    "express": "^4.18.2",
+    "nodemailer": "^6.9.0",
+    "fs-extra": "^11.0.0",
+    "yaml": "^2.2.0",
+    "socket.io": "^4.7.0"
+  },
+  "devDependencies": {
+    "jest": "^29.0.0"
+  }
+}