node-karin 0.0.3

package/lib/core/plugin.loader.js

@@ -0,0 +1,462 @@
+import fs from 'fs'
+import lodash from 'lodash'
+import path from 'path'
+import schedule from 'node-schedule'
+import Renderer from '../renderer/app.js'
+import button from '../utils/button.js'
+import Common from '../utils/common.js'
+import handler from '../utils/handler.js'
+import listener from './listener.js'
+import logger from '../utils/logger.js'
+import PluginApp from './plugin.app.js'
+/**
+ * 加载插件
+ */
+export default new (class PluginLoader {
+  dir
+  dirPath
+  /**
+     * - 插件列表
+     */
+  Apps
+  /**
+     * - 定时任务
+     */
+  task
+  /**
+     * - 监听器
+     */
+  watcher
+  /**
+     * - 热更新列表
+     */
+  watchList
+  /**
+     * - 插件索引ID
+     */
+  index
+  /**
+     * - 命令插件索引列表
+     */
+  rule
+  PluginList
+  constructor () {
+    this.dir = './plugins'
+    this.dirPath = Common.urlToPath(import.meta.url)
+    this.Apps = []
+    this.task = []
+    this.watcher = new Map()
+    /** 热更新收集 */
+    this.watchList = []
+    this.rule = []
+    this.index = 0
+    this.PluginList = {}
+  }
+
+  /**
+     * 插件初始化
+     */
+  async load () {
+    const files = this.getPlugins()
+    listener.once('plugin.loader', () => {
+      for (const v of this.watchList) {
+        v.name ? this.watch(v.dir, v.name) : this.watchDir(v.dir)
+      }
+    })
+    logger.info(logger.green('-----------'))
+    logger.info('加载插件中..')
+    /** 载入插件 */
+    const promises = files.map(async ({ dir, name }) => await this.createdApp(dir, name, false))
+    /** 等待所有插件加载完成 */
+    await Promise.all(promises)
+    const handlerKeys = Object.keys(handler.events)
+    let handlerCount = 0
+    handlerKeys.forEach((key) => {
+      handlerCount += handler.events[key].length
+    })
+    logger.info(`[按钮][${button.Apps.length}个] 加载完成`)
+    logger.info(`[插件][${this.Apps.length}个] 加载完成`)
+    logger.info(`[渲染器][${Renderer.Apps.length}个] 加载完成`)
+    logger.info(`[定时任务][${this.task.length}个] 加载完成`)
+    logger.info(`[Handler][Key:${handlerKeys.length}个][fnc:${handlerCount}个] 加载完成`)
+    logger.info(logger.green('-----------'))
+    logger.info(`Karin启动完成：耗时 ${logger.green(process.uptime().toFixed(2))} 秒...`)
+    /** 优先级排序 */
+    this.orderBy()
+    listener.emit('plugin.loader')
+    return this
+  }
+
+  /**
+     * 获取所有插件
+     */
+  getPlugins () {
+    const Apps = []
+    /** 获取所有插件包 */
+    const plugins = Common.getPlugins()
+    const isTs = process.env.karin_app_lang === 'ts'
+    for (const dir of plugins) {
+      /**
+             * - 插件包路径
+             * - 例如: ./plugins/karin-plugin-example
+             */
+      const PluginPath = `${this.dir}/${dir}`
+      // 非插件包
+      if (!Common.isPlugin(PluginPath)) {
+        const list = fs.readdirSync(`${this.dir}/${dir}`, {
+          withFileTypes: true,
+        })
+        for (const file of list) {
+          /** 忽略不符合规则的文件 */
+          const ext = isTs ? ['.js', '.ts'] : ['.js']
+          if (!ext.includes(path.extname(file.name))) { continue }
+          Apps.push({ dir, name: file.name })
+        }
+      }
+      /** js环境 */
+      if (Common.exists(`${PluginPath}/index.js`)) {
+        Apps.push({ dir, name: 'index.js' })
+      }
+      const appList = ['apps', 'dist/apps']
+      appList.forEach(app => {
+        if (Common.isDir(`${PluginPath}/${app}`)) {
+          const result = this.getApps((`${dir}/${app}`))
+          Apps.push(...result)
+        }
+      })
+      /** ts环境 */
+      if (isTs) {
+        if (Common.exists(`${PluginPath}/index.ts`)) {
+          Apps.push({ dir, name: 'index.ts' })
+        }
+        if (Common.isDir(`${PluginPath}/src/apps`)) {
+          const result = this.getApps((`${dir}/src/apps`), true)
+          Apps.push(...result)
+        }
+      }
+    }
+    return Apps
+  }
+
+  /**
+     * 获取指定文件夹下的所有插件
+     * @param dir - 插件包名称
+     * @param isTs - 是否获取ts插件
+     */
+  getApps (dir, isTs = false) {
+    const info = []
+    const ext = isTs ? ['.js', '.ts'] : ['.js']
+    const list = fs.readdirSync(`${this.dir}/${dir}`, { withFileTypes: true })
+    for (const file of list) {
+      // 获取后缀
+      const extname = path.extname(file.name)
+      if (!ext.includes(extname)) { continue }
+      info.push({ dir, name: file.name })
+    }
+    return info
+  }
+
+  /**
+     * 构建插件信息
+     */
+  App (
+    /**
+     * - 插件Class 未实例化
+     */
+    App,
+    /**
+     * - 插件实例化后的Class
+     */
+    Class,
+    /**
+     * - 插件文件信息
+     */
+    file) {
+    const info = {
+      App,
+      /** 插件文件信息 */
+      file,
+      name: Class.name,
+      desc: Class.dsc || Class.desc || Class.name,
+      event: Class.event || 'message',
+      priority: Class.priority ?? 5000,
+      accept: typeof Class.accept === 'function',
+      rule: Class.rule || [],
+      type: typeof App === 'function' ? 'function' : 'class',
+      task: Class.task || [],
+      handler: Class.handler || [],
+      button: Class.button || [],
+    }
+    /** 进一步处理rule */
+    info.rule.forEach((val, index) => {
+      info.rule[index].reg = new RegExp(val.reg)
+      info.rule[index].log = val.log === false ? (id, log) => logger.debug('mark', id, log) : (id, log) => logger.bot('mark', id, log)
+    })
+    return info
+  }
+
+  /** 排序 */
+  orderBy () {
+    const list = []
+    Object.keys(this.PluginList).forEach(key => {
+      list.push({ key, val: this.PluginList[key].priority })
+    })
+    this.rule = lodash.orderBy(list, ['val'], ['asc']).map((v) => Number(v.key))
+    logger.debug('rule排序完成...')
+    logger.info(this.rule)
+  }
+
+  /**
+     * 新增插件
+     * @param dir - 插件包路径
+     * @param name - 插件名称
+     * @param isOrderBy - 是否重新导入
+     */
+  async createdApp (dir, name, isOrderBy = false) {
+    try {
+      let path = `${this.dirPath}plugins/${dir}/${name}`
+      if (isOrderBy) { path = path + `?${Date.now()}` }
+      const tmp = await import(path)
+      lodash.forEach(tmp, (App) => {
+        const index = this.index
+        this.index++
+        if (typeof App === 'object') {
+          if (App?.file?.type !== 'function') { return }
+          if (!App?.name) { return logger.error(`[${dir}][${name}] 插件名称错误`) }
+          App.file.dir = dir
+          App.file.name = name
+          this.PluginList[index] = App
+        }
+        if (typeof App !== 'function' || !App?.prototype?.constructor) { return }
+        const Class = new App()
+        if (!Class.name) { return logger.error(`[${dir}][${name}] 插件名称错误`) }
+        logger.debug(`载入插件 [${name}][${Class.name}]`)
+        const info = PluginApp({
+          file: {
+            dir,
+            name,
+            type: 'class',
+            fnc: App,
+          },
+          name: Class.name,
+          event: Class.event,
+          priority: Class.priority,
+          accept: Class.accept && typeof Class.accept === 'function',
+        })
+        /** 定时任务 */
+        lodash.forEach(Class.task, (val) => {
+          if (!val.name) { return logger.error(`[${dir}][${name}] 定时任务name错误`) }
+          if (!val.cron) { return logger.error(`[${dir}][${name}] 定时任务cron错误：${Class.name}`) }
+          info.task.push({
+            name: val.name,
+            cron: val.cron,
+            fnc: val.fnc,
+            log: val.log === false ? (log) => logger.debug(log) : (log) => logger.mark(log),
+            schedule: schedule.scheduleJob(val.cron, async () => {
+              try {
+                typeof val.log === 'function' && val.log(`[定时任务][${dir}][${val.name}] 开始执行`)
+                if (typeof val.fnc === 'function') {
+                  await val.fnc()
+                } else {
+                  const cla = new App()
+                  await cla[val.fnc]()
+                }
+                typeof val.log === 'function' && val.log(`[定时任务][${dir}][${val.name}] 执行完毕`)
+              } catch (error) {
+                logger.error(`[定时任务][${dir}][${val.name}] 执行报错`)
+                logger.error(error)
+              }
+            }),
+          })
+        })
+        /** rule */
+        lodash.forEach(Class.rule, (val) => {
+          if (!val.fnc) { return logger.error(`[${dir}][${name}] rule.fnc错误：${Class.name}`) }
+          info.rule.push({
+            reg: val.reg instanceof RegExp ? val.reg : new RegExp(val.reg),
+            fnc: val.fnc,
+            event: val.event,
+            permission: val.permission || 'all',
+            log: val.log === false ? (id, log) => logger.debug('mark', id, log) : (id, log) => logger.bot('mark', id, log),
+          })
+        })
+        /** 执行初始化 */
+        Class.init && Class.init()
+        this.PluginList[index] = info
+        // const Class = new App()
+        /** 注册Handler */
+        // if (!lodash.isEmpty(Class.handler)) handler.add({ name, dir, App, Class })
+        /** 注册按钮 */
+        // if (!lodash.isEmpty(Class.button)) button.add({ name, dir, App, Class })
+        /** 收集插件 */
+        // const res = this.App(App, Class, { name, dir, path: `${dir}/${name}` })
+        // this.Apps.push(res)
+        return true
+      })
+      // rule收集并排序
+      if (isOrderBy) { this.orderBy() }
+      return true
+    } catch (error) {
+      if (/Cannot find package '(.+?)'/.exec(error)?.[1]) {
+        const pack = /Cannot find package '(.+?)'/.exec(error)?.[1] || ''
+        logger.error(logger.red('--------插件载入错误--------'))
+        logger.mark(`错误: [${dir}][${name}] 缺少必要的依赖项: ${logger.red(pack)}`)
+        logger.mark(`操作：请尝试在命令终端中执行 ${logger.red('pnpm i -P')} 命令安装依赖项`)
+        logger.mark('提示：如安装后仍未解决，可选择以下方案')
+        logger.mark(`      1.手工安装依赖: ${logger.red('pnpm i ' + pack)}`)
+        logger.mark(`      2.联系插件作者：联系插件作者将 ${logger.red(pack)} 依赖项添加至插件的packageon文件中的dependencies字段中`)
+        logger.error(logger.red('-----------------------------'))
+      } else {
+        logger.error(`载入插件错误：${logger.red(`${dir}/${name}`)}`)
+        logger.error(error)
+      }
+      return false
+    }
+  }
+
+  /**
+     * 卸载插件
+     */
+  uninstallApp (dir, name) {
+    this.Apps = this.Apps.filter((v) => !(v.file.dir === dir && v.file.name === name))
+    this.uninstallTask(dir, name)
+    button.del(dir, name)
+    handler.del({ dir, name, key: '' })
+  }
+
+  /** 创建定时任务 */
+  async creatTask () {
+    this.task.forEach((val, index) => {
+      if (val.schedule) { return }
+      val.log = val.log === false ? (log) => logger.debug(log) : (log) => logger.mark(log)
+      val.schedule = schedule.scheduleJob(val.cron, async () => {
+        try {
+          typeof val.log === 'function' && val.log(`[定时任务][${val.file.dir}][${val.name}] 开始执行`)
+          const App = new val.App()
+          await App[val.fnc]()
+          typeof val.log === 'function' && val.log(`[定时任务][${val.file.dir}][${val.name}] 执行完毕`)
+        } catch (error) {
+          logger.error(`[定时任务][${val.file.dir}][${val.name}] 执行报错`)
+          logger.error(error)
+        }
+      })
+      this.task[index] = val
+    })
+  }
+
+  /**
+     * 卸载定时任务
+     */
+  uninstallTask (dir, name) {
+    this.task = this.task.filter((task) => {
+      if (task.file.dir === dir && task.file.name === name) {
+        /** 停止定时任务 */
+        task.schedule && task.schedule.cancel()
+        /** 移除定时任务 */
+        return false
+      }
+      /** 保留定时任务 */
+      return true
+    })
+  }
+
+  /**
+     * 监听单个文件热更新
+     */
+  watch (dir, name) {
+    // if (this.watcher.get(`${dir}.${name}`)) return
+    // const file = `./plugins/${dir}/${name}`
+    // const watcher = chokidar.watch(file)
+    // /** 监听修改 */
+    // watcher.on('change', async () => {
+    //   /** 卸载 */
+    //   this.uninstallApp(dir, name)
+    //   /** 载入插件 */
+    //   const res = await this.createdApp(dir, name, true)
+    //   if (!res) return
+    //   logger.mark(`[修改插件][${dir}][${name}]`)
+    // })
+    /** 监听删除 */
+    // watcher.on('unlink', async () => {
+    //   /** 卸载 */
+    //   this.uninstallApp(dir, name)
+    //   this.watcher.delete(`${dir}.${name}`)
+    //   logger.mark(`[卸载插件][${dir}][${name}]`)
+    // })
+    // this.watcher.set(`${dir}.${name}`, watcher)
+  }
+
+  /**
+     * 监听文件夹更新
+     */
+  watchDir (dir) {
+    // if (dir) return
+    //   if (this.watcher.get(dir)) return
+    //   const file = `${this.dir}/${dir}/`
+    //   const watcher = chokidar.watch(file)
+    //   /** 热更新 */
+    //   setTimeout(() => {
+    //     /** 新增文件 */
+    //     watcher.on('add', async filePath => {
+    //       logger.debug(`[热更新][新增插件] ${filePath}`)
+    //       const name = path.basename(filePath) as fileName
+    //       if (!name.endsWith('')) return
+    //       if (!fs.existsSync(`${file}/${name}`)) return
+    //       /** 载入插件 */
+    //       const res = await this.createdApp(dir, name, true)
+    //       if (!res) return
+    //       /** 延迟1秒 等待卸载完成 */
+    //       Common.sleep(1000)
+    //         .then(() => {
+    //           /** 停止整个文件夹监听 */
+    //           watcher.close()
+    //           /** 新增插件之后重新监听文件夹 */
+    //           this.watcher.delete(dir)
+    //           this.watchDir(dir)
+    //           logger.mark(`[新增插件][${dir}][${name}]`)
+    //           return true
+    //         })
+    //         .catch(error => logger.error(error))
+    //     })
+    //     /** 监听修改 */
+    //     watcher.on('change', async PluPath => {
+    //       const name = path.basename(PluPath) as fileName
+    //       if (!name.endsWith('')) return
+    //       if (!fs.existsSync(`${this.dir}/${dir}/${name}`)) return
+    //       /** 卸载 */
+    //       this.uninstallApp(dir, name)
+    //       /** 载入插件 */
+    //       const res = await this.createdApp(dir, name, true)
+    //       if (!res) return
+    //       logger.mark(`[修改插件][${dir}][${name}]`)
+    //     })
+    //     /** 监听删除 */
+    //     watcher.on('unlink', async PluPath => {
+    //       const name = path.basename(PluPath) as fileName
+    //       if (!name.endsWith('')) return
+    //       /** 卸载 */
+    //       this.uninstallApp(dir, name)
+    //       /** 停止监听 */
+    //       watcher.close()
+    //       /** 重新监听文件夹 */
+    //       this.watcher.delete(dir)
+    //       this.watchDir(dir)
+    //       logger.mark(`[卸载插件][${dir}][${name}]`)
+    //     })
+    //   }, 500)
+    //   /** 生成随机数0.5-2秒 */
+    //   const random = Math.floor(Math.random() * 1000) + 500
+    //   Common.sleep(random)
+    //     .then(() => {
+    //       const isExist = this.watcher.get(dir)
+    //       /** 这里需要检查一下是否已经存在，已经存在就关掉之前的监听 */
+    //       if (isExist) {
+    //         isExist.close()
+    //         this.watcher.delete(dir)
+    //       }
+    //       this.watcher.set(dir, watcher)
+    //       return true
+    //     })
+    //     .catch(() => {})
+  }
+})()

