node-karin 0.10.0 → 0.10.2

package/lib/utils/config.js

@@ -1,318 +0,0 @@
-import fs from 'fs'
-import Yaml from 'yaml'
-import path from 'path'
-import chokidar from 'chokidar'
-import { karinDir } from '../core/dir.js'
-import { common } from './common.js'
-/**
- * 配置文件
- */
-export const config = new (class Cfg {
-  /**
-     * 运行目录绝对路径
-     */
-  dir
-  /**
-     * 运行目录配置文件夹路径
-     */
-  cfgDir
-  /**
-     * node-karin npm包路径
-     */
-  pkgDir
-  /**
-     * node-karin 包配置文件夹路径
-     */
-  pkgCfgDir
-  change
-  watcher
-  review
-  logger
-  constructor () {
-    this.dir = process.cwd()
-    this.pkgDir = karinDir
-    this.cfgDir = this.dir + '/config'
-    this.pkgCfgDir = this.pkgDir + '/config/defSet'
-    /** 缓存 */
-    this.change = new Map()
-    /** 监听文件 */
-    this.watcher = new Map()
-    /** 拦截器状态 */
-    this.review = false
-    this.initCfg()
-  }
-
-  /** 初始化配置 */
-  async initCfg () {
-    const list = [
-      this.dir + '/temp/input',
-      this.dir + '/plugins/karin-plugin-example',
-      this.cfgDir + '/config',
-      this.cfgDir + '/plugin',
-    ]
-    list.forEach(path => this.mkdir(path))
-    if (this.pkgCfgDir !== (this.cfgDir + '/defSet').replace(/\\/g, '/')) {
-      const files = fs.readdirSync(this.pkgCfgDir).filter(file => file.endsWith('.yaml'))
-      files.forEach(file => {
-        const path = `${this.cfgDir}/config/${file}`
-        const pathDef = `${this.pkgCfgDir}/${file}`
-        if (!fs.existsSync(path)) { fs.copyFileSync(pathDef, path) }
-      })
-    }
-    /** 为每个插件包创建统一存储的文件夹 */
-    const plugins = await this.getPlugins()
-    const DataList = [
-      'data',
-      'temp',
-      'resources',
-      'temp/html',
-      this.cfgDir + '/plugin',
-    ]
-    DataList.forEach(path => this.dirPath(path, plugins))
-    this.logger = (await import('./logger.js')).default
-  }
-
-  async getPlugins () {
-    const list = []
-    const files = fs.readdirSync('./plugins', { withFileTypes: true })
-    // 过滤掉非karin-plugin-开头的文件夹
-    list.push(...files.filter(file => file.isDirectory() && (file.name.startsWith('karin-plugin-'))).map(dir => dir.name))
-    // 获取npm插件
-    list.push(...(await common.getNpmPlugins(false)))
-    return list
-  }
-
-  /**
-     * 递归创建目录
-     * @param dirname - 要创建的文件夹路径
-     */
-  mkdir (dirname) {
-    if (fs.existsSync(dirname)) { return true }
-    /** 递归自调用 */
-    if (this.mkdir(path.dirname(dirname))) { fs.mkdirSync(dirname) }
-    return true
-  }
-
-  /**
-     * 为每一个插件建立对应的文件夹
-     */
-  async dirPath (_path, plugins) {
-    this.mkdir(_path)
-    for (const plugin of plugins) {
-      const path = `${_path}/${plugin}`
-      this.mkdir(path)
-    }
-  }
-
-  /**
-     * 超时时间
-     */
-  timeout (type = 'ws') {
-    let timeout = 60
-    if (type === 'ws') {
-      timeout = this.Server.websocket.timeout
-    } else {
-      timeout = this.Server.grpc.timeout
-    }
-    return timeout || 60
-  }
-
-  /**
-     * Redis 配置
-     * 采用实时读取优化性能
-     */
-  get redis () {
-    const config = this.getYaml('config', 'redis', false)
-    const defSet = this.getYaml('defSet', 'redis', false)
-    const data = { ...defSet, ...config }
-    return data
-  }
-
-  /**
-     * 主人列表
-     */
-  get master () {
-    return this.Config.master || []
-  }
-
-  /**
-     * 管理员列表
-     */
-  get admin () {
-    return this.Config.admin || []
-  }
-
-  /** App管理 */
-  get App () {
-    const key = 'change.App'
-    const res = this.change.get(key)
-    /** 取缓存 */
-    if (res) { return res }
-    /** 取配置 */
-    const config = this.getYaml('config', 'App', true)
-    const defSet = this.getYaml('defSet', 'App', true)
-    const data = { ...defSet, ...config }
-    /** 缓存 */
-    this.change.set(key, data)
-    return data
-  }
-
-  /**
-     * 基本配置
-     */
-  get Config () {
-    const key = 'change.config'
-    const res = this.change.get(key)
-    /** 取缓存 */
-    if (res) { return res }
-    /** 取配置 */
-    const config = this.getYaml('config', 'config', true)
-    const defSet = this.getYaml('defSet', 'config', false)
-    const data = { ...defSet, ...config }
-    const Config = {
-      ...data,
-      WhiteList: {
-        users: data.WhiteList.users.map((i) => String(i)),
-        groups: data.WhiteList.groups.map((i) => String(i)),
-        GroupMsgLog: data.WhiteList.GroupMsgLog.map((i) => String(i)),
-      },
-      BlackList: {
-        users: data.BlackList.users.map((i) => String(i)),
-        groups: data.BlackList.groups.map((i) => String(i)),
-        GroupMsgLog: data.BlackList.GroupMsgLog.map((i) => String(i)),
-      },
-      master: data.master.map((i) => String(i)),
-      admin: data.admin.map((i) => String(i)),
-      private: {
-        white_list: data.private.white_list.map((i) => String(i)),
-        tips: data.private.tips,
-      },
-    }
-    /** 缓存 */
-    this.change.set(key, Config)
-    return Config
-  }
-
-  /**
-     * Server 配置文档
-     */
-  get Server () {
-    const key = 'change.server'
-    /** 取缓存 */
-    const res = this.change.get(key)
-    if (res) { return res }
-    /** 取配置 */
-    const config = this.getYaml('config', 'server', true)
-    const defSet = this.getYaml('defSet', 'server', false)
-    const data = { ...defSet, ...config }
-    /** 缓存 */
-    this.change.set(key, data)
-    return data
-  }
-
-  /**
-     * packageon
-     * 实时获取packageon文件
-     */
-  get package () {
-    const data = fs.readFileSync(this.pkgDir + '/package.json', 'utf8')
-    const pack = JSON.parse(data)
-    return pack
-  }
-
-  /**
-     * 获取群配置
-     */
-  group (group_id = '') {
-    const key = 'change.group'
-    /** 取缓存 */
-    let res = this.change.get(key)
-    if (res) {
-      res = { ...res.defCfg.default, ...res.Config.default, ...(res.Config[group_id] || {}) }
-      return res
-    }
-    /** 取配置 */
-    const Config = this.getYaml('config', 'group', true)
-    const defCfg = this.getYaml('defSet', 'group', false)
-    const data = { Config, defCfg }
-    /** 缓存 */
-    res = this.change.set(key, data)
-    res = { ...defCfg.default, ...Config.default, ...(Config[group_id] || {}) }
-    return res
-  }
-
-  /**
-     * 获取配置yaml
-     */
-  getYaml (type, name, isWatch = false) {
-    /** 文件路径 */
-    const file = type === 'defSet' ? `${this.pkgCfgDir}/${name}.yaml` : `${this.cfgDir}/config/${name}.yaml`
-    /** 读取文件 */
-    const data = Yaml.parse(fs.readFileSync(file, 'utf8'))
-    /** 监听文件 */
-    if (isWatch) { this.watch(type, name, file) }
-    return data
-  }
-
-  /**
-     * 监听配置文件
-     * @param {'defSet'|'config'} type 类型
-     * @param {string} name 文件名称 不带后缀
-     * @param {string} file 文件路径
-     */
-  async watch (type, name, file) {
-    const key = `change.${name}`
-    /** 已经监听过了 */
-    const res = this.watcher.get(key)
-    if (res) { return true }
-    /** 监听文件 */
-    const watcher = chokidar.watch(file)
-    /** 监听文件变化 */
-    watcher.on('change', () => {
-      this.change.delete(key)
-      this.logger.mark(`[修改配置文件][${type}][${name}]`)
-      /** 文件修改后调用对应的方法 */
-      switch (`change_${name}`) {
-        case 'change_App':
-          this.change_App()
-          break
-        case 'change_config':
-          this.change_config()
-          break
-        case 'change_group':
-          this.change_group()
-          break
-      }
-    })
-    /** 缓存 防止重复监听 */
-    this.watcher.set(key, watcher)
-  }
-
-  async change_App () {
-    await this.#review()
-  }
-
-  async change_config () {
-    /** 修改日志等级 */
-    this.logger.level = this.Config.log4jsCfg.level
-    await this.#review()
-    if (this.Server.HotUpdate) {
-      const { Bot } = await import('../index.js')
-      Bot.emit('restart_http', {})
-      Bot.emit('restart_grpc', {})
-    }
-  }
-
-  async change_group () {
-    await this.#review()
-  }
-
-  async #review () {
-    if (this.review) { return }
-    this.review = true
-    const { review } = await import('../event/index.js')
-    review.main()
-    this.review = false
-  }
-})()
-export const Cfg = config

