@kotori-bot/loader 1.3.0 → 1.4.1

package/README.md

@@ -1,5 +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.js

@@ -7,5 +7,5 @@ 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)/;
+exports.SUPPORTS_VERSION = /(1\.1\.0)|(1\.2\.0)/;
 exports.SUPPORTS_HALF_VERSION = /(x\.x\.(.*?))/;

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-06 19:03:21
+ * @LastEditTime: 2024-02-20 20:20:54
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;

package/lib/loader.d.ts

@@ -1,23 +1,29 @@
 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];
-        useAll(): void;
+        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;
     private loadCount;
-    private failLoadCount;
     constructor(options?: {
         dir?: string;
         mode?: string;
@@ -26,8 +32,9 @@ export declare class Loader extends Container {
     private handleError;
     private catchError;
     private listenMessage;
-    private loadAllModule;
-    private loadAllService;
+    private setPreService;
+    private loadAllModules;
+    private loadAllAdapter;
     private checkUpdate;
 }
 export default Loader;

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-06 21:05:17
+ * @LastEditTime: 2024-02-21 11:35:04
  */
 const core_1 = require("@kotori-bot/core");
 const path_1 = __importDefault(require("path"));
@@ -41,22 +41,28 @@ 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 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 = (baseDir) => {
-        if (!fs_1.default.existsSync(baseDir.modules))
-            fs_1.default.mkdirSync(baseDir.modules);
-        if (!fs_1.default.existsSync(baseDir.logs))
-            fs_1.default.mkdirSync(baseDir.logs);
+    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;
     };
     const options = {
         mode: file === consts_1.DEV_CONFIG_NAME ? 'dev' : 'build'
     };
     if (dir)
-        return {
-            baseDir: handle({ root: dir, modules: path_1.default.join(dir, 'modules'), logs: path_1.default.join(dir, 'logs') }),
-            options
-        };
+        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))) {
@@ -67,10 +73,7 @@ function getRunnerConfig(file, dir) {
         root = path_1.default.join(root, '..');
         count += 1;
     }
-    return {
-        baseDir: handle({ root, modules: path_1.default.join(root, 'modules'), logs: path_1.default.join(root, 'logs') }),
-        options
-    };
+    return { baseDir: handle(root), options };
 }
 /* eslint consistent-return: 0 */
 function getCoreConfig(file, baseDir) {
@@ -78,6 +81,7 @@ function getCoreConfig(file, baseDir) {
         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'])
             }),
@@ -110,14 +114,13 @@ function getCoreConfig(file, baseDir) {
 class Loader extends core_1.Container {
     ctx;
     loadCount = 0;
-    failLoadCount = 0;
     constructor(options) {
         super();
         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', 'useAll', 'watcher']);
+        ctx.mixin('runner', ['baseDir', 'options']);
         core_1.Container.setInstance(ctx);
         this.ctx = core_1.Container.getInstance();
     }
@@ -125,20 +128,27 @@ class Loader extends core_1.Container {
         (0, log_1.default)(this.ctx.pkg, this.ctx);
         this.catchError();
         this.listenMessage();
-        this.loadAllModule();
+        this.setPreService();
+        this.loadAllModules();
         this.checkUpdate();
     }
     handleError(err, prefix) {
         if (!(err instanceof core_1.KotoriError)) {
-            this.ctx.logger.label(prefix).error(err);
+            if (err instanceof Error) {
+                this.ctx.logger.label(prefix).error(err.message, err.stack);
+            }
+            else {
+                this.ctx.logger.label(prefix).error(err);
+            }
             return;
         }
-        ({
-            DatabaseError: () => this.ctx.logger.label('database').warn(err.message, err.stack),
-            ModuleError: () => this.ctx.logger.label('module').error(err.message, err.stack),
-            UnknownError: () => this.ctx.logger.error(err.name, err.stack),
-            DevError: () => this.ctx.logger.label('error').debug(err.name, err.stack)
-        })[err.name]();
+        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'));
@@ -174,31 +184,24 @@ class Loader extends core_1.Container {
                         msg = `dispose completed about ${address}`;
                 }
             }
-            this.ctx.logger.label([adapter.platform, adapter.identity])[normal ? 'info' : 'warn'](msg);
+            adapter.ctx.logger[normal ? 'info' : 'warn'](msg);
         });
         this.ctx.on('status', (data) => {
             const { status, adapter } = data;
-            this.ctx.logger.label([adapter.platform, adapter.identity]).info(status);
+            adapter.ctx.logger.info(status);
         });
         this.ctx.on('ready_module', (data) => {
-            if (!data.module || typeof data.module === 'string')
+            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 } = data.module.pkg;
-            if (data.error) {
-                this.failLoadCount += 1;
-                this.ctx.logger.warn(`failed to load module ${name}`);
-                if (data.error instanceof core_1.KotoriError) {
-                    process.emit('uncaughtExceptionMonitor', data.error);
-                }
-                else {
-                    this.ctx.logger.warn(data.error);
-                }
-            }
-            else {
-                this.ctx.logger.info(`loaded module ${name} version: ${version} ${Array.isArray(author) ? `authors: ${author.join(',')}` : `author: ${author}`}`);
-            }
-            const requiredVersion = data.module.pkg.peerDependencies['kotori-bot'];
+            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)) {
@@ -208,18 +211,21 @@ class Loader extends core_1.Container {
                     this.ctx.logger.error(`unsupported module version: ${requiredVersion}`);
                 }
             }
