koishi-plugin-echo-cave 1.1.1 → 1.2.0

package/lib/forward-helper.d.ts

@@ -0,0 +1,4 @@
+import { CQCode } from '@pynickle/koishi-plugin-adapter-onebot';
+import { Message } from '@pynickle/koishi-plugin-adapter-onebot/lib/types';
+import { Context } from 'koishi';
+export declare function reconstructForwardMsg(ctx: Context, message: Message[]): Promise<CQCode[]>;

package/lib/image-helper.d.ts

@@ -1,2 +1,2 @@
-import { Context, Session, h } from 'koishi';
-export declare function saveImages(ctx: Context, session: Session, imgElement: h): Promise<string>;
+import { Context } from 'koishi';
+export declare function saveImages(ctx: Context, imgElement: Record<string, any>): Promise<string>;

package/lib/index.cjs

@@ -35,15 +35,17 @@ __export(index_exports, {
   name: () => name
 });
 module.exports = __toCommonJS(index_exports);
+var import_koishi_plugin_adapter_onebot = require("@pynickle/koishi-plugin-adapter-onebot");
+var import_fs = __toESM(require("fs"), 1);
 var import_koishi = require("koishi");
-var import_koishi_plugin_adapter_onebot = require("koishi-plugin-adapter-onebot");
+var import_node_path2 = __toESM(require("node:path"), 1);
 
 // src/image-helper.ts
 var import_node_fs = require("node:fs");
 var import_node_path = __toESM(require("node:path"), 1);
