koishi-plugin-best-cave 1.1.4 → 1.2.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: "视频发送失败" }, 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: "管理员", 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}文件大小超过限制" } } } };
   }
 });
 
 // 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" }, 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: "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" } } } };
   }
 });
 
@@ -49,8 +49,6 @@ var src_exports = {};
 __export(src_exports, {
   Config: () => Config,
   apply: () => apply,
-  handleCaveAction: () => handleCaveAction,
-  initCavePaths: () => initCavePaths,
   inject: () => inject,
   name: () => name
 });
@@ -78,18 +76,382 @@ 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 { caveFilePath, resourceDir, pendingFilePath } = await initCavePaths(ctx);
+  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");
+  await FileHandler.ensureDirectory(dataDir);
+  await FileHandler.ensureDirectory(caveDir);
+  await FileHandler.ensureDirectory(resourceDir);
+  await FileHandler.ensureJsonFile(caveFilePath);
+  await FileHandler.ensureJsonFile(pendingFilePath);
+  const idManager = new IdManager(ctx.baseDir);
+  await idManager.initialize(caveFilePath, pendingFilePath);
   const lastUsed = /* @__PURE__ */ new Map();
+  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 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(",")]);
+    });
+    const totalSubmissions = Object.values(stats).reduce((sum, arr) => sum + arr.length, 0);
+    if (config2.enablePagination) {
+      const itemsPerPage = config2.itemsPerPage;
+      const totalPages = Math.max(1, Math.ceil(lines.length / itemsPerPage));
+      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]);
+    } else {
+      return session.text("commands.cave.list.header", [totalSubmissions]) + "\n" + lines.join("\n");
+    }
+  }
+  __name(processList, "processList");
+  async function processAudit(ctx2, pendingFilePath2, caveFilePath2, resourceDir2, session, options, content) {
+    const pendingData = await FileHandler.readJsonData(pendingFilePath2);
+    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);
+    }
+    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);
+  }
+  __name(processAudit, "processAudit");
+  async function processView(caveFilePath2, resourceDir2, session, options, content, config2) {
+    if (!await checkCooldown(session, config2)) {
+      return "";
+    }
+    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 cave = data.find((item) => item.cave_id === caveId);
+    if (!cave) return sendMessage(session, "commands.cave.error.notFound", [], true);
+    return buildMessage(cave, resourceDir2, session);
+  }
+  __name(processView, "processView");
+  async function processRandom(caveFilePath2, resourceDir2, session, config2) {
+    const data = await FileHandler.readJsonData(caveFilePath2);
+    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);
+  }
+  __name(processRandom, "processRandom");
+  async function processDelete(caveFilePath2, resourceDir2, pendingFilePath2, 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 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);
+    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);
+          }
+        }
+      }
+    }
+    if (isPending) {
+      const newPendingData = pendingData.filter((item) => item.cave_id !== caveId);
+      await FileHandler.writeJsonData(pendingFilePath2, newPendingData);
+    } else {
+      const newData = data.filter((item) => item.cave_id !== caveId);
+      await FileHandler.writeJsonData(caveFilePath2, 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) {
+    try {
+      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) 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);
+      }
+      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 [savedImages, savedVideos] = await Promise.all([
+        imageUrls.length > 0 ? saveMedia(
+          imageUrls,
+          imageElements.map((el) => el.fileName),
+          resourceDir2,
+          caveId,
+          "img",
+          ctx2,
+          session
+        ) : [],
+        videoUrls.length > 0 ? saveMedia(
+          videoUrls,
+          videoElements.map((el) => el.fileName),
+          resourceDir2,
+          caveId,
+          "video",
+          ctx2,
+          session
+        ) : []
+      ]);
+      const newCave = {
+        cave_id: caveId,
+        elements: [
+          ...textParts,
+          ...imageElements.map((el, idx) => ({
+            ...el,
+            file: savedImages[idx],
+            // 保持原始文本和图片的相对位置
+            index: el.index
+          }))
+        ].sort((a, b) => a.index - b.index),
+        contributor_number: session.userId,
+        contributor_name: session.username
+      };
+      if (videoUrls.length > 0 && savedVideos.length > 0) {
+        newCave.elements.push({
+          type: "video",
+          file: savedVideos[0],
+          index: Number.MAX_SAFE_INTEGER
+          // 确保视频总是在最后
+        });
+      }
+      if (config2.enableAudit && !bypassAudit) {
+        const pendingData = await FileHandler.readJsonData(pendingFilePath2);
+        pendingData.push(newCave);
+        await Promise.all([
+          FileHandler.writeJsonData(pendingFilePath2, pendingData),
+          sendAuditMessage(ctx2, config2, newCave, await buildMessage(newCave, resourceDir2, session), session)
+        ]);
+        return sendMessage(session, "commands.cave.add.submitPending", [caveId], false);
+      }
+      const data = await FileHandler.readJsonData(caveFilePath2);
+      data.push({
+        ...newCave,
+        elements: cleanElementsForSave(newCave.elements, false)
+      });
+      await FileHandler.writeJsonData(caveFilePath2, data);
+      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);
+    }
+  }
+  __name(processAdd, "processAdd");
+  async function handleAudit(ctx2, pendingData, isApprove, caveFilePath2, resourceDir2, pendingFilePath2, session, targetId) {
+    if (pendingData.length === 0) {
+      return sendMessage(session, "commands.cave.audit.noPending", [], true);
+    }
+    if (typeof targetId === "number") {
+      const targetCave = pendingData.find((item) => item.cave_id === targetId);
+      if (!targetCave) {
+        return sendMessage(session, "commands.cave.audit.pendingNotFound", [], true);
+      }
+      const newPendingData = pendingData.filter((item) => item.cave_id !== targetId);
+      if (isApprove) {
+        const oldCaveData = await FileHandler.readJsonData(caveFilePath2);
+        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: pendingFilePath2,
+            operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath2, newPendingData), "operation"),
+            rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath2, pendingData), "rollback")
+          }
+        ]);
+        await idManager.addStat(targetCave.contributor_number, targetId);
+      } else {
+        await FileHandler.writeJsonData(pendingFilePath2, 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 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);
+      }
+      return sendMessage(
+        session,
+        isApprove ? "commands.cave.audit.auditPassed" : "commands.cave.audit.auditRejected",
+        [],
+        false
+      );
+    }
+    const data = isApprove ? await FileHandler.readJsonData(caveFilePath2) : null;
+    let processedCount = 0;
+    if (isApprove && data) {
+      const oldData = [...data];
+      const newData = [...data];
+      await FileHandler.withTransaction([
+        {
+          filePath: caveFilePath2,
+          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);
+          }, "operation"),
+          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath2, oldData), "rollback")
+        },
+        {
+          filePath: pendingFilePath2,
+          operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath2, []), "operation"),
+          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath2, pendingData), "rollback")
+        }
+      ]);
+    } else {
+      for (const cave of pendingData) {
+        await idManager.markDeleted(cave.cave_id);
+      }
+      await FileHandler.writeJsonData(pendingFilePath2, []);
+      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);
+              }
+            }
+          }
+        }
+        processedCount++;
+      }
+    }
+    return sendMessage(session, "commands.cave.audit.batchAuditResult", [
+      isApprove ? "通过" : "拒绝",
+      processedCount,
+      pendingData.length
+    ], 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 sendTempMessage(session, "commands.cave.message.blacklisted");
+      return sendMessage(session, "commands.cave.message.blacklisted", [], true);
     }
-    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");
+    if ((options.p || options.d) && !config.manager.includes(session.userId)) {
+      return sendMessage(session, "commands.cave.message.managerOnly", [], true);
     }
   }).action(async ({ session, options }, ...content) => {
-    return await handleCaveAction(ctx, config, session, options, content, lastUsed);
+    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) {
+      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 (options.p || options.d) {
+      return await processAudit(ctx, pendingFilePath2, caveFilePath2, resourceDir2, session, options, content);
+    }
+    if (options.g) {
+      return await processView(caveFilePath2, resourceDir2, session, options, content, config);
+    }
+    if (options.r) {
+      return await processDelete(caveFilePath2, resourceDir2, pendingFilePath2, session, config, options, content);
+    }
+    if (options.a) {
+      return await processAdd(ctx, config, caveFilePath2, resourceDir2, pendingFilePath2, session, content);
+    }
+    return await processRandom(caveFilePath2, resourceDir2, session, config);
   });
 }
 __name(apply, "apply");
@@ -98,563 +460,472 @@ var FileHandler = class {
   static {
     __name(this, "FileHandler");
   }
-  static readJsonData(filePath, session, validator) {
+  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 {
-      const data = fs.readFileSync(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 [];
+      return await operationPromise;
+    } finally {
+      this.locks.delete(key);
     }
   }
-  static writeJsonData(filePath, data, session) {
+  /**
+   * 事务处理
+   */
+  static async withTransaction(operations) {
+    const results = [];
+    const completed = /* @__PURE__ */ new Set();
     try {
-      fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+      for (const { filePath, operation } of operations) {
+        const result = await this.withFileOp(filePath, operation);
+        results.push(result);
+        completed.add(filePath);
+      }
+      return results;
     } catch (error) {
-      logger.error(session.text("commands.cave.error.fileWrite", [error.message]));
-      throw new Error(session.text("commands.cave.error.saveFailed"));
+      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) {
-    !fs.existsSync(dir) && await fs.promises.mkdir(dir, { recursive: true });
+    await this.withConcurrencyLimit(async () => {
+      if (!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");
+  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);
+      }
+    });
   }
 };
-async function saveMedia(urls, fileNames, fileSizes, resourceDir, caveId, config, ctx, mediaType, session) {
-  const savedFiles = [];
-  const defaults = mediaType === "img" ? { ext: "png", accept: "image/*", maxSize: config.imageMaxSize } : { ext: "mp4", accept: "video/*", maxSize: config.videoMaxSize };
-  const extPattern = /\.[a-zA-Z0-9]+$/;
-  for (let i = 0; i < urls.length; i++) {
+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 {
-      const url = urls[i];
-      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]));
-          continue;
+      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)
+        ]);
       }
