node-karin 0.10.0 → 0.10.2

package/lib/core/process.js

@@ -1,98 +0,0 @@
-import { listener } from './listener.js'
-import { logger, common, config } from '../utils/index.js'
-/**
- * 处理基本事件
- */
-export default class Process {
-  /**
-     * 进程初始化
-     */
-  static async process () {
-    /**
-         * 监听挂起信号 在终端关闭时触发
-         */
-    process.once('SIGHUP', async (code) => await this.exit(code))
-    /**
-         * 监听中断信号 用户按下 Ctrl + C 时触发
-         */
-    process.once('SIGINT', async (code) => await this.exit(code))
-    /**
-         * 监听终止信号 程序正常退出时触发
-         */
-    process.once('SIGTERM', async (code) => await this.exit(code))
-    /**
-         * 监听退出信号 windows下程序正常退出时触发
-         */
-    process.once('SIGBREAK', async (code) => await this.exit(code))
-    /**
-         * 监听退出信号 与 SIGINT 类似，但会生成核心转储
-         */
-    process.once('SIGQUIT', async (code) => await this.exit(code))
-    /**
-         * 监听退出信号 Node.js进程退出时触发
-         */
-    process.once('exit', async (code) => await this.exit(code))
-    /**
-         * 捕获警告
-         */
-    process.on('warning', warning => listener.emit('warn', warning))
-    /**
-         * 捕获错误
-         */
-    process.on('uncaughtException', error => listener.emit('error', error))
-    /**
-         * 捕获未处理的Promise错误
-         */
-    process.on('unhandledRejection', error => listener.emit('error', error))
-    return this
-  }
-
-  /**
-     * 检查后台进程
-     */
-  static async check () {
-    const host = `http://127.0.0.1:${config.Server.http.port}/api`
-    /**
-         * 使用api来检查后台
-         */
-    const res = await common.axios(host + '/ping', 'get', { timeout: 100 })
-    if (!res) { return this }
-    logger.mark(logger.red('检测到后台进程 正在关闭'))
-    /** 发退出信号 */
-    await common.axios(host + '/exit', 'get', { timeout: 10 })
-    for (let i = 0; i < 50; i++) {
-      const res = await common.axios(host + '/ping', 'get', { timeout: 100 })
-      /** 请求成功继续循环 */
-      if (res) { continue }
-      /** 请求异常即代表后台进程已关闭 */
-      logger.mark(logger.green('后台进程已关闭'))
-      return this
-    }
-    /**
-         * 走到这里说明后台关闭失败
-         * 根据配置文件判断是否继续
-         */
-    logger.error(logger.red(`后台进程关闭失败，请检查是否有进程正在占用端口${config.Server.http.port}`))
-    if (!config.Config.multi_progress) {
-      logger.error(logger.red('当前配置不允许多进程运行，程序即将退出'))
-      await this.exit(1)
-    }
-    logger.error(logger.red('当前配置允许多进程运行，程序继续运行'))
-    return this
-  }
-
-  /**
-     * 退出Karin
-     * @param code 退出码
-     */
-  static async exit (code = 0) {
-    try {
-      const { redis } = await import('../db/index.js')
-      if (redis && redis.save) { await redis.save() }
-      logger.mark(`Karin 已停止运行 运行时间：${common.uptime()} 退出码：${code || '未知'}`)
-    } finally {
-      process.exit()
-    }
-  }
-}
-Process.process()

package/lib/core/server.js

