koishi-plugin-msg-router 1.0.0 → 1.1.0

package/lib/index.js

@@ -59,6 +59,61 @@ function toOneBotId(value) {
     }
     return undefined;
 }
+function firstMessageId(value) {
+    const first = Array.isArray(value) ? value[0] : value;
+    if (first == null || first === '')
+        return Math.floor(Math.random() * 1000000);
+    if (typeof first === 'number')
+        return first;
+    const numeric = Number(first);
+    return Number.isFinite(numeric) ? numeric : String(first);
+}
+/** Extracts QQ's native Markdown payload without letting generic Satori conversion discard it. */
+function extractQQMarkdown(value) {
+    const segments = Array.isArray(value) ? value : [value];
+    let markdownSource;
+    const remaining = [];
+    for (const item of segments) {
+        if (!item || typeof item !== 'object') {
+            remaining.push(item);
+            continue;
+        }
+        const segment = item;
+        if (segment.type === 'markdown') {
+            const source = segment.data?.markdown ?? segment.data ?? {};
+            markdownSource = typeof source === 'string' ? { content: source } : source;
+        }
+        else if (!Array.isArray(value) && segment.markdown) {
+            markdownSource = typeof segment.markdown === 'string'
+                ? { content: segment.markdown }
+                : segment.markdown;
+        }
+        else {
+            remaining.push(item);
+        }
+    }
+    if (!markdownSource)
+        return;
+    const content = markdownSource.content == null ? undefined : String(markdownSource.content);
+    if (!content)
+        return;
+    const fallback = String(markdownSource.fallback_text
+        ?? markdownSource.fallback
+        ?? markdownSource.prompt
+        ?? content
+        ?? '');
+    return {
+        markdown: { content },
+        fallback,
+        remaining,
+    };
+}
+function resolveOutgoingMessage(params) {
+    if (params?.markdown) {
+        return { markdown: params.markdown };
+    }
+    return params?.message;
+}
 function toElements(value) {
     if (value == null)
         return [];
@@ -106,6 +161,18 @@ function toElements(value) {
         if (segment.type === 'reply') {
             return [(0, koishi_1.h)('quote', { id: segment.data?.id || '' })];
         }
+        if (segment.type === 'markdown') {
+            const source = segment.data?.markdown ?? segment.data ?? {};
+            const fallback = source.fallback_text ?? source.fallback ?? source.prompt ?? source.content;
+            return fallback == null ? [] : [koishi_1.h.text(String(fallback))];
+        }
+        if (segment.type === 'keyboard')
+            return [];
+        if (segment.markdown !== undefined) {
+            const source = segment.markdown ?? {};
+            const fallback = source.fallback_text ?? source.fallback ?? source.prompt ?? source.content;
+            return fallback == null ? [] : [koishi_1.h.text(String(fallback))];
+        }
         if (segment.reply !== undefined)
             return toElements(segment.reply);
         if (segment.message !== undefined)
@@ -203,6 +270,8 @@ class RouteRuntime {
     queue = [];
     closed = false;
     lastPong = 0;
+    recentGroupSessions = new Map();
+    recentPrivateSessions = new Map();
     constructor(ctx, config, route) {
         this.ctx = ctx;
         this.config = config;
@@ -273,6 +342,14 @@ class RouteRuntime {
             this.ctx.logger(exports.name).debug(`route ${this.routeLabel} command content: ${JSON.stringify(content)}`);
         }
         const event = buildOneBotMessageEvent(session, commandName, content);
+        const isGroup = Boolean(session?.guildId != null
+            || (session?.channelId != null && String(session.channelId) !== String(session?.userId ?? '')));
+        if (isGroup && session?.channelId) {
+            this.recentGroupSessions.set(String(session.channelId), session);
+        }
+        else if (session?.userId) {
+            this.recentPrivateSessions.set(String(session.userId), session);
+        }
         this.sendEvent(event);
         return undefined; // We do not return a reply here. Standard OB11 backends reply using send_msg API calls.
     }
@@ -301,6 +378,58 @@ class RouteRuntime {
         };
         push().catch(e => this.ctx.logger(exports.name).warn(e));
     }
+    async sendRoutedMessage(bot, session, targetId, isPrivate, message) {
+        const qq = extractQQMarkdown(message);
+        const isQQ = session?.platform === 'qq' || bot?.platform === 'qq';
+        const internal = bot?.internal;
+        const isQQPublicBot = typeof internal?.sendPrivateMessage === 'function';
+        const canSendNative = isQQ && typeof internal?.sendMessage === 'function'
+            && (!isPrivate || isQQPublicBot);
+        if (!qq || !canSendNative) {
+            const elements = qq
+                ? [...(qq.fallback ? [koishi_1.h.text(qq.fallback)] : []), ...toElements(qq.remaining)]
+                : toElements(message);
+            if (!elements.length)
+                return [];
+            return session
+                ? await session.send(elements)
+                : isPrivate
+                    ? await bot.sendPrivateMessage(targetId, elements)
+                    : await bot.sendMessage(targetId, elements);
+        }
+        const recentMessageId = session?.messageId
+            && (!session.timestamp || Date.now() - session.timestamp < 5 * 60 * 1000)
+            ? String(session.messageId)
+            : undefined;
+        const request = isQQPublicBot
+            ? {
+                msg_type: 2,
+                markdown: qq.markdown,
+                ...(recentMessageId ? { msg_id: recentMessageId } : {}),
+            }
+            : {
+                content: ' ',
+                markdown: qq.markdown,
+                ...(recentMessageId ? { msg_id: recentMessageId } : {}),
+            };
+        const response = isPrivate
+            ? await internal.sendPrivateMessage(targetId, request)
+            : await internal.sendMessage(targetId, request);
+        const ids = response?.id ? [response.id] : [];
+        // The Markdown segment forms one native QQ message. Preserve any other
+        // OneBot segments by sending them as a second, ordinary message.
+        const remaining = toElements(qq.remaining);
+        if (remaining.length) {
+            const extra = session
+                ? await session.send(remaining)
+                : isPrivate
+                    ? await bot.sendPrivateMessage(targetId, remaining)
+                    : await bot.sendMessage(targetId, remaining);
+            if (Array.isArray(extra))
+                ids.push(...extra);
+        }
+        return ids;
+    }
     acquireSlot() {
         if (this.inflight < this.route.maxConcurrency) {
             this.inflight += 1;
@@ -464,15 +593,27 @@ class RouteRuntime {
                 };
                 if (data.action === 'send_private_msg' || (data.action === 'send_msg' && data.params?.message_type === 'private')) {
                     const userId = data.params?.user_id;
-                    const message = data.params?.message;
+                    const message = resolveOutgoingMessage(data.params);
                     if (userId == null || message == null) {
                         return sendResponse({ status: 'failed', retcode: 100, msg: 'Missing user_id or message', data: null });
                     }
                     const bot = this.ctx.bots.find(b => b.selfId === String(data.params?.self_id)) || this.ctx.bots[0];
-                    if (bot) {
+                    const session = this.recentPrivateSessions.get(String(userId));
+                    if (session && (!data.params?.self_id || session.bot?.selfId === String(data.params?.self_id))) {
                         try {
-                            const msgIds = await bot.sendPrivateMessage(String(userId), toElements(message));
-                            const msgId = msgIds && msgIds.length > 0 ? (Number(msgIds[0]) || Math.floor(Math.random() * 1000000)) : Math.floor(Math.random() * 1000000);
+                            const msgIds = await this.sendRoutedMessage(session.bot ?? bot, session, String(userId), true, message);
+                            const msgId = firstMessageId(msgIds);
+                            sendResponse({ status: 'ok', retcode: 0, data: { message_id: msgId } });
+                        }
+                        catch (e) {
+                            this.ctx.logger(exports.name).error(`[send_private_msg] Failed to send via session to ${userId}:`, e);
+                            sendResponse({ status: 'failed', retcode: 100, msg: String(e), data: null });
+                        }
+                    }
+                    else if (bot) {
+                        try {
+                            const msgIds = await this.sendRoutedMessage(bot, null, String(userId), true, message);
+                            const msgId = firstMessageId(msgIds);
                             sendResponse({ status: 'ok', retcode: 0, data: { message_id: msgId } });
                         }
                         catch (e) {
@@ -487,15 +628,27 @@ class RouteRuntime {
                 }
                 if (data.action === 'send_group_msg' || (data.action === 'send_msg' && data.params?.message_type === 'group')) {
                     const groupId = data.params?.group_id;
-                    const message = data.params?.message;
+                    const message = resolveOutgoingMessage(data.params);
                     if (groupId == null || message == null) {
                         return sendResponse({ status: 'failed', retcode: 100, msg: 'Missing group_id or message', data: null });
                     }
                     const bot = this.ctx.bots.find(b => b.selfId === String(data.params?.self_id)) || this.ctx.bots[0];
-                    if (bot) {
+                    const session = this.recentGroupSessions.get(String(groupId));
+                    if (session && (!data.params?.self_id || session.bot?.selfId === String(data.params?.self_id))) {
                         try {
-                            const msgIds = await bot.sendMessage(String(groupId), toElements(message));
-                            const msgId = msgIds && msgIds.length > 0 ? (Number(msgIds[0]) || Math.floor(Math.random() * 1000000)) : Math.floor(Math.random() * 1000000);
+                            const msgIds = await this.sendRoutedMessage(session.bot ?? bot, session, String(groupId), false, message);
+                            const msgId = firstMessageId(msgIds);
+                            sendResponse({ status: 'ok', retcode: 0, data: { message_id: msgId } });
+                        }
+                        catch (e) {
+                            this.ctx.logger(exports.name).error(`[send_group_msg] Failed to send via session to ${groupId}:`, e);
+                            sendResponse({ status: 'failed', retcode: 100, msg: String(e), data: null });
+                        }
+                    }
+                    else if (bot) {
+                        try {
+                            const msgIds = await this.sendRoutedMessage(bot, null, String(groupId), false, message);
+                            const msgId = firstMessageId(msgIds);
                             sendResponse({ status: 'ok', retcode: 0, data: { message_id: msgId } });
                         }
                         catch (e) {
@@ -508,6 +661,90 @@ class RouteRuntime {
                     }
                     return;
                 }
+                const bot = this.ctx.bots.find(b => b.selfId === String(data.params?.self_id)) || this.ctx.bots[0];
+                if (!bot) {
+                    return sendResponse({ status: 'failed', retcode: 100, msg: 'No Koishi bot available', data: null });
+                }
+                try {
+                    if (data.action === 'delete_msg') {
+                        const messageId = String(data.params?.message_id);
+                        if (!messageId)
+                            throw new Error('Missing message_id');
+                        // In OneBot, we only get message_id, not channel_id. But Satori requires channelId to delete.
+                        // A naive fallback if channel_id is not provided is to try to guess it, but standard OB11 doesn't provide channel_id.
+                        // We will attempt deletion if channel_id is provided, or fail.
+                        const channelId = String(data.params?.channel_id || data.params?.group_id || '');
+                        if (!channelId)
+                            throw new Error('Cannot delete message without channel_id/group_id context in Satori');
+                        await bot.deleteMessage(channelId, messageId);
+                        return sendResponse({ status: 'ok', retcode: 0, data: null });
+                    }
+                    if (data.action === 'get_login_info') {
+                        return sendResponse({
+                            status: 'ok',
+                            retcode: 0,
+                            data: {
+                                user_id: toOneBotId(bot.selfId),
+                                nickname: bot.user?.name || bot.user?.nick || 'bot',
+                            }
+                        });
+                    }
+                    if (data.action === 'set_group_ban') {
+                        const groupId = String(data.params?.group_id);
+                        const userId = String(data.params?.user_id);
+                        const duration = Number(data.params?.duration) * 1000; // OB11 is seconds, Koishi is ms
+                        if (!groupId || !userId)
+                            throw new Error('Missing group_id or user_id');
+                        await bot.muteGuildMember(groupId, userId, duration);
+                        return sendResponse({ status: 'ok', retcode: 0, data: null });
+                    }
+                    if (data.action === 'set_group_kick') {
+                        const groupId = String(data.params?.group_id);
+                        const userId = String(data.params?.user_id);
+                        if (!groupId || !userId)
+                            throw new Error('Missing group_id or user_id');
+                        await bot.kickGuildMember(groupId, userId);
+                        return sendResponse({ status: 'ok', retcode: 0, data: null });
+                    }
+                    if (data.action === 'get_group_member_info') {
+                        const groupId = String(data.params?.group_id);
+                        const userId = String(data.params?.user_id);
+                        if (!groupId || !userId)
+                            throw new Error('Missing group_id or user_id');
+                        const member = await bot.getGuildMember(groupId, userId);
+                        return sendResponse({
+                            status: 'ok',
+                            retcode: 0,
+                            data: {
+                                group_id: toOneBotId(groupId),
+                                user_id: toOneBotId(userId),
+                                nickname: member.user?.name || member.nick || '',
+                                card: member.nick || '',
+                                role: member.roles?.includes('admin') || member.roles?.includes('owner') ? 'admin' : 'member'
+                            }
+                        });
+                    }
+                    if (data.action === 'get_group_info') {
+                        const groupId = String(data.params?.group_id);
+                        if (!groupId)
+                            throw new Error('Missing group_id');
+                        const guild = await bot.getGuild(groupId);
+                        return sendResponse({
+                            status: 'ok',
+                            retcode: 0,
+                            data: {
+                                group_id: toOneBotId(groupId),
+                                group_name: guild.name || '',
+                                member_count: 0,
+                                max_member_count: 0,
+                            }
+                        });
+                    }
+                }
+                catch (e) {
+                    this.ctx.logger(exports.name).warn(`[${data.action}] Native delegation failed:`, e);
+                    return sendResponse({ status: 'failed', retcode: 100, msg: String(e), data: null });
+                }
                 // Unsupported action fallback
                 sendResponse({ status: 'failed', retcode: 102, msg: 'Unsupported API action', data: null });
                 return;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-msg-router",
-  "description": "OneBot v11 WebSocket 消息转发插件",
-  "version": "1.0.0",
+  "description": "Koishi 指令中转路由：仅接管指定指令，通过 OneBot v11 WebSocket 双向通信，支持 QQ Markdown",
+  "version": "1.1.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -19,6 +19,8 @@
     "plugin",
     "onebot",
     "onebot11",
+    "qq",
+    "markdown",
     "websocket",
     "router"
   ],
@@ -31,8 +33,8 @@
   },
   "koishi": {
     "description": {
-      "zh": "标准 OneBot v11 WebSocket 消息路由与通信中间件",
-      "en": "Standard OneBot v11 WebSocket message routing and communication middleware"
+      "zh": "仅接管指定指令，通过 OneBot v11 WebSocket 与外部后端双向通信，支持正反向连接和 QQ Markdown",
+      "en": "Routes selected commands to external backends over OneBot v11 WebSocket, with forward/reverse connections and QQ Markdown"
     }
   }
 }

package/readme.md

@@ -2,16 +2,19 @@
 
 [![npm](https://img.shields.io/npm/v/koishi-plugin-msg-router?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-msg-router)
 
-这是一个用于 Koishi 的消息转发插件。它把你配置好的指令转发到外部 OneBot v11 WebSocket 后端，再把后端返回内容回传给用户。
+一个面向 Koishi 的 OneBot v11 指令中转路由插件。插件仅接管配置中指定的指令，将会话转换为 OneBot v11 消息事件并通过 WebSocket 交给外部后端处理；未配置的指令保持 Koishi 原有处理流程，不受影响。
+
+后端可以通过标准 OneBot API 动作向群聊或私聊回发文本、图片、语音等消息。针对 QQ 官方适配器，插件还支持原生 Markdown 文本，并在不支持 Markdown 的平台上自动降级为普通文本。
 
 ## 主要用途
 
-- 把某些 Koishi 指令交给外部后端程序处理
-- 支持正向 WS 和反向 WS 两种模式
-- 后端可通过 WebSocket 常驻连接接收请求
-- 支持令牌鉴权，`token` 可留空
-- 支持可选的 HMAC 签名
-- 支持断线重连、心跳保活、超时控制、并发控制
+- **按需接管指令**：每条路由独立配置指令列表，只转发明确指定的指令
+- **OneBot v11 兼容**：向后端推送标准消息事件，并处理常用 OneBot API 动作
+- **双向 WebSocket**：支持插件主动连接后端，也支持插件监听并等待后端连接
+- **多路由配置**：不同指令可以连接不同后端，分别设置地址、鉴权和连接参数
+- **消息类型转换**：支持文本、图片、@、回复、语音、视频和表情等常用消息段
+- **QQ Markdown**：支持 QQ 原生 Markdown 文本，其他平台自动使用普通文本降级
+- **连接管理**：提供令牌鉴权、心跳检测、断线重连、请求超时和调试日志
 
 ## 控制台配置说明
 
@@ -156,6 +159,31 @@
 
 如果 `data.text`、`data.message` 或 `data.reply` 存在，插件会直接把它返回给用户。`data.message` 支持 OneBot 风格的文本段数组。
 
+### QQ Markdown 文本
+
+后端通过 `send_group_msg`、`send_private_msg` 或 `send_msg` 回发消息时，可以使用 QQ 原生 Markdown 文本。插件在 QQ 官方适配器上会直接提交 `markdown.content`；在其他平台上会把同一内容作为普通文本降级发送。
+
+```json
+{
+  "action": "send_group_msg",
+  "params": {
+    "group_id": "群 openid",
+    "message": [
+      {
+        "type": "markdown",
+        "data": {
+          "content": "# 标题\n**加粗内容**\n[查看详情](https://example.com)",
+          "fallback_text": "标题\n加粗内容\nhttps://example.com"
+        }
+      }
+    ]
+  },
+  "echo": "request-id"
+}
+```
+
+如果后端本身直接使用 QQ 消息结构，也可以省略 `message`，直接在 `params.markdown.content` 中提供内容。`fallback_text` 可选；未提供时会直接使用 `content` 作为降级文本。
+
 ## 兼容说明
 
 - `token` 是可选项，不填时不会附加 `Authorization` 头