koishi-plugin-best-cave 1.1.5 → 1.3.0

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}文件大小超过限制", mediaFormatUnsupported: "{0}格式不支持", videoSendFailed: "视频发送失败", 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: { commandProcess: "命令处理失败：{0}", getCave: "获取回声洞失败", noCave: "暂无回声洞", saveFailed: "保存数据失败", mediaLoadFailed: "[加载{0}失败]", videoSendFailed: "视频发送失败", uploadImageFailed: "图片上传失败", uploadVideoFailed: "视频上传失败", fileRead: "读取 JSON 数据失败：{0}", fileWrite: "写入 JSON 数据失败：{0}", notFound: "未找到", userInfo: "获取用户信息失败：{0}", auditProcess: "审核处理失败：{0}", invalidId: "请输入有效的回声洞序号" }, message: { blacklisted: "你已被列入黑名单", managerOnly: "此操作仅限管理员可用", cooldown: "群聊冷却中...请在 {0} 秒后重试", caveTitle: "回声洞 —— （{0}）", videoSending: "[视频发送中]", mediaInvalid: "[无效的{0}]", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0}文件大小超过限制" } } } };
+    module2.exports = { _config: { manager: "管理员", number: "冷却时间（秒）", enableAudit: "启用审核", imageMaxSize: "图片最大大小（MB）", 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: "未找到该回声洞", duplicateFound: "发现相似度为 {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: "Manager", blacklist: "Blacklist (User)", whitelist: "Whitelist (User/Group/Channel)", number: "Cooldown Time (Seconds)", enableAudit: "Enable Audit", allowVideo: "Allow Video Upload", videoMaxSize: "Max Video Size (MB)", imageMaxSize: "Max Image Size (MB)", enablePagination: "Enable Pagination", itemsPerPage: "Items Per Page" }, commands: { cave: { description: "Echo Cave", usage: "Support adding, drawing, viewing, and managing Echo Cave", examples: "Use cave to randomly draw Echo Cave\nUse -a to add or reference directly\nUse -g to view specified Echo Cave\nUse -r to delete specified Echo Cave", options: { a: "Add Echo Cave", g: "View Echo Cave", r: "Delete Echo Cave", 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 canceled", videoDisabled: "Video upload not allowed", submitPending: "Submission successful, ID is ({0})", addSuccess: "Addition successful, ID is ({0})", mediaSizeExceeded: "{0} file size exceeds limit", mediaFormatUnsupported: "{0} format not supported", videoSendFailed: "Video send failed", localFileNotAllowed: "Local file path detected, cannot save" }, remove: { noPermission: "You do not have permission to delete others' Echo Cave", deletePending: "Delete (Pending Audit)", deleted: "Deleted" }, list: { pageInfo: "Page {0} / {1}", header: "There are currently {0} Echo Caves:", totalItems: "User {0} has submitted a total of {1} items:", idsLine: "{0}" }, audit: { noPending: "No pending Echo Caves", pendingNotFound: "Pending Echo Cave not found", pendingResult: "{0}, {1} pending Echo Caves remaining: [{2}]", auditPassed: "Approved", auditRejected: "Rejected", batchAuditResult: "{0} {1}/{2} Echo Caves", title: "Pending Echo Caves:", from: "Contributor:", sendFailed: "Failed to send audit message, unable to contact manager {0}" }, error: { commandProcess: "Command processing failed: {0}", getCave: "Failed to get Echo Cave", noCave: "No Echo Caves", saveFailed: "Failed to save data", mediaLoadFailed: "[Failed to load {0}]", videoSendFailed: "Video send failed", uploadImageFailed: "Image upload failed", uploadVideoFailed: "Video upload failed", fileRead: "Failed to read JSON data: {0}", fileWrite: "Failed to write JSON data: {0}", notFound: "Not found", userInfo: "Failed to get user information: {0}", auditProcess: "Audit processing failed: {0}", invalidId: "Please enter a valid Echo Cave ID" }, message: { blacklisted: "You have been blacklisted", managerOnly: "This operation is for managers only", cooldown: "Group chat cooldown... Please try again in {0} seconds", caveTitle: "Echo Cave —— ({0})", videoSending: "[Video sending]", mediaInvalid: "[Invalid {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)", duplicateThreshold: "Image similarity threshold (0-1)", allowVideo: "Allow video uploads", 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 cave entries", examples: "Use cave to randomly draw an entry\nUse -a to add directly or 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 submission (batch)", d: "Reject submission (batch)", l: "Check submission statistics" }, add: { noContent: "Please send content within one minute", operationTimeout: "Operation timeout, addition cancelled", videoDisabled: "Video uploads are 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' entries", deletePending: "Delete (pending)", 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: "{0} {1}/{2} entries", title: "Pending entries:", from: "Submitted by:", sendFailed: "Failed to send moderation message, cannot contact administrator {0}" }, error: { noContent: "Entry content is empty", getCave: "Failed to get entry", noCave: "No entries available", invalidId: "Please enter a valid entry ID", notFound: "Entry not found", duplicateFound: "Found duplicate image with similarity of {0}%" }, message: { blacklisted: "You have been blacklisted", managerOnly: "This operation is for administrators only", cooldown: "Group chat cooldown... Please try again in {0} seconds", caveTitle: "Echo Cave —— ({0})", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0} file size exceeds limit" } } } };
   }
 });
 
