node-karin 0.10.7 → 0.11.1

package/lib/core/plugin/loader.js

@@ -4,52 +4,18 @@ import lodash from 'lodash';
 import chokidar from 'chokidar';
 import schedule from 'node-schedule';
 import { listener } from '../listener/listener.js';
-import PluginApp from './app.js';
 import { render } from '../../render/index.js';
-import { common, handler, logger } from '../../utils/index.js';
+import { common, logger } from '../../utils/index.js';
 class PluginLoader {
     dir;
-    dirPath;
     /**
      * - 插件索引ID
      */
     index;
-    /**
-     * - 命令插件索引列表
-     */
-    ruleIds;
-    /**
-     * - 按钮插件索引列表
-     */
-    buttonIds;
-    /**
-     * - accept插件索引列表
-     */
-    acceptIds;
-    /**
-     * - handler
-     */
-    handlerIds;
-    /**
-     * - 插件列表
-     */
-    FileList;
-    /**
-     * - 是否ts环境
-     */
-    isTs;
-    /**
-     * - 是否开发环境
-     */
-    isDev;
-    /**
-     * - 最终缓存的插件列表 通过index索引
-     */
-    PluginList;
     /**
      * - 定时任务
      */
-    task;
+    // task: Array<PluginTask & { App: NewMessagePlugin, schedule?: schedule.Job, file: { dir: dirName, name: fileName } }>
     /**
      * - 监听器
      */
@@ -58,267 +24,362 @@ class PluginLoader {
      * - 热更新列表
      */
     watchList;
-    /**
-     * - 所有插件包package.json
-     */
-    pkgJson;
     /**
      * - 依赖缺失收集
      */
     dependErr;
+    /** accept */
+    accept;
+    /** button */
+    button;
+    /** command规则集信息 */
+    command;
+    /** handler */
+    handler;
+    /** plugin基本信息 */
+    plugin;
+    /** task定时任务信息 */
+    task;
+    /** 中间件 */
+    use;
+    /** 加载的文件数组 .js .ts */
+    ext;
     constructor() {
+        this.accept = [];
+        this.button = [];
+        this.command = [];
+        this.handler = {};
+        this.plugin = {};
+        this.task = [];
+        this.use = {
+            recvMsg: [],
+            replyMsg: [],
+            sendMsg: [],
+        };
+        this.ext = process.env.karin_app_lang === 'ts' ? ['.js', '.ts'] : ['.js'];
         this.index = 0;
         this.dir = './plugins';
-        this.dirPath = common.urlToPath(import.meta.url);
-        this.isTs = process.env.karin_app_lang === 'ts';
-        this.isDev = process.env.karin_app_mode === 'dev';
         this.watcher = new Map();
         this.watchList = [];
-        this.FileList = [];
-        this.PluginList = {};
-        this.task = [];
-        this.ruleIds = [];
-        this.acceptIds = [];
-        this.buttonIds = [];
-        this.handlerIds = {};
-        this.pkgJson = {};
         this.dependErr = {};
     }
     /**
      * 插件初始化
      */
     async load() {
-        await this.getPlugins();
         listener.once('plugin.watch', () => {
-            for (const v of this.watchList) {
-                v.name ? this.watch(v.dir, v.name) : this.watchDir(v.dir);
-                logger.debug(`[热更新][${v.dir}]${v.name ? `[${v.name}]` : ''} 监听中...`);
-            }
+            this.watchList.forEach(async ({ plugin, path }) => {
+                await this.watchDir(plugin, path);
+                logger.debug(`[热更新][${plugin}][${path}] 监听中...`);
+            });
+            this.watchList = [];
         });
         logger.info(logger.green('-----------'));
-        logger.info('加载插件中..');
-        /** 载入插件 */
-        const promises = this.FileList.map(async ({ dir, name }) => await this.createdApp(dir, name, false));
-        /** 获取npm插件 */
-        const npm = await common.getNpmPlugins(true);
-        /** 载入npm插件 */
-        promises.push(...npm.map(async ({ dir, name, isMain }) => await this.createdApp(dir, name, false, true, isMain)));
-        /** 等待所有插件加载完成 */
-        await Promise.all(promises);
+        logger.info('加载插件中...');
+        const list = [];
+        list.push(...await this.getGitPlugin());
+        list.push(...await this.getNpmPlugin());
+        await Promise.all(list);
         /** 打印依赖缺失 */
         this.printDependErr();
-        /** 释放缓存 */
-        this.FileList = [];
         /** 优先级排序并打印插件信息 */
         this.orderBy(true);
         listener.emit('plugin.watch');
         return this;
     }
     /**
-     * 获取所有插件
+     * 获取Git插件
      */
-    async getPlugins() {
+    async getGitPlugin() {
         /** 获取所有插件包 */
         const plugins = common.getPlugins();
+        const list = [];
         for (const dir of plugins) {
-            /**
-             * - 插件包路径
-             * - 例如: ./plugins/karin-plugin-example
-             */
-            const PluginPath = `${this.dir}/${dir}`;
-            /**
-             * 一共3种模式
-             * 1. npm run dev 开发模式  直接加载ts，js文件，对于同时存在编译产物、源代码的情况，优先加载编译产物而不加载源代码
-             * 2. node . 生产模式  只加载js文件
-             * 3. npm run debug 调试模式 利用tsx自身的热更新机制，重启karin
-             */
+            /** 插件包路径 例如: ./plugins/karin-plugin-example */
+            const root = `${this.dir}/${dir}`;
             /** 非插件包 加载该文件夹下全部js 视语言环境加载ts */
-            if (!common.isPlugin(PluginPath)) {
-                this.getApps(dir, this.isTs, true);
+            if (!common.isPlugin(root)) {
+                /** 热更新 */
+                this.watchList.push({ plugin: dir, path: '' });
+                list.push(...this.loadApps(dir, '', `${"js" /* AppsType.Js */}`));
                 continue;
             }
             /** package */
-            const pkg = common.readJson(`${PluginPath}/package.json`);
-            /** 缓存package.json */
-            this.pkgJson[dir] = pkg;
-            /** 入口文件 */
-            if (pkg.main) {
-                const { dir: dirName, pop } = common.splitPath(pkg.main);
-                const dirPath = `${dir}/${dirName}`;
-                if (common.exists(`${this.dir}/${dirPath}/${pop}`)) {
-                    this.FileList.push({ dir: dirPath, name: pop });
-                    this.isDev && this.watchList.push({ dir: dirPath, name: pop });
-                }
-                else {
-                    logger.debug(`[插件收集][${pkg.main}] 入口文件不存在，已忽略`);
-                }
-            }
-            else {
-                /** 没有配置入口默认为index.js */
-                if (common.exists(`${PluginPath}/index.js`)) {
-                    this.FileList.push({ dir, name: 'index.js' });
-                    this.isDev && this.watchList.push({ dir, name: 'index.js' });
-                }
-            }
-            /** 全部apps路径 */
-            const apps = ['apps'];
-            if (pkg?.karin?.apps && Array.isArray(pkg.karin.apps))
-                apps.push(...pkg.karin.apps);
-            /** js环境 或 ts环境、js插件 */
-            if (!this.isTs || !common.exists(`${PluginPath}/tsconfig.json`)) {
-                apps.forEach((apps) => {
-                    /** 路径存在才加载 */
-                    if (common.isDir(`${PluginPath}/${apps}`)) {
-                        this.getApps((`${dir}/${apps}`), false, this.isDev);
+            const pkg = common.readJson(`${root}/package.json`);
+            this.loadMain(root, pkg.main, false);
+            /**
+             * 插件加载优先级:
+             * 1. ts环境: 按照 编译产物 > TS源代码 举例: 优先级高的不存在才会加载下一个。
+             * 2. js环境: 按照 pkg.apps 进行加载。 当前版本兼容apps，apps处于根目录并且没有在pkg.apps中填写会自动加载，后续废弃。
+             *
+             * 注: ts编译产物的路径也是根据pkg.apps进行加载的。
+             *
+             * 开发环境说明:
+             * 1. ts环境默认为开发模式
+             * 2. 在开发环境下 会对所有 `.js`，`.ts` 文件进行热更新 只需要点下保存即可。
+             * 3. 监察者模式当前暂未适配 待后续适配。
+             */
+            /** ts环境 */
+            if (process.env.karin_app_lang === 'ts') {
+                /** 加载ts入口 */
+                if (pkg?.karin?.main)
+                    this.loadMain(root, pkg.karin.main, false);
+                /** 获取apps */
+                const apps = pkg?.karin?.apps && Array.isArray(pkg.karin.apps) ? pkg.karin.apps : [];
+                /** apps为空则跳过 */
+                if (!apps.length)
+                    continue;
+                const { outDir, rootDir } = await this.getTsMain(root, pkg);
+                /** 先瞅瞅编译产物根目录是否存在 */
+                if (common.exists(path.join(root, outDir))) {
+                    for (const file of apps) {
+                        const rootApps = path.join(root, outDir, file);
+                        if (!common.exists(rootApps)) {
+                            logger.debug(`[插件收集][${rootApps}] 路径不存在，已忽略`);
+                            continue;
+                        }
+                        const _path = path.join(outDir, file);
+                        /** 热更新 */
+                        this.watchList.push({ plugin: dir, path: _path });
+                        list.push(...this.loadApps(dir, _path, `${"git" /* AppsType.Git */}`));
                     }
-                    else {
-                        logger.debug(`[插件收集][${dir}/${apps}] 路径不存在，已忽略`);
+                    continue;
+                }
+                /** 源码根目录 */
+                if (common.exists(path.join(root, rootDir))) {
+                    for (const file of apps) {
+                        const rootApps = path.join(root, rootDir, file);
+                        if (!common.exists(rootApps)) {
+                            logger.debug(`[插件收集][${rootApps}] 路径不存在，已忽略`);
+                            continue;
+                        }
+                        const _path = path.join(rootDir, file);
+                        /** 热更新 */
+                        this.watchList.push({ plugin: dir, path: _path });
+                        list.push(...this.loadApps(dir, _path, `${"git" /* AppsType.Git */}`));
                     }
-                });
-                continue;
-            }
-            /** ts环境 ts插件 */
-            const outDir = pkg?.karin?.outDir || 'lib';
-            const rootDir = pkg?.karin?.rootDir || 'src';
-            /** 编译产物存在 */
-            if (common.exists(`${PluginPath}/${outDir}/apps`)) {
-                this.getApps((`${dir}/${outDir}/apps`), true, this.isDev);
+                    continue;
+                }
+                /** 走到这说明有问题 打印错误信息 */
+                logger.error(`[插件收集][${dir}] 加载错误，未检测到任何文件，请检查配置是否正确`);
                 continue;
             }
-            else {
-                /** 入口文件 */
-                if (common.exists(`${PluginPath}/${rootDir}/index.ts`)) {
-                    const dirPath = `${dir}/${rootDir}`;
-                    this.FileList.push({ dir: dirPath, name: 'index.ts' });
-                    this.isDev && this.watchList.push({ dir: dirPath, name: 'index.ts' });
+            /** 全部apps路径 */
+            const apps = pkg?.karin?.apps && Array.isArray(pkg.karin.apps) ? pkg.karin.apps : [];
+            /** 暂时兼容旧版本 加入apps 计划在正式版本发布之前废弃 */
+            if (!apps.includes('apps'))
+                apps.push('apps');
+            for (const file of apps) {
+                const rootApps = path.join(root, file);
+                if (!common.exists(rootApps)) {
+                    logger.debug(`[插件收集][${rootApps}] 路径不存在，已忽略`);
                     continue;
                 }
-                /** ts源码 */
-                if (common.exists(`${PluginPath}/${rootDir}/apps`)) {
-                    this.getApps((`${dir}/${rootDir}/apps`), true, this.isDev);
-                    continue;
+                const dev = process.env.karin_app_mode === 'dev';
+                if (dev) {
+                    /** 热更新 */
+                    this.watchList.push({ plugin: dir, path: file });
                 }
+                list.push(...this.loadApps(dir, file, `${"git" /* AppsType.Git */}`));
+            }
+        }
+        return list;
+    }
+    /**
+     * 获取Npm插件
+     */
+    async getNpmPlugin() {
+        const list = [];
+        const info = await common.getNpmPlugins(true);
+        for (const { plugin, path: _path, file, isMain } of info) {
+            if (!isMain) {
+                const root = path.join(process.cwd(), 'node_modules', plugin, _path);
+                this.loadMain(root, file, true);
+                continue;
+            }
+            list.push(this.createdApp(plugin, _path, file, `${"npm" /* AppsType.Npm */}`));
+        }
+        return list;
+    }
+    /**
+     * 加载入口文件 只加载
+     * @param root - 插件根目录
+     * @param main - 入口文件
+     * @param isNpm - 是否为npm插件
+     */
+    async loadMain(root, main, isNpm) {
+        const _path = path.resolve(root, main || '');
+        if (!common.exists(_path) || !main) {
+            if (isNpm)
+                return false;
+            const defRoot = path.resolve(root, 'index.js');
+            if (common.exists(defRoot)) {
+                await import(`file://${defRoot}`);
+                return true;
             }
+            logger.debug(`[插件收集][${main}] 入口文件不存在，已忽略`);
+            return false;
+        }
+        await import(`file://${_path}`);
+        return true;
+    }
+    /**
+     * 获取ts插件入口 编译入口路径
+     * @param root - 插件根目录
+     * @param pkg - package.json
+     */
+    async getTsMain(root, pkg) {
+        let outDir = 'dist';
+        let rootDir = 'src';
+        /** 先尝试解析tsconfig.json来进行读取 */
+        try {
+            const tsconfig = common.readJson(`${root}/tsconfig.json`);
+            if (tsconfig?.compilerOptions?.outDir)
+                outDir = tsconfig.compilerOptions.outDir;
+            if (tsconfig?.compilerOptions?.rootDir)
+                rootDir = tsconfig.compilerOptions.rootDir;
+        }
+        catch (error) {
+            logger.error(`[插件收集][${root}] tsconfig.json解析错误，请检查格式`);
+            logger.error(error);
+            /** 如果报错 则读取pkg的 */
+            if (pkg?.karin?.outDir)
+                outDir = pkg.karin.outDir;
+            if (pkg?.karin?.rootDir)
+                rootDir = pkg.karin.rootDir;
         }
-        return plugins;
+        return { outDir, rootDir };
     }
     /**
-     * 获取指定文件夹下的所有插件
-     * @param dir - 插件包名称
-     * @param isTs - 是否获取ts插件
+     * 加载指定文件夹下的所有插件
+     * @param plugin - 插件名称
+     * @param _path - 插件apps相对路径
+     * @param file - 插件文件名称
+     * @param isNpm - 是否为npm插件
+     * @param isWatch - 是否监听热更新
      */
-    getApps(dir, isTs, isWatch = false) {
-        isWatch && this.watchList.push({ dir });
-        const ext = isTs ? ['.js', '.ts'] : ['.js'];
-        const list = fs.readdirSync(`${this.dir}/${dir}`, { withFileTypes: true });
-        for (const file of list) {
+    loadApps(plugin, _path, type) {
+        const list = [];
+        const root = type === 'npm' ? path.join(process.cwd(), 'node_modules', plugin, _path) : path.join(this.dir, plugin, _path);
+        const files = fs.readdirSync(root, { withFileTypes: true });
+        for (const file of files) {
             const extname = path.extname(file.name);
-            if (!ext.includes(extname))
+            if (!this.ext.includes(extname))
                 continue;
-            this.FileList.push({ dir, name: file.name });
+            list.push(this.createdApp(plugin, _path, file.name, type));
         }
+        return list;
     }
     /**
      * 排序并打印插件信息
      * @param isPrint - 是否打印
      */
     orderBy(isPrint = false) {
-        let taskCount = 0;
         let handlerCount = 0;
-        const rule = [];
-        const button = [];
-        const accept = [];
-        Object.keys(this.PluginList).forEach(key => {
-            taskCount += this.PluginList[key].task.length;
-            if (this.PluginList[key].rule.length)
-                rule.push({ key, val: this.PluginList[key].priority });
-            if (this.PluginList[key].button.length)
-                button.push({ key, val: this.PluginList[key].priority });
-            if (this.PluginList[key].accept)
-                accept.push({ key, val: this.PluginList[key].priority });
+        this.accept = lodash.orderBy(this.accept, ['rank'], ['asc']);
+        this.button = lodash.orderBy(this.button, ['rank'], ['asc']);
+        this.command = lodash.orderBy(this.command, ['rank'], ['asc']);
+        this.task = lodash.orderBy(this.task, ['rank'], ['asc']);
+        this.use.recvMsg = lodash.orderBy(this.use.recvMsg, ['rank'], ['asc']);
+        this.use.replyMsg = lodash.orderBy(this.use.replyMsg, ['rank'], ['asc']);
+        this.use.sendMsg = lodash.orderBy(this.use.sendMsg, ['rank'], ['asc']);
+        const handler = Object.keys(this.handler);
+        handler.forEach(key => {
+            this.handler[key] = lodash.orderBy(this.handler[key], ['rank'], ['asc']);
+            handlerCount += this.handler[key].length;
         });
-        this.ruleIds = lodash.orderBy(rule, ['val'], ['asc']).map((v) => Number(v.key));
-        logger.debug('rule排序完成...');
-        this.buttonIds = lodash.orderBy(button, ['val'], ['asc']).map((v) => Number(v.key));
-        logger.debug('button排序完成...');
-        this.acceptIds = lodash.orderBy(accept, ['val'], ['asc']).map((v) => Number(v.key));
         if (!isPrint)
             return;
-        const PluginListKeys = Object.keys(this.PluginList);
-        const handlerKeys = Object.keys(this.handlerIds);
-        handlerKeys.forEach((key) => {
-            handlerCount += this.handlerIds[key].length;
-        });
-        logger.info(`[插件][${PluginListKeys.length}个] 加载完成`);
+        logger.info(`[插件][${Object.keys(this.plugin).length}个] 加载完成`);
         logger.info(`[渲染器][${render.Apps.length}个] 加载完成`);
-        logger.info(`[rule][${this.ruleIds.length}个] 加载完成`);
-        logger.info(`[button][${this.buttonIds.length}个] 加载完成`);
-        logger.info(`[accept][${this.acceptIds.length}个] 加载完成`);
-        logger.info(`[定时任务][${taskCount}个] 加载完成`);
-        logger.info(`[Handler][Key:${handlerKeys.length}个][fnc:${handlerCount}个] 加载完成`);
+        logger.info(`[command][${this.command.length}个] 加载完成`);
+        logger.info(`[button][${this.button.length}个] 加载完成`);
+        logger.info(`[accept][${this.accept.length}个] 加载完成`);
+        logger.info(`[定时任务][${this.task.length}个] 加载完成`);
+        logger.info(`[Handler][Key:${handler.length}个][fnc:${handlerCount}个] 加载完成`);
         logger.info(logger.green('-----------'));
         logger.info(`Karin启动完成：耗时 ${logger.green(process.uptime().toFixed(2))} 秒...`);
     }
     /**
      * 新增插件
-     * @param dir - 插件包路径
-     * @param name - 插件名称
-     * @param isOrderBy - 是否为动态导入 默认为静态导入
-     * @param isNpm - 是否为npm包
-     * @param isMain - 是否为主入口文件
+     * @param plugin - 插件名称 例如: karin-plugin-example
+     * @param _path - 插件路径 例如: lib/apps 不存在则传空字符串
+     * @param file - 插件文件 例如: index.js ts目前解释器支持不够，暂不支持ts
+     * @param type - 插件类型 默认为git
+     * @param isOrderBy - 是否排序 开启会使用动态导入
      */
-    async createdApp(dir, name, isOrderBy = false, isNpm = false, isMain = false) {
+    async createdApp(plugin, _path, file, type = 'git', isOrderBy = false) {
         try {
+            const index = ++this.index;
+            /** 缓存基本信息 */
+            this.plugin[index] = { type, plugin, path: _path, file };
             const list = [];
-            let path = `${this.dirPath}${isNpm ? 'node_modules' : 'plugins'}/${dir}/${name}`;
+            let rootPath = 'file://' + path.join(process.cwd(), type === 'npm' ? 'node_modules' : 'plugins', plugin, _path, file);
             if (isOrderBy)
-                path = path + `?${Date.now()}`;
-            const tmp = await import(path);
-            /** npm包的入口文件不作为app载入 只加载 */
-            if (isMain)
-                return true;
-            lodash.forEach(tmp, (App) => {
+                rootPath = rootPath + `?${Date.now()}`;
+            const tmp = await import(rootPath);
+            lodash.forEach(tmp, (Fn) => {
                 const index = this.index;
                 this.index++;
-                if (typeof App === 'object' && App?.file?.type === 'function') {
-                    if (!App?.name) {
-                        logger.error(`[${dir}][${name}] 插件名称错误`);
-                        return false;
-                    }
-                    App.file.dir = dir;
-                    App.file.name = name;
-                    App.rule.forEach((v, index) => {
-                        App.rule[index].log = v.log === false ? (id, log) => logger.bot('debug', id, log) : (id, log) => logger.bot('mark', id, log);
-                    });
-                    /** handler */
-                    App.task = this.addTaskFnc(dir, App);
-                    this.PluginList[index] = App;
-                    handler.add(index + '', App);
-                    if (App.accept)
-                        this.acceptIds.push(index);
+                /** 函数语法糖 */
+                if (typeof Fn === 'object' && Fn?.type) {
+                    logger.debug(`载入插件 [${plugin}]${_path ? `${common.getRelPath(_path)}` : ''}[${file}][${Fn.name}]`);
+                    list.push(this.cachePlugin(index, plugin, file, Fn));
                     return true;
                 }
-                if (typeof App !== 'function' || !App?.prototype?.constructor)
+                if (typeof Fn !== 'function' || !Fn?.prototype?.constructor)
                     return false;
-                const Class = new App();
+                const Class = new Fn();
                 if (!Class.name) {
-                    logger.error(`[${dir}][${name}] 插件名称错误`);
+                    logger.error(`[${plugin}]${_path ? `${common.getRelPath(_path)}` : ''}[${file}] 插件名称错误`);
                     return false;
                 }
-                logger.debug(`载入插件 [${name}][${Class.name}]`);
-                this.PluginList[index] = PluginApp({
-                    file: { dir, name, type: 'class', fnc: App },
-                    name: Class.name,
-                    event: Class.event,
-                    priority: Class.priority,
-                    accept: false,
+                logger.debug(`载入插件 [${plugin}]${_path ? `${common.getRelPath(_path)}` : ''}[${file}][${Class.name}]`);
+                if (Class.rule.length) {
+                    for (const val of Class.rule) {
+                        list.push(() => {
+                            const log = val.log === false
+                                ? (id, log) => logger.debug('mark', id, log)
+                                : (id, log) => logger.bot('mark', id, log);
+                            const fn = typeof val.fnc === 'function' ? val.fnc : Class[val.fnc];
+                            return this.cachePlugin(index, plugin, file, {
+                                name: Class.name,
+                                type: 'command',
+                                fn,
+                                fnname: typeof val.fnc === 'function' ? val.fnc.name || 'fnc' : val.fnc,
+                                data: Fn,
+                                event: val.event || Class.event || 'message',
+                                log,
+                                perm: val.permission || "all" /* Permission.All */,
+                                rank: val.priority || Class.priority || 10000,
+                                reg: val.reg instanceof RegExp ? val.reg : new RegExp(val.reg),
+                            }, Fn);
+                        });
+                    }
+                }
+                if (Class.task.length) {
+                    for (const val of Class.task) {
+                        list.push(() => {
+                            if (!val.name)
+                                throw TypeError(`[${plugin}][${file}] 定时任务name错误`);
+                            if (!val.cron)
+                                throw TypeError(`[${plugin}][${file}] 定时任务cron错误：${Class.name}`);
+                            const log = val.log === false ? (log) => logger.debug(log) : (log) => logger.mark(log);
+                            return this.cachePlugin(index, plugin, file, {
+                                name: Class.name,
+                                fnname: val.name,
+                                type: 'task',
+                                fn: typeof val.fnc === 'function' ? val.fnc : Class[val.fnc],
+                                log,
+                                cron: val.cron,
+                            }, Fn);
+                        });
+                    }
+                }
+                /** init */
+                list.push(async () => {
+                    'init' in Class && typeof Class.init === 'function' && await Class.init();
                 });
-                /** 异步收集 加载速度 */
-                list.push(this.addRule(dir, name, index, Class));
-                list.push(this.addTask(dir, name, index, Class, App));
-                list.push(this.addAccept(index, Class));
-                list.push(this.addButton(dir, name, index, Class));
-                list.push(this.addInit(Class));
                 return true;
             });
             await Promise.all(list);
@@ -329,22 +390,121 @@ class PluginLoader {
         }
         catch (error) {
             if (/Cannot find package '(.+?)'/.exec(error)?.[1]) {
-                const key = `${dir}.${name}`;
+                const key = `${plugin}.${_path}.${file}`;
                 if (this.dependErr[key])
                     return false;
                 this.dependErr[key] = {
-                    dir,
-                    name,
+                    plugin,
+                    path: _path,
+                    file,
                     depend: /Cannot find package '(.+?)'/.exec(error)?.[1] || '',
                 };
             }
             else {
-                logger.error(`载入插件错误：${logger.red(`${dir}/${name}`)}`);
+                logger.error(`载入插件错误：${logger.red(`${plugin}/${_path}/${file}`)}`);
                 logger.error(error);
             }
             return false;
         }
     }
+    /**
+     * 缓存插件
+     * @param index - 插件索引
+     */
+    async cachePlugin(index, plugin, file, info, App) {
+        if (!info?.name) {
+            logger.error(`[${plugin}][${file}][${info.name}] 插件名称错误`);
+            return false;
+        }
+        switch (info.type) {
+            case 'accept': {
+                this.accept.push({
+                    name: info.name,
+                    event: info.event,
+                    fn: info.fn,
+                    key: index + '',
+                    log: info.log,
+                    rank: info.rank,
+                });
+                return true;
+            }
+            case 'button': {
+                this.button.push({
+                    name: info.name,
+                    reg: info.reg,
+                    fn: info.fn,
+                    key: index + '',
+                    rank: info.rank,
+                });
+                return true;
+            }
+            case 'handler': {
+                if (!this.handler[info.key])
+                    this.handler[info.key] = [];
+                this.handler[info.key].push({
+                    name: info.name,
+                    fn: info.fn,
+                    key: index + '',
+                    rank: info.rank,
+                });
+                return true;
+            }
+            case 'command': {
+                this.command.push({
+                    name: info.name,
+                    data: App,
+                    event: info.event,
+                    fn: info.fn,
+                    fnname: info.fnname,
+                    key: index + '',
+                    log: info.log,
+                    perm: info.perm,
+                    rank: info.rank,
+                    reg: info.reg,
+                    type: 'function',
+                });
+                return true;
+            }
+            case 'task': {
+                this.task.push({
+                    name: info.name,
+                    cron: info.cron,
+                    fn: info.fn,
+                    key: index + '',
+                    taskname: info.fnname,
+                    data: App,
+                    log: info.log,
+                    schedule: schedule.scheduleJob(info.cron, async () => {
+                        try {
+                            info.log(`[定时任务][${plugin}][${info.fnname}] 开始执行`);
+                            if (App) {
+                                const app = new App();
+                                await info.fn.call(app);
+                            }
+                            else {
+                                await info.fn();
+                            }
+                            info.log(`[定时任务][${plugin}][${info.fnname}] 执行完毕`);
+                        }
+                        catch (error) {
+                            logger.error(`[定时任务][${plugin}][${info.fnname}] 执行报错`);
+                            logger.error(error);
+                        }
+                    }),
+                });
+                return true;
+            }
+            case 'use': {
+                this.use[info.key].push({
+                    name: info.name,
+                    fn: info.fn,
+                    key: index + '',
+                    rank: info.rank,
+                });
+                return true;
+            }
+        }
+    }
     /**
      * 打印依赖缺失
      */
@@ -355,8 +515,8 @@ class PluginLoader {
                 return;
             const msg = ['-----依赖缺失----'];
             keys.forEach(key => {
-                const { dir, name, depend } = this.dependErr[key];
-                msg.push(`[${dir}][${name}] 缺少依赖：${logger.red(depend)}`);
+                const { plugin, path, file, depend } = this.dependErr[key];
+                msg.push(`[${plugin}]${path ? `[${path}]` : ''}[${file}] 缺少依赖：${logger.red(depend)}`);
             });
             msg.push('-------------------');
             logger.error(msg.join('\n'));
@@ -367,209 +527,85 @@ class PluginLoader {
         }
     }
     /**
-     * 新增rule
-     */
-    async addRule(dir, name, index, Class) {
-        lodash.forEach(Class.rule, val => {
-            if (!val.fnc)
-                return logger.error(`[${dir}][${name}] rule.fnc错误：${Class.name}`);
-            this.PluginList[index].rule.push({
-                reg: val.reg instanceof RegExp ? val.reg : new RegExp(val.reg),
-                fnc: val.fnc,
-                event: val.event,
-                permission: val.permission || "all" /* Permission.All */,
-                log: val.log === false ? (id, log) => logger.debug('mark', id, log) : (id, log) => logger.bot('mark', id, log),
-            });
-        });
-    }
-    /**
-     * 新增task fnc模式
+     * 卸载插件
      */
-    addTaskFnc(dir, App) {
-        const task = [];
-        lodash.forEach(App.task, val => {
-            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();
-                        typeof val.log === 'function' && val.log(`[定时任务][${dir}][${val.name}] 执行完毕`);
-                    }
-                    catch (error) {
-                        logger.error(`[定时任务][${dir}][${val.name}] 执行报错`);
-                        logger.error(error);
+    uninstallApp(plugin, _path, file) {
+        Object.keys(this.plugin).forEach(key => {
+            const info = this.plugin[key];
+            if (info.plugin === plugin && info.path === _path && info.file === file) {
+                /** 删除缓存 */
+                delete this.plugin[key];
+                this.accept = this.accept.filter(val => val.key !== key);
+                this.button = this.button.filter(val => val.key !== key);
+                this.command = this.command.filter(val => val.key !== key);
+                this.use.recvMsg = this.use.recvMsg.filter(val => val.key !== key);
+                this.use.replyMsg = this.use.replyMsg.filter(val => val.key !== key);
+                this.use.sendMsg = this.use.sendMsg.filter(val => val.key !== key);
+                /** 定时任务需要先停止 */
+                this.task = this.task.filter(val => {
+                    if (val.key === key) {
+                        val.schedule?.cancel();
+                        return false;
                     }
-                }),
-            });
-            return true;
-        });
-        return task;
-    }
-    /**
-     * 新增task
-     */
-    async addTask(dir, name, index, Class, App) {
-        /** 定时任务 */
-        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}`);
-            this.PluginList[index].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]();
+                    return true;
+                });
+                /** 处理handler */
+                Object.keys(this.handler).forEach(keys => {
+                    this.handler[keys].forEach((val, i) => {
+                        if (val.key === key) {
+                            this.handler[keys].splice(i, 1);
+                            if (!this.handler[keys].length)
+                                delete this.handler[keys];
+                            return true;
                         }
-                        typeof val.log === 'function' && val.log(`[定时任务][${dir}][${val.name}] 执行完毕`);
-                    }
-                    catch (error) {
-                        logger.error(`[定时任务][${dir}][${val.name}] 执行报错`);
-                        logger.error(error);
-                    }
-                }),
-            });
-        });
-    }
-    /**
-     * 新增accept、handler
-     */
-    async addAccept(index, Class) {
-        if ('accept' in Class && typeof Class.accept === 'function') {
-            this.PluginList[index].accept = true;
-            this.acceptIds.push(index);
-        }
-        await handler.add(index + '', Class);
-    }
-    /**
-     * 新增button
-     */
-    async addButton(dir, name, index, Class) {
-        lodash.forEach(Class.button, val => {
-            if (!val.fnc)
-                return logger.error(`[${dir}][${name}] button.fnc错误：${Class.name}`);
-            this.PluginList[index].button.push({
-                reg: val.reg instanceof RegExp ? val.reg : new RegExp(val.reg),
-                fnc: val.fnc,
-            });
-        });
-    }
-    /**
-     * 执行初始化
-     */
-    async addInit(Class) {
-        'init' in Class && typeof Class.init === 'function' && await Class.init();
-    }
-    /**
-     * 卸载插件
-     */
-    uninstallApp(dir, name) {
-        const index = [];
-        Object.keys(this.PluginList).forEach(key => {
-            const info = this.PluginList[key];
-            /** 停止定时任务 */
-            info.task.forEach(val => val.schedule?.cancel());
-            if (info.file.dir === dir && info.file.name === name) {
-                index.push(key);
-                delete this.PluginList[key];
+                    });
+                });
             }
         });
-        /** 删除handler */
-        index.forEach(key => handler.del(key));
         /** 重新排序 */
         this.orderBy();
     }
-    /**
-     * 监听单个文件热更新
-     */
-    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);
-            /** 载入插件 */
-            await this.createdApp(dir, name, true);
-            logger.mark(`[修改插件][${dir}][${name}]`);
-        });
-        /** 监听删除 */
-        watcher.on('unlink', async () => {
-            /** 卸载 */
-            this.uninstallApp(dir, name);
-            this.watcher.delete(`${dir}.${name}`);
-            logger.mark(`[卸载插件][${dir}][${name}]`);
-            /** 卸载之后停止监听 */
-            watcher.close();
-        });
-        this.watcher.set(`${dir}.${name}`, watcher);
-    }
     /**
      * 监听文件夹更新
      */
-    async watchDir(dir) {
-        if (this.watcher.get(dir))
-            return;
-        const file = `${this.dir}/${dir}/`;
-        const watcher = chokidar.watch(file);
+    async watchDir(plugin, _path) {
+        const root = path.join(this.dir, plugin, _path);
+        if (this.watcher.get(root))
+            return false;
+        const watcher = chokidar.watch(root);
         await common.sleep(1000);
-        watcher.on('add', async (_path) => {
+        watcher.on('add', async (files) => {
             /** 排除掉不符合规则文件新增 */
-            const ext = this.isTs ? ['.js', '.ts'] : ['.js'];
-            if (!ext.some(ext => _path.endsWith(ext)))
-                return;
-            const name = path.basename(_path);
-            await this.createdApp(dir, name, true);
-            logger.mark(`[新增插件][${dir}][${name}]`);
+            if (!this.ext.some(ext => files.endsWith(ext)))
+                return false;
+            const name = path.basename(files);
+            await this.createdApp(plugin, _path, name, `${"git" /* AppsType.Git */}`, true);
+            logger.mark(`[新增插件][${plugin}]${path ? `${common.getRelPath(_path)}` : ''}[${name}]`);
             return true;
         });
-        watcher.on('change', async (_path) => {
+        watcher.on('change', async (files) => {
             /** 排除掉不符合规则文件新增 */
-            const ext = this.isTs ? ['.js', '.ts'] : ['.js'];
-            if (!ext.some(ext => _path.endsWith(ext)))
-                return;
-            const name = path.basename(_path);
+            if (!this.ext.some(ext => files.endsWith(ext)))
+                return false;
+            const name = path.basename(files);
             /** 卸载 */
-            this.uninstallApp(dir, name);
+            this.uninstallApp(plugin, _path, name);
             /** 载入插件 */
-            await this.createdApp(dir, name, true);
-            logger.mark(`[修改插件][${dir}][${name}]`);
+            await this.createdApp(plugin, _path, name, `${"git" /* AppsType.Git */}`, true);
+            logger.mark(`[修改插件][${plugin}]${path ? `${common.getRelPath(_path)}` : ''}[${name}]`);
             return true;
         });
-        watcher.on('unlink', async (_path) => {
+        watcher.on('unlink', async (files) => {
             /** 排除掉不符合规则文件新增 */
-            const ext = this.isTs ? ['.js', '.ts'] : ['.js'];
-            if (!ext.some(ext => _path.endsWith(ext)))
-                return;
-            const name = path.basename(_path);
+            if (!this.ext.some(ext => files.endsWith(ext)))
+                return false;
+            const name = path.basename(files);
             /** 卸载 */
-            this.uninstallApp(dir, name);
-            logger.mark(`[卸载插件][${dir}][${name}]`);
+            this.uninstallApp(plugin, _path, name);
+            logger.mark(`[卸载插件][${plugin}]${path ? `${common.getRelPath(_path)}` : ''}[${name}]`);
             return true;
         });
-        /** 这里需要检查一下是否已经存在，已经存在就关掉之前的监听 */
-        const isExist = this.watcher.get(dir);
-        if (isExist) {
-            isExist.close();
-            this.watcher.delete(dir);
-        }
-        this.watcher.set(dir, watcher);
+        this.watcher.set(root, watcher);
         return true;
     }
 }