-      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"
+      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] = [];
         }
-      });
-      const fileBuffer = Buffer.from(response.data);
-      await fs.promises.writeFile(targetPath, fileBuffer);
-      savedFiles.push(finalFileName);
+        this.stats[cave.contributor_number].push(cave.cave_id);
+      }
+      await this.saveStatus();
+      this.initialized = true;
     } catch (error) {
-      const errorKey = mediaType === "img" ? "commands.cave.error.uploadImageFailed" : "commands.cave.error.uploadVideoFailed";
-      await sendTempMessage(session, errorKey);
-      return [];
+      this.initialized = false;
+      logger.error(`IdManager initialization failed: ${error.message}`);
+      throw error;
     }
   }
-  return savedFiles;
-}
-__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]));
+  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;
   }
-}
-__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);
-        }
+  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();
     }
-    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 ? FileHandler.readJsonData(caveFilePath, session) : null;
-    const auditResult = await handleSingleCaveAudit(ctx, cave, isApprove, resourceDir, data2, session);
-    if (typeof auditResult === "string") return auditResult;
-    if (isApprove && data2) FileHandler.writeJsonData(caveFilePath, data2, session);
-    pendingData.splice(pendingIndex, 1);
-    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
-      // 审核结果改为永久消息
-    );
+  // 获取统计信息
+  getStats() {
+    return this.stats;
   }