-            if (this.loadCount !== this.ctx.get('runner')[core_1.Symbols.modules].size)
-                return;
-            this.ctx.logger.info(`loaded ${this.loadCount - this.failLoadCount} modules successfully${this.failLoadCount > 0 ? `, failed to load ${this.failLoadCount} modules` : ''} `);
-            this.loadAllService();
-            this.ctx.emit('ready');
         });
     }
-    loadAllModule() {
-        this.ctx.useAll();
+    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()));
     }
-    loadAllService() {
-        /* load database before adapters */
+    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];
@@ -228,19 +234,18 @@ class Loader extends core_1.Container {
                 this.ctx.logger.warn(`cannot find adapter '${botConfig.extends}' for ${botName}`);
                 return;
             }
-            const isSchema = array[1]?.parseSafe(botConfig);
-            if (isSchema && !isSchema.value)
-                return;
-            /* adapter donot support hot reload, so no extends for context */
-            const bot = new array[0](this.ctx, isSchema ? isSchema.data : botConfig, botName);
+            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());
         });
-        /* load custom services after adapters */
     }
     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')
+            .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.warn(`detection update failed`);

package/lib/log.js

@@ -11,6 +11,7 @@ function loadInfo(info, ctx) {
 ██║  ██╗╚██████╔╝   ██║   ╚██████╔╝██║  ██║██║
 ╚═╝  ╚═╝ ╚═════╝    ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚═╝
 `);
+    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`);

package/lib/runner.d.ts

@@ -1,7 +1,8 @@
-import { Context, ModuleConfig, ModuleInstance, Symbols } from '@kotori-bot/core';
+import { Context, LocaleType, ModuleConfig, Symbols } from '@kotori-bot/core';
 interface BaseDir {
     root: string;
     modules: string;
+    data: string;
     logs: string;
 }
 interface Options {
@@ -11,19 +12,44 @@ 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]: Set<[ModuleInstance, ModuleConfig]>;
+    readonly [Symbols.modules]: Map<string, [ModuleMeta, ModuleConfig]>;
     constructor(ctx: Context, config: RunnerConfig);
     private getDirFiles;
     private getModuleRootDir;
     private getModuleList;
-    private moduleQuick;
-    useAll(): void;
+    private loadEx;
+    private unloadEx;
+    loadAll(): void;
     watcher(): void;
 }
 export default Runner;

package/lib/runner.js

@@ -30,14 +30,15 @@ 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 = __importStar(require("@kotori-bot/logger"));
+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]{3,13})\b/),
+    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(),
@@ -74,29 +75,22 @@ class Runner {
     options;
     ctx;
     isDev;
-    [core_1.Symbols.modules] = new Set();
+    [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';
-        if (this.isDev)
-            this.watcher();
         const loggerOptions = {
             level: this.isDev ? logger_1.LoggerLevel.TRACE : logger_1.LoggerLevel.INFO,
             label: [],
-            transports: new logger_1.ConsoleTransport()
+            transports: [
+                new logger_1.ConsoleTransport(),
+                new logger_1.FileTransport({ dir: this.baseDir.logs, filter: (data) => data.level >= logger_1.LoggerLevel.WARN })
+            ]
         };
-        const logger = Object.assign(new logger_1.default(), { ctx: this.ctx });
-        ctx.provide('logger', logger.extends(new Proxy(loggerOptions, {
-            get: (target, prop, receiver) => {
-                if (prop === 'label') {
-                    return logger.ctx.identity ? [logger.ctx.identity, ...target.label] : target.label;
-                }
-                return Reflect.get(target, prop, receiver);
-            }
-        })));
+        ctx.provide('logger', new logger_2.default(loggerOptions, this.ctx));
         ctx.inject('logger');
     }
     getDirFiles(rootDir) {
@@ -154,28 +148,56 @@ class Runner {
                 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].add([
-                { pkg, main, files },
+            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)] || {}
             ]);
         });
     }
-    moduleQuick(instance, config) {
-        this.ctx.use(instance, config);
+    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 });
     }
-    useAll() {
+    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.moduleQuick(...el));
+            .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.ctx.dispose(data[0]);
-            this.moduleQuick(...data);
+            this.unloadEx(data[0]);
+            this.loadEx(...data);
         })));
     }
 }

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,14 +1,10 @@
 {
   "name": "@kotori-bot/loader",
-  "version": "v1.3.0",
+  "version": "1.4.1",
   "description": "Loader For KotoriBot",
   "license": "GPL-3.0",
   "main": "lib/index.js",
   "author": "Hotaru <biyuehuya@gmail.com>",
-  "dependencies": {
-    "@kotori-bot/core": "^v1.2.0",
-    "@kotori-bot/logger": "^v1.1.1"
-  },
   "keywords": [
     "kotori",
     "chatbot",
@@ -26,5 +22,19 @@
     "type": "git",
     "url": "git+https://github.com/kotorijs/kotori.git"
   },
-  "homepage": "https://kotori.js.org"
+  "homepage": "https://kotori.js.org",
+  "dependencies": {
+    "express": "^4.18.2",
+    "knex": "^3.1.0",
+    "sqlite3": "^5.1.7",
+    "@kotori-bot/core": "^1.3.0",
+    "@kotori-bot/logger": "^1.2.0"
+  },
+  "devDependencies": {
+    "@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"
+  }
 }