@kotori-bot/loader 1.4.2 → 1.5.0

package/lib/class/loader.d.ts

@@ -0,0 +1,41 @@
+import { Container, Symbols } from '@kotori-bot/core';
+import Logger from '@kotori-bot/logger';
+import Runner from './runner';
+import Server from '../service/server';
+import type 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 readonly ctx;
+    private loadCount;
+    constructor(options?: {
+        dir?: string;
+        mode?: string;
+        level?: number;
+    });
+    run(): void;
+    private handleError;
+    private catchError;
+    private listenMessage;
+    private setPreService;
+    private loadAllModules;
+    private loadAllAdapter;
+    private checkUpdate;
+}
+export default Loader;

package/lib/class/loader.js

@@ -0,0 +1,268 @@
+"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: 2024-05-03 22:05:36
+ */
+const core_1 = require("@kotori-bot/core");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const logger_1 = __importStar(require("@kotori-bot/logger"));
+const runner_1 = __importStar(require("./runner"));
+const log_1 = __importDefault(require("../utils/log"));
+const constants_1 = require("../constants");
+const server_1 = __importDefault(require("../service/server"));
+const file_1 = __importDefault(require("../service/file"));
+function getBaseDir(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;
+    };
+    if (dir)
+        return handle(path_1.default.resolve(dir));
+    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 handle(root);
+}
+/* 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;
+    loadCount = 0;
+    constructor(options) {
+        super();
+        const file = options && options.mode?.startsWith(constants_1.DEV_MODE) ? constants_1.DEV_CONFIG_NAME : constants_1.BUILD_CONFIG_NAME;
+        const runnerConfig = {
+            baseDir: getBaseDir(file, options?.dir),
+            options: { mode: (options?.mode || constants_1.BUILD_MODE) },
+            level: options?.level || options?.mode?.startsWith(constants_1.DEV_MODE) ? logger_1.LoggerLevel.DEBUG : logger_1.LoggerLevel.INFO
+        };
+        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();
+        this.ctx.logger.trace(`options:`, options);
+        this.ctx.logger.trace(`runnerConfig:`, runnerConfig);
+        this.ctx.logger.trace(`baseDir:`, this.ctx.baseDir);
+        this.ctx.logger.trace(`options:`, this.ctx.options);
+        this.ctx.logger.trace(`config:`, this.ctx.config);
+        this.ctx.logger.trace(`where:`, __dirname, __filename);
+        this.ctx.logger.trace(`running:`, process.cwd());
+    }
+    run() {
+        (0, log_1.default)(this.ctx.pkg, this.ctx);
+        this.catchError();
+        this.listenMessage();
+        this.setPreService();
+        this.loadAllModules();
+        this.checkUpdate();
+    }
+    handleError(err, prefix) {
+        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;
+        }
+        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, 'sync'));
+        process.on('unhandledRejection', (err) => this.handleError(err, 'async'));
+        process.on('SIGINT', () => process.exit());
+        this.ctx.logger.debug('run info: develop with debugging...');
+    }
+    listenMessage() {
+        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;
+            const pkg = data.instance.name
+                ? this.ctx.get('runner')[core_1.Symbols.modules].get(data.instance.name)
+                : undefined;
+            if (!pkg)
+                return;
+            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') &&
+                (!constants_1.SUPPORTS_VERSION.exec(requiredVersion) || requiredVersion !== this.ctx.pkg.version)) {
+                if (constants_1.SUPPORTS_HALF_VERSION.exec(requiredVersion)) {
+                    this.ctx.logger.warn(`incomplete supported module version: ${requiredVersion}`);
+                }
+                else {
+                    this.ctx.logger.error(`unsupported module version: ${requiredVersion}`);
+                }
+            }
+        });
+    }
+    setPreService() {
+        this.ctx.service('server', new server_1.default(this.ctx.extends(), { port: this.ctx.config.global.port }));
+        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[core_1.Symbols.adapter];
+        Object.keys(this.ctx.config.adapter).forEach((botName) => {
+            const botConfig = this.ctx.config.adapter[botName];
+            const array = adapters.get(botConfig.extends);
+            if (!array) {
+                this.ctx.logger.warn(`cannot find adapter '${botConfig.extends}' for ${botName}`);
+                return;
+            }
+            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.pkg;
+        const res = await this.ctx.http
+            .get("https://hotaru.icu/api/agent/?url=https://raw.githubusercontent.com/kotorijs/kotori/master/packages/core/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.warn(`detection update failed`);
+        }
+        else if (version === res.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`);
+        }
+    }
+}
+exports.Loader = Loader;
+exports.default = Loader;

package/lib/class/runner.d.ts

@@ -0,0 +1,60 @@
+import { Context, LocaleType, ModuleConfig, Symbols } from '@kotori-bot/core';
+import { BUILD_MODE, DEV_MODE, DEV_SOURCE_MODE } from '../constants';
+interface BaseDir {
+    root: string;
+    modules: string;
+    data: string;
+    logs: string;
+}
+interface Options {
+    mode: typeof BUILD_MODE | typeof DEV_MODE | typeof DEV_SOURCE_MODE;
+}
+interface RunnerConfig {
+    baseDir: BaseDir;
+    options: Options;
+    level: number;
+}
+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 readonly ctx;
+    private readonly isDev;
+    private readonly isSourceDev;
+    readonly [Symbols.modules]: Map<string, [ModuleMeta, ModuleConfig]>;
+    constructor(ctx: Context, config: RunnerConfig);
+    private getDirFiles;
+    private getModuleRootDir;
+    private checkModuleFiles;
+    private getModuleList;
+    private loadLang;
+    private loadEx;
+    private unloadEx;
+    loadAll(): void;
+    watcher(): void;
+}
+export default Runner;

package/lib/class/runner.js

@@ -0,0 +1,233 @@
+"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 = __importStar(require("path"));
+const core_1 = require("@kotori-bot/core");
+const logger_1 = require("@kotori-bot/logger");
+const constants_1 = require("../constants");
+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;
+    isSourceDev;
+    [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.startsWith(constants_1.DEV_MODE);
+        this.isSourceDev = this.options.mode === constants_1.DEV_SOURCE_MODE;
+        const loggerOptions = {
+            level: this.ctx.config.global.level ?? config.level,
+            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.isSourceDev ? constants_1.DEV_FILE : constants_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;
+    }
+    async checkModuleFiles(rootDir, 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.isSourceDev && (0, fs_1.existsSync)(path_1.default.resolve(dir, constants_1.DEV_IMPORT));
+        const main = path_1.default.resolve(dir, devMode ? constants_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 ? constants_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)] || {}
+        ]);
+    }
+    getModuleList(rootDir) {
+        this.ctx.logger.trace('load dirs:', rootDir);
+        fs_1.default.readdirSync(rootDir).forEach(async (filename) => {
+            await this.checkModuleFiles(rootDir, filename);
+        });
+    }
+    loadLang(lang) {
+        if (lang)
+            this.ctx.i18n.use((0, path_1.resolve)(...(Array.isArray(lang) ? lang : [lang])));
+    }
+    loadEx(instance, origin) {
+        this.ctx.logger.trace('module:', instance, origin);
+        const parsed = (schema) => {
+            const result = schema.parseSafe(config);
+            if (!result.value)
+                throw new core_1.ModuleError(`Config format of module ${pkg.name} is error: ${result.error.message}`);
+            return result.data;
+        };
+        const { main, pkg } = instance;
+        /* eslint-disable-next-line import/no-dynamic-require, global-require, @typescript-eslint/no-var-requires */
+        let obj = require(main);
+        let config = origin;
+        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)) {
+            /* Adapter Class */
+            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)) {
+            /* Service Class */
+            obj = {};
+        }
+        else if (obj.config instanceof core_1.Parser) {
+            config = parsed(obj.config);
+        }
+        if (obj.lang)
+            this.loadLang(obj.lang);
+        if (obj.default) {
+            if (obj.default.lang)
+                this.loadLang(obj.default.lang);
+            if (obj.default.config instanceof core_1.Parser)
+                config = parsed(obj.default.config);
+        }
+        else if (obj.Main) {
+            if (obj.Main.lang)
+                this.loadLang(obj.Main.lang);
+            if (obj.Main.config instanceof core_1.Parser)
+                config = parsed(obj.Main.config);
+        }
+        this.ctx.load({ name: pkg.name, ...obj, config });
+    }
+    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/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const DEV_FILE = ".ts";
+export declare const BUILD_FILE = ".js";
+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;
+export declare const BUILD_MODE: "build";
+export declare const DEV_MODE: "dev";
+export declare const DEV_SOURCE_MODE: "dev-source";

