@kotori-bot/loader 1.5.1 → 1.6.0

package/lib/class/loader.js

@@ -1,267 +1,680 @@
+
+/**
+ * @Package @kotori-bot/loader
+ * @Version 1.6.0-beta.1
+ * @Author Hotaru <biyuehuya@gmail.com>
+ * @Copyright 2024 Hotaru. All rights reserved.
+ * @License GPL-3.0
+ * @Link https://github.com/kotorijs/kotori
+ * @Date 2024/6/6 21:03:54
+ */
+
 "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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-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-12 16:24:15
- */
-const core_1 = require("@kotori-bot/core");
-const node_path_1 = __importDefault(require("node:path"));
-const node_fs_1 = __importDefault(require("node: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: node_path_1.default.join(root, 'modules'),
-            data: node_path_1.default.join(root, 'data'),
-            logs: node_path_1.default.join(root, 'logs')
-        };
-        Object.values(baseDir).forEach((val) => {
-            if (!node_fs_1.default.existsSync(val))
-                node_fs_1.default.mkdirSync(val);
-        });
-        return baseDir;
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/class/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  Loader: () => Loader,
+  default: () => loader_default
+});
+module.exports = __toCommonJS(loader_exports);
+var import_core4 = require("@kotori-bot/core");
+var import_node_path3 = __toESM(require("path"));
+var import_node_fs2 = __toESM(require("fs"));
+var import_logger4 = __toESM(require("@kotori-bot/logger"));
+
+// src/class/runner.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var import_core = require("@kotori-bot/core");
+var import_logger2 = require("@kotori-bot/logger");
+
+// src/constants.ts
+var DEV_FILE = ".ts";
+var BUILD_FILE = ".js";
+var DEV_CODE_DIRS = "./src/";
+var DEV_IMPORT = `${DEV_CODE_DIRS}index.ts`;
+var CONFIG_EXT = [".toml", ".yml", ".yaml", ".json"];
+var BUILD_CONFIG_NAME = "kotori";
+var DEV_CONFIG_NAME = "kotori.dev";
+var SUPPORTS_VERSION = /(1\.1\.0)|(1\.2\.0)|(1\.3\.(.*))|(1\.4\.(.*))/;
+var SUPPORTS_HALF_VERSION = /(x\.x\.(.*?))/;
+var BUILD_MODE = "build";
+var DEV_MODE = "dev";
+var DEV_SOURCE_MODE = "dev-source";
+var CORE_MODULES = [
+  "@kotori-bot/kotori-plugin-core",
+  "@kotori-bot/kotori-plugin-i18n-command",
+  "@kotori-bot/kotori-plugin-filter"
+  // '@kotori-bot/kotori-plugin-webui'
+];
+
+// src/utils/logger.ts
+var import_logger = require("@kotori-bot/logger");
+var KotoriLogger = class extends import_logger.Logger {
+  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[/* @__PURE__ */ (() => "options")()].label = label;
+    return () => {
+      this[/* @__PURE__ */ (() => "options")()].label = origin;
     };
-    if (dir)
-        return handle(node_path_1.default.resolve(dir));
-    let root = node_path_1.default.resolve(__dirname, '..').replace('loader', 'kotori');
-    let count = 0;
-    while (!node_fs_1.default.existsSync(node_path_1.default.join(root, file))) {
-        if (count > 5) {
-            logger_1.default.fatal(`cannot find file ${file} `);
-            process.exit();
-        }
-        root = node_path_1.default.join(root, '..');
-        count += 1;
-    }
-    return handle(root);
+  }
+  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();
+  }
+  record(...args) {
+    const dispose = this.setLabel();
+    super.record(...args);
+    dispose();
+  }
+  debug(...args) {
+    const dispose = this.setLabel();
+    super.debug(...args);
+    dispose();
+  }
+  trace(...args) {
+    const dispose = this.setLabel();
+    super.trace(...args);
+    dispose();
+  }
+};
+var logger_default = KotoriLogger;
+
+// src/class/runner.ts
+var localeTypeSchema = import_core.Tsu.Union([
+  import_core.Tsu.Union([import_core.Tsu.Literal("en_US"), import_core.Tsu.Literal("ja_JP")]),
+  import_core.Tsu.Union([import_core.Tsu.Literal("zh_TW"), import_core.Tsu.Any()])
+]);
+var modulePackageSchema = import_core.Tsu.Object({
+  name: import_core.Tsu.String().regexp(/kotori-plugin-[a-z]([a-z,0-9]{2,13})\b/),
+  version: import_core.Tsu.String(),
+  description: import_core.Tsu.String(),
+  main: import_core.Tsu.String(),
+  license: import_core.Tsu.Literal("GPL-3.0"),
+  keywords: import_core.Tsu.Custom(
+    (val) => Array.isArray(val) && val.includes("kotori") && val.includes("chatbot") && val.includes("kotori-plugin")
+  ),
+  author: import_core.Tsu.Union([import_core.Tsu.String(), import_core.Tsu.Array(import_core.Tsu.String())]),
+  peerDependencies: import_core.Tsu.Object({
+    "kotori-bot": import_core.Tsu.String()
+  }),
+  kotori: import_core.Tsu.Object({
+    enforce: import_core.Tsu.Union([import_core.Tsu.Literal("pre"), import_core.Tsu.Literal("post")]).optional(),
+    meta: import_core.Tsu.Object({
+      language: import_core.Tsu.Array(localeTypeSchema).default([])
+    }).default({ language: [] })
+  }).default({
+    enforce: void 0,
+    meta: { language: [] }
+  })
+});
+function moduleLoadOrder(pkg) {
+  if (CORE_MODULES.includes(pkg.name)) return 1;
+  if (pkg.name.includes(import_core.DATABASE_PREFIX)) return 2;
+  if (pkg.name.includes(import_core.ADAPTER_PREFIX)) return 3;
+  if (pkg.kotori.enforce === "pre") return 4;
+  if (!pkg.kotori.enforce) return 5;
+  return 6;
 }