@@ -53,22 +53,690 @@ __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;
+  // 并发控制
+  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);
+      }
+    });
+  }
+};
+
+// 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();
+  constructor(baseDir) {
+    const caveDir = path2.join(baseDir, "data", "cave");
+    this.statusFilePath = path2.join(caveDir, "status.json");
+  }
+  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;
+    }
+  }
+  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");
+    }
+  }
+  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;
+  }
+  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();
+  }
+  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 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");
+  }
+  /**
+   * 计算图片哈希值
+   */
+  static async calculateHash(imageBuffer) {
+    const { data } = await (0, import_sharp.default)(imageBuffer).grayscale().resize(32, 32, { fit: "fill" }).raw().toBuffer({ resolveWithObject: true });
+    const waveletMatrix = this.haarWaveletTransform(data, 32);
+    const features = this.extractFeatures(waveletMatrix, 32);
+    const mean = features.reduce((sum, val) => sum + val, 0) / features.length;
+    const binaryHash = features.map((val) => val > mean ? "1" : "0").join("");
+    return this.binaryToHex(binaryHash);
+  }
+  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("");
+  }
+  static hexToBinary(hex) {
+    let binary = "";
+    for (const char of hex) {
+      const bin = parseInt(char, 16).toString(2).padStart(4, "0");
+      binary += bin;
+    }
+    return binary;
+  }
+  static haarWaveletTransform(data, size) {
+    const matrix = 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 i = 0; i < size; i++) {
+      this.haarTransform1D(matrix[i]);
+    }
+    for (let j = 0; j < size; j++) {
+      const col = matrix.map((row) => row[j]);
+      this.haarTransform1D(col);
+      for (let i = 0; i < size; i++) {
+        matrix[i][j] = col[i];
+      }
+    }
+    return matrix;
+  }
+  static haarTransform1D(arr) {
+    const len = arr.length;
+    const temp = new Array(len).fill(0);
+    for (let i = 0; i < len; i += 2) {
+      if (i + 1 < len) {
+        temp[i / 2] = (arr[i] + arr[i + 1]) / 2;
+        temp[len / 2 + i / 2] = (arr[i] - arr[i + 1]) / 2;
+      } else {
+        temp[i / 2] = arr[i];
+      }
+    }
+    for (let i = 0; i < len; i++) {
+      arr[i] = temp[i];
+    }
+  }
+  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;
+  }
+  /**
+   * 计算两个hash值的汉明距离
+   */
+  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;
+  }
+  /**
+   * 计算图片相似度(0-1)
+   */
+  static calculateSimilarity(hash1, hash2) {
+    const distance = this.calculateDistance(hash1, hash2);
+    return (64 - distance) / 64;
+  }
+  /**
+   * 批量比较图片相似度
+   */
+  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 {
+  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);
+  }
+  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;
+    }
+  }
+  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
+      }))
+    };
+  }
+  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}`);
+    }
+  }
+  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;
+    }
+  }
+  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;
+        }
+      })
+    );
+  }
+  async loadCaveData() {
+    const data = await FileHandler.readJsonData(this.caveFilePath);
+    return Array.isArray(data) ? data.flat() : [];
+  }
+  async saveHashes() {
+    const data = {
+      hashes: Object.fromEntries(this.hashes),
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await FileHandler.writeJsonData(this.filePath, [data]);
+  }
+  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`);
+  }
+  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`);
+    }
+  }
+  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)
+  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,28 +744,27 @@ 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);
+  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(caveFilePath2, session, content, options, config2) {
-    const caveData = await CacheManager.getCaveData(caveFilePath2, session);
-    const caveDir2 = path.dirname(caveFilePath2);
-    const stats = {};
-    for (const cave of caveData) {
-      if (cave.contributor_number === "10000") continue;
-      if (!stats[cave.contributor_number]) stats[cave.contributor_number] = [];
-      stats[cave.contributor_number].push(cave.cave_id);
+  async function processList(session, config2, userId, pageNum = 1) {
+    const stats = idManager.getStats();
+    if (userId && userId in stats) {
+      const ids = stats[userId];
+      return session.text("commands.cave.list.totalItems", [userId, ids.length]) + "\n" + session.text("commands.cave.list.idsLine", [ids.join(",")]);
     }
-    const statFilePath = path.join(caveDir2, "stat.json");
-    fs.writeFileSync(statFilePath, JSON.stringify(stats, null, 2), "utf8");
     const lines = Object.entries(stats).map(([cid, ids]) => {
       return session.text("commands.cave.list.totalItems", [cid, ids.length]) + "\n" + session.text("commands.cave.list.idsLine", [ids.join(",")]);
     });
@@ -105,10 +772,7 @@ async function apply(ctx, config) {
     if (config2.enablePagination) {
       const itemsPerPage = config2.itemsPerPage;
       const totalPages = Math.max(1, Math.ceil(lines.length / itemsPerPage));
-      let query = (content[0] || String(options.l) || "").trim();
-      let pageNum = parseInt(query, 10);
-      if (isNaN(pageNum) || pageNum < 1) pageNum = 1;
-      if (pageNum > totalPages) pageNum = totalPages;
+      pageNum = Math.min(Math.max(1, pageNum), totalPages);
       const start = (pageNum - 1) * itemsPerPage;
       const paginatedLines = lines.slice(start, start + itemsPerPage);
       return session.text("commands.cave.list.header", [totalSubmissions]) + "\n" + paginatedLines.join("\n") + "\n" + session.text("commands.cave.list.pageInfo", [pageNum, totalPages]);
@@ -117,595 +781,556 @@ async function apply(ctx, config) {
     }
   }
   __name(processList, "processList");
-  async function processAudit(ctx2, pendingFilePath2, caveFilePath2, resourceDir2, session, options, content) {
-    const pendingData = await CacheManager.getPendingData(pendingFilePath2, session);
+  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) {
+  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 CacheManager.getCaveData(caveFilePath2, session);
+    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);
-    const caveContent = await buildMessage(cave, resourceDir2, session);
-    return caveContent;
+    return buildMessage(cave, resourceDir, session);
   }
   __name(processView, "processView");
-  async function processRandom(caveFilePath2, resourceDir2, session, config2, lastUsed2) {
-    try {
-      const data = await CacheManager.getCaveData(caveFilePath2, session);
-      if (data.length === 0) {
-        return sendMessage(session, "commands.cave.error.noCave", [], true);
-      }
-      const guildId = session.guildId;
-      const now = Date.now();
-      const lastCall = lastUsed2.get(guildId) || 0;
-      const isManager = config2.manager.includes(session.userId);
-      if (!isManager && now - lastCall < config2.number * 1e3) {
-        const waitTime = Math.ceil((config2.number * 1e3 - (now - lastCall)) / 1e3);
-        return sendMessage(session, "commands.cave.message.cooldown", [waitTime], true);
-      }
-      if (!isManager) lastUsed2.set(guildId, now);
-      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);
-    } catch (error) {
-      return sendMessage(session, "commands.cave.error.commandProcess", [error.message], true);
+  async function processRandom(caveFilePath, resourceDir, session) {
+    const data = await FileHandler.readJsonData(caveFilePath);
+    if (data.length === 0) {
+      return sendMessage(session, "commands.cave.error.noCave", [], true);
     }
+    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, 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 CacheManager.getCaveData(caveFilePath2, session);
-    const pendingData = await CacheManager.getPendingData(pendingFilePath2, session);
-    const index = data.findIndex((item) => item.cave_id === caveId);
-    const pendingIndex = pendingData.findIndex((item) => item.cave_id === caveId);
-    if (index === -1 && pendingIndex === -1) return sendMessage(session, "commands.cave.error.notFound", [], true);
-    let targetCave;
-    let isPending = false;
-    if (index !== -1) {
-      targetCave = data[index];
-    } else {
-      targetCave = pendingData[pendingIndex];
-      isPending = true;
+    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) {
+      return sendMessage(session, "commands.cave.error.notFound", [], true);
     }
+    const targetCave = targetInData || targetInPending;
+    const isPending = !targetInData;
     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)) fs.unlinkSync(fullPath);
+          const fullPath = path4.join(resourceDir, element.file);
+          if (fs4.existsSync(fullPath)) {
+            await fs4.promises.unlink(fullPath);
+          }
         }
       }
     }
     if (isPending) {
-      pendingData.splice(pendingIndex, 1);
-      await FileHandler.writeJsonData(pendingFilePath2, pendingData, session);
-      const deleteStatus = isPending ? session.text("commands.cave.remove.deletePending") : "";
-      const deleteMessage = session.text("commands.cave.remove.deleted");
-      return `${deleteMessage}${deleteStatus}
-${caveContent}`;
+      const newPendingData = pendingData.filter((item) => item.cave_id !== caveId);
+      await FileHandler.writeJsonData(pendingFilePath, newPendingData);
     } else {
-      data.splice(index, 1);
-      await FileHandler.writeJsonData(caveFilePath2, data, session);
-      const deleteStatus = isPending ? session.text("commands.cave.remove.deletePending") : "";
-      const deleteMessage = session.text("commands.cave.remove.deleted");
-      return `${deleteMessage}${deleteStatus}${caveContent}`;
+      const newData = data.filter((item) => item.cave_id !== caveId);
+      await FileHandler.writeJsonData(caveFilePath, newData);
+      await idManager.removeStat(targetCave.contributor_number, caveId);
     }
+    await idManager.markDeleted(caveId);
+    const deleteStatus = isPending ? session.text("commands.cave.remove.deletePending") : "";
+    const deleteMessage = session.text("commands.cave.remove.deleted");
+    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 {
-      let inputParts = [];
-      if (content.length > 0) {
-        inputParts = content;
-      }
-      if (!inputParts.length) {
+      const inputContent = content.length > 0 ? content.join("\n") : await (async () => {
         await sendMessage(session, "commands.cave.add.noContent", [], true);
         const reply = await session.prompt({ timeout: 6e4 });
-        if (!reply || reply.trim() === "") {
-          return sendMessage(session, "commands.cave.add.operationTimeout", [], true);
-        }
-        inputParts = [reply];
-      }
-      const combinedInput = inputParts.join("\n");
-      if (combinedInput.includes("/app/.config/QQ/")) {
+        if (!reply) throw new Error(session.text("commands.cave.add.operationTimeout"));
+        return reply;
+      })();
+      const caveId = await idManager.getNextId();
+      if (inputContent.includes("/app/.config/QQ/")) {
         return sendMessage(session, "commands.cave.add.localFileNotAllowed", [], true);
       }
-      let { imageUrls, imageElements, videoUrls, videoElements, textParts } = await extractMediaContent(combinedInput);
+      const bypassAudit = config2.whitelist.includes(session.userId) || config2.whitelist.includes(session.guildId) || config2.whitelist.includes(session.channelId);
+      const { imageUrls, imageElements, videoUrls, videoElements, textParts } = await extractMediaContent(inputContent, config2, session);
       if (videoUrls.length > 0 && !config2.allowVideo) {
         return sendMessage(session, "commands.cave.add.videoDisabled", [], true);
       }
-      const pendingData = await CacheManager.getPendingData(pendingFilePath2, session);
-      const data = await CacheManager.getCaveData(caveFilePath2, session);
-      const usedIds = /* @__PURE__ */ new Set([...data.map((item) => item.cave_id), ...pendingData.map((item) => item.cave_id)]);
-      let caveId = 1;
-      while (usedIds.has(caveId)) {
-        caveId++;
-      }
-      let savedImages = [];
-      if (imageUrls.length > 0) {
-        try {
-          const imageFileNames = imageElements.map((el) => el.fileName);
-          const imageFileSizes = imageElements.map((el) => el.fileSize);
-          savedImages = await saveMedia(
-            imageUrls,
-            imageFileNames,
-            imageFileSizes,
-            resourceDir2,
-            caveId,
-            config2,
-            ctx2,
-            "img",
-            session
-          );
-        } catch (error) {
-          return sendMessage(session, "commands.cave.error.uploadImageFailed", [], true);
-        }
-      }
-      let savedVideos = [];
-      if (videoUrls.length > 0) {
-        try {
-          const videoFileNames = videoElements.map((el) => el.fileName);
-          const videoFileSizes = videoElements.map((el) => el.fileSize);
-          savedVideos = await saveMedia(
-            videoUrls,
-            videoFileNames,
-            videoFileSizes,
-            resourceDir2,
-            caveId,
-            config2,
-            ctx2,
-            "video",
-            session
-          );
-        } catch (error) {
-          return sendMessage(session, "commands.cave.error.uploadVideoFailed", [], true);
-        }
-      }
-      const elements = [];
-      elements.push(...textParts);
-      savedImages.forEach((file, idx) => {
-        if (imageElements[idx]) {
-          elements.push({ ...imageElements[idx], type: "img", file });
-        }
-      });
-      savedVideos.forEach((file, idx) => {
-        if (videoElements[idx]) {
-          elements.push({ ...videoElements[idx], type: "video", file });
-        }
-      });
-      elements.sort((a, b) => a.index - b.index);
-      let contributorName = session.username;
-      if (ctx2.database) {
-        try {
-          const userInfo = await ctx2.database.getUser(session.platform, session.userId);
-          contributorName = userInfo?.nickname || session.username;
-        } catch (error) {
-          return sendMessage(
-            session,
-            "commands.cave.error.userInfo",
-            [error.message],
-            true
-          );
-        }
-      }
+      const [savedImages, savedVideos] = await Promise.all([
+        imageUrls.length > 0 ? saveMedia(
+          imageUrls,
+          imageElements.map((el) => el.fileName),
+          resourceDir,
+          caveId,
+          "img",
+          config2,
+          ctx2,
+          session
+        ) : [],
+        videoUrls.length > 0 ? saveMedia(
+          videoUrls,
+          videoElements.map((el) => el.fileName),
+          resourceDir,
+          caveId,
+          "video",
+          config2,
+          ctx2,
+          session
+        ) : []
+      ]);
       const newCave = {
         cave_id: caveId,
-        elements: cleanElementsForSave(elements, true),
+        elements: [
+          ...textParts,
+          ...imageElements.map((el, idx) => ({
+            ...el,
+            file: savedImages[idx],
+            // 保持原始文本和图片的相对位置
+            index: el.index
+          }))
+        ].sort((a, b) => a.index - a.index),
         contributor_number: session.userId,
-        contributor_name: contributorName
+        contributor_name: session.username
       };
-      const bypassAudit = config2.whitelist.includes(session.userId) || session.guildId && config2.whitelist.includes(session.guildId) || session.channelId && config2.whitelist.includes(session.channelId);
+      if (videoUrls.length > 0 && savedVideos.length > 0) {
+        newCave.elements.push({
+          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) {
-        pendingData.push({ ...newCave, elements: cleanElementsForSave(elements, true) });
-        await FileHandler.writeJsonData(pendingFilePath2, pendingData, session);
-        await sendAuditMessage(ctx2, config2, newCave, await buildMessage(newCave, resourceDir2, session), session);
+        const pendingData = await FileHandler.readJsonData(pendingFilePath);
+        pendingData.push(newCave);
+        await Promise.all([
+          FileHandler.writeJsonData(pendingFilePath, pendingData),
+          sendAuditMessage(ctx2, config2, newCave, await buildMessage(newCave, resourceDir, session), session)
+        ]);
         return sendMessage(session, "commands.cave.add.submitPending", [caveId], false);
-      } else {
-        const caveWithoutIndex = { ...newCave, elements: cleanElementsForSave(elements, false) };
-        data.push(caveWithoutIndex);
-        await FileHandler.writeJsonData(caveFilePath2, data, session);
-        return sendMessage(session, "commands.cave.add.addSuccess", [caveId], false);
       }
+      const data = await FileHandler.readJsonData(caveFilePath);
+      data.push({
+        ...newCave,
+        elements: cleanElementsForSave(newCave.elements, false)
+      });
+      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) {
-      return sendMessage(session, "commands.cave.error.commandProcess", [error.message], true);
+      logger4.error(`Failed to process add command: ${error.message}`);
     }
   }
   __name(processAdd, "processAdd");
-  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 sendTempMessage(session, "commands.cave.message.blacklisted");
-    }
-    if (session.content && session.content.includes("-help")) return;
-    if ((options.l || options.p || options.d) && !config.manager.includes(session.userId)) {
-      return sendTempMessage(session, "commands.cave.message.managerOnly");
+  async function handleAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, targetId) {
+    if (pendingData.length === 0) {
+      return sendMessage(session, "commands.cave.audit.noPending", [], true);
     }
-  }).action(async ({ session, options }, ...content) => {
-    try {
-      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");
-      if (options.l !== void 0) {
-        return await processList(caveFilePath2, session, content, options, config);
+    if (typeof targetId === "number") {
+      const targetCave = pendingData.find((item) => item.cave_id === targetId);
+      if (!targetCave) {
+        return sendMessage(session, "commands.cave.audit.pendingNotFound", [], true);
       }
-      if (options.p || options.d) {
-        return await processAudit(ctx, pendingFilePath2, caveFilePath2, resourceDir2, session, options, content);
+      const newPendingData = pendingData.filter((item) => item.cave_id !== targetId);
+      if (isApprove) {
+        const oldCaveData = await FileHandler.readJsonData(caveFilePath);
+        const newCaveData = [...oldCaveData, {
+          ...targetCave,
+          cave_id: targetId,
+          elements: cleanElementsForSave(targetCave.elements, false)
+        }];
+        await FileHandler.withTransaction([
+          {
+            filePath: caveFilePath,
+            operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, newCaveData), "operation"),
+            rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, oldCaveData), "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(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 = path4.join(resourceDir, element.file);
+              if (fs4.existsSync(fullPath)) {
+                await fs4.promises.unlink(fullPath);
+              }
+            }
+          }
+        }
       }
-      if (options.g) {
-        return await processView(caveFilePath2, resourceDir2, session, options, content);
+      const remainingCount = newPendingData.length;
+      if (remainingCount > 0) {
+        const remainingIds = newPendingData.map((c) => c.cave_id).join(", ");
+        const action = isApprove ? "auditPassed" : "auditRejected";
+        return sendMessage(session, "commands.cave.audit.pendingResult", [
+          session.text(`commands.cave.audit.${action}`),
+          remainingCount,
+          remainingIds
+        ], false);
       }
-      if (options.r) {
-        return await processDelete(caveFilePath2, resourceDir2, pendingFilePath2, session, config, options, content);
+      return sendMessage(
+        session,
+        isApprove ? "commands.cave.audit.auditPassed" : "commands.cave.audit.auditRejected",
+        [],
+        false
+      );
+    }
+    const data = isApprove ? await FileHandler.readJsonData(caveFilePath) : null;
+    let processedCount = 0;
+    if (isApprove && data) {
+      const oldData = [...data];
+      const newData = [...data];
+      await FileHandler.withTransaction([
+        {
+          filePath: caveFilePath,
+          operation: /* @__PURE__ */ __name(async () => {
+            for (const cave of pendingData) {
+              newData.push({
+                ...cave,
+                cave_id: cave.cave_id,
+                elements: cleanElementsForSave(cave.elements, false)
+              });
+              processedCount++;
+              await idManager.addStat(cave.contributor_number, cave.cave_id);
+            }
+            return FileHandler.writeJsonData(caveFilePath, newData);
+          }, "operation"),
+          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, oldData), "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);
       }
-      if (options.a) {
-        return await processAdd(ctx, config, caveFilePath2, resourceDir2, pendingFilePath2, session, content);
+      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 = path4.join(resourceDir, element.file);
+              if (fs4.existsSync(fullPath)) {
+                await fs4.promises.unlink(fullPath);
+              }
+            }
+          }
+        }
+        processedCount++;
       }
-      return await processRandom(caveFilePath2, resourceDir2, session, config, lastUsed);
-    } catch (error) {
-      logger.error(error);
-      return sendMessage(session, "commands.cave.error.commandProcess", [error.message], true);
     }
-  });
-}
-__name(apply, "apply");
-var logger = new import_koishi.Logger("cave");
-var FileHandler = class {
-  static {
-    __name(this, "FileHandler");
+    return sendMessage(session, "commands.cave.audit.batchAuditResult", [
+      isApprove ? "通过" : "拒绝",
+      processedCount,
+      pendingData.length
+    ], false);
   }
-  static writeQueue = /* @__PURE__ */ new Map();
-  static async readJsonData(filePath, session, validator) {
-    try {
-      const data = await fs.promises.readFile(filePath, "utf8");
-      const parsed = JSON.parse(data || "[]");
-      return Array.isArray(parsed) ? validator ? parsed.filter(validator) : parsed : [];
-    } catch (error) {
-      logger.error(session.text("commands.cave.error.fileRead", [error.message]));
-      return [];
+  __name(handleAudit, "handleAudit");
+  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);
     }
-  }
-  static async writeJsonData(filePath, data, session) {
-    const queueKey = filePath;
-    const writeOperation = /* @__PURE__ */ __name(async () => {
-      try {
-        const jsonString = JSON.stringify(data, null, 2);
-        await fs.promises.writeFile(filePath, jsonString, "utf8");
-      } catch (error) {
-        logger.error(session.text("commands.cave.error.fileWrite", [error.message]));
-        throw new Error(session.text("commands.cave.error.saveFailed"));
-      }
-    }, "writeOperation");
-    if (!this.writeQueue.has(queueKey)) {
-      this.writeQueue.set(queueKey, Promise.resolve());
+    if ((options.p || options.d) && !config.manager.includes(session.userId)) {
+      return sendMessage(session, "commands.cave.message.managerOnly", [], true);
     }
-    const currentPromise = this.writeQueue.get(queueKey).then(writeOperation).finally(() => {
-      if (this.writeQueue.get(queueKey) === currentPromise) {
-        this.writeQueue.delete(queueKey);
+  }).action(async ({ session, options }, ...content) => {
+    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);
       }
-    });
-    this.writeQueue.set(queueKey, currentPromise);
-    return currentPromise;
-  }
-  static async ensureDirectory(dir) {
-    !fs.existsSync(dir) && await fs.promises.mkdir(dir, { recursive: true });
-  }
-  static async ensureJsonFile(filePath, defaultContent = "[]") {
-    !fs.existsSync(filePath) && await fs.promises.writeFile(filePath, defaultContent, "utf8");
-  }
-};
-async function saveMedia(urls, fileNames, fileSizes, resourceDir, caveId, config, ctx, mediaType, session) {
-  const defaults = mediaType === "img" ? { ext: "png", accept: "image/*", maxSize: config.imageMaxSize } : { ext: "mp4", accept: "video/*", maxSize: config.videoMaxSize };
-  const extPattern = /\.[a-zA-Z0-9]+$/;
-  const downloadPromises = urls.map(async (url, i) => {
-    try {
-      const processedUrl = (() => {
-        try {
-          const decodedUrl = decodeURIComponent(url);
-          return decodedUrl.includes("multimedia.nt.qq.com.cn") ? decodedUrl.replace(/&amp;/g, "&") : url;
-        } catch {
-          return url;
-        }
-      })();
-      let ext = defaults.ext;
-      const fileName = fileNames[i];
-      const fileSize = fileSizes[i];
-      if (fileSize) {
-        const sizeInBytes = parseInt(fileSize);
-        if (sizeInBytes > defaults.maxSize * 1024 * 1024) {
-          logger.warn(session.text("commands.cave.message.mediaSizeExceeded", [mediaType]));
-          return null;
+      lastUsed.set(guildId, now);
+    }
+    if (options.l !== void 0) {
+      const input = typeof options.l === "string" ? options.l : content[0];
+      const num = parseInt(input);
+      if (config.manager.includes(session.userId)) {
+        if (!isNaN(num)) {
+          if (num < 1e4) {
+            return await processList(session, config, void 0, num);
+          } else {
+            return await processList(session, config, num.toString());
+          }
+        } else if (input) {
+          return await processList(session, config, input);
         }
+        return await processList(session, config);
+      } else {
+        return await processList(session, config, session.userId);
       }
-      if (fileName && extPattern.test(fileName)) {
-        ext = fileName.match(extPattern)[0].slice(1);
-      }
-      const finalFileName = fileName ? `${caveId}_${path.basename(fileName)}` : `${caveId}_${i + 1}.${ext}`;
-      const targetPath = path.join(resourceDir, finalFileName);
-      const response = await ctx.http(processedUrl, {
-        method: "GET",
-        responseType: "arraybuffer",
-        timeout: 3e4,
-        headers: {
-          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
-          "Accept": defaults.accept,
-          "Referer": "https://qq.com"
-        }
-      });
-      const fileBuffer = Buffer.from(response.data);
-      await fs.promises.writeFile(targetPath, fileBuffer);
-      return finalFileName;
-    } catch (error) {
-      const errorKey = mediaType === "img" ? "commands.cave.error.uploadImageFailed" : "commands.cave.error.uploadVideoFailed";
-      await sendTempMessage(session, errorKey);
-      return null;
     }
-  });
-  const results = await Promise.all(downloadPromises);
-  return results.filter((name2) => name2 !== null);
-}
-__name(saveMedia, "saveMedia");
-async function sendAuditMessage(ctx, config, cave, content, session) {
-  const auditMessage = `${session.text("commands.cave.audit.title")}
-${content}
-${session.text("commands.cave.audit.from")}${cave.contributor_number}`;
-  for (const managerId of config.manager) {
-    try {
-      await ctx.bots[0]?.sendPrivateMessage(managerId, auditMessage);
-    } catch (error) {
-      logger.error(session.text("commands.cave.audit.sendFailed", [managerId]));
+    if (options.p || options.d) {
+      return await processAudit(pendingFilePath, caveFilePath, resourceDir, session, options, content);
     }
-  }
-}
-__name(sendAuditMessage, "sendAuditMessage");
-async function handleSingleCaveAudit(ctx, cave, isApprove, resourceDir, data, session) {
-  try {
-    if (isApprove && data) {
-      const caveWithoutIndex = {
-        ...cave,
-        elements: cleanElementsForSave(cave.elements, false)
-      };
-      data.push(caveWithoutIndex);
-    } else if (!isApprove && cave.elements) {
-      for (const element of cave.elements) {
-        if (element.type === "img" && element.file) {
-          const fullPath = path.join(resourceDir, element.file);
-          if (fs.existsSync(fullPath)) fs.unlinkSync(fullPath);
-        }
-      }
+    if (options.g) {
+      return await processView(caveFilePath, resourceDir, session, options, content);
     }
-    return true;
-  } catch (error) {
-    return sendTempMessage(session, "commands.cave.error.auditProcess", [error.message]);
-  }
-}
-__name(handleSingleCaveAudit, "handleSingleCaveAudit");
-async function handleAudit(ctx, pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, targetId) {
-  if (pendingData.length === 0) return sendMessage(session, "commands.cave.audit.noPending", [], true);
-  if (typeof targetId === "number") {
-    const pendingIndex = pendingData.findIndex((item) => item.cave_id === targetId);
-    if (pendingIndex === -1) return sendMessage(session, "commands.cave.audit.pendingNotFound", [], true);
-    const cave = pendingData[pendingIndex];
-    const data2 = isApprove ? await FileHandler.readJsonData(caveFilePath, session) : null;
-    const auditResult = await handleSingleCaveAudit(ctx, cave, isApprove, resourceDir, data2, session);
-    if (typeof auditResult === "string") return auditResult;
-    if (isApprove && data2) await FileHandler.writeJsonData(caveFilePath, data2, session);
-    pendingData.splice(pendingIndex, 1);
-    await FileHandler.writeJsonData(pendingFilePath, pendingData, session);
-    const remainingCount = pendingData.length;
-    if (remainingCount > 0) {
-      const remainingIds = pendingData.map((c) => c.cave_id).join(", ");
-      const action = isApprove ? "auditPassed" : "auditRejected";
-      return sendMessage(session, "commands.cave.audit.pendingResult", [
-        session.text(`commands.cave.audit.${action}`),
-        remainingCount,
-        remainingIds
-      ], false);
-    }
-    return sendMessage(
-      session,
-      isApprove ? "commands.cave.audit.auditPassed" : "commands.cave.audit.auditRejected",
-      [],
-      false
-      // 审核结果改为永久消息
-    );
-  }
-  const data = isApprove ? await FileHandler.readJsonData(caveFilePath, session) : null;
-  let processedCount = 0;
-  for (const cave of pendingData) {
-    await handleSingleCaveAudit(ctx, cave, isApprove, resourceDir, data, session) && processedCount++;
-  }
-  if (isApprove && data) await FileHandler.writeJsonData(caveFilePath, data, session);
-  await FileHandler.writeJsonData(pendingFilePath, [], session);
-  return sendMessage(session, "commands.cave.audit.batchAuditResult", [
-    isApprove ? "通过" : "拒绝",
-    processedCount,
-    pendingData.length
-  ], false);
-}
-__name(handleAudit, "handleAudit");
-function cleanElementsForSave(elements, keepIndex = false) {
-  const sorted = elements.sort((a, b) => a.index - b.index);
-  return sorted.map(({ type, content, file, index }) => ({
-    type,
-    ...keepIndex && { index },
-    ...content && { content },
-    ...file && { file }
-  }));
-}
-__name(cleanElementsForSave, "cleanElementsForSave");
-async function sendTempMessage(session, key, params = [], timeout = 1e4) {
-  const msg = await session.send(session.text(key, params));
-  setTimeout(async () => {
-    try {
-      await session.bot.deleteMessage(session.channelId, msg);
-    } catch (error) {
-      logger.error("Failed to delete message:", error);
+    if (options.r) {
+      return await processDelete(caveFilePath, resourceDir, pendingFilePath, session, config, options, content);
     }
-  }, timeout);
-  return "";
+    if (options.a) {
+      return await processAdd(ctx, config, caveFilePath, resourceDir, pendingFilePath, session, content);
+    }
+    return await processRandom(caveFilePath, resourceDir, session);
+  });
 }
-__name(sendTempMessage, "sendTempMessage");
-var messageQueue = /* @__PURE__ */ new Map();
+__name(apply, "apply");
+var logger4 = new import_koishi4.Logger("cave");
 async function sendMessage(session, key, params = [], isTemp = true, timeout = 1e4) {
-  const channelId = session.channelId;
-  const sendOperation = /* @__PURE__ */ __name(async () => {
+  try {
     const msg = await session.send(session.text(key, params));
-    if (isTemp) {
+    if (isTemp && msg) {
       setTimeout(async () => {
         try {
-          await session.bot.deleteMessage(channelId, msg);
+          await session.bot.deleteMessage(session.channelId, msg);
         } catch (error) {
-          logger.error("Failed to delete message:", error);
+          logger4.debug(`Failed to delete temporary message: ${error.message}`);
         }
       }, timeout);
     }
-  }, "sendOperation");
-  if (!messageQueue.has(channelId)) {
-    messageQueue.set(channelId, Promise.resolve());
+  } catch (error) {
+    logger4.error(`Failed to send message: ${error.message}`);
   }
-  const currentPromise = messageQueue.get(channelId).then(sendOperation).finally(() => {
-    if (messageQueue.get(channelId) === currentPromise) {
-      messageQueue.delete(channelId);
-    }
-  });
-  messageQueue.set(channelId, currentPromise);
   return "";
 }
 __name(sendMessage, "sendMessage");
-async function extractMediaContent(originalContent) {
-  const parsedTexts = originalContent.split(/<img[^>]+>|<video[^>]+>/g).map((t) => t.trim()).filter((t) => t);
-  const textParts = [];
-  parsedTexts.forEach((text, idx) => {
-    textParts.push({ type: "text", content: text, index: idx * 3 });
-  });
-  const imageUrls = [];
-  const imageElements = [];
-  const videoUrls = [];
-  const videoElements = [];
-  const imgMatches = originalContent.match(/<img[^>]+src="([^"]+)"[^>]*>/g) || [];
-  imgMatches.forEach((img, idx) => {
-    const srcMatch = img.match(/src="([^"]+)"/);
-    const fileName = img.match(/file="([^"]+)"/)?.[1];
-    const fileSize = img.match(/fileSize="([^"]+)"/)?.[1];
-    if (srcMatch?.[1]) {
-      imageUrls.push(srcMatch[1]);
-      imageElements.push({ type: "img", index: idx * 3 + 1, fileName, fileSize });
+async function sendAuditMessage(ctx, config, cave, content, session) {
+  const auditMessage = `${session.text("commands.cave.audit.title")}
+${content}
+${session.text("commands.cave.audit.from")}${cave.contributor_number}`;
+  for (const managerId of config.manager) {
+    const bot = ctx.bots[0];
+    if (bot) {
+      try {
+        await bot.sendPrivateMessage(managerId, auditMessage);
+      } catch (error) {
+        logger4.error(session.text("commands.cave.audit.sendFailed", [managerId]));
+      }
     }
-  });
-  const videoMatches = originalContent.match(/<video[^>]+src="([^"]+)"[^>]*>/g) || [];
-  videoMatches.forEach((video, idx) => {
-    const srcMatch = video.match(/src="([^"]+)"/);
-    const fileName = video.match(/file="([^"]+)"/)?.[1];
-    const fileSize = video.match(/fileSize="([^"]+)"/)?.[1];
-    if (srcMatch?.[1]) {
-      videoUrls.push(srcMatch[1]);
-      videoElements.push({ type: "video", index: idx * 3 + 2, fileName, fileSize });
+  }
+}
+__name(sendAuditMessage, "sendAuditMessage");
+function cleanElementsForSave(elements, keepIndex = false) {
+  if (!elements?.length) return [];
+  const cleanedElements = elements.map((element) => {
+    if (element.type === "text") {
+      const cleanedElement = {
+        type: "text",
+        content: element.content
+      };
+      if (keepIndex) cleanedElement.index = element.index;
+      return cleanedElement;
+    } else if (element.type === "img" || element.type === "video") {
+      const mediaElement = element;
+      const cleanedElement = {
+        type: mediaElement.type
+      };
+      if (mediaElement.file) cleanedElement.file = mediaElement.file;
+      if (keepIndex) cleanedElement.index = element.index;
+      return cleanedElement;
     }
+    return element;
   });
-  return { imageUrls, imageElements, videoUrls, videoElements, textParts };
+  return keepIndex ? cleanedElements.sort((a, b) => (a.index || 0) - (b.index || 0)) : cleanedElements;
 }
-__name(extractMediaContent, "extractMediaContent");
+__name(cleanElementsForSave, "cleanElementsForSave");
+async function processMediaFile(filePath, type) {
+  const data = await fs4.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) {
-  let content = session.text("commands.cave.message.caveTitle", [cave.cave_id]) + "\n";
-  const videoElements = [];
-  for (const element of cave.elements) {
+  if (!cave?.elements?.length) {
+    return session.text("commands.cave.error.noContent");
+  }
+  const videoElement = cave.elements.find((el) => el.type === "video");
+  const nonVideoElements = cave.elements.filter((el) => el.type !== "video").sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+  if (videoElement?.file) {
+    const basicInfo = [
+      session.text("commands.cave.message.caveTitle", [cave.cave_id]),
+      session.text("commands.cave.message.contributorSuffix", [cave.contributor_name])
+    ].join("\n");
+    await session?.send(basicInfo);
+    const filePath = path4.join(resourceDir, videoElement.file);
+    const base64Data = await processMediaFile(filePath, "video");
+    if (base64Data && session) {
+      await session.send((0, import_koishi4.h)("video", { src: base64Data }));
+    }
+    return "";
+  }
+  const lines = [session.text("commands.cave.message.caveTitle", [cave.cave_id])];
+  for (const element of nonVideoElements) {
     if (element.type === "text") {
-      content += element.content + "\n";
+      lines.push(element.content);
     } else if (element.type === "img" && element.file) {
-      const fullImagePath = path.join(resourceDir, element.file);
-      if (fs.existsSync(fullImagePath)) {
-        try {
-          const imageBuffer = fs.readFileSync(fullImagePath);
-          content += (0, import_koishi.h)("image", { src: `data:image/png;base64,${imageBuffer.toString("base64")}` }) + "\n";
-        } catch (error) {
-          content += session.text("commands.cave.error.mediaLoadFailed", ["图片"]) + "\n";
-        }
-      } else {
-        content += session.text("commands.cave.message.mediaInvalid", ["图片"]) + "\n";
+      const filePath = path4.join(resourceDir, element.file);
+      const base64Data = await processMediaFile(filePath, "image");
+      if (base64Data) {
+        lines.push((0, import_koishi4.h)("image", { src: base64Data }));
       }
-    } else if (element.type === "video" && element.file) {
-      videoElements.push({ file: element.file });
     }
   }
-  if (videoElements.length > 0 && session) {
-    content += session.text("commands.cave.message.videoSending") + "\n";
-    for (const video of videoElements) {
-      const fullVideoPath = path.join(resourceDir, video.file);
-      if (fs.existsSync(fullVideoPath)) {
-        try {
-          const videoBuffer = fs.readFileSync(fullVideoPath);
-          session.send((0, import_koishi.h)("video", { src: `data:video/mp4;base64,${videoBuffer.toString("base64")}` })).catch((error) => logger.warn(session.text("commands.cave.error.videoSendFailed"), error.message));
-        } catch (error) {
-          content += session.text("commands.cave.error.mediaLoadFailed", ["视频"]) + "\n";
+  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) {
+  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 ext = path4.extname(fileName || url) || (mediaType === "img" ? ".png" : ".mp4");
+    const baseName = path4.basename(fileName || "media", ext).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
+    const finalFileName = `${caveId}_${baseName}${ext}`;
+    const filePath = path4.join(resourceDir, finalFileName);
+    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");
+      if (mediaType === "img") {
+        const buffer = Buffer.from(response.data);
+        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.duplicateFound",
+                [(similarity * 100).toFixed(1)]
+              );
+              await session.send(message + await buildMessage(originalCave, resourceDir, session));
+              throw new Error("duplicate_found");
+            }
+          }
         }
+        await FileHandler.saveMediaFile(filePath, buffer);
       } else {
-        content += session.text("commands.cave.message.mediaInvalid", ["视频"]) + "\n";
+        await FileHandler.saveMediaFile(filePath, Buffer.from(response.data));
+      }
+      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`));
     }
