alemonjs 2.1.0-alpha.32 → 2.1.0-alpha.34

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 { USER_AGENT_HEADER, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, platformClient, childrenClient, fullClient, childrenBind } from './config.js';
+import { platformClient, childrenClient, fullClient, childrenBind, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER } 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 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 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 DeviceId = parsedMessage.DeviceId;
                     if (childrenClient.has(DeviceId)) {
                         const clientWs = childrenClient.get(DeviceId);
                         if (clientWs && clientWs.readyState === WebSocket.OPEN) {
@@ -81,10 +81,9 @@ const cbpServer = (port, listeningListener) => {
                             fullClient.delete(DeviceId);
                         }
                     }
-                }
-                else if (parsedMessage?.actionId) {
-                    // 指定的设备 处理消费。终端有记录每个客户端是谁
-                    const DeviceId = parsedMessage.DeviceId;
+                };
+                // 处理 action
+                const handleAction = (DeviceId, message) => {
                     if (childrenClient.has(DeviceId)) {
                         const clientWs = childrenClient.get(DeviceId);
                         if (clientWs && clientWs.readyState === WebSocket.OPEN) {
@@ -107,8 +106,9 @@ const cbpServer = (port, listeningListener) => {
                             fullClient.delete(DeviceId);
                         }
                     }
-                }
-                else if (parsedMessage?.name) {
+                };
+                // 处理事件
+                const handleEvent = (message, ID) => {
                     // 全量客户端
                     fullClient.forEach((clientWs, clientId) => {
                         // 检查状态 并检查状态
@@ -122,7 +122,6 @@ const cbpServer = (port, listeningListener) => {
                     });
                     // 根据所在群进行分流。
                     // 确保同一个频道的消息。都流向同一个客户端。
-                    const ID = parsedMessage.ChannelId || parsedMessage.GuildId || parsedMessage.DeviceId;
                     if (!ID) {
                         logger.error({
                             code: ResultCode.Fail,
@@ -199,151 +198,237 @@ const cbpServer = (port, listeningListener) => {
                         return;
                     }
                     clientWs.send(message);
-                }
-            }
-            catch (error) {
-                logger.error({
-                    code: ResultCode.Fail,
-                    message: '服务端解析平台消息失败',
-                    data: error
+                };
+                // 得到平台客户端的消息
+                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;
+                    }
                 });
-                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', () => {
+                    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
+                    });
+                });
+            };
+            // 设置子客户端
+            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);
+                            }
+                        });
                     }
-                    else {
-                        // 如果连接已关闭，删除该平台客户端
-                        platformClient.delete(originId);
+                });
+                // 处理关闭事件
+                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);
+                            }
+                        });
                     }
                 });
-            }
-        });
-        // 处理关闭事件
-        ws.on('close', () => {
-            delete childrenClient[originId];
-            logger.debug({
-                code: ResultCode.Fail,
-                message: `Client ${originId} disconnected`,
-                data: null
+                // 处理关闭事件
+                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('error', err => {
-            logger.error({
-                code: ResultCode.Fail,
-                message: `Client ${originId} error`,
-                data: err
+            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'
+                    });
+                }
             });
-        });
-    };
-    // 全量客户端
-    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);
-                    }
+            chatbotServer.on('close', () => {
+                logger.info({
+                    code: ResultCode.Ok,
+                    message: 'WebSocket server closed',
+                    data: null
                 });
-            }
-        });
-        // 处理关闭事件
-        ws.on('close', () => {
-            delete fullClient[originId];
-            logger.debug({
-                code: ResultCode.Fail,
-                message: `Client ${originId} disconnected`,
-                data: null
+                // 清理所有客户端连接
+                platformClient.clear();
+                childrenClient.clear();
+                fullClient.clear();
             });
-        });
-    };
-    // 处理客户端连接
-    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;
         }
-        logger.debug({
-            code: ResultCode.Ok,
-            message: `Client ${originId} connected`,
-            data: null
-        });
-        // 根据来源进行分类
-        if (origin === 'platform') {
-            setPlatformClient(originId, ws);
-            return;
-        }
-        // 连接时，需要给客户端发送主动消息
-        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);
+        catch (error) {
+            logger.error({
+                code: ResultCode.FailInternal,
+                message: '创建 CBP 服务器失败',
+                data: error
+            });
             return;
         }
-        setChildrenClient(originId, ws);
-    });
+    };
+    createServer();
 };
 
 export { cbpServer };

package/lib/cbp/router.js

