koishi-plugin-best-cave 2.7.7 → 2.7.9

package/lib/Utils.d.ts

@@ -20,7 +20,7 @@ export declare function buildCaveMessage(cave: CaveObject, config: Config, fileM
  * @param logger 日志记录器实例。
  * @param reusableIds 可复用 ID 的内存缓存。
  */
-export declare function cleanupPendingDeletions(ctx: Context, fileManager: FileManager, logger: Logger, reusableIds: Set<number>): Promise<void>;
+export declare function cleanupPendingDeletions(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reusableIds: Set<number>): Promise<void>;
 /**
  * @description 根据配置和会话，生成数据库查询的范围条件。
  * @param session 当前会话。
@@ -81,7 +81,7 @@ export declare function performSimilarityChecks(ctx: Context, config: Config, ha
 export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, cave: CaveObject, downloadedMedia: {
     fileName: string;
     buffer: Buffer;
-}[], reusableIds: Set<number>, session: Session): Promise<'pending' | 'active' | 'delete'>;
+}[], reusableIds: Set<number>, session: Session): Promise<'pending' | 'active'>;
 /**
  * @description 校验会话是否来自指定的管理群组。
  * @param session 当前会话。

package/lib/index.js

@@ -321,7 +321,7 @@ async function buildCaveMessage(cave, config, fileManager, logger2, platform, pr
   return [finalInitialMessage, ...followUpMessages].filter((msg) => msg.length > 0);
 }
 __name(buildCaveMessage, "buildCaveMessage");
-async function cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds) {
+async function cleanupPendingDeletions(ctx, config, fileManager, logger2, reusableIds) {
   try {
     const cavesToDelete = await ctx.database.get("cave", { status: "delete" });
     if (!cavesToDelete.length) return;
@@ -331,7 +331,7 @@ async function cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds) {
     idsToDelete.forEach((id) => reusableIds.add(id));
     await ctx.database.remove("cave", { id: { $in: idsToDelete } });
     await ctx.database.remove("cave_hash", { cave: { $in: idsToDelete } });
-    await ctx.database.remove("cave_meta", { cave: { $in: idsToDelete } });
+    if (config.enableAI) await ctx.database.remove("cave_meta", { cave: { $in: idsToDelete } });
   } catch (error) {
     logger2.error("清理回声洞时发生错误:", error);
   }
@@ -492,8 +492,8 @@ async function handleFileUploads(ctx, config, fileManager, logger2, cave, downlo
   } catch (fileProcessingError) {
     logger2.error(`回声洞（${cave.id}）文件处理失败:`, fileProcessingError);
     await ctx.database.upsert("cave", [{ id: cave.id, status: "delete" }]);
-    cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds);
-    return "delete";
+    cleanupPendingDeletions(ctx, config, fileManager, logger2, reusableIds);
+    throw fileProcessingError;
   }
 }
 __name(handleFileUploads, "handleFileUploads");
@@ -655,7 +655,7 @@ ${pendingCaves.map((c) => c.id).join("|")}`;
         if (cavesToProcess.length === 0) return `回声洞（${idsToProcess.join("|")}）无需审核或不存在`;
         const processedIds = cavesToProcess.map((cave2) => cave2.id);
         await this.ctx.database.upsert("cave", processedIds.map((id) => ({ id, status: targetStatus })));
-        if (targetStatus === "delete") cleanupPendingDeletions(this.ctx, this.fileManager, this.logger, this.reusableIds);
+        if (targetStatus === "delete") cleanupPendingDeletions(this.ctx, this.config, this.fileManager, this.logger, this.reusableIds);
         return `已${actionText}回声洞（${processedIds.join("|")}）`;
       } catch (error) {
         this.logger.error(`审核操作失败:`, error);
@@ -722,42 +722,29 @@ var HashManager = class {
       if (requireAdmin(session, this.config)) return requireAdmin(session, this.config);
       try {
         const allCaves = await this.ctx.database.get("cave", { status: "active" });
-        if (allCaves.length === 0) return "无需补全回声洞哈希";
-        await session.send(`开始补全 ${allCaves.length} 个回声洞的哈希...`);
-        const existingHashes = await this.ctx.database.get("cave_hash", {});
-        const existingHashSet = new Set(existingHashes.map((h4) => `${h4.cave}-${h4.hash}-${h4.type}`));
-        let hashesToInsert = [];
+        const existingHashes = await this.ctx.database.get("cave_hash", {}, { fields: ["cave"] });
+        const hashedCaveIds = new Set(existingHashes.map((h4) => h4.cave));
+        const cavesToProcess = allCaves.filter((cave2) => !hashedCaveIds.has(cave2.id));
+        if (cavesToProcess.length === 0) return "无需补全回声洞哈希";
+        await session.send(`开始补全 ${cavesToProcess.length} 个回声洞的哈希...`);
+        const hashesToInsert = [];
         let processedCaveCount = 0;
-        let totalHashesGenerated = 0;
         let errorCount = 0;
-        const flushBatch = /* @__PURE__ */ __name(async () => {
-          if (hashesToInsert.length === 0) return;
-          await this.ctx.database.upsert("cave_hash", hashesToInsert);
-          totalHashesGenerated += hashesToInsert.length;
-          this.logger.info(`[${processedCaveCount}/${allCaves.length}] 正在导入 ${hashesToInsert.length} 条回声洞哈希...`);
-          hashesToInsert = [];
-        }, "flushBatch");
-        for (const cave2 of allCaves) {
+        for (const cave2 of cavesToProcess) {
           processedCaveCount++;
           try {
             const newHashesForCave = await this.generateAllHashesForCave(cave2);
-            for (const hashObj of newHashesForCave) {
-              const uniqueKey = `${hashObj.cave}-${hashObj.hash}-${hashObj.type}`;
-              if (!existingHashSet.has(uniqueKey)) {
-                hashesToInsert.push(hashObj);
-                existingHashSet.add(uniqueKey);
-              }
-            }
-            if (hashesToInsert.length >= 100) await flushBatch();
+            if (newHashesForCave.length > 0) hashesToInsert.push(...newHashesForCave);
           } catch (error) {
             errorCount++;
             this.logger.warn(`补全回声洞（${cave2.id}）哈希时出错: ${error.message}`);
           }
         }
-        await flushBatch();
-        return `已补全 ${allCaves.length} 个回声洞的 ${totalHashesGenerated} 条哈希（失败 ${errorCount} 条）`;
+        if (hashesToInsert.length > 0) await this.ctx.database.upsert("cave_hash", hashesToInsert);
+        const successCount = processedCaveCount - errorCount;
+        return `已补全 ${successCount} 个回声洞的 ${hashesToInsert.length} 条哈希（失败 ${errorCount} 条）`;
       } catch (error) {
-        this.logger.error("生成哈希失败:", error);
+        this.logger.error("补全哈希失败:", error);
         return `操作失败: ${error.message}`;
       }
     });