package/lib/utils/exec.js

@@ -1,36 +0,0 @@
-import logger from './logger.js'
-import { exec as execCmd } from 'child_process'
-/**
- * 执行 shell 命令
- * @param cmd 命令
- * @param log 是否打印日志
- * @param options 选项
- */
-export const exec = (cmd, log = true, options = { cwd: process.cwd(), encoding: 'utf-8' }) => {
-  return new Promise(resolve => {
-    const logMessage = (level, message) => {
-      if (log) { logger[level](message) }
-    }
-    const logType = (status) => {
-      switch (status) {
-        case '开始执行':
-          return logger.yellow('[exec][开始执行]')
-        case 'ok':
-          return logger.green('[exec][执行成功]')
-        case 'failed':
-          return logger.red('[exec][执行失败]')
-      }
-    }
-    const formatMessage = (status, details) => [logType(status), `cmd: ${cmd}`, `cwd: ${options.cwd || process.cwd()}`, details, '--------'].join('\n')
-    logMessage('info', formatMessage('开始执行', ''))
-    execCmd(cmd, options, (error, stdout, stderr) => {
-      if (error) {
-        logMessage('error', formatMessage('failed', `Error: ${error.message || error.stack || error.toString()}`))
-        return resolve({ status: 'failed', error, stdout, stderr })
-      }
-      logMessage('mark', formatMessage('ok', `stdout: ${stdout}\nstderr: ${stderr}`))
-      resolve({ status: 'ok', error, stdout, stderr })
-    })
-  })
-}
-export default exec