@@ -1,269 +0,0 @@
-import fs from 'fs'
-import Process from './process.js'
-import { WebSocketServer } from 'ws'
-import { createServer } from 'http'
-import { listener } from './listener.js'
-import express from 'express'
-import { exec, config, logger, common } from '../utils/index.js'
-import { AdapterOneBot11 } from '../adapter/onebot/11/index.js'
-import { render, HttpRenderer, Wormhole, RenderClient } from '../render/index.js'
-export const server = 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服务器
-     */
-  async init () {
-    try {
-      /** 防止多进程端口冲突 启动失败 */
-      await Process.check()
-      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/ping', (req, res) => {
-        /** 只允许本机ip访问 */
-        if (req.hostname === 'localhost' || req.hostname === '127.0.0.1') {
-          const data = {
-            pm2_id: process.env.pm_id || '',
-            uptime: process.uptime(),
-            karin_app_mode: process.env.karin_app_mode,
-            karin_app_lang: process.env.karin_app_lang,
-            karin_app_runner: process.env.karin_app_runner,
-            karin_app_start_count: process.env.karin_app_start_count,
-          }
-          res.json(data)
-        } else {
-          res.status(403).json({ error: '禁止访问', message: '无效的请求' })
-        }
-      })
-      /** 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()
-        }
-      })
-      /** 控制台适配器 */
-      this.app.get('/api/input', (req, res) => {
-        const name = req.query.name
-        const token = req.query.token
-        if (!name || !token) {
-          logger.error('[HTTP][input] 缺少参数', req.query)
-          return res.status(403).json({ error: '禁止访问', message: '缺少参数' })
-        }
-        // 禁止键入向上级目录
-        if (name.includes('/')) {
-          logger.error('[HTTP][input] 无效的文件名', name)
-          return res.status(403).json({ error: '禁止访问', message: '无效的文件名' })
-        }
-        const CfgToken = config.Config.AdapterInput.token
-        if (CfgToken === 'AdapterInput' || CfgToken !== token) {
-          logger.error('[HTTP][input] 无效的令牌', token)
-          return res.status(403).json({ error: '禁止访问', message: '无效的令牌' })
-        }
-        const file = process.cwd() + `/temp/input/${name}`
-        if (!fs.existsSync(file)) {
-          logger.error('[HTTP][input] 文件不存在', file)
-          return res.status(404).json({ error: '文件不存在', message: '找不到指定文件' })
-        }
-        logger.info(`${logger.yellow('[HTTP][input]')} ${logger.green(token)} file:${file}`)
-        res.sendFile(file)
-      })
-      /** 监听端口 */
-      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 renderCfg = config.Server.websocket.render
-      if (Array.isArray(renderCfg) && renderCfg.length) {
-        for (const url of renderCfg) {
-          new RenderClient(url).start()
-        }
-      }
-      const Onebot11 = config.Server.websocket.OneBot11Host
-      if (Array.isArray(Onebot11) && Onebot11.length) {
-        for (const connect of Onebot11) {
-          new AdapterOneBot11().client(connect)
-        }
-      }
-      const { enable, WormholeClient } = config.Server.HttpRender
-      if (enable) {
-        this.static()
-        if (WormholeClient) {
-          Wormhole()
-          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()))
-  }
-
-  /**
-     * 构建静态资源路径
-     */
-  async 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/xxx/resources下所有文件夹 */
-    const pluginsDir = './plugins'
-    const plugins = fs.readdirSync(pluginsDir)
-    for (const dir of plugins) {
-      /** 忽略不是karin-plugin-开头 */
-      if (!dir.startsWith('karin-plugin-')) { continue }
-      const file = `${pluginsDir}/${dir}`
-      const resFile = `${file}/resources`
-      /** 包含resources文件夹 */
-      if (common.isDir(file) && common.isDir(resFile)) { this.list.push(resFile.replace('.', '')) }
-      const componentsFile = `${file}/lib/components`
-      /** 包含lib/components文件夹 兼容mys */
-      if (common.isDir(file) && common.isDir(componentsFile)) { this.list.push(componentsFile.replace('.', '')) }
-      /** 读取package.json 查找是否存在自定义资源文件入口 */
-      const pkgFile = `${file}/package.json`
-      if (!common.exists(pkgFile)) { continue }
-      const pkg = common.readJson(pkgFile)
-      if (!pkg?.karin?.static || !Array.isArray(pkg.karin.static)) { continue }
-      /** 标准格式为 lib/test/xxxx */
-      for (let staticFile of pkg.karin.static) {
-        /** 不允许向上级目录 ../开头等 */
-        if (staticFile.startsWith('../')) { continue }
-        /** ./开头去掉./ */
-        if (staticFile.startsWith('./')) { staticFile = staticFile.slice(2) }
-        this.list.push(`${file}/${staticFile}`)
-      }
-    }
-    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)
-    }
-  }
-})()

package/lib/db/level.js

@@ -1,37 +0,0 @@
-import { Level } from 'level'
-const path = process.cwd() + '/data/db/Level'
-/**
- * @type {Level}
- */
-export default class LevelDB extends Level {
-  id
-  constructor () {
-    super(path, { valueEncoding: 'json' })
-    /**
-         * @type {'Level'} 唯一标识符 用于区分不同的数据库
-         */
-    this.id = 'Level'
-  }
-
-  /**
-     * 对get方法进行重写 找不到数据时返回null
-     */
-  async get (key) {
-    try {
-      const res = await super.get(key)
-      return res
-    } catch {
-      return ''
-    }
-  }
-
-  /**
-     * 增加set方法
-     * @param {string} key 键
-     * @param {object|string} value 值
-     */
-  async set (key, value) {
-    return await super.put(key, value)
-  }
-}
-export const level = new LevelDB()