@@ -768,33 +755,41 @@ var HashManager = class {
         const textThreshold = options.textThreshold ?? this.config.textThreshold;
         const imageThreshold = options.imageThreshold ?? this.config.imageThreshold;
         const allHashes = await this.ctx.database.get("cave_hash", {});
-        const allCaveIds = [...new Set(allHashes.map((h4) => h4.cave))];
-        const textHashes = /* @__PURE__ */ new Map();
-        const imageHashes = /* @__PURE__ */ new Map();
-        for (const hash of allHashes) {
-          if (hash.type === "text") {
-            textHashes.set(hash.cave, hash.hash);
-          } else if (hash.type === "image") {
-            imageHashes.set(hash.cave, hash.hash);
+        if (allHashes.length < 2) return "无可比较哈希";
+        const buckets = /* @__PURE__ */ new Map();
+        const hashLookup = /* @__PURE__ */ new Map();
+        for (const hashObj of allHashes) {
+          if (!hashLookup.has(hashObj.cave)) hashLookup.set(hashObj.cave, {});
+          hashLookup.get(hashObj.cave)[hashObj.type] = hashObj.hash;
+          const binHash = BigInt("0x" + hashObj.hash).toString(2).padStart(64, "0");
+          for (let i = 0; i < 4; i++) {
+            const band = binHash.substring(i * 16, (i + 1) * 16);
+            const bucketKey = `${hashObj.type}:${i}:${band}`;
+            if (!buckets.has(bucketKey)) buckets.set(bucketKey, []);
+            buckets.get(bucketKey).push(hashObj.cave);
           }
         }
+        const candidatePairs = /* @__PURE__ */ new Set();
         const similarPairs = { text: /* @__PURE__ */ new Set(), image: /* @__PURE__ */ new Set() };
-        for (let i = 0; i < allCaveIds.length; i++) {
-          for (let j = i + 1; j < allCaveIds.length; j++) {
-            const id1 = allCaveIds[i];
-            const id2 = allCaveIds[j];
-            const pair = [id1, id2].sort((a, b) => a - b).join(" & ");
-            const text1 = textHashes.get(id1);
-            const text2 = textHashes.get(id2);
-            if (text1 && text2) {
-              const similarity = this.calculateSimilarity(text1, text2);
-              if (similarity >= textThreshold) similarPairs.text.add(`${pair} = ${similarity.toFixed(2)}%`);
-            }
-            const image1 = imageHashes.get(id1);
-            const image2 = imageHashes.get(id2);
-            if (image1 && image2) {
-              const similarity = this.calculateSimilarity(image1, image2);
-              if (similarity >= imageThreshold) similarPairs.image.add(`${pair} = ${similarity.toFixed(2)}%`);
+        for (const ids of buckets.values()) {
+          if (ids.length < 2) continue;
+          for (let i = 0; i < ids.length; i++) {
+            for (let j = i + 1; j < ids.length; j++) {
+              const id1 = ids[i];
+              const id2 = ids[j];
+              const pairKey = [id1, id2].sort((a, b) => a - b).join("-");
+              if (candidatePairs.has(pairKey)) continue;
+              candidatePairs.add(pairKey);
+              const cave1Hashes = hashLookup.get(id1);
+              const cave2Hashes = hashLookup.get(id2);
+              if (cave1Hashes?.text && cave2Hashes?.text) {
+                const similarity = this.calculateSimilarity(cave1Hashes.text, cave2Hashes.text);
+                if (similarity >= textThreshold) similarPairs.text.add(`${id1} & ${id2} = ${similarity.toFixed(2)}%`);
+              }
+              if (cave1Hashes?.image && cave2Hashes?.image) {
+                const similarity = this.calculateSimilarity(cave1Hashes.image, cave2Hashes.image);
+                if (similarity >= imageThreshold) similarPairs.image.add(`${id1} & ${id2} = ${similarity.toFixed(2)}%`);
+              }
             }
           }
         }
@@ -809,6 +804,68 @@ var HashManager = class {
         return `检查失败: ${error.message}`;
       }
     });
+    cave.subcommand(".fix [...ids:posint]", "修复回声洞", { hidden: true, authority: 3 }).usage("扫描并修复回声洞中的图片，可指定一个或多个 ID。").action(async ({ session }, ...ids) => {
+      if (requireAdmin(session, this.config)) return requireAdmin(session, this.config);
+      let cavesToProcess;
+      try {
+        await session.send("正在修复，请稍候...");
+        if (ids.length === 0) {
+          cavesToProcess = await this.ctx.database.get("cave", { status: "active" });
+        } else {
+          cavesToProcess = await this.ctx.database.get("cave", { id: { $in: ids }, status: "active" });
+        }
+        if (!cavesToProcess.length) return "无可修复的回声洞";
+        let fixedFiles = 0;
+        let errorCount = 0;
+        const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+        const JPEG_SIGNATURE = Buffer.from([255, 216]);
+        const GIF_SIGNATURE = Buffer.from("GIF");
+        for (const cave2 of cavesToProcess) {
+          const imageElements = cave2.elements.filter((el) => el.type === "image" && el.file);
+          for (const element of imageElements) {
+            try {
+              const originalBuffer = await this.fileManager.readFile(element.file);
+              let sanitizedBuffer = originalBuffer;
+              if (originalBuffer.slice(0, 8).equals(PNG_SIGNATURE)) {
+                const IEND_CHUNK = Buffer.from("IEND");
+                const iendIndex = originalBuffer.lastIndexOf(IEND_CHUNK);
+                if (iendIndex !== -1) {
+                  const endOfPngData = iendIndex + 8;
+                  if (originalBuffer.length > endOfPngData) sanitizedBuffer = originalBuffer.slice(0, endOfPngData);
+                }
+              } else if (originalBuffer.slice(0, 2).equals(JPEG_SIGNATURE)) {
+                const EOI_MARKER = Buffer.from([255, 217]);
+                const eoiIndex = originalBuffer.lastIndexOf(EOI_MARKER);
+                if (eoiIndex !== -1) {
+                  const endOfJpegData = eoiIndex + 2;
+                  if (originalBuffer.length > endOfJpegData) sanitizedBuffer = originalBuffer.slice(0, endOfJpegData);
+                }
+              } else if (originalBuffer.slice(0, 3).equals(GIF_SIGNATURE)) {
+                const GIF_TERMINATOR = Buffer.from([59]);
+                const terminatorIndex = originalBuffer.lastIndexOf(GIF_TERMINATOR);
+                if (terminatorIndex !== -1) {
+                  const endOfGifData = terminatorIndex + 1;
+                  if (originalBuffer.length > endOfGifData) sanitizedBuffer = originalBuffer.slice(0, endOfGifData);
+                }
+              }
+              if (!originalBuffer.equals(sanitizedBuffer)) {
+                await this.fileManager.saveFile(element.file, sanitizedBuffer);
+                fixedFiles++;
+              }
+            } catch (error) {
+              if (error.code !== "ENOENT" && error.name !== "NoSuchKey") {
+                this.logger.warn(`无法修复回声洞（${cave2.id}）的图片（${element.file}）:`, error);
+                errorCount++;
+              }
+            }
+          }
+        }
+        return `已修复 ${cavesToProcess.length} 个回声洞的 ${fixedFiles} 张图片（失败 ${errorCount} 条）`;
+      } catch (error) {
+        this.logger.error("修复图像文件时发生严重错误:", error);
+        return `操作失败: ${error.message}`;
+      }
+    });
   }
   /**
    * @description 为单个回声洞对象生成所有类型的哈希（文本+图片）。
@@ -835,8 +892,9 @@ var HashManager = class {
         const imageBuffer = await this.fileManager.readFile(el.file);
         const imageHash = await this.generatePHash(imageBuffer);
         addUniqueHash({ cave: cave.id, hash: imageHash, type: "image" });
-      } catch (e) {
-        this.logger.warn(`无法为回声洞（${cave.id}）的图片（${el.file}）生成哈希:`, e);
+      } catch (error) {
+        this.logger.warn(`无法为回声洞（${cave.id}）的图片（${el.file}）生成哈希:`, error);
+        throw error;
       }
     }
     return tempHashes;
@@ -1279,7 +1337,7 @@ function apply(ctx, config) {
       if (staleCaves.length > 0) {
         const idsToMark = staleCaves.map((c) => ({ id: c.id, status: "delete" }));
         await ctx.database.upsert("cave", idsToMark);
-        await cleanupPendingDeletions(ctx, fileManager, logger, reusableIds);
+        await cleanupPendingDeletions(ctx, config, fileManager, logger, reusableIds);
       }
     } catch (error) {
       logger.error("清理残留回声洞时发生错误:", error);
@@ -1353,7 +1411,7 @@ function apply(ctx, config) {
         time: creationTime
       });
       if (hasMedia) finalStatus = await handleFileUploads(ctx, config, fileManager, logger, newCave, downloadedMedia, reusableIds, session);
-      if (finalStatus !== "preload" && finalStatus !== "delete") {
+      if (finalStatus !== "preload") {
         newCave.status = finalStatus;
         if (aiManager) await aiManager.analyzeAndStore(newCave, downloadedMedia);
         if (hashManager) {
@@ -1390,8 +1448,8 @@ function apply(ctx, config) {
       if (!isAuthor && !isAdmin) return "你没有权限删除这条回声洞";
       await ctx.database.upsert("cave", [{ id, status: "delete" }]);
       const caveMessages = await buildCaveMessage(targetCave, config, fileManager, logger, session.platform, "已删除");
-      cleanupPendingDeletions(ctx, fileManager, logger, reusableIds);
       for (const message of caveMessages) if (message.length > 0) await session.send(import_koishi3.h.normalize(message));
+      cleanupPendingDeletions(ctx, config, fileManager, logger, reusableIds);
     } catch (error) {
       logger.error(`标记回声洞（${id}）失败:`, error);
       return "删除失败，请稍后再试";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "功能强大、高度可定制的回声洞。支持丰富的媒体类型、内容查重、人工审核、用户昵称、数据迁移以及本地/S3 双重文件存储后端。",
-  "version": "2.7.7",
+  "version": "2.7.9",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],