-async function saveImages(ctx, session, imgElement) {
-  const imgUrl = imgElement.attrs.src;
-  const originalImgName = imgElement.attrs.file;
+async function saveImages(ctx, imgElement) {
+  const imgUrl = imgElement.url;
+  const originalImgName = imgElement.file;
   const lastDotIndex = originalImgName.lastIndexOf(".");
   let imgExt = "";
   if (lastDotIndex === -1) {
@@ -52,20 +54,77 @@ async function saveImages(ctx, session, imgElement) {
     imgExt = originalImgName.substring(lastDotIndex + 1);
   }
   const imgPath = import_node_path.default.join(ctx.baseDir, "data", "cave", "images");
-  const imgName = (/* @__PURE__ */ new Date()).toISOString();
+  const imgName = (/* @__PURE__ */ new Date()).getTime().toString();
   let fullImgPath = import_node_path.default.join(imgPath, `${imgName}.${imgExt}`);
-  ctx.logger.info(`Saving image from URL: ${imgUrl} to path: ${fullImgPath}`);
+  ctx.logger.info(
+    `Saving image from URL: ${imgUrl} to path: ${imgName}.${imgExt}`
+  );
   const buffer = await ctx.http.get(imgUrl);
   if (buffer.byteLength === 0) throw new Error("Image download failed");
   await import_node_fs.promises.writeFile(fullImgPath, Buffer.from(buffer));
   return fullImgPath;
 }
 
+// src/forward-helper.ts
+async function reconstructForwardMsg(ctx, message) {
+  return Promise.all(
+    message.map(async (msg) => {
+      const content = await processMessageContent(ctx, msg);
+      return {
+        type: "node",
+        data: {
+          user_id: msg.sender.user_id,
+          nick_name: msg.sender.nickname,
+          content
+        }
+      };
+    })
+  );
+}
+async function processMessageContent(ctx, msg) {
+  if (typeof msg.message === "string") {
+    return msg.message;
+  }
+  const firstElement = msg.message[0];
+  if (firstElement?.type === "forward") {
+    return reconstructForwardMsg(ctx, firstElement.data.content);
+  }
+  return Promise.all(
+    msg.message.map(async (element) => {
+      if (element.type === "image") {
+        return {
+          ...element,
+          data: {
+            ...element.data,
+            url: await saveImages(ctx, element.data)
+          }
+        };
+      }
+      return element;
+    })
+  );
+}
+
+// src/msg-helper.ts
+async function sendCaveMsg(session, caveMsg) {
+  const { channelId } = session;
+  const content = JSON.parse(caveMsg.content);
+  if (caveMsg.type === "forward") {
+    await session.onebot.sendGroupForwardMsg(channelId, content);
+  } else {
+    await session.onebot.sendGroupMsg(channelId, content);
+  }
+}
+
 // src/index.ts
 var name = "echo-cave";
 var inject = ["database"];
 var Config = import_koishi.Schema.object({});
 function apply(ctx) {
+  const imgPath = import_node_path2.default.join(ctx.baseDir, "data", "cave", "images");
+  if (!import_fs.default.existsSync(imgPath)) {
+    import_fs.default.mkdirSync(imgPath, { recursive: true });
+  }
   ctx.model.extend(
     "echo_cave",
     {
@@ -74,7 +133,8 @@ function apply(ctx) {
       createTime: "timestamp",
       userId: "string",
       originUserId: "string",
-      content: "string"
+      type: "string",
+      content: "text"
     },
     {
       primary: "id",
@@ -82,25 +142,36 @@ function apply(ctx) {
       unique: ["content"]
     }
   );
-  ctx.command("cave", "\u968F\u673A\u83B7\u53D6\u56DE\u58F0\u6D1E\u6D88\u606F").action(
-    async ({ session }) => await getCave(ctx, session)
-  );
+  ctx.command(
+    "cave [id:number]",
+    "\u968F\u673A\u83B7\u53D6 / \u83B7\u53D6\u7279\u5B9A id \u7684\u56DE\u58F0\u6D1E\u4FE1\u606F"
+  ).action(async ({ session }, id) => await getCave(ctx, session, id));
   ctx.command("cave.echo", "\u5C06\u6D88\u606F\u5B58\u5165\u56DE\u58F0\u6D1E\u7A74").action(
     async ({ session }) => await addCave(ctx, session)
   );
 }
-async function getCave(ctx, session) {
+async function getCave(ctx, session, id) {
   if (!session.guildId) {
     return "\u274C \u8BF7\u5728\u7FA4\u804A\u4E2D\u4F7F\u7528\u8BE5\u547D\u4EE4\uFF01";
   }
-  const { channelId } = session;
-  const caves = await ctx.database.get("echo_cave", {
-    channelId
-  });
-  if (caves.length === 0) {
-    return '\u{1F680} \u56DE\u58F0\u6D1E\u4E2D\u6682\u65E0\u6D88\u606F\uFF0C\u5FEB\u4F7F\u7528 "cave.echo" \u547D\u4EE4\u6DFB\u52A0\u7B2C\u4E00\u6761\u6D88\u606F\u5427\uFF01';
+  let caveMsg;
+  if (!id) {
+    const { channelId } = session;
+    const caves = await ctx.database.get("echo_cave", {
+      channelId
+    });
+    if (caves.length === 0) {
+      return '\u{1F680} \u56DE\u58F0\u6D1E\u4E2D\u6682\u65E0\u6D88\u606F\uFF0C\u5FEB\u4F7F\u7528 "cave.echo" \u547D\u4EE4\u6DFB\u52A0\u7B2C\u4E00\u6761\u6D88\u606F\u5427\uFF01';
+    }
+    caveMsg = caves[Math.floor(Math.random() * caves.length)];
+  } else {
+    const caves = await ctx.database.get("echo_cave", id);
+    if (caves.length === 0) {
+      return "\u{1F50D} \u672A\u627E\u5230\u8BE5 ID \u7684\u56DE\u58F0\u6D1E\u6D88\u606F";
+    }
+    caveMsg = caves[0];
   }
-  return import_koishi.h.parse(caves[Math.floor(Math.random() * caves.length)].content);
+  await sendCaveMsg(session, caveMsg);
 }
 async function addCave(ctx, session) {
   if (!session.guildId) {
@@ -110,16 +181,22 @@ async function addCave(ctx, session) {
     return "\u{1F4A1} \u8BF7\u5F15\u7528\u4E00\u6761\u6D88\u606F\u540E\u518D\u4F7F\u7528\u6B64\u547D\u4EE4\uFF01";
   }
   const { userId, channelId, quote } = session;
-  const elements = quote.elements;
-  elements.forEach((element) => {
-    ctx.logger("echo-cave").info(
-      `Processing element type: ${element.type}`
+  const messageId = quote.id;
+  let content;
+  let type;
+  if (quote.elements[0].type === "forward") {
+    type = "forward";
+    const message = await reconstructForwardMsg(
+      ctx,
+      await session.onebot.getForwardMsg(messageId)
     );
-    if (element.type === "img") {
-      element.attrs.src = saveImages(ctx, session, element);
-    }
-  });
-  const content = JSON.stringify(elements);
+    content = JSON.stringify(message);
+  } else {
+    type = "msg";
+    content = JSON.stringify(
+      (await session.onebot.getMsg(messageId)).message
+    );
+  }
   await ctx.database.get("echo_cave", { content }).then((existing) => {
     if (existing) {
       return "\u267B\uFE0F \u8BE5\u6D88\u606F\u5DF2\u5B58\u5728\u4E8E\u56DE\u58F0\u6D1E\u7A74\u4E2D\uFF01";
@@ -131,20 +208,17 @@ async function addCave(ctx, session) {
       createTime: /* @__PURE__ */ new Date(),
       userId,
       originUserId: quote.user.id,
+      type,
       content
     });
-    if (session.onebot) {
-      const messageId = await session.onebot.sendGroupMsg(
-        session.channelId,
-        `\u2705 \u56DE\u58F0\u6D1E\u6D88\u606F\u5DF2\u6210\u529F\u5B58\u5165\uFF0C\u6D88\u606F ID\uFF1A${result.id}`
-      );
-      ctx.setTimeout(
-        async () => await session.onebot.deleteMsg(messageId),
-        5e3
-      );
-    } else {
-      return `\u2705 \u56DE\u58F0\u6D1E\u6D88\u606F\u5DF2\u6210\u529F\u5B58\u5165\uFF0C\u6D88\u606F ID\uFF1A${result.id}`;
-    }
+    const messageId2 = await session.onebot.sendGroupMsg(
+      session.channelId,
+      `\u2705 \u56DE\u58F0\u6D1E\u6D88\u606F\u5DF2\u6210\u529F\u5B58\u5165\uFF0C\u6D88\u606F ID\uFF1A${result.id}`
+    );
+    ctx.setTimeout(
+      async () => await session.onebot.deleteMsg(messageId2),
+      5e3
+    );
   } catch (error) {
     this.ctx.logger.warn("\u4E0A\u67B6\u5546\u54C1\u5931\u8D25:", error);
     return "\u274C \u4E0A\u67B6\u5546\u54C1\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF01";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
+import '@pynickle/koishi-plugin-adapter-onebot';
 import { Context, Schema } from 'koishi';
-import 'koishi-plugin-adapter-onebot';
 export declare const name = "echo-cave";
 export declare const inject: string[];
 export interface Config {
@@ -11,6 +11,7 @@ export interface EchoCave {
     createTime: Date;
     userId: string;
     originUserId: string;
+    type: 'forward' | 'msg';
     content: string;
 }
 declare module 'koishi' {

package/lib/msg-helper.d.ts

@@ -0,0 +1,3 @@
+import { Session } from 'koishi';
+import { EchoCave } from './index';
+export declare function sendCaveMsg(session: Session, caveMsg: EchoCave): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-echo-cave",
   "description": "Group echo cave",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "main": "lib/index.cjs",
   "typings": "lib/index.d.ts",
   "type": "module",
@@ -23,8 +23,8 @@
     "cave"
   ],
   "peerDependencies": {
-    "koishi": "^4.18.9",
-    "koishi-plugin-adapter-onebot": "^6.8.0"
+    "@pynickle/koishi-plugin-adapter-onebot": "^1.0.0",
+    "koishi": "^4.18.9"
   },
   "devDependencies": {
     "@semantic-release/changelog": "^6.0.3",