package/lib/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_SOURCE_MODE = exports.DEV_MODE = exports.BUILD_MODE = 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_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)|(1\.3\.(.*))|(1\.4\.(.*))/;
+exports.SUPPORTS_HALF_VERSION = /(x\.x\.(.*?))/;
+exports.BUILD_MODE = 'build';
+exports.DEV_MODE = 'dev';
+exports.DEV_SOURCE_MODE = 'dev-source';

package/lib/decorators/index.d.ts

@@ -0,0 +1,5 @@
+import Decorators from './utils';
+export declare function plugins(plugin: string | string[] | {
+    name: string;
+}): Decorators;
+export default plugins;

package/lib/decorators/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugins = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const core_1 = require("@kotori-bot/core");
+const utils_1 = __importDefault(require("./utils"));
+function plugins(plugin) {
+    let pkgName;
+    if (!Array.isArray(plugin) && typeof plugin === 'object') {
+        pkgName = plugin.name;
+    }
+    else {
+        pkgName = JSON.parse((0, fs_1.readFileSync)((0, path_1.resolve)(...(Array.isArray(plugin) ? plugin : [plugin]), 'package.json')).toString()).name;
+    }
+    const pluginName = pkgName.split(core_1.PLUGIN_PREFIX)[1] ?? pkgName;
+    const ctx = core_1.Container.getInstance().extends(undefined, pluginName);
+    return new utils_1.default(ctx);
+}
+exports.plugins = plugins;
+exports.default = plugins;

