alemonjs 2.1.0-alpha.30 → 2.1.0-alpha.32

package/lib/cbp/index.js

@@ -1,64 +1,64 @@
 import Koa from 'koa';
 import { WebSocketServer, WebSocket } from 'ws';
 import router from './router.js';
+import koaStatic from 'koa-static';
 import koaCors from '@koa/cors';
 import { ResultCode } from '../core/code.js';
-import { platformClient, childrenClient, fullClient, childrenBind, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER } from './config.js';
+import { USER_AGENT_HEADER, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, platformClient, childrenClient, fullClient, childrenBind } from './config.js';
 import { getConfig } from '../core/config.js';
 import * as flattedJSON from 'flatted';
-import { connectionTestOne } from './testone.js';
 
-function getReConnectTime() {
-    const time = 1000 * 1;
-    const curTime = time;
-    const mTime = (curTime / 1000 / 60).toFixed(2);
-    logger.info({
-        code: ResultCode.Fail,
-        message: `[ws-discord] 等待 ${mTime} 分钟后重新连接`,
-        data: null
-    });
-    return curTime;
-}
 const cbpServer = (port, listeningListener) => {
     if (global.chatbotServer) {
         delete global.chatbotServer;
     }
-    const createServer = () => {
-        try {
-            // create
-            const app = new Koa();
-            // MessageRouter
-            app.use(router.routes());
-            app.use(router.allowedMethods());
-            // Cors
-            app.use(koaCors({
-                origin: '*', // 允许所有来源
-                allowMethods: ['GET', 'POST', 'PUT', 'DELETE'] // 允许的 HTTP 方法
-            }));
-            const server = app.listen(port, listeningListener);
-            // 创建 WebSocketServer 并监听同一个端口
-            global.chatbotServer = new WebSocketServer({ server });
-            /**
-             *
-             * @param originId
-             * @param ws
-             */
-            const setPlatformClient = (originId, ws) => {
-                // 仅允许有一个平台连接
-                if (platformClient.size > 0) {
-                    logger.error({
-                        code: ResultCode.Fail,
-                        message: `平台连接已存在: ${originId}`,
-                        data: null
-                    });
-                    ws.close(); // 关闭新连接
-                    return;
-                }
-                // 设置平台客户端
-                platformClient.set(originId, ws);
-                // 处理api
-                const handleApi = (DeviceId, message) => {
+    const app = new Koa();
+    app.use(router.routes());
+    app.use(router.allowedMethods());
+    // 读取静态文件夹 gui
+    app.use(koaStatic('/gui'));
+    // 允许跨域
+    app.use(koaCors({
+        origin: '*', // 允许所有来源
+        allowMethods: ['GET', 'POST', 'PUT', 'DELETE'] // 允许的 HTTP 方法
+    }));
+    const server = app.listen(port, listeningListener);
+    // 创建 WebSocketServer 并监听同一个端口
+    global.chatbotServer = new WebSocketServer({ server });
+    /**
+     *
+     * @param originId
+     * @param ws
+     */
+    const setPlatformClient = (originId, ws) => {
+        // 仅允许有一个平台连接
+        if (platformClient.size > 0) {
+            logger.error({
+                code: ResultCode.Fail,
+                message: `平台连接已存在: ${originId}`,
+                data: null
+            });
+            ws.close(); // 关闭新连接
+            return;
+        }
+        // 设置平台客户端
+        platformClient.set(originId, ws);
+        // 得到平台客户端的消息
+        ws.on('message', (message) => {
+            try {
+                // 解析消息
+                const parsedMessage = flattedJSON.parse(message.toString());
+                // 1. 解析得到 actionId ，说明是消费行为请求。要广播告诉所有客户端。
+                // 2. 解析得到 name ，说明是一个事件请求。
+                // 3. 解析得到 apiId ，说明是一个接口请求。
+                logger.debug({
+                    code: ResultCode.Ok,
+                    message: '服务端接收到消息',
+                    data: parsedMessage
+                });
+                if (parsedMessage.apiId) {
                     // 指定的设备 处理消费。终端有记录每个客户端是谁
+                    const DeviceId = parsedMessage.DeviceId;
                     if (childrenClient.has(DeviceId)) {
                         const clientWs = childrenClient.get(DeviceId);
                         if (clientWs && clientWs.readyState === WebSocket.OPEN) {
@@ -81,9 +81,10 @@ const cbpServer = (port, listeningListener) => {
                             fullClient.delete(DeviceId);
                         }
                     }
-                };
-                // 处理 action
-                const handleAction = (DeviceId, message) => {
+                }
+                else if (parsedMessage?.actionId) {
+                    // 指定的设备 处理消费。终端有记录每个客户端是谁
+                    const DeviceId = parsedMessage.DeviceId;
                     if (childrenClient.has(DeviceId)) {
                         const clientWs = childrenClient.get(DeviceId);
                         if (clientWs && clientWs.readyState === WebSocket.OPEN) {
@@ -106,9 +107,8 @@ const cbpServer = (port, listeningListener) => {
                             fullClient.delete(DeviceId);
                         }
                     }
-                };
-                // 处理事件
-                const handleEvent = (message, ID) => {
+                }
+                else if (parsedMessage?.name) {
                     // 全量客户端
                     fullClient.forEach((clientWs, clientId) => {
                         // 检查状态 并检查状态
@@ -122,6 +122,7 @@ const cbpServer = (port, listeningListener) => {
                     });
                     // 根据所在群进行分流。
                     // 确保同一个频道的消息。都流向同一个客户端。
+                    const ID = parsedMessage.ChannelId || parsedMessage.GuildId || parsedMessage.DeviceId;
                     if (!ID) {
                         logger.error({
                             code: ResultCode.Fail,
@@ -198,237 +199,151 @@ const cbpServer = (port, listeningListener) => {
                         return;
                     }
                     clientWs.send(message);
-                };
-                // 得到平台客户端的消息
-                ws.on('message', (message) => {
-                    try {
-                        // 解析消息
-                        const parsedMessage = flattedJSON.parse(message.toString());
-                        // 1. 解析得到 actionId ，说明是消费行为请求。要广播告诉所有客户端。
-                        // 2. 解析得到 name ，说明是一个事件请求。
-                        // 3. 解析得到 apiId ，说明是一个接口请求。
-                        // 4. 解析得到 testID ，说明是一个测试请求。
-                        logger.debug({
-                            code: ResultCode.Ok,
-                            message: '服务端接收到消息',
-                            data: parsedMessage
-                        });
-                        if (parsedMessage.apiId) {
-                            // 指定的设备 处理消费。终端有记录每个客户端是谁
-                            const DeviceId = parsedMessage.DeviceId;
-                            handleApi(DeviceId, message);
-                        }
-                        else if (parsedMessage?.actionId) {
-                            // 指定的设备 处理消费。终端有记录每个客户端是谁
-                            const DeviceId = parsedMessage.DeviceId;
-                            handleAction(DeviceId, message);
-                        }
-                        else if (parsedMessage?.name) {
-                            const ID = parsedMessage.ChannelId || parsedMessage.GuildId || parsedMessage.DeviceId;
-                            handleEvent(message, ID);
-                        }
-                        else if (parsedMessage?.testID) {
-                            // 继续解析数据。测试请求。
-                        }
-                    }
-                    catch (error) {
-                        logger.error({
-                            code: ResultCode.Fail,
-                            message: '服务端解析平台消息失败',
-                            data: error
-                        });
-                        return;
-                    }
-                });
-                // 处理关闭事件
-                ws.on('close', () => {
-                    platformClient.delete(originId);
-                    logger.debug({
-                        code: ResultCode.Fail,
-                        message: `Client ${originId} disconnected`,
-                        data: null
-                    });
-                });
-                ws.on('error', err => {
-                    logger.error({
-                        code: ResultCode.Fail,
-                        message: `Client ${originId} error`,
-                        data: err
-                    });
+                }
+            }
+            catch (error) {
+                logger.error({
+                    code: ResultCode.Fail,
+                    message: '服务端解析平台消息失败',
+                    data: error
                 });
-            };
-            // 设置子客户端
-            const setChildrenClient = (originId, ws) => {
-                childrenClient.set(originId, ws);
-                // 得到子客户端的消息。只会是actions请求。
-                ws.on('message', (message) => {
-                    // tudo
-                    // 为什么 子客户端的行为，不携带目标平台的 DeviceId？
-                    // 导致无法进行多个平台连接。
-                    if (platformClient.size > 0) {
-                        platformClient.forEach((platformWs, platformId) => {
-                            // 检查平台客户端状态
-                            if (platformWs.readyState === WebSocket.OPEN) {
-                                platformWs.send(message);
-                            }
-                            else {
-                                // 如果连接已关闭，删除该平台客户端
-                                platformClient.delete(platformId);
-                            }
-                        });
+                return;
+            }
+        });
+        // 处理关闭事件
+        ws.on('close', () => {
+            delete platformClient[originId];
+            logger.debug({
+                code: ResultCode.Fail,
+                message: `Client ${originId} disconnected`,
+                data: null
+            });
+        });
+        ws.on('error', err => {
+            logger.error({
+                code: ResultCode.Fail,
+                message: `Client ${originId} error`,
+                data: err
+            });
+        });
+    };
+    // 设置子客户端
+    const setChildrenClient = (originId, ws) => {
+        childrenClient.set(originId, ws);
+        // 得到子客户端的消息。只会是actions请求。
+        ws.on('message', (message) => {
+            // tudo
+            // 为什么 子客户端的行为，不携带目标平台的 DeviceId？
+            // 导致无法进行多个平台连接。
+            if (platformClient.size > 0) {
+                platformClient.forEach(platformWs => {
+                    // 检查平台客户端状态
+                    if (platformWs.readyState === WebSocket.OPEN) {
+                        platformWs.send(message);
                     }
-                });
-                // 处理关闭事件
-                ws.on('close', () => {
-                    childrenClient.delete(originId);
-                    logger.debug({
-                        code: ResultCode.Fail,
-                        message: `Client ${originId} disconnected`,
-                        data: null
-                    });
-                });
-                ws.on('error', err => {
-                    logger.error({
-                        code: ResultCode.Fail,
-                        message: `Client ${originId} error`,
-                        data: err
-                    });
-                });
-            };
-            // 全量客户端
-            const setFullClient = (originId, ws) => {
-                fullClient.set(originId, ws);
-                // 处理消息事件
-                ws.on('message', (message) => {
-                    // tudo
-                    // 为什么 子客户端的行为，不携带目标平台的 DeviceId？
-                    // 导致无法进行多个平台连接。
-                    if (platformClient.size > 0) {
-                        platformClient.forEach((platformWs, platformId) => {
-                            // 检查平台客户端状态
-                            if (platformWs.readyState === WebSocket.OPEN) {
-                                platformWs.send(message);
-                            }
-                            else {
-                                // 如果连接已关闭，删除该平台客户端
-                                platformClient.delete(platformId);
-                            }
-                        });
+                    else {
+                        // 如果连接已关闭，删除该平台客户端
+                        platformClient.delete(originId);
                     }
                 });
-                // 处理关闭事件
-                ws.on('close', () => {
-                    fullClient.delete(originId);
-                    logger.debug({
-                        code: ResultCode.Fail,
-                        message: `Client ${originId} disconnected`,
-                        data: null
-                    });
-                });
-            };
-            // 处理客户端连接
-            global.chatbotServer.on('connection', (ws, request) => {
-                // 测试平台的连接
-                if (request.url === '/testone') {
-                    connectionTestOne(ws, request);
-                    return;
-                }
-                // 读取请求头中的 来源
-                const headers = request.headers;
-                const origin = headers[USER_AGENT_HEADER] || USER_AGENT_HEADER_VALUE_MAP.client;
-                // 来源id
-                const originId = headers[DEVICE_ID_HEADER];
-                if (!originId) {
-                    // 如果没有来源 ID，拒绝连接
-                    ws.close(4000, 'Missing Device ID');
-                    return;
-                }
-                logger.debug({
-                    code: ResultCode.Ok,
-                    message: `Client ${originId} connected`,
-                    data: null
-                });
-                // 根据来源进行分类
-                if (origin === USER_AGENT_HEADER_VALUE_MAP.platform) {
-                    setPlatformClient(originId, ws);
-                    return;
-                }
-                else if (origin === USER_AGENT_HEADER_VALUE_MAP.client) {
-                    // 连接时，需要给客户端发送主动消息
-                    ws.send(flattedJSON.stringify({
-                        active: 'sync',
-                        payload: {
-                            value: getConfig().value,
-                            args: getConfig().argv,
-                            package: {
-                                version: getConfig().package?.version
-                            },
-                            env: {
-                                login: process.env.login,
-                                platform: process.env.platform,
-                                port: process.env.port
-                            }
-                        },
-                        // 主动消息
-                        activeId: originId
-                    }));
-                }
-                const isFullReceive = headers[FULL_RECEIVE_HEADER] === '1';
-                // 如果是全量接收
-                if (isFullReceive) {
-                    setFullClient(originId, ws);
-                    return;
-                }
-                setChildrenClient(originId, ws);
+            }
+        });
+        // 处理关闭事件
+        ws.on('close', () => {
+            delete childrenClient[originId];
+            logger.debug({
+                code: ResultCode.Fail,
+                message: `Client ${originId} disconnected`,
+                data: null
             });
-            chatbotServer.on('error', (err) => {
-                // 清理所有客户端连接
-                platformClient.clear();
-                childrenClient.clear();
-                fullClient.clear();
-                // 发现是端口已经被占用
-                if (err.code === 'EADDRINUSE') {
-                    logger.error({
-                        code: ResultCode.FailInternal,
-                        message: `端口 ${port} 已被占用，请检查是否有其他服务在运行`,
-                        data: err.message
-                    });
-                    const reCreateTime = getReConnectTime();
-                    // 清理所有客户端连接，开始重新创建服务器
-                    setTimeout(() => {
-                        createServer();
-                    }, reCreateTime);
-                }
-                else {
-                    logger.error({
-                        code: ResultCode.FailInternal,
-                        message: 'WebSocket server error',
-                        data: err.message || 'Unknown error'
-                    });
-                }
+        });
+        ws.on('error', err => {
+            logger.error({
+                code: ResultCode.Fail,
+                message: `Client ${originId} error`,
+                data: err
             });
-            chatbotServer.on('close', () => {
-                logger.info({
-                    code: ResultCode.Ok,
-                    message: 'WebSocket server closed',
-                    data: null
+        });
+    };
+    // 全量客户端
+    const setFullClient = (originId, ws) => {
+        fullClient.set(originId, ws);
+        // 处理消息事件
+        ws.on('message', (message) => {
+            // tudo
+            // 为什么 子客户端的行为，不携带目标平台的 DeviceId？
+            // 导致无法进行多个平台连接。
+            if (platformClient.size > 0) {
+                platformClient.forEach(platformWs => {
+                    // 检查平台客户端状态
+                    if (platformWs.readyState === WebSocket.OPEN) {
+                        platformWs.send(message);
+                    }
+                    else {
+                        // 如果连接已关闭，删除该平台客户端
+                        platformClient.delete(originId);
+                    }
                 });
-                // 清理所有客户端连接
-                platformClient.clear();
-                childrenClient.clear();
-                fullClient.clear();
+            }
+        });
+        // 处理关闭事件
+        ws.on('close', () => {
+            delete fullClient[originId];
+            logger.debug({
+                code: ResultCode.Fail,
+                message: `Client ${originId} disconnected`,
+                data: null
             });
+        });
+    };
+    // 处理客户端连接
+    global.chatbotServer.on('connection', (ws, request) => {
+        // 读取请求头中的 来源
+        const headers = request.headers;
+        const origin = headers[USER_AGENT_HEADER] || 'client';
+        // 来源id
+        const originId = headers[DEVICE_ID_HEADER];
+        if (!originId) {
+            // 如果没有来源 ID，拒绝连接
+            ws.close(4000, 'Missing Device ID');
+            return;
         }
-        catch (error) {
-            logger.error({
-                code: ResultCode.FailInternal,
-                message: '创建 CBP 服务器失败',
-                data: error
-            });
+        logger.debug({
+            code: ResultCode.Ok,
+            message: `Client ${originId} connected`,
+            data: null
+        });
+        // 根据来源进行分类
+        if (origin === 'platform') {
+            setPlatformClient(originId, ws);
             return;
         }
-    };
-    createServer();
+        // 连接时，需要给客户端发送主动消息
+        ws.send(flattedJSON.stringify({
+            active: 'sync',
+            payload: {
+                value: getConfig().value,
+                args: getConfig().argv,
+                package: {
+                    version: getConfig().package?.version
+                },
+                env: {
+                    login: process.env.login,
+                    platform: process.env.platform,
+                    port: process.env.port
+                }
+            },
+            // 主动消息
+            activeId: originId
+        }));
+        const isFullReceive = headers[FULL_RECEIVE_HEADER] === '1';
+        // 如果是全量接收
+        if (isFullReceive) {
+            setFullClient(originId, ws);
+            return;
+        }
+        setChildrenClient(originId, ws);
+    });
 };
 
 export { cbpServer };

package/lib/cbp/router.js

@@ -1,10 +1,25 @@
 import KoaRouter from 'koa-router';
+import fs, { existsSync } from 'fs';
+import path, { join, dirname } from 'path';
+import mime from 'mime-types';
+import { createRequire } from 'module';
 
+const require = createRequire(import.meta.url);
+const mainDirMap = new Map();
+const formatPath = (path) => {
+    const pates = path.split('/');
+    const lastPath = pates[pates.length - 1];
+    if (lastPath.includes('.')) {
+        return path;
+    }
+    path += '.html';
+    return path;
+};
 const router = new KoaRouter({
-    prefix: '/api'
+    prefix: '/'
 });
 // 响应服务在线
-router.get('/online', ctx => {
+router.get('api/online', ctx => {
     ctx.status = 200;
     ctx.body = {
         code: 200,
@@ -12,5 +27,149 @@ router.get('/online', ctx => {
         data: null
     };
 });
+router.get('app/{*path}', async (ctx) => {
+    if (!process.env.input) {
+        ctx.status = 400;
+        ctx.body = {
+            code: 400,
+            message: '没有主要入口文件',
+            data: null
+        };
+        return;
+    }
+    const rootPath = process.cwd();
+    if (ctx.path.startsWith(`/app/api`)) {
+        let mainPath = join(rootPath, process.env.input);
+        // 路径
+        if (!existsSync(mainPath)) {
+            ctx.status = 400;
+            ctx.body = {
+                code: 400,
+                message: '未找到主要入口文件',
+                data: null
+            };
+            return;
+        }
+        const mainDir = dirname(mainPath);
+        try {
+            const dir = join(mainDir, 'route', ctx.path);
+            if (!existsSync(dir)) {
+                ctx.status = 404;
+                ctx.body = {
+                    code: 404,
+                    message: `API 'route/${ctx.path}' 未找到。`,
+                    data: null
+                };
+                return;
+            }
+            const apiModule = await import(dir);
+            await apiModule.default(ctx);
+        }
+        catch (err) {
+            console.error(`Error handling API request ${ctx.path}:`, err);
+            ctx.status = 500;
+            ctx.body = {
+                code: 500,
+                message: `处理 API 请求时发生错误。`,
+                error: err.message
+            };
+        }
+        return;
+    }
+    const resourcePath = formatPath(ctx.params?.path || 'index.html');
+    const fullPath = path.join(rootPath, resourcePath);
+    try {
+        // 返回文件
+        const file = await fs.promises.readFile(fullPath);
+        const mimeType = mime.lookup(fullPath) || 'application/octet-stream';
+        ctx.set('Content-Type', mimeType); // 自动设置响应头
+        ctx.body = file;
+        ctx.status = 200;
+    }
+    catch (err) {
+        if (err.status === 404) {
+            ctx.status = 404;
+            ctx.body = {
+                code: 404,
+                message: `资源中未找到。`,
+                data: null
+            };
+        }
+        else {
+            ctx.status = 500;
+            ctx.body = {
+                code: 500,
+                message: `加载资源时发生服务器错误。`,
+                error: err.message
+            };
+        }
+    }
+});
+router.get('apps/:app/{*path}', async (ctx) => {
+    const appName = ctx.params.app;
+    const rootPath = process.cwd();
+    const apiDir = `/apps/${appName}/api`;
+    if (ctx.path.startsWith(apiDir)) {
+        try {
+            if (!mainDirMap.has(appName)) {
+                const mainPath = require.resolve(appName);
+                // 不存在 main
+                if (!existsSync(mainPath)) {
+                    ctx.status = 400;
+                    ctx.body = {
+                        code: 400,
+                        message: '未找到主要入口文件',
+                        data: null
+                    };
+                    return;
+                }
+                const mainDir = dirname(mainPath);
+                mainDirMap.set(appName, mainDir);
+            }
+            const dir = join(mainDirMap.get(appName), 'route', ctx.path?.replace(apiDir, '/api') || '');
+            const apiModule = await import(dir);
+            await apiModule.default(ctx);
+        }
+        catch (err) {
+            logger.warn(`Error handling API request ${ctx.path}:`, err?.message || '');
+            ctx.status = 500;
+            ctx.body = {
+                code: 500,
+                message: `处理 API 请求时发生错误。`,
+                error: err.message
+            };
+        }
+        return;
+    }
+    const resourcePath = formatPath(ctx.params?.path || 'index.html');
+    const fullPath = path.join(rootPath, 'packages', appName, resourcePath);
+    try {
+        // 返回文件
+        const file = await fs.promises.readFile(fullPath);
+        const mimeType = mime.lookup(fullPath) || 'application/octet-stream';
+        ctx.set('Content-Type', mimeType); // 自动设置响应头
+        ctx.body = file;
+        ctx.status = 200;
+    }
+    catch (err) {
+        if (err.status === 404) {
+            ctx.status = 404;
+            ctx.body = {
+                code: 404,
+                message: `资源 '${resourcePath}' 在子应用 '${appName}' 中未找到。`,
+                data: null
+            };
+        }
+        else {
+            ctx.status = 500;
+            ctx.body = {
+                code: 500,
+                message: `加载子应用 '${appName}' 资源时发生服务器错误。`,
+                error: err.message
+            };
+            logger.warn(`Error handling API request ${ctx.path}:`, err?.message || '');
+        }
+    }
+});
 
 export { router as default };

package/lib/cbp/testone.js

@@ -185,7 +185,6 @@ const connectionTestOne = (ws, _request) => {
             try {
                 const messages = JSON.parse(readFileSync(messagePath, 'utf-8'));
                 const updatedMessages = messages.filter((msg) => msg.CreateAt !== CreateAt);
-                console.log('updatedMessages', updatedMessages);
                 writeFile(messagePath, JSON.stringify(updatedMessages, null, 2), error => {
                     if (error) {
                         logger.error(`写入 ${type} 消息失败:`, error);

package/lib/global.d.ts

@@ -79,6 +79,7 @@ declare global {
             login?: string;
             platform?: string;
             port?: string;
+            input?: string;
             NODE_ENV?: 'development' | 'production';
         }
     }

package/lib/main.js

@@ -80,8 +80,8 @@ const start = async (options = {}) => {
         // 设置环境变量
         process.env.port = port;
         cbpServer(port, async () => {
-            console.log(`ws://127.0.0.1:${port}`);
             const url = `ws://127.0.0.1:${port}`;
+            logger.info(`[CBP server started at ${url}]`);
             const isFullReceive = options?.is_full_receive || cfg.argv?.is_full_receive || cfg.value?.is_full_receive || true;
             cbpClient(url, { isFullReceive });
             // 加载平台服务
@@ -121,6 +121,7 @@ const start = async (options = {}) => {
     }
     // 获取入口文件
     const input = options.input || cfg.argv?.input || cfg.value?.input || getInputExportPath();
+    process.env.input = input;
     // 运行本地模块
     run(input);
     // load module

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.0-alpha.30",
+  "version": "2.1.0-alpha.32",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",
@@ -31,10 +31,11 @@
     "commander": "^13.1.0",
     "file-type": "21.0.0",
     "flatted": "^3.3.3",
-    "koa": "^2.15.3",
-    "koa-router": "^13.0.1",
+    "koa": "^3.0.1",
+    "koa-router": "^14.0.0",
     "koa-static": "^5.0.0",
     "log4js": "^6.9.1",
+    "mime-types": "^3.0.1",
     "public-ip": "^7.0.1",
     "qrcode": "^1.5.4",
     "uuid": "11.1.0",
@@ -48,6 +49,7 @@
     "@types/koa-router": "^7.4.8",
     "@types/koa-static": "^4.0.4",
     "@types/koa__cors": "^5.0.0",
+    "@types/mime-types": "^3.0.1",
     "@types/uuid": "^10.0.0"
   },
   "bin": {

package/lib/typing/event/map.js

@@ -1,20 +0,0 @@
-const EventsKeyEnum = [
-    'message.create',
-    'message.update',
-    'message.delete',
-    'message.reaction.add',
-    'message.reaction.remove',
-    'private.message.create',
-    'private.message.update',
-    'private.message.delete',
-    'private.friend.add',
-    'private.guild.add',
-    'channal.create',
-    'channal.delete',
-    'guild.join',
-    'guild.exit',
-    'member.add',
-    'member.remove'
-];
-
-export { EventsKeyEnum };