package/lib/utils/ffmpeg.js

@@ -1,25 +0,0 @@
-import exec from './exec.js'
-import logger from './logger.js'
-import { config } from './config.js'
-/**
- * 执行 ffmpeg 命令
- */
-export async function ffmpeg () {
-  let ffmpeg = 'ffmpeg'
-  const { status } = await exec('ffmpeg -version', false)
-  if (status !== 'ok') {
-    logger.debug('ffmpeg 未安装，开始尝试读取配置文件是否存在ffmpeg路径')
-    const ffmpegPath = config.Config.ffmpeg_path
-    if (!ffmpegPath) {
-      logger.warn('ffmpeg 未安装，请安装 ffmpeg 或手动配置 ffmpeg 路径后重启')
-      return false
-    }
-    ffmpeg = `"${ffmpegPath}"`
-  }
-  // 返回函数
-  return async (cmd, log = true, options = { cwd: process.cwd(), encoding: 'utf-8' }) => {
-    cmd = cmd.replace(/^ffmpeg/, '').trim()
-    cmd = `${ffmpeg} ${cmd}`
-    return await exec(cmd, log, options)
-  }
-}

package/lib/utils/handler.js

@@ -1,109 +0,0 @@
-import lodash from 'lodash'
-import logger from './logger.js'
-import { pluginLoader as loader } from '../core/index.js'
-/**
- * 事件处理器类
- */
-export const handler = new (class EventHandler {
-  /**
-     * 添加事件处理器
-     * @param index 插件索引
-     * @param Class 插件类
-     */
-  async add (index, Class) {
-    lodash.forEach(Class.handler, val => {
-      if (!val.key) { logger.error(`[Handler][Add]: [${Class.name}] 缺少 key`) }
-      if (!val.fnc) { logger.error(`[Handler][Add]: [${Class.name}] 缺少 fnc`) }
-      logger.debug(`[Handler][Reg]: [${Class.name}][${val.key}]`)
-      if (!Array.isArray(loader.handlerIds[val.key])) { loader.handlerIds[val.key] = [] }
-      loader.handlerIds[val.key].push({ index, fnc: val.fnc, priority: val.priority || Class.priority })
-      loader.handlerIds[val.key] = lodash.orderBy(loader.handlerIds[val.key], ['priority'], ['asc'])
-    })
-  }
-
-  /**
-     * 删除事件处理器
-     * 如果不传参数则删除所有处理器
-     * @param index 插件索引
-     * @param key 事件键
-     */
-  del (index = '', key = '') {
-    /** 无参 */
-    if (!key && !index) {
-      loader.handlerIds = {}
-      return true
-    }
-    /** 删除指定索引插件 */
-    if (!key) {
-      for (const v of Object.keys(loader.handlerIds)) {
-        loader.handlerIds[v] = loader.handlerIds[v].filter(v => v.index !== index)
-        // 如果处理器为空则删除键
-        if (!loader.handlerIds[v].length) {
-          delete loader.handlerIds[v]
-        } else {
-          loader.handlerIds[v] = lodash.orderBy(loader.handlerIds[v], ['priority'], ['asc'])
-        }
-      }
-      return true
-    }
-    /** 删除指定key */
-    if (!index) {
-      loader.handlerIds[key] && delete loader.handlerIds[key]
-      return true
-    }
-    /** 删除指定key的index */
-    if (!loader.handlerIds[key]) { return false }
-    loader.handlerIds[key] = loader.handlerIds[key].filter(v => v.index !== index)
-    if (!loader.handlerIds[key].length) {
-      delete loader.handlerIds[key]
-      return true
-    }
-    loader.handlerIds[key] = lodash.orderBy(loader.handlerIds[key], ['priority'], ['asc'])
-    return true
-  }
-
-  /**
-     * 调用事件处理器
-     * @param key 事件键
-     * @param args 自定义参数 一般用来传递e之类的
-     */
-  async call (key, args) {
-    let res
-    for (const v of loader.handlerIds[key] || []) {
-      const info = loader.PluginList[v.index]
-      try {
-        let done = true
-        /**
-                 * 拒绝处理器 调用后则不再继续执行下一个处理器
-                 * @param msg 错误信息
-                 */
-        const reject = (msg = '') => {
-          if (msg) { logger.mark(`[Handler][Reject]: [${info.file.dir}][${info.file.name}][${key}] ${msg}`) }
-          done = false
-        }
-        if (info.file.type === 'function' && typeof v.fnc === 'function') {
-          res = await v.fnc(args, reject)
-        } else {
-          const cla = new info.file.Fnc()
-          if (args.e) { cla.e = args.e }
-          res = await cla[v.fnc](args, reject)
-        }
-        if (done) {
-          logger.mark(`[Handler][Done]: [${info.file.dir}][${info.file.name}][${key}]`)
-          return res
-        }
-      } catch (e) {
-        // 产生错误继续下一个处理器
-        logger.error(`[Handler][Error]: [${info.file.dir}][${info.file.name}][${key}] ${e}`)
-      }
-    }
-    return res
-  }
-
-  /**
-     * 检查是否存在指定键的事件处理器
-     */
-  has (key) {
-    return !!loader.handlerIds[key]
-  }
-})()