package/lib/decorators/utils.d.ts

@@ -0,0 +1,35 @@
+import { Context, EventsList, CommandAccess, MessageScope } from '@kotori-bot/core';
+export declare class Decorators {
+    private readonly ctx;
+    private isCreated;
+    private pkgName;
+    private object?;
+    private register;
+    constructor(ctx: Context);
+    readonly import: (Target: object) => void;
+    readonly lang: <T extends object>(target: T, property: keyof T) => void;
+    readonly inject: <T extends object>(target: T, property: keyof T) => void;
+    readonly schema: <T extends object>(Target: T, property: keyof T) => void;
+    on<T extends keyof EventsList>(meta: {
+        type: T;
+    }): (...args: any[]) => void;
+    once<T extends keyof EventsList>(meta: {
+        type: T;
+    }): (...args: any[]) => void;
+    midware(meta?: {
+        priority: number;
+    }): (...args: any[]) => void;
+    command(meta: {
+        template: string;
+        alias?: string[];
+        description?: string;
+        help?: string;
+        scope?: MessageScope | 'all';
+        access?: CommandAccess;
+        options?: [string, string][];
+    }): (...args: any[]) => void;
+    regexp(meta: {
+        match: RegExp;
+    }): (...args: any[]) => void;
+}
+export default Decorators;

package/lib/decorators/utils.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decorators = void 0;
+const path_1 = require("path");
+const core_1 = require("@kotori-bot/core");
+class Decorators {
+    ctx;
+    isCreated = false;
+    pkgName;
+    object;
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    register(callback) {
+        return (...args) => this.ctx.parent.once('ready_module', (data) => {
+            if (data.instance.name === this.pkgName) {
+                callback(...args);
+                return;
+            }
+            this.register(callback);
+        });
+    }
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.pkgName = `${core_1.PLUGIN_PREFIX}${ctx.identity}`;
+    }
+    import = (Target) => {
+        this.register(() => {
+            if (!this.isCreated)
+                this.schema(Target, undefined);
+        })();
+    };
+    lang = (target, property) => {
+        this.register(() => {
+            const lang = target[property];
+            this.ctx.parent.i18n.use((0, path_1.resolve)(...(Array.isArray(lang) ? lang : [lang])));
+        })();
+    };
+    inject = (target, property) => {
+        this.register(() => {
+            const inject = target[property];
+            inject.forEach((identity) => this.ctx[core_1.Tokens.container].forEach((service, name) => {
+                if (!(service instanceof core_1.Service) || service.identity !== identity)
+                    return;
+                this.ctx.inject(name);
+            }));
+        })();
+    };
+    schema = (Target, property) => {
+        this.register(() => {
+            let config = (this.ctx[core_1.Symbols.modules].get(this.pkgName) ?? [])[1];
+            const result = Target[property].parseSafe(config);
+            if (!result.value)
+                throw new core_1.ModuleError(`Config format of module ${this.pkgName} is error: ${result.error.message}`);
+            config = result.data;
+            if (this.isCreated)
+                return;
+            this.isCreated = true;
+            this.object = new Target(this.ctx, config);
+        })();
+    };
+    on(meta) {
+        return this.register((target, property) => this.ctx.on(meta.type, (...args) => target[property].bind(this.object)(...args)));
+    }
+    once(meta) {
+        return this.register((target, property) => this.ctx.once(meta.type, (...args) => target[property].bind(this.object)(...args)));
+    }
+    midware(meta) {
+        return this.register((target, property) => this.ctx.midware((next, session) => target[property].bind(this.object)(next, session), meta?.priority));
+    }
+    command(meta) {
+        return this.register((target, property) => {
+            const command = this.ctx
+                .command(meta.template, meta)
+                .action((data, session) => target[property].bind(this.object)(data, session));
+            meta.options?.forEach(([name, template]) => command.option(name, template));
+        });
+    }
+    regexp(meta) {
+        return this.register((target, property) => this.ctx.regexp(meta.match, (match, session) => target[property].bind(this.object)(match, session)));
+    }
+}
+exports.Decorators = Decorators;
+exports.default = Decorators;

