alemonjs 2.1.0-alpha.26 → 2.1.0-alpha.27

package/lib/cbp/platform.js

@@ -0,0 +1,170 @@
+import { WebSocket } from 'ws';
+import { ResultCode } from '../core/code.js';
+import { deviceId, DEVICE_ID_HEADER, USER_AGENT_HEADER, reconnectInterval } from './config.js';
+import * as flattedJSON from 'flatted';
+import { useHeartbeat } from './connect.js';
+
+/**
+ * CBP 平台端
+ * @param url
+ * @param options
+ * @returns
+ */
+const cbpPlatform = (url, options = {
+    open: () => { }
+}) => {
+    if (global.chatbotPlatform) {
+        delete global.chatbotPlatform;
+    }
+    const { open = () => { } } = options;
+    const [heartbeatControl] = useHeartbeat({
+        ping: () => {
+            global?.chatbotPlatform?.ping?.();
+        },
+        isConnected: () => {
+            return global?.chatbotPlatform && global?.chatbotPlatform?.readyState === WebSocket.OPEN;
+        },
+        terminate: () => {
+            try {
+                global?.chatbotPlatform?.terminate?.();
+            }
+            catch (error) {
+                logger.debug({
+                    code: ResultCode.Fail,
+                    message: '强制断开连接失败',
+                    data: error
+                });
+            }
+        }
+    });
+    /**
+     * 发送数据
+     * @param data
+     */
+    const send = (data) => {
+        if (global.chatbotPlatform && global.chatbotPlatform.readyState === WebSocket.OPEN) {
+            data.DeviceId = deviceId; // 设置设备 ID
+            global.chatbotPlatform.send(flattedJSON.stringify(data));
+        }
+    };
+    const actionReplys = [];
+    const apiReplys = [];
+    /**
+     * 消费数据
+     * @param data
+     * @param payload
+     */
+    const replyAction = (data, payload) => {
+        if (global.chatbotPlatform && global.chatbotPlatform.readyState === WebSocket.OPEN) {
+            // 透传消费。也就是对应的设备进行处理消费。
+            global.chatbotPlatform.send(flattedJSON.stringify({
+                action: data.action,
+                payload: payload,
+                actionId: data.actionId,
+                DeviceId: data.DeviceId
+            }));
+        }
+    };
+    const replyApi = (data, payload) => {
+        if (global.chatbotPlatform && global.chatbotPlatform.readyState === WebSocket.OPEN) {
+            // 透传消费。也就是对应的设备进行处理消费。
+            global.chatbotPlatform.send(flattedJSON.stringify({
+                action: data.action,
+                apiId: data.apiId,
+                DeviceId: data.DeviceId,
+                payload: payload
+            }));
+        }
+    };
+    /**
+     * 接收行为
+     * @param reply
+     */
+    const onactions = (reply) => {
+        actionReplys.push(reply);
+    };
+    /**
+     * 接收接口
+     */
+    const onapis = (reply) => {
+        apiReplys.push(reply);
+    };
+    /**
+     * 启动 WebSocket 连接
+     */
+    const start = () => {
+        global.chatbotPlatform = new WebSocket(url, {
+            headers: {
+                [USER_AGENT_HEADER]: 'platform',
+                [DEVICE_ID_HEADER]: deviceId
+            }
+        });
+        global.chatbotPlatform.on('open', () => {
+            open();
+            heartbeatControl.start(); // 启动心跳
+        });
+        global.chatbotPlatform.on('pong', () => {
+            heartbeatControl.pong(); // 更新 pong 时间
+        });
+        global.chatbotPlatform.on('message', message => {
+            try {
+                const data = flattedJSON.parse(message.toString());
+                logger.debug({
+                    code: ResultCode.Ok,
+                    message: '平台端接收消息',
+                    data: data
+                });
+                if (data.apiId) {
+                    for (const cb of apiReplys) {
+                        cb(data, 
+                        // 传入一个消费函数
+                        val => replyApi(data, val));
+                    }
+                }
+                else if (data.actionId) {
+                    for (const cb of actionReplys) {
+                        cb(data, 
+                        // 传入一个消费函数
+                        val => replyAction(data, val));
+                    }
+                }
+            }
+            catch (error) {
+                logger.error({
+                    code: ResultCode.Fail,
+                    message: '解析消息失败',
+                    data: error
+                });
+            }
+        });
+        global.chatbotPlatform.on('close', err => {
+            heartbeatControl.stop(); // 停止心跳
+            logger.warn({
+                code: ResultCode.Fail,
+                message: '平台端连接关闭，尝试重新连接...',
+                data: err
+            });
+            delete global.chatbotPlatform;
+            // 重新连接逻辑
+            setTimeout(() => {
+                start(); // 重新连接
+            }, reconnectInterval); // 6秒后重连
+        });
+        global.chatbotPlatform.on('error', err => {
+            logger.error({
+                code: ResultCode.Fail,
+                message: '平台端错误',
+                data: err
+            });
+        });
+    };
+    start();
+    const client = {
+        send,
+        onactions,
+        onapis
+    };
+    return client;
+};
+
+export { cbpPlatform };