package/lib/utils/init.js

@@ -1,208 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { exec } from 'child_process'
-import { karinDir } from '../core/dir.js'
-export class KarinInit {
-  /**
-     * 基础目录
-     */
-  baseDir
-  constructor () {
-    this.baseDir = [
-      './config/config',
-      './config/view',
-      './config/plugin',
-      './temp/input',
-      './temp/html',
-      './plugins/karin-plugin-example',
-    ]
-  }
-
-  init () {
-    this.baseDir.forEach(dir => this.mkdir(dir))
-    /** 非src源代码环境才创建 */
-    if (!fs.existsSync('./src')) {
-      this.copyFile()
-      this.modifyPackage()
-    }
-  }
-
-  /**
-     * 递归创建目录
-     * @param dirname - 路径
-     */
-  mkdir (dirname) {
-    if (fs.existsSync(dirname)) { return true }
-    if (this.mkdir(path.dirname(dirname))) { fs.mkdirSync(dirname) }
-    return true
-  }
-
-  /**
-     * 解析json
-     */
-  readJson (file) {
-    return JSON.parse(fs.readFileSync(file, 'utf-8'))
-  }
-
-  /**
-     * 获取插件列表
-     */
-  getPlugins () {
-    const pluginsDir = './plugins'
-    const plugins = fs.readdirSync(pluginsDir)
-    return plugins.filter(dir => dir.startsWith('karin-plugin-'))
-  }
-
-  /**
-     * 从npm包内复制默认配置出来
-     */
-  copyFile () {
-    /** 配置 */
-    const list = ['config/view']
-    list.forEach(dir => {
-      const pkgDir = path.join(karinDir, dir)
-      const projDir = path.join(process.cwd(), dir)
-      /** 清空projDir目录下的文件 保留目录 */
-      if (fs.existsSync(projDir)) { fs.rmSync(projDir, { recursive: true }) }
-      this.mkdir(projDir)
-      /** 读取pkgDir目录下的所有文件 复制到projDir下 */
-      const files = fs.readdirSync(pkgDir).filter(file => file.endsWith('.yaml'))
-      files.forEach(file => {
-        const destPath = path.join(projDir, file)
-        const srcPath = path.join(pkgDir, file)
-        fs.copyFileSync(srcPath, destPath)
-      })
-    })
-    /** 创建pnpm工作区配置 */
-    fs.writeFileSync('./pnpm-workspace.yaml', `packages:\n  - 'plugins/**'\n`)
-    /** 为每个插件包创建统一存储的文件夹 */
-    const plugins = this.getPlugins()
-    const DataList = [
-      'data',
-      'temp',
-      'resources',
-      'temp/html',
-      'config/plugin',
-    ]
-    DataList.forEach(_path => {
-      _path = path.join(process.cwd(), _path)
-      plugins.forEach(plugin => this.mkdir(path.join(_path, plugin)))
-    })
-  }
-
-  /**
-     * 修改package.json以支持运行
-     */
-  modifyPackage () {
-    const pkg = this.readJson(path.join(karinDir, 'package.json'))
-    const projPkg = this.readJson('./package.json')
-    const main = 'node_modules/node-karin/lib/index.js'
-    delete pkg.bin
-    pkg.main = `./${main}`
-    pkg.types = `./${main.replace('.js', '.d.ts')}`
-    pkg.dependencies = { ...projPkg.dependencies, ...pkg.dependencies }
-    pkg.devDependencies = { ...projPkg.devDependencies, ...pkg.devDependencies }
-    projPkg.type = 'module'
-    projPkg.private = true
-    projPkg.main = `./${main}`
-    projPkg.dependencies = { ...projPkg.dependencies, ...pkg.dependencies }
-    projPkg.dependencies['node-karin'] = 'latest'
-    projPkg.dependencies['kritor-proto'] = 'latest'
-    if (!projPkg.scripts) { projPkg.scripts = {} }
-    if (!projPkg.devDependencies) { projPkg.devDependencies = {} }
-    projPkg.scripts.debug = `node --watch ${main}`
-    projPkg.scripts.dev = `tsx --watch ${main}`
-    fs.writeFileSync('./package.json', JSON.stringify(projPkg, null, 2))
-  }
-
-  /**
-     * 更换镜像源为淘宝源
-     */
-  async changeRegistry (host) {
-    const cmd = `npm config set registry ${host}`
-    // 检查当前镜像源是否为淘宝源
-    const registry = await this.shell('npm config get registry')
-    if (registry === host) {
-      console.log(`当前npm源已经是 ${host} ~`)
-      return
-    }
-    if (!await this.shell(cmd)) {
-      console.log('更换npm源失败，请手动更换npm源！')
-      console.log(`可尝试手动执行 【 npm config set registry ${host} 】 更换镜像源~`)
-    } else {
-      console.log('更换npm源成功~')
-    }
-  }
-
-  /**
-     * 安装pnpm或者yarn
-     * @param type - 包管理器名称
-     */
-  async install (type) {
-    /** 检查是否已经安装对应的包管理器 */
-    if (!(await this.shell(`${type} -v`))) {
-      console.log(`检测到未安装${type}，开始安装...`)
-      if (!await this.shell(`npm install -g ${type}`)) {
-        console.log(`${type}安装失败，请手动安装${type}！`)
-        console.log(`可尝试手动执行 【 npm install -g ${type} 】 安装${type}~`)
-        return
-      } else {
-        console.log(`${type}安装完成~`)
-      }
-    } else {
-      console.log('检测到已安装pnpm，开始安装依赖...')
-    }
-    /** 安装依赖 */
-    if (!(await this.shell(`${type} -P --force`))) {
-      console.log('安装依赖失败，请手动安装依赖！')
-      console.log(`可尝试手动执行 【 ${type} install -P 】 安装依赖~`)
-      console.log('如中国大陆用户安装失败，请尝试执行换源 【 npm config set registry https://registry.npmmirror.com 】后再安装依赖~')
-    } else {
-      console.log('依赖安装完成~')
-    }
-    /** 检查安装pm2 */
-    if (!(await this.shell('pm2 -v'))) {
-      console.log('检测到未安装pm2，开始安装pm2...')
-      if (!(await this.shell(`${type} install -g pm2`))) {
-        console.log('安装pm2失败，请手动安装pm2！')
-        console.log('可尝试手动执行 【 npm install -g pm2 】 安装pm2~')
-      } else {
-        console.log('pm2安装完成~')
-      }
-    } else {
-      console.log('检测到已安装pm2~')
-    }
-    console.log('依赖环境初始化完成~')
-  }
-
-  /**
-     * 执行命令
-     * @param cmd - 命令
-     */
-  shell (cmd) {
-    return new Promise(resolve => {
-      exec(cmd, { env: process.env, cwd: process.cwd() }, (err, stdout, stderr) => {
-        if (stdout) { return resolve(stdout.trim()) }
-        if (err) {
-          console.error(err)
-          return resolve(false)
-        }
-        if (stderr) {
-          console.error(stderr)
-          return resolve(false)
-        }
-      })
-    })
-  }
-
-  /**
-     * 获取当前的包管理器 根据锁文件判断
-     */
-  getRegistry () {
-    if (fs.existsSync('./pnpm-lock.yaml')) { return 'pnpm' }
-    if (fs.existsSync('./yarn.lock')) { return 'yarn' }
-    if (fs.existsSync('./package-lock.json')) { return 'npm' }
-    // cnpm 没有锁文件
-    return 'cnpm'
-  }
-}