-/* eslint consistent-return: 0 */
-function getCoreConfig(file, baseDir) {
+var Runner = class {
+  baseDir;
+  options;
+  ctx;
+  isDev;
+  isSourceDev;
+  [import_core.Symbols.modules] = /* @__PURE__ */ new Map();
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.baseDir = config.baseDir;
+    this.options = config.options;
+    this.isDev = this.options.mode.startsWith(DEV_MODE);
+    this.isSourceDev = this.options.mode === DEV_SOURCE_MODE;
+    const loggerOptions = {
+      level: this.ctx.config.global.level ?? config.level,
+      label: [],
+      transports: [
+        new import_logger2.ConsoleTransport({
+          template: "<blue>%time%</blue> %level% (<bold>%pid%</bold>) %labels%: %msg%",
+          time: "M/D H:m:s"
+        }),
+        new import_logger2.FileTransport({ dir: this.baseDir.logs, filter: (data) => data.level >= import_logger2.LoggerLevel.WARN })
+      ]
+    };
+    ctx.provide("logger", new logger_default(loggerOptions, this.ctx));
+    ctx.inject("logger");
+  }
+  getDirFiles(rootDir) {
+    const files = import_node_fs.default.readdirSync(rootDir);
+    const list = [];
+    files.forEach((fileName) => {
+      const file = import_node_path.default.join(rootDir, fileName);
+      if (import_node_fs.default.statSync(file).isDirectory()) {
+        list.push(...this.getDirFiles(file));
+      }
+      if (import_node_path.default.parse(file).ext !== (this.isSourceDev ? DEV_FILE : BUILD_FILE)) return;
+      list.push(import_node_path.default.resolve(file));
+    });
+    return list;
+  }
+  getModuleRootDir() {
+    const moduleRootDir = [];
+    [
+      ...this.ctx.config.global.dirs.map((dir) => import_node_path.default.resolve(this.ctx.baseDir.root, dir)),
+      this.ctx.baseDir.modules
+    ].forEach((dir) => {
+      if (import_node_fs.default.existsSync(dir) && import_node_fs.default.statSync(dir).isDirectory()) moduleRootDir.push(dir);
+    });
+    return moduleRootDir;
+  }
+  async checkModuleFiles(rootDir, filename) {
+    const dir = import_node_path.default.join(rootDir, filename);
+    if (!import_node_fs.default.statSync(dir).isDirectory()) return;
+    if (rootDir !== this.ctx.baseDir.modules && !filename.startsWith(import_core.PLUGIN_PREFIX)) return;
+    const packagePath = import_node_path.default.join(dir, "package.json");
+    let pkg;
+    if (!import_node_fs.default.existsSync(packagePath)) return;
     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)(node_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);
+      pkg = JSON.parse(import_node_fs.default.readFileSync(packagePath).toString());
+    } catch {
+      throw new import_core.DevError(this.ctx.format("error.dev.package.illegal", [packagePath]));
     }