package/lib/cbp/router.js

@@ -1,7 +1,7 @@
 import KoaRouter from 'koa-router';
 
 const router = new KoaRouter({
-    prefix: '/'
+    prefix: '/api'
 });
 // 响应服务在线
 router.get('/online', ctx => {

package/lib/cbp/server.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CBP 服务器
+ * @param port
+ * @param listeningListener
+ */
+declare const cbpServer: (port: number, listeningListener?: () => void) => void;
+
+export { cbpServer };

package/lib/cbp/server.js

@@ -0,0 +1,451 @@
+import Koa from 'koa';
+import { WebSocketServer, WebSocket } from 'ws';
+import router from './router.js';
+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 { getConfig } from '../core/config.js';
+import * as flattedJSON from 'flatted';
+import { connectionTestOne } from './testone.js';
+
+/**
+ * CBP 服务器
+ * @param port
+ * @param listeningListener
+ */
+const cbpServer = (port, listeningListener) => {
+    if (global.chatbotServer) {
+        delete global.chatbotServer;
+    }
+    /**
+     * 获取重连时间
+     * @returns
+     */
+    const getReConnectTime = () => {
+        const time = 1000 * 1;
+        let curTime = time;
+        const mTime = (curTime / 1000 / 60).toFixed(2);
+        logger.info({
+            code: ResultCode.Fail,
+            message: `[ws-discord] 等待 ${mTime} 分钟后重新连接`,
+            data: null
+        });
+        return curTime;
+    };
+    /**
+     * 创建服务器
+     * @returns
+     */
+    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) => {
+                    // 指定的设备 处理消费。终端有记录每个客户端是谁
+                    if (childrenClient.has(DeviceId)) {
+                        const clientWs = childrenClient.get(DeviceId);
+                        if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                            // 发送消息到指定的子客户端
+                            clientWs.send(message);
+                        }
+                        else {
+                            // 如果连接已关闭，删除该客户端
+                            childrenClient.delete(DeviceId);
+                        }
+                    }
+                    else if (fullClient.has(DeviceId)) {
+                        const clientWs = fullClient.get(DeviceId);
+                        if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                            // 发送消息到指定的全量客户端
+                            clientWs.send(message);
+                        }
+                        else {
+                            // 如果连接已关闭，删除该客户端
+                            fullClient.delete(DeviceId);
+                        }
+                    }
+                };
+                // 处理 action
+                const handleAction = (DeviceId, message) => {
+                    if (childrenClient.has(DeviceId)) {
+                        const clientWs = childrenClient.get(DeviceId);
+                        if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                            // 发送消息到指定的子客户端
+                            clientWs.send(message);
+                        }
+                        else {
+                            // 如果连接已关闭，删除该客户端
+                            childrenClient.delete(DeviceId);
+                        }
+                    }
+                    else if (fullClient.has(DeviceId)) {
+                        const clientWs = fullClient.get(DeviceId);
+                        if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                            // 发送消息到指定的全量客户端
+                            clientWs.send(message);
+                        }
+                        else {
+                            // 如果连接已关闭，删除该客户端
+                            fullClient.delete(DeviceId);
+                        }
+                    }
+                };
+                // 处理事件
+                const handleEvent = (message, ID) => {
+                    // 全量客户端
+                    fullClient.forEach((clientWs, clientId) => {
+                        // 检查状态 并检查状态
+                        if (clientWs.readyState === WebSocket.OPEN) {
+                            clientWs.send(message);
+                        }
+                        else {
+                            // 如果连接已关闭，删除该客户端
+                            childrenClient.delete(clientId);
+                        }
+                    });
+                    // 根据所在群进行分流。
+                    // 确保同一个频道的消息。都流向同一个客户端。
+                    if (!ID) {
+                        logger.error({
+                            code: ResultCode.Fail,
+                            message: '消息缺少标识符 ID',
+                            data: null
+                        });
+                        return;
+                    }
+                    // 重新绑定并发送消息
+                    const reBind = () => {
+                        if (childrenClient.size === 0) {
+                            return;
+                        }
+                        else if (childrenClient.size === 1) {
+                            // 只有一个客户端，直接绑定
+                            const [bindId, clientWs] = childrenClient.entries().next().value;
+                            childrenBind.set(ID, bindId);
+                            clientWs.send(message);
+                            return;
+                        }
+                        // 有多个客户端，找到绑定最少的那个。
+                        // 如果大家都一样。就拿最近的第一个直接绑定。
+                        let minBindCount = Infinity;
+                        let bindId = null;
+                        childrenClient.forEach((_, id) => {
+                            const count = Array.from(childrenBind.values()).filter(v => v === id).length;
+                            if (count < minBindCount) {
+                                minBindCount = count;
+                                bindId = id;
+                            }
+                        });
+                        if (bindId) {
+                            const clientWs = childrenClient.get(bindId);
+                            if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                                // 进行绑定
+                                childrenBind.set(ID, bindId);
+                                // 发送消息到绑定的客户端
+                                clientWs.send(message);
+                            }
+                            else {
+                                // 如果连接已关闭，删除该客户端
+                                childrenClient.delete(bindId);
+                                // 重新进行绑定
+                                reBind();
+                            }
+                        }
+                        else {
+                            logger.error({
+                                code: ResultCode.Fail,
+                                message: '服务端出现意外，无法绑定客户端',
+                                data: null
+                            });
+                        }
+                    };
+                    // 判断该id是否被分配过
+                    if (!childrenBind.has(ID)) {
+                        // 进行绑定
+                        reBind();
+                        return;
+                    }
+                    const bindId = childrenBind.get(ID);
+                    if (!childrenClient.has(bindId)) {
+                        // 出现意外。
+                        // 重新进行绑定。
+                        reBind();
+                        return;
+                    }
+                    const clientWs = childrenClient.get(bindId);
+                    if (!clientWs || clientWs.readyState !== WebSocket.OPEN) {
+                        // 如果连接已关闭，删除该客户端
+                        childrenClient.delete(bindId);
+                        // 重新进行绑定
+                        reBind();
+                        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
+                    });
+                });
+            };
+            // 设置子客户端
+            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);
+                            }
+                        });
+                    }
+                });
+                // 处理关闭事件
+                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', () => {
+                    fullClient.delete(originId);
+                    logger.debug({
+                        code: ResultCode.Fail,
+                        message: `Client ${originId} disconnected`,
+                        data: null
+                    });
+                });
+            };
+            // 处理客户端连接
+            global.chatbotServer.on('connection', (ws, request) => {
+                // 测试平台的连接
+                if (request.url === '/testone') {
+                    if (!global.sandbox) {
+                        ws.close(4000, 'Sandbox mode required');
+                        return;
+                    }
+                    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);
+            });
+            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'
+                    });
+                }
+            });
+            chatbotServer.on('close', () => {
+                logger.info({
+                    code: ResultCode.Ok,
+                    message: 'WebSocket server closed',
+                    data: null
+                });
+                // 清理所有客户端连接
+                platformClient.clear();
+                childrenClient.clear();
+                fullClient.clear();
+            });
+        }
+        catch (error) {
+            logger.error({
+                code: ResultCode.FailInternal,
+                message: '创建 CBP 服务器失败',
+                data: error
+            });
+            return;
+        }
+    };
+    createServer();
+};
+
+export { cbpServer };