package/lib/core/server.d.ts

@@ -0,0 +1,26 @@
+import { Express } from 'express';
+import { WebSocketServer } from 'ws';
+import { Server as ServerType, ServerResponse, IncomingMessage } from 'http';
+declare const _default: {
+    reg: RegExp;
+    list: string[];
+    app: Express;
+    server: ServerType<typeof IncomingMessage, typeof ServerResponse>;
+    WebSocketServer: WebSocketServer;
+    RegExp: RegExp;
+    /**
+     * 监听WebSocket连接并初始化http服务器
+     */
+    init(): false | any;
+    /**
+     * HTTP渲染器
+     */
+    static(): void;
+    /**
+     * 构建静态资源路径
+     */
+    staticPath(): void;
+    /** 重启当前HTTP服务器 */
+    "__#3@#restartServer"(): Promise<void>;
+};
+export default _default;

package/lib/core/server.js

@@ -0,0 +1,213 @@
+import fs from 'fs'
+import express from 'express'
+import { createServer } from 'http'
+import { WebSocketServer } from 'ws'
+import { render } from '../index.js'
+import connect from '../renderer/wormhole.js'
+import HttpRenderer from '../renderer/http.js'
+import logger from '../utils/logger.js'
+import common from '../utils/common.js'
+import config from '../utils/config.js'
+import listener from './listener.js'
+import exec from '../utils/exec.js'
+export default new (class Server {
+  reg
+  list
+  app
+  server
+  WebSocketServer
+  RegExp
+  constructor () {
+    this.reg = /(?:)/
+    this.list = []
+    this.app = express()
+    this.server = createServer(this.app)
+    this.WebSocketServer = new WebSocketServer({ server: this.server })
+    this.RegExp = new RegExp(`(${process.cwd()}|${process.cwd().replace(/\\/g, '/')})`, 'g')
+  }
+
+  /**
+     * 监听WebSocket连接并初始化http服务器
+     */
+  init () {
+    try {
+      this.WebSocketServer.on('connection', (socket, request) => {
+        const path = request.url
+        const headers = request.headers
+        logger.debug('[反向WS]', path, JSON.stringify(headers, null, 2))
+        try {
+          const Adapter = listener.getAdapter(path)
+          if (!Adapter) {
+            logger.error(`[反向WS] 适配器不存在：${path}`)
+            return socket.close()
+          }
+          const KarinAdapter = new Adapter()
+          if (typeof KarinAdapter?.server === 'function') {
+            KarinAdapter.server(socket, request)
+          }
+        } catch (error) {
+          logger.error(`[反向WS] 注册适配器发生错误：${path}`, error.stack || error.message || error)
+          socket.close()
+        }
+      })
+      /** GET接口 - 获取当前启动信息 */
+      this.app.get('/api/info', (req, res) => {
+        /** 只允许本机ip访问 */
+        if (req.hostname === 'localhost' || req.hostname === '127.0.0.1') {
+          const data = {
+            start: process.env.pm_id ? 'pm2' : 'node',
+            start_time: process.uptime().toFixed(2),
+            memory: (process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2),
+            time: Date.now(),
+          }
+          res.json(data)
+        }
+      })
+      /** GET接口 - 退出当前进程 */
+      this.app.get('/api/exit', async (req) => {
+        /** 只允许本机ip访问 */
+        if (req.hostname === 'localhost' || req.hostname === '127.0.0.1') {
+          logger.mark('[服务器][HTTP] 收到退出请求，即将退出')
+          /** 关闭服务器 */
+          listener.emit('exit.grpc')
+          this.server.close()
+          /** 如果是pm2 获取当前pm2ID 使用 */
+          if (process.env.pm_id) { await exec(`pm2 delete ${process.env.pm_id}`) }
+          /** 正常启动的进程 */
+          process.exit()
+        }
+      })
+      /** 监听端口 */
+      const { host, port } = config.Server.http
+      this.server.listen(port, host, () => {
+        logger.mark('[服务器][启动成功][HTTP]: ' + logger.green(`http://${host}:${port}`))
+      })
+      listener.once('restart.http', () => {
+        logger.mark('[服务器][重启][HTTP] 正在重启HTTP服务器...')
+        this.#restartServer()
+      })
+      const { enable, WormholeClient } = config.Server.HttpRender
+      if (enable) {
+        this.static()
+        if (WormholeClient) {
+          connect()
+          return this
+        }
+        const { host, post, token } = config.Server.HttpRender
+        /** 注册渲染器 */
+        const rd = new HttpRenderer(host, post, token)
+        render.app({ id: 'puppeteer', type: 'image', render: rd.render.bind(rd) })
+      }
+      return this
+    } catch (error) {
+      logger.error('初始化HTTP服务器失败: ', error)
+      return false
+    }
+  }
+
+  /**
+     * HTTP渲染器
+     */
+  static () {
+    this.staticPath()
+    /** GET接口 - 渲染 */
+    this.app.get('/api/renderHtml', (req, res) => {
+      try {
+        let { html } = req.query
+        if (!html) { return res.status(404).send(JSON.stringify({ code: 404, msg: 'Not Found' })) }
+        html = decodeURIComponent(html)
+          .replace(/\\/g, '/')
+          .replace(/^\.\//, '')
+        /** 判断是否为html文件且路径存在 */
+        if (!html.endsWith('.html') || !fs.existsSync(html)) {
+          const not_found = config.Server.HttpRender.not_found
+          if (not_found.startsWith('http')) {
+            return res.redirect(not_found)
+          } else {
+            return res.status(404).send(JSON.stringify({ code: 404, msg: not_found || '?' }))
+          }
+        }
+        let content = fs.readFileSync(html, 'utf-8')
+        /** 处理所有绝对路径、相对路径 */
+        content = content.replace(this.RegExp, '')
+        res.send(content)
+      } catch (e) {
+        logger.error('[服务器][GET接口 - 渲染]', e)
+        res.status(500).send(JSON.stringify({ code: 500, msg: 'Internal Server Error' }))
+      }
+    })
+    /** 拦截静态资源 防止恶意访问 */
+    this.app.use((req, res, next) => {
+      logger.debug(`[静态资源][${req.headers.host}] ${req.url}`)
+      /** 解码 */
+      req.url = decodeURIComponent(req.url)
+      req.url = req.url
+        .replace(/\\/g, '/')
+        .replace(/^\.\//, '')
+        .replace(/^(\.\.\/)+/, '')
+      /** 拦截非资源文件 */
+      this.reg.lastIndex = 0
+      if (!this.reg.test(req.url)) {
+        logger.mark(`[${req.ip}][拦截非资源文件]`, req.url)
+        res.status(404).send(JSON.stringify({ code: 404, msg: 'Not Found' }))
+        return
+      }
+      next()
+    })
+    /** 设置静态文件目录 */
+    this.app.use(express.static(process.cwd()))
+  }
+
+  /**
+     * 构建静态资源路径
+     */
+  staticPath () {
+    this.list = []
+    /** 读取./resources文件夹 */
+    const resDir = './resources'
+    const resdirs = fs.readdirSync(resDir)
+    for (const dir of resdirs) {
+      const file = `${resDir}/${dir}`
+      if (common.isDir(file)) { this.list.push(file.replace('.', '')) }
+    }
+    /** 读取./temp/html下所有文件夹 */
+    const htmlDir = './temp/html'
+    const dirs = fs.readdirSync(htmlDir)
+    for (const dir of dirs) {
+      const file = `${htmlDir}/${dir}`
+      if (common.isDir(file)) { this.list.push(file.replace('.', '')) }
+    }
+    /** 读取./plugins/html下所有文件夹 */
+    const pluginsDir = './plugins'
+    const plugins = fs.readdirSync(pluginsDir)
+    for (const dir of plugins) {
+      const file = `${pluginsDir}/${dir}`
+      const resFile = `${file}/resources`
+      /** 包含resources文件夹 */
+      if (common.isDir(file) && common.isDir(resFile)) { this.list.push(resFile.replace('.', '')) }
+      const componentsFile = `${file}/components`
+      /** 包含components文件夹 兼容mys */
+      if (common.isDir(file) && common.isDir(componentsFile)) { this.list.push(componentsFile.replace('.', '')) }
+    }
+    this.reg = new RegExp(`(${this.list.join('|')})`, 'g')
+  }
+
+  /** 重启当前HTTP服务器 */
+  async #restartServer () {
+    try {
+      /** 断开所有 WebSocket 连接 */
+      for (const ws of this.WebSocketServer.clients) { ws.terminate() }
+      /** 关闭当前HTTP服务器 */
+      this.server.close()
+      /** 延迟1秒 */
+      await common.sleep(1000)
+      /** 创建一个新的服务器实例 */
+      this.server = createServer(this.app)
+      this.WebSocketServer = new WebSocketServer({ server: this.server })
+      this.init()
+      this.static()
+    } catch (err) {
+      logger.error('[服务器][重启失败]', err)
+    }
+  }
+})()