@kotori-bot/loader 1.2.0 → 1.4.0

package/README.md

@@ -0,0 +1,27 @@
+# @kotori-bot/core
+
+```typescript
+interface Context {
+  readonly baseDir: Runner['baseDir'];
+  readonly options: Runner['options'];
+  readonly [Symbols.modules]: Runner[typeof Symbols.modules];
+  loadAll(): void;
+  watcher(): void;
+  logger: Logger;
+  /* Service */
+  server: Server;
+  db: Database;
+  file: File;
+}
+```
+
+- Loader
+- Runner
+- Server
+- Database
+- File
+- log
+
+## Reference
+
+- [Kotori Docs](https://kotori.js.org/)

package/lib/consts.d.ts

@@ -1,4 +1,8 @@
 export declare const DEV_FILE = ".ts";
 export declare const BUILD_FILE = ".js";
-export declare const DEV_IMPORT = "./src/index.ts";
 export declare const DEV_CODE_DIRS = "./src/";
+export declare const DEV_IMPORT = "./src/index.ts";
+export declare const BUILD_CONFIG_NAME = "kotori.yml";
+export declare const DEV_CONFIG_NAME = "kotori.dev.yml";
+export declare const SUPPORTS_VERSION: RegExp;
+export declare const SUPPORTS_HALF_VERSION: RegExp;

package/lib/consts.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEV_CODE_DIRS = exports.DEV_IMPORT = exports.BUILD_FILE = exports.DEV_FILE = void 0;
+exports.SUPPORTS_HALF_VERSION = exports.SUPPORTS_VERSION = exports.DEV_CONFIG_NAME = exports.BUILD_CONFIG_NAME = exports.DEV_IMPORT = exports.DEV_CODE_DIRS = exports.BUILD_FILE = exports.DEV_FILE = void 0;
 exports.DEV_FILE = '.ts';
 exports.BUILD_FILE = '.js';
-exports.DEV_IMPORT = './src/index.ts';
 exports.DEV_CODE_DIRS = './src/';
+exports.DEV_IMPORT = `${exports.DEV_CODE_DIRS}index.ts`;
+exports.BUILD_CONFIG_NAME = 'kotori.yml';
+exports.DEV_CONFIG_NAME = 'kotori.dev.yml';
+exports.SUPPORTS_VERSION = /(1\.1\.0)|(1\.2\.0)/;
+exports.SUPPORTS_HALF_VERSION = /(x\.x\.(.*?))/;

package/lib/index.d.ts

@@ -1,2 +1,3 @@
-import loader from './loader';
-export default loader;
+export * from './loader';
+export * from './consts';
+export * from '@kotori-bot/logger';

package/lib/index.js

@@ -1,14 +1,26 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
 /*
  * @Author: Hotaru biyuehuya@gmail.com
  * @Blog: https://hotaru.icu
  * @Date: 2023-10-29 16:20:51
  * @LastEditors: Hotaru biyuehuya@gmail.com
- * @LastEditTime: 2023-12-30 17:32:51
+ * @LastEditTime: 2024-02-20 20:20:54
  */
-const loader_1 = __importDefault(require("./loader"));
-exports.default = loader_1.default;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./loader"), exports);
+__exportStar(require("./consts"), exports);
+__exportStar(require("@kotori-bot/logger"), exports);

package/lib/loader.d.ts

@@ -1,13 +1,40 @@
-import { ContextInstance } from '@kotori-bot/core';
-declare class Main extends ContextInstance {
+import { Container, Symbols } from '@kotori-bot/core';
+import Logger from '@kotori-bot/logger';
+import Runner from './runner';
+import Server from './service/server';
+import Database from './service/database';
+import File from './service/file';
+declare module '@kotori-bot/core' {
+    interface Context {
+        readonly baseDir: Runner['baseDir'];
+        readonly options: Runner['options'];
+        readonly [Symbols.modules]: Runner[typeof Symbols.modules];
+        loadAll(): void;
+        watcher(): void;
+        logger: Logger;
+        server: Server;
+        db: Database;
+        file: File;
+    }
+    interface GlobalConfig {
+        dirs: string[];
+        port: number;
+    }
+}
+export declare class Loader extends Container {
     private ctx;
-    constructor();
+    private loadCount;
+    constructor(options?: {
+        dir?: string;
+        mode?: string;
+    });
     run(): void;
     private handleError;
     private catchError;
     private listenMessage;
-    private loadAllModule;
+    private setPreService;
+    private loadAllModules;
     private loadAllAdapter;
     private checkUpdate;
 }
-export default Main;
+export default Loader;

package/lib/loader.js

@@ -1,130 +1,262 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loader = void 0;
 /*
  * @Author: hotaru biyuehuya@gmail.com
  * @Blog: https://hotaru.icu
  * @Date: 2023-06-24 15:12:55
  * @LastEditors: Hotaru biyuehuya@gmail.com
- * @LastEditTime: 2023-12-30 19:12:43
+ * @LastEditTime: 2024-02-21 11:35:04
  */
 const core_1 = require("@kotori-bot/core");
-const modules_1 = __importDefault(require("./modules"));
-const global_1 = require("./global");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const logger_1 = __importDefault(require("@kotori-bot/logger"));
+const runner_1 = __importStar(require("./runner"));
 const log_1 = __importDefault(require("./log"));
-const kotoriConfig = () => {
-    let result = {};
-    const baseDir = (0, global_1.getBaseDir)();
-    result = {
-        baseDir,
-        config: (0, global_1.getGlobalConfig)(baseDir),
-        options: {
-            env: (0, global_1.isDev)() ? 'dev' : 'build',
-        },
+const consts_1 = require("./consts");
+const server_1 = __importDefault(require("./service/server"));
+const database_1 = __importDefault(require("./service/database"));
+const file_1 = __importDefault(require("./service/file"));
+function getRunnerConfig(file, dir) {
+    const handle = (root) => {
+        const baseDir = {
+            root,
+            modules: path_1.default.join(root, 'modules'),
+            data: path_1.default.join(root, 'data'),
+            logs: path_1.default.join(root, 'logs')
+        };
+        Object.values(baseDir).forEach((val) => {
+            if (!fs_1.default.existsSync(val))
+                fs_1.default.mkdirSync(val);
+        });
+        return baseDir;
     };
-    return result;
-};
-class Main extends core_1.ContextInstance {
+    const options = {
+        mode: file === consts_1.DEV_CONFIG_NAME ? 'dev' : 'build'
+    };
+    if (dir)
+        return { baseDir: handle(path_1.default.resolve(dir)), options };
+    let root = path_1.default.resolve(__dirname, '..').replace('loader', 'kotori');
+    let count = 0;
+    while (!fs_1.default.existsSync(path_1.default.join(root, file))) {
+        if (count > 5) {
+            logger_1.default.fatal(`cannot find file ${file} `);
+            process.exit();
+        }
+        root = path_1.default.join(root, '..');
+        count += 1;
+    }
+    return { baseDir: handle(root), options };
+}
+/* eslint consistent-return: 0 */
+function getCoreConfig(file, baseDir) {
+    try {
+        const result1 = core_1.Tsu.Object({
+            global: core_1.Tsu.Object({
+                dirs: core_1.Tsu.Array(core_1.Tsu.String()).default([]),
+                port: core_1.Tsu.Number().default(core_1.DEFAULT_PORT),
+                lang: runner_1.localeTypeSchema.default(core_1.DEFAULT_CORE_CONFIG.global.lang),
+                'command-prefix': core_1.Tsu.String().default(core_1.DEFAULT_CORE_CONFIG.global['command-prefix'])
+            }),
+            plugin: core_1.Tsu.Object({})
+                .index(core_1.Tsu.Object({
+                filter: core_1.Tsu.Object({}).default({})
+            }).default({ filter: {} }))
+                .default(core_1.DEFAULT_CORE_CONFIG.plugin)
+        })
+            .default({ global: Object.assign(core_1.DEFAULT_CORE_CONFIG.global), plugin: core_1.DEFAULT_CORE_CONFIG.plugin })
+            .parse((0, core_1.loadConfig)(path_1.default.join(baseDir.root, file), 'yaml'));
+        return core_1.Tsu.Object({
+            adapter: core_1.Tsu.Object({})
+                .index(core_1.Tsu.Object({
+                extends: core_1.Tsu.String(),
+                master: core_1.Tsu.Union([core_1.Tsu.Number(), core_1.Tsu.String()]),
+                lang: runner_1.localeTypeSchema.default(result1.global.lang),
+                'command-prefix': core_1.Tsu.String().default(result1.global['command-prefix'])
+            }))
+                .default(core_1.DEFAULT_CORE_CONFIG.adapter)
+        }).parse(result1);
+    }
+    catch (err) {
+        if (!(err instanceof core_1.TsuError))
+            throw err;
+        logger_1.default.fatal(`file ${file} format error: ${err.message}`);
+        process.exit();
+    }
+}
+class Loader extends core_1.Container {
     ctx;
-    constructor() {
+    loadCount = 0;
+    constructor(options) {
         super();
-        core_1.ContextInstance.setInstance(new modules_1.default(kotoriConfig()));
-        this.ctx = core_1.ContextInstance.getInstance();
-        // 静态类型继续居然她妈是隔离的
+        const file = options && options.mode === 'dev' ? consts_1.DEV_CONFIG_NAME : consts_1.BUILD_CONFIG_NAME;
+        const runnerConfig = getRunnerConfig(file, options?.dir);
+        const ctx = new core_1.Core(getCoreConfig(file, runnerConfig.baseDir));
+        ctx.provide('runner', new runner_1.default(ctx, runnerConfig));
+        ctx.mixin('runner', ['baseDir', 'options']);
+        core_1.Container.setInstance(ctx);
+        this.ctx = core_1.Container.getInstance();
     }
     run() {
-        (0, log_1.default)(this.ctx.package, this.ctx);
+        (0, log_1.default)(this.ctx.pkg, this.ctx);
         this.catchError();
         this.listenMessage();
-        this.loadAllModule();
+        this.setPreService();
+        this.loadAllModules();
         this.checkUpdate();
     }
     handleError(err, prefix) {
-        const isKotoriError = err instanceof core_1.KotoriError;
-        if (!isKotoriError) {
-            this.ctx.logger.tag(prefix, 'default', prefix === 'UCE' ? 'cyanBG' : 'greenBG').error(err);
+        if (!(err instanceof core_1.KotoriError)) {
+            if (err instanceof Error) {
+                this.ctx.logger.label(prefix).error(err.message, err.stack);
+            }
+            else {
+                this.ctx.logger.label(prefix).error(err);
+            }
             return;
         }
-        this.ctx.logger
-            .tag(err.name.split('Error')[0].toUpperCase(), 'yellow', 'default')[err.level === 'normal' ? 'error' : err.level](err.message, err.stack);
-        if (err.name !== 'CoreError')
-            return;
-        this.ctx.logger.tag('CORE', 'black', 'red').error(err.message);
-        process.emit('SIGINT');
+        const list = {
+            ServiceError: () => this.ctx.logger.label('service').warn,
+            ModuleError: () => this.ctx.logger.label('module').error,
+            UnknownError: () => this.ctx.logger.error,
+            DevError: () => this.ctx.logger.label('error').debug
+        };
+        list[err.name]().bind(this.ctx.logger)(err.message, err.stack);
     }
     catchError() {
-        process.on('uncaughtExceptionMonitor', err => this.handleError(err, 'UCE'));
-        process.on('unhandledRejection', err => this.handleError(err, 'UHR'));
-        process.on('SIGINT', () => {
-            process.exit();
-        });
-        this.ctx.logger.debug('Run info: develop with debuing...');
+        process.on('uncaughtExceptionMonitor', (err) => this.handleError(err, 'sync'));
+        process.on('unhandledRejection', (err) => this.handleError(err, 'async'));
+        process.on('SIGINT', () => process.exit());
+        this.ctx.logger.debug('run info: develop with debuing...');
     }
     listenMessage() {
-        const handleConnectInfo = (data) => {
-            if (!data.info)
+        this.ctx.on('connect', (data) => {
+            const { type, mode, normal, address, adapter } = data;
+            let msg;
+            if (type === 'connect') {
+                switch (mode) {
+                    case 'ws':
+                        msg = `${normal ? 'Connect' : 'Reconnect'} server to ${address}`;
+                        break;
+                    case 'ws-reverse':
+                        msg = `server ${normal ? 'start' : 'restart'} at ${address}`;
+                        break;
+                    default:
+                        msg = `ready completed about ${address}`;
+                }
+            }
+            else {
+                switch (mode) {
+                    case 'ws':
+                        msg = `disconnect server from ${address}${normal ? '' : ' unexpectedly'}`;
+                        break;
+                    case 'ws-reverse':
+                        msg = `server stop at ${address}${normal ? '' : ' unexpectedly'}`;
+                        break;
+                    default:
+                        msg = `dispose completed about ${address}`;
+                }
+            }
+            adapter.ctx.logger[normal ? 'info' : 'warn'](msg);
+        });
+        this.ctx.on('status', (data) => {
+            const { status, adapter } = data;
+            adapter.ctx.logger.info(status);
+        });
+        this.ctx.on('ready_module', (data) => {
+            if (typeof data.instance !== 'object')
                 return;
-            this.ctx.logger[data.normal ? 'log' : 'warn'](`[${data.adapter.platform}]`, `${data.adapter.identity}:`, data.info);
-        };
-        this.ctx.on('connect', handleConnectInfo);
-        this.ctx.on('disconnect', handleConnectInfo);
-        this.ctx.on('load_module', data => {
-            if (!data.module)
+            const pkg = data.instance.name
+                ? this.ctx.get('runner')[core_1.Symbols.modules].get(data.instance.name)
+                : undefined;
+            if (!pkg)
                 return;
-            const { name, version, author } = data.module.package;
-            this.ctx.logger.info(`Loaded ${data.moduleType} ${name} Version: ${version} ${Array.isArray(author) ? `Authors: ${author.join(',')}` : `Author: ${author}`}`);
-        });
-        this.ctx.on('load_all_module', data => {
-            const failed = data.expected - data.reality;
-            this.ctx.logger.info(`Loaded ${data.reality} modules (plugins)${failed > 0 ? `, failed to load ${failed} modules` : ''}`);
-            this.loadAllAdapter();
+            this.loadCount += 1;
+            const { name, version, author, peerDependencies } = pkg[0].pkg;
+            this.ctx.logger.info(`loaded module ${name} version: ${version} ${Array.isArray(author) ? `authors: ${author.join(',')}` : `author: ${author}`}`);
+            const requiredVersion = peerDependencies['kotori-bot'];
+            if (!requiredVersion.includes('workspace') &&
+                (!consts_1.SUPPORTS_VERSION.exec(requiredVersion) || requiredVersion !== this.ctx.pkg.version)) {
+                if (consts_1.SUPPORTS_HALF_VERSION.exec(requiredVersion)) {
+                    this.ctx.logger.warn(`incomplete supported module version: ${requiredVersion}`);
+                }
+                else {
+                    this.ctx.logger.error(`unsupported module version: ${requiredVersion}`);
+                }
+            }
         });
     }
-    loadAllModule() {
-        this.ctx.moduleAll();
-        if ((0, global_1.isDev)())
-            this.ctx.watchFile();
+    setPreService() {
+        this.ctx.service('server', new server_1.default(this.ctx.extends(), { port: this.ctx.config.global.port }));
+        this.ctx.service('db', new database_1.default(this.ctx.extends()));
+        this.ctx.service('file', new file_1.default(this.ctx.extends()));
+    }
+    loadAllModules() {
+        this.ctx.get('runner').loadAll();
+        const failLoadCount = this.ctx.get('runner')[core_1.Symbols.modules].size - this.loadCount;
+        this.ctx.logger.info(`loaded ${this.loadCount} modules successfully${failLoadCount > 0 ? `, failed to load ${failLoadCount} modules` : ''} `);
+        this.loadAllAdapter();
+        this.ctx.emit('ready');
     }
     loadAllAdapter() {
-        const adapters = this.ctx.internal.getAdapters();
-        Object.keys(this.ctx.config.adapter).forEach(botName => {
+        const adapters = this.ctx[core_1.Symbols.adapter];
+        Object.keys(this.ctx.config.adapter).forEach((botName) => {
             const botConfig = this.ctx.config.adapter[botName];
-            if (!(botConfig.extends in adapters)) {
-                this.ctx.logger.warn(`Cannot find adapter '${botConfig.extends}' for ${botName}`);
-                return;
-            }
-            const array = adapters[botConfig.extends];
-            const isSchema = array[1]?.parseSafe(botConfig);
-            if (isSchema && !isSchema.value) {
+            const array = adapters.get(botConfig.extends);
+            if (!array) {
+                this.ctx.logger.warn(`cannot find adapter '${botConfig.extends}' for ${botName}`);
                 return;
             }
-            const bot = new array[0](this.ctx, isSchema ? isSchema.data : botConfig, botName);
-            // if (!(botConfig.extend in Adapter)) Adapter.apis[botConfig.extend] = []; // I dont know whats this
-            // this.ctx.botStack[botConfig.extend].push(bot.api);
-            bot.start();
-        }); /*
-            const adapters: Adapter[] = [];
-            Object.values(this.ctx.botStack).forEach(apis => {
-                apis.forEach(api => adapters.push(api.adapter));
-            }); */
-        // this.ctx.emit({ type: 'adapters', adapters });
+            const result = array[1]?.parseSafe(botConfig);
+            if (result && !result.value)
+                throw new core_1.ModuleError(`Config format of adapter ${botName} is error: ${result.error.message}`);
+            const bot = new array[0](this.ctx.extends({}, `${botConfig.extends}/${botName}`), result ? result.data : botConfig, botName);
+            this.ctx.on('ready', () => bot.start());
+            this.ctx.on('dispose', () => bot.stop());
+        });
     }
     async checkUpdate() {
-        const { version } = this.ctx.package;
+        const { version } = this.ctx.pkg;
         const res = await this.ctx.http
-            .get('https://hotaru.icu/api/agent/?url=https://raw.githubusercontent.com/kotorijs/kotori/master/packages/kotori/package.json')
-            .catch(() => this.ctx.logger.error('Get update failed, please check your network'));
+            .get("https://hotaru.icu/api/agent/?url=https://raw.githubusercontent.com/kotorijs/kotori/master/packages/kotori/package.json" /* GLOBAL.UPDATE */)
+            .catch(() => this.ctx.logger.error('get update failed, please check your network'));
         if (!res || !core_1.Tsu.Object({ version: core_1.Tsu.String() }).check(res)) {
-            this.ctx.logger.error(`Detection update failed`);
+            this.ctx.logger.warn(`detection update failed`);
         }
         else if (version === res.version) {
-            this.ctx.logger.log('Kotori is currently the latest version');
+            this.ctx.logger.info('kotori is currently the latest version');
         }
         else {
-            this.ctx.logger.warn(`The current version of Kotori is ${version}, and the latest version is ${res.version}. Please go to ${"https://github.com/kotorijs/kotori" /* GLOBAL.REPO */} to update`);
+            this.ctx.logger.warn(`the current version of Kotori is ${version}, and the latest version is ${res.version}. please go to ${"https://github.com/kotorijs/kotori" /* GLOBAL.REPO */} to update`);
         }
     }
 }
-exports.default = Main;
+exports.Loader = Loader;
+exports.default = Loader;

package/lib/log.d.ts

@@ -1,3 +1,3 @@
-import type { Context, PackageInfo } from '@kotori-bot/core';
-export declare function loadInfo(info: PackageInfo, ctx: Context): void;
+import type { Context } from '@kotori-bot/core';
+export declare function loadInfo(info: Context['pkg'], ctx: Context): void;
 export default loadInfo;

package/lib/log.js

@@ -2,18 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadInfo = void 0;
 function loadInfo(info, ctx) {
-    console.info('Kotori Bot is loading...');
-    console.info(`
-██╗  ██╗ ██████╗ ████████╗ ██████╗ ██████╗ ██╗
-██║ ██╔╝██╔═══██╗╚══██╔══╝██╔═══██╗██╔══██╗██║
-█████╔╝ ██║   ██║   ██║   ██║   ██║██████╔╝██║
-██╔═██╗ ██║   ██║   ██║   ██║   ██║██╔══██╗██║
-██║  ██╗╚██████╔╝   ██║   ╚██████╔╝██║  ██║██║
-╚═╝  ╚═╝ ╚═════╝    ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚═╝
+    process.stdout.write('Kotori Bot is loading...');
+    process.stdout.write(`
+██╗  ██╗ ██████╗ ████████╗ ██████╗ ██████╗ ██╗
+██║ ██╔╝██╔═══██╗╚══██╔══╝██╔═══██╗██╔══██╗██║
+█████╔╝ ██║   ██║   ██║   ██║   ██║██████╔╝██║
+██╔═██╗ ██║   ██║   ██║   ██║   ██║██╔══██╗██║
+██║  ██╗╚██████╔╝   ██║   ╚██████╔╝██║  ██║██║
+╚═╝  ╚═╝ ╚═════╝    ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚═╝
 `);
+    ctx.logger.info('loader base dir:', ctx.baseDir.root);
     ctx.logger.info(`Kotori Bot Version: ${info.version} License: ${info.license}`);
     ctx.logger.info(`Kotori Bot By ${info.author}`);
-    ctx.logger.info(`Copyright © 2023 ${info.author} All rights reserved.`);
+    ctx.logger.info(`Copyright © 2023 - 2024 ${info.author} All rights reserved`);
 }
 exports.loadInfo = loadInfo;
 exports.default = loadInfo;

package/lib/runner.d.ts

@@ -0,0 +1,55 @@
+import { Context, LocaleType, ModuleConfig, Symbols } from '@kotori-bot/core';
+interface BaseDir {
+    root: string;
+    modules: string;
+    data: string;
+    logs: string;
+}
+interface Options {
+    mode: 'dev' | 'build';
+}
+interface RunnerConfig {
+    baseDir: BaseDir;
+    options: Options;
+}
+interface ModulePackage {
+    name: string;
+    version: string;
+    description: string;
+    main: string;
+    keywords: string[];
+    license: 'GPL-3.0';
+    author: string | string[];
+    peerDependencies: {
+        'kotori-bot': string;
+        [propName: string]: string;
+    };
+    kotori: {
+        enforce?: 'pre' | 'post';
+        meta: {
+            language: LocaleType[];
+        };
+    };
+}
+interface ModuleMeta {
+    pkg: ModulePackage;
+    files: string[];
+    main: string;
+}
+export declare const localeTypeSchema: import("@kotori-bot/core").UnionParser<[import("@kotori-bot/core").UnionParser<[import("@kotori-bot/core").LiteralParser<"en_US">, import("@kotori-bot/core").LiteralParser<"ja_JP">]>, import("@kotori-bot/core").UnionParser<[import("@kotori-bot/core").LiteralParser<"zh_TW">, import("@kotori-bot/core").AnyParser<any>]>]>;
+export declare class Runner {
+    readonly baseDir: BaseDir;
+    readonly options: Options;
+    private ctx;
+    private isDev;
+    readonly [Symbols.modules]: Map<string, [ModuleMeta, ModuleConfig]>;
+    constructor(ctx: Context, config: RunnerConfig);
+    private getDirFiles;
+    private getModuleRootDir;
+    private getModuleList;
+    private loadEx;
+    private unloadEx;
+    loadAll(): void;
+    watcher(): void;
+}
+export default Runner;

package/lib/runner.js

@@ -0,0 +1,205 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runner = exports.localeTypeSchema = void 0;
+const fs_1 = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const core_1 = require("@kotori-bot/core");
+const logger_1 = require("@kotori-bot/logger");
+const consts_1 = require("./consts");
+const logger_2 = __importDefault(require("./utils/logger"));
+exports.localeTypeSchema = core_1.Tsu.Union([
+    core_1.Tsu.Union([core_1.Tsu.Literal('en_US'), core_1.Tsu.Literal('ja_JP')]),
+    core_1.Tsu.Union([core_1.Tsu.Literal('zh_TW'), core_1.Tsu.Any()])
+]);
+const modulePackageSchema = core_1.Tsu.Object({
+    name: core_1.Tsu.String().regexp(/kotori-plugin-[a-z]([a-z,0-9]{2,13})\b/),
+    version: core_1.Tsu.String(),
+    description: core_1.Tsu.String(),
+    main: core_1.Tsu.String(),
+    license: core_1.Tsu.Literal('GPL-3.0'),
+    keywords: core_1.Tsu.Custom((val) => Array.isArray(val) && val.includes('kotori') && val.includes('chatbot') && val.includes('kotori-plugin')),
+    author: core_1.Tsu.Union([core_1.Tsu.String(), core_1.Tsu.Array(core_1.Tsu.String())]),
+    peerDependencies: core_1.Tsu.Object({
+        'kotori-bot': core_1.Tsu.String()
+    }),
+    kotori: core_1.Tsu.Object({
+        enforce: core_1.Tsu.Union([core_1.Tsu.Literal('pre'), core_1.Tsu.Literal('post')]).optional(),
+        meta: core_1.Tsu.Object({
+            language: core_1.Tsu.Array(exports.localeTypeSchema).default([])
+        }).default({ language: [] })
+    }).default({
+        enforce: undefined,
+        meta: { language: [] }
+    })
+});
+function moduleLoadOrder(pkg) {
+    if (pkg.name.includes(core_1.DATABASE_PREFIX))
+        return 1;
+    if (pkg.name.includes(core_1.ADAPTER_PREFIX))
+        return 2;
+    // if (CORE_MODULES.includes(pkg.name)) return 3;
+    if (pkg.kotori.enforce === 'pre')
+        return 4;
+    if (!pkg.kotori.enforce)
+        return 5;
+    return 6;
+}
+class Runner {
+    baseDir;
+    options;
+    ctx;
+    isDev;
+    [core_1.Symbols.modules] = new Map();
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        /* handle config */
+        this.baseDir = config.baseDir;
+        this.options = config.options;
+        this.isDev = this.options.mode === 'dev';
+        const loggerOptions = {
+            level: this.isDev ? logger_1.LoggerLevel.TRACE : logger_1.LoggerLevel.INFO,
+            label: [],
+            transports: [
+                new logger_1.ConsoleTransport(),
+                new logger_1.FileTransport({ dir: this.baseDir.logs, filter: (data) => data.level >= logger_1.LoggerLevel.WARN })
+            ]
+        };
+        ctx.provide('logger', new logger_2.default(loggerOptions, this.ctx));
+        ctx.inject('logger');
+    }
+    getDirFiles(rootDir) {
+        const files = fs_1.default.readdirSync(rootDir);
+        const list = [];
+        files.forEach((fileName) => {
+            const file = path_1.default.join(rootDir, fileName);
+            if (fs_1.default.statSync(file).isDirectory()) {
+                list.push(...this.getDirFiles(file));
+            }
+            if (path_1.default.parse(file).ext !== (this.isDev ? consts_1.DEV_FILE : consts_1.BUILD_FILE))
+                return;
+            list.push(path_1.default.resolve(file));
+        });
+        return list;
+    }
+    getModuleRootDir() {
+        const moduleRootDir = [];
+        [
+            ...this.ctx.config.global.dirs.map((dir) => path_1.default.resolve(this.ctx.baseDir.root, dir)),
+            this.ctx.baseDir.modules
+        ].forEach((dir) => {
+            if (fs_1.default.existsSync(dir) && fs_1.default.statSync(dir).isDirectory())
+                moduleRootDir.push(dir);
+        });
+        return moduleRootDir;
+    }
+    getModuleList(rootDir) {
+        fs_1.default.readdirSync(rootDir).forEach(async (fileName) => {
+            const dir = path_1.default.join(rootDir, fileName);
+            if (!fs_1.default.statSync(dir).isDirectory())
+                return;
+            if (rootDir !== this.ctx.baseDir.modules && !fileName.startsWith(core_1.PLUGIN_PREFIX))
+                return;
+            const packagePath = path_1.default.join(dir, 'package.json');
+            let pkg;
+            if (!fs_1.default.existsSync(packagePath))
+                return;
+            try {
+                pkg = JSON.parse(fs_1.default.readFileSync(packagePath).toString());
+            }
+            catch {
+                throw new core_1.DevError(`illegal package.json ${packagePath}`);
+            }
+            const result = modulePackageSchema.parseSafe(pkg);
+            if (!result.value) {
+                if (rootDir !== this.ctx.baseDir.modules)
+                    return;
+                throw new core_1.DevError(`package.json format error ${packagePath}: ${result.error.message}`);
+            }
+            pkg = result.data;
+            const devMode = this.isDev && (0, fs_1.existsSync)(path_1.default.resolve(dir, consts_1.DEV_IMPORT));
+            const main = path_1.default.resolve(dir, devMode ? consts_1.DEV_IMPORT : pkg.main);
+            if (!fs_1.default.existsSync(main))
+                throw new core_1.DevError(`cannot find ${main}`);
+            const dirs = path_1.default.join(dir, devMode ? consts_1.DEV_CODE_DIRS : path_1.default.dirname(pkg.main));
+            const files = fs_1.default.statSync(dirs).isDirectory() ? this.getDirFiles(dirs) : [];
+            this[core_1.Symbols.modules].set(pkg.name, [
+                { pkg, files, main },
+                this.ctx.config.plugin[(0, core_1.stringRightSplit)(pkg.name, core_1.PLUGIN_PREFIX)] || {}
+            ]);
+        });
+    }
+    loadEx(instance, config) {
+        const { main, pkg } = instance;
+        /* eslint-disable-next-line import/no-dynamic-require, global-require, @typescript-eslint/no-var-requires */
+        let obj = require(main);
+        let handle = config;
+        const adapterName = pkg.name.split(core_1.ADAPTER_PREFIX)[1];
+        if (core_1.Adapter.isPrototypeOf.call(core_1.Adapter, obj.default) &&
+            adapterName &&
+            (!obj.config || obj.config instanceof core_1.Parser)) {
+            this.ctx[core_1.Symbols.adapter].set(adapterName, [obj.default, obj.config]);
+            obj = {};
+        }
+        else if (core_1.Service.isPrototypeOf.call(core_1.Service, obj.default)) {
+            obj = {};
+        }
+        else if (obj.config instanceof core_1.Parser) {
+            const result = obj.config.parseSafe(handle);
+            if (!result.value)
+                throw new core_1.ModuleError(`Config format of module ${pkg.name} is error: ${result.error.message}`);
+            handle = result.data;
+        }
+        if (obj.lang)
+            this.ctx.i18n.use(Array.isArray(obj.lang) ? path_1.default.resolve(...obj.lang) : path_1.default.resolve(obj.lang));
+        this.ctx.load({ name: pkg.name, ...obj, config: handle });
+    }
+    unloadEx(instance) {
+        instance.files.forEach((file) => delete require.cache[require.resolve(file)]);
+        this.ctx.load({ name: instance.pkg.name });
+    }
+    loadAll() {
+        this.getModuleRootDir().forEach((dir) => this.getModuleList(dir));
+        const modules = [];
+        this[core_1.Symbols.modules].forEach((val) => modules.push(val));
+        modules
+            .sort((el1, el2) => moduleLoadOrder(el1[0].pkg) - moduleLoadOrder(el2[0].pkg))
+            .forEach((el) => this.loadEx(...el));
+        if (this.isDev)
+            this.watcher();
+    }
+    watcher() {
+        this[core_1.Symbols.modules].forEach((data) => data[0].files.forEach((file) => fs_1.default.watchFile(file, async () => {
+            this.ctx.logger.debug(`file happen changed, module ${data[0].pkg.name} is reloading...`);
+            this.unloadEx(data[0]);
+            this.loadEx(...data);
+        })));
+    }
+}
+exports.Runner = Runner;
+exports.default = Runner;

package/lib/service/database.d.ts

@@ -0,0 +1,12 @@
+import { Context, Service } from '@kotori-bot/core';
+import knex from 'knex';
+export declare class Database extends Service {
+    internal: ReturnType<typeof knex>;
+    select: ReturnType<typeof knex>['select'];
+    delete: ReturnType<typeof knex>['delete'];
+    update: ReturnType<typeof knex>['update'];
+    insert: ReturnType<typeof knex>['insert'];
+    schema: ReturnType<typeof knex>['schema'];
+    constructor(ctx: Context);
+}
+export default Database;

package/lib/service/database.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+const core_1 = require("@kotori-bot/core");
+const knex_1 = __importDefault(require("knex"));
+const path_1 = require("path");
+class Database extends core_1.Service {
+    internal;
+    select;
+    delete;
+    update;
+    insert;
+    schema;
+    constructor(ctx) {
+        super(ctx, {}, 'database');
+        this.internal = (0, knex_1.default)({
+            client: 'sqlite',
+            connection: {
+                filename: (0, path_1.resolve)(this.ctx.baseDir.root, 'kotori.db')
+            },
+            useNullAsDefault: true
+        } /*  {
+          client: 'mysql',
+          connection: {
+            host: '127.0.0.1',
+            port: 3306,
+            user: 'kotori',
+            password: 'kotori',
+            database: 'kotori'
+          }
+        } */);
+        this.select = this.internal.select.bind(this.internal);
+        this.delete = this.internal.delete.bind(this.internal);
+        this.update = this.internal.update.bind(this.internal);
+        this.insert = this.internal.insert.bind(this.internal);
+        this.schema = this.internal.schema;
+    }
+}
+exports.Database = Database;
+exports.default = Database;

package/lib/service/file.d.ts

@@ -0,0 +1,10 @@
+import { Context, Service, createConfig, loadConfig, saveConfig } from '@kotori-bot/core';
+export declare class File extends Service {
+    constructor(ctx: Context);
+    getDir(): string;
+    getFile(filename: string): string;
+    load(filename: string, type?: Parameters<typeof loadConfig>[1], init?: Parameters<typeof loadConfig>[2]): string | object | unknown[] | null;
+    save(filename: string, data: Parameters<typeof saveConfig>[1], type?: Parameters<typeof saveConfig>[2]): void;
+    create(filename: string, data?: Parameters<typeof createConfig>[1], type?: Parameters<typeof createConfig>[2]): void;
+}
+export default File;

package/lib/service/file.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = void 0;
+const core_1 = require("@kotori-bot/core");
+const path_1 = require("path");
+class File extends core_1.Service {
+    constructor(ctx) {
+        super(ctx, {}, 'file');
+    }
+    getDir() {
+        return (0, path_1.join)(this.ctx.baseDir.data, ...(this.ctx.identity ? this.ctx.identity.split('/') : []));
+    }
+    getFile(filename) {
+        return (0, path_1.join)(this.getDir(), filename);
+    }
+    load(filename, type, init) {
+        return (0, core_1.loadConfig)(this.getFile(filename), type, init);
+    }
+    save(filename, data, type) {
+        (0, core_1.saveConfig)(this.getFile(filename), data, type);
+    }
+    create(filename, data, type) {
+        (0, core_1.createConfig)(this.getFile(filename), data, type);
+    }
+}
+exports.File = File;
+exports.default = File;

package/lib/service/server.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="body-parser" />
+/// <reference types="connect" />
+/// <reference types="serve-static" />
+import { Context, Service } from '@kotori-bot/core';
+import express from 'express';
+interface ServerConfig {
+    port: number;
+}
+export declare class Server extends Service<ServerConfig> {
+    private app;
+    private server?;
+    constructor(ctx: Context, config: ServerConfig);
+    start(): void;
+    stop(): void;
+    get: Server['app']['get'];
+    post: Server['app']['post'];
+    patch: Server['app']['patch'];
+    put: Server['app']['put'];
+    delete: Server['app']['delete'];
+    all: Server['app']['all'];
+    use: Server['app']['use'];
+    router: typeof express.Router;
+    json: (options?: import("body-parser").OptionsJson | undefined) => import("connect").NextHandleFunction;
+    static: import("serve-static").RequestHandlerConstructor<express.Response<any, Record<string, any>>>;
+}
+export default Server;

package/lib/service/server.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+const core_1 = require("@kotori-bot/core");
+const express_1 = __importDefault(require("express"));
+class Server extends core_1.Service {
+    app;
+    server;
+    constructor(ctx, config) {
+        super(ctx, config, 'server');
+        this.app = (0, express_1.default)();
+        this.app.use('/', (_, res, next) => {
+            let isWebui = false;
+            ctx[core_1.Symbols.modules].forEach((module) => {
+                if (isWebui)
+                    return;
+                if (module[0].pkg.name === '@kotori-bot/kotori-plugin-webui')
+                    isWebui = true;
+            });
+            if (!isWebui) {
+                res.setHeader('Content-type', 'text/html');
+                res.send(/* html */ `<h1>Welcome to kotori!</h1>`);
+            }
+            next();
+        });
+        this.get = this.app.get.bind(this.app);
+        this.post = this.app.post.bind(this.app);
+        this.patch = this.app.patch.bind(this.app);
+        this.put = this.app.put.bind(this.app);
+        this.delete = this.app.delete.bind(this.app);
+        this.use = this.app.use.bind(this.app);
+        this.all = this.app.all.bind(this.app);
+    }
+    start() {
+        if (this.server)
+            return;
+        this.server = this.app.listen(this.config.port);
+        this.ctx.logger.label('server').info(`server start at http://127.0.0.1:${this.config.port}`);
+    }
+    stop() {
+        if (!this.server)
+            return;
+        this.server.close();
+    }
+    get;
+    post;
+    patch;
+    put;
+    delete;
+    all;
+    use;
+    router = express_1.default.Router;
+    json = express_1.default.json;
+    static = express_1.default.static;
+}
+exports.Server = Server;
+exports.default = Server;

package/lib/utils/logger.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from '@kotori-bot/core';
+import { Logger } from '@kotori-bot/logger';
+export declare class KotoriLogger extends Logger {
+    private optionsSelf;
+    private ctx;
+    constructor(optionsSelf: Logger['options'], ctx: Context);
+    private setLabel;
+    fatal(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+}
+export default KotoriLogger;

package/lib/utils/logger.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KotoriLogger = void 0;
+const logger_1 = require("@kotori-bot/logger");
+class KotoriLogger extends logger_1.Logger {
+    optionsSelf;
+    ctx;
+    constructor(optionsSelf, ctx) {
+        super(optionsSelf);
+        this.optionsSelf = optionsSelf;
+        this.ctx = ctx;
+    }
+    setLabel() {
+        const origin = Object.create(this.optionsSelf.label);
+        const label = this.ctx.identity ? [this.ctx.identity, ...this.optionsSelf.label] : this.optionsSelf.label;
+        this[(() => 'options')()].label = label;
+        return () => {
+            this[(() => 'options')()].label = origin;
+        };
+    }
+    fatal(...args) {
+        const dispose = this.setLabel();
+        super.fatal(...args);
+        dispose();
+    }
+    error(...args) {
+        const dispose = this.setLabel();
+        super.error(...args);
+        dispose();
+    }
+    warn(...args) {
+        const dispose = this.setLabel();
+        super.warn(...args);
+        dispose();
+    }
+    info(...args) {
+        const dispose = this.setLabel();
+        super.info(...args);
+        dispose();
+    }
+    debug(...args) {
+        const dispose = this.setLabel();
+        super.debug(...args);
+        dispose();
+    }
+    trace(...args) {
+        const dispose = this.setLabel();
+        super.trace(...args);
+        dispose();
+    }
+}
+exports.KotoriLogger = KotoriLogger;
+exports.default = KotoriLogger;

package/package.json

@@ -1,18 +1,40 @@
 {
   "name": "@kotori-bot/loader",
-  "version": "v1.2.0",
+  "version": "1.4.0",
   "description": "Loader For KotoriBot",
   "license": "GPL-3.0",
   "main": "lib/index.js",
   "author": "Hotaru <biyuehuya@gmail.com>",
-  "dependencies": {
-    "@kotori-bot/core": "^v1.1.0"
-  },
+  "keywords": [
+    "kotori",
+    "chatbot",
+    "loader"
+  ],
   "files": [
-    "lib"
+    "lib",
+    "LICENSE",
+    "README.md"
   ],
+  "bugs": {
+    "url": "https://github.com/kotorijs/kotori/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kotorijs/kotori.git"
+  },
+  "homepage": "https://kotori.js.org",
+  "dependencies": {
+    "express": "^4.18.2",
+    "knex": "^3.1.0",
+    "sqlite3": "^5.1.7",
+    "@kotori-bot/logger": "^1.1.1",
+    "@kotori-bot/core": "^1.3.0"
+  },
   "devDependencies": {
-    "ts-node": "^10.9.2",
-    "typescript": "^5.1.3"
+    "@types/body-parser": "^1.19.5",
+    "@types/connect": "^3.4.38",
+    "@types/express": "^4.17.21",
+    "@types/express-serve-static-core": "^4.17.43",
+    "@types/serve-static": "^1.15.5"
   }
 }

package/lib/global.d.ts

@@ -1,25 +0,0 @@
-import { BaseDir } from '@kotori-bot/core';
-export declare const isDev: () => boolean;
-export declare const CONFIG_FILE: () => "kotori.dev.yml" | "kotori.yml";
-export declare const getBaseDir: () => {
-    root: any;
-    modules: string;
-};
-export declare const getGlobalConfig: (baseDir: BaseDir) => import("@kotori-bot/core").ObjectParserInfer<{
-    global: import("@kotori-bot/core").IntersectionParser<[import("@kotori-bot/core").ObjectParser<{
-        dirs: import("@kotori-bot/core").ArrayParser<import("@kotori-bot/core").StringParser>;
-    }>, import("@kotori-bot/core").ObjectParser<{
-        lang: import("@kotori-bot/core").UnionParser<[import("@kotori-bot/core").UnionParser<[import("@kotori-bot/core").LiteralParser<"en_US">, import("@kotori-bot/core").LiteralParser<"ja_JP">]>, import("@kotori-bot/core").UnionParser<[import("@kotori-bot/core").LiteralParser<"zh_CN">, import("@kotori-bot/core").LiteralParser<"zh_TW">]>]>;
-        'command-prefix': import("@kotori-bot/core").StringParser;
-    }>]>;
-    adapter: import("@kotori-bot/core").Parser<import("@kotori-bot/core").IndexObject<import("@kotori-bot/core").ObjectParserInfer<{
-        extends: import("@kotori-bot/core").StringParser;
-        master: import("@kotori-bot/core").UnionParser<[import("@kotori-bot/core").NumberParser, import("@kotori-bot/core").StringParser]>;
-    }> & import("@kotori-bot/core").ObjectParserInfer<{
-        lang: import("@kotori-bot/core").UnionParser<[import("@kotori-bot/core").UnionParser<[import("@kotori-bot/core").LiteralParser<"en_US">, import("@kotori-bot/core").LiteralParser<"ja_JP">]>, import("@kotori-bot/core").UnionParser<[import("@kotori-bot/core").LiteralParser<"zh_CN">, import("@kotori-bot/core").LiteralParser<"zh_TW">]>]>;
-        'command-prefix': import("@kotori-bot/core").StringParser;
-    }>>>;
-    plugin: import("@kotori-bot/core").Parser<import("@kotori-bot/core").IndexObject<import("@kotori-bot/core").ObjectParserInfer<{
-        priority: import("@kotori-bot/core").NumberParser;
-    }>>>;
-}>;

package/lib/global.js

@@ -1,53 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGlobalConfig = exports.getBaseDir = exports.CONFIG_FILE = exports.isDev = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const core_1 = require("@kotori-bot/core");
-const isDev = () => globalThis.env_mode === 'dev';
-exports.isDev = isDev;
-const CONFIG_FILE = () => ((0, exports.isDev)() ? 'kotori.dev.yml' : 'kotori.yml');
-exports.CONFIG_FILE = CONFIG_FILE;
-const getBaseDir = () => {
-    const { env_dir: envDir } = globalThis;
-    if (envDir) {
-        return {
-            root: envDir,
-            modules: path_1.default.join(envDir, 'modules'),
-        };
-    }
-    let root = path_1.default.resolve(__dirname, '..').replace('loader', 'kotori');
-    let count = 0;
-    while (!fs_1.default.existsSync(path_1.default.join(root, (0, exports.CONFIG_FILE)()))) {
-        if (count > 5)
-            throw new core_1.CoreError(`cannot find kotori-bot global ${exports.CONFIG_FILE}`);
-        root = path_1.default.join(root, '..');
-        count += 1;
-    }
-    return {
-        root,
-        modules: path_1.default.join(root, 'modules'),
-    };
-};
-exports.getBaseDir = getBaseDir;
-const getGlobalConfig = (baseDir) => {
-    const data = (0, core_1.loadConfig)(path_1.default.join(baseDir.root, (0, exports.CONFIG_FILE)()), 'yaml');
-    const isExistsGlobal = data && typeof data === 'object' && data.global && typeof data.global === 'object';
-    try {
-        if (!isExistsGlobal)
-            throw new core_1.TsuError('en_US', 'array_error');
-        const lang = data.global.lang ? core_1.localeTypeSchema.parse(data.global.lang) : undefined;
-        const commandPrefix = data.global['command-prefix'] ? data.global['command-prefix'] : undefined;
-        return (0, core_1.globalConfigSchemaController)(lang, commandPrefix).parse(data);
-    }
-    catch (err) {
-        if (!(err instanceof core_1.TsuError))
-            throw err;
-        // process.exit(1);
-        throw new core_1.CoreError(`kotori-bot global ${exports.CONFIG_FILE} format error: ${err.message}`);
-    }
-};
-exports.getGlobalConfig = getGlobalConfig;

package/lib/modules.d.ts

@@ -1,18 +0,0 @@
-import { Context } from '@kotori-bot/core';
-declare module '@kotori-bot/core' {
-    interface Context {
-        readonly moduleAll?: () => void;
-        readonly watchFile?: () => void;
-    }
-}
-export declare class Modules extends Context {
-    private isDev;
-    private readonly moduleRootDir;
-    private getDirFiles;
-    private getModuleRootDir;
-    private getModuleList;
-    private moduleQuick;
-    readonly moduleAll: () => Promise<void>;
-    readonly watchFile: () => Promise<void>;
-}
-export default Modules;

package/lib/modules.js

@@ -1,84 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Modules = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const core_1 = require("@kotori-bot/core");
-const consts_1 = require("./consts");
-class Modules extends core_1.Context {
-    isDev = this.options.env === 'dev';
-    moduleRootDir = [];
-    getDirFiles(rootDir) {
-        const files = fs_1.default.readdirSync(rootDir);
-        const list = [];
-        files.forEach(fileName => {
-            const file = path_1.default.join(rootDir, fileName);
-            if (fs_1.default.statSync(file).isDirectory()) {
-                list.push(...this.getDirFiles(file));
-            }
-            if (path_1.default.parse(file).ext !== (this.isDev ? consts_1.DEV_FILE : consts_1.BUILD_FILE))
-                return;
-            list.push(path_1.default.resolve(file));
-        });
-        return list;
-    }
-    getModuleRootDir() {
-        Object.assign(this.config.global.dirs, [this.baseDir.modules]).forEach(dir => {
-            if (fs_1.default.existsSync(dir) && fs_1.default.statSync(dir).isDirectory())
-                this.moduleRootDir.push(dir);
-        });
-    }
-    getModuleList(rootDir) {
-        const files = fs_1.default.readdirSync(rootDir);
-        files.forEach(fileName => {
-            const dir = path_1.default.join(rootDir, fileName);
-            if (!fs_1.default.statSync(dir).isDirectory())
-                return;
-            if (rootDir !== this.baseDir.modules && fileName.startsWith(core_1.PLUGIN_PREFIX))
-                return;
-            const packagePath = path_1.default.join(dir, 'package.json');
-            let packageJson;
-            if (!fs_1.default.existsSync(packagePath))
-                return;
-            try {
-                packageJson = JSON.parse(fs_1.default.readFileSync(packagePath).toString());
-            }
-            catch {
-                throw new core_1.DevError(`illegal package.json ${packagePath}`);
-            }
-            const result = core_1.ModulePackageSchema.parseSafe(packageJson);
-            if (!result.value && rootDir === this.baseDir.modules) {
-                throw new core_1.DevError(`package.json format error ${packagePath}: ${result.error.message}`);
-            }
-            const mainPath = path_1.default.join(dir, this.isDev ? consts_1.DEV_IMPORT : packageJson.main);
-            if (!fs_1.default.existsSync(mainPath))
-                throw new core_1.DevError(`cannot find ${mainPath}`);
-            const codeDirs = path_1.default.join(dir, this.isDev ? consts_1.DEV_CODE_DIRS : path_1.default.dirname(packageJson.main));
-            this.moduleStack.push({
-                package: packageJson,
-                fileList: fs_1.default.statSync(codeDirs).isDirectory() ? this.getDirFiles(codeDirs) : [],
-                mainPath: path_1.default.resolve(mainPath),
-            });
-        });
-    }
-    moduleQuick(moduleData) {
-        return this.use(moduleData, this, this.config.plugin[(0, core_1.stringRightSplit)(moduleData.package.name, core_1.PLUGIN_PREFIX)] ?? {});
-    }
-    moduleAll = async () => {
-        this.getModuleRootDir();
-        this.moduleRootDir.forEach(dir => {
-            this.getModuleList(dir);
-        });
-        const array = this.moduleStack.filter(data => data.package.name.startsWith(core_1.OFFICIAL_MODULES_SCOPE));
-        array.push(...this.moduleStack.filter(data => !array.includes(data)));
-        array.forEach(moduleData => this.moduleQuick(moduleData));
-    };
-    watchFile = async () => {
-        this.moduleStack.forEach(moduleData => moduleData.fileList.forEach(file => fs_1.default.watchFile(file, () => this.dispose(moduleData) && this.moduleQuick(moduleData))));
-    };
-}
-exports.Modules = Modules;
-exports.default = Modules;