@@ -7,6 +7,9 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const mainDirMap = new Map();
 const formatPath = (path) => {
+    if (!path || path === '/') {
+        return '/index.html';
+    }
     const pates = path.split('/');
     const lastPath = pates[pates.length - 1];
     if (lastPath.includes('.')) {
@@ -15,6 +18,30 @@ const formatPath = (path) => {
     path += '.html';
     return path;
 };
+// 输入一个文件路径。
+const getModuelFile = (dir) => {
+    const dirMap = {
+        '.js': `${dir}.js`,
+        '.jsx': `${dir}.jsx`,
+        '.mjs': `${dir}.mjs`,
+        '.cjs': `${dir}.cjs`,
+        '/index.js': `${dir}/index.js`,
+        '/index.jsx': `${dir}/index.jsx`,
+        '/index.mjs': `${dir}/index.mjs`,
+        '/index.cjs': `${dir}/index.cjs`,
+        '.ts': `${dir}.ts`,
+        '.tsx': `${dir}.tsx`,
+        '/index.ts': `${dir}/index.ts`,
+        '/index.tsx': `${dir}/index.tsx`
+    };
+    for (const key in dirMap) {
+        const filePath = dirMap[key];
+        if (existsSync(filePath) && fs.statSync(filePath)) {
+            return filePath;
+        }
+    }
+    return '';
+};
 const router = new KoaRouter({
     prefix: '/'
 });
@@ -27,7 +54,7 @@ router.get('api/online', ctx => {
         data: null
     };
 });
-router.get('app/{*path}', async (ctx) => {
+router.all('app/{*path}', async (ctx) => {
     if (!process.env.input) {
         ctx.status = 400;
         ctx.body = {
@@ -38,7 +65,8 @@ router.get('app/{*path}', async (ctx) => {
         return;
     }
     const rootPath = process.cwd();
-    if (ctx.path.startsWith(`/app/api`)) {
+    const apiPath = `/app/api`;
+    if (ctx.path.startsWith(apiPath)) {
         let mainPath = join(rootPath, process.env.input);
         // 路径
         if (!existsSync(mainPath)) {
@@ -46,27 +74,43 @@ router.get('app/{*path}', async (ctx) => {
             ctx.body = {
                 code: 400,
                 message: '未找到主要入口文件',
-                data: null
+                data: 'existsSync input'
             };
             return;
         }
         const mainDir = dirname(mainPath);
         try {
-            const dir = join(mainDir, 'route', ctx.path);
-            if (!existsSync(dir)) {
+            const dir = join(mainDir, 'route', ctx.path?.replace(apiPath, '/api') || '');
+            const dirs = dir.split('/');
+            const fileName = dirs[dirs.length - 1];
+            if (fileName.includes('.')) {
                 ctx.status = 404;
                 ctx.body = {
                     code: 404,
-                    message: `API 'route/${ctx.path}' 未找到。`,
-                    data: null
+                    message: `API '${ctx.path}' 未找到。`,
+                    data: 'existsSync route filename'
                 };
                 return;
             }
-            const apiModule = await import(dir);
-            await apiModule.default(ctx);
+            const modulePath = getModuelFile(dir);
+            if (!modulePath) {
+                ctx.status = 404;
+                ctx.body = {
+                    code: 404,
+                    message: `API '${ctx.path}' 未找到。`,
+                    data: 'existsSync modulePath'
+                };
+                return;
+            }
+            const apiModule = await import(modulePath);
+            if (!apiModule[ctx.method] || typeof apiModule[ctx.method] !== 'function') {
+                ctx.status = 405;
+                return;
+            }
+            await apiModule[ctx.method](ctx);
         }
         catch (err) {
-            console.error(`Error handling API request ${ctx.path}:`, err);
+            console.error(`Error handling API request ${ctx.path}`);
             ctx.status = 500;
             ctx.body = {
                 code: 500,
@@ -76,8 +120,27 @@ router.get('app/{*path}', async (ctx) => {
         }
         return;
     }
-    const resourcePath = formatPath(ctx.params?.path || 'index.html');
-    const fullPath = path.join(rootPath, resourcePath);
+    // 如果不是 get请求。即不响应
+    if (ctx.method !== 'GET') {
+        ctx.status = 405;
+        return;
+    }
+    let root = '';
+    const resourcePath = formatPath(ctx.params?.path);
+    try {
+        const pkg = require(path.join(rootPath, 'package.json')) || {};
+        root = pkg.alemonjs?.web?.root || '';
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = {
+            code: 500,
+            message: `加载 package.json 时发生错误。`,
+            error: err.message
+        };
+        return;
+    }
+    const fullPath = root ? path.join(rootPath, root, resourcePath) : path.join(rootPath, resourcePath);
     try {
         // 返回文件
         const file = await fs.promises.readFile(fullPath);
@@ -87,7 +150,7 @@ router.get('app/{*path}', async (ctx) => {
         ctx.status = 200;
     }
     catch (err) {
-        if (err.status === 404) {
+        if (err?.status === 404) {
             ctx.status = 404;
             ctx.body = {
                 code: 404,
@@ -105,11 +168,14 @@ router.get('app/{*path}', async (ctx) => {
         }
     }
 });
-router.get('apps/:app/{*path}', async (ctx) => {
+router.all('app', async (ctx) => {
+    ctx.redirect('/app/');
+    return;
+});
+router.all('apps/:app/{*path}', async (ctx) => {
     const appName = ctx.params.app;
-    const rootPath = process.cwd();
-    const apiDir = `/apps/${appName}/api`;
-    if (ctx.path.startsWith(apiDir)) {
+    const apiPath = `/apps/${appName}/api`;
+    if (ctx.path.startsWith(apiPath)) {
         try {
             if (!mainDirMap.has(appName)) {
                 const mainPath = require.resolve(appName);
@@ -126,12 +192,37 @@ router.get('apps/:app/{*path}', async (ctx) => {
                 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);
+            const dir = join(mainDirMap.get(appName), 'route', ctx.path?.replace(apiPath, '/api') || '');
+            const dirs = dir.split('/');
+            const fileName = dirs[dirs.length - 1];
+            if (fileName.includes('.')) {
+                ctx.status = 404;
+                ctx.body = {
+                    code: 404,
+                    message: `API 'route/${ctx.path}' 未找到。`,
+                    data: null
+                };
+                return;
+            }
+            const modulePath = getModuelFile(dir);
+            if (!modulePath) {
+                ctx.status = 404;
+                ctx.body = {
+                    code: 404,
+                    message: `API 'route/${ctx.path}' 未找到。`,
+                    data: null
+                };
+                return;
+            }
+            const apiModule = await import(modulePath);
+            if (!apiModule[ctx.method] || typeof apiModule[ctx.method] !== 'function') {
+                ctx.status = 405;
+                return;
+            }
+            await apiModule[ctx.method](ctx);
         }
         catch (err) {
-            logger.warn(`Error handling API request ${ctx.path}:`, err?.message || '');
+            logger.warn(`Error request ${ctx.path}:`, err?.message || '');
             ctx.status = 500;
             ctx.body = {
                 code: 500,
@@ -141,8 +232,28 @@ router.get('apps/:app/{*path}', async (ctx) => {
         }
         return;
     }
-    const resourcePath = formatPath(ctx.params?.path || 'index.html');
-    const fullPath = path.join(rootPath, 'packages', appName, resourcePath);
+    // 如果不是 get请求。即不响应
+    if (ctx.method !== 'GET') {
+        ctx.status = 405;
+        return;
+    }
+    const rootPath = path.join(process.cwd(), 'packages', appName);
+    const resourcePath = formatPath(ctx.params?.path);
+    let root = '';
+    try {
+        const pkg = require(`${appName}/package`) || {};
+        root = pkg?.alemonjs?.web?.root || '';
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = {
+            code: 500,
+            message: `加载 package.json 时发生错误。`,
+            error: err.message
+        };
+        return;
+    }
+    const fullPath = root ? path.join(rootPath, root, resourcePath) : path.join(rootPath, resourcePath);
     try {
         // 返回文件
         const file = await fs.promises.readFile(fullPath);
@@ -152,7 +263,7 @@ router.get('apps/:app/{*path}', async (ctx) => {
         ctx.status = 200;
     }
     catch (err) {
-        if (err.status === 404) {
+        if (err?.status === 404) {
             ctx.status = 404;
             ctx.body = {
                 code: 404,
@@ -161,15 +272,21 @@ router.get('apps/:app/{*path}', async (ctx) => {
             };
         }
         else {
+            logger.warn(`Error request ${ctx.path}:`, err?.message || '');
             ctx.status = 500;
             ctx.body = {
                 code: 500,
                 message: `加载子应用 '${appName}' 资源时发生服务器错误。`,
                 error: err.message
             };
-            logger.warn(`Error handling API request ${ctx.path}:`, err?.message || '');
         }
     }
 });
+router.all('apps/:name', async (ctx) => {
+    if (ctx.path === `/apps/${ctx.params.name}`) {
+        ctx.redirect(`/apps/${ctx.params.name}/`);
+        return;
+    }
+});
 
 export { router as default };

package/lib/typing/event/map.js

@@ -0,0 +1,20 @@
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.0-alpha.32",
+  "version": "2.1.0-alpha.34",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",