package/lib/db/redis.js

@@ -1,134 +0,0 @@
-import { exec } from 'child_process'
-import RedisLevel from './redis_level.js'
-import { logger, config } from '../utils/index.js'
-import { createClient, createCluster } from 'redis'
-class Redis {
-  id
-  RunCmd
-  constructor () {
-    this.id = 'redis'
-    this.RunCmd = ''
-  }
-
-  /**
-     * redis实例化
-     */
-  async start () {
-    const { host, port, username, password, db: database, cluster } = config.redis
-    /** 集群模式 */
-    if (cluster && cluster.enable) {
-      const rootNodes = cluster.rootNodes.map((node) => ({ url: node }))
-      logger.debug('正在连接 Redis 集群...')
-      const { status, data } = await this.connectCluster(rootNodes)
-      if (status === 'ok') {
-        logger.info('Redis 集群连接成功')
-        return data
-      }
-      logger.error(`Redis 集群建立连接失败：${logger.red(data)}`)
-      return false
-    }
-    logger.debug(`正在连接 ${logger.green(`Redis://${host}:${port}/${database}`)}`)
-    const options = { socket: { host, port }, username, password, database }
-    /** 第一次连接 */
-    const { status, data } = await this.connect(options)
-    if (status === 'ok') {
-      logger.info('Redis 连接成功')
-      return data
-    }
-    /** 第一次连接失败尝试拉起 windows直接降级 */
-    if (process.platform === 'win32') {
-      // logger.info(`Redis 建立连接失败：${data}`)
-      return await this.LevelDB()
-    }
-    this.RunCmd = 'redis-server --save 900 1 --save 300 10 --daemonize yes' + (await this.aarch64())
-    logger.info('正在尝试启动 Redis...')
-    try {
-      await this.execSync(this.RunCmd)
-      /** 启动成功再次重试 */
-      const { status, data } = await this.connect(options)
-      if (status === 'ok') {
-        logger.info('Redis 连接成功')
-        return data
-      }
-      logger.debug(`Redis 二次建立连接失败：${logger.red(data)}`)
-      return false
-    } catch (error) {
-      logger.debug(`Redis 启动失败：${logger.red(data)}`)
-      return await this.LevelDB()
-    }
-  }
-
-  /**
-     * 降级为 LevelDB
-     */
-  async LevelDB () {
-    try {
-      logger.debug('使用LevelDB代替Redis实现基础Api')
-      const redis = new RedisLevel()
-      return redis
-    } catch (error) {
-      logger.error('降级为 LevelDB 失败')
-      logger.error(error)
-      return false
-    }
-  }
-
-  /**
-     * 连接 Redis 单例
-     */
-  async connect (options) {
-    const client = createClient(options)
-    try {
-      await client.connect()
-      return { status: 'ok', data: client }
-    } catch (error) {
-      return { status: 'error', data: error }
-    }
-  }
-
-  /**
-     * 连接 Redis 集群
-     */
-  async connectCluster (rootNodes) {
-    const client = createCluster({ rootNodes })
-    try {
-      await client.connect()
-      return { status: 'ok', data: client }
-    } catch (error) {
-      return { status: 'error', data: error }
-    }
-  }
-
-  /**
-     * 判断是否为 ARM64 并返回参数
-     */
-  async aarch64 () {
-    try {
-      /** 判断arch */
-      const arch = await this.execSync('uname -m')
-      if (arch && arch.includes('aarch64')) {
-        /** 提取 Redis 版本 */
-        const version = await this.execSync('redis-server -v')
-        if (version) {
-          /** 提取版本号 */
-          const RedisVersion = version.match(/v=(\d)./)
-          /** 如果>=6版本则忽略警告 */
-          if (RedisVersion && Number(RedisVersion[1]) >= 6) { return ' --ignore-warnings ARM64-COW-BUG' }
-        }
-      }
-      return ''
-    } catch {
-      return ''
-    }
-  }
-
-  execSync (cmd) {
-    return new Promise((resolve, reject) => {
-      exec(cmd, (error, stdout) => {
-        if (error) { return reject(error) }
-        resolve(stdout)
-      })
-    })
-  }
-}
-export const redis = await new Redis().start()