koishi-plugin-best-cave 1.7.2 → 2.0.0

package/lib/index.js

@@ -5,9 +5,6 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name2 in all)
     __defProp(target, name2, { get: all[name2], enumerable: true });
@@ -30,1800 +27,801 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/locales/zh-CN.yml
-var require_zh_CN = __commonJS({
-  "src/locales/zh-CN.yml"(exports2, module2) {
-    module2.exports = { _config: { manager: "管理员", number: "冷却时间（秒）", enableAudit: "启用审核", enableTextDuplicate: "启用文本查重", textDuplicateThreshold: "文本相似度阈值（0-1）", enableImageDuplicate: "启用图片查重", imageDuplicateThreshold: "图片相似度阈值（0-1）", imageMaxSize: "图片最大大小（MB）", allowVideo: "允许视频上传", videoMaxSize: "视频最大大小（MB）", enablePagination: "启用统计分页", itemsPerPage: "每页显示数目", blacklist: "黑名单（用户）", whitelist: "审核白名单（用户/群组/频道）" }, commands: { cave: { description: "回声洞", usage: "支持添加、抽取、查看、管理回声洞", examples: "使用 cave 随机抽取回声洞\n使用 -a 直接添加或引用添加\n使用 -g 查看指定回声洞\n使用 -r 删除指定回声洞", options: { a: "添加回声洞", g: "查看回声洞", r: "删除回声洞", l: "查询投稿统计" }, pass: { description: "通过回声洞审核", usage: "通过指定ID的回声洞审核\ncave.pass <ID> - 通过审核\ncave.pass all - 通过所有待审核内容\n" }, reject: { description: "拒绝回声洞审核", usage: "拒绝指定ID的回声洞审核\ncave.reject <ID> - 拒绝审核\ncave.reject all - 拒绝所有待审核内容\n" }, add: { noContent: "请在一分钟内发送内容", operationTimeout: "操作超时，添加取消", videoDisabled: "不允许上传视频", submitPending: "提交成功，序号为（{0}）", addSuccess: "添加成功，序号为（{0}）", mediaSizeExceeded: "{0}文件大小超过限制", localFileNotAllowed: "检测到本地文件路径，无法保存" }, remove: { noPermission: "你无权删除他人添加的回声洞", deletePending: "删除（待审核）", deleted: "已删除" }, list: { pageInfo: "第 {0} / {1} 页", header: "当前共有 {0} 项回声洞：", totalItems: "用户 {0} 共计投稿 {1} 项：", idsLine: "{0}" }, audit: { noPending: "暂无待审核回声洞", pendingNotFound: "未找到待审核回声洞", pendingResult: "{0}，剩余 {1} 个待审核回声洞：[{2}]", auditPassed: "已通过", auditRejected: "已拒绝", batchAuditResult: "已{0} {1}/{2} 项回声洞", title: "待审核回声洞：", from: "投稿人：", sendFailed: "发送审核消息失败，无法联系管理员 {0}" }, error: { noContent: "回声洞内容为空", getCave: "获取回声洞失败", noCave: "当前无回声洞", invalidId: "请输入有效的回声洞ID", notFound: "未找到该回声洞", exactDuplicateFound: "发现完全相同的", similarDuplicateFound: "发现相似度为 {0}% 的", addFailed: "添加失败，请稍后重试。" }, 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: "Administrator", number: "Cooldown time (seconds)", enableAudit: "Enable moderation", enableTextDuplicate: "Enable text duplicate check", textDuplicateThreshold: "Text similarity threshold (0-1)", enableImageDuplicate: "Enable image duplicate check", imageDuplicateThreshold: "Image similarity threshold (0-1)", imageMaxSize: "Maximum image size (MB)", allowVideo: "Allow video upload", videoMaxSize: "Maximum video size (MB)", enablePagination: "Enable statistics pagination", itemsPerPage: "Items per page", blacklist: "Blacklist (users)", whitelist: "Moderation whitelist (users/groups/channels)" }, commands: { cave: { description: "Echo Cave", usage: "Support adding, drawing, viewing, and managing echo caves", examples: "Use cave to randomly draw an echo\nUse -a to add directly or add by reference\nUse -g to view specific echo\nUse -r to delete specific echo", options: { a: "Add echo", g: "View echo", r: "Delete echo", l: "Query submission statistics" }, pass: { description: "Approve cave submission", usage: "Approve cave submission with specific ID\ncave.pass <ID> - Approve submission\ncave.pass all - Approve all pending submissions\n" }, reject: { description: "Reject cave submission", usage: "Reject cave submission with specific ID\ncave.reject <ID> - Reject submission\ncave.reject all - Reject all pending submissions\n" }, add: { noContent: "Please send content within one minute", operationTimeout: "Operation timeout, addition cancelled", videoDisabled: "Video upload not allowed", submitPending: "Submission successful, ID is ({0})", addSuccess: "Added successfully, ID is ({0})", mediaSizeExceeded: "{0} file size exceeds limit", localFileNotAllowed: "Local file path detected, cannot save" }, remove: { noPermission: "You don't have permission to delete others' echos", deletePending: "Delete (pending review)", deleted: "Deleted" }, list: { pageInfo: "Page {0} / {1}", header: "Currently there are {0} echos:", totalItems: "User {0} has submitted {1} items:", idsLine: "{0}" }, audit: { noPending: "No pending echos for review", pendingNotFound: "Pending echo not found", pendingResult: "{0}, {1} pending echos remaining: [{2}]", auditPassed: "Approved", auditRejected: "Rejected", batchAuditResult: "{0} {1}/{2} echos", title: "Pending echos:", from: "Submitted by:", sendFailed: "Failed to send moderation message, cannot contact administrator {0}" }, error: { noContent: "Echo content is empty", getCave: "Failed to get echo", noCave: "No echos available", invalidId: "Please enter a valid echo ID", notFound: "Echo not found", exactDuplicateFound: "Found exactly identical", similarDuplicateFound: "Found {0}% similar", addFailed: "Add failed, please try again later." }, message: { blacklisted: "You have been blacklisted", managerOnly: "This operation is limited to administrators only", cooldown: "Group chat cooling down... Please try again in {0} seconds", caveTitle: "Echo Cave —— ({0})", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0} file size exceeds limit" } } } };
-  }
-});
-
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   Config: () => Config,
   apply: () => apply,
   inject: () => inject,
-  name: () => name
+  name: () => name,
+  usage: () => usage
 });
-module.exports = __toCommonJS(src_exports);
-var import_koishi6 = require("koishi");
-var fs7 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+module.exports = __toCommonJS(index_exports);
+var import_koishi3 = require("koishi");
 
-// src/utils/FileHandler.ts
-var fs = __toESM(require("fs"));
+// src/FileManager.ts
+var import_client_s3 = require("@aws-sdk/client-s3");
+var fs = __toESM(require("fs/promises"));
 var path = __toESM(require("path"));
-var import_koishi = require("koishi");
-var logger = new import_koishi.Logger("fileHandler");
-var FileHandler = class {
-  static {
-    __name(this, "FileHandler");
-  }
-  static locks = /* @__PURE__ */ new Map();
-  static RETRY_COUNT = 3;
-  static RETRY_DELAY = 1e3;
-  static CONCURRENCY_LIMIT = 5;
-  /**
-   * 并发控制
-   * @param operation 要执行的操作
-   * @param limit 并发限制
-   * @returns 操作结果
-   */
-  static async withConcurrencyLimit(operation, limit = this.CONCURRENCY_LIMIT) {
-    while (this.locks.size >= limit) {
-      await Promise.race(this.locks.values());
-    }
-    return operation();
-  }
-  /**
-   * 文件操作包装器
-   * @param filePath 文件路径
-   * @param operation 要执行的操作
-   * @returns 操作结果
-   */
-  static async withFileOp(filePath, operation) {
-    const key = filePath;
-    while (this.locks.has(key)) {
-      await this.locks.get(key);
-    }
-    const operationPromise = (async () => {
-      for (let i = 0; i < this.RETRY_COUNT; i++) {
-        try {
-          return await operation();
-        } catch (error) {
-          if (i === this.RETRY_COUNT - 1) throw error;
-          await new Promise((resolve) => setTimeout(resolve, this.RETRY_DELAY));
+var FileManager = class {
+  /**
+   * 创建一个 FileManager 实例。
+   * @param baseDir - Koishi 应用的基础数据目录 (ctx.baseDir)。
+   * @param config - 插件的完整配置对象。
+   * @param logger - 日志记录器实例。
+   */
+  constructor(baseDir, config, logger2) {
+    this.logger = logger2;
+    this.resourceDir = path.join(baseDir, "data", "cave");
+    if (config.enableS3 && config.endpoint && config.bucket && config.accessKeyId && config.secretAccessKey) {
+      this.s3Client = new import_client_s3.S3Client({
+        endpoint: config.endpoint,
+        region: config.region,
+        credentials: {
+          accessKeyId: config.accessKeyId,
+          secretAccessKey: config.secretAccessKey
         }
-      }
-      throw new Error("Operation failed after retries");
-    })();
-    this.locks.set(key, operationPromise);
-    try {
-      return await operationPromise;
-    } finally {
-      this.locks.delete(key);
-    }
-  }
-  /**
-   * 事务处理
-   * @param operations 要执行的操作数组
-   * @returns 操作结果数组
-   */
-  static async withTransaction(operations) {
-    const results = [];
-    const completed = /* @__PURE__ */ new Set();
-    try {
-      for (const { filePath, operation } of operations) {
-        const result = await this.withFileOp(filePath, operation);
-        results.push(result);
-        completed.add(filePath);
-      }
-      return results;
-    } catch (error) {
-      await Promise.all(
-        operations.filter(({ filePath }) => completed.has(filePath)).map(async ({ filePath, rollback }) => {
-          if (rollback) {
-            await this.withFileOp(filePath, rollback).catch(
-              (e) => logger.error(`Rollback failed for ${filePath}: ${e.message}`)
-            );
-          }
-        })
-      );
-      throw error;
+      });
+      this.s3Bucket = config.bucket;
     }
   }
-  /**
-   * 读取 JSON 数据
-   * @param filePath 文件路径
-   * @returns JSON 数据
-   */
-  static async readJsonData(filePath) {
-    return this.withFileOp(filePath, async () => {
-      try {
-        const data = await fs.promises.readFile(filePath, "utf8");
-        return JSON.parse(data || "[]");
-      } catch (error) {
-        return [];
-      }
-    });
-  }
-  /**
-   * 写入 JSON 数据
-   * @param filePath 文件路径
-   * @param data 要写入的数据
-   */
-  static async writeJsonData(filePath, data) {
-    const tmpPath = `${filePath}.tmp`;
-    await this.withFileOp(filePath, async () => {
-      await fs.promises.writeFile(tmpPath, JSON.stringify(data, null, 2));
-      await fs.promises.rename(tmpPath, filePath);
-    });
-  }
-  /**
-   * 确保目录存在
-   * @param dir 目录路径
-   */
-  static async ensureDirectory(dir) {
-    await this.withConcurrencyLimit(async () => {
-      if (!fs.existsSync(dir)) {
-        await fs.promises.mkdir(dir, { recursive: true });
-      }
-    });
-  }
-  /**
-   * 确保 JSON 文件存在
-   * @param filePath 文件路径
-   */
-  static async ensureJsonFile(filePath) {
-    await this.withFileOp(filePath, async () => {
-      if (!fs.existsSync(filePath)) {
-        await fs.promises.writeFile(filePath, "[]", "utf8");
-      }
-    });
-  }
-  /**
-   * 保存媒体文件
-   * @param filePath 文件路径
-   * @param data 文件数据
-   */
-  static async saveMediaFile(filePath, data) {
-    await this.withConcurrencyLimit(async () => {
-      const dir = path.dirname(filePath);
-      await this.ensureDirectory(dir);
-      await this.withFileOp(
-        filePath,
-        () => fs.promises.writeFile(filePath, data)
-      );
-    });
-  }
-  /**
-   * 删除媒体文件
-   * @param filePath 文件路径
-   */
-  static async deleteMediaFile(filePath) {
-    await this.withFileOp(filePath, async () => {
-      if (fs.existsSync(filePath)) {
-        await fs.promises.unlink(filePath);
-      }
-    });
-  }
-};
-
-// src/utils/IdManager.ts
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
-var import_koishi2 = require("koishi");
-var logger2 = new import_koishi2.Logger("IdManager");
-var IdManager = class {
   static {
-    __name(this, "IdManager");
-  }
-  deletedIds = /* @__PURE__ */ new Set();
-  maxId = 0;
-  initialized = false;
-  statusFilePath;
-  stats = {};
-  usedIds = /* @__PURE__ */ new Set();
-  /**
-   * 初始化ID管理器
-   * @param baseDir - 基础目录路径
-   */
-  constructor(baseDir) {
-    const caveDir = path2.join(baseDir, "data", "cave");
-    this.statusFilePath = path2.join(caveDir, "status.json");
-  }
-  /**
-   * 初始化ID管理系统
-   * @param caveFilePath - 正式回声洞数据文件路径
-   * @param pendingFilePath - 待处理回声洞数据文件路径
-   * @throws 当初始化失败时抛出错误
+    __name(this, "FileManager");
+  }
+  // 本地资源存储目录的绝对路径。
+  resourceDir;
+  // 本地文件锁，键为文件绝对路径，值为一个 Promise，用于防止对同一文件的并发访问。
+  locks = /* @__PURE__ */ new Map();
+  // S3 客户端实例，仅在启用 S3 时初始化。
+  s3Client;
+  // S3 存储桶名称。
+  s3Bucket;
+  /**
+   * 确保本地资源目录存在。如果目录不存在，则会递归创建。
+   * 这是一个幂等操作。
+   * @private
    */
-  async initialize(caveFilePath, pendingFilePath) {
-    if (this.initialized) return;
+  async ensureDirectory() {
     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 || []);
-      for (let i = 1; i <= this.maxId; i++) {
-        if (!this.usedIds.has(i)) {
-          this.deletedIds.add(i);
-        }
-      }
-      await this.saveStatus();
-      this.initialized = true;
-      logger2.success(`Cave ID Manager initialized with ${this.maxId}(-${this.deletedIds.size}) IDs`);
+      await fs.mkdir(this.resourceDir, { recursive: true });
     } catch (error) {
-      this.initialized = false;
-      logger2.error(`ID Manager initialization failed: ${error.message}`);
+      this.logger.error(`创建资源目录失败 ${this.resourceDir}:`, error);
       throw error;
     }
   }
   /**
-   * 处理ID冲突
-   * @param conflicts - ID冲突映射表
-   * @param caveFilePath - 正式回声洞数据文件路径
-   * @param pendingFilePath - 待处理回声洞数据文件路径
-   * @param caveData - 正式回声洞数据
-   * @param pendingData - 待处理回声洞数据
+   * 获取给定文件名的完整本地路径。
+   * @param fileName - 文件名。
+   * @returns 文件的绝对路径。
    * @private
    */
-  async handleConflicts(conflicts, caveFilePath, pendingFilePath, caveData, pendingData) {
-    logger2.warn(`Found ${conflicts.size} ID conflicts`);
-    let modified = false;
-    for (const items of conflicts.values()) {
-      items.slice(1).forEach((item) => {
-        let newId = this.maxId + 1;
-        while (this.usedIds.has(newId)) {
-          newId++;
-        }
-        logger2.info(`Reassigning ID: ${item.cave_id} -> ${newId}`);
-        item.cave_id = newId;
-        this.usedIds.add(newId);
-        this.maxId = Math.max(this.maxId, newId);
-        modified = true;
-      });
-    }
-    if (modified) {
-      await Promise.all([
-        FileHandler.writeJsonData(caveFilePath, caveData),
-        FileHandler.writeJsonData(pendingFilePath, pendingData)
-      ]);
-      logger2.success("ID conflicts resolved");
-    }
-  }
-  /**
-   * 获取下一个可用的ID
-   * @returns 下一个可用的ID
-   * @throws 当ID管理器未初始化时抛出错误
-   */
-  getNextId() {
-    if (!this.initialized) {
-      throw new Error("IdManager not initialized");
-    }
-    let nextId;
-    if (this.deletedIds.size > 0) {
-      const minDeletedId = Math.min(...Array.from(this.deletedIds));
-      if (!isNaN(minDeletedId) && minDeletedId > 0) {
-        nextId = minDeletedId;
-        this.deletedIds.delete(nextId);
-      } else {
-        nextId = this.maxId + 1;
-      }
-    } else {
-      nextId = this.maxId + 1;
-    }
-    while (isNaN(nextId) || nextId <= 0 || this.usedIds.has(nextId)) {
-      nextId = this.maxId + 1;
-      this.maxId++;
-    }
-    this.usedIds.add(nextId);
-    this.saveStatus().catch(
-      (err) => logger2.error(`Failed to save status after getNextId: ${err.message}`)
-    );
-    return nextId;
-  }
-  /**
-   * 标记ID为已删除状态
-   * @param id - 要标记为删除的ID
-   * @throws 当ID管理器未初始化时抛出错误
-   */
-  async markDeleted(id) {
-    if (!this.initialized) {
-      throw new Error("IdManager not initialized");
-    }
-    this.deletedIds.add(id);
-    this.usedIds.delete(id);
-    const maxUsedId = Math.max(...Array.from(this.usedIds), 0);
-    const maxDeletedId = Math.max(...Array.from(this.deletedIds), 0);
-    this.maxId = Math.max(maxUsedId, maxDeletedId);
-    await this.saveStatus();
-  }
-  /**
-   * 添加贡献统计
-   * @param contributorNumber - 贡献者编号
-   * @param caveId - 回声洞ID
-   */
-  async addStat(contributorNumber, caveId) {
-    if (contributorNumber === "10000") return;
-    if (!this.stats[contributorNumber]) {
-      this.stats[contributorNumber] = [];
-    }
-    this.stats[contributorNumber].push(caveId);
-    await this.saveStatus();
-  }
-  /**
-   * 移除贡献统计
-   * @param contributorNumber - 贡献者编号
-   * @param caveId - 回声洞ID
-   */
-  async removeStat(contributorNumber, caveId) {
-    if (this.stats[contributorNumber]) {
-      this.stats[contributorNumber] = this.stats[contributorNumber].filter((id) => id !== caveId);
-      if (this.stats[contributorNumber].length === 0) {
-        delete this.stats[contributorNumber];
-      }
-      await this.saveStatus();
-    }
-  }
-  /**
-   * 获取所有贡献统计信息
-   * @returns 贡献者编号到回声洞ID列表的映射
-   */
-  getStats() {
-    return this.stats;
+  getFullPath(fileName) {
+    return path.join(this.resourceDir, fileName);
   }
   /**
-   * 保存当前状态到文件
+   * 使用文件锁来安全地执行一个异步文件操作。
+   * 这可以防止对同一文件的并发读写造成数据损坏。
+   * @template T - 异步操作的返回类型。
+   * @param fileName - 需要加锁的文件名。
+   * @param operation - 要执行的异步函数。
+   * @returns 返回异步操作的结果。
    * @private
-   * @throws 当保存失败时抛出错误
    */
-  async saveStatus() {
-    try {
-      const status = {
-        deletedIds: Array.from(this.deletedIds).sort((a, b) => a - b),
-        maxId: this.maxId,
-        stats: this.stats,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      const tmpPath = `${this.statusFilePath}.tmp`;
-      await fs2.promises.writeFile(tmpPath, JSON.stringify(status, null, 2), "utf8");
-      await fs2.promises.rename(tmpPath, this.statusFilePath);
-    } catch (error) {
-      logger2.error(`Status save failed: ${error.message}`);
-      throw error;
+  async withLock(fileName, operation) {
+    const fullPath = this.getFullPath(fileName);
+    while (this.locks.has(fullPath)) {
+      await this.locks.get(fullPath);
     }
-  }
-};
-
-// src/utils/HashManager.ts
-var import_koishi3 = require("koishi");
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
-
-// src/utils/ContentHasher.ts
-var import_sharp = __toESM(require("sharp"));
-var ContentHasher = class {
-  static {
-    __name(this, "ContentHasher");
-  }
-  /**
-   * 计算图片的感知哈希值
-   * @param imageBuffer - 图片的二进制数据
-   * @returns 返回64位的十六进制哈希字符串
-   * @throws 当图片处理失败时可能抛出错误
-   */
-  static async calculateHash(imageBuffer) {
-    const { data } = await (0, import_sharp.default)(imageBuffer).grayscale().resize(32, 32, { fit: "fill" }).raw().toBuffer({ resolveWithObject: true });
-    const dctMatrix = this.computeDCT(data, 32);
-    const features = this.extractFeatures(dctMatrix, 32);
-    const median = this.calculateMedian(features);
-    const binaryHash = features.map((val) => val > median ? "1" : "0").join("");
-    return this.binaryToHex(binaryHash);
-  }
-  /**
-   * 将二进制字符串转换为十六进制
-   * @param binary - 二进制字符串
-   * @returns 十六进制字符串
-   * @private
-   */
-  static binaryToHex(binary) {
-    const hex = [];
-    for (let i = 0; i < binary.length; i += 4) {
-      const chunk = binary.slice(i, i + 4);
-      hex.push(parseInt(chunk, 2).toString(16));
+    const promise = operation().finally(() => {
+      this.locks.delete(fullPath);
+    });
+    this.locks.set(fullPath, promise);
+    return promise;
+  }
+  /**
+   * 保存文件，自动选择 S3 或本地存储。
+   * @param fileName - 文件名，将用作 S3 中的 Key 或本地文件名。
+   * @param data - 要写入的 Buffer 数据。
+   * @returns 返回保存时使用的文件名/标识符。
+   */
+  async saveFile(fileName, data) {
+    if (this.s3Client) {
+      const command = new import_client_s3.PutObjectCommand({
+        Bucket: this.s3Bucket,
+        Key: fileName,
+        Body: data,
+        ACL: "public-read"
+        // 默认将文件权限设置为公开可读，方便通过 URL 访问。
+      });
+      await this.s3Client.send(command);
+      return fileName;
+    } else {
+      await this.ensureDirectory();
+      const filePath = this.getFullPath(fileName);
+      await this.withLock(fileName, () => fs.writeFile(filePath, data));
+      return fileName;
     }
-    return hex.join("");
   }
   /**
-   * 将十六进制字符串转换为二进制
-   * @param hex - 十六进制字符串
-   * @returns 二进制字符串
-   * @private
+   * 读取文件，自动从 S3 或本地存储读取。
+   * @param fileName - 要读取的文件名/标识符。
+   * @returns 文件的 Buffer 数据。
    */
-  static hexToBinary(hex) {
-    let binary = "";
-    for (const char of hex) {
-      const bin = parseInt(char, 16).toString(2).padStart(4, "0");
-      binary += bin;
+  async readFile(fileName) {
+    if (this.s3Client) {
+      const command = new import_client_s3.GetObjectCommand({
+        Bucket: this.s3Bucket,
+        Key: fileName
+      });
+      const response = await this.s3Client.send(command);
+      const byteArray = await response.Body.transformToByteArray();
+      return Buffer.from(byteArray);
+    } else {
+      const filePath = this.getFullPath(fileName);
+      return this.withLock(fileName, () => fs.readFile(filePath));
     }
-    return binary;
   }
   /**
-   * 计算图像的DCT(离散余弦变换)
-   * @param data - 图像数据
-   * @param size - 图像尺寸
-   * @returns DCT变换后的矩阵
-   * @private
+   * 删除文件，自动从 S3 或本地删除。
+   * @param fileIdentifier - 要删除的文件名/标识符。
    */
-  static computeDCT(data, size) {
-    const matrix = Array(size).fill(0).map(() => Array(size).fill(0));
-    const output = Array(size).fill(0).map(() => Array(size).fill(0));
-    for (let i = 0; i < size; i++) {
-      for (let j = 0; j < size; j++) {
-        matrix[i][j] = data[i * size + j];
-      }
-    }
-    for (let u = 0; u < size; u++) {
-      for (let v = 0; v < size; v++) {
-        let sum = 0;
-        for (let x = 0; x < size; x++) {
-          for (let y = 0; y < size; y++) {
-            const cx = Math.cos((2 * x + 1) * u * Math.PI / (2 * size));
-            const cy = Math.cos((2 * y + 1) * v * Math.PI / (2 * size));
-            sum += matrix[x][y] * cx * cy;
+  async deleteFile(fileIdentifier) {
+    if (this.s3Client) {
+      const command = new import_client_s3.DeleteObjectCommand({
+        Bucket: this.s3Bucket,
+        Key: fileIdentifier
+      });
+      await this.s3Client.send(command).catch((err) => {
+        this.logger.warn(`删除文件 ${fileIdentifier} 失败:`, err);
+      });
+    } else {
+      const filePath = this.getFullPath(fileIdentifier);
+      await this.withLock(fileIdentifier, async () => {
+        try {
+          await fs.unlink(filePath);
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            this.logger.warn(`删除文件 ${filePath} 失败:`, error);
           }
         }
-        output[u][v] = sum * this.getDCTCoefficient(u, size) * this.getDCTCoefficient(v, size);
-      }
+      });
     }
-    return output;
   }
+};
+
+// src/ProfileManager.ts
+var ProfileManager = class {
   /**
-   * 获取DCT系数
-   * @param index - 索引值
-   * @param size - 矩阵大小
-   * @returns DCT系数
-   * @private
+   * 创建一个 ProfileManager 实例。
+   * @param ctx - Koishi 上下文，用于初始化数据库模型。
    */
-  static getDCTCoefficient(index, size) {
-    return index === 0 ? Math.sqrt(1 / size) : Math.sqrt(2 / size);
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.ctx.model.extend("cave_user", {
+      userId: "string",
+      // 用户 ID
+      nickname: "string"
+      // 用户自定义昵称
+    }, {
+      primary: "userId"
+      // 使用 userId 作为主键，确保每个用户只有一条昵称记录。
+    });
   }
-  /**
-   * 计算数组的中位数
-   * @param arr - 输入数组
-   * @returns 中位数
-   * @private
-   */
-  static calculateMedian(arr) {
-    const sorted = [...arr].sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+  static {
+    __name(this, "ProfileManager");
   }
   /**
-   * 从DCT矩阵中提取特征值
-   * @param matrix - DCT矩阵
-   * @param size - 矩阵大小
-   * @returns 特征值数组
-   * @private
+   * 注册与用户昵称相关的 `.profile` 子命令。
+   * @param cave - 主 `cave` 命令的实例，用于挂载子命令。
    */
-  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]);
+  registerCommands(cave) {
+    cave.subcommand(".profile [nickname:text]", "设置显示昵称").usage("设置你在回声洞中显示的昵称。不提供昵称则清除记录。").action(async ({ session }, nickname) => {
+      const trimmedNickname = nickname?.trim();
+      if (!trimmedNickname) {
+        await this.clearNickname(session.userId);
+        return "昵称已清除";
       }
-    }
-    return features;
+      await this.setNickname(session.userId, trimmedNickname);
+      return `昵称已更新为：${trimmedNickname}`;
+    });
   }
   /**
-   * 计算两个哈希值之间的汉明距离
-   * @param hash1 - 第一个哈希值
-   * @param hash2 - 第二个哈希值
-   * @returns 汉明距离
-   * @throws 当两个哈希值长度不等时抛出错误
+   * 设置或更新指定用户的昵称。
+   * @param userId - 目标用户的 ID。
+   * @param nickname - 要设置的新昵称。
    */
-  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;
+  async setNickname(userId, nickname) {
+    await this.ctx.database.upsert("cave_user", [{
+      userId,
+      nickname
+    }]);
   }
   /**
-   * 计算两个图片哈希值的相似度
-   * @param hash1 - 第一个哈希值
-   * @param hash2 - 第二个哈希值
-   * @returns 返回0-1之间的相似度值，1表示完全相同，0表示完全不同
+   * 获取指定用户的昵称。
+   * @param userId - 目标用户的 ID。
+   * @returns 返回用户的昵称字符串。如果用户未设置昵称，则返回 null。
    */
-  static calculateSimilarity(hash1, hash2) {
-    const distance = this.calculateDistance(hash1, hash2);
-    return (64 - distance) / 64;
+  async getNickname(userId) {
+    const profiles = await this.ctx.database.get("cave_user", { userId });
+    return profiles[0]?.nickname || null;
   }
   /**
-   * 计算文本的哈希值
-   * @param text - 输入文本
-   * @returns 文本的哈希值(36进制字符串)
+   * 清除指定用户的昵称设置。
+   * @param userId - 目标用户的 ID。
    */
-  static calculateTextHash(text) {
-    const normalizedText = text.toLowerCase().trim().replace(/\s+/g, " ");
-    let hash = 0;
-    for (let i = 0; i < normalizedText.length; i++) {
-      const char = normalizedText.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return hash.toString(36);
+  async clearNickname(userId) {
+    await this.ctx.database.remove("cave_user", { userId });
   }
 };
 
-// src/utils/HashManager.ts
-var import_util = require("util");
-var logger3 = new import_koishi3.Logger("HashManager");
-var readFileAsync = (0, import_util.promisify)(fs3.readFile);
-var HashManager = class _HashManager {
-  /**
-   * 初始化HashManager实例
-   * @param caveDir 回声洞数据目录路径
-   */
-  constructor(caveDir) {
-    this.caveDir = caveDir;
-  }
-  static {
-    __name(this, "HashManager");
-  }
-  static HASH_FILE = "hash.json";
-  static CAVE_FILE = "cave.json";
-  static BATCH_SIZE = 50;
-  imageHashes = /* @__PURE__ */ new Map();
-  textHashes = /* @__PURE__ */ new Map();
-  initialized = false;
-  get filePath() {
-    return path3.join(this.caveDir, _HashManager.HASH_FILE);
-  }
-  get resourceDir() {
-    return path3.join(this.caveDir, "resources");
-  }
-  get caveFilePath() {
-    return path3.join(this.caveDir, _HashManager.CAVE_FILE);
+// src/Utils.ts
+var import_koishi = require("koishi");
+var path2 = __toESM(require("path"));
+var mimeTypeMap = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".mp4": "video/mp4",
+  ".mp3": "audio/mpeg",
+  ".webp": "image/webp"
+};
+function storedFormatToHElements(elements) {
+  return elements.map((el) => {
+    switch (el.type) {
+      case "text":
+        return import_koishi.h.text(el.content);
+      case "img":
+        return (0, import_koishi.h)("image", { src: el.file });
+      case "video":
+      case "audio":
+      case "file":
+        return (0, import_koishi.h)(el.type, { src: el.file });
+      default:
+        return null;
+    }
+  }).filter(Boolean);
+}
+__name(storedFormatToHElements, "storedFormatToHElements");
+async function mediaElementToBase64(element, fileManager, logger2) {
+  const fileName = element.attrs.src;
+  try {
+    const data = await fileManager.readFile(fileName);
+    const ext = path2.extname(fileName).toLowerCase();
+    const mimeType = mimeTypeMap[ext] || "application/octet-stream";
+    return (0, import_koishi.h)(element.type, { ...element.attrs, src: `data:${mimeType};base64,${data.toString("base64")}` });
+  } catch (error) {
+    logger2.warn(`转换本地文件 ${fileName} 为 Base64 失败:`, error);
+    return (0, import_koishi.h)("p", {}, `[${element.type}]`);
   }
-  /**
-   * 初始化哈希存储
-   * 读取现有哈希数据或重新构建哈希值
-   * @throws 初始化失败时抛出错误
-   */
-  async initialize() {
-    if (this.initialized) return;
-    try {
-      const hashData = await FileHandler.readJsonData(this.filePath).then((data) => data[0]).catch(() => null);
-      if (!hashData?.imageHashes || !hashData?.textHashes || Object.keys(hashData.imageHashes).length === 0) {
-        this.imageHashes.clear();
-        this.textHashes.clear();
-        await this.buildInitialHashes();
-      } else {
-        this.imageHashes = new Map(
-          Object.entries(hashData.imageHashes).map(([k, v]) => [Number(k), v])
-        );
-        this.textHashes = new Map(
-          Object.entries(hashData.textHashes).map(([k, v]) => [Number(k), v])
-        );
-        await this.updateMissingHashes();
-      }
-      const totalCaves = (/* @__PURE__ */ new Set([...this.imageHashes.keys(), ...this.textHashes.keys()])).size;
-      this.initialized = true;
-      logger3.success(`Cave Hash Manager initialized with ${totalCaves} hashes`);
-    } catch (error) {
-      logger3.error(`Initialization failed: ${error.message}`);
-      this.initialized = false;
-      throw error;
+}
+__name(mediaElementToBase64, "mediaElementToBase64");
+async function buildCaveMessage(cave, config, fileManager, logger2) {
+  const caveHElements = storedFormatToHElements(cave.elements);
+  const processedElements = await Promise.all(caveHElements.map((element) => {
+    const isMedia = ["image", "video", "audio", "file"].includes(element.type);
+    const fileName = element.attrs.src;
+    if (!isMedia || !fileName) {
+      return Promise.resolve(element);
+    }
+    if (config.enableS3 && config.publicUrl) {
+      const fullUrl = config.publicUrl.endsWith("/") ? `${config.publicUrl}${fileName}` : `${config.publicUrl}/${fileName}`;
+      return Promise.resolve((0, import_koishi.h)(element.type, { ...element.attrs, src: fullUrl }));
+    }
+    return mediaElementToBase64(element, fileManager, logger2);
+  }));
+  return [
+    (0, import_koishi.h)("p", {}, `回声洞 ——（${cave.id}）`),
+    ...processedElements,
+    (0, import_koishi.h)("p", {}, `—— ${cave.userName}`)
+  ];
+}
+__name(buildCaveMessage, "buildCaveMessage");
+async function cleanupPendingDeletions(ctx, fileManager, logger2) {
+  try {
+    const cavesToDelete = await ctx.database.get("cave", { status: "delete" });
+    if (cavesToDelete.length === 0) return;
+    for (const cave of cavesToDelete) {
+      const deletePromises = cave.elements.filter((el) => el.file).map((el) => fileManager.deleteFile(el.file));
+      await Promise.all(deletePromises);
+      await ctx.database.remove("cave", { id: cave.id });
     }
+  } catch (error) {
+    logger2.error("清理回声洞时发生错误:", error);
   }
-  /**
-   * 获取当前哈希存储状态
-   * @returns 包含最后更新时间和所有条目的状态对象
-   */
-  async getStatus() {
-    if (!this.initialized) await this.initialize();
-    return {
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      entries: Array.from(this.imageHashes.entries()).map(([caveId, imgHashes]) => ({
-        caveId,
-        imageHashes: imgHashes,
-        textHashes: this.textHashes.get(caveId) || []
-      }))
-    };
+}
+__name(cleanupPendingDeletions, "cleanupPendingDeletions");
+function getScopeQuery(session, config) {
+  const baseQuery = { status: "active" };
+  if (config.perChannel && session.channelId) {
+    return { ...baseQuery, channelId: session.channelId };
   }
-  /**
-   * 更新指定回声洞的图片哈希值
-   * @param caveId 回声洞ID
-   * @param content 图片buffer数组
-   */
-  async updateCaveContent(caveId, content) {
-    if (!this.initialized) await this.initialize();
-    try {
-      if (content.images?.length) {
-        const imageHashes = await Promise.all(
-          content.images.map((buffer) => ContentHasher.calculateHash(buffer))
-        );
-        this.imageHashes.set(caveId, imageHashes);
-      }
-      if (content.texts?.length) {
-        const textHashes = content.texts.map((text) => ContentHasher.calculateTextHash(text));
-        this.textHashes.set(caveId, textHashes);
-      }
-      if (!content.images && !content.texts) {
-        this.imageHashes.delete(caveId);
-        this.textHashes.delete(caveId);
-      }
-      await this.saveContentHashes();
-    } catch (error) {
-      logger3.error(`Failed to update content hashes (cave ${caveId}): ${error.message}`);
-    }
+  return baseQuery;
+}
+__name(getScopeQuery, "getScopeQuery");
+async function getNextCaveId(ctx, query = {}) {
+  const allCaves = await ctx.database.get("cave", query, { fields: ["id"] });
+  const existingIds = new Set(allCaves.map((c) => c.id));
+  let newId = 1;
+  while (existingIds.has(newId)) {
+    newId++;
+  }
+  return newId;
+}
+__name(getNextCaveId, "getNextCaveId");
+async function downloadMedia(ctx, fileManager, url, originalName, type, caveId, index, channelId, userId) {
+  const defaultExtMap = { "img": ".jpg", "image": ".jpg", "video": ".mp4", "audio": ".mp3", "file": ".dat" };
+  const ext = originalName ? path2.extname(originalName) : "";
+  const finalExt = ext || defaultExtMap[type] || ".dat";
+  const fileName = `${caveId}_${index}_${channelId}_${userId}${finalExt}`;
+  const response = await ctx.http.get(url, { responseType: "arraybuffer", timeout: 3e4 });
+  return fileManager.saveFile(fileName, Buffer.from(response));
+}
+__name(downloadMedia, "downloadMedia");
+function checkCooldown(session, config, lastUsed) {
+  if (config.cooldown <= 0 || !session.channelId || config.adminUsers.includes(session.userId)) {
+    return null;
+  }
+  const now = Date.now();
+  const lastTime = lastUsed.get(session.channelId) || 0;
+  if (now - lastTime < config.cooldown * 1e3) {
+    const waitTime = Math.ceil((config.cooldown * 1e3 - (now - lastTime)) / 1e3);
+    return `指令冷却中，请在 ${waitTime} 秒后重试`;
+  }
+  return null;
+}
+__name(checkCooldown, "checkCooldown");
+function updateCooldownTimestamp(session, config, lastUsed) {
+  if (config.cooldown > 0 && session.channelId) {
+    lastUsed.set(session.channelId, Date.now());
   }
+}
+__name(updateCooldownTimestamp, "updateCooldownTimestamp");
+
+// src/DataManager.ts
+var DataManager = class {
   /**
-   * 更新所有回声洞的哈希值
-   * @param isInitialBuild 是否为初始构建
+   * 创建一个 DataManager 实例。
+   * @param ctx - Koishi 上下文，用于数据库操作。
+   * @param config - 插件配置。
+   * @param fileManager - 文件管理器实例，用于读写导入/导出文件。
+   * @param logger - 日志记录器实例。
    */
-  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.imageHashes.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 ContentHasher.calculateHash(imgBuffer);
-            })
-          );
-          const validHashes = hashes.filter((hash) => hash !== null);
-          if (validHashes.length > 0) {
-            this.imageHashes.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.saveContentHashes();
-      logger3.success(`Update completed. Processed ${processedCount}/${totalImages} images`);
-    } catch (error) {
-      logger3.error(`Full update failed: ${error.message}`);
-      throw error;
-    }
+  constructor(ctx, config, fileManager, logger2) {
+    this.ctx = ctx;
+    this.config = config;
+    this.fileManager = fileManager;
+    this.logger = logger2;
+  }
+  static {
+    __name(this, "DataManager");
   }
   /**
-   * 查找重复的图片
-   * @param content 待查找的图片buffer数组
-   * @param thresholds 相似度阈值
-   * @returns 匹配结果数组，包含索引、回声洞ID和相似度
+   * 注册与数据导入导出相关的 `.export` 和 `.import` 子命令。
+   * @param cave - 主 `cave` 命令的实例，用于挂载子命令。
    */
-  async findDuplicates(content, thresholds) {
-    if (!this.initialized) await this.initialize();
-    const results = [];
-    if (content.images?.length) {
-      const imageResults = await this.findImageDuplicates(content.images, thresholds.image);
-      results.push(...imageResults.map(
-        (result) => result ? { ...result, type: "image" } : null
-      ));
-    }
-    if (content.texts?.length) {
-      const textResults = await this.findTextDuplicates(content.texts, thresholds.text);
-      results.push(...textResults.map(
-        (result) => result ? { ...result, type: "text" } : null
-      ));
-    }
-    return results;
-  }
-  async findTextDuplicates(texts, threshold) {
-    const inputHashes = texts.map((text) => ContentHasher.calculateTextHash(text));
-    const existingHashes = Array.from(this.textHashes.entries());
-    return inputHashes.map((hash, index) => {
-      let maxSimilarity = 0;
-      let matchedCaveId = null;
-      for (const [caveId, hashes] of existingHashes) {
-        for (const existingHash of hashes) {
-          const similarity = this.calculateTextSimilarity(hash, existingHash);
-          if (similarity >= threshold && similarity > maxSimilarity) {
-            maxSimilarity = similarity;
-            matchedCaveId = caveId;
-            if (similarity === 1) break;
-          }
-        }
-        if (maxSimilarity === 1) break;
+  registerCommands(cave) {
+    cave.subcommand(".export", "导出回声洞数据").usage("将所有回声洞数据导出到 cave_export.json。").action(async ({ session }) => {
+      if (!this.config.adminUsers.includes(session.userId)) return "抱歉，你没有权限导出数据";
+      try {
+        await session.send("正在导出数据，请稍候...");
+        const resultMessage = await this.exportData();
+        return resultMessage;
+      } catch (error) {
+        this.logger.error("导出数据时发生错误:", error);
+        return `导出失败: ${error.message}`;
       }
-      return matchedCaveId ? {
-        index,
-        caveId: matchedCaveId,
-        similarity: maxSimilarity
-      } : null;
     });
-  }
-  calculateTextSimilarity(hash1, hash2) {
-    if (hash1 === hash2) return 1;
-    const length = Math.max(hash1.length, hash2.length);
-    let matches = 0;
-    for (let i = 0; i < length; i++) {
-      if (hash1[i] === hash2[i]) matches++;
-    }
-    return matches / length;
-  }
-  async findImageDuplicates(images, threshold) {
-    if (!this.initialized) await this.initialize();
-    const inputHashes = await Promise.all(
-      images.map((buffer) => ContentHasher.calculateHash(buffer))
-    );
-    const existingHashes = Array.from(this.imageHashes.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 = ContentHasher.calculateSimilarity(hash, existingHash);
-              if (similarity >= threshold && similarity > maxSimilarity) {
-                maxSimilarity = similarity;
-                matchedCaveId = caveId;
-                if (Math.abs(similarity - 1) < Number.EPSILON) break;
-              }
-            }
-            if (Math.abs(maxSimilarity - 1) < Number.EPSILON) break;
-          }
-          return matchedCaveId ? {
-            index,
-            caveId: matchedCaveId,
-            similarity: maxSimilarity
-          } : null;
-        } catch (error) {
-          logger3.warn(`处理图片 ${index} 失败: ${error.message}`);
-          return null;
-        }
-      })
-    );
-  }
-  /**
-   * 加载回声洞数据
-   * @returns 回声洞数据数组
-   * @private
-   */
-  async loadCaveData() {
-    const data = await FileHandler.readJsonData(this.caveFilePath);
-    return Array.isArray(data) ? data.flat() : [];
-  }
-  /**
-   * 保存哈希数据到文件
-   * @private
-   */
-  async saveContentHashes() {
-    const data = {
-      imageHashes: Object.fromEntries(this.imageHashes),
-      textHashes: Object.fromEntries(this.textHashes),
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await FileHandler.writeJsonData(this.filePath, [data]);
-  }
-  /**
-   * 构建初始哈希数据
-   * @private
-   */
-  async buildInitialHashes() {
-    const caveData = await this.loadCaveData();
-    let processedCount = 0;
-    const totalCaves = caveData.length;
-    logger3.info(`Building hash data for ${totalCaves} caves...`);
-    for (const cave of caveData) {
+    cave.subcommand(".import", "导入回声洞数据").usage("从 cave_import.json 中导入回声洞数据。").action(async ({ session }) => {
+      if (!this.config.adminUsers.includes(session.userId)) return "抱歉，你没有权限导入数据";
       try {
-        const imgElements = cave.elements?.filter((el) => el.type === "img" && el.file) || [];
-        if (imgElements.length > 0) {
-          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);
-              return await ContentHasher.calculateHash(imgBuffer);
-            })
-          );
-          const validHashes = hashes.filter((hash) => hash !== null);
-          if (validHashes.length > 0) {
-            this.imageHashes.set(cave.cave_id, validHashes);
-          }
-        }
-        const textElements = cave.elements?.filter((el) => el.type === "text" && el.content) || [];
-        if (textElements.length > 0) {
-          const textHashes = textElements.map((el) => ContentHasher.calculateTextHash(el.content));
-          this.textHashes.set(cave.cave_id, textHashes);
-        }
-        processedCount++;
-        if (processedCount % 100 === 0) {
-          logger3.info(`Progress: ${processedCount}/${totalCaves} caves`);
-        }
+        await session.send("正在导入数据，请稍候...");
+        const resultMessage = await this.importData();
+        return resultMessage;
       } catch (error) {
-        logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
+        this.logger.error("导入数据时发生错误:", error);
+        return `导入失败: ${error.message}`;
       }
-    }
-    await this.saveContentHashes();
-    logger3.success(`Build completed. Processed ${processedCount}/${totalCaves} caves`);
+    });
   }
   /**
-   * 更新缺失的哈希值
-   * @private
+   * 导出所有状态为 'active' 的回声洞数据。
+   * 数据将被序列化为 JSON 并保存到 `cave_export.json` 文件中。
+   * @returns 一个描述导出结果的字符串消息。
    */
-  async updateMissingHashes() {
-    const caveData = await this.loadCaveData();
-    let updatedCount = 0;
-    for (const cave of caveData) {
-      if (this.imageHashes.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 ContentHasher.calculateHash(imgBuffer);
-          })
-        );
-        const validHashes = hashes.filter((hash) => hash !== null);
-        if (validHashes.length > 0) {
-          this.imageHashes.set(cave.cave_id, validHashes);
-          updatedCount++;
-        }
-      } catch (error) {
-        logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
-      }
-    }
+  async exportData() {
+    const fileName = "cave_export.json";
+    const cavesToExport = await this.ctx.database.get("cave", { status: "active" });
+    const portableCaves = cavesToExport.map(({ id, ...rest }) => rest);
+    const data = JSON.stringify(portableCaves, null, 2);
+    await this.fileManager.saveFile(fileName, Buffer.from(data));
+    return `成功导出 ${portableCaves.length} 条数据`;
   }
   /**
-   * 批量处理数组项
-   * @param items 待处理项数组
-   * @param processor 处理函数
-   * @param batchSize 批处理大小
-   * @private
+   * 从 `cave_import.json` 文件导入回声洞数据。
+   * @returns 一个描述导入结果的字符串消息。
    */
-  async processBatch(items, processor, batchSize = _HashManager.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}`);
-          }
-        })
-      );
+  async importData() {
+    const fileName = "cave_import.json";
+    let importedCaves;
+    try {
+      const fileContent = await this.fileManager.readFile(fileName);
+      importedCaves = JSON.parse(fileContent.toString("utf-8"));
+      if (!Array.isArray(importedCaves)) {
+        throw new Error("导入文件格式无效");
+      }
+    } catch (error) {
+      this.logger.error(`读取导入文件失败:`, error);
+      return `读取导入文件失败: ${error.message || "未知错误"}`;
+    }
+    let successCount = 0;
+    for (const cave of importedCaves) {
+      const newId = await getNextCaveId(this.ctx, {});
+      const newCave = {
+        ...cave,
+        id: newId,
+        channelId: cave.channelId || null,
+        // 确保 channelId 存在，若无则为 null。
+        status: "active"
+        // 导入的数据直接设为 active 状态。
+      };
+      await this.ctx.database.create("cave", newCave);
+      successCount++;
     }
+    return `成功导入 ${successCount} 条回声洞数据`;
   }
 };
 
-// src/utils/AuditHandler.ts
-var import_koishi4 = require("koishi");
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
-var AuditManager = class {
+// src/ReviewManager.ts
+var import_koishi2 = require("koishi");
+var ReviewManager = class {
   /**
-   * 创建审核管理器实例
-   * @param ctx - Koishi 上下文
-   * @param config - 配置对象
-   * @param idManager - ID 管理器实例
+   * 创建一个 ReviewManager 实例。
+   * @param ctx - Koishi 上下文。
+   * @param config - 插件配置。
+   * @param fileManager - 文件管理器实例。
+   * @param logger - 日志记录器实例。
    */
-  constructor(ctx, config, idManager) {
+  constructor(ctx, config, fileManager, logger2) {
     this.ctx = ctx;
     this.config = config;
-    this.idManager = idManager;
+    this.fileManager = fileManager;
+    this.logger = logger2;
   }
   static {
-    __name(this, "AuditManager");
-  }
-  logger = new import_koishi4.Logger("AuditManager");
-  /**
-   * 处理审核操作
-   * @param pendingData - 待审核的洞数据数组
-   * @param isApprove - 是否通过审核
-   * @param caveFilePath - 洞数据文件路径
-   * @param resourceDir - 资源目录路径
-   * @param pendingFilePath - 待审核数据文件路径
-   * @param session - 会话对象
-   * @param targetId - 目标洞ID（可选）
-   * @returns 处理结果消息
-   */
-  async processAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, targetId) {
-    if (pendingData.length === 0) {
-      return this.sendMessage(session, "commands.cave.audit.noPending", [], true);
-    }
-    if (typeof targetId === "number") {
-      return await this.handleSingleAudit(
-        pendingData,
-        isApprove,
-        caveFilePath,
-        resourceDir,
-        pendingFilePath,
-        targetId,
-        session
-      );
-    }
-    return await this.handleBatchAudit(
-      pendingData,
-      isApprove,
-      caveFilePath,
-      resourceDir,
-      pendingFilePath,
-      session
-    );
-  }
-  /**
-   * 处理单条审核
-   * @param pendingData - 待审核的洞数据数组
-   * @param isApprove - 是否通过审核
-   * @param caveFilePath - 洞数据文件路径
-   * @param resourceDir - 资源目录路径
-   * @param pendingFilePath - 待审核数据文件路径
-   * @param targetId - 目标洞ID
-   * @param session - 会话对象
-   * @returns 处理结果消息
-   * @private
-   */
-  async handleSingleAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, targetId, session) {
-    const targetCave = pendingData.find((item) => item.cave_id === targetId);
-    if (!targetCave) {
-      return this.sendMessage(session, "commands.cave.audit.pendingNotFound", [], true);
-    }
-    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: this.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 this.idManager.addStat(targetCave.contributor_number, targetId);
-    } else {
-      await FileHandler.writeJsonData(pendingFilePath, newPendingData);
-      await this.idManager.markDeleted(targetId);
-      await this.deleteMediaFiles(targetCave, resourceDir);
-    }
-    const remainingCount = newPendingData.length;
-    if (remainingCount > 0) {
-      const remainingIds = newPendingData.map((c) => c.cave_id).join(", ");
-      const action = isApprove ? "auditPassed" : "auditRejected";
-      return this.sendMessage(session, "commands.cave.audit.pendingResult", [
-        session.text(`commands.cave.audit.${action}`),
-        remainingCount,
-        remainingIds
-      ], false);
-    }
-    return this.sendMessage(
-      session,
-      isApprove ? "commands.cave.audit.auditPassed" : "commands.cave.audit.auditRejected",
-      [],
-      false
-    );
+    __name(this, "ReviewManager");
   }
   /**
-   * 处理批量审核
-   * @param pendingData - 待审核的洞数据数组
-   * @param isApprove - 是否通过审核
-   * @param caveFilePath - 洞数据文件路径
-   * @param resourceDir - 资源目录路径
-   * @param pendingFilePath - 待审核数据文件路径
-   * @param session - 会话对象
-   * @returns 处理结果消息
-   * @private
+   * 注册与审核相关的 `.review` 子命令。
+   * @param cave - 主 `cave` 命令的实例，用于挂载子命令。
    */
-  async handleBatchAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session) {
-    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: this.cleanElementsForSave(cave.elements, false)
-              });
-              processedCount++;
-              await this.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 this.idManager.markDeleted(cave.cave_id);
-        await this.deleteMediaFiles(cave, resourceDir);
-        processedCount++;
+  registerCommands(cave) {
+    cave.subcommand(".review [id:posint] [action:string]", "审核回声洞").usage("查看或审核回声洞，使用 <Y/N> 进行审核。").action(async ({ session }, id, action) => {
+      if (!this.config.adminUsers.includes(session.userId)) {
+        return "抱歉，你没有权限执行审核";
       }
-      await FileHandler.writeJsonData(pendingFilePath, []);
-    }
-    return this.sendMessage(session, "commands.cave.audit.batchAuditResult", [
-      isApprove ? "通过" : "拒绝",
-      processedCount,
-      pendingData.length
-    ], false);
-  }
-  /**
-   * 发送审核消息给管理员
-   * @param cave - 待审核的洞数据
-   * @param content - 消息内容
-   * @param session - 会话对象
-   */
-  async sendAuditMessage(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 this.config.manager) {
-      const bot = this.ctx.bots[0];
-      if (bot) {
-        try {
-          await bot.sendPrivateMessage(managerId, auditMessage);
-        } catch (error) {
-          this.logger.error(session.text("commands.cave.audit.sendFailed", [managerId]));
+      if (!id) {
+        const pendingCaves = await this.ctx.database.get("cave", { status: "pending" });
+        if (pendingCaves.length === 0) {
+          return "当前没有需要审核的回声洞";
         }
+        const pendingIds = pendingCaves.map((c) => c.id).join(", ");
+        return `当前共有 ${pendingCaves.length} 条待审核回声洞，序号为：
+${pendingIds}`;
+      }
+      const [targetCave] = await this.ctx.database.get("cave", { id });
+      if (!targetCave) {
+        return `回声洞（${id}）不存在`;
+      }
+      if (targetCave.status !== "pending") {
+        return `回声洞（${id}）无需审核`;
+      }
+      if (id && !action) {
+        return this.buildReviewMessage(targetCave);
+      }
+      const normalizedAction = action.toLowerCase();
+      let reviewAction;
+      if (["y", "yes", "ok", "pass", "approve"].includes(normalizedAction)) {
+        reviewAction = "approve";
+      } else if (["n", "no", "deny", "reject"].includes(normalizedAction)) {
+        reviewAction = "reject";
+      } else {
+        return `无效操作: "${action}"
+请使用 "Y" (通过) 或 "N" (拒绝)`;
       }
-    }
-  }
-  /**
-   * 删除媒体文件
-   * @param cave - 洞数据
-   * @param resourceDir - 资源目录路径
-   * @private
-   */
-  async deleteMediaFiles(cave, resourceDir) {
-    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);
-          }
-        }
-      }
-    }
-  }
-  /**
-   * 清理元素数据用于保存
-   * @param elements - 元素数组
-   * @param keepIndex - 是否保留索引
-   * @returns 清理后的元素数组
-   * @private
-   */
-  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 this.processReview(reviewAction, id, session.username);
     });
-    return keepIndex ? cleanedElements.sort((a, b) => (a.index || 0) - (b.index || 0)) : cleanedElements;
   }
   /**
-   * 发送消息
-   * @param session - 会话对象
-   * @param key - 消息key
-   * @param params - 消息参数
-   * @param isTemp - 是否为临时消息
-   * @param timeout - 临时消息超时时间
-   * @returns 空字符串
-   * @private
+   * 将一条新的回声洞提交给所有管理员进行审核。
+   * @param cave - 新创建的、状态为 'pending' 的回声洞对象。
    */
-  async 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) {
-            this.logger.debug(`Failed to delete temporary message: ${error.message}`);
-          }
-        }, timeout);
-      }
-    } catch (error) {
-      this.logger.error(`Failed to send message: ${error.message}`);
-    }
-    return "";
-  }
-};
-
-// src/utils/MediaHandler.ts
-var import_koishi5 = require("koishi");
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
-var logger4 = new import_koishi5.Logger("MediaHandle");
-async function buildMessage(cave, resourceDir, session) {
-  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 = path5.join(resourceDir, videoElement.file);
-    const base64Data = await processMediaFile(filePath, "video");
-    if (base64Data && session) {
-      await session.send((0, import_koishi5.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") {
-      lines.push(element.content);
-    } else if (element.type === "img" && element.file) {
-      const filePath = path5.join(resourceDir, element.file);
-      const base64Data = await processMediaFile(filePath, "image");
-      if (base64Data) {
-        lines.push((0, import_koishi5.h)("image", { src: base64Data }));
-      }
-    }
-  }
-  lines.push(session.text("commands.cave.message.contributorSuffix", [cave.contributor_name]));
-  return lines.join("\n");
-}
-__name(buildMessage, "buildMessage");
-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) {
-          logger4.debug(`Failed to delete temporary message: ${error.message}`);
-        }
-      }, timeout);
-    }
-  } catch (error) {
-    logger4.error(`Failed to send message: ${error.message}`);
-  }
-  return "";
-}
-__name(sendMessage, "sendMessage");
-async function processMediaFile(filePath, type) {
-  const data = await fs5.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 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++;
+  async sendForReview(cave) {
+    if (!this.config.adminUsers?.length) {
+      this.logger.warn(`未配置管理员，回声洞（${cave.id}）已自动通过审核`);
+      await this.ctx.database.upsert("cave", [{ id: cave.id, status: "active" }]);
+      return;
     }
-    return { urls, elements };
-  }, "getMediaElements");
-  const { urls: imageUrls, elements: imageElementsRaw } = getMediaElements("img", config.imageMaxSize);
-  const imageElements = imageElementsRaw;
-  const { urls: videoUrls, elements: videoElementsRaw } = getMediaElements("video", config.videoMaxSize);
-  const videoElements = videoElementsRaw;
-  return { imageUrls, imageElements, videoUrls, videoElements, textParts };
-}
-__name(extractMediaContent, "extractMediaContent");
-async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config, ctx, session, buffers) {
-  const accept = mediaType === "img" ? "image/*" : "video/*";
-  const hashStorage = new HashManager(path5.join(ctx.baseDir, "data", "cave"));
-  await hashStorage.initialize();
-  const downloadTasks = urls.map(async (url, i) => {
-    const fileName = fileNames[i];
-    const ext = path5.extname(fileName || url) || (mediaType === "img" ? ".png" : ".mp4");
+    const reviewMessage = await this.buildReviewMessage(cave);
     try {
-      const response = await ctx.http(decodeURIComponent(url).replace(/&amp;/g, "&"), {
-        method: "GET",
-        responseType: "arraybuffer",
-        timeout: 3e4,
-        headers: {
-          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
-          "Accept": accept,
-          "Referer": "https://qq.com"
-        }
-      });
-      if (!response.data) throw new Error("empty_response");
-      const buffer = Buffer.from(response.data);
-      if (buffers && mediaType === "img") {
-        buffers.push(buffer);
-      }
-      const md5 = path5.basename(fileName || `${mediaType}`, ext).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
-      const files = await fs5.promises.readdir(resourceDir);
-      const duplicateFile = files.find((file) => {
-        const match = file.match(/^\d+_([^.]+)/);
-        return match && match[1] === md5;
-      });
-      if (duplicateFile) {
-        const duplicateCaveId = parseInt(duplicateFile.split("_")[0]);
-        if (!isNaN(duplicateCaveId)) {
-          const caveFilePath = path5.join(ctx.baseDir, "data", "cave", "cave.json");
-          const data = await FileHandler.readJsonData(caveFilePath);
-          const originalCave = data.find((item) => item.cave_id === duplicateCaveId);
-          if (originalCave) {
-            const message = session.text("commands.cave.error.exactDuplicateFound");
-            await session.send(message + await buildMessage(originalCave, resourceDir, session));
-            throw new Error("duplicate_found");
-          }
-        }
-      }
-      if (mediaType === "img" && config.enableImageDuplicate) {
-        const result = await hashStorage.findDuplicates(
-          { images: [buffer] },
-          {
-            image: config.imageDuplicateThreshold,
-            text: config.textDuplicateThreshold
-          }
-        );
-        if (result.length > 0 && result[0] !== null) {
-          const duplicate = result[0];
-          const similarity = duplicate.similarity;
-          if (similarity >= config.imageDuplicateThreshold) {
-            const caveFilePath = path5.join(ctx.baseDir, "data", "cave", "cave.json");
-            const data = await FileHandler.readJsonData(caveFilePath);
-            const originalCave = data.find((item) => item.cave_id === duplicate.caveId);
-            if (originalCave) {
-              const message = session.text(
-                "commands.cave.error.similarDuplicateFound",
-                [(similarity * 100).toFixed(1)]
-              );
-              await session.send(message + await buildMessage(originalCave, resourceDir, session));
-              throw new Error("duplicate_found");
-            }
-          }
-        }
-      }
-      const finalFileName = `${caveId}_${md5}${ext}`;
-      const filePath = path5.join(resourceDir, finalFileName);
-      await FileHandler.saveMediaFile(filePath, buffer);
-      return finalFileName;
+      await this.ctx.broadcast(this.config.adminUsers, reviewMessage);
     } 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`));
+      this.logger.error(`广播回声洞（${cave.id}）审核请求失败:`, error);
     }
-  });
-  return Promise.all(downloadTasks);
-}
-__name(saveMedia, "saveMedia");
-
-// src/utils/ProcessHandle.ts
-var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
-async function processList(session, config, idManager, 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 (config.enablePagination) {
-    const itemsPerPage = config.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 processView(caveFilePath, resourceDir, session, options, content) {
-  const caveId = parseInt(content[0] || (typeof options.g === "string" ? options.g : ""));
-  if (isNaN(caveId)) return sendMessage(session, "commands.cave.error.invalidId", [], true);
-  const data = await FileHandler.readJsonData(caveFilePath);
-  const cave = data.find((item) => item.cave_id === caveId);
-  if (!cave) return sendMessage(session, "commands.cave.error.notFound", [], true);
-  return buildMessage(cave, resourceDir, session);
-}
-__name(processView, "processView");
-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(caveFilePath, resourceDir, pendingFilePath, session, config, options, content, idManager, HashManager2) {
-  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(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 && !config.manager.includes(session.userId)) {
-    return sendMessage(session, "commands.cave.remove.noPermission", [], true);
-  }
-  const caveContent = await buildMessage(targetCave, resourceDir, session);
-  if (targetCave.elements) {
-    await HashManager2.updateCaveContent(caveId, {
-      images: void 0,
-      texts: void 0
-    });
-    for (const element of targetCave.elements) {
-      if ((element.type === "img" || element.type === "video") && element.file) {
-        const fullPath = path6.join(resourceDir, element.file);
-        if (fs6.existsSync(fullPath)) {
-          await fs6.promises.unlink(fullPath);
-        }
-      }
+  /**
+   * 构建一条用于发送给管理员的、包含审核信息的消息。
+   * @param cave - 待审核的回声洞对象。
+   * @returns 一个可直接发送的消息数组。
+   * @private
+   */
+  async buildReviewMessage(cave) {
+    const caveContent = await buildCaveMessage(cave, this.config, this.fileManager, this.logger);
+    return [
+      (0, import_koishi2.h)("p", `以下内容待审核：`),
+      ...caveContent
+    ];
+  }
+  /**
+   * 处理管理员的审核决定（通过或拒绝）。
+   * @param action - 'approve' (通过) 或 'reject' (拒绝)。
+   * @param caveId - 被审核的回声洞 ID。
+   * @param adminUserName - 执行操作的管理员的昵称。
+   * @returns 返回给操作者的确认消息。
+   */
+  async processReview(action, caveId, adminUserName) {
+    const [cave] = await this.ctx.database.get("cave", { id: caveId });
+    if (!cave) return `回声洞（${caveId}）不存在`;
+    if (cave.status !== "pending") return `回声洞（${caveId}）无需审核`;
+    let resultMessage;
+    let broadcastMessage;
+    if (action === "approve") {
+      await this.ctx.database.upsert("cave", [{ id: caveId, status: "active" }]);
+      resultMessage = `回声洞（${caveId}）已通过`;
+      broadcastMessage = `回声洞（${caveId}）已由管理员 "${adminUserName}" 通过`;
+    } else {
+      await this.ctx.database.upsert("cave", [{ id: caveId, status: "delete" }]);
+      resultMessage = `回声洞（${caveId}）已拒绝`;
+      const caveContent = await buildCaveMessage(cave, this.config, this.fileManager, this.logger);
+      broadcastMessage = [
+        (0, import_koishi2.h)("p", `回声洞（${caveId}）已由管理员 "${adminUserName}" 拒绝`),
+        ...caveContent
+      ];
+    }
+    if (broadcastMessage && this.config.adminUsers?.length) {
+      await this.ctx.broadcast(this.config.adminUsers, broadcastMessage).catch((err) => {
+        this.logger.error(`广播回声洞（${cave.id}）审核结果失败:`, err);
+      });
     }
+    return resultMessage;
   }
-  if (isPending) {
-    const newPendingData = pendingData.filter((item) => item.cave_id !== caveId);
-    await FileHandler.writeJsonData(pendingFilePath, newPendingData);
-  } else {
-    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");
+};
 
 // src/index.ts
 var name = "best-cave";
 var inject = ["database"];
-var logger5 = new import_koishi6.Logger("cave");
-var Config = import_koishi6.Schema.object({
-  manager: import_koishi6.Schema.array(import_koishi6.Schema.string()).required(),
-  // 管理员用户ID
-  number: import_koishi6.Schema.number().default(60),
-  // 冷却时间(秒)
-  enableAudit: import_koishi6.Schema.boolean().default(false),
-  // 启用审核
-  enableTextDuplicate: import_koishi6.Schema.boolean().default(true),
-  // 启用文本查重
-  textDuplicateThreshold: import_koishi6.Schema.number().default(0.9),
-  // 文本查重阈值
-  enableImageDuplicate: import_koishi6.Schema.boolean().default(true),
-  // 开启图片查重
-  imageDuplicateThreshold: import_koishi6.Schema.number().default(0.8),
-  // 图片查重阈值
-  imageMaxSize: import_koishi6.Schema.number().default(4),
-  // 图片大小限制(MB)
-  allowVideo: import_koishi6.Schema.boolean().default(true),
-  // 允许视频
-  videoMaxSize: import_koishi6.Schema.number().default(16),
-  // 视频大小限制(MB)
-  enablePagination: import_koishi6.Schema.boolean().default(false),
-  // 启用分页
-  itemsPerPage: import_koishi6.Schema.number().default(10),
-  // 每页条数
-  blacklist: import_koishi6.Schema.array(import_koishi6.Schema.string()).default([]),
-  // 黑名单
-  whitelist: import_koishi6.Schema.array(import_koishi6.Schema.string()).default([])
-  // 白名单
-}).i18n({
-  "zh-CN": require_zh_CN()._config,
-  "en-US": require_en_US()._config
-});
-async function apply(ctx, config) {
-  ctx.i18n.define("zh-CN", require_zh_CN());
-  ctx.i18n.define("en-US", require_en_US());
-  const dataDir = path7.join(ctx.baseDir, "data");
-  const caveDir = path7.join(dataDir, "cave");
-  await FileHandler.ensureDirectory(caveDir);
-  await FileHandler.ensureDirectory(path7.join(caveDir, "resources"));
-  await FileHandler.ensureJsonFile(path7.join(caveDir, "cave.json"));
-  await FileHandler.ensureJsonFile(path7.join(caveDir, "pending.json"));
-  await FileHandler.ensureJsonFile(path7.join(caveDir, "hash.json"));
-  const idManager = new IdManager(ctx.baseDir);
-  const contentHashManager = new HashManager(caveDir);
-  const auditManager = new AuditManager(ctx, config, idManager);
-  await Promise.all([
-    idManager.initialize(path7.join(caveDir, "cave.json"), path7.join(caveDir, "pending.json")),
-    contentHashManager.initialize()
-  ]);
+var usage = `
+<div style="border-radius: 10px; border: 1px solid #ddd; padding: 16px; margin-bottom: 20px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);">
+  <h2 style="margin-top: 0; color: #4a6ee0;">📌 插件说明</h2>
+  <p>📖 <strong>使用文档</strong>：请点击左上角的 <strong>插件主页</strong> 查看插件使用文档</p>
+  <p>🔍 <strong>更多插件</strong>：可访问 <a href="https://github.com/YisRime" style="color:#4a6ee0;text-decoration:none;">苡淞的 GitHub</a> 查看本人的所有插件</p>
+</div>
+
+<div style="border-radius: 10px; border: 1px solid #ddd; padding: 16px; margin-bottom: 20px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);">
+  <h2 style="margin-top: 0; color: #e0574a;">❤️ 支持与反馈</h2>
+  <p>🌟 喜欢这个插件？请在 <a href="https://github.com/YisRime" style="color:#e0574a;text-decoration:none;">GitHub</a> 上给我一个 Star！</p>
+  <p>🐛 遇到问题？请通过 <strong>Issues</strong> 提交反馈，或加入 QQ 群 <a href="https://qm.qq.com/q/PdLMx9Jowq" style="color:#e0574a;text-decoration:none;"><strong>855571375</strong></a> 进行交流</p>
+</div>
+`;
+var logger = new import_koishi3.Logger("best-cave");
+var Config = import_koishi3.Schema.intersect([
+  import_koishi3.Schema.object({
+    cooldown: import_koishi3.Schema.number().default(10).description("冷却时间（秒）"),
+    perChannel: import_koishi3.Schema.boolean().default(false).description("启用分群模式"),
+    enableProfile: import_koishi3.Schema.boolean().default(false).description("启用自定义昵称"),
+    enableDataIO: import_koishi3.Schema.boolean().default(false).description("启用导入导出"),
+    adminUsers: import_koishi3.Schema.array(import_koishi3.Schema.string()).default([]).description("管理员 ID 列表")
+  }).description("基础配置"),
+  import_koishi3.Schema.object({
+    enableReview: import_koishi3.Schema.boolean().default(false).description("启用审核")
+  }).description("审核配置"),
+  import_koishi3.Schema.object({
+    enableS3: import_koishi3.Schema.boolean().default(false).description("启用 S3 存储"),
+    endpoint: import_koishi3.Schema.string().required().description("端点 (Endpoint)"),
+    bucket: import_koishi3.Schema.string().required().description("存储桶 (Bucket)"),
+    region: import_koishi3.Schema.string().default("auto").description("区域 (Region)"),
+    publicUrl: import_koishi3.Schema.string().description("公共访问 URL").role("link"),
+    accessKeyId: import_koishi3.Schema.string().required().description("Access Key ID").role("secret"),
+    secretAccessKey: import_koishi3.Schema.string().required().description("Secret Access Key").role("secret")
+  }).description("存储配置")
+]);
+function apply(ctx, config) {
+  ctx.model.extend("cave", {
+    id: "unsigned",
+    // 无符号整数，作为主键。
+    elements: "json",
+    // 存储为 JSON 字符串的元素数组。
+    channelId: "string",
+    // 频道 ID。
+    userId: "string",
+    // 用户 ID。
+    userName: "string",
+    // 用户昵称。
+    status: "string",
+    // 回声洞状态。
+    time: "timestamp"
+    // 提交时间。
+  }, {
+    primary: "id"
+    // 将 'id' 字段设置为主键。
+  });
+  const fileManager = new FileManager(ctx.baseDir, config, logger);
   const lastUsed = /* @__PURE__ */ new Map();
-  async function processAdd(ctx2, config2, caveFilePath, resourceDir, pendingFilePath, session, content) {
-    let caveId;
+  let profileManager;
+  let dataManager;
+  let reviewManager;
+  const cave = ctx.command("cave", "回声洞").option("add", "-a <content:text> 添加回声洞").option("view", "-g <id:posint> 查看指定回声洞").option("delete", "-r <id:posint> 删除指定回声洞").option("list", "-l 查询投稿统计").usage("随机抽取一条已添加的回声洞。").action(async ({ session, options }) => {
+    if (options.add) return session.execute(`cave.add ${options.add}`);
+    if (options.view) return session.execute(`cave.view ${options.view}`);
+    if (options.delete) return session.execute(`cave.del ${options.delete}`);
+    if (options.list) return session.execute("cave.list");
+    const cdMessage = checkCooldown(session, config, lastUsed);
+    if (cdMessage) return cdMessage;
     try {
-      caveId = await idManager.getNextId();
-      if (isNaN(caveId) || caveId <= 0) {
-        throw new Error("Invalid ID generated");
-      }
-      const inputContent = content.length > 0 ? content.join("\n") : await (async () => {
-        await sendMessage(session, "commands.cave.add.noContent", [], true, 6e4);
-        const reply = await session.prompt({ timeout: 6e4 });
-        if (!reply) {
-          await sendMessage(session, "commands.cave.add.operationTimeout", [], true);
-          return null;
+      const query = getScopeQuery(session, config);
+      const candidates = await ctx.database.get("cave", query, { fields: ["id"] });
+      if (candidates.length === 0) {
+        return `当前${config.perChannel && session.channelId ? "本群" : ""}还没有任何回声洞`;
+      }
+      const randomId = candidates[Math.floor(Math.random() * candidates.length)].id;
+      const [randomCave] = await ctx.database.get("cave", { ...query, id: randomId });
+      updateCooldownTimestamp(session, config, lastUsed);
+      return buildCaveMessage(randomCave, config, fileManager, logger);
+    } catch (error) {
+      logger.error("随机获取回声洞失败:", error);
+      return "随机获取回声洞失败";
+    }
+  });
+  cave.subcommand(".add [content:text]", "添加回声洞").usage("添加一条回声洞。可以直接发送内容，也可以回复或引用一条消息。").action(async ({ session }, content) => {
+    cleanupPendingDeletions(ctx, fileManager, logger);
+    const savedFileIdentifiers = [];
+    try {
+      let sourceElements;
+      if (session.quote?.elements) {
+        sourceElements = session.quote.elements;
+      } else if (content?.trim()) {
+        sourceElements = import_koishi3.h.parse(content);
+      } else {
+        await session.send("请在一分钟内发送你要添加的内容");
+        const reply = await session.prompt(6e4);
+        if (!reply) return "操作超时，已取消添加";
+        sourceElements = import_koishi3.h.parse(reply);
+      }
+      const scopeQuery = getScopeQuery(session, config);
+      const newId = await getNextCaveId(ctx, scopeQuery);
+      const finalElementsForDb = [];
+      let mediaIndex = 1;
+      async function traverseAndProcess(elements) {
+        for (const el of elements) {
+          const elementType = el.type === "image" ? "img" : el.type;
+          if (["img", "video", "audio", "file"].includes(elementType) && el.attrs.src) {
+            let fileIdentifier = el.attrs.src;
+            if (fileIdentifier.startsWith("http")) {
+              mediaIndex++;
+              const originalName = el.attrs.file;
+              const savedId = await downloadMedia(ctx, fileManager, fileIdentifier, originalName, elementType, newId, mediaIndex, session.channelId, session.userId);
+              savedFileIdentifiers.push(savedId);
+              fileIdentifier = savedId;
+            }
+            finalElementsForDb.push({ type: elementType, file: fileIdentifier });
+          } else if (elementType === "text" && el.attrs.content?.trim()) {
+            finalElementsForDb.push({ type: "text", content: el.attrs.content.trim() });
+          }
+          if (el.children) await traverseAndProcess(el.children);
         }
-        return reply;
-      })();
-      if (!inputContent) {
-        return "";
-      }
-      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);
+      __name(traverseAndProcess, "traverseAndProcess");
+      await traverseAndProcess(sourceElements);
+      if (finalElementsForDb.length === 0) return "内容为空，已取消添加";
+      let userName = session.username;
+      if (config.enableProfile) {
+        userName = await profileManager.getNickname(session.userId) || userName;
       }
-      const imageBuffers = [];
-      const [savedImages, savedVideos] = await Promise.all([
-        imageUrls.length > 0 ? saveMedia(
-          imageUrls,
-          imageElements.map((el) => el.fileName),
-          resourceDir,
-          caveId,
-          "img",
-          config2,
-          ctx2,
-          session,
-          imageBuffers
-        ) : [],
-        videoUrls.length > 0 ? saveMedia(
-          videoUrls,
-          videoElements.map((el) => el.fileName),
-          resourceDir,
-          caveId,
-          "video",
-          config2,
-          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 || "100000",
-        contributor_name: session.username || "User"
+        id: newId,
+        elements: finalElementsForDb,
+        channelId: session.channelId,
+        userId: session.userId,
+        userName,
+        status: config.enableReview ? "pending" : "active",
+        time: /* @__PURE__ */ new Date()
       };
-      if (videoUrls.length > 0 && savedVideos.length > 0) {
-        newCave.elements.push({
-          type: "video",
-          file: savedVideos[0],
-          index: Number.MAX_SAFE_INTEGER
-        });
+      await ctx.database.create("cave", newCave);
+      if (newCave.status === "pending") {
+        reviewManager.sendForReview(newCave);
+        return `提交成功，序号为（${newCave.id}）`;
       }
-      const hashStorage = new HashManager(path7.join(ctx2.baseDir, "data", "cave"));
-      await hashStorage.initialize();
-      const hashStatus = await hashStorage.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 hashStorage.updateAllCaves(true);
-        }
-      }
-      if (config2.enableAudit && !bypassAudit) {
-        const pendingData = await FileHandler.readJsonData(pendingFilePath);
-        pendingData.push(newCave);
-        await Promise.all([
-          FileHandler.writeJsonData(pendingFilePath, pendingData),
-          auditManager.sendAuditMessage(newCave, await buildMessage(newCave, resourceDir, session), session)
-        ]);
-        return sendMessage(session, "commands.cave.add.submitPending", [caveId], false);
-      }
-      const data = await FileHandler.readJsonData(caveFilePath);
-      data.push({
-        ...newCave,
-        elements: cleanElementsForSave(newCave.elements, false)
-      });
-      if (config2.enableImageDuplicate || config2.enableTextDuplicate) {
-        const duplicateResults = await contentHashManager.findDuplicates({
-          images: config2.enableImageDuplicate ? imageBuffers : void 0,
-          texts: config2.enableTextDuplicate ? textParts.filter((p) => p.type === "text").map((p) => p.content) : void 0
-        }, {
-          image: config2.imageDuplicateThreshold,
-          text: config2.textDuplicateThreshold
-        });
-        for (const result of duplicateResults) {
-          if (!result) continue;
-          const originalCave = data.find((item) => item.cave_id === result.caveId);
-          if (!originalCave) continue;
-          await idManager.markDeleted(caveId);
-          const duplicateMessage = session.text(
-            "commands.cave.error.similarDuplicateFound",
-            [(result.similarity * 100).toFixed(1)]
-          );
-          await session.send(duplicateMessage + await buildMessage(originalCave, resourceDir, session));
-          throw new Error("duplicate_found");
-        }
-      }
-      await Promise.all([
-        FileHandler.writeJsonData(caveFilePath, data),
-        contentHashManager.updateCaveContent(caveId, {
-          images: savedImages.length > 0 ? await Promise.all(savedImages.map((file) => fs7.promises.readFile(path7.join(resourceDir, file)))) : void 0,
-          texts: textParts.filter((p) => p.type === "text").map((p) => p.content)
-        })
-      ]);
-      await idManager.addStat(session.userId, caveId);
-      return sendMessage(session, "commands.cave.add.addSuccess", [caveId], false);
+      return `添加成功，序号为（${newId}）`;
     } catch (error) {
-      if (typeof caveId === "number" && !isNaN(caveId) && caveId > 0) {
-        await idManager.markDeleted(caveId);
-      }
-      if (error.message === "duplicate_found") {
-        return "";
+      logger.error("添加回声洞失败:", error);
+      if (savedFileIdentifiers.length > 0) {
+        logger.info(`添加失败，回滚并删除 ${savedFileIdentifiers.length} 个文件...`);
+        await Promise.all(savedFileIdentifiers.map((fileId) => fileManager.deleteFile(fileId)));
       }
-      logger5.error(`Failed to process add command: ${error.message}`);
-      return sendMessage(session, "commands.cave.error.addFailed", [], true);
+      return "添加失败，请稍后再试";
     }
-  }
-  __name(processAdd, "processAdd");
-  const caveCommand = ctx.command("cave [message]").option("a", "添加回声洞").option("g", "查看回声洞", { type: "string" }).option("r", "删除回声洞", { type: "string" }).option("l", "查询投稿统计", { type: "string" }).before(async ({ session }) => {
-    if (config.blacklist.includes(session.userId)) {
-      return sendMessage(session, "commands.cave.message.blacklisted", [], true);
-    }
-  }).action(async ({ session, options }, ...content) => {
-    const dataDir2 = path7.join(ctx.baseDir, "data");
-    const caveDir2 = path7.join(dataDir2, "cave");
-    const caveFilePath = path7.join(caveDir2, "cave.json");
-    const resourceDir = path7.join(caveDir2, "resources");
-    const pendingFilePath = path7.join(caveDir2, "pending.json");
-    const needsCooldown = !options.l && !options.a;
-    if (needsCooldown) {
-      const guildId = session.guildId;
-      const now = Date.now();
-      const lastTime = lastUsed.get(guildId) || 0;
-      const isManager = config.manager.includes(session.userId);
-      if (!isManager && now - lastTime < config.number * 1e3) {
-        const waitTime = Math.ceil((config.number * 1e3 - (now - lastTime)) / 1e3);
-        return sendMessage(session, "commands.cave.message.cooldown", [waitTime], true);
-      }
-      lastUsed.set(guildId, now);
-    }
-    if (options.l !== void 0) {
-      const input = typeof options.l === "string" ? options.l : content[0];
-      const num = parseInt(input);
-      if (config.manager.includes(session.userId)) {
-        if (!isNaN(num)) {
-          if (num < 1e4) {
-            return await processList(session, config, idManager, void 0, num);
-          } else {
-            return await processList(session, config, idManager, num.toString());
-          }
-        } else if (input) {
-          return await processList(session, config, idManager, input);
-        }
-        return await processList(session, config, idManager);
-      } else {
-        return await processList(session, config, idManager, session.userId);
+  });
+  cave.subcommand(".view <id:posint>", "查看指定回声洞").usage("通过序号查看对应的回声洞。").action(async ({ session }, id) => {
+    if (!id) return "请输入要查看的回声洞序号";
+    const cdMessage = checkCooldown(session, config, lastUsed);
+    if (cdMessage) return cdMessage;
+    try {
+      const query = { ...getScopeQuery(session, config), id };
+      const [targetCave] = await ctx.database.get("cave", query);
+      if (!targetCave) {
+        return `回声洞（${id}）不存在`;
       }
+      updateCooldownTimestamp(session, config, lastUsed);
+      return buildCaveMessage(targetCave, config, fileManager, logger);
+    } catch (error) {
+      logger.error(`查看回声洞（${id}）失败:`, error);
+      return "查看失败，请稍后再试";
     }
-    if (options.g) {
-      return await processView(caveFilePath, resourceDir, session, options, content);
-    }
-    if (options.r) {
-      return await processDelete(caveFilePath, resourceDir, pendingFilePath, session, config, options, content, idManager, contentHashManager);
-    }
-    if (options.a) {
-      return await processAdd(ctx, config, caveFilePath, resourceDir, pendingFilePath, session, content);
-    }
-    return await processRandom(caveFilePath, resourceDir, session);
   });
-  caveCommand.subcommand(".pass <id:text>", "通过回声洞审核").before(async ({ session }) => {
-    if (!config.manager.includes(session.userId)) {
-      return sendMessage(session, "commands.cave.message.managerOnly", [], true);
+  cave.subcommand(".del <id:posint>", "删除指定回声洞").usage("通过序号删除对应的回声洞。").action(async ({ session }, id) => {
+    if (!id) return "请输入要删除的回声洞序号";
+    try {
+      const [targetCave] = await ctx.database.get("cave", { id, status: "active" });
+      if (!targetCave) return `回声洞（${id}）不存在`;
+      const isOwner = targetCave.userId === session.userId;
+      const isAdmin = config.adminUsers.includes(session.userId);
+      if (!isOwner && !isAdmin) {
+        return "抱歉，你没有权限删除这条回声洞";
+      }
+      await ctx.database.upsert("cave", [{ id, status: "delete" }]);
+      cleanupPendingDeletions(ctx, fileManager, logger);
+      const caveMessage = await buildCaveMessage(targetCave, config, fileManager, logger);
+      return [
+        (0, import_koishi3.h)("p", {}, `以下内容已删除`),
+        ...caveMessage
+      ];
+    } catch (error) {
+      logger.error(`标记回声洞（${id}）失败:`, error);
+      return "删除失败，请稍后再试";
     }
-  }).action(async ({ session }, id) => {
-    const dataDir2 = path7.join(ctx.baseDir, "data");
-    const caveDir2 = path7.join(dataDir2, "cave");
-    const caveFilePath = path7.join(caveDir2, "cave.json");
-    const resourceDir = path7.join(caveDir2, "resources");
-    const pendingFilePath = path7.join(caveDir2, "pending.json");
-    const pendingData = await FileHandler.readJsonData(pendingFilePath);
-    return await auditManager.processAudit(pendingData, true, caveFilePath, resourceDir, pendingFilePath, session, id === "all" ? void 0 : parseInt(id));
   });
-  caveCommand.subcommand(".reject <id:text>", "拒绝回声洞审核").before(async ({ session }) => {
-    if (!config.manager.includes(session.userId)) {
-      return sendMessage(session, "commands.cave.message.managerOnly", [], true);
+  cave.subcommand(".list", "查询我的投稿").usage("查询并列出你所有投稿的回声洞序号。").action(async ({ session }) => {
+    try {
+      const query = { ...getScopeQuery(session, config), userId: session.userId };
+      const userCaves = await ctx.database.get("cave", query);
+      if (userCaves.length === 0) return "你还没有投稿过回声洞";
+      const caveIds = userCaves.map((c) => c.id).sort((a, b) => a - b).join(", ");
+      return `你已投稿 ${userCaves.length} 条回声洞，序号为：
+${caveIds}`;
+    } catch (error) {
+      logger.error("查询投稿列表失败:", error);
+      return "查询失败，请稍后再试";
     }
-  }).action(async ({ session }, id) => {
-    const dataDir2 = path7.join(ctx.baseDir, "data");
-    const caveDir2 = path7.join(dataDir2, "cave");
-    const caveFilePath = path7.join(caveDir2, "cave.json");
-    const resourceDir = path7.join(caveDir2, "resources");
-    const pendingFilePath = path7.join(caveDir2, "pending.json");
-    const pendingData = await FileHandler.readJsonData(pendingFilePath);
-    return await auditManager.processAudit(pendingData, false, caveFilePath, resourceDir, pendingFilePath, session, id === "all" ? void 0 : parseInt(id));
   });
+  if (config.enableProfile) {
+    profileManager = new ProfileManager(ctx);
+    profileManager.registerCommands(cave);
+  }
+  if (config.enableDataIO) {
+    dataManager = new DataManager(ctx, config, fileManager, logger);
+    dataManager.registerCommands(cave);
+  }
+  if (config.enableReview) {
+    reviewManager = new ReviewManager(ctx, config, fileManager, logger);
+    reviewManager.registerCommands(cave);
+  }
 }
 __name(apply, "apply");
-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 keepIndex ? cleanedElements.sort((a, b) => (a.index || 0) - (b.index || 0)) : cleanedElements;
-}
-__name(cleanElementsForSave, "cleanElementsForSave");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,
   apply,
   inject,
-  name
+  name,
+  usage
 });