-    catch (err) {
-        if (!(err instanceof core_1.TsuError))
-            throw err;
-        logger_1.default.fatal(`file ${file} format error: ${err.message}`);
-        process.exit();
+    const result = modulePackageSchema.parseSafe(pkg);
+    if (!result.value) {
+      if (rootDir !== this.ctx.baseDir.modules) return;
+      throw new import_core.DevError(this.ctx.format("error.dev.package.missing", [packagePath, result.error.message]));
     }
-}
-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);
-        ctx.provide('loader-tools', { format: (0, core_1.formatFactory)(ctx.i18n), locale: ctx.i18n.locale.bind(ctx.i18n) });
-        ctx.mixin('loader-tools', ['locale', 'format']);
-        ctx.i18n.use(node_path_1.default.resolve(__dirname, '../../locales'));
-        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();
+    pkg = result.data;
+    const devMode = this.isSourceDev && (0, import_node_fs.existsSync)(import_node_path.default.resolve(dir, DEV_IMPORT));
+    const main = import_node_path.default.resolve(dir, devMode ? DEV_IMPORT : pkg.main);
+    if (!import_node_fs.default.existsSync(main)) throw new import_core.DevError(this.ctx.format("error.dev.main_file", [main]));
+    const dirs = import_node_path.default.join(dir, devMode ? DEV_CODE_DIRS : import_node_path.default.dirname(pkg.main));
+    const files = import_node_fs.default.statSync(dirs).isDirectory() ? this.getDirFiles(dirs) : [];
+    this[import_core.Symbols.modules].set(pkg.name, [
+      { pkg, files, main },
+      this.ctx.config.plugin[(0, import_core.stringRightSplit)(pkg.name, import_core.PLUGIN_PREFIX)] || {}
+    ]);
+  }
+  getModuleList(rootDir) {
+    this.ctx.logger.trace("load dirs:", rootDir);
+    import_node_fs.default.readdirSync(rootDir).forEach(async (filename) => {
+      await this.checkModuleFiles(rootDir, filename);
+    });
+  }
+  loadLang(lang) {
+    if (lang) this.ctx.i18n.use((0, import_node_path.resolve)(...Array.isArray(lang) ? lang : [lang]));
+  }
+  loadEx(instance, origin) {
+    this.ctx.logger.trace("module:", instance, origin);
+    if (!instance.main) return;
+    const parsed = (schema) => {
+      const result = schema.parseSafe(config);
+      if (!result.value)
+        throw new import_core.ModuleError(this.ctx.format("error.module.config", [pkg.name, result.error.message]));
+      return result.data;
+    };
+    const { main, pkg } = instance;
+    let obj = require(main);
+    let config = origin;
+    const adapterName = pkg.name.split(import_core.ADAPTER_PREFIX)[1];
+    if (this.ctx.get("decorators")?.registers.includes(pkg.name)) {
+      this.ctx.emit("ready_module_decorators", pkg.name);
+      return;
     }
-    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);
+    if (import_core.Adapter.isPrototypeOf.call(import_core.Adapter, obj.default) && adapterName && (!obj.config || obj.config instanceof import_core.Parser)) {
+      this.ctx[import_core.Symbols.adapter].set(adapterName, [obj.default, obj.config]);
+      obj = {};
+    } else if (import_core.Service.isPrototypeOf.call(import_core.Service, obj.default)) {
+      obj = {};
+    } else if (obj.config instanceof import_core.Parser) {
+      config = parsed(obj.config);
     }
