koishi-plugin-best-cave 1.2.0 → 1.3.1

package/lib/index.js

@@ -33,14 +33,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/locales/zh-CN.yml
 var require_zh_CN = __commonJS({
   "src/locales/zh-CN.yml"(exports2, module2) {
-    module2.exports = { _config: { manager: "管理员", blacklist: "黑名单（用户）", whitelist: "审核白名单（用户/群组/频道）", number: "冷却时间（秒）", enableAudit: "启用审核", allowVideo: "允许视频上传", videoMaxSize: "视频最大大小（MB）", imageMaxSize: "图片最大大小（MB）", enablePagination: "启用统计分页", itemsPerPage: "每页显示数目" }, commands: { cave: { description: "回声洞", usage: "支持添加、抽取、查看、管理回声洞", examples: "使用 cave 随机抽取回声洞\n使用 -a 直接添加或引用添加\n使用 -g 查看指定回声洞\n使用 -r 删除指定回声洞", options: { a: "添加回声洞", g: "查看回声洞", r: "删除回声洞", p: "通过审核（批量）", d: "拒绝审核（批量）", l: "查询投稿统计" }, add: { noContent: "请在一分钟内发送内容", operationTimeout: "操作超时，添加取消", videoDisabled: "不允许上传视频", submitPending: "提交成功，序号为（{0}）", addSuccess: "添加成功，序号为（{0}）", mediaSizeExceeded: "{0}文件大小超过限制", localFileNotAllowed: "检测到本地文件路径，无法保存" }, remove: { noPermission: "你无权删除他人添加的回声洞", deletePending: "删除（待审核）", deleted: "已删除" }, list: { pageInfo: "第 {0} / {1} 页", header: "当前共有 {0} 项回声洞：", totalItems: "用户 {0} 共计投稿 {1} 项：", idsLine: "{0}" }, audit: { noPending: "暂无待审核回声洞", pendingNotFound: "未找到待审核回声洞", pendingResult: "{0}，剩余 {1} 个待审核回声洞：[{2}]", auditPassed: "已通过", auditRejected: "已拒绝", batchAuditResult: "已{0} {1}/{2} 项回声洞", title: "待审核回声洞：", from: "投稿人：", sendFailed: "发送审核消息失败，无法联系管理员 {0}" }, error: { noContent: "回声洞内容为空", getCave: "获取回声洞失败", noCave: "没有回声洞", invalidId: "请输入有效的回声洞ID", notFound: "未找到该回声洞" }, message: { blacklisted: "你已被列入黑名单", managerOnly: "此操作仅限管理员可用", cooldown: "群聊冷却中...请在 {0} 秒后重试", caveTitle: "回声洞 —— （{0}）", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0}文件大小超过限制" } } } };
+    module2.exports = { _config: { manager: "管理员", number: "冷却时间（秒）", enableAudit: "启用审核", imageMaxSize: "图片最大大小（MB）", enableDuplicate: "启用图片查重", duplicateThreshold: "图片相似度阈值（0-1）", allowVideo: "允许视频上传", videoMaxSize: "视频最大大小（MB）", enablePagination: "启用统计分页", itemsPerPage: "每页显示数目", blacklist: "黑名单（用户）", whitelist: "审核白名单（用户/群组/频道）" }, commands: { cave: { description: "回声洞", usage: "支持添加、抽取、查看、管理回声洞", examples: "使用 cave 随机抽取回声洞\n使用 -a 直接添加或引用添加\n使用 -g 查看指定回声洞\n使用 -r 删除指定回声洞", options: { a: "添加回声洞", g: "查看回声洞", r: "删除回声洞", p: "通过审核（批量）", d: "拒绝审核（批量）", l: "查询投稿统计" }, add: { noContent: "请在一分钟内发送内容", operationTimeout: "操作超时，添加取消", videoDisabled: "不允许上传视频", submitPending: "提交成功，序号为（{0}）", addSuccess: "添加成功，序号为（{0}）", mediaSizeExceeded: "{0}文件大小超过限制", localFileNotAllowed: "检测到本地文件路径，无法保存" }, remove: { noPermission: "你无权删除他人添加的回声洞", deletePending: "删除（待审核）", deleted: "已删除" }, list: { pageInfo: "第 {0} / {1} 页", header: "当前共有 {0} 项回声洞：", totalItems: "用户 {0} 共计投稿 {1} 项：", idsLine: "{0}" }, audit: { noPending: "暂无待审核回声洞", pendingNotFound: "未找到待审核回声洞", pendingResult: "{0}，剩余 {1} 个待审核回声洞：[{2}]", auditPassed: "已通过", auditRejected: "已拒绝", batchAuditResult: "已{0} {1}/{2} 项回声洞", title: "待审核回声洞：", from: "投稿人：", sendFailed: "发送审核消息失败，无法联系管理员 {0}" }, error: { noContent: "回声洞内容为空", getCave: "获取回声洞失败", noCave: "没有回声洞", invalidId: "请输入有效的回声洞ID", notFound: "未找到该回声洞", exactDuplicateFound: "发现完全相同的", similarDuplicateFound: "发现相似度为 {0}% 的" }, message: { blacklisted: "你已被列入黑名单", managerOnly: "此操作仅限管理员可用", cooldown: "群聊冷却中...请在 {0} 秒后重试", caveTitle: "回声洞 —— （{0}）", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0}文件大小超过限制" } } } };
   }
 });
 
 // src/locales/en-US.yml
 var require_en_US = __commonJS({
   "src/locales/en-US.yml"(exports2, module2) {
-    module2.exports = { _config: { manager: "Administrators", blacklist: "Blacklist (Users)", whitelist: "Audit Whitelist (Users/Groups/Channels)", number: "Cooldown Time (seconds)", enableAudit: "Enable Audit", allowVideo: "Allow Video Upload", videoMaxSize: "Maximum Video Size (MB)", imageMaxSize: "Maximum Image Size (MB)", enablePagination: "Enable Statistics Pagination", itemsPerPage: "Items Per Page" }, commands: { cave: { description: "Echo Cave", usage: "Supports adding, drawing, viewing, and managing echo cave entries", examples: "Use cave to randomly draw an entry\nUse -a to add directly or add by reference\nUse -g to view specific entry\nUse -r to delete specific entry", options: { a: "Add entry", g: "View entry", r: "Delete entry", p: "Approve audit (batch)", d: "Reject audit (batch)", l: "Query submission statistics" }, add: { noContent: "Please send content within one minute", operationTimeout: "Operation timed out, addition cancelled", videoDisabled: "Video upload is not allowed", submitPending: "Submission successful, ID is ({0})", addSuccess: "Addition successful, ID is ({0})", mediaSizeExceeded: "{0} file size exceeds limit", localFileNotAllowed: "Local file path detected, cannot save" }, remove: { noPermission: "You don't have permission to delete others' entries", deletePending: "Delete (pending audit)", deleted: "Deleted" }, list: { pageInfo: "Page {0} / {1}", header: "Currently there are {0} entries:", totalItems: "User {0} has submitted {1} entries:", idsLine: "{0}" }, audit: { noPending: "No pending entries", pendingNotFound: "Pending entry not found", pendingResult: "{0}, {1} pending entries remaining: [{2}]", auditPassed: "Approved", auditRejected: "Rejected", batchAuditResult: "Has {0} {1}/{2} entries", title: "Pending Entries:", from: "Submitted by:", sendFailed: "Failed to send audit message, cannot contact administrator {0}" }, error: { noContent: "Entry content is empty", getCave: "Failed to get entry", noCave: "No entries found", invalidId: "Please enter a valid entry ID", notFound: "Entry not found" }, message: { blacklisted: "You have been blacklisted", managerOnly: "This operation is restricted to administrators", cooldown: "Group chat cooling down... Please try again in {0} seconds", caveTitle: "Echo Cave —— ({0})", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0} file size exceeds limit" } } } };
+    module2.exports = { _config: { manager: "Administrator", number: "Cooldown time (seconds)", enableAudit: "Enable moderation", imageMaxSize: "Maximum image size (MB)", enableDuplicate: "Enable image duplicate check", duplicateThreshold: "Image similarity threshold (0-1)", allowVideo: "Allow video upload", videoMaxSize: "Maximum video size (MB)", enablePagination: "Enable statistics pagination", itemsPerPage: "Items per page", blacklist: "Blacklist (users)", whitelist: "Moderation whitelist (users/groups/channels)" }, commands: { cave: { description: "Echo Cave", usage: "Support adding, drawing, viewing, and managing echo caves", examples: "Use cave to randomly draw an echo\nUse -a to add directly or add by reference\nUse -g to view specific echo\nUse -r to delete specific echo", options: { a: "Add echo", g: "View echo", r: "Delete echo", p: "Approve moderation (batch)", d: "Reject moderation (batch)", l: "Query submission statistics" }, add: { noContent: "Please send content within one minute", operationTimeout: "Operation timeout, addition cancelled", videoDisabled: "Video upload not allowed", submitPending: "Submission successful, ID is ({0})", addSuccess: "Added successfully, ID is ({0})", mediaSizeExceeded: "{0} file size exceeds limit", localFileNotAllowed: "Local file path detected, cannot save" }, remove: { noPermission: "You don't have permission to delete others' echos", deletePending: "Delete (pending review)", deleted: "Deleted" }, list: { pageInfo: "Page {0} / {1}", header: "Currently there are {0} echos:", totalItems: "User {0} has submitted {1} items:", idsLine: "{0}" }, audit: { noPending: "No pending echos for review", pendingNotFound: "Pending echo not found", pendingResult: "{0}, {1} pending echos remaining: [{2}]", auditPassed: "Approved", auditRejected: "Rejected", batchAuditResult: "{0} {1}/{2} echos", title: "Pending echos:", from: "Submitted by:", sendFailed: "Failed to send moderation message, cannot contact administrator {0}" }, error: { noContent: "Echo content is empty", getCave: "Failed to get echo", noCave: "No echos available", invalidId: "Please enter a valid echo ID", notFound: "Echo not found", exactDuplicateFound: "Found exactly identical", similarDuplicateFound: "Found {0}% similar" }, message: { blacklisted: "You have been blacklisted", managerOnly: "This operation is limited to administrators only", cooldown: "Group chat cooling down... Please try again in {0} seconds", caveTitle: "Echo Cave —— ({0})", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0} file size exceeds limit" } } } };
   }
 });
 
@@ -53,22 +53,879 @@ __export(src_exports, {
   name: () => name
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi = require("koishi");
+var import_koishi4 = require("koishi");
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+
+// src/utils/fileHandler.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
+var import_koishi = require("koishi");
+var logger = new import_koishi.Logger("fileHandler");
+var FileHandler = class {
+  static {
+    __name(this, "FileHandler");
+  }
+  static locks = /* @__PURE__ */ new Map();
+  static RETRY_COUNT = 3;
+  static RETRY_DELAY = 1e3;
+  static CONCURRENCY_LIMIT = 5;
+  /**
+   * 并发控制
+   * @param operation 要执行的操作
+   * @param limit 并发限制
+   * @returns 操作结果
+   */
+  static async withConcurrencyLimit(operation, limit = this.CONCURRENCY_LIMIT) {
+    while (this.locks.size >= limit) {
+      await Promise.race(this.locks.values());
+    }
+    return operation();
+  }
+  /**
+   * 文件操作包装器
+   * @param filePath 文件路径
+   * @param operation 要执行的操作
+   * @returns 操作结果
+   */
+  static async withFileOp(filePath, operation) {
+    const key = filePath;
+    while (this.locks.has(key)) {
+      await this.locks.get(key);
+    }
+    const operationPromise = (async () => {
+      for (let i = 0; i < this.RETRY_COUNT; i++) {
+        try {
+          return await operation();
+        } catch (error) {
+          if (i === this.RETRY_COUNT - 1) throw error;
+          await new Promise((resolve) => setTimeout(resolve, this.RETRY_DELAY));
+        }
+      }
+      throw new Error("Operation failed after retries");
+    })();
+    this.locks.set(key, operationPromise);
+    try {
+      return await operationPromise;
+    } finally {
+      this.locks.delete(key);
+    }
+  }
+  /**
+   * 事务处理
+   * @param operations 要执行的操作数组
+   * @returns 操作结果数组
+   */
+  static async withTransaction(operations) {
+    const results = [];
+    const completed = /* @__PURE__ */ new Set();
+    try {
+      for (const { filePath, operation } of operations) {
+        const result = await this.withFileOp(filePath, operation);
+        results.push(result);
+        completed.add(filePath);
+      }
+      return results;
+    } catch (error) {
+      await Promise.all(
+        operations.filter(({ filePath }) => completed.has(filePath)).map(async ({ filePath, rollback }) => {
+          if (rollback) {
+            await this.withFileOp(filePath, rollback).catch(
+              (e) => logger.error(`Rollback failed for ${filePath}: ${e.message}`)
+            );
+          }
+        })
+      );
+      throw error;
+    }
+  }
+  /**
+   * 读取 JSON 数据
+   * @param filePath 文件路径
+   * @returns JSON 数据
+   */
+  static async readJsonData(filePath) {
+    return this.withFileOp(filePath, async () => {
+      try {
+        const data = await fs.promises.readFile(filePath, "utf8");
+        return JSON.parse(data || "[]");
+      } catch (error) {
+        return [];
+      }
+    });
+  }
+  /**
+   * 写入 JSON 数据
+   * @param filePath 文件路径
+   * @param data 要写入的数据
+   */
+  static async writeJsonData(filePath, data) {
+    const tmpPath = `${filePath}.tmp`;
+    await this.withFileOp(filePath, async () => {
+      await fs.promises.writeFile(tmpPath, JSON.stringify(data, null, 2));
+      await fs.promises.rename(tmpPath, filePath);
+    });
+  }
+  /**
+   * 确保目录存在
+   * @param dir 目录路径
+   */
+  static async ensureDirectory(dir) {
+    await this.withConcurrencyLimit(async () => {
+      if (!fs.existsSync(dir)) {
+        await fs.promises.mkdir(dir, { recursive: true });
+      }
+    });
+  }
+  /**
+   * 确保 JSON 文件存在
+   * @param filePath 文件路径
+   */
+  static async ensureJsonFile(filePath) {
+    await this.withFileOp(filePath, async () => {
+      if (!fs.existsSync(filePath)) {
+        await fs.promises.writeFile(filePath, "[]", "utf8");
+      }
+    });
+  }
+  /**
+   * 保存媒体文件
+   * @param filePath 文件路径
+   * @param data 文件数据
+   */
+  static async saveMediaFile(filePath, data) {
+    await this.withConcurrencyLimit(async () => {
+      const dir = path.dirname(filePath);
+      await this.ensureDirectory(dir);
+      await this.withFileOp(
+        filePath,
+        () => fs.promises.writeFile(filePath, data)
+      );
+    });
+  }
+  /**
+   * 删除媒体文件
+   * @param filePath 文件路径
+   */
+  static async deleteMediaFile(filePath) {
+    await this.withFileOp(filePath, async () => {
+      if (fs.existsSync(filePath)) {
+        await fs.promises.unlink(filePath);
+      }
+    });
+  }
+};
+
+// src/utils/idManager.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_koishi2 = require("koishi");
+var logger2 = new import_koishi2.Logger("idManager");
+var IdManager = class {
+  static {
+    __name(this, "IdManager");
+  }
+  deletedIds = /* @__PURE__ */ new Set();
+  maxId = 0;
+  initialized = false;
+  statusFilePath;
+  stats = {};
+  usedIds = /* @__PURE__ */ new Set();
+  /**
+   * 初始化ID管理器
+   * @param baseDir - 基础目录路径
+   */
+  constructor(baseDir) {
+    const caveDir = path2.join(baseDir, "data", "cave");
+    this.statusFilePath = path2.join(caveDir, "status.json");
+  }
+  /**
+   * 初始化ID管理系统
+   * @param caveFilePath - 正式回声洞数据文件路径
+   * @param pendingFilePath - 待处理回声洞数据文件路径
+   * @throws 当初始化失败时抛出错误
+   */
+  async initialize(caveFilePath, pendingFilePath) {
+    if (this.initialized) return;
+    try {
+      const status = fs2.existsSync(this.statusFilePath) ? JSON.parse(await fs2.promises.readFile(this.statusFilePath, "utf8")) : {
+        deletedIds: [],
+        maxId: 0,
+        stats: {},
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const [caveData, pendingData] = await Promise.all([
+        FileHandler.readJsonData(caveFilePath),
+        FileHandler.readJsonData(pendingFilePath)
+      ]);
+      this.usedIds.clear();
+      this.stats = {};
+      const conflicts = /* @__PURE__ */ new Map();
+      for (const data of [caveData, pendingData]) {
+        for (const item of data) {
+          if (this.usedIds.has(item.cave_id)) {
+            if (!conflicts.has(item.cave_id)) {
+              conflicts.set(item.cave_id, []);
+            }
+            conflicts.get(item.cave_id)?.push(item);
+          } else {
+            this.usedIds.add(item.cave_id);
+            if (data === caveData && item.contributor_number !== "10000") {
+              if (!this.stats[item.contributor_number]) {
+                this.stats[item.contributor_number] = [];
+              }
+              this.stats[item.contributor_number].push(item.cave_id);
+            }
+          }
+        }
+      }
+      if (conflicts.size > 0) {
+        await this.handleConflicts(conflicts, caveFilePath, pendingFilePath, caveData, pendingData);
+      }
+      this.maxId = Math.max(
+        status.maxId || 0,
+        ...[...this.usedIds],
+        ...status.deletedIds || [],
+        0
+      );
+      this.deletedIds = new Set(
+        status.deletedIds?.filter((id) => !this.usedIds.has(id)) || []
+      );
+      await this.saveStatus();
+      this.initialized = true;
+      logger2.success("ID Manager initialized");
+    } catch (error) {
+      this.initialized = false;
+      logger2.error(`ID Manager initialization failed: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * 处理ID冲突
+   * @param conflicts - ID冲突映射表
+   * @param caveFilePath - 正式回声洞数据文件路径
+   * @param pendingFilePath - 待处理回声洞数据文件路径
+   * @param caveData - 正式回声洞数据
+   * @param pendingData - 待处理回声洞数据
+   * @private
+   */
+  async handleConflicts(conflicts, caveFilePath, pendingFilePath, caveData, pendingData) {
+    logger2.warn(`Found ${conflicts.size} ID conflicts`);
+    let modified = false;
+    for (const items of conflicts.values()) {
+      items.slice(1).forEach((item) => {
+        let newId = this.maxId + 1;
+        while (this.usedIds.has(newId)) {
+          newId++;
+        }
+        logger2.info(`Reassigning ID: ${item.cave_id} -> ${newId}`);
+        item.cave_id = newId;
+        this.usedIds.add(newId);
+        this.maxId = Math.max(this.maxId, newId);
+        modified = true;
+      });
+    }
+    if (modified) {
+      await Promise.all([
+        FileHandler.writeJsonData(caveFilePath, caveData),
+        FileHandler.writeJsonData(pendingFilePath, pendingData)
+      ]);
+      logger2.success("ID conflicts resolved");
+    }
+  }
+  /**
+   * 获取下一个可用的ID
+   * @returns 下一个可用的ID
+   * @throws 当ID管理器未初始化时抛出错误
+   */
+  getNextId() {
+    if (!this.initialized) {
+      throw new Error("IdManager not initialized");
+    }
+    let nextId;
+    if (this.deletedIds.size === 0) {
+      nextId = ++this.maxId;
+    } else {
+      nextId = Math.min(...Array.from(this.deletedIds));
+      this.deletedIds.delete(nextId);
+    }
+    while (this.usedIds.has(nextId)) {
+      nextId = ++this.maxId;
+    }
+    this.usedIds.add(nextId);
+    this.saveStatus().catch(
+      (err) => logger2.error(`Failed to save status after getNextId: ${err.message}`)
+    );
+    return nextId;
+  }
+  /**
+   * 标记ID为已删除状态
+   * @param id - 要标记为删除的ID
+   * @throws 当ID管理器未初始化时抛出错误
+   */
+  async markDeleted(id) {
+    if (!this.initialized) {
+      throw new Error("IdManager not initialized");
+    }
+    this.deletedIds.add(id);
+    this.usedIds.delete(id);
+    const maxUsedId = Math.max(...Array.from(this.usedIds), 0);
+    const maxDeletedId = Math.max(...Array.from(this.deletedIds), 0);
+    this.maxId = Math.max(maxUsedId, maxDeletedId);
+    await this.saveStatus();
+  }
+  /**
+   * 添加贡献统计
+   * @param contributorNumber - 贡献者编号
+   * @param caveId - 回声洞ID
+   */
+  async addStat(contributorNumber, caveId) {
+    if (contributorNumber === "10000") return;
+    if (!this.stats[contributorNumber]) {
+      this.stats[contributorNumber] = [];
+    }
+    this.stats[contributorNumber].push(caveId);
+    await this.saveStatus();
+  }
+  /**
+   * 移除贡献统计
+   * @param contributorNumber - 贡献者编号
+   * @param caveId - 回声洞ID
+   */
+  async removeStat(contributorNumber, caveId) {
+    if (this.stats[contributorNumber]) {
+      this.stats[contributorNumber] = this.stats[contributorNumber].filter((id) => id !== caveId);
+      if (this.stats[contributorNumber].length === 0) {
+        delete this.stats[contributorNumber];
+      }
+      await this.saveStatus();
+    }
+  }
+  /**
+   * 获取所有贡献统计信息
+   * @returns 贡献者编号到回声洞ID列表的映射
+   */
+  getStats() {
+    return this.stats;
+  }
+  /**
+   * 保存当前状态到文件
+   * @private
+   * @throws 当保存失败时抛出错误
+   */
+  async saveStatus() {
+    try {
+      const status = {
+        deletedIds: Array.from(this.deletedIds).sort((a, b) => a - b),
+        maxId: this.maxId,
+        stats: this.stats,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const tmpPath = `${this.statusFilePath}.tmp`;
+      await fs2.promises.writeFile(tmpPath, JSON.stringify(status, null, 2), "utf8");
+      await fs2.promises.rename(tmpPath, this.statusFilePath);
+    } catch (error) {
+      logger2.error(`Status save failed: ${error.message}`);
+      throw error;
+    }
+  }
+};
+
+// src/utils/HashStorage.ts
+var import_koishi3 = require("koishi");
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+
+// src/utils/ImageHasher.ts
+var import_sharp = __toESM(require("sharp"));
+var ImageHasher = class {
+  static {
+    __name(this, "ImageHasher");
+  }
+  /**
+   * 计算图片的感知哈希值
+   * @param imageBuffer - 图片的二进制数据
+   * @returns 返回64位的十六进制哈希字符串
+   * @throws 当图片处理失败时可能抛出错误
+   */
+  static async calculateHash(imageBuffer) {
+    const { data } = await (0, import_sharp.default)(imageBuffer).grayscale().resize(32, 32, { fit: "fill" }).raw().toBuffer({ resolveWithObject: true });
+    const dctMatrix = this.computeDCT(data, 32);
+    const features = this.extractFeatures(dctMatrix, 32);
+    const median = this.calculateMedian(features);
+    const binaryHash = features.map((val) => val > median ? "1" : "0").join("");
+    return this.binaryToHex(binaryHash);
+  }
+  /**
+   * 将二进制字符串转换为十六进制
+   * @param binary - 二进制字符串
+   * @returns 十六进制字符串
+   * @private
+   */
+  static binaryToHex(binary) {
+    const hex = [];
+    for (let i = 0; i < binary.length; i += 4) {
+      const chunk = binary.slice(i, i + 4);
+      hex.push(parseInt(chunk, 2).toString(16));
+    }
+    return hex.join("");
+  }
+  /**
+   * 将十六进制字符串转换为二进制
+   * @param hex - 十六进制字符串
+   * @returns 二进制字符串
+   * @private
+   */
+  static hexToBinary(hex) {
+    let binary = "";
+    for (const char of hex) {
+      const bin = parseInt(char, 16).toString(2).padStart(4, "0");
+      binary += bin;
+    }
+    return binary;
+  }
+  /**
+   * 计算图像的DCT(离散余弦变换)
+   * @param data - 图像数据
+   * @param size - 图像尺寸
+   * @returns DCT变换后的矩阵
+   * @private
+   */
+  static computeDCT(data, size) {
+    const matrix = Array(size).fill(0).map(() => Array(size).fill(0));
+    const output = Array(size).fill(0).map(() => Array(size).fill(0));
+    for (let i = 0; i < size; i++) {
+      for (let j = 0; j < size; j++) {
+        matrix[i][j] = data[i * size + j];
+      }
+    }
+    for (let u = 0; u < size; u++) {
+      for (let v = 0; v < size; v++) {
+        let sum = 0;
+        for (let x = 0; x < size; x++) {
+          for (let y = 0; y < size; y++) {
+            const cx = Math.cos((2 * x + 1) * u * Math.PI / (2 * size));
+            const cy = Math.cos((2 * y + 1) * v * Math.PI / (2 * size));
+            sum += matrix[x][y] * cx * cy;
+          }
+        }
+        output[u][v] = sum * this.getDCTCoefficient(u, size) * this.getDCTCoefficient(v, size);
+      }
+    }
+    return output;
+  }
+  /**
+   * 获取DCT系数
+   * @param index - 索引值
+   * @param size - 矩阵大小
+   * @returns DCT系数
+   * @private
+   */
+  static getDCTCoefficient(index, size) {
+    return index === 0 ? Math.sqrt(1 / size) : Math.sqrt(2 / size);
+  }
+  /**
+   * 计算数组的中位数
+   * @param arr - 输入数组
+   * @returns 中位数
+   * @private
+   */
+  static calculateMedian(arr) {
+    const sorted = [...arr].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+  /**
+   * 从DCT矩阵中提取特征值
+   * @param matrix - DCT矩阵
+   * @param size - 矩阵大小
+   * @returns 特征值数组
+   * @private
+   */
+  static extractFeatures(matrix, size) {
+    const features = [];
+    const featureSize = 8;
+    for (let i = 0; i < featureSize; i++) {
+      for (let j = 0; j < featureSize; j++) {
+        features.push(matrix[i][j]);
+      }
+    }
+    return features;
+  }
+  /**
+   * 计算两个哈希值之间的汉明距离
+   * @param hash1 - 第一个哈希值
+   * @param hash2 - 第二个哈希值
+   * @returns 汉明距离
+   * @throws 当两个哈希值长度不等时抛出错误
+   */
+  static calculateDistance(hash1, hash2) {
+    if (hash1.length !== hash2.length) {
+      throw new Error("Hash lengths must be equal");
+    }
+    const bin1 = this.hexToBinary(hash1);
+    const bin2 = this.hexToBinary(hash2);
+    let distance = 0;
+    for (let i = 0; i < bin1.length; i++) {
+      if (bin1[i] !== bin2[i]) distance++;
+    }
+    return distance;
+  }
+  /**
+   * 计算两个图片哈希值的相似度
+   * @param hash1 - 第一个哈希值
+   * @param hash2 - 第二个哈希值
+   * @returns 返回0-1之间的相似度值，1表示完全相同，0表示完全不同
+   */
+  static calculateSimilarity(hash1, hash2) {
+    const distance = this.calculateDistance(hash1, hash2);
+    return (64 - distance) / 64;
+  }
+  /**
+   * 批量比较一个新哈希值与多个已存在哈希值的相似度
+   * @param newHash - 新的哈希值
+   * @param existingHashes - 已存在的哈希值数组
+   * @returns 相似度数组，每个元素对应一个已存在哈希值的相似度
+   */
+  static batchCompareSimilarity(newHash, existingHashes) {
+    return existingHashes.map((hash) => this.calculateSimilarity(newHash, hash));
+  }
+};
+
+// src/utils/HashStorage.ts
+var import_util = require("util");
+var logger3 = new import_koishi3.Logger("HashStorage");
+var readFileAsync = (0, import_util.promisify)(fs3.readFile);
+var HashStorage = class _HashStorage {
+  /**
+   * 初始化HashStorage实例
+   * @param caveDir 回声洞数据目录路径
+   */
+  constructor(caveDir) {
+    this.caveDir = caveDir;
+  }
+  static {
+    __name(this, "HashStorage");
+  }
+  // 哈希数据文件名
+  static HASH_FILE = "hash.json";
+  // 回声洞数据文件名
+  static CAVE_FILE = "cave.json";
+  // 批处理大小
+  static BATCH_SIZE = 50;
+  // 存储回声洞ID到图片哈希值的映射
+  hashes = /* @__PURE__ */ new Map();
+  // 初始化状态标志
+  initialized = false;
+  get filePath() {
+    return path3.join(this.caveDir, _HashStorage.HASH_FILE);
+  }
+  get resourceDir() {
+    return path3.join(this.caveDir, "resources");
+  }
+  get caveFilePath() {
+    return path3.join(this.caveDir, _HashStorage.CAVE_FILE);
+  }
+  /**
+   * 初始化哈希存储
+   * 读取现有哈希数据或重新构建哈希值
+   * @throws 初始化失败时抛出错误
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      const hashData = await FileHandler.readJsonData(this.filePath).then((data) => data[0]).catch(() => null);
+      if (!hashData?.hashes || Object.keys(hashData.hashes).length === 0) {
+        this.hashes.clear();
+        await this.buildInitialHashes();
+      } else {
+        this.hashes = new Map(
+          Object.entries(hashData.hashes).map(([k, v]) => [Number(k), v])
+        );
+        await this.updateMissingHashes();
+      }
+      this.initialized = true;
+    } catch (error) {
+      logger3.error(`Initialization failed: ${error.message}`);
+      this.initialized = false;
+      throw error;
+    }
+  }
+  /**
+   * 获取当前哈希存储状态
+   * @returns 包含最后更新时间和所有条目的状态对象
+   */
+  async getStatus() {
+    if (!this.initialized) await this.initialize();
+    return {
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      entries: Array.from(this.hashes.entries()).map(([caveId, hashes]) => ({
+        caveId,
+        hashes
+      }))
+    };
+  }
+  /**
+   * 更新指定回声洞的图片哈希值
+   * @param caveId 回声洞ID
+   * @param imgBuffers 图片buffer数组
+   */
+  async updateCaveHash(caveId, imgBuffers) {
+    if (!this.initialized) await this.initialize();
+    try {
+      if (imgBuffers?.length) {
+        const hashes = await Promise.all(
+          imgBuffers.map((buffer) => ImageHasher.calculateHash(buffer))
+        );
+        this.hashes.set(caveId, hashes);
+      } else {
+        this.hashes.delete(caveId);
+      }
+      await this.saveHashes();
+    } catch (error) {
+      logger3.error(`Failed to update hash (cave ${caveId}): ${error.message}`);
+    }
+  }
+  /**
+   * 更新所有回声洞的哈希值
+   * @param isInitialBuild 是否为初始构建
+   */
+  async updateAllCaves(isInitialBuild = false) {
+    if (!this.initialized && !isInitialBuild) {
+      await this.initialize();
+      return;
+    }
+    try {
+      logger3.info("Starting full hash update...");
+      const caveData = await this.loadCaveData();
+      const cavesWithImages = caveData.filter(
+        (cave) => cave.elements?.some((el) => el.type === "img" && el.file)
+      );
+      this.hashes.clear();
+      let processedCount = 0;
+      const totalImages = cavesWithImages.length;
+      const processCave = /* @__PURE__ */ __name(async (cave) => {
+        const imgElements = cave.elements?.filter((el) => el.type === "img" && el.file) || [];
+        if (imgElements.length === 0) return;
+        try {
+          const hashes = await Promise.all(
+            imgElements.map(async (imgElement) => {
+              const filePath = path3.join(this.resourceDir, imgElement.file);
+              if (!fs3.existsSync(filePath)) {
+                logger3.warn(`Image file not found: ${filePath}`);
+                return null;
+              }
+              const imgBuffer = await readFileAsync(filePath);
+              return await ImageHasher.calculateHash(imgBuffer);
+            })
+          );
+          const validHashes = hashes.filter((hash) => hash !== null);
+          if (validHashes.length > 0) {
+            this.hashes.set(cave.cave_id, validHashes);
+            processedCount++;
+            if (processedCount % 100 === 0) {
+              logger3.info(`Progress: ${processedCount}/${totalImages}`);
+            }
+          }
+        } catch (error) {
+          logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
+        }
+      }, "processCave");
+      await this.processBatch(cavesWithImages, processCave);
+      await this.saveHashes();
+      logger3.success(`Update completed. Processed ${processedCount}/${totalImages} images`);
+    } catch (error) {
+      logger3.error(`Full update failed: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * 查找重复的图片
+   * @param imgBuffers 待查找的图片buffer数组
+   * @param threshold 相似度阈值
+   * @returns 匹配结果数组，包含索引、回声洞ID和相似度
+   */
+  async findDuplicates(imgBuffers, threshold) {
+    if (!this.initialized) await this.initialize();
+    const inputHashes = await Promise.all(
+      imgBuffers.map((buffer) => ImageHasher.calculateHash(buffer))
+    );
+    const existingHashes = Array.from(this.hashes.entries());
+    return Promise.all(
+      inputHashes.map(async (hash, index) => {
+        try {
+          let maxSimilarity = 0;
+          let matchedCaveId = null;
+          for (const [caveId, hashes] of existingHashes) {
+            for (const existingHash of hashes) {
+              const similarity = ImageHasher.calculateSimilarity(hash, existingHash);
+              if (similarity >= threshold && similarity > maxSimilarity) {
+                maxSimilarity = similarity;
+                matchedCaveId = caveId;
+                if (Math.abs(similarity - 1) < Number.EPSILON) break;
+              }
+            }
+            if (Math.abs(maxSimilarity - 1) < Number.EPSILON) break;
+          }
+          return matchedCaveId ? {
+            index,
+            caveId: matchedCaveId,
+            similarity: maxSimilarity
+          } : null;
+        } catch (error) {
+          logger3.warn(`处理图片 ${index} 失败: ${error.message}`);
+          return null;
+        }
+      })
+    );
+  }
+  /**
+   * 加载回声洞数据
+   * @returns 回声洞数据数组
+   * @private
+   */
+  async loadCaveData() {
+    const data = await FileHandler.readJsonData(this.caveFilePath);
+    return Array.isArray(data) ? data.flat() : [];
+  }
+  /**
+   * 保存哈希数据到文件
+   * @private
+   */
+  async saveHashes() {
+    const data = {
+      hashes: Object.fromEntries(this.hashes),
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await FileHandler.writeJsonData(this.filePath, [data]);
+  }
+  /**
+   * 构建初始哈希数据
+   * @private
+   */
+  async buildInitialHashes() {
+    const caveData = await this.loadCaveData();
+    let processedImageCount = 0;
+    const totalImages = caveData.reduce((sum, cave) => sum + (cave.elements?.filter((el) => el.type === "img" && el.file).length || 0), 0);
+    logger3.info(`Building hash data for ${totalImages} images...`);
+    for (const cave of caveData) {
+      const imgElements = cave.elements?.filter((el) => el.type === "img" && el.file) || [];
+      if (imgElements.length === 0) continue;
+      try {
+        const hashes = await Promise.all(
+          imgElements.map(async (imgElement) => {
+            const filePath = path3.join(this.resourceDir, imgElement.file);
+            if (!fs3.existsSync(filePath)) {
+              logger3.warn(`Image not found: ${filePath}`);
+              return null;
+            }
+            const imgBuffer = await fs3.promises.readFile(filePath);
+            const hash = await ImageHasher.calculateHash(imgBuffer);
+            processedImageCount++;
+            if (processedImageCount % 100 === 0) {
+              logger3.info(`Progress: ${processedImageCount}/${totalImages} images`);
+            }
+            return hash;
+          })
+        );
+        const validHashes = hashes.filter((hash) => hash !== null);
+        if (validHashes.length > 0) {
+          this.hashes.set(cave.cave_id, validHashes);
+        }
+      } catch (error) {
+        logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
+      }
+    }
+    await this.saveHashes();
+    logger3.success(`Build completed. Processed ${processedImageCount}/${totalImages} images`);
+  }
+  /**
+   * 更新缺失的哈希值
+   * @private
+   */
+  async updateMissingHashes() {
+    const caveData = await this.loadCaveData();
+    let updatedCount = 0;
+    for (const cave of caveData) {
+      if (this.hashes.has(cave.cave_id)) continue;
+      const imgElements = cave.elements?.filter((el) => el.type === "img" && el.file) || [];
+      if (imgElements.length === 0) continue;
+      try {
+        const hashes = await Promise.all(
+          imgElements.map(async (imgElement) => {
+            const filePath = path3.join(this.resourceDir, imgElement.file);
+            if (!fs3.existsSync(filePath)) {
+              return null;
+            }
+            const imgBuffer = await fs3.promises.readFile(filePath);
+            return ImageHasher.calculateHash(imgBuffer);
+          })
+        );
+        const validHashes = hashes.filter((hash) => hash !== null);
+        if (validHashes.length > 0) {
+          this.hashes.set(cave.cave_id, validHashes);
+          updatedCount++;
+        }
+      } catch (error) {
+        logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
+      }
+    }
+    if (updatedCount > 0) {
+      await this.saveHashes();
+      logger3.info(`Updated ${updatedCount} new hashes`);
+    }
+  }
+  /**
+   * 批量处理数组项
+   * @param items 待处理项数组
+   * @param processor 处理函数
+   * @param batchSize 批处理大小
+   * @private
+   */
+  async processBatch(items, processor, batchSize = _HashStorage.BATCH_SIZE) {
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      await Promise.all(
+        batch.map(async (item) => {
+          try {
+            await processor(item);
+          } catch (error) {
+            logger3.error(`Batch processing error: ${error.message}`);
+          }
+        })
+      );
+    }
+  }
+};
+
+// src/index.ts
 var name = "best-cave";
 var inject = ["database"];
-var Config = import_koishi.Schema.object({
-  manager: import_koishi.Schema.array(import_koishi.Schema.string()).required(),
-  blacklist: import_koishi.Schema.array(import_koishi.Schema.string()).default([]),
-  whitelist: import_koishi.Schema.array(import_koishi.Schema.string()).default([]),
-  number: import_koishi.Schema.number().default(60),
-  enableAudit: import_koishi.Schema.boolean().default(false),
-  allowVideo: import_koishi.Schema.boolean().default(true),
-  videoMaxSize: import_koishi.Schema.number().default(16),
-  imageMaxSize: import_koishi.Schema.number().default(4),
-  enablePagination: import_koishi.Schema.boolean().default(false),
-  itemsPerPage: import_koishi.Schema.number().default(10)
+var Config = import_koishi4.Schema.object({
+  manager: import_koishi4.Schema.array(import_koishi4.Schema.string()).required(),
+  // 管理员用户ID
+  number: import_koishi4.Schema.number().default(60),
+  // 冷却时间(秒)
+  enableAudit: import_koishi4.Schema.boolean().default(false),
+  // 启用审核
+  imageMaxSize: import_koishi4.Schema.number().default(4),
+  // 图片大小限制(MB)
+  enableDuplicate: import_koishi4.Schema.boolean().default(true),
+  // 开启查重
+  duplicateThreshold: import_koishi4.Schema.number().default(0.8),
+  // 查重阈值(0-1)
+  allowVideo: import_koishi4.Schema.boolean().default(true),
+  // 允许视频
+  videoMaxSize: import_koishi4.Schema.number().default(16),
+  // 视频大小限制(MB)
+  enablePagination: import_koishi4.Schema.boolean().default(false),
+  // 启用分页
+  itemsPerPage: import_koishi4.Schema.number().default(10),
+  // 每页条数
+  blacklist: import_koishi4.Schema.array(import_koishi4.Schema.string()).default([]),
+  // 黑名单
+  whitelist: import_koishi4.Schema.array(import_koishi4.Schema.string()).default([])
+  // 白名单
 }).i18n({
   "zh-CN": require_zh_CN()._config,
   "en-US": require_en_US()._config
@@ -76,18 +933,20 @@ var Config = import_koishi.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 = path.join(ctx.baseDir, "data");
-  const caveDir = path.join(dataDir, "cave");
-  const caveFilePath = path.join(caveDir, "cave.json");
-  const resourceDir = path.join(caveDir, "resources");
-  const pendingFilePath = path.join(caveDir, "pending.json");
+  const dataDir = path4.join(ctx.baseDir, "data");
+  const caveDir = path4.join(dataDir, "cave");
   await FileHandler.ensureDirectory(dataDir);
   await FileHandler.ensureDirectory(caveDir);
-  await FileHandler.ensureDirectory(resourceDir);
-  await FileHandler.ensureJsonFile(caveFilePath);
-  await FileHandler.ensureJsonFile(pendingFilePath);
+  await FileHandler.ensureDirectory(path4.join(caveDir, "resources"));
+  await FileHandler.ensureJsonFile(path4.join(caveDir, "cave.json"));
+  await FileHandler.ensureJsonFile(path4.join(caveDir, "pending.json"));
+  await FileHandler.ensureJsonFile(path4.join(caveDir, "hash.json"));
   const idManager = new IdManager(ctx.baseDir);
-  await idManager.initialize(caveFilePath, pendingFilePath);
+  const hashStorage = new HashStorage(caveDir);
+  await Promise.all([
+    idManager.initialize(path4.join(caveDir, "cave.json"), path4.join(caveDir, "pending.json")),
+    hashStorage.initialize()
+  ]);
   const lastUsed = /* @__PURE__ */ new Map();
   async function processList(session, config2, userId, pageNum = 1) {
     const stats = idManager.getStats();
@@ -111,53 +970,47 @@ async function apply(ctx, config) {
     }
   }
   __name(processList, "processList");
-  async function processAudit(ctx2, pendingFilePath2, caveFilePath2, resourceDir2, session, options, content) {
-    const pendingData = await FileHandler.readJsonData(pendingFilePath2);
+  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 handleAudit(ctx2, pendingData, isApprove, caveFilePath2, resourceDir2, pendingFilePath2, session);
+      return await handleAudit(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 sendMessage(session, await handleAudit(ctx2, pendingData, isApprove, caveFilePath2, resourceDir2, pendingFilePath2, session, id), [], true);
+    return sendMessage(session, await handleAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, id), [], true);
   }
   __name(processAudit, "processAudit");
-  async function processView(caveFilePath2, resourceDir2, session, options, content, config2) {
-    if (!await checkCooldown(session, config2)) {
-      return "";
-    }
+  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(caveFilePath2);
+    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, resourceDir2, session);
+    return buildMessage(cave, resourceDir, session);
   }
   __name(processView, "processView");
-  async function processRandom(caveFilePath2, resourceDir2, session, config2) {
-    const data = await FileHandler.readJsonData(caveFilePath2);
+  async function processRandom(caveFilePath, resourceDir, session) {
+    const data = await FileHandler.readJsonData(caveFilePath);
     if (data.length === 0) {
       return sendMessage(session, "commands.cave.error.noCave", [], true);
     }
-    if (!await checkCooldown(session, config2)) {
-      return "";
-    }
     const cave = (() => {
       const validCaves = data.filter((cave2) => cave2.elements && cave2.elements.length > 0);
       if (!validCaves.length) return void 0;
       const randomIndex = Math.floor(Math.random() * validCaves.length);
       return validCaves[randomIndex];
     })();
-    return cave ? buildMessage(cave, resourceDir2, session) : sendMessage(session, "commands.cave.error.getCave", [], true);
+    return cave ? buildMessage(cave, resourceDir, session) : sendMessage(session, "commands.cave.error.getCave", [], true);
   }
   __name(processRandom, "processRandom");
-  async function processDelete(caveFilePath2, resourceDir2, pendingFilePath2, session, config2, options, content) {
+  async function processDelete(caveFilePath, resourceDir, pendingFilePath, session, config2, options, content) {
     const caveId = parseInt(content[0] || (typeof options.r === "string" ? options.r : ""));
     if (isNaN(caveId)) return sendMessage(session, "commands.cave.error.invalidId", [], true);
-    const data = await FileHandler.readJsonData(caveFilePath2);
-    const pendingData = await FileHandler.readJsonData(pendingFilePath2);
+    const data = await FileHandler.readJsonData(caveFilePath);
+    const pendingData = await FileHandler.readJsonData(pendingFilePath);
     const targetInData = data.find((item) => item.cave_id === caveId);
     const targetInPending = pendingData.find((item) => item.cave_id === caveId);
     if (!targetInData && !targetInPending) {
@@ -168,23 +1021,26 @@ 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, resourceDir2, session);
+    const caveContent = await buildMessage(targetCave, resourceDir, session);
     if (targetCave.elements) {
+      const hashStorage2 = new HashStorage(caveDir);
+      await hashStorage2.initialize();
+      await hashStorage2.updateCaveHash(caveId);
       for (const element of targetCave.elements) {
         if ((element.type === "img" || element.type === "video") && element.file) {
-          const fullPath = path.join(resourceDir2, element.file);
-          if (fs.existsSync(fullPath)) {
-            await fs.promises.unlink(fullPath);
+          const fullPath = path4.join(resourceDir, element.file);
+          if (fs4.existsSync(fullPath)) {
+            await fs4.promises.unlink(fullPath);
           }
         }
       }
     }
     if (isPending) {
       const newPendingData = pendingData.filter((item) => item.cave_id !== caveId);
-      await FileHandler.writeJsonData(pendingFilePath2, newPendingData);
+      await FileHandler.writeJsonData(pendingFilePath, newPendingData);
     } else {
       const newData = data.filter((item) => item.cave_id !== caveId);
-      await FileHandler.writeJsonData(caveFilePath2, newData);
+      await FileHandler.writeJsonData(caveFilePath, newData);
       await idManager.removeStat(targetCave.contributor_number, caveId);
     }
     await idManager.markDeleted(caveId);
@@ -193,7 +1049,7 @@ async function apply(ctx, config) {
     return `${deleteMessage}${deleteStatus}${caveContent}`;
   }
   __name(processDelete, "processDelete");
-  async function processAdd(ctx2, config2, caveFilePath2, resourceDir2, pendingFilePath2, session, content) {
+  async function processAdd(ctx2, config2, caveFilePath, resourceDir, pendingFilePath, session, content) {
     try {
       const inputContent = content.length > 0 ? content.join("\n") : await (async () => {
         await sendMessage(session, "commands.cave.add.noContent", [], true);
@@ -214,18 +1070,20 @@ async function apply(ctx, config) {
         imageUrls.length > 0 ? saveMedia(
           imageUrls,
           imageElements.map((el) => el.fileName),
-          resourceDir2,
+          resourceDir,
           caveId,
           "img",
+          config2,
           ctx2,
           session
         ) : [],
         videoUrls.length > 0 ? saveMedia(
           videoUrls,
           videoElements.map((el) => el.fileName),
-          resourceDir2,
+          resourceDir,
           caveId,
           "video",
+          config2,
           ctx2,
           session
         ) : []
@@ -240,7 +1098,7 @@ async function apply(ctx, config) {
             // 保持原始文本和图片的相对位置
             index: el.index
           }))
-        ].sort((a, b) => a.index - b.index),
+        ].sort((a, b) => a.index - a.index),
         contributor_number: session.userId,
         contributor_name: session.username
       };
@@ -249,33 +1107,46 @@ async function apply(ctx, config) {
           type: "video",
           file: savedVideos[0],
           index: Number.MAX_SAFE_INTEGER
-          // 确保视频总是在最后
         });
       }
+      const hashStorage2 = new HashStorage(path4.join(ctx2.baseDir, "data", "cave"));
+      await hashStorage2.initialize();
+      const hashStatus = await hashStorage2.getStatus();
+      if (!hashStatus.lastUpdated || hashStatus.entries.length === 0) {
+        const existingData = await FileHandler.readJsonData(caveFilePath);
+        const hasImages = existingData.some(
+          (cave) => cave.elements?.some((element) => element.type === "img" && element.file)
+        );
+        if (hasImages) {
+          await hashStorage2.updateAllCaves(true);
+        }
+      }
       if (config2.enableAudit && !bypassAudit) {
-        const pendingData = await FileHandler.readJsonData(pendingFilePath2);
+        const pendingData = await FileHandler.readJsonData(pendingFilePath);
         pendingData.push(newCave);
         await Promise.all([
-          FileHandler.writeJsonData(pendingFilePath2, pendingData),
-          sendAuditMessage(ctx2, config2, newCave, await buildMessage(newCave, resourceDir2, session), session)
+          FileHandler.writeJsonData(pendingFilePath, pendingData),
+          sendAuditMessage(ctx2, config2, newCave, await buildMessage(newCave, resourceDir, session), session)
         ]);
         return sendMessage(session, "commands.cave.add.submitPending", [caveId], false);
       }
-      const data = await FileHandler.readJsonData(caveFilePath2);
+      const data = await FileHandler.readJsonData(caveFilePath);
       data.push({
         ...newCave,
         elements: cleanElementsForSave(newCave.elements, false)
       });
-      await FileHandler.writeJsonData(caveFilePath2, data);
+      await Promise.all([
+        FileHandler.writeJsonData(caveFilePath, data),
+        hashStorage2.updateCaveHash(caveId)
+      ]);
       await idManager.addStat(session.userId, caveId);
       return sendMessage(session, "commands.cave.add.addSuccess", [caveId], false);
     } catch (error) {
-      logger.error(`Failed to process add command: ${error.message}`);
-      return sendMessage(session, `commands.cave.error.${error.code || "unknown"}`, [], true);
+      logger4.error(`Failed to process add command: ${error.message}`);
     }
   }
   __name(processAdd, "processAdd");
-  async function handleAudit(ctx2, pendingData, isApprove, caveFilePath2, resourceDir2, pendingFilePath2, session, targetId) {
+  async function handleAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, targetId) {
     if (pendingData.length === 0) {
       return sendMessage(session, "commands.cave.audit.noPending", [], true);
     }
@@ -286,36 +1157,34 @@ async function apply(ctx, config) {
       }
       const newPendingData = pendingData.filter((item) => item.cave_id !== targetId);
       if (isApprove) {
-        const oldCaveData = await FileHandler.readJsonData(caveFilePath2);
+        const oldCaveData = await FileHandler.readJsonData(caveFilePath);
         const newCaveData = [...oldCaveData, {
           ...targetCave,
           cave_id: targetId,
-          // 明确指定ID
-          // 保存到 cave.json 时移除 index
           elements: cleanElementsForSave(targetCave.elements, false)
         }];
         await FileHandler.withTransaction([
           {
-            filePath: caveFilePath2,
-            operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath2, newCaveData), "operation"),
-            rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath2, oldCaveData), "rollback")
+            filePath: caveFilePath,
+            operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, newCaveData), "operation"),
+            rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, oldCaveData), "rollback")
           },
           {
-            filePath: pendingFilePath2,
-            operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath2, newPendingData), "operation"),
-            rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath2, pendingData), "rollback")
+            filePath: pendingFilePath,
+            operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, newPendingData), "operation"),
+            rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, pendingData), "rollback")
           }
         ]);
         await idManager.addStat(targetCave.contributor_number, targetId);
       } else {
-        await FileHandler.writeJsonData(pendingFilePath2, newPendingData);
+        await FileHandler.writeJsonData(pendingFilePath, newPendingData);
         await idManager.markDeleted(targetId);
         if (targetCave.elements) {
           for (const element of targetCave.elements) {
             if ((element.type === "img" || element.type === "video") && element.file) {
-              const fullPath = path.join(resourceDir2, element.file);
-              if (fs.existsSync(fullPath)) {
-                await fs.promises.unlink(fullPath);
+              const fullPath = path4.join(resourceDir, element.file);
+              if (fs4.existsSync(fullPath)) {
+                await fs4.promises.unlink(fullPath);
               }
             }
           }
@@ -338,48 +1207,46 @@ async function apply(ctx, config) {
         false
       );
     }
-    const data = isApprove ? await FileHandler.readJsonData(caveFilePath2) : null;
+    const data = isApprove ? await FileHandler.readJsonData(caveFilePath) : null;
     let processedCount = 0;
     if (isApprove && data) {
       const oldData = [...data];
       const newData = [...data];
       await FileHandler.withTransaction([
         {
-          filePath: caveFilePath2,
+          filePath: caveFilePath,
           operation: /* @__PURE__ */ __name(async () => {
             for (const cave of pendingData) {
               newData.push({
                 ...cave,
                 cave_id: cave.cave_id,
-                // 确保ID保持不变
-                // 保存到 cave.json 时移除 index
                 elements: cleanElementsForSave(cave.elements, false)
               });
               processedCount++;
               await idManager.addStat(cave.contributor_number, cave.cave_id);
             }
-            return FileHandler.writeJsonData(caveFilePath2, newData);
+            return FileHandler.writeJsonData(caveFilePath, newData);
           }, "operation"),
-          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath2, oldData), "rollback")
+          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, oldData), "rollback")
         },
         {
-          filePath: pendingFilePath2,
-          operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath2, []), "operation"),
-          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath2, pendingData), "rollback")
+          filePath: pendingFilePath,
+          operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, []), "operation"),
+          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, pendingData), "rollback")
         }
       ]);
     } else {
       for (const cave of pendingData) {
         await idManager.markDeleted(cave.cave_id);
       }
-      await FileHandler.writeJsonData(pendingFilePath2, []);
+      await FileHandler.writeJsonData(pendingFilePath, []);
       for (const cave of pendingData) {
         if (cave.elements) {
           for (const element of cave.elements) {
             if ((element.type === "img" || element.type === "video") && element.file) {
-              const fullPath = path.join(resourceDir2, element.file);
-              if (fs.existsSync(fullPath)) {
-                await fs.promises.unlink(fullPath);
+              const fullPath = path4.join(resourceDir, element.file);
+              if (fs4.existsSync(fullPath)) {
+                await fs4.promises.unlink(fullPath);
               }
             }
           }
@@ -394,20 +1261,6 @@ async function apply(ctx, config) {
     ], false);
   }
   __name(handleAudit, "handleAudit");
-  async function checkCooldown(session, config2) {
-    const guildId = session.guildId;
-    const now = Date.now();
-    const lastTime = lastUsed.get(guildId) || 0;
-    const isManager = config2.manager.includes(session.userId);
-    if (!isManager && now - lastTime < config2.number * 1e3) {
-      const waitTime = Math.ceil((config2.number * 1e3 - (now - lastTime)) / 1e3);
-      await sendMessage(session, "commands.cave.message.cooldown", [waitTime], true);
-      return false;
-    }
-    lastUsed.set(guildId, now);
-    return true;
-  }
-  __name(checkCooldown, "checkCooldown");
   ctx.command("cave [message]").option("a", "添加回声洞").option("g", "查看回声洞", { type: "string" }).option("r", "删除回声洞", { type: "string" }).option("p", "通过审核", { type: "string" }).option("d", "拒绝审核", { type: "string" }).option("l", "查询投稿统计", { type: "string" }).before(async ({ session, options }) => {
     if (config.blacklist.includes(session.userId)) {
       return sendMessage(session, "commands.cave.message.blacklisted", [], true);
@@ -416,11 +1269,23 @@ async function apply(ctx, config) {
       return sendMessage(session, "commands.cave.message.managerOnly", [], true);
     }
   }).action(async ({ session, options }, ...content) => {
-    const dataDir2 = path.join(ctx.baseDir, "data");
-    const caveDir2 = path.join(dataDir2, "cave");
-    const caveFilePath2 = path.join(caveDir2, "cave.json");
-    const resourceDir2 = path.join(caveDir2, "resources");
-    const pendingFilePath2 = path.join(caveDir2, "pending.json");
+    const dataDir2 = path4.join(ctx.baseDir, "data");
+    const caveDir2 = path4.join(dataDir2, "cave");
+    const caveFilePath = path4.join(caveDir2, "cave.json");
+    const resourceDir = path4.join(caveDir2, "resources");
+    const pendingFilePath = path4.join(caveDir2, "pending.json");
+    const needsCooldown = !options.l && !options.a && !options.p && !options.d;
+    if (needsCooldown) {
+      const guildId = session.guildId;
+      const now = Date.now();
+      const lastTime = lastUsed.get(guildId) || 0;
+      const isManager = config.manager.includes(session.userId);
+      if (!isManager && now - lastTime < config.number * 1e3) {
+        const waitTime = Math.ceil((config.number * 1e3 - (now - lastTime)) / 1e3);
+        return sendMessage(session, "commands.cave.message.cooldown", [waitTime], true);
+      }
+      lastUsed.set(guildId, now);
+    }
     if (options.l !== void 0) {
       const input = typeof options.l === "string" ? options.l : content[0];
       const num = parseInt(input);
@@ -440,311 +1305,22 @@ async function apply(ctx, config) {
       }
     }
     if (options.p || options.d) {
-      return await processAudit(ctx, pendingFilePath2, caveFilePath2, resourceDir2, session, options, content);
+      return await processAudit(pendingFilePath, caveFilePath, resourceDir, session, options, content);
     }
     if (options.g) {
-      return await processView(caveFilePath2, resourceDir2, session, options, content, config);
+      return await processView(caveFilePath, resourceDir, session, options, content);
     }
     if (options.r) {
-      return await processDelete(caveFilePath2, resourceDir2, pendingFilePath2, session, config, options, content);
+      return await processDelete(caveFilePath, resourceDir, pendingFilePath, session, config, options, content);
     }
     if (options.a) {
-      return await processAdd(ctx, config, caveFilePath2, resourceDir2, pendingFilePath2, session, content);
+      return await processAdd(ctx, config, caveFilePath, resourceDir, pendingFilePath, session, content);
     }
-    return await processRandom(caveFilePath2, resourceDir2, session, config);
+    return await processRandom(caveFilePath, resourceDir, session);
   });
 }
 __name(apply, "apply");
-var logger = new import_koishi.Logger("cave");
-var FileHandler = class {
-  static {
-    __name(this, "FileHandler");
-  }
-  static locks = /* @__PURE__ */ new Map();
-  static RETRY_COUNT = 3;
-  static RETRY_DELAY = 1e3;
-  static CONCURRENCY_LIMIT = 5;
-  /**
-   * 并发控制
-   */
-  static async withConcurrencyLimit(operation, limit = this.CONCURRENCY_LIMIT) {
-    while (this.locks.size >= limit) {
-      await Promise.race(this.locks.values());
-    }
-    return operation();
-  }
-  /**
-   * 统一的文件操作包装器
-   */
-  static async withFileOp(filePath, operation) {
-    const key = filePath;
-    while (this.locks.has(key)) {
-      await this.locks.get(key);
-    }
-    const operationPromise = (async () => {
-      for (let i = 0; i < this.RETRY_COUNT; i++) {
-        try {
-          return await operation();
-        } catch (error) {
-          if (i === this.RETRY_COUNT - 1) throw error;
-          await new Promise((resolve) => setTimeout(resolve, this.RETRY_DELAY));
-        }
-      }
-      throw new Error("Operation failed after retries");
-    })();
-    this.locks.set(key, operationPromise);
-    try {
-      return await operationPromise;
-    } finally {
-      this.locks.delete(key);
-    }
-  }
-  /**
-   * 事务处理
-   */
-  static async withTransaction(operations) {
-    const results = [];
-    const completed = /* @__PURE__ */ new Set();
-    try {
-      for (const { filePath, operation } of operations) {
-        const result = await this.withFileOp(filePath, operation);
-        results.push(result);
-        completed.add(filePath);
-      }
-      return results;
-    } catch (error) {
-      await Promise.all(
-        operations.filter(({ filePath }) => completed.has(filePath)).map(async ({ filePath, rollback }) => {
-          if (rollback) {
-            await this.withFileOp(filePath, rollback).catch(
-              (e) => logger.error(`Rollback failed for ${filePath}: ${e.message}`)
-            );
-          }
-        })
-      );
-      throw error;
-    }
-  }
-  /**
-   * JSON文件读写
-   */
-  static async readJsonData(filePath) {
-    return this.withFileOp(filePath, async () => {
-      try {
-        const data = await fs.promises.readFile(filePath, "utf8");
-        return JSON.parse(data || "[]");
-      } catch (error) {
-        return [];
-      }
-    });
-  }
-  static async writeJsonData(filePath, data) {
-    const tmpPath = `${filePath}.tmp`;
-    await this.withFileOp(filePath, async () => {
-      await fs.promises.writeFile(tmpPath, JSON.stringify(data, null, 2));
-      await fs.promises.rename(tmpPath, filePath);
-    });
-  }
-  /**
-   * 文件系统操作
-   */
-  static async ensureDirectory(dir) {
-    await this.withConcurrencyLimit(async () => {
-      if (!fs.existsSync(dir)) {
-        await fs.promises.mkdir(dir, { recursive: true });
-      }
-    });
-  }
-  static async ensureJsonFile(filePath) {
-    await this.withFileOp(filePath, async () => {
-      if (!fs.existsSync(filePath)) {
-        await fs.promises.writeFile(filePath, "[]", "utf8");
-      }
-    });
-  }
-  /**
-   * 媒体文件操作
-   */
-  static async saveMediaFile(filePath, data) {
-    await this.withConcurrencyLimit(async () => {
-      const dir = path.dirname(filePath);
-      await this.ensureDirectory(dir);
-      await this.withFileOp(
-        filePath,
-        () => fs.promises.writeFile(filePath, data)
-      );
-    });
-  }
-  static async deleteMediaFile(filePath) {
-    await this.withFileOp(filePath, async () => {
-      if (fs.existsSync(filePath)) {
-        await fs.promises.unlink(filePath);
-      }
-    });
-  }
-};
-var IdManager = class {
-  static {
-    __name(this, "IdManager");
-  }
-  deletedIds = /* @__PURE__ */ new Set();
-  maxId = 0;
-  initialized = false;
-  statusFilePath;
-  stats = {};
-  usedIds = /* @__PURE__ */ new Set();
-  // 新增：跟踪所有使用中的ID
-  constructor(baseDir) {
-    const caveDir = path.join(baseDir, "data", "cave");
-    this.statusFilePath = path.join(caveDir, "status.json");
-  }
-  async initialize(caveFilePath, pendingFilePath) {
-    if (this.initialized) return;
-    try {
-      this.initialized = true;
-      const status = fs.existsSync(this.statusFilePath) ? JSON.parse(await fs.promises.readFile(this.statusFilePath, "utf8")) : {
-        deletedIds: [],
-        maxId: 0,
-        stats: {},
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      const [caveData, pendingData] = await Promise.all([
-        FileHandler.readJsonData(caveFilePath),
-        FileHandler.readJsonData(pendingFilePath)
-      ]);
-      this.usedIds.clear();
-      const conflicts = /* @__PURE__ */ new Map();
-      const collectIds = /* @__PURE__ */ __name((items) => {
-        items.forEach((item) => {
-          if (this.usedIds.has(item.cave_id)) {
-            if (!conflicts.has(item.cave_id)) {
-              conflicts.set(item.cave_id, []);
-            }
-            conflicts.get(item.cave_id)?.push(item);
-          } else {
-            this.usedIds.add(item.cave_id);
-          }
-        });
-      }, "collectIds");
-      collectIds(caveData);
-      collectIds(pendingData);
-      if (conflicts.size > 0) {
-        logger.warn(`Found ${conflicts.size} ID conflicts, auto-fixing...`);
-        for (const [conflictId, items] of conflicts) {
-          items.forEach((item, index) => {
-            if (index > 0) {
-              let newId = this.maxId + 1;
-              while (this.usedIds.has(newId)) {
-                newId++;
-              }
-              logger.info(`Reassigning ID ${item.cave_id} -> ${newId} for item`);
-              item.cave_id = newId;
-              this.usedIds.add(newId);
-              this.maxId = Math.max(this.maxId, newId);
-            }
-          });
-        }
-        await Promise.all([
-          FileHandler.writeJsonData(caveFilePath, caveData),
-          FileHandler.writeJsonData(pendingFilePath, pendingData)
-        ]);
-      }
-      this.maxId = Math.max(
-        this.maxId,
-        status.maxId || 0,
-        ...[...this.usedIds]
-      );
-      this.deletedIds = new Set(
-        status.deletedIds?.filter((id) => !this.usedIds.has(id)) || []
-      );
-      this.stats = {};
-      for (const cave of caveData) {
-        if (cave.contributor_number === "10000") continue;
-        if (!this.stats[cave.contributor_number]) {
-          this.stats[cave.contributor_number] = [];
-        }
-        this.stats[cave.contributor_number].push(cave.cave_id);
-      }
-      await this.saveStatus();
-      this.initialized = true;
-    } catch (error) {
-      this.initialized = false;
-      logger.error(`IdManager initialization failed: ${error.message}`);
-      throw error;
-    }
-  }
-  getNextId() {
-    if (!this.initialized) {
-      throw new Error("IdManager not initialized");
-    }
-    let nextId;
-    if (this.deletedIds.size === 0) {
-      nextId = ++this.maxId;
-    } else {
-      nextId = Math.min(...Array.from(this.deletedIds));
-      this.deletedIds.delete(nextId);
-    }
-    while (this.usedIds.has(nextId)) {
-      nextId = ++this.maxId;
-    }
-    this.usedIds.add(nextId);
-    this.saveStatus().catch(
-      (err) => logger.error(`Failed to save status after getNextId: ${err.message}`)
-    );
-    return nextId;
-  }
-  async markDeleted(id) {
-    if (!this.initialized) {
-      throw new Error("IdManager not initialized");
-    }
-    this.deletedIds.add(id);
-    this.usedIds.delete(id);
-    if (id === this.maxId) {
-      const maxUsedId = Math.max(...Array.from(this.usedIds));
-      this.maxId = maxUsedId;
-    }
-    await this.saveStatus();
-  }
-  // 添加新的统计记录
-  async addStat(contributorNumber, caveId) {
-    if (contributorNumber === "10000") return;
-    if (!this.stats[contributorNumber]) {
-      this.stats[contributorNumber] = [];
-    }
-    this.stats[contributorNumber].push(caveId);
-    await this.saveStatus();
-  }
-  // 删除统计记录
-  async removeStat(contributorNumber, caveId) {
-    if (this.stats[contributorNumber]) {
-      this.stats[contributorNumber] = this.stats[contributorNumber].filter((id) => id !== caveId);
-      if (this.stats[contributorNumber].length === 0) {
-        delete this.stats[contributorNumber];
-      }
-      await this.saveStatus();
-    }
-  }
-  // 获取统计信息
-  getStats() {
-    return this.stats;
-  }
-  async saveStatus() {
-    try {
-      const status = {
-        deletedIds: Array.from(this.deletedIds).sort((a, b) => a - b),
-        maxId: this.maxId,
-        stats: this.stats,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      const tmpPath = `${this.statusFilePath}.tmp`;
-      await fs.promises.writeFile(tmpPath, JSON.stringify(status, null, 2), "utf8");
-      await fs.promises.rename(tmpPath, this.statusFilePath);
-    } catch (error) {
-      logger.error(`Failed to save status: ${error.message}`);
-      throw error;
-    }
-  }
-};
+var logger4 = new import_koishi4.Logger("cave");
 async function sendMessage(session, key, params = [], isTemp = true, timeout = 1e4) {
   try {
     const msg = await session.send(session.text(key, params));
@@ -753,12 +1329,12 @@ async function sendMessage(session, key, params = [], isTemp = true, timeout = 1
         try {
           await session.bot.deleteMessage(session.channelId, msg);
         } catch (error) {
-          logger.debug(`Failed to delete temporary message: ${error.message}`);
+          logger4.debug(`Failed to delete temporary message: ${error.message}`);
         }
       }, timeout);
     }
   } catch (error) {
-    logger.error(`Failed to send message: ${error.message}`);
+    logger4.error(`Failed to send message: ${error.message}`);
   }
   return "";
 }
@@ -773,7 +1349,7 @@ ${session.text("commands.cave.audit.from")}${cave.contributor_number}`;
       try {
         await bot.sendPrivateMessage(managerId, auditMessage);
       } catch (error) {
-        logger.error(session.text("commands.cave.audit.sendFailed", [managerId]));
+        logger4.error(session.text("commands.cave.audit.sendFailed", [managerId]));
       }
     }
   }
@@ -804,7 +1380,7 @@ function cleanElementsForSave(elements, keepIndex = false) {
 }
 __name(cleanElementsForSave, "cleanElementsForSave");
 async function processMediaFile(filePath, type) {
-  const data = await fs.promises.readFile(filePath).catch(() => null);
+  const data = await fs4.promises.readFile(filePath).catch(() => null);
   if (!data) return null;
   return `data:${type}/${type === "image" ? "png" : "mp4"};base64,${data.toString("base64")}`;
 }
@@ -821,10 +1397,10 @@ async function buildMessage(cave, resourceDir, session) {
       session.text("commands.cave.message.contributorSuffix", [cave.contributor_name])
     ].join("\n");
     await session?.send(basicInfo);
-    const filePath = path.join(resourceDir, videoElement.file);
+    const filePath = path4.join(resourceDir, videoElement.file);
     const base64Data = await processMediaFile(filePath, "video");
     if (base64Data && session) {
-      await session.send((0, import_koishi.h)("video", { src: base64Data }));
+      await session.send((0, import_koishi4.h)("video", { src: base64Data }));
     }
     return "";
   }
@@ -833,10 +1409,10 @@ async function buildMessage(cave, resourceDir, session) {
     if (element.type === "text") {
       lines.push(element.content);
     } else if (element.type === "img" && element.file) {
-      const filePath = path.join(resourceDir, element.file);
+      const filePath = path4.join(resourceDir, element.file);
       const base64Data = await processMediaFile(filePath, "image");
       if (base64Data) {
-        lines.push((0, import_koishi.h)("image", { src: base64Data }));
+        lines.push((0, import_koishi4.h)("image", { src: base64Data }));
       }
     }
   }
@@ -871,7 +1447,6 @@ async function extractMediaContent(originalContent, config, session) {
       elements.push({
         type,
         index: type === "video" ? Number.MAX_SAFE_INTEGER : idx * 3 + 1,
-        // 视频始终在最后
         fileName,
         fileSize
       });
@@ -886,15 +1461,13 @@ async function extractMediaContent(originalContent, config, session) {
   return { imageUrls, imageElements, videoUrls, videoElements, textParts };
 }
 __name(extractMediaContent, "extractMediaContent");
-async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, ctx, session) {
-  const { ext, accept } = mediaType === "img" ? { ext: "png", accept: "image/*" } : { ext: "mp4", accept: "video/*" };
+async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config, ctx, session) {
+  const accept = mediaType === "img" ? "image/*" : "video/*";
+  const hashStorage = new HashStorage(path4.join(ctx.baseDir, "data", "cave"));
+  await hashStorage.initialize();
   const downloadTasks = urls.map(async (url, i) => {
     const fileName = fileNames[i];
-    const fileExt = fileName?.match(/\.[a-zA-Z0-9]+$/)?.[0]?.slice(1) || ext;
-    const baseName = fileName;
-    path.basename(fileName, path.extname(fileName)).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
-    const finalFileName = `${caveId}_${baseName}.${fileExt}`;
-    const filePath = path.join(resourceDir, finalFileName);
+    const ext = path4.extname(fileName || url) || (mediaType === "img" ? ".png" : ".mp4");
     try {
       const response = await ctx.http(decodeURIComponent(url).replace(/&amp;/g, "&"), {
         method: "GET",
@@ -907,19 +1480,64 @@ async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, ctx, s
         }
       });
       if (!response.data) throw new Error("empty_response");
-      await FileHandler.saveMediaFile(filePath, Buffer.from(response.data));
-      return finalFileName;
+      const buffer = Buffer.from(response.data);
+      if (mediaType === "img") {
+        const baseName = path4.basename(fileName || "md5", ext).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
+        const files = await fs4.promises.readdir(resourceDir);
+        const duplicateFile = files.find((file) => file.startsWith(baseName + "_"));
+        if (duplicateFile) {
+          const duplicateCaveId = parseInt(duplicateFile.split("_")[1]);
+          if (!isNaN(duplicateCaveId)) {
+            const caveFilePath = path4.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 (config.enableDuplicate) {
+          const result = await hashStorage.findDuplicates([buffer], config.duplicateThreshold);
+          if (result.length > 0 && result[0] !== null) {
+            const duplicate = result[0];
+            const similarity = duplicate.similarity;
+            if (similarity >= config.duplicateThreshold) {
+              const caveFilePath = path4.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}_${baseName}${ext}`;
+        const filePath = path4.join(resourceDir, finalFileName);
+        await FileHandler.saveMediaFile(filePath, buffer);
+        return finalFileName;
+      } else {
+        const baseName = path4.basename(fileName || "video", ext).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
+        const finalFileName = `${caveId}_${baseName}${ext}`;
+        const filePath = path4.join(resourceDir, finalFileName);
+        await FileHandler.saveMediaFile(filePath, buffer);
+        return finalFileName;
+      }
     } catch (error) {
-      logger.error(`Failed to download media: ${error.message}`);
-      throw 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`));
     }
   });
-  const results = await Promise.allSettled(downloadTasks);
-  const successfulResults = results.filter((result) => result.status === "fulfilled").map((result) => result.value);
-  if (!successfulResults.length) {
-    throw new Error(session.text(`commands.cave.error.upload${mediaType === "img" ? "Image" : "Video"}Failed`));
-  }
-  return successfulResults;
+  return Promise.all(downloadTasks);
 }
 __name(saveMedia, "saveMedia");
 // Annotate the CommonJS export names for ESM import in node: