koishi-plugin-best-cave 1.5.3 → 1.5.4

package/lib/index.js

@@ -53,9 +53,9 @@ __export(src_exports, {
   name: () => name
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi5 = require("koishi");
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var import_koishi6 = require("koishi");
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 
 // src/utils/FileHandle.ts
 var fs = __toESM(require("fs"));
@@ -1188,37 +1188,181 @@ ${session.text("commands.cave.audit.from")}${cave.contributor_number}`;
   }
 };
 
+// src/utils/MediaHandle.ts
+var import_koishi5 = require("koishi");
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var logger4 = new import_koishi5.Logger("MediaHandle");
+async function extractMediaContent(originalContent, config, session) {
+  const textParts = originalContent.split(/<(img|video)[^>]+>/).map((text, idx) => text.trim() && {
+    type: "text",
+    content: text.replace(/^(img|video)$/, "").trim(),
+    index: idx * 3
+  }).filter((text) => text && text.content);
+  const getMediaElements = /* @__PURE__ */ __name((type, maxSize) => {
+    const regex = new RegExp(`<${type}[^>]+src="([^"]+)"[^>]*>`, "g");
+    const elements = [];
+    const urls = [];
+    let match;
+    let idx = 0;
+    while ((match = regex.exec(originalContent)) !== null) {
+      const element = match[0];
+      const url = match[1];
+      const fileName = element.match(/file="([^"]+)"/)?.[1];
+      const fileSize = element.match(/fileSize="([^"]+)"/)?.[1];
+      if (fileSize) {
+        const sizeInBytes = parseInt(fileSize);
+        if (sizeInBytes > maxSize * 1024 * 1024) {
+          throw new Error(session.text("commands.cave.message.mediaSizeExceeded", [type]));
+        }
+      }
+      urls.push(url);
+      elements.push({
+        type,
+        index: type === "video" ? Number.MAX_SAFE_INTEGER : idx * 3 + 1,
+        fileName,
+        fileSize
+      });
+      idx++;
+    }
+    return { urls, elements };
+  }, "getMediaElements");
+  const { urls: imageUrls, elements: imageElementsRaw } = getMediaElements("img", config.imageMaxSize);
+  const imageElements = imageElementsRaw;
+  const { urls: videoUrls, elements: videoElementsRaw } = getMediaElements("video", config.videoMaxSize);
+  const videoElements = videoElementsRaw;
+  return { imageUrls, imageElements, videoUrls, videoElements, textParts };
+}
+__name(extractMediaContent, "extractMediaContent");
+async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config, ctx, session, buffers) {
+  const accept = mediaType === "img" ? "image/*" : "video/*";
+  const hashStorage = new ContentHashManager(path5.join(ctx.baseDir, "data", "cave"));
+  await hashStorage.initialize();
+  const downloadTasks = urls.map(async (url, i) => {
+    const fileName = fileNames[i];
+    const ext = path5.extname(fileName || url) || (mediaType === "img" ? ".png" : ".mp4");
+    try {
+      const response = await ctx.http(decodeURIComponent(url).replace(/&amp;/g, "&"), {
+        method: "GET",
+        responseType: "arraybuffer",
+        timeout: 3e4,
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+          "Accept": accept,
+          "Referer": "https://qq.com"
+        }
+      });
+      if (!response.data) throw new Error("empty_response");
+      const buffer = Buffer.from(response.data);
+      if (buffers && mediaType === "img") {
+        buffers.push(buffer);
+      }
+      const md5 = path5.basename(fileName || `${mediaType}`, ext).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
+      const files = await fs5.promises.readdir(resourceDir);
+      const duplicateFile = files.find((file) => {
+        const match = file.match(/^\d+_([^.]+)/);
+        return match && match[1] === md5;
+      });
+      if (duplicateFile) {
+        const duplicateCaveId = parseInt(duplicateFile.split("_")[0]);
+        if (!isNaN(duplicateCaveId)) {
+          const caveFilePath = path5.join(ctx.baseDir, "data", "cave", "cave.json");
+          const data = await FileHandler.readJsonData(caveFilePath);
+          const originalCave = data.find((item) => item.cave_id === duplicateCaveId);
+          if (originalCave) {
+            const message = session.text("commands.cave.error.exactDuplicateFound");
+            await session.send(message + await buildMessage(originalCave, resourceDir, session));
+            throw new Error("duplicate_found");
+          }
+        }
+      }
+      if (mediaType === "img" && config.enableImageDuplicate) {
+        const result = await hashStorage.findDuplicates(
+          { images: [buffer] },
+          {
+            image: config.imageDuplicateThreshold,
+            text: config.textDuplicateThreshold
+          }
+        );
+        if (result.length > 0 && result[0] !== null) {
+          const duplicate = result[0];
+          const similarity = duplicate.similarity;
+          if (similarity >= config.imageDuplicateThreshold) {
+            const caveFilePath = path5.join(ctx.baseDir, "data", "cave", "cave.json");
+            const data = await FileHandler.readJsonData(caveFilePath);
+            const originalCave = data.find((item) => item.cave_id === duplicate.caveId);
+            if (originalCave) {
+              const message = session.text(
+                "commands.cave.error.similarDuplicateFound",
+                [(similarity * 100).toFixed(1)]
+              );
+              await session.send(message + await buildMessage(originalCave, resourceDir, session));
+              throw new Error("duplicate_found");
+            }
+          }
+        }
+      }
+      const finalFileName = `${caveId}_${md5}${ext}`;
+      const filePath = path5.join(resourceDir, finalFileName);
+      await FileHandler.saveMediaFile(filePath, buffer);
+      return finalFileName;
+    } catch (error) {
+      if (error.message === "duplicate_found") {
+        throw error;
+      }
+      logger4.error(`Failed to download media: ${error.message}`);
+      throw new Error(session.text(`commands.cave.error.upload${mediaType === "img" ? "Image" : "Video"}Failed`));
+    }
+  });
+  return Promise.all(downloadTasks);
+}
+__name(saveMedia, "saveMedia");
+async function buildMessage(cave, resourceDir, session) {
+  if (!cave?.elements?.length) {
+    return session.text("commands.cave.error.noContent");
+  }
+  const lines = [session.text("commands.cave.message.caveTitle", [cave.cave_id])];
+  for (const element of cave.elements) {
+    if (element.type === "text") {
+      lines.push(element.content);
+    }
+  }
+  lines.push(session.text("commands.cave.message.contributorSuffix", [cave.contributor_name]));
+  return lines.join("\n");
+}
+__name(buildMessage, "buildMessage");
+
 // src/index.ts
 var name = "best-cave";
 var inject = ["database"];
-var Config = import_koishi5.Schema.object({
-  manager: import_koishi5.Schema.array(import_koishi5.Schema.string()).required(),
+var Config = import_koishi6.Schema.object({
+  manager: import_koishi6.Schema.array(import_koishi6.Schema.string()).required(),
   // 管理员用户ID
-  number: import_koishi5.Schema.number().default(60),
+  number: import_koishi6.Schema.number().default(60),
   // 冷却时间(秒)
-  enableAudit: import_koishi5.Schema.boolean().default(false),
+  enableAudit: import_koishi6.Schema.boolean().default(false),
   // 启用审核
-  enableTextDuplicate: import_koishi5.Schema.boolean().default(true),
+  enableTextDuplicate: import_koishi6.Schema.boolean().default(true),
   // 启用文本查重
-  textDuplicateThreshold: import_koishi5.Schema.number().default(0.9),
+  textDuplicateThreshold: import_koishi6.Schema.number().default(0.9),
   // 文本查重阈值
-  enableImageDuplicate: import_koishi5.Schema.boolean().default(true),
+  enableImageDuplicate: import_koishi6.Schema.boolean().default(true),
   // 开启图片查重
-  imageDuplicateThreshold: import_koishi5.Schema.number().default(0.8),
+  imageDuplicateThreshold: import_koishi6.Schema.number().default(0.8),
   // 图片查重阈值
-  imageMaxSize: import_koishi5.Schema.number().default(4),
+  imageMaxSize: import_koishi6.Schema.number().default(4),
   // 图片大小限制(MB)
-  allowVideo: import_koishi5.Schema.boolean().default(true),
+  allowVideo: import_koishi6.Schema.boolean().default(true),
   // 允许视频
-  videoMaxSize: import_koishi5.Schema.number().default(16),
+  videoMaxSize: import_koishi6.Schema.number().default(16),
   // 视频大小限制(MB)
-  enablePagination: import_koishi5.Schema.boolean().default(false),
+  enablePagination: import_koishi6.Schema.boolean().default(false),
   // 启用分页
-  itemsPerPage: import_koishi5.Schema.number().default(10),
+  itemsPerPage: import_koishi6.Schema.number().default(10),
   // 每页条数
-  blacklist: import_koishi5.Schema.array(import_koishi5.Schema.string()).default([]),
+  blacklist: import_koishi6.Schema.array(import_koishi6.Schema.string()).default([]),
   // 黑名单
-  whitelist: import_koishi5.Schema.array(import_koishi5.Schema.string()).default([])
+  whitelist: import_koishi6.Schema.array(import_koishi6.Schema.string()).default([])
   // 白名单
 }).i18n({
   "zh-CN": require_zh_CN()._config,
@@ -1227,19 +1371,19 @@ var Config = import_koishi5.Schema.object({
 async function apply(ctx, config) {
   ctx.i18n.define("zh-CN", require_zh_CN());
   ctx.i18n.define("en-US", require_en_US());
-  const dataDir = path5.join(ctx.baseDir, "data");
-  const caveDir = path5.join(dataDir, "cave");
+  const dataDir = path6.join(ctx.baseDir, "data");
+  const caveDir = path6.join(dataDir, "cave");
   await FileHandler.ensureDirectory(dataDir);
   await FileHandler.ensureDirectory(caveDir);
-  await FileHandler.ensureDirectory(path5.join(caveDir, "resources"));
-  await FileHandler.ensureJsonFile(path5.join(caveDir, "cave.json"));
-  await FileHandler.ensureJsonFile(path5.join(caveDir, "pending.json"));
-  await FileHandler.ensureJsonFile(path5.join(caveDir, "hash.json"));
+  await FileHandler.ensureDirectory(path6.join(caveDir, "resources"));
+  await FileHandler.ensureJsonFile(path6.join(caveDir, "cave.json"));
+  await FileHandler.ensureJsonFile(path6.join(caveDir, "pending.json"));
+  await FileHandler.ensureJsonFile(path6.join(caveDir, "hash.json"));
   const idManager = new IdManager(ctx.baseDir);
   const contentHashManager = new ContentHashManager(caveDir);
   const auditManager = new AuditManager(ctx, config, caveDir, idManager);
   await Promise.all([
-    idManager.initialize(path5.join(caveDir, "cave.json"), path5.join(caveDir, "pending.json")),
+    idManager.initialize(path6.join(caveDir, "cave.json"), path6.join(caveDir, "pending.json")),
     contentHashManager.initialize()
   ]);
   const lastUsed = /* @__PURE__ */ new Map();
@@ -1265,26 +1409,13 @@ async function apply(ctx, config) {
     }
   }
   __name(processList, "processList");
-  async function processAudit(pendingFilePath, caveFilePath, resourceDir, session, options, content) {
-    const pendingData = await FileHandler.readJsonData(pendingFilePath);
-    const isApprove = Boolean(options.p);
-    if (options.p === true && content[0] === "all" || options.d === true && content[0] === "all") {
-      return await auditManager.processAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session);
-    }
-    const id = parseInt(content[0] || (typeof options.p === "string" ? options.p : "") || (typeof options.d === "string" ? options.d : ""));
-    if (isNaN(id)) {
-      return sendMessage(session, "commands.cave.error.invalidId", [], true);
-    }
-    return await auditManager.processAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, id);
-  }
-  __name(processAudit, "processAudit");
   async function processView(caveFilePath, resourceDir, session, options, content) {
     const caveId = parseInt(content[0] || (typeof options.g === "string" ? options.g : ""));
     if (isNaN(caveId)) return sendMessage(session, "commands.cave.error.invalidId", [], true);
     const data = await FileHandler.readJsonData(caveFilePath);
     const cave = data.find((item) => item.cave_id === caveId);
     if (!cave) return sendMessage(session, "commands.cave.error.notFound", [], true);
-    return buildMessage(cave, resourceDir, session);
+    return buildMessage2(cave, resourceDir, session);
   }
   __name(processView, "processView");
   async function processRandom(caveFilePath, resourceDir, session) {
@@ -1298,7 +1429,7 @@ async function apply(ctx, config) {
       const randomIndex = Math.floor(Math.random() * validCaves.length);
       return validCaves[randomIndex];
     })();
-    return cave ? buildMessage(cave, resourceDir, session) : sendMessage(session, "commands.cave.error.getCave", [], true);
+    return cave ? buildMessage2(cave, resourceDir, session) : sendMessage(session, "commands.cave.error.getCave", [], true);
   }
   __name(processRandom, "processRandom");
   async function processDelete(caveFilePath, resourceDir, pendingFilePath, session, config2, options, content) {
@@ -1316,7 +1447,7 @@ async function apply(ctx, config) {
     if (targetCave.contributor_number !== session.userId && !config2.manager.includes(session.userId)) {
       return sendMessage(session, "commands.cave.remove.noPermission", [], true);
     }
-    const caveContent = await buildMessage(targetCave, resourceDir, session);
+    const caveContent = await buildMessage2(targetCave, resourceDir, session);
     if (targetCave.elements) {
       await contentHashManager.updateCaveContent(caveId, {
         images: void 0,
@@ -1324,9 +1455,9 @@ async function apply(ctx, config) {
       });
       for (const element of targetCave.elements) {
         if ((element.type === "img" || element.type === "video") && element.file) {
-          const fullPath = path5.join(resourceDir, element.file);
-          if (fs5.existsSync(fullPath)) {
-            await fs5.promises.unlink(fullPath);
+          const fullPath = path6.join(resourceDir, element.file);
+          if (fs6.existsSync(fullPath)) {
+            await fs6.promises.unlink(fullPath);
           }
         }
       }
@@ -1355,9 +1486,15 @@ async function apply(ctx, config) {
       const inputContent = content.length > 0 ? content.join("\n") : await (async () => {
         await sendMessage(session, "commands.cave.add.noContent", [], true, 6e4);
         const reply = await session.prompt({ timeout: 6e4 });
-        if (!reply) sendMessage(session, "commands.cave.add.operationTimeout", [], true);
+        if (!reply) {
+          await sendMessage(session, "commands.cave.add.operationTimeout", [], true);
+          return null;
+        }
         return reply;
       })();
+      if (!inputContent) {
+        return "";
+      }
       if (inputContent.includes("/app/.config/QQ/")) {
         return sendMessage(session, "commands.cave.add.localFileNotAllowed", [], true);
       }
@@ -1415,7 +1552,7 @@ async function apply(ctx, config) {
           index: Number.MAX_SAFE_INTEGER
         });
       }
-      const hashStorage = new ContentHashManager(path5.join(ctx2.baseDir, "data", "cave"));
+      const hashStorage = new ContentHashManager(path6.join(ctx2.baseDir, "data", "cave"));
       await hashStorage.initialize();
       const hashStatus = await hashStorage.getStatus();
       if (!hashStatus.lastUpdated || hashStatus.entries.length === 0) {
@@ -1432,7 +1569,7 @@ async function apply(ctx, config) {
         pendingData.push(newCave);
         await Promise.all([
           FileHandler.writeJsonData(pendingFilePath, pendingData),
-          auditManager.sendAuditMessage(newCave, await buildMessage(newCave, resourceDir, session), session)
+          auditManager.sendAuditMessage(newCave, await buildMessage2(newCave, resourceDir, session), session)
         ]);
         return sendMessage(session, "commands.cave.add.submitPending", [caveId], false);
       }
@@ -1458,14 +1595,14 @@ async function apply(ctx, config) {
             "commands.cave.error.similarDuplicateFound",
             [(result.similarity * 100).toFixed(1)]
           );
-          await session.send(duplicateMessage + await buildMessage(originalCave, resourceDir, session));
+          await session.send(duplicateMessage + await buildMessage2(originalCave, resourceDir, session));
           throw new Error("duplicate_found");
         }
       }
       await Promise.all([
         FileHandler.writeJsonData(caveFilePath, data),
         contentHashManager.updateCaveContent(caveId, {
-          images: savedImages.length > 0 ? await Promise.all(savedImages.map((file) => fs5.promises.readFile(path5.join(resourceDir, file)))) : void 0,
+          images: savedImages.length > 0 ? await Promise.all(savedImages.map((file) => fs6.promises.readFile(path6.join(resourceDir, file)))) : void 0,
           texts: textParts.filter((p) => p.type === "text").map((p) => p.content)
         })
       ]);
@@ -1478,7 +1615,7 @@ async function apply(ctx, config) {
       if (error.message === "duplicate_found") {
         return "";
       }
-      logger4.error(`Failed to process add command: ${error.message}`);
+      logger5.error(`Failed to process add command: ${error.message}`);
       return sendMessage(session, "commands.cave.error.addFailed", [], true);
     }
   }
@@ -1488,11 +1625,11 @@ async function apply(ctx, config) {
       return sendMessage(session, "commands.cave.message.blacklisted", [], true);
     }
   }).action(async ({ session, options }, ...content) => {
-    const dataDir2 = path5.join(ctx.baseDir, "data");
-    const caveDir2 = path5.join(dataDir2, "cave");
-    const caveFilePath = path5.join(caveDir2, "cave.json");
-    const resourceDir = path5.join(caveDir2, "resources");
-    const pendingFilePath = path5.join(caveDir2, "pending.json");
+    const dataDir2 = path6.join(ctx.baseDir, "data");
+    const caveDir2 = path6.join(dataDir2, "cave");
+    const caveFilePath = path6.join(caveDir2, "cave.json");
+    const resourceDir = path6.join(caveDir2, "resources");
+    const pendingFilePath = path6.join(caveDir2, "pending.json");
     const needsCooldown = !options.l && !options.a;
     if (needsCooldown) {
       const guildId = session.guildId;
@@ -1539,42 +1676,30 @@ async function apply(ctx, config) {
       return sendMessage(session, "commands.cave.message.managerOnly", [], true);
     }
   }).action(async ({ session }, id) => {
-    const dataDir2 = path5.join(ctx.baseDir, "data");
-    const caveDir2 = path5.join(dataDir2, "cave");
-    const caveFilePath = path5.join(caveDir2, "cave.json");
-    const resourceDir = path5.join(caveDir2, "resources");
-    const pendingFilePath = path5.join(caveDir2, "pending.json");
-    return await processAudit(
-      pendingFilePath,
-      caveFilePath,
-      resourceDir,
-      session,
-      { p: true },
-      [id]
-    );
+    const dataDir2 = path6.join(ctx.baseDir, "data");
+    const caveDir2 = path6.join(dataDir2, "cave");
+    const caveFilePath = path6.join(caveDir2, "cave.json");
+    const resourceDir = path6.join(caveDir2, "resources");
+    const pendingFilePath = path6.join(caveDir2, "pending.json");
+    const pendingData = await FileHandler.readJsonData(pendingFilePath);
+    return await auditManager.processAudit(pendingData, true, caveFilePath, resourceDir, pendingFilePath, session, id === "all" ? void 0 : parseInt(id));
   });
   caveCommand.subcommand(".reject <id:text>", "拒绝回声洞审核").before(async ({ session }) => {
     if (!config.manager.includes(session.userId)) {
       return sendMessage(session, "commands.cave.message.managerOnly", [], true);
     }
   }).action(async ({ session }, id) => {
-    const dataDir2 = path5.join(ctx.baseDir, "data");
-    const caveDir2 = path5.join(dataDir2, "cave");
-    const caveFilePath = path5.join(caveDir2, "cave.json");
-    const resourceDir = path5.join(caveDir2, "resources");
-    const pendingFilePath = path5.join(caveDir2, "pending.json");
-    return await processAudit(
-      pendingFilePath,
-      caveFilePath,
-      resourceDir,
-      session,
-      { d: true },
-      [id]
-    );
+    const dataDir2 = path6.join(ctx.baseDir, "data");
+    const caveDir2 = path6.join(dataDir2, "cave");
+    const caveFilePath = path6.join(caveDir2, "cave.json");
+    const resourceDir = path6.join(caveDir2, "resources");
+    const pendingFilePath = path6.join(caveDir2, "pending.json");
+    const pendingData = await FileHandler.readJsonData(pendingFilePath);
+    return await auditManager.processAudit(pendingData, false, caveFilePath, resourceDir, pendingFilePath, session, id === "all" ? void 0 : parseInt(id));
   });
 }
 __name(apply, "apply");
-var logger4 = new import_koishi5.Logger("cave");
+var logger5 = new import_koishi6.Logger("cave");
 async function sendMessage(session, key, params = [], isTemp = true, timeout = 1e4) {
   try {
     const msg = await session.send(session.text(key, params));
@@ -1583,12 +1708,12 @@ async function sendMessage(session, key, params = [], isTemp = true, timeout = 1
         try {
           await session.bot.deleteMessage(session.channelId, msg);
         } catch (error) {
-          logger4.debug(`Failed to delete temporary message: ${error.message}`);
+          logger5.debug(`Failed to delete temporary message: ${error.message}`);
         }
       }, timeout);
     }
   } catch (error) {
-    logger4.error(`Failed to send message: ${error.message}`);
+    logger5.error(`Failed to send message: ${error.message}`);
   }
   return "";
 }
@@ -1618,12 +1743,12 @@ function cleanElementsForSave(elements, keepIndex = false) {
 }
 __name(cleanElementsForSave, "cleanElementsForSave");
 async function processMediaFile(filePath, type) {
-  const data = await fs5.promises.readFile(filePath).catch(() => null);
+  const data = await fs6.promises.readFile(filePath).catch(() => null);
   if (!data) return null;
   return `data:${type}/${type === "image" ? "png" : "mp4"};base64,${data.toString("base64")}`;
 }
 __name(processMediaFile, "processMediaFile");
-async function buildMessage(cave, resourceDir, session) {
+async function buildMessage2(cave, resourceDir, session) {
   if (!cave?.elements?.length) {
     return session.text("commands.cave.error.noContent");
   }
@@ -1635,10 +1760,10 @@ async function buildMessage(cave, resourceDir, session) {
       session.text("commands.cave.message.contributorSuffix", [cave.contributor_name])
     ].join("\n");
     await session?.send(basicInfo);
-    const filePath = path5.join(resourceDir, videoElement.file);
+    const filePath = path6.join(resourceDir, videoElement.file);
     const base64Data = await processMediaFile(filePath, "video");
     if (base64Data && session) {
-      await session.send((0, import_koishi5.h)("video", { src: base64Data }));
+      await session.send((0, import_koishi6.h)("video", { src: base64Data }));
     }
     return "";
   }
@@ -1647,141 +1772,17 @@ async function buildMessage(cave, resourceDir, session) {
     if (element.type === "text") {
       lines.push(element.content);
     } else if (element.type === "img" && element.file) {
-      const filePath = path5.join(resourceDir, element.file);
+      const filePath = path6.join(resourceDir, element.file);
       const base64Data = await processMediaFile(filePath, "image");
       if (base64Data) {
-        lines.push((0, import_koishi5.h)("image", { src: base64Data }));
+        lines.push((0, import_koishi6.h)("image", { src: base64Data }));
       }
     }
   }
   lines.push(session.text("commands.cave.message.contributorSuffix", [cave.contributor_name]));
   return lines.join("\n");
 }
-__name(buildMessage, "buildMessage");
-async function extractMediaContent(originalContent, config, session) {
-  const textParts = originalContent.split(/<(img|video)[^>]+>/).map((text, idx) => text.trim() && {
-    type: "text",
-    content: text.replace(/^(img|video)$/, "").trim(),
-    index: idx * 3
-  }).filter((text) => text && text.content);
-  const getMediaElements = /* @__PURE__ */ __name((type, maxSize) => {
-    const regex = new RegExp(`<${type}[^>]+src="([^"]+)"[^>]*>`, "g");
-    const elements = [];
-    const urls = [];
-    let match;
-    let idx = 0;
-    while ((match = regex.exec(originalContent)) !== null) {
-      const element = match[0];
-      const url = match[1];
-      const fileName = element.match(/file="([^"]+)"/)?.[1];
-      const fileSize = element.match(/fileSize="([^"]+)"/)?.[1];
-      if (fileSize) {
-        const sizeInBytes = parseInt(fileSize);
-        if (sizeInBytes > maxSize * 1024 * 1024) {
-          throw new Error(session.text("commands.cave.message.mediaSizeExceeded", [type]));
-        }
-      }
-      urls.push(url);
-      elements.push({
-        type,
-        index: type === "video" ? Number.MAX_SAFE_INTEGER : idx * 3 + 1,
-        fileName,
-        fileSize
-      });
-      idx++;
-    }
-    return { urls, elements };
-  }, "getMediaElements");
-  const { urls: imageUrls, elements: imageElementsRaw } = getMediaElements("img", config.imageMaxSize);
-  const imageElements = imageElementsRaw;
-  const { urls: videoUrls, elements: videoElementsRaw } = getMediaElements("video", config.videoMaxSize);
-  const videoElements = videoElementsRaw;
-  return { imageUrls, imageElements, videoUrls, videoElements, textParts };
-}
-__name(extractMediaContent, "extractMediaContent");
-async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config, ctx, session, buffers) {
-  const accept = mediaType === "img" ? "image/*" : "video/*";
-  const hashStorage = new ContentHashManager(path5.join(ctx.baseDir, "data", "cave"));
-  await hashStorage.initialize();
-  const downloadTasks = urls.map(async (url, i) => {
-    const fileName = fileNames[i];
-    const ext = path5.extname(fileName || url) || (mediaType === "img" ? ".png" : ".mp4");
-    try {
-      const response = await ctx.http(decodeURIComponent(url).replace(/&amp;/g, "&"), {
-        method: "GET",
-        responseType: "arraybuffer",
-        timeout: 3e4,
-        headers: {
-          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
-          "Accept": accept,
-          "Referer": "https://qq.com"
-        }
-      });
-      if (!response.data) throw new Error("empty_response");
-      const buffer = Buffer.from(response.data);
-      if (buffers && mediaType === "img") {
-        buffers.push(buffer);
-      }
-      const md5 = path5.basename(fileName || `${mediaType}`, ext).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
-      const files = await fs5.promises.readdir(resourceDir);
-      const duplicateFile = files.find((file) => {
-        const match = file.match(/^\d+_([^.]+)/);
-        return match && match[1] === md5;
-      });
-      if (duplicateFile) {
-        const duplicateCaveId = parseInt(duplicateFile.split("_")[0]);
-        if (!isNaN(duplicateCaveId)) {
-          const caveFilePath = path5.join(ctx.baseDir, "data", "cave", "cave.json");
-          const data = await FileHandler.readJsonData(caveFilePath);
-          const originalCave = data.find((item) => item.cave_id === duplicateCaveId);
-          if (originalCave) {
-            const message = session.text("commands.cave.error.exactDuplicateFound");
-            await session.send(message + await buildMessage(originalCave, resourceDir, session));
-            throw new Error("duplicate_found");
-          }
-        }
-      }
-      if (mediaType === "img" && config.enableImageDuplicate) {
-        const result = await hashStorage.findDuplicates(
-          { images: [buffer] },
-          {
-            image: config.imageDuplicateThreshold,
-            text: config.textDuplicateThreshold
-          }
-        );
-        if (result.length > 0 && result[0] !== null) {
-          const duplicate = result[0];
-          const similarity = duplicate.similarity;
-          if (similarity >= config.imageDuplicateThreshold) {
-            const caveFilePath = path5.join(ctx.baseDir, "data", "cave", "cave.json");
-            const data = await FileHandler.readJsonData(caveFilePath);
-            const originalCave = data.find((item) => item.cave_id === duplicate.caveId);
-            if (originalCave) {
-              const message = session.text(
-                "commands.cave.error.similarDuplicateFound",
-                [(similarity * 100).toFixed(1)]
-              );
-              await session.send(message + await buildMessage(originalCave, resourceDir, session));
-              throw new Error("duplicate_found");
-            }
-          }
-        }
-      }
-      const finalFileName = `${caveId}_${md5}${ext}`;
-      const filePath = path5.join(resourceDir, finalFileName);
-      await FileHandler.saveMediaFile(filePath, buffer);
-      return finalFileName;
-    } catch (error) {
-      if (error.message === "duplicate_found") {
-        throw error;
-      }
-      logger4.error(`Failed to download media: ${error.message}`);
-      throw new Error(session.text(`commands.cave.error.upload${mediaType === "img" ? "Image" : "Video"}Failed`));
-    }
-  });
-  return Promise.all(downloadTasks);
-}
-__name(saveMedia, "saveMedia");
+__name(buildMessage2, "buildMessage");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,

package/lib/utils/MediaHandle.d.ts

@@ -0,0 +1,42 @@
+import { Context } from 'koishi';
+export interface BaseElement {
+    type: 'text' | 'img' | 'video';
+    index: number;
+}
+export interface TextElement extends BaseElement {
+    type: 'text';
+    content: string;
+}
+export interface MediaElement extends BaseElement {
+    type: 'img' | 'video';
+    file?: string;
+    fileName?: string;
+    fileSize?: string;
+    filePath?: string;
+}
+export type Element = TextElement | MediaElement;
+export declare function extractMediaContent(originalContent: string, config: {
+    imageMaxSize: number;
+    videoMaxSize: number;
+}, session: any): Promise<{
+    imageUrls: string[];
+    imageElements: Array<{
+        type: 'img';
+        index: number;
+        fileName?: string;
+        fileSize?: string;
+    }>;
+    videoUrls: string[];
+    videoElements: Array<{
+        type: 'video';
+        index: number;
+        fileName?: string;
+        fileSize?: string;
+    }>;
+    textParts: Element[];
+}>;
+export declare function saveMedia(urls: string[], fileNames: (string | undefined)[], resourceDir: string, caveId: number, mediaType: 'img' | 'video', config: {
+    enableImageDuplicate: boolean;
+    imageDuplicateThreshold: number;
+    textDuplicateThreshold: number;
+}, ctx: Context, session: any, buffers?: Buffer[]): Promise<string[]>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "最好的 cave 插件，可开关的审核系统，可引用添加，支持图文混合内容，可查阅投稿列表，完美复刻你的 .cave 体验！",
-  "version": "1.5.3",
+  "version": "1.5.4",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],