package/lib/index.d.ts

@@ -1,3 +1,4 @@
-export * from './loader';
-export * from './consts';
+export * from './class/loader';
+export * from './constants';
+export * from './decorators';
 export * from '@kotori-bot/logger';

package/lib/index.js

@@ -4,7 +4,7 @@
  * @Blog: https://hotaru.icu
  * @Date: 2023-10-29 16:20:51
  * @LastEditors: Hotaru biyuehuya@gmail.com
- * @LastEditTime: 2024-02-20 20:20:54
+ * @LastEditTime: 2024-05-02 10:44:55
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -21,6 +21,7 @@ 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("./class/loader"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./decorators"), exports);
 __exportStar(require("@kotori-bot/logger"), exports);

package/lib/loader.js

@@ -32,7 +32,7 @@ exports.Loader = void 0;
  * @Blog: https://hotaru.icu
  * @Date: 2023-06-24 15:12:55
  * @LastEditors: Hotaru biyuehuya@gmail.com
- * @LastEditTime: 2024-02-24 19:11:35
+ * @LastEditTime: 2024-05-01 22:06:58
  */
 const core_1 = require("@kotori-bot/core");
 const path_1 = __importDefault(require("path"));
@@ -40,7 +40,7 @@ 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 consts_1 = require("./consts");
+const constants_1 = require("./constants");
 const server_1 = __importDefault(require("./service/server"));
 const file_1 = __importDefault(require("./service/file"));
 function getRunnerConfig(file, dir) {
@@ -58,7 +58,7 @@ function getRunnerConfig(file, dir) {
         return baseDir;
     };
     const options = {
-        mode: file === consts_1.DEV_CONFIG_NAME ? 'dev' : 'build'
+        mode: file === constants_1.DEV_CONFIG_NAME ? 'dev' : 'build'
     };
     if (dir)
         return { baseDir: handle(path_1.default.resolve(dir)), options };
@@ -115,7 +115,7 @@ class Loader extends core_1.Container {
     loadCount = 0;
     constructor(options) {
         super();
-        const file = options && options.mode === 'dev' ? consts_1.DEV_CONFIG_NAME : consts_1.BUILD_CONFIG_NAME;
+        const file = options && options.mode === 'dev' ? constants_1.DEV_CONFIG_NAME : constants_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));
@@ -202,8 +202,8 @@ class Loader extends core_1.Container {
             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)) {
+                (!constants_1.SUPPORTS_VERSION.exec(requiredVersion) || requiredVersion !== this.ctx.pkg.version)) {
+                if (constants_1.SUPPORTS_HALF_VERSION.exec(requiredVersion)) {
                     this.ctx.logger.warn(`incomplete supported module version: ${requiredVersion}`);
                 }
                 else {
@@ -243,7 +243,7 @@ class Loader extends core_1.Container {
     async checkUpdate() {
         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" /* GLOBAL.UPDATE */)
+            .get("https://hotaru.icu/api/agent/?url=https://raw.githubusercontent.com/kotorijs/kotori/master/packages/core/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.warn(`detection update failed`);

package/lib/runner.js

@@ -31,7 +31,7 @@ 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 constants_1 = require("./constants");
 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')]),
@@ -101,7 +101,7 @@ class Runner {
             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))
+            if (path_1.default.parse(file).ext !== (this.isDev ? constants_1.DEV_FILE : constants_1.BUILD_FILE))
                 return;
             list.push(path_1.default.resolve(file));
         });
@@ -142,11 +142,11 @@ class Runner {
                 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);
+            const devMode = this.isDev && (0, fs_1.existsSync)(path_1.default.resolve(dir, constants_1.DEV_IMPORT));
+            const main = path_1.default.resolve(dir, devMode ? constants_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 dirs = path_1.default.join(dir, devMode ? constants_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 },

package/lib/service/file.d.ts

@@ -3,7 +3,7 @@ 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;
+    load<T = Parameters<typeof saveConfig>[1]>(filename: string, type?: Parameters<typeof loadConfig>[1], init?: Parameters<typeof loadConfig>[2]): T;
     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;
 }

package/lib/service/file.js

@@ -13,6 +13,7 @@ class File extends core_1.Service {
     getFile(filename) {
         return (0, path_1.join)(this.getDir(), filename);
     }
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
     load(filename, type, init) {
         return (0, core_1.loadConfig)(this.getFile(filename), type, init);
     }

package/lib/service/server.d.ts

@@ -1,14 +1,18 @@
 /// <reference types="body-parser" />
 /// <reference types="connect" />
 /// <reference types="serve-static" />
+/// <reference types="node" />
 import { Context, Service } from '@kotori-bot/core';
 import express from 'express';
+import { IncomingMessage } from 'http';
+import ws from 'ws';
 interface ServerConfig {
     port: number;
 }
 export declare class Server extends Service<ServerConfig> {
     private app;
     private server?;
+    private wsServer?;
     constructor(ctx: Context, config: ServerConfig);
     start(): void;
     stop(): void;
@@ -22,5 +26,6 @@ export declare class Server extends Service<ServerConfig> {
     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>>>;
+    wss(path?: string): ws.Server<typeof ws, typeof IncomingMessage> | undefined;
 }
 export default Server;

package/lib/service/server.js

@@ -6,9 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Server = void 0;
 const core_1 = require("@kotori-bot/core");
 const express_1 = __importDefault(require("express"));
+const ws_1 = __importDefault(require("ws"));
 class Server extends core_1.Service {
     app;
     server;
+    wsServer;
     constructor(ctx, config) {
         super(ctx, config, 'server');
         this.app = (0, express_1.default)();
@@ -35,15 +37,21 @@ class Server extends core_1.Service {
         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}`);
+        if (!this.server) {
+            this.server = this.app.listen(this.config.port);
+            this.ctx.logger.label('server').info(`http server start at http://127.0.0.1:${this.config.port}`);
+        }
+        if (!this.wsServer) {
+            const port = this.config.port + 1;
+            this.wsServer = new ws_1.default.Server({ port });
+            this.ctx.logger.label('server').info(`websocket server start at ws://127.0.0.1:${port}`);
+        }
     }
     stop() {
-        if (!this.server)
-            return;
-        this.server.close();
+        if (this.server)
+            this.server.close();
+        if (this.wsServer)
+            this.wsServer.close();
     }
     get;
     post;
@@ -55,6 +63,32 @@ class Server extends core_1.Service {
     router = express_1.default.Router;
     json = express_1.default.json;
     static = express_1.default.static;
+    wss(path) {
+        if (!this.wsServer)
+            return undefined;
+        if (!path)
+            return this.wsServer;
+        const eventEmiter = new Proxy(this.wsServer.on, {
+            apply: (target, thisArg, argArray) => {
+                const [event, callback] = argArray;
+                if (event !== 'connection')
+                    return Reflect.apply(target, thisArg, argArray);
+                return this.wsServer.on(event, (ws, req) => {
+                    if (req.url !== path && path)
+                        return;
+                    callback(ws, req);
+                    this.ctx.logger.label('server').info(`websocket connection from ${req.url}`);
+                });
+            }
+        });
+        return new Proxy(this.wsServer, {
+            get: (target, p, receiver) => {
+                if (p !== 'on')
+                    return Reflect.get(target, p, receiver);
+                return eventEmiter;
+            }
+        });
+    }
 }
 exports.Server = Server;
 exports.default = Server;

package/lib/utils/log.d.ts

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

package/lib/utils/log.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadInfo = void 0;
+function loadInfo(info, ctx) {
+    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 - 2024 ${info.author} All rights reserved`);
+}
+exports.loadInfo = loadInfo;
+exports.default = loadInfo;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kotori-bot/loader",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Loader For KotoriBot",
   "license": "GPL-3.0",
   "main": "lib/index.js",
@@ -24,9 +24,11 @@
   },
   "homepage": "https://kotori.js.org",
   "dependencies": {
+    "@types/ws": "^8.5.8",
     "express": "^4.18.2",
     "knex": "^3.1.0",
-    "@kotori-bot/core": "^1.3.0",
+    "ws": "^8.14.2",
+    "@kotori-bot/core": "^1.4.0",
     "@kotori-bot/logger": "^1.2.0"
   },
   "devDependencies": {