-  const data = isApprove ? 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) FileHandler.writeJsonData(caveFilePath, data, session);
-  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 () => {
+  async saveStatus() {
     try {
-      await session.bot.deleteMessage(session.channelId, msg);
+      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 delete message:", error);
+      logger.error(`Failed to save status: ${error.message}`);
+      throw error;
     }
-  }, timeout);
+  }
+};
+async function sendMessage(session, key, params = [], isTemp = true, timeout = 1e4) {
+  try {
+    const msg = await session.send(session.text(key, params));
+    if (isTemp && msg) {
+      setTimeout(async () => {
+        try {
+          await session.bot.deleteMessage(session.channelId, msg);
+        } catch (error) {
+          logger.debug(`Failed to delete temporary message: ${error.message}`);
+        }
+      }, timeout);
+    }
+  } catch (error) {
+    logger.error(`Failed to send message: ${error.message}`);
+  }
   return "";
 }
-__name(sendTempMessage, "sendTempMessage");
-async function sendMessage(session, key, params = [], isTemp = true, timeout = 1e4) {
-  const msg = await session.send(session.text(key, params));
-  if (isTemp) {
-    setTimeout(async () => {
+__name(sendMessage, "sendMessage");
+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 session.bot.deleteMessage(session.channelId, msg);
+        await bot.sendPrivateMessage(managerId, auditMessage);
       } catch (error) {
-        logger.error("Failed to delete message:", error);
+        logger.error(session.text("commands.cave.audit.sendFailed", [managerId]));
       }
-    }, timeout);
+    }
   }
-  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 });
-    }
-  });
-  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 fs.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 (element.type === "text") {
-      content += element.content + "\n";
-    } 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";
-      }
-    } else if (element.type === "video" && element.file) {
-      videoElements.push({ file: element.file });
+  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 = path.join(resourceDir, videoElement.file);
+    const base64Data = await processMediaFile(filePath, "video");
+    if (base64Data && session) {
+      await session.send((0, import_koishi.h)("video", { src: base64Data }));
     }
+    return "";
   }
-  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";
-        }
-      } else {
-        content += session.text("commands.cave.message.mediaInvalid", ["视频"]) + "\n";
+  const lines = [session.text("commands.cave.message.caveTitle", [cave.cave_id])];
+  for (const element of nonVideoElements) {
+    if (element.type === "text") {
+      lines.push(element.content);
+    } else if (element.type === "img" && element.file) {
+      const filePath = path.join(resourceDir, element.file);
+      const base64Data = await processMediaFile(filePath, "image");
+      if (base64Data) {
+        lines.push((0, import_koishi.h)("image", { src: base64Data }));
       }
     }
   }
-  content += session.text("commands.cave.message.contributorSuffix", [cave.contributor_name]);
-  return content;
+  lines.push(session.text("commands.cave.message.contributorSuffix", [cave.contributor_name]));
+  return lines.join("\n");
 }
 __name(buildMessage, "buildMessage");