-  }
-  content += session.text("commands.cave.message.contributorSuffix", [cave.contributor_name]);
-  return content;
+  });
+  return Promise.all(downloadTasks);
 }
-__name(buildMessage, "buildMessage");
-var CacheManager = class {
-  static {
-    __name(this, "CacheManager");
-  }
-  static caveDataCache = null;
-  static pendingDataCache = null;
-  static cacheTimeout = 5 * 60 * 1e3;
-  // 5分钟缓存
-  static lastCaveUpdate = 0;
-  static lastPendingUpdate = 0;
-  static clearCache() {
-    this.caveDataCache = null;
-    this.pendingDataCache = null;
-  }
-  static async getCaveData(filePath, session) {
-    const now = Date.now();
-    if (!this.caveDataCache || now - this.lastCaveUpdate > this.cacheTimeout) {
-      this.caveDataCache = await FileHandler.readJsonData(filePath, session);
-      this.lastCaveUpdate = now;
-    }
-    return this.caveDataCache;
-  }
-  static async getPendingData(filePath, session) {
-    const now = Date.now();
-    if (!this.pendingDataCache || now - this.lastPendingUpdate > this.cacheTimeout) {
-      this.pendingDataCache = await FileHandler.readJsonData(filePath, session);
-      this.lastPendingUpdate = now;
-    }
-    return this.pendingDataCache;
-  }
-  static updateCaveData(data) {
-    this.caveDataCache = data;
-    this.lastCaveUpdate = Date.now();
-  }
-  static updatePendingData(data) {
-    this.pendingDataCache = data;
-    this.lastPendingUpdate = Date.now();
-  }
-};
+__name(saveMedia, "saveMedia");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,