node-karin 0.0.3

package/lib/utils/config.js

@@ -0,0 +1,254 @@
+import fs from 'fs'
+import Yaml from 'yaml'
+import chokidar from 'chokidar'
+/** 配置文件 */
+export default new (class Cfg {
+  dir
+  _path
+  _pathDef
+  change
+  watcher
+  review
+  loggger
+  constructor () {
+    this.dir = process.cwd()
+    this._path = this.dir + '/config/config'
+    this._pathDef = this.dir + '/config/defSet'
+    /** 缓存 */
+    this.change = new Map()
+    /** 监听文件 */
+    this.watcher = new Map()
+    /** 拦截器状态 */
+    this.review = false
+    this.initCfg()
+  }
+
+  /** 初始化配置 */
+  async initCfg () {
+    if (!fs.existsSync(this._path)) { fs.mkdirSync(this._path) }
+    const files = fs.readdirSync(this._pathDef).filter(file => file.endsWith('.yaml'))
+    for (const file of files) {
+      const path = `${this._path}/${file}`
+      const pathDef = `${this._pathDef}/${file}`
+      if (!fs.existsSync(path)) { fs.copyFileSync(pathDef, path) }
+    }
+    // 创建插件文件夹文件夹
+    const plugins = this.getPlugins()
+    this.dirPath('data', plugins)
+    this.dirPath('temp', plugins)
+    this.dirPath('resources', plugins)
+    this.dirPath('temp/html', plugins)
+    this.loggger = (await import('./logger.js')).default
+  }
+
+  getPlugins () {
+    const files = fs.readdirSync('./plugins', { withFileTypes: true })
+    // 过滤掉非karin-plugin-开头或karin-adapter-开头的文件夹
+    return files.filter(file => file.isDirectory() && (file.name.startsWith('karin-plugin-') || file.name.startsWith('karin-adapter-'))).map(dir => dir.name)
+  }
+
+  /**
+     * 为每一个插件建立对应的文件夹
+     */
+  async dirPath (name, plugins) {
+    name = `./${name}`
+    if (!fs.existsSync(name)) { fs.mkdirSync(name) }
+    for (const plugin of plugins) {
+      const path = `${name}/${plugin}`
+      if (!fs.existsSync(path)) { fs.mkdirSync(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
+  }
+
+  /**
+     * 主人列表
+     * @returns {string[]}
+     */
+  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 }
+    /** 缓存 */
+    this.change.set(key, data)
+    return data
+  }
+
+  /**
+     * 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('./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')
+    const defCfg = this.getYaml('defSet', 'group')
+    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 = `./config/${type}/${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.change.get(key)
+    if (res) { return true }
+    /** 监听文件 */
+    const watcher = chokidar.watch(file)
+    /** 监听文件变化 */
+    watcher.on('change', () => {
+      this.change.delete(key)
+      this.loggger.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.loggger.level = this.Config.log_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/review')
+    // review.default.main()
+    // this.review = false
+  }
+})()

package/lib/utils/exec.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 执行 shell 命令
+ * @param cmd 命令
+ * @param log 是否打印日志
+ * @param options 选项
+ */
+export declare const exec: (cmd: string, log?: boolean, options?: {
+    cwd: string;
+    encoding: string;
+}) => Promise<{
+    /**
+     * - 执行状态
+     */
+    status: 'ok' | 'failed';
+    /**
+     * - 错误信息
+     */
+    error: Error | null;
+    stdout: string | '';
+    stderr: string | '';
+}>;
+export default exec;

package/lib/utils/exec.js

@@ -0,0 +1,36 @@
+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.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 执行 ffmpeg 命令
+ */
+export default function ffmpeg(): Promise<false | ((cmd: string, log?: boolean, options?: {
+    cwd: string;
+    encoding: string;
+}) => Promise<{
+    status: "failed" | "ok";
+    error: Error | null;
+    stdout: string;
+    stderr: string;
+}>)>;

package/lib/utils/ffmpeg.js

@@ -0,0 +1,25 @@
+import exec from './exec.js'
+import logger from './logger.js'
+import Config from './config.js'
+/**
+ * 执行 ffmpeg 命令
+ */
+export default 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.d.ts

@@ -0,0 +1,76 @@
+import Plugin from '../core/plugin.js';
+import { dirName, fileName } from '../types/plugin.js';
+/**
+ * 事件处理器类
+ */
+declare const _default: {
+    events: {
+        [key: string]: {
+            /**
+             * - 文件信息
+             */
+            file: {
+                /**
+                 * - 插件包名称
+                 */
+                dir: dirName;
+                /**
+                 * - 文件名称
+                 */
+                name: fileName;
+            };
+            /**
+             * - 事件class
+             */
+            App: new () => Plugin;
+            /**
+             * - 事件键
+             */
+            key: string;
+            /**
+             * - 事件处理函数名称
+             */
+            fnc: string;
+            /**
+             * - 优先级
+             */
+            priority: number;
+        }[];
+    };
+    /**
+     * 添加事件处理器
+     * @param {Object} config 配置对象
+     * @param {string} config.name 处理器名称
+     * @param {string} config.dir 处理器所在目录
+     * @param {Function} config.App 应用构造函数
+     * @param {Object} config.Class 类配置
+     */
+    add({ name, dir, App, Class }: {
+        dir: dirName;
+        name: fileName;
+        App: new () => Plugin;
+        Class: Plugin;
+    }): void;
+    /**
+     * 删除事件处理器
+     */
+    del({ dir, name, key, }: {
+        dir: dirName | '';
+        name: fileName | '';
+        /**
+         * 事件键 未传入则删除所有处理器
+         */
+        key: string | '';
+    }): boolean;
+    /**
+     * 调用事件处理器
+     * @param key 事件键
+     * @param args 自定义参数 一般用来传递e之类的
+     */
+    call(key: string, args?: {}): Promise<any>;
+    /**
+     * 检查是否存在指定键的事件处理器
+     */
+    has(key: string): boolean;
+};
+export default _default;

package/lib/utils/handler.js

@@ -0,0 +1,102 @@
+import util from 'util'
+import lodash from 'lodash'
+import logger from './logger.js'
+/**
+ * 事件处理器类
+ */
+export default new (class EventHandler {
+  events
+  constructor () {
+    this.events = {}
+  }
+
+  /**
+     * 添加事件处理器
+     * @param {Object} config 配置对象
+     * @param {string} config.name 处理器名称
+     * @param {string} config.dir 处理器所在目录
+     * @param {Function} config.App 应用构造函数
+     * @param {Object} config.Class 类配置
+     */
+  add ({ name, dir, App, Class }) {
+    for (const cfg of Class.handler) {
+      const { key = '', fnc = '', priority = 2000 } = cfg
+      if (!key) {
+        return logger.error(`[Handler][Add]: [${name}] 缺少 key`)
+      }
+      if (!fnc) {
+        return logger.error(`[Handler][Add]: [${name}] 缺少 fnc`)
+      }
+      logger.debug(`[Handler][Reg]: [${name}][${key}]`)
+      if (!Array.isArray(this.events[key])) { this.events[key] = [] }
+      this.events[key].push({ file: { name, dir }, App, key, fnc, priority })
+      this.events[key] = lodash.orderBy(this.events[key], ['priority'], ['asc'])
+    }
+  }
+
+  /**
+     * 删除事件处理器
+     */
+  del ({ dir = '', name = '', key = '' }) {
+    /** 这里是删除所有 全部重新初始化 */
+    if (!key && !dir && !name) {
+      this.events = {}
+      return true
+    }
+    /** 热重载 删除指定目录 */
+    if (!key) {
+      for (const v of Object.keys(this.events)) {
+        this.events[v] = this.events[v].filter(v => v.file.dir !== dir || v.file.name !== name)
+        // 如果处理器为空则删除键
+        if (!this.events[v].length) {
+          delete this.events[v]
+        } else {
+          this.events[v] = lodash.orderBy(this.events[v], ['priority'], ['asc'])
+        }
+      }
+      return true
+    }
+    if (!this.events[key]) { return false }
+    this.events[key] = this.events[key].filter(v => v.file.dir !== dir || v.file.name !== name)
+    this.events[key] = lodash.orderBy(this.events[key], ['priority'], ['asc'])
+    return true
+  }
+
+  /**
+     * 调用事件处理器
+     * @param key 事件键
+     * @param args 自定义参数 一般用来传递e之类的
+     */
+  async call (key, args = {}) {
+    let ret
+    for (const v of this.events[key] || []) {
+      const App = new v.App()
+      if ('e' in args && args.e) { App.e = args.e }
+      let done = true
+      // 标记函数，用于标记处理器是否执行成功，由处理器自行调用，如果未调用则认为处理器未执行成功
+      const reject = (msg = '') => {
+        if (msg) { logger.mark(`[Handler][Reject]: [${v.file.dir}][${v.file.name}][${key}] ${msg}`) }
+        done = false
+      }
+      try {
+        ret = await App[v.fnc](args, reject)
+        if (util.types.isPromise(ret)) { ret = await ret }
+        if (done) {
+          logger.mark(`[Handler][Done]: [${v.file.dir}][${v.file.name}][${key}]`)
+          return ret
+        }
+      } catch (e) {
+        // 产生错误继续下一个处理器
+        logger.error(`[Handler][Error]: [${v.file.dir}][${v.file.name}][${key}] ${e}`)
+      }
+    }
+    return ret
+  }
+
+  /**
+     * 检查是否存在指定键的事件处理器
+     */
+  has (key) {
+    return !!this.events[key]
+  }
+})()

package/lib/utils/logger.d.ts

@@ -0,0 +1,3 @@
+import log4js from 'log4js';
+declare const logger: log4js.Logger;
+export default logger;

package/lib/utils/logger.js

@@ -0,0 +1,104 @@
+import fs from 'fs'
+import chalk from 'chalk'
+import log4js from 'log4js'
+import Cfg from './config.js'
+const logsDir = './logs'
+if (!fs.existsSync(logsDir)) { fs.mkdirSync(logsDir) }
+const { log_level, log_days_Keep, log4jsCfg } = Cfg.Config
+const level = log_level || log4jsCfg.level || 'info'
+const daysToKeep = log_days_Keep || log4jsCfg.daysToKeep || 7
+const { overall, fragments, maxLogSize } = log4jsCfg
+const defaultOptions = { appenders: ['console'], level, enableCallStack: process.env.KarinMode === 'dev' }
+const options = {
+  appenders: {
+    console: {
+      type: 'console',
+      layout: {
+        type: 'pattern',
+        pattern: `%[[Karin][%d{hh:mm:ss.SSS}][%4.4p]%] ${process.env.KarinMode === 'dev' ? '[%f{3}:%l] ' : ''}%m`,
+      },
+    },
+  },
+  categories: { default: defaultOptions },
+}
+if (overall) {
+  defaultOptions.appenders.unshift('overall')
+  options.appenders.overall = {
+    /** 输出到文件 */
+    type: 'file',
+    filename: 'logs/logger',
+    pattern: 'yyyy-MM-dd.log',
+    /** 日期后缀 */
+    keepFileExt: true,
+    /** 日志文件名中包含日期模式 */
+    alwaysIncludePattern: true,
+    /** 日志文件保留天数 */
+    daysToKeep,
+    /** 日志输出格式 */
+    layout: {
+      type: 'pattern',
+      pattern: '[%d{hh:mm:ss.SSS}][%4.4p] %m',
+    },
+  }
+}
+if (fragments) {
+  defaultOptions.appenders.unshift('fragments')
+  options.appenders.fragments = {
+    type: 'file',
+    filename: 'logs/app.log',
+    pattern: 'MM-dd.log',
+    keepFileExt: true,
+    alwaysIncludePattern: true,
+    daysToKeep,
+    maxLogSize: (maxLogSize || 30) * 1024 * 1024,
+    /** 最大文件数 */
+    numBackups: 9999999,
+    /** 日志输出格式 */
+    layout: {
+      type: 'pattern',
+      pattern: '[%d{hh:mm:ss.SSS}][%4.4p] %m',
+    },
+  }
+}
+log4js.configure(options)
+const logger = log4js.getLogger('default')
+logger.chalk = chalk
+logger.red = chalk.red
+logger.green = chalk.green
+logger.yellow = chalk.yellow
+logger.blue = chalk.blue
+logger.magenta = chalk.magenta
+logger.cyan = chalk.cyan
+logger.white = chalk.white
+logger.gray = chalk.gray
+logger.violet = chalk.hex('#868ECC')
+logger.fnc = chalk.hex(Cfg.Config.log_color || '#FFFF00')
+logger.bot = (level, id, ...args) => {
+  switch (level) {
+    case 'trace':
+      logger.trace(logger.violet(`[Bot:${id}] `), ...args)
+      break
+    case 'debug':
+      logger.debug(logger.violet(`[Bot:${id}] `), ...args)
+      break
+    case 'mark':
+      logger.mark(logger.violet(`[Bot:${id}] `), ...args)
+      break
+    case 'info':
+      logger.info(logger.violet(`[Bot:${id}] `), ...args)
+      break
+    case 'warn':
+      logger.warn(logger.violet(`[Bot:${id}] `), ...args)
+      break
+    case 'error':
+      logger.error(logger.violet(`[Bot:${id}] `), ...args)
+      break
+    case 'fatal':
+      logger.fatal(logger.violet(`[Bot:${id}] `), ...args)
+      break
+    default:
+      logger.info(logger.violet(`[Bot:${id}] `), ...args)
+  }
+}
+global.logger = logger
+export default logger