-async function initCavePaths(ctx) {
-  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");
-  await FileHandler.ensureDirectory(dataDir);
-  await FileHandler.ensureDirectory(caveDir);
-  await FileHandler.ensureDirectory(resourceDir);
-  await FileHandler.ensureJsonFile(caveFilePath);
-  await FileHandler.ensureJsonFile(pendingFilePath);
-  return { dataDir, caveDir, caveFilePath, resourceDir, pendingFilePath };
-}
-__name(initCavePaths, "initCavePaths");
-async function handleCaveAction(ctx, config, session, options, content, lastUsed) {
-  try {
-    const { caveFilePath, resourceDir, pendingFilePath } = await initCavePaths(ctx);
-    async function processList() {
-      const caveData = FileHandler.readJsonData(caveFilePath, session);
-      const caveDir = path.dirname(caveFilePath);
-      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);
-      }
-      const statFilePath = path.join(caveDir, "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(",")]);
-      });
-      const totalSubmissions = Object.values(stats).reduce((sum, arr) => sum + arr.length, 0);
-      if (config.enablePagination) {
-        const itemsPerPage = config.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;
-        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]);
-      } else {
-        return session.text("commands.cave.list.header", [totalSubmissions]) + "\n" + lines.join("\n");
-      }
-    }
-    __name(processList, "processList");
-    async function processAudit() {
-      const pendingData = FileHandler.readJsonData(pendingFilePath, session);
-      const isApprove = Boolean(options.p);
-      if (options.p === true && content[0] === "all" || options.d === true && content[0] === "all") {
-        return await handleAudit(ctx, 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(ctx, pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, id), [], true);
-    }
-    __name(processAudit, "processAudit");
-    async function processView() {
-      const caveId = parseInt(content[0] || (typeof options.g === "string" ? options.g : ""));
-      if (isNaN(caveId)) return sendMessage(session, "commands.cave.error.invalidId", [], true);
-      const data = FileHandler.readJsonData(
-        caveFilePath,
-        session,
-        (item) => item && typeof item.cave_id === "number" && Array.isArray(item.elements) && item.elements.every(
-          (el) => el.type === "text" && typeof el.content === "string" || el.type === "img" && typeof el.file === "string" || el.type === "video" && typeof el.file === "string"
-        ) && typeof item.contributor_number === "string" && typeof item.contributor_name === "string"
-      );
-      const cave = data.find((item) => item.cave_id === caveId);
-      if (!cave) return sendMessage(session, "commands.cave.error.notFound", [], true);
-      const caveContent = await buildMessage(cave, resourceDir, session);
-      return caveContent;
-    }
-    __name(processView, "processView");
-    async function processRandom() {
-      try {
-        const data = FileHandler.readJsonData(
-          caveFilePath,
-          session,
-          (item) => item && typeof item.cave_id === "number" && Array.isArray(item.elements) && item.elements.every(
-            (el) => el.type === "text" && typeof el.content === "string" || el.type === "img" && typeof el.file === "string"
-          ) && typeof item.contributor_number === "string" && typeof item.contributor_name === "string"
-        );
-        if (data.length === 0) {
-          return sendMessage(session, "commands.cave.error.noCave", [], true);
-        }
-        const guildId = session.guildId;
-        const now = Date.now();
-        const lastCall = lastUsed.get(guildId) || 0;
-        const isManager = config.manager.includes(session.userId);
-        if (!isManager && now - lastCall < config.number * 1e3) {
-          const waitTime = Math.ceil((config.number * 1e3 - (now - lastCall)) / 1e3);
-          return sendMessage(session, "commands.cave.message.cooldown", [waitTime], true);
-        }
-        if (!isManager) lastUsed.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, resourceDir, session) : sendMessage(session, "commands.cave.error.getCave", [], true);
-      } catch (error) {
-        return sendMessage(session, "commands.cave.error.commandProcess", [error.message], true);
-      }
-    }
-    __name(processRandom, "processRandom");
-    async function processDelete() {
-      const caveId = parseInt(content[0] || (typeof options.r === "string" ? options.r : ""));
-      if (isNaN(caveId)) return sendMessage(session, "commands.cave.error.invalidId", [], true);
-      const data = FileHandler.readJsonData(
-        caveFilePath,
-        session,
-        (item) => item && typeof item.cave_id === "number"
-      );
-      const pendingData = FileHandler.readJsonData(pendingFilePath, 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;
-      }
-      if (targetCave.contributor_number !== session.userId && !config.manager.includes(session.userId)) {
-        return sendMessage(session, "commands.cave.remove.noPermission", [], true);
-      }
-      const caveContent = await buildMessage(targetCave, resourceDir, session);
-      if (targetCave.elements) {
-        for (const element of targetCave.elements) {
-          if ((element.type === "img" || element.type === "video") && element.file) {
-            const fullPath = path.join(resourceDir, element.file);
-            if (fs.existsSync(fullPath)) fs.unlinkSync(fullPath);
-          }
+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]));
         }
       }
