koishi-plugin-echo-cave 1.16.11 → 1.16.13

package/lib/cqcode-helper.d.ts

@@ -8,4 +8,4 @@ export declare function createTextMsg(content: string): {
         text: string;
     };
 };
-export declare function parseUserIds(userIds: string[]): ParseResult;
+export declare function parseUserIds(userIds: any[]): ParseResult;

package/lib/index.cjs

@@ -154,10 +154,10 @@ __export(index_exports, {
   name: () => name
 });
 module.exports = __toCommonJS(index_exports);
-var import_koishi_plugin_adapter_onebot2 = require("@pynickle/koishi-plugin-adapter-onebot");
+var import_koishi_plugin_adapter_onebot = require("@pynickle/koishi-plugin-adapter-onebot");
 
 // src/cqcode-helper.ts
-var import_koishi_plugin_adapter_onebot = require("@pynickle/koishi-plugin-adapter-onebot");
+var import_koishi = require("koishi");
 function createTextMsg(content) {
   return {
     type: "text",
@@ -168,28 +168,17 @@ function createTextMsg(content) {
 }
 function parseUserIds(userIds) {
   const parsedUserIds = [];
-  for (const userIdStr of userIds) {
+  for (const userId of userIds) {
     try {
-      const cqCode = import_koishi_plugin_adapter_onebot.CQCode.from(userIdStr);
-      if (cqCode.type === "at") {
-        const qq = cqCode.data.qq;
-        if (qq === "all") {
-          return {
-            parsedUserIds: [],
-            error: "invalid_all_mention"
-          };
-        }
-        if (qq) {
-          parsedUserIds.push(qq);
-        }
-      } else {
-        const num = Number(userIdStr);
-        if (!Number.isNaN(num)) {
-          parsedUserIds.push(String(num));
-        }
+      const element = import_koishi.h.parse(userId);
+      if (element.length === 1 && element[0].type === "at") {
+        parsedUserIds.push(element[0].attrs.id);
       }
     } catch (e) {
-      parsedUserIds.push(userIdStr.split(":")[1]);
+      const num = Number(userId);
+      if (Number.isNaN(num)) {
+        parsedUserIds.push(userId);
+      }
     }
   }
   return {
@@ -200,6 +189,82 @@ function parseUserIds(userIds) {
 // src/media-helper.ts
 var import_axios = __toESM(require("axios"), 1);
 var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+async function saveMedia(ctx, mediaElement, type, cfg) {
+  const mediaUrl = mediaElement.url;
+  const originalMediaName = mediaElement.file;
+  const ext = (() => {
+    const i = originalMediaName.lastIndexOf(".");
+    return i === -1 ? type === "image" ? "png" : type === "video" ? "mp4" : type === "record" ? "mp3" : "bin" : originalMediaName.slice(i + 1).toLowerCase();
+  })();
+  const mediaDir = import_node_path.default.join(ctx.baseDir, "data", "cave", type + "s");
+  const mediaName = Date.now().toString();
+  const fullMediaPath = import_node_path.default.join(mediaDir, `${mediaName}.${ext}`);
+  ctx.logger.info(`Saving ${type} from ${mediaUrl} -> ${fullMediaPath}`);
+  try {
+    await import_node_fs.promises.mkdir(mediaDir, { recursive: true });
+    const res = await import_axios.default.get(mediaUrl, {
+      responseType: "arraybuffer",
+      validateStatus: () => true
+    });
+    if (res.status < 200 || res.status >= 300) {
+      ctx.logger.warn(
+        `${type.charAt(0).toUpperCase() + type.slice(1)} download failed: HTTP ${res.status}`
+      );
+      return mediaUrl;
+    }
+    const contentType = res.headers["content-type"];
+    if (contentType) {
+      if (type === "image" && !contentType.startsWith("image/")) {
+        ctx.logger.warn(`Invalid image content-type: ${contentType}`);
+        return mediaUrl;
+      }
+      if (type === "video" && !contentType.startsWith("video/")) {
+        ctx.logger.warn(`Invalid video content-type: ${contentType}`);
+        return mediaUrl;
+      }
+      if (type === "record" && !contentType.startsWith("audio/")) {
+        ctx.logger.warn(`Invalid record content-type: ${contentType}`);
+        return mediaUrl;
+      }
+    }
+    const buffer = Buffer.from(res.data);
+    if (!buffer || buffer.length === 0) {
+      ctx.logger.warn(`Downloaded ${type} buffer is empty`);
+      return mediaUrl;
+    }
+    await import_node_fs.promises.writeFile(fullMediaPath, buffer);
+    ctx.logger.info(
+      `${type.charAt(0).toUpperCase() + type.slice(1)} saved successfully: ${fullMediaPath}`
+    );
+    await checkAndCleanMediaFiles(ctx, cfg, type);
+    return fullMediaPath;
+  } catch (err) {
+    ctx.logger.error(`Failed to save ${type}: ${err}`);
+    return mediaUrl;
+  }
+}
+async function processMediaElement(ctx, element, cfg) {
+  if (element.type === "image" || element.type === "video" || element.type === "file" || element.type === "record") {
+    const savedPath = await saveMedia(
+      ctx,
+      element.data,
+      element.type,
+      cfg
+    );
+    const fileUri = `file:///${savedPath.replace(/\\/g, "/")}`;
+    return {
+      ...element,
+      data: {
+        ...element.data,
+        file: fileUri,
+        // Remove the url field
+        url: void 0
+      }
+    };
+  }
+  return element;
+}
 async function convertFileUriToBase64(ctx, element) {
   if (element.type === "image" || element.type === "video" || element.type === "file" || element.type === "record") {
     const fileUri = element.data.file;
@@ -229,6 +294,72 @@ async function convertFileUriToBase64(ctx, element) {
   }
   return element;
 }
+async function checkAndCleanMediaFiles(ctx, cfg, type) {
+  if (!cfg.enableSizeLimit) {
+    return;
+  }
+  const mediaDir = import_node_path.default.join(ctx.baseDir, "data", "cave", type + "s");
+  const maxSize = (() => {
+    switch (type) {
+      case "image":
+        return (cfg.maxImageSize || 100) * 1024 * 1024;
+      // 转换为字节
+      case "video":
+        return (cfg.maxVideoSize || 500) * 1024 * 1024;
+      case "file":
+        return (cfg.maxFileSize || 1e3) * 1024 * 1024;
+      case "record":
+        return (cfg.maxRecordSize || 200) * 1024 * 1024;
+    }
+  })();
+  try {
+    const files = await import_node_fs.promises.readdir(mediaDir);
+    if (files.length === 0) {
+      return;
+    }
+    const fileInfos = await Promise.all(
+      files.map(async (file) => {
+        const filePath = import_node_path.default.join(mediaDir, file);
+        const stats = await import_node_fs.promises.stat(filePath);
+        return {
+          path: filePath,
+          size: stats.size,
+          mtime: stats.mtimeMs
+        };
+      })
+    );
+    const totalSize = fileInfos.reduce((sum, file) => sum + file.size, 0);
+    ctx.logger.info(
+      `${type} directory total size: ${(totalSize / (1024 * 1024)).toFixed(2)} MB, max allowed: ${(maxSize / (1024 * 1024)).toFixed(2)} MB`
+    );
+    if (totalSize > maxSize) {
+      ctx.logger.warn(
+        `${type} directory size exceeds limit! Total: ${(totalSize / (1024 * 1024)).toFixed(2)} MB, Max: ${(maxSize / (1024 * 1024)).toFixed(2)} MB`
+      );
+      fileInfos.sort((a, b) => a.mtime - b.mtime);
+      let currentSize = totalSize;
+      let filesToDelete = [];
+      for (const file of fileInfos) {
+        if (currentSize <= maxSize) {
+          break;
+        }
+        filesToDelete.push(file);
+        currentSize -= file.size;
+      }
+      for (const file of filesToDelete) {
+        await import_node_fs.promises.unlink(file.path);
+        ctx.logger.info(
+          `Deleted oldest ${type} file: ${import_node_path.default.basename(file.path)} (${(file.size / (1024 * 1024)).toFixed(2)} MB)`
+        );
+      }
+      ctx.logger.info(
+        `Cleanup completed. ${type} directory new size: ${(currentSize / (1024 * 1024)).toFixed(2)} MB`
+      );
+    }
+  } catch (err) {
+    ctx.logger.error(`Failed to check and clean ${type} files: ${err}`);
+  }
+}
 async function deleteMediaFilesFromMessage(ctx, content) {
   try {
     const elements = JSON.parse(content);
@@ -346,22 +477,76 @@ function formatDate(date) {
   });
 }
 
+// src/forward-helper.ts
+async function reconstructForwardMsg(ctx, session, message, cfg) {
+  return Promise.all(
+    message.map(async (msg) => {
+      const content = await processForwardMessageContent(ctx, session, msg, cfg);
+      const senderNickname = msg.sender.nickname;
+      let senderUserId = msg.sender.user_id;
+      senderUserId = senderUserId === 1094950020 ? await getUserIdFromNickname(session, senderNickname, senderUserId) : senderUserId;
+      return {
+        type: "node",
+        data: {
+          user_id: senderUserId,
+          nickname: senderNickname,
+          content
+        }
+      };
+    })
+  );
+}
+async function getUserIdFromNickname(session, nickname, userId) {
+  const memberInfos = await session.onebot.getGroupMemberList(session.channelId);
+  const matches = memberInfos.filter((m) => m.nickname === nickname);
+  if (matches.length === 1) {
+    return matches[0].user_id;
+  }
+  return userId;
+}
+async function processForwardMessageContent(ctx, session, msg, cfg) {
+  if (typeof msg.message === "string") {
+    return msg.message;
+  }
+  const firstElement = msg.message[0];
+  if (firstElement?.type === "forward") {
+    return reconstructForwardMsg(ctx, session, firstElement.data.content, cfg);
+  }
+  return Promise.all(
+    msg.message.map(async (element) => {
+      return processMediaElement(ctx, element, cfg);
+    })
+  );
+}
+
+// src/msg-helper.ts
+async function processMessageContent(ctx, msg, cfg) {
+  return Promise.all(
+    msg.map(async (element) => {
+      if (element.type === "reply") {
+        return element;
+      }
+      return processMediaElement(ctx, element, cfg);
+    })
+  );
+}
+
 // src/index.ts
-var import_koishi_plugin_adapter_onebot3 = require("@pynickle/koishi-plugin-adapter-onebot");
-var import_koishi = require("koishi");
+var import_koishi_plugin_adapter_onebot2 = require("@pynickle/koishi-plugin-adapter-onebot");
+var import_koishi2 = require("koishi");
 var name = "echo-cave";
 var inject = ["database"];
-var Config = import_koishi.Schema.object({
-  adminMessageProtection: import_koishi.Schema.boolean().default(false),
-  allowContributorDelete: import_koishi.Schema.boolean().default(true),
-  allowSenderDelete: import_koishi.Schema.boolean().default(true),
-  deleteMediaWhenDeletingMsg: import_koishi.Schema.boolean().default(true),
-  enableSizeLimit: import_koishi.Schema.boolean().default(false),
-  maxImageSize: import_koishi.Schema.number().default(2048),
-  maxVideoSize: import_koishi.Schema.number().default(512),
-  maxFileSize: import_koishi.Schema.number().default(512),
-  maxRecordSize: import_koishi.Schema.number().default(512),
-  useBase64ForMedia: import_koishi.Schema.boolean().default(false)
+var Config = import_koishi2.Schema.object({
+  adminMessageProtection: import_koishi2.Schema.boolean().default(false),
+  allowContributorDelete: import_koishi2.Schema.boolean().default(true),
+  allowSenderDelete: import_koishi2.Schema.boolean().default(true),
+  deleteMediaWhenDeletingMsg: import_koishi2.Schema.boolean().default(true),
+  enableSizeLimit: import_koishi2.Schema.boolean().default(false),
+  maxImageSize: import_koishi2.Schema.number().default(2048),
+  maxVideoSize: import_koishi2.Schema.number().default(512),
+  maxFileSize: import_koishi2.Schema.number().default(512),
+  maxRecordSize: import_koishi2.Schema.number().default(512),
+  useBase64ForMedia: import_koishi2.Schema.boolean().default(false)
 }).i18n({
   "zh-CN": require_zh_CN()._config
 });
@@ -387,10 +572,8 @@ function apply(ctx, cfg) {
   ctx.command("cave [id:number]").action(
     async ({ session }, id) => await getCave(ctx, session, cfg, id)
   );
-  ctx.command("cave.echo [userIds:text]").action(
-    async ({ session }, userIds) => {
-      ctx.logger.info(`User ${session.userId} is adding a cave message with related users: ${userIds}`);
-    }
+  ctx.command("cave.echo [...userIds]").action(
+    async ({ session }, ...userIds) => await addCave(ctx, session, cfg, userIds)
   );
   ctx.command("cave.wipe <id:number>").action(
     async ({ session }, id) => await deleteCave(ctx, session, cfg, id)
@@ -402,6 +585,10 @@ function apply(ctx, cfg) {
   ctx.command("cave.bind <id:number> <...userIds>", { authority: 4 }).action(
     async ({ session }, id, ...userIds) => {
       ctx.logger.info(`Binding users ${JSON.stringify(userIds)} to cave ID ${id}`);
+      for (const uid of userIds) {
+        ctx.logger.info(`User ID to bind: ${uid}`);
+        ctx.logger.info(`userid type: ${typeof uid}`);
+      }
       await bindUsersToCave(ctx, session, id, userIds);
     }
   );
@@ -510,6 +697,73 @@ async function deleteCave(ctx, session, cfg, id) {
   await ctx.database.remove("echo_cave", id);
   return session.text(".msgDeleted", [id]);
 }
+async function addCave(ctx, session, cfg, userIds) {
+  if (!session.guildId) {
+    return session.text("echo-cave.general.privateChatReminder");
+  }
+  if (!session.quote) {
+    return session.text(".noMsgQuoted");
+  }
+  const { userId, channelId, quote } = session;
+  const messageId = quote.id;
+  let parsedUserIds = [];
+  if (userIds && userIds.length > 0) {
+    ctx.logger.info(`Original userIds in addCave: ${JSON.stringify(userIds)}`);
+    const result = parseUserIds(userIds);
+    if (result.error === "invalid_all_mention") {
+      return session.text(".invalidAllMention");
+    }
+    parsedUserIds = result.parsedUserIds;
+    const isAllUsersInGroup = await checkUsersInGroup(ctx, session, parsedUserIds);
+    if (!isAllUsersInGroup) {
+      return session.text(".userNotInGroup");
+    }
+  }
+  let content;
+  let type;
+  if (quote.elements[0].type === "forward") {
+    type = "forward";
+    const message = await reconstructForwardMsg(
+      ctx,
+      session,
+      await session.onebot.getForwardMsg(messageId),
+      cfg
+    );
+    content = JSON.stringify(message);
+  } else {
+    type = "msg";
+    const message = (await session.onebot.getMsg(messageId)).message;
+    let msgJson;
+    if (typeof message === "string") {
+      msgJson = import_koishi_plugin_adapter_onebot2.CQCode.parse(message);
+    } else {
+      if (message[0].type === "video" || message[0].type === "file") {
+        type = "forward";
+      }
+      msgJson = message;
+    }
+    content = JSON.stringify(await processMessageContent(ctx, msgJson, cfg));
+  }
+  await ctx.database.get("echo_cave", { content }).then((existing) => {
+    if (existing) {
+      return session.text(".existingMsg");
+    }
+  });
+  try {
+    const result = await ctx.database.create("echo_cave", {
+      channelId,
+      createTime: /* @__PURE__ */ new Date(),
+      userId,
+      originUserId: quote.user.id,
+      type,
+      content,
+      relatedUsers: parsedUserIds || []
+    });
+    return session.text(".msgSaved", [result.id]);
+  } catch (error) {
+    return session.text(".msgFailedToSave");
+  }
+}
 async function bindUsersToCave(ctx, session, id, userIds) {
   if (!session.guildId) {
     return session.text("echo-cave.general.privateChatReminder");
@@ -526,7 +780,6 @@ async function bindUsersToCave(ctx, session, id, userIds) {
     return session.text(".invalidAllMention");
   }
   parsedUserIds = result.parsedUserIds;
-  ctx.logger.info(`Parsed userIds: ${JSON.stringify(parsedUserIds)}`);
   const caves = await ctx.database.get("echo_cave", id);
   if (caves.length === 0) {
     return session.text("echo-cave.general.noMsgWithId");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-echo-cave",
   "description": "Group echo cave",
-  "version": "1.16.11",
+  "version": "1.16.13",
   "main": "lib/index.cjs",
   "typings": "lib/index.d.ts",
   "type": "module",