koishi-plugin-fake-message 1.0.1 → 2.0.0

package/lib/index.d.ts

@@ -1,8 +1,6 @@
 import { Context, Schema } from 'koishi';
 export declare const name = "fake-message";
 export interface Config {
-    userSplit: string;
-    messageSplit: string;
     blockedUsers: string[];
 }
 export declare const Config: Schema<Config>;

package/lib/index.js

@@ -28,106 +28,120 @@ module.exports = __toCommonJS(src_exports);
 var import_koishi = require("koishi");
 var name = "fake-message";
 var Config = import_koishi.Schema.object({
-  userSplit: import_koishi.Schema.string().default("|").description("用户消息分隔符"),
-  messageSplit: import_koishi.Schema.string().default(" ").description("同一用户多条消息分隔符"),
-  blockedUsers: import_koishi.Schema.array(import_koishi.Schema.string()).default([]).description("被屏蔽的QQ号列表，这些QQ号将无法被伪造消息")
+  blockedUsers: import_koishi.Schema.array(import_koishi.Schema.string()).default([]).description("被屏蔽的用户ID列表")
 });
-var fakeMsgRegex = /^\d{6,10}说/;
+function parseMessages(elements, quotedContent) {
+  const messages = [];
+  let currentMessage = null;
+  let nextIsNewMessage = false;
+  for (let i = 0; i < elements.length; i++) {
+    const element = elements[i];
+    if (element.type === "message-boundary") {
+      nextIsNewMessage = true;
+      continue;
+    }
+    if (element.type === "at") {
+      if (nextIsNewMessage || messages.length === 0) {
+        const userId = element.attrs.id;
+        const userName = element.attrs.name || userId;
+        currentMessage = {
+          userId,
+          userName,
+          content: []
+        };
+        messages.push(currentMessage);
+        nextIsNewMessage = false;
+        continue;
+      }
+    }
+    if (currentMessage) {
+      currentMessage.content.push(element);
+    }
+  }
+  if (quotedContent && quotedContent.length > 0 && messages.length > 0) {
+    const firstMsg = messages[0];
+    const hasNonEmptyContent = firstMsg.content.some((el) => {
+      if (el.type === "text") {
+        return el.attrs.content.trim().length > 0;
+      }
+      return el.type !== "br" && el.type !== "p";
+    });
+    if (!hasNonEmptyContent) {
+      firstMsg.content = quotedContent;
+    }
+  }
+  return messages;
+}
+__name(parseMessages, "parseMessages");
 function apply(ctx, config) {
-  ctx.using(["help"], (ctx2) => {
-    ctx2.command("fakemsg").action(() => [
-      "消息伪造插件",
-      "用法：【QQ号】说【内容】|【QQ号】说【内容】",
-      "示例：123456说你好|654321说早上好",
-      "注意：被屏蔽的QQ号将无法被伪造消息"
-    ].join("\n"));
-  });
-  const checkIfFakeMsg = /* @__PURE__ */ __name((content) => {
-    return fakeMsgRegex.test(content);
-  }, "checkIfFakeMsg");
-  const isUserBlocked = /* @__PURE__ */ __name((userId) => {
-    return config.blockedUsers.includes(userId);
-  }, "isUserBlocked");
-  ctx.middleware(async (session, next) => {
-    const content = session.content;
-    if (!checkIfFakeMsg(content)) {
-      return next();
+  ctx.command("fake <content:el>", "伪造合并转发消息", { checkArgCount: true }).usage(
+    "用法示例：\nfake @用户A 消息内容1\n@用户B 消息内容2\n@用户A 第一行\n第二行（同一条消息）\n\n规则：\n- 每行开头的 @用户 表示一条新消息\n- 换行后如果不是 @用户 开头，则属于上一条消息\n- 行内的 @用户 (非行首) 作为消息内容\n- 支持发送图片\n- 引用本指令可将被引用消息作为第一个用户的消息内容（如果没有为其提供消息的话）"
+  ).action(async ({ session }) => {
+    let contentStr = session.content;
+    if (!contentStr) {
+      return "请输入要伪造的消息内容";
     }
-    await session.send("正在伪造消息……");
-    try {
-      const fakeMessages = [];
-      const userMessages = content.split(config.userSplit);
-      for (const userMsg of userMessages) {
-        const trimmedMsg = userMsg.trim();
-        if (!trimmedMsg || !trimmedMsg.includes("说")) continue;
-        const [userQQ, message] = trimmedMsg.split("说", 2);
-        if (!userQQ || !message) continue;
-        if (isUserBlocked(userQQ)) {
-          await session.send(`QQ号 ${userQQ} 已被屏蔽，无法伪造该用户的消息`);
-          continue;
-        }
-        try {
-          const userInfo = await session.bot.getUser(userQQ);
-          const userName = userInfo?.name || userQQ;
-          const messages = message.split(config.messageSplit);
-          for (const msg of messages) {
-            if (msg.trim()) {
-              fakeMessages.push({
-                userId: userQQ,
-                nickname: userName,
-                content: msg.trim()
-              });
-            }
-          }
-        } catch (e) {
-          console.error(`获取用户 ${userQQ} 信息失败:`, e);
-          const messages = message.split(config.messageSplit);
-          for (const msg of messages) {
-            if (msg.trim()) {
-              fakeMessages.push({
-                userId: userQQ,
-                nickname: userQQ,
-                content: msg.trim()
-              });
-            }
-          }
-        }
+    contentStr = contentStr.replace(/(^|[\s])@(\d+)(?=$|[\s])/g, (match, prefix, id) => {
+      return `${prefix}<at id="${id}"/>`;
+    });
+    contentStr = contentStr.replace(/(\n\s*)(<at)/g, "$1<message-boundary/>$2");
+    const elements = import_koishi.h.parse(contentStr);
+    let quotedContent = null;
+    if (session.quote) {
+      if (session.quote.content) {
+        quotedContent = import_koishi.h.parse(session.quote.content);
+      } else if (session.quote.elements && session.quote.elements.length > 0) {
+        quotedContent = session.quote.elements;
       }
-      if (fakeMessages.length > 0) {
-        await sendForwardMessage(session, fakeMessages);
-      } else {
-        await session.send("消息格式错误，请检查后重试");
+    }
+    const quoteElementIndex = elements.findIndex((el) => el.type === "quote");
+    if (quoteElementIndex !== -1) {
+      const quoteEl = elements[quoteElementIndex];
+      if (!quotedContent || quotedContent.length === 0) {
+        if (quoteEl.children && quoteEl.children.length > 0) {
+          quotedContent = quoteEl.children.filter((el) => el.type !== "author");
+        }
       }
-    } catch (e) {
-      console.error("伪造消息失败:", e);
-      await session.send(`发送失败: ${e.message || "未知错误"}`);
+      elements.splice(quoteElementIndex, 1);
     }
-    return;
-  });
-  async function sendForwardMessage(session, messages) {
-    try {
-      const nodes = messages.map((msg) => ({
-        type: "node",
-        data: {
-          name: msg.nickname,
-          uin: msg.userId,
-          content: msg.content
+    const fakeMessages = parseMessages(elements, quotedContent);
+    if (fakeMessages.length === 0) {
+      return "未能解析出任何消息，请确保格式正确（每条消息以 @用户 开头）";
+    }
+    if (session.guildId) {
+      await Promise.all(fakeMessages.map(async (msg) => {
+        if (msg.userName === msg.userId || !msg.userName) {
+          try {
+            const member = await session.bot.getGuildMember(session.guildId, msg.userId);
+            msg.userName = member.nick || member.user?.nick || member.user?.name || msg.userId;
+          } catch {
+            try {
+              const user = await session.bot.getUser(msg.userId);
+              msg.userName = user.nick || user.name || msg.userId;
+            } catch {
+              if (!msg.userName) msg.userName = msg.userId;
+            }
+          }
         }
       }));
-      if (session.subtype === "group") {
-        await session.bot.internal.sendGroupForwardMsg(session.guildId, nodes);
-      } else {
-        await session.bot.internal.sendPrivateForwardMsg(session.userId, nodes);
-      }
-    } catch (e) {
-      console.error("发送合并转发消息失败:", e);
-      await session.send("合并转发失败，将逐条发送消息");
-      for (const msg of messages) {
-        await session.send(`${msg.nickname}：${msg.content}`);
+    }
+    const forwardMessages = [];
+    for (let idx = 0; idx < fakeMessages.length; idx++) {
+      const msg = fakeMessages[idx];
+      if (config.blockedUsers.includes(msg.userId)) {
+        continue;
       }
+      const messageChildren = [
+        (0, import_koishi.h)("author", { id: msg.userId, name: msg.userName }),
+        ...msg.content
+      ];
+      forwardMessages.push((0, import_koishi.h)("message", {}, messageChildren));
     }
-  }
-  __name(sendForwardMessage, "sendForwardMessage");
+    if (forwardMessages.length === 0) {
+      return "所有消息内容都为空或发送者被屏蔽";
+    }
+    await session.send((0, import_koishi.h)("message", { forward: true }, forwardMessages));
+  });
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-fake-message",
-  "description": "伪造消息，可用于恶搞群友或好友",
-  "version": "1.0.1",
+  "description": "伪造合并转发消息",
+  "version": "2.0.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -9,19 +9,11 @@
     "dist"
   ],
   "license": "MIT",
-  "scripts": {
-    "build": "tsc"
-  },
   "keywords": [
     "chatbot",
     "koishi",
-    "plugin",
-    "fake-message",
-    "forward-message"
+    "plugin"
   ],
-  "devDependencies": {
-    "typescript": "^5.0.0"
-  },
   "peerDependencies": {
     "koishi": "^4.18.7"
   }

package/readme.md

@@ -1,44 +1,35 @@
 # koishi-plugin-fake-message
 
-一个用于伪造消息的 Koishi 插件，移植自 [nonebot-plugin-fakemsg](https://github.com/Cvandia/nonebot-plugin-fakemsg)。
+[![npm](https://img.shields.io/npm/v/koishi-plugin-fake-message?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-fake-message)
 
-## 功能介绍
+伪造合并转发消息
 
-本插件可以伪造任意用户的消息，形成一个合并转发消息，用于恶搞群友或好友。
+## 功能特点
 
-## 使用方法
+- 换行后的第一个内容如果是 @用户，则表示新的一条消息
+- 支持多行消息（换行后不是 @用户 开头则属于同一条消息）
+- 支持发送图片
 
-触发格式：`QQ号说内容`
+## 使用方法
 
-例如：
 ```
-123456说你好
+fake @用户A 这是第一条消息
+@用户B 这是第二条消息
+@用户A 这是第三条消息
+第二行（同一条消息）
+第三行（同一条消息）
+@用户C 这是第四条消息 <img src="图片链接"/>
 ```
 
-如果要同时伪造多个用户的消息，可以使用 `|` 分隔：
-```
-123456说你好|654321说早上好
-```
+### 引用被回复的消息
 
-如果要伪造同一用户的多条消息，可以使用空格分隔：
-```
-123456说你好 早上好 今天天气真不错
-```
+回复某条消息并使用本指令时，如果第一个用户没有提供消息内容，则会使用被引用的消息内容：
 
-当然，你也可以综合使用：
 ```
-123456说你好 早上好|654321说今天天气真不错 周末要不要出去玩
+[回复某条消息]
+fake @用户A
+@用户B 第二条消息
 ```
 
-## 配置项
-
-- `userSplit`: 用户消息分隔符，默认为 `|`
-- `messageSplit`: 同一用户多条消息分隔符，默认为空格
-- `blockedUsers`: 被屏蔽的QQ号列表，这些QQ号将无法被伪造消息，默认为空数组
-
-## 注意事项
+此时用户A的消息内容将是被回复的那条消息的内容。
 
-1. 伪造消息的 QQ 号必须是真实存在的用户
-2. 如果合并转发消息发送失败，插件会自动退化为逐条发送文本消息
-3. 本插件适用于所有适配器，但合并转发功能可能只在部分适配器中可用
-4. 被屏蔽的QQ号将无法被伪造消息，尝试伪造被屏蔽QQ号的消息时会收到提示