-      if (isPending) {
-        pendingData.splice(pendingIndex, 1);
-        FileHandler.writeJsonData(pendingFilePath, pendingData, session);
-        const deleteStatus = isPending ? session.text("commands.cave.remove.deletePending") : "";
-        const deleteMessage = session.text("commands.cave.remove.deleted");
-        return `${deleteMessage}${deleteStatus}
-${caveContent}`;
-      } else {
-        data.splice(index, 1);
-        FileHandler.writeJsonData(caveFilePath, data, session);
-        const deleteStatus = isPending ? session.text("commands.cave.remove.deletePending") : "";
-        const deleteMessage = session.text("commands.cave.remove.deleted");
-        return `${deleteMessage}${deleteStatus}${caveContent}`;
-      }
+      urls.push(url);
+      elements.push({
+        type,
+        index: type === "video" ? Number.MAX_SAFE_INTEGER : idx * 3 + 1,
+        // 视频始终在最后
+        fileName,
+        fileSize
+      });
+      idx++;
     }
-    __name(processDelete, "processDelete");
-    async function processAdd() {
-      try {
-        let inputParts = [];
-        if (content.length > 0) {
-          inputParts = content;
-        }
-        if (!inputParts.length) {
-          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];
-        }
-        let { imageUrls, imageElements, videoUrls, videoElements, textParts } = await extractMediaContent(inputParts.join("\n"));
-        if (videoUrls.length > 0 && !config.allowVideo) {
-          return sendMessage(session, "commands.cave.add.videoDisabled", [], true);
-        }
-        const pendingData = FileHandler.readJsonData(pendingFilePath, session);
-        const data = FileHandler.readJsonData(caveFilePath, session, (item) => item && typeof item.cave_id === "number");
-        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,
-              resourceDir,
-              caveId,
-              config,
-              ctx,
-              "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,
-              resourceDir,
-              caveId,
-              config,
-              ctx,
-              "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 (ctx.database) {
-          try {
-            const userInfo = await ctx.database.getUser(session.platform, session.userId);
-            contributorName = userInfo?.nickname || session.username;
-          } catch (error) {
-            return sendMessage(
-              session,
-              "commands.cave.error.userInfo",
-              [error.message],
-              true
-            );
-          }
-        }
-        const newCave = {
-          cave_id: caveId,
-          elements: cleanElementsForSave(elements, true),
-          contributor_number: session.userId,
-          contributor_name: contributorName
-        };
-        const bypassAudit = config.whitelist.includes(session.userId) || session.guildId && config.whitelist.includes(session.guildId) || session.channelId && config.whitelist.includes(session.channelId);
-        if (config.enableAudit && !bypassAudit) {
-          pendingData.push({ ...newCave, elements: cleanElementsForSave(elements, true) });
-          FileHandler.writeJsonData(pendingFilePath, pendingData, session);
-          await sendAuditMessage(ctx, config, 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);
-          FileHandler.writeJsonData(caveFilePath, data, session);
-          return sendMessage(session, "commands.cave.add.addSuccess", [caveId], false);
+    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, ctx, session) {
+  const { ext, accept } = mediaType === "img" ? { ext: "png", accept: "image/*" } : { ext: "mp4", accept: "video/*" };
+  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);
+    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"
         }
-      } catch (error) {
-        return sendMessage(session, "commands.cave.error.commandProcess", [error.message], true);
-      }
+      });
+      if (!response.data) throw new Error("empty_response");
+      await FileHandler.saveMediaFile(filePath, Buffer.from(response.data));
+      return finalFileName;
+    } catch (error) {
+      logger.error(`Failed to download media: ${error.message}`);
+      throw error;
     }
-    __name(processAdd, "processAdd");
-    if (options.l !== void 0) return await processList();
-    if (options.p || options.d) return await processAudit();
-    if (options.g) return await processView();
-    if (options.r) return await processDelete();
-    if (options.a) return await processAdd();
-    return await processRandom();
-  } catch (error) {
-    logger.error(error);
-    return sendMessage(session, "commands.cave.error.commandProcess", [error.message], true);
+  });
+  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;
 }
-__name(handleCaveAction, "handleCaveAction");
+__name(saveMedia, "saveMedia");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,
   apply,
-  handleCaveAction,
-  initCavePaths,
   inject,
   name
 });