-    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(this.ctx.locale('loader.debug.info'));
+    if (obj.lang) this.loadLang(obj.lang);
+    if (obj.default) {
+      if (obj.default.lang) this.loadLang(obj.default.lang);
+      if (obj.default.config instanceof import_core.Parser) config = parsed(obj.default.config);
+    } else if (obj.Main) {
+      if (obj.Main.lang) this.loadLang(obj.Main.lang);
+      if (obj.Main.config instanceof import_core.Parser) config = parsed(obj.Main.config);
     }
-    listenMessage() {
-        this.ctx.on('connect', (data) => {
-            const { type, mode, normal, address: addr, adapter } = data;
-            let msg;
-            if (type === 'connect') {
-                switch (mode) {
-                    case 'ws':
-                        msg = this.ctx.format(`loader.bots.${normal ? 'connect' : 'reconnect'}`, [addr]);
-                        break;
-                    case 'ws-reverse':
-                        msg = this.ctx.format(`loader.bots.${normal ? 'start' : 'restart'}`, [addr]);
-                        break;
-                    default:
-                        msg = this.ctx.format('loader.bots.ready', [addr]);
-                }
-            }
-            else {
-                switch (mode) {
-                    case 'ws':
-                        msg = this.ctx.format(`loader.bots.disconnect${normal ? '' : '.error'}`, [addr]);
-                        break;
-                    case 'ws-reverse':
-                        msg = this.ctx.format(`loader.bots.stop${normal ? '' : '.error'}`, [addr]);
-                        break;
-                    default:
-                        msg = this.ctx.format('loader.bots.dispose', [addr]);
-                }
-            }
-            adapter.ctx.logger[normal ? 'info' : 'warn'](msg);
-        });
-        this.ctx.on('status', ({ status, adapter }) => 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(this.ctx.format('loader.modules.load', [name, version, Array.isArray(author) ? author.join(',') : author]));
-            const requiredVersion = peerDependencies['kotori-bot'];
-            if (requiredVersion.includes('workspace') ||
-                constants_1.SUPPORTS_VERSION.exec(requiredVersion) ||
-                requiredVersion.includes(this.ctx.pkg.version))
-                return;
-            if (constants_1.SUPPORTS_HALF_VERSION.exec(requiredVersion)) {
-                this.ctx.logger.warn(this.ctx.format('loader.modules.incomplete', [requiredVersion]));
-            }
-            else {
-                this.ctx.logger.error(this.ctx.format('loader.modules.unsupported', [requiredVersion]));
-            }
+    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[import_core.Symbols.modules].forEach((val) => modules.push(val));
+    modules.sort(([{ pkg: pkg1 }], [{ pkg: pkg2 }]) => moduleLoadOrder(pkg1) - moduleLoadOrder(pkg2)).forEach((el) => this.loadEx(...el));
+    if (this.isDev) this.watcher();
+  }
+  watcher() {
+    this[import_core.Symbols.modules].forEach(
+      (data) => data[0].files.forEach(
+        (file) => import_node_fs.default.watchFile(file, async () => {
+          this.ctx.logger.debug(this.ctx.format("loader.debug.reload", [data[0].pkg.name]));
+          this.unloadEx(data[0]);
+          this.loadEx(...data);
+        })
+      )
+    );
+  }
+};
+var runner_default = Runner;
+
+// src/utils/log.ts
+function loadInfo(info, ctx) {
+  process.stdout.write("Kotori Bot is loading...");
+  process.stdout.write(`
+\u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557
+\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551
+\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551
+\u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551
+\u2588\u2588\u2551  \u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D   \u2588\u2588\u2551   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551
+\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D    \u255A\u2550\u255D    \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D
+`);
+  ctx.logger.record("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 \xA9 2023 - 2024 ${info.author} All rights reserved`);
+}
+var log_default = loadInfo;
+
+// src/service/server.ts
+var import_core2 = require("@kotori-bot/core");
+var import_node_http = require("http");
+var import_path_to_regexp = require("path-to-regexp");
+var import_express = __toESM(require("express"));
+var import_ws = __toESM(require("ws"));
+var Server = class extends import_core2.Service {
+  app;
+  server;
+  wsServer;
+  wsRoutes = /* @__PURE__ */ new Map();
+  constructor(ctx, config) {
+    super(ctx, config, "server");
+    this.app = (0, import_express.default)();
+    this.app.use(import_express.default.json());
+    this.app.use("/", (req, res, next) => {
+      let isWebui = false;
+      ctx[import_core2.Symbols.modules].forEach((module2) => {
+        if (isWebui) return;
+        if (module2[0].pkg.name === "@kotori-bot/kotori-plugin-webui") isWebui = true;
+      });
+      if (isWebui || req.url !== "/") {
+        next();
+        return;
+      }
+      res.setHeader("Content-type", "text/html");
+      res.send(
+        /* html */
+        `<h1>Welcome to kotori!</h1>`
+      );
+    });
+    this.server = (0, import_node_http.createServer)(this.app);
+    this.wsServer = new import_ws.default.Server({ noServer: true });
+    this.server.on("upgrade", (req, socket, head) => {
+      this.wsServer.handleUpgrade(req, socket, head, (ws) => {
+        this.wsServer.emit("connection", ws, req);
+      });
+    });
+    this.wsServer.on("connection", (ws, req) => {
+      let triggered = false;
+      for (const [template, list] of this.wsRoutes.entries()) {
+        if (!req.url) continue;
+        const result = (0, import_path_to_regexp.match)(template, { decode: decodeURIComponent })(req.url);
+        if (!result) continue;
+        if (!triggered) triggered = true;
+        list.forEach((callback) => {
+          callback(ws, Object.assign(req, { params: result.params }));
         });
+      }
+      if (!triggered) ws.close(1002);
+    });
+  }
+  start() {
+    this.server.listen(this.config.port, () => {
+      this.ctx.logger.label("server").info(`http server start at http://127.0.0.1:${this.config.port}`);
+      this.ctx.logger.label("server").info(`websocket server start at ws://127.0.0.1:${this.config.port}`);
+    });
+  }
+  stop() {
+    this.wsServer.close();
+    this.server.close();
+  }
+  get(path3, ...callback) {
+    this.app.get(path3, ...callback);
+  }
+  post(path3, ...callback) {
+    this.app.post(path3, ...callback);
+  }
+  patch(path3, ...callback) {
+    this.app.patch(path3, ...callback);
+  }
+  put(path3, ...callback) {
+    this.app.put(path3, ...callback);
+  }
+  delete(path3, ...callback) {
+    this.app.delete(path3, ...callback);
+  }
+  all(path3, ...callback) {
+    this.app.all(path3, ...callback);
+  }
+  use(path3, ...callback) {
+    if (typeof path3 === "string") this.app.use(path3, ...callback);
+    else this.app.use("/", path3, ...callback);
+  }
+  router = import_express.default.Router;
+  json = import_express.default.json;
+  static = import_express.default.static;
+  urlencoded = import_express.default.urlencoded;
+  wss(path3, callback) {
+    const list = this.wsRoutes.get(path3) || /* @__PURE__ */ new Set();
+    list.add(callback);
+    this.wsRoutes.set(path3, list);
+    return () => list.delete(callback);
+  }
+};
+var server_default = Server;
+
+// src/service/file.ts
+var import_core3 = require("@kotori-bot/core");
+var import_node_path2 = require("path");
+var File = class extends import_core3.Service {
+  constructor(ctx) {
+    super(ctx, {}, "file");
+  }
+  getDir() {
+    return (0, import_node_path2.join)(this.ctx.baseDir.data, ...this.ctx.identity ? this.ctx.identity.split("/") : []);
+  }
+  getFile(filename) {
+    return (0, import_node_path2.join)(this.getDir(), filename);
+  }
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  load(filename, type, init) {
+    return (0, import_core3.loadConfig)(this.getFile(filename), type, init);
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+  save(filename, data, type) {
+    (0, import_core3.saveConfig)(this.getFile(filename), data, type);
+  }
+  create(filename, data, type) {
+    (0, import_core3.createConfig)(this.getFile(filename), data, type);
+  }
+};
+var file_default = File;
+
+// src/class/loader.ts
+function getBaseDir(filename, dir) {
+  let root = dir ? import_node_path3.default.resolve(dir) : import_node_path3.default.resolve(__dirname, "..").replace("loader", "kotori");
+  let filenameFull;
+  let count = 0;
+  let index = 0;
+  while (!filenameFull) {
+    if (count > 5) {
+      import_logger4.default.fatal(`cannot find file ${filename} `);
+      process.exit();
     }
-    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()));
+    const fullName = `${filename}${CONFIG_EXT[index]}`;
+    if (import_node_fs2.default.existsSync(import_node_path3.default.join(root, fullName))) {
+      filenameFull = fullName;
+      break;
     }
-    loadAllModules() {
-        this.ctx.get('runner').loadAll();
-        const failLoadCount = this.ctx.get('runner')[core_1.Symbols.modules].size - this.loadCount;
-        this.ctx.logger.info(this.ctx.format(`loader.modules.all${failLoadCount > 0 ? '.fail' : ''}`, [this.loadCount, failLoadCount]));
-        this.loadAllAdapter();
-        this.ctx.emit('ready');
+    if (index === CONFIG_EXT.length - 1) {
+      root = import_node_path3.default.join(root, "..");
+      index = 0;
+      count += 1;
+    } else {
+      index += 1;
     }
-    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)
-                return this.ctx.logger.warn(this.ctx.format('loader.adapter.notfound', [botConfig.extends, botName]));
-            const result = array[1]?.parseSafe(botConfig);
-            if (result && !result.value)
-                throw new core_1.ModuleError(this.ctx.format('error.module.config_bot', [botName, 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());
-        });
+  }
+  const baseDir = {
+    root,
+    modules: import_node_path3.default.join(root, "modules"),
+    data: import_node_path3.default.join(root, "data"),
+    logs: import_node_path3.default.join(root, "logs"),
+    config: filenameFull
+  };
+  Object.entries(baseDir).filter(([key]) => !["modules", "config"].includes(key)).forEach(([, val]) => {
+    if (!import_node_fs2.default.existsSync(val)) import_node_fs2.default.mkdirSync(val);
+  });
+  return baseDir;
+}
+function getCoreConfig(baseDir) {
+  try {
+    const result1 = import_core4.Tsu.Object({
+      global: import_core4.Tsu.Object({
+        dirs: import_core4.Tsu.Array(import_core4.Tsu.String()).default([]),
+        port: import_core4.Tsu.Number().default(import_core4.DEFAULT_PORT),
+        lang: localeTypeSchema.default(import_core4.DEFAULT_CORE_CONFIG.global.lang),
+        "command-prefix": import_core4.Tsu.String().default(import_core4.DEFAULT_CORE_CONFIG.global["command-prefix"])
+      }),
+      plugin: import_core4.Tsu.Object({}).index(
+        import_core4.Tsu.Object({
+          filter: import_core4.Tsu.Object({}).default({})
+        }).default({ filter: {} })
+      ).default(import_core4.DEFAULT_CORE_CONFIG.plugin)
+    }).default({ global: Object.assign(import_core4.DEFAULT_CORE_CONFIG.global), plugin: import_core4.DEFAULT_CORE_CONFIG.plugin }).parse((0, import_core4.loadConfig)(import_node_path3.default.join(baseDir.root, baseDir.config), baseDir.config.split(".").pop()));
+    return import_core4.Tsu.Object({
+      adapter: import_core4.Tsu.Object({}).index(
+        import_core4.Tsu.Object({
+          extends: import_core4.Tsu.String(),
+          master: import_core4.Tsu.Union([import_core4.Tsu.Number(), import_core4.Tsu.String()]),
+          lang: localeTypeSchema.default(result1.global.lang),
+          "command-prefix": import_core4.Tsu.String().default(result1.global["command-prefix"])
+        })
+      ).default(import_core4.DEFAULT_CORE_CONFIG.adapter)
+    }).parse(result1);
+  } catch (err) {
+    if (!(err instanceof import_core4.TsuError)) throw err;
+    import_logger4.default.fatal(`file ${baseDir.config} format error: ${err.message}`);
+    process.exit();
+  }
+}
+var Loader = class extends import_core4.Container {
+  ctx;
+  loadCount = 0;
+  constructor(options) {
+    super();
+    const filename = options && options.mode?.startsWith(DEV_MODE) ? DEV_CONFIG_NAME : BUILD_CONFIG_NAME;
+    const runnerConfig = {
+      baseDir: getBaseDir(filename, options?.dir),
+      options: { mode: options?.mode || BUILD_MODE },
+      level: options?.level || options?.mode?.startsWith(DEV_MODE) ? import_logger4.LoggerLevel.DEBUG : import_logger4.LoggerLevel.INFO
+    };
+    const ctx = new import_core4.Core(getCoreConfig(runnerConfig.baseDir));
+    ctx.provide("runner", new runner_default(ctx, runnerConfig));
+    ctx.mixin("runner", ["baseDir", "options"]);
+    import_core4.Container.setInstance(ctx);
+    ctx.provide("loader-tools", { format: (0, import_core4.formatFactory)(ctx.i18n), locale: ctx.i18n.locale.bind(ctx.i18n) });
+    ctx.mixin("loader-tools", ["locale", "format"]);
+    ctx.i18n.use(import_node_path3.default.resolve(__dirname, "../../locales"));
+    this.ctx = import_core4.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() {
+    log_default(this.ctx.pkg, this.ctx);
+    this.catchError();
+    this.listenMessage();
+    this.setPreService();
+    this.loadAllModules();
+    this.checkUpdate();
+  }
+  handleError(err, prefix) {
+    if (!(err instanceof import_core4.KotoriError)) {
+      if (err instanceof Error) {
+        this.ctx.logger.label(prefix).error(err.message, err.stack);
+      } else {
+        this.ctx.logger.label(prefix).error(err);
+      }
+      return;
     }
-    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(this.ctx.locale('loader.tips.update.failed')));
-        if (!res || !core_1.Tsu.Object({ version: core_1.Tsu.String() }).check(res)) {
-            this.ctx.logger.warn(this.ctx.locale('loader.tips.update.failed'));
-        }
-        else if (version === res.version) {
-            this.ctx.logger.info(this.ctx.locale('loader.tips.update.latest'));
+    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(this.ctx.locale("loader.debug.info"));
+  }
+  listenMessage() {
+    this.ctx.on("connect", (data) => {
+      const { type, mode, normal, address: addr, adapter } = data;
+      let msg;
+      if (type === "connect") {
+        switch (mode) {
+          case "ws":
+            msg = this.ctx.format(`loader.bots.${normal ? "connect" : "reconnect"}`, [addr]);
+            break;
+          case "ws-reverse":
+            msg = this.ctx.format(`loader.bots.${normal ? "start" : "restart"}`, [addr]);
+            break;
+          default:
+            msg = this.ctx.format("loader.bots.ready", [addr]);
         }
-        else {
-            this.ctx.logger.warn(this.ctx.format('loader.tips.update.available', [version, res.version, "https://github.com/kotorijs/kotori" /* GLOBAL.REPO */]));
+      } else {
+        switch (mode) {
+          case "ws":
+            msg = this.ctx.format(`loader.bots.disconnect${normal ? "" : ".error"}`, [addr]);
+            break;
+          case "ws-reverse":
+            msg = this.ctx.format(`loader.bots.stop${normal ? "" : ".error"}`, [addr]);
+            break;
+          default:
+            msg = this.ctx.format("loader.bots.dispose", [addr]);
         }
+      }
+      adapter.ctx.logger[normal ? "info" : "warn"](msg);
+    });
+    this.ctx.on("status", ({ status, adapter }) => 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")[import_core4.Symbols.modules].get(data.instance.name) : void 0;
+      if (!pkg) return;
+      this.loadCount += 1;
+      const { name, version, author, peerDependencies } = pkg[0].pkg;
+      this.ctx.logger.info(
+        this.ctx.format("loader.modules.load", [name, version, Array.isArray(author) ? author.join(",") : author])
+      );
+      const requiredVersion = peerDependencies["kotori-bot"];
+      if (requiredVersion.includes("workspace") || SUPPORTS_VERSION.exec(requiredVersion) || requiredVersion.includes(this.ctx.pkg.version))
+        return;
+      if (SUPPORTS_HALF_VERSION.exec(requiredVersion)) {
+        this.ctx.logger.warn(this.ctx.format("loader.modules.incomplete", [requiredVersion]));
+      } else {
+        this.ctx.logger.error(this.ctx.format("loader.modules.unsupported", [requiredVersion]));
+      }
+    });
+  }
+  setPreService() {
+    this.ctx.service("server", new server_default(this.ctx.extends(), { port: this.ctx.config.global.port }));
+    this.ctx.service("file", new file_default(this.ctx.extends()));
+  }
+  loadAllModules() {
+    this.ctx.get("runner").loadAll();
+    const failLoadCount = this.ctx.get("runner")[import_core4.Symbols.modules].size - this.loadCount;
+    this.ctx.logger.info(
+      this.ctx.format(`loader.modules.all${failLoadCount > 0 ? ".failed" : ""}`, [this.loadCount, failLoadCount])
+    );
+    this.loadAllAdapter();
+    this.ctx.emit("ready");
+  }
+  loadAllAdapter() {
+    const adapters = this.ctx[import_core4.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)
+        return this.ctx.logger.warn(this.ctx.format("loader.adapters.notfound", [botConfig.extends, botName]));
+      const result = array[1]?.parseSafe(botConfig);
+      if (result && !result.value)
+        throw new import_core4.ModuleError(this.ctx.format("error.module.config_bot", [botName, 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" /* UPDATE */).catch(() => this.ctx.logger.error(this.ctx.locale("loader.tips.update.failed")));
+    if (!res || !import_core4.Tsu.Object({ version: import_core4.Tsu.String() }).check(res)) {
+      this.ctx.logger.warn(this.ctx.locale("loader.tips.update.failed"));
+    } else if (version === res.version) {
+      this.ctx.logger.info(this.ctx.locale("loader.tips.update.latest"));
+    } else {
+      this.ctx.logger.warn(this.ctx.format("loader.tips.update.available", [version, res.version, "https://github.com/kotorijs/kotori" /* REPO */]));
     }
-}
-exports.Loader = Loader;
-exports.default = Loader;
+  }
+};
+var loader_default = Loader;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Loader
+});