koishi-plugin-msg-router 1.4.0 → 1.4.3

package/lib/index.d.ts

@@ -35,6 +35,7 @@ export interface ClientRouteConfig {
     heartbeatInterval: number;
     reconnectInterval: number;
     maxConcurrency: number;
+    maxConnections: number;
 }
 export interface ServerRouteConfig {
     name: string;
@@ -51,6 +52,7 @@ export interface ServerRouteConfig {
     heartbeatInterval: number;
     reconnectInterval: number;
     maxConcurrency: number;
+    maxConnections: number;
 }
 export type RouteConfig = ClientRouteConfig | ServerRouteConfig;
 export interface Config {

package/lib/index.js

@@ -35,6 +35,7 @@ const CommonRouteConfig = {
     heartbeatInterval: koishi_1.Schema.number().default(30000).description('心跳间隔，单位毫秒'),
     reconnectInterval: koishi_1.Schema.number().default(5000).description('断线后重连间隔，单位毫秒'),
     maxConcurrency: koishi_1.Schema.number().min(1).default(16).description('这条路由同时处理的最大并发数'),
+    maxConnections: koishi_1.Schema.natural().min(1).default(16).description('server 模式下同时允许连接的后端数量上限；同一事件会广播给全部已连接后端'),
 };
 const ClientRouteConfig = koishi_1.Schema.object({
     ...CommonRouteConfig,
@@ -146,6 +147,9 @@ function extractQQMarkdown(value) {
     return {
         markdown: { content },
         fallback,
+        keyboard: markdownSource.keyboard && typeof markdownSource.keyboard === 'object'
+            ? markdownSource.keyboard
+            : undefined,
         remaining,
     };
 }
@@ -304,15 +308,15 @@ class RouteRuntime {
     declareCommands;
     socket = null;
     server = null;
+    serverSockets = new Set();
     connecting = null;
     reconnectTimer = null;
-    heartbeatTimer = null;
+    heartbeats = new Map();
     serverReadyWaiter = null;
     pending = new Map();
     inflight = 0;
     queue = [];
     closed = false;
-    lastPong = 0;
     recentGroupSessions = new Map();
     recentPrivateSessions = new Map();
     constructor(ctx, config, route, declareCommands) {
@@ -331,6 +335,9 @@ class RouteRuntime {
     get routeLabel() {
         return `${this.route.name}(${this.kind})`;
     }
+    get maxConnections() {
+        return Math.max(1, Number(this.route.maxConnections) || 16);
+    }
     get enabled() {
         const commands = Array.isArray(this.route.commands) ? this.route.commands : [];
         const mappings = Array.isArray(this.route.commandMappings)
@@ -362,22 +369,20 @@ class RouteRuntime {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = null;
         }
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
+        this.stopAllHeartbeats();
         if (this.server) {
             this.server.close();
             this.server = null;
         }
         this.rejectServerReadyWaiter(new Error(`route ${this.route.name} closed`));
         this.rejectAll(new Error(`route ${this.route.name} closed`));
-        if (this.socket && this.socket.readyState === ws_1.default.OPEN) {
-            this.socket.close(1000, 'plugin disposed');
-        }
-        else if (this.socket) {
-            this.socket.terminate();
+        for (const socket of this.getOpenSockets()) {
+            if (socket.readyState === ws_1.default.OPEN)
+                socket.close(1000, 'plugin disposed');
+            else
+                socket.terminate();
         }
+        this.serverSockets.clear();
         this.socket = null;
     }
     async forward(session, commandName, content = '', sourceCommand = commandName) {
@@ -401,24 +406,24 @@ class RouteRuntime {
         if (this.closed)
             return;
         const push = async () => {
-            if (this.kind === 'server') {
+            if (this.kind === 'server')
                 await this.waitForServerSocket();
-            }
-            else {
+            else
                 await this.connect();
-            }
-            const socket = this.socket;
-            if (!socket || socket.readyState !== ws_1.default.OPEN) {
+            const sockets = this.getOpenSockets();
+            if (!sockets.length) {
                 throw new Error(`route ${this.route.name} is not connected`);
             }
             if (this.config.debug) {
                 this.ctx.logger(exports.name).debug(`route ${this.routeLabel} push event => ${JSON.stringify(event)}`);
             }
-            socket.send(JSON.stringify(event), (error) => {
-                if (error) {
-                    this.ctx.logger(exports.name).warn(`route ${this.routeLabel} push event failed: ${error.message}`);
-                }
-            });
+            const payload = JSON.stringify(event);
+            for (const socket of sockets) {
+                socket.send(payload, (error) => {
+                    if (error)
+                        this.ctx.logger(exports.name).warn(`route ${this.routeLabel} push event failed: ${error.message}`);
+                });
+            }
         };
         push().catch(e => this.ctx.logger(exports.name).warn(e));
     }
@@ -449,11 +454,13 @@ class RouteRuntime {
             ? {
                 msg_type: 2,
                 markdown: qq.markdown,
+                ...(qq.keyboard ? { keyboard: qq.keyboard } : {}),
                 ...(recentMessageId ? { msg_id: recentMessageId } : {}),
             }
             : {
                 content: ' ',
                 markdown: qq.markdown,
+                ...(qq.keyboard ? { keyboard: qq.keyboard } : {}),
                 ...(recentMessageId ? { msg_id: recentMessageId } : {}),
             };
         const response = isPrivate
@@ -524,9 +531,8 @@ class RouteRuntime {
             });
             socket.once('open', () => {
                 this.socket = socket;
-                this.lastPong = Date.now();
                 this.bindSocket(socket);
-                this.startHeartbeat();
+                this.startHeartbeat(socket);
                 this.ctx.logger(exports.name).info(`route ${this.routeLabel} connected`);
                 // Push standard OB11 lifecycle meta_event
                 const selfId = toOneBotId(this.ctx.bots[0]?.selfId) || 0;
@@ -579,13 +585,14 @@ class RouteRuntime {
                     return;
                 }
             }
-            if (this.socket && this.socket !== socket) {
-                this.socket.terminate();
+            if (this.serverSockets.size >= this.maxConnections) {
+                this.ctx.logger(exports.name).warn(`route ${this.routeLabel} rejected connection from ${remote}: connection limit (${this.maxConnections}) reached`);
+                socket.close(1013, 'connection limit reached');
+                return;
             }
-            this.socket = socket;
-            this.lastPong = Date.now();
+            this.serverSockets.add(socket);
             this.bindSocket(socket);
-            this.startHeartbeat();
+            this.startHeartbeat(socket);
             this.resolveServerReadyWaiter();
             // Push standard OB11 lifecycle meta_event
             const selfId = toOneBotId(this.ctx.bots[0]?.selfId) || 0;
@@ -599,11 +606,6 @@ class RouteRuntime {
             if (socket.readyState === ws_1.default.OPEN) {
                 socket.send(JSON.stringify(connectEvent));
             }
-            socket.on('close', () => {
-                if (this.socket === socket) {
-                    this.handleDisconnect();
-                }
-            });
         });
         this.server.on('listening', () => {
             this.ctx.logger(exports.name).info(`route ${this.routeLabel} listening on ws://${listenHost}:${listenPort}`);
@@ -613,7 +615,7 @@ class RouteRuntime {
         });
     }
     async waitForServerSocket() {
-        if (this.socket?.readyState === ws_1.default.OPEN)
+        if (this.getOpenSockets().length)
             return;
         const waiter = this.getServerReadyWaiter();
         await waiter.promise;
@@ -819,12 +821,14 @@ class RouteRuntime {
             }
         });
         socket.on('pong', () => {
-            this.lastPong = Date.now();
+            const heartbeat = this.heartbeats.get(socket);
+            if (heartbeat)
+                heartbeat.lastPong = Date.now();
         });
         socket.on('close', (code, reason) => {
             const text = Buffer.isBuffer(reason) ? reason.toString() : String(reason ?? '');
             this.ctx.logger(exports.name).warn(`route ${this.routeLabel} socket closed: code=${code} reason=${text || 'none'}`);
-            this.handleDisconnect();
+            this.handleSocketDisconnect(socket);
         });
         socket.on('error', (error) => {
             this.ctx.logger(exports.name).warn(`route ${this.routeLabel} websocket error: ${error.message}`);
@@ -842,30 +846,55 @@ class RouteRuntime {
             return null;
         }
     }
-    startHeartbeat() {
-        if (this.heartbeatTimer)
-            clearInterval(this.heartbeatTimer);
-        this.heartbeatTimer = setInterval(() => {
-            const socket = this.socket;
-            if (!socket || socket.readyState !== ws_1.default.OPEN)
-                return;
-            const elapsed = Date.now() - this.lastPong;
-            if (elapsed > this.route.heartbeatInterval * 2) {
-                socket.terminate();
-                return;
-            }
-            socket.ping();
-        }, this.route.heartbeatInterval);
+    getOpenSockets() {
+        if (this.kind === 'client') {
+            return this.socket?.readyState === ws_1.default.OPEN ? [this.socket] : [];
+        }
+        return [...this.serverSockets].filter(socket => socket.readyState === ws_1.default.OPEN);
     }
-    handleDisconnect() {
-        this.socket = null;
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
+    startHeartbeat(socket) {
+        this.stopHeartbeat(socket);
+        const heartbeat = {
+            lastPong: Date.now(),
+            timer: setInterval(() => {
+                if (socket.readyState !== ws_1.default.OPEN)
+                    return;
+                const elapsed = Date.now() - heartbeat.lastPong;
+                if (elapsed > this.route.heartbeatInterval * 2) {
+                    socket.terminate();
+                    return;
+                }
+                socket.ping();
+            }, this.route.heartbeatInterval),
+        };
+        this.heartbeats.set(socket, heartbeat);
+    }
+    stopHeartbeat(socket) {
+        const heartbeat = this.heartbeats.get(socket);
+        if (!heartbeat)
+            return;
+        clearInterval(heartbeat.timer);
+        this.heartbeats.delete(socket);
+    }
+    stopAllHeartbeats() {
+        for (const { timer } of this.heartbeats.values())
+            clearInterval(timer);
+        this.heartbeats.clear();
+    }
+    handleSocketDisconnect(socket) {
+        this.stopHeartbeat(socket);
+        if (this.kind === 'server') {
+            this.serverSockets.delete(socket);
+            if (!this.serverSockets.size) {
+                this.rejectServerReadyWaiter(new Error(`route ${this.route.name} disconnected`));
+            }
+            return;
         }
-        this.rejectServerReadyWaiter(new Error(`route ${this.route.name} disconnected`));
+        if (this.socket !== socket)
+            return;
+        this.socket = null;
         this.rejectAll(new Error(`route ${this.route.name} disconnected`));
-        if (!this.closed && this.kind === 'client') {
+        if (!this.closed) {
             this.ctx.logger(exports.name).warn(`route ${this.routeLabel} scheduling reconnect in ${this.route.reconnectInterval}ms`);
             this.scheduleReconnect();
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-msg-router",
   "description": "Koishi OneBot 指令路由：支持手动/动态转译、权限与频率控制、双向 WebSocket 和 QQ Markdown",
-  "version": "1.4.0",
+  "version": "1.4.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -4,7 +4,7 @@
 
 一个面向 Koishi 的 OneBot v11 指令中转路由插件。插件仅接管配置中指定的指令，将会话转换为 OneBot v11 消息事件并通过 WebSocket 交给外部后端处理；未配置的指令保持 Koishi 原有处理流程，不受影响。
 
-后端可以通过标准 OneBot API 动作向群聊或私聊回发文本、图片、语音等消息。针对 QQ 官方适配器，插件还支持原生 Markdown 文本，并在不支持 Markdown 的平台上自动降级为普通文本。
+后端可以通过标准 OneBot API 动作向群聊或私聊回发文本、图片、语音等消息。针对 QQ 官方适配器，插件还支持原生 Markdown 文本和 Markdown 键盘，并在不支持 Markdown 的平台上自动降级为普通文本。
 
 ## 主要用途
 
@@ -12,7 +12,7 @@
 - **手动或动态转译**：可以在配置页维护指令映射，也可以由后端通过接口动态声明
 - **Koishi 指令控制**：映射可配置权限、帮助菜单隐藏、调用频率、群聊/私聊范围和平台限制
 - **OneBot v11 兼容**：向后端推送标准消息事件，并处理常用 OneBot API 动作
-- **双向 WebSocket**：支持插件主动连接后端，也支持插件监听并等待后端连接
+- **双向 WebSocket**：支持插件主动连接后端，也支持插件监听并同时维持多个后端连接
 - **多路由配置**：不同指令可以连接不同后端，分别设置地址、鉴权和连接参数
 - **消息类型转换**：支持文本、图片、@、回复、语音、视频和表情等常用消息段
 - **QQ Markdown**：支持 QQ 原生 Markdown 文本，其他平台自动使用普通文本降级
@@ -48,6 +48,7 @@
 - `heartbeatInterval`：发送 ping 的间隔，单位毫秒
 - `reconnectInterval`：断线后的重连间隔，单位毫秒
 - `maxConcurrency`：同时允许的请求数量
+- `maxConnections`：仅 server 模式有效，同时允许接入的后端连接数量上限，默认 `16`
 
 ### 反向 WS 路由列表
 
@@ -67,6 +68,7 @@
 - `heartbeatInterval`：发送 ping 的间隔，单位毫秒
 - `reconnectInterval`：断线后的重连间隔，单位毫秒
 - `maxConcurrency`：同时允许的请求数量
+- `maxConnections`：同时允许接入的后端连接数量上限，默认 `16`；每个指令事件会广播给全部已连接后端
 
 ## 推荐配置示例
 
@@ -86,7 +88,8 @@
       "timeout": 10000,
       "heartbeatInterval": 30000,
       "reconnectInterval": 5000,
-      "maxConcurrency": 16
+      "maxConcurrency": 16,
+      "maxConnections": 16
     }
   ],
   "serverRoutes": [
@@ -103,7 +106,8 @@
       "timeout": 10000,
       "heartbeatInterval": 30000,
       "reconnectInterval": 5000,
-      "maxConcurrency": 16
+      "maxConcurrency": 16,
+      "maxConnections": 16
     }
   ]
 }
@@ -113,7 +117,7 @@
 
 - `client` 模式：插件主动连接后端
 - `server` 模式：插件自己监听，等待后端连接
-- `server` 模式下，如果后端还没连上来，命令会等待到超时为止
+- `server` 模式下可以同时连接多个后端；每个命令事件会广播给所有在线连接。若还没有任何后端连上来，命令会等待到超时为止
 
 ## 协议约定
 
@@ -255,9 +259,9 @@
 - 插件不会覆盖其他 Koishi 插件已经注册的指令，冲突项会出现在 `rejected` 中
 - 只配置动态声明、不填写静态 `commands` 的路由也会启动并等待后端声明
 
-### QQ Markdown 文本
+### QQ Markdown 与键盘
 
-后端通过 `send_group_msg`、`send_private_msg` 或 `send_msg` 回发消息时，可以使用 QQ 原生 Markdown 文本。插件在 QQ 官方适配器上会直接提交 `markdown.content`；在其他平台上会把同一内容作为普通文本降级发送。
+后端通过 `send_group_msg`、`send_private_msg` 或 `send_msg` 回发消息时，可以使用 QQ 原生 Markdown 文本。插件在 QQ 官方适配器上会直接提交 `markdown.content`，并透传 `keyboard`；在其他平台上会把同一内容作为普通文本降级发送。
 
 此功能可通过配置页面的 `enableQQMarkdown` 开关控制。关闭后不会调用 QQ 原生 Markdown 接口，而是把 `content` 或 `fallback_text` 作为普通消息发送。
 
@@ -271,7 +275,12 @@
         "type": "markdown",
         "data": {
           "content": "# 标题\n**加粗内容**\n[查看详情](https://example.com)",
-          "fallback_text": "标题\n加粗内容\nhttps://example.com"
+          "fallback_text": "标题\n加粗内容\nhttps://example.com",
+          "keyboard": {
+            "content": {
+              "rows": []
+            }
+          }
         }
       }
     ]