koishi-plugin-best-cave 2.0.6 → 2.0.8

package/lib/index.js

@@ -37,7 +37,8 @@ __export(index_exports, {
   usage: () => usage
 });
 module.exports = __toCommonJS(index_exports);
-var import_koishi2 = require("koishi");
+var import_koishi3 = require("koishi");
+var path3 = __toESM(require("path"));
 
 // src/FileManager.ts
 var import_client_s3 = require("@aws-sdk/client-s3");
@@ -45,10 +46,10 @@ var fs = __toESM(require("fs/promises"));
 var path = __toESM(require("path"));
 var FileManager = class {
   /**
-   * 创建一个 FileManager 实例。
-   * @param baseDir - Koishi 应用的基础数据目录 (ctx.baseDir)。
-   * @param config - 插件的完整配置对象。
-   * @param logger - 日志记录器实例。
+   * @constructor
+   * @param baseDir Koishi 应用的基础数据目录 (ctx.baseDir)。
+   * @param config 插件的配置对象。
+   * @param logger 日志记录器实例。
    */
   constructor(baseDir, config, logger2) {
     this.logger = logger2;
@@ -68,47 +69,18 @@ var FileManager = class {
   static {
     __name(this, "FileManager");
   }
-  // 本地资源存储目录的绝对路径。
   resourceDir;
-  // 本地文件锁，键为文件绝对路径，值为一个 Promise，用于防止对同一文件的并发访问。
   locks = /* @__PURE__ */ new Map();
-  // S3 客户端实例，仅在启用 S3 时初始化。
   s3Client;
-  // S3 存储桶名称。
   s3Bucket;
   /**
-   * 确保本地资源目录存在。如果目录不存在，则会递归创建。
-   * 这是一个幂等操作。
-   * @private
-   */
-  async ensureDirectory() {
-    try {
-      await fs.mkdir(this.resourceDir, { recursive: true });
-    } catch (error) {
-      this.logger.error(`创建资源目录失败 ${this.resourceDir}:`, error);
-      throw error;
-    }
-  }
-  /**
-   * 获取给定文件名的完整本地路径。
-   * @param fileName - 文件名。
-   * @returns 文件的绝对路径。
-   * @private
-   */
-  getFullPath(fileName) {
-    return path.join(this.resourceDir, fileName);
-  }
-  /**
-   * 使用文件锁来安全地执行一个异步文件操作。
-   * 这可以防止对同一文件的并发读写造成数据损坏。
-   * @template T - 异步操作的返回类型。
-   * @param fileName - 需要加锁的文件名。
-   * @param operation - 要执行的异步函数。
+   * @description 使用文件锁安全地执行异步文件操作，防止并发读写冲突。
+   * @template T 异步操作的返回类型。
+   * @param fullPath 需要加锁的文件的完整路径。
+   * @param operation 要执行的异步函数。
    * @returns 返回异步操作的结果。
-   * @private
    */
-  async withLock(fileName, operation) {
-    const fullPath = this.getFullPath(fileName);
+  async withLock(fullPath, operation) {
     while (this.locks.has(fullPath)) {
       await this.locks.get(fullPath);
     }
@@ -119,9 +91,9 @@ var FileManager = class {
     return promise;
   }
   /**
-   * 保存文件，自动选择 S3 或本地存储。
-   * @param fileName - 文件名，将用作 S3 中的 Key 或本地文件名。
-   * @param data - 要写入的 Buffer 数据。
+   * @description 保存文件，自动选择 S3 或本地存储。
+   * @param fileName 用作 S3 Key 或本地文件名。
+   * @param data 要写入的 Buffer 数据。
    * @returns 返回保存时使用的文件名/标识符。
    */
   async saveFile(fileName, data) {
@@ -131,57 +103,52 @@ var FileManager = class {
         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;
+      await fs.mkdir(this.resourceDir, { recursive: true }).catch((error) => {
+        this.logger.error(`创建资源目录失败 ${this.resourceDir}:`, error);
+        throw error;
+      });
+      const filePath = path.join(this.resourceDir, fileName);
+      await this.withLock(filePath, () => fs.writeFile(filePath, data));
     }
+    return fileName;
   }
   /**
-   * 读取文件，自动从 S3 或本地存储读取。
-   * @param fileName - 要读取的文件名/标识符。
+   * @description 读取文件，自动从 S3 或本地存储读取。
+   * @param fileName 要读取的文件名/标识符。
    * @returns 文件的 Buffer 数据。
    */
   async readFile(fileName) {
     if (this.s3Client) {
-      const command = new import_client_s3.GetObjectCommand({
-        Bucket: this.s3Bucket,
-        Key: fileName
-      });
+      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);
+      return Buffer.from(await response.Body.transformToByteArray());
     } else {
-      const filePath = this.getFullPath(fileName);
-      return this.withLock(fileName, () => fs.readFile(filePath));
+      const filePath = path.join(this.resourceDir, fileName);
+      return this.withLock(filePath, () => fs.readFile(filePath));
     }
   }
   /**
-   * 删除文件，自动从 S3 或本地删除。
-   * @param fileIdentifier - 要删除的文件名/标识符。
+   * @description 删除文件，自动从 S3 或本地删除。
+   * @param fileIdentifier 要删除的文件名/标识符。
    */
   async deleteFile(fileIdentifier) {
     if (this.s3Client) {
-      const command = new import_client_s3.DeleteObjectCommand({
-        Bucket: this.s3Bucket,
-        Key: fileIdentifier
-      });
+      const command = new import_client_s3.DeleteObjectCommand({ Bucket: this.s3Bucket, Key: fileIdentifier });
       await this.s3Client.send(command).catch((err) => {
-        this.logger.warn(`删除文件 ${fileIdentifier} 失败:`, err);
+        this.logger.warn(`删除 S3 文件 ${fileIdentifier} 失败:`, err);
       });
     } else {
-      const filePath = this.getFullPath(fileIdentifier);
-      await this.withLock(fileIdentifier, async () => {
+      const filePath = path.join(this.resourceDir, fileIdentifier);
+      await this.withLock(filePath, async () => {
         try {
           await fs.unlink(filePath);
         } catch (error) {
           if (error.code !== "ENOENT") {
-            this.logger.warn(`删除文件 ${filePath} 失败:`, error);
+            this.logger.warn(`删除本地文件 ${filePath} 失败:`, error);
           }
         }
       });
@@ -192,7 +159,7 @@ var FileManager = class {
 // src/ProfileManager.ts
 var ProfileManager = class {
   /**
-   * 创建一个 ProfileManager 实例。
+   * @constructor
    * @param ctx - Koishi 上下文，用于初始化数据库模型。
    */
   constructor(ctx) {
@@ -204,49 +171,47 @@ var ProfileManager = class {
       // 用户自定义昵称
     }, {
       primary: "userId"
-      // 使用 userId 作为主键，确保每个用户只有一条昵称记录。
+      // 保证每个用户只有一条昵称记录。
     });
   }
   static {
     __name(this, "ProfileManager");
   }
   /**
-   * 注册与用户昵称相关的 `.profile` 子命令。
-   * @param cave - 主 `cave` 命令的实例，用于挂载子命令。
+   * @description 注册 `.profile` 子命令，用于管理用户昵称。
+   * @param cave - 主 `cave` 命令实例。
    */
   registerCommands(cave) {
-    cave.subcommand(".profile [nickname:text]", "设置显示昵称").usage("设置你在回声洞中显示的昵称。不提供昵称则清除记录。").action(async ({ session }, nickname) => {
+    cave.subcommand(".profile [nickname:text]", "设置显示昵称").usage("设置你在回声洞中显示的昵称。若不提供昵称，则清除现有昵称。").action(async ({ session }, nickname) => {
       const trimmedNickname = nickname?.trim();
-      if (!trimmedNickname) {
+      if (trimmedNickname) {
+        await this.setNickname(session.userId, trimmedNickname);
+        return `昵称已更新为：${trimmedNickname}`;
+      } else {
         await this.clearNickname(session.userId);
         return "昵称已清除";
       }
-      await this.setNickname(session.userId, trimmedNickname);
-      return `昵称已更新为：${trimmedNickname}`;
     });
   }
   /**
-   * 设置或更新指定用户的昵称。
+   * @description 设置或更新指定用户的昵称。
    * @param userId - 目标用户的 ID。
    * @param nickname - 要设置的新昵称。
    */
   async setNickname(userId, nickname) {
-    await this.ctx.database.upsert("cave_user", [{
-      userId,
-      nickname
-    }]);
+    await this.ctx.database.upsert("cave_user", [{ userId, nickname }]);
   }
   /**
-   * 获取指定用户的昵称。
+   * @description 获取指定用户的昵称。
    * @param userId - 目标用户的 ID。
-   * @returns 返回用户的昵称字符串。如果用户未设置昵称，则返回 null。
+   * @returns 返回用户的昵称字符串，如果未设置则返回 null。
    */
   async getNickname(userId) {
-    const profiles = await this.ctx.database.get("cave_user", { userId });
-    return profiles[0]?.nickname || null;
+    const profile = await this.ctx.database.get("cave_user", { userId });
+    return profile[0]?.nickname ?? null;
   }
   /**
-   * 清除指定用户的昵称设置。
+   * @description 清除指定用户的昵称设置。
    * @param userId - 目标用户的 ID。
    */
   async clearNickname(userId) {
@@ -257,78 +222,46 @@ var ProfileManager = class {
 // 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"
-};
+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 "image":
-      case "video":
-      case "audio":
-      case "file":
-        return (0, import_koishi.h)(el.type, { src: el.file });
-      default:
-        return null;
-    }
+    if (el.type === "text") return import_koishi.h.text(el.content);
+    if (["image", "video", "audio", "file"].includes(el.type)) return (0, import_koishi.h)(el.type, { src: el.file });
+    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}]`);
-  }
-}
-__name(mediaElementToBase64, "mediaElementToBase64");
 async function buildCaveMessage(cave, config, fileManager, logger2) {
   const caveHElements = storedFormatToHElements(cave.elements);
-  const processedElements = await Promise.all(caveHElements.map((element) => {
+  const processedElements = await Promise.all(caveHElements.map(async (element) => {
     const isMedia = ["image", "video", "audio", "file"].includes(element.type);
     const fileName = element.attrs.src;
-    if (!isMedia || !fileName) {
-      return Promise.resolve(element);
-    }
+    if (!isMedia || !fileName) return 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 (0, import_koishi.h)(element.type, { ...element.attrs, src: fullUrl });
     }
     if (config.localPath) {
-      const mappedPath = path2.join(config.localPath, fileName);
-      const fileUri = `file://${mappedPath}`;
-      return Promise.resolve((0, import_koishi.h)(element.type, { ...element.attrs, src: fileUri }));
+      const fileUri = `file://${path2.join(config.localPath, fileName)}`;
+      return (0, import_koishi.h)(element.type, { ...element.attrs, src: fileUri });
+    }
+    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}]`);
     }
-    return mediaElementToBase64(element, fileManager, logger2);
   }));
   const finalMessage = [];
-  const formatString = config.caveFormat;
-  const separatorIndex = formatString.indexOf("|");
-  let headerFormat, footerFormat;
-  if (separatorIndex === -1) {
-    headerFormat = formatString;
-    footerFormat = "";
-  } else {
-    headerFormat = formatString.substring(0, separatorIndex);
-    footerFormat = formatString.substring(separatorIndex + 1);
-  }
-  const headerText = headerFormat.replace("{id}", cave.id.toString()).replace("{name}", cave.userName);
+  const [headerFormat, footerFormat = ""] = config.caveFormat.split("|");
+  const replacements = { id: cave.id.toString(), name: cave.userName };
+  const headerText = headerFormat.replace(/\{id\}|\{name\}/g, (match) => replacements[match.slice(1, -1)]);
   if (headerText.trim()) finalMessage.push(headerText);
   finalMessage.push(...processedElements);
-  const footerText = footerFormat.replace("{id}", cave.id.toString()).replace("{name}", cave.userName);
+  const footerText = footerFormat.replace(/\{id\}|\{name\}/g, (match) => replacements[match.slice(1, -1)]);
   if (footerText.trim()) finalMessage.push(footerText);
   return finalMessage;
 }
@@ -336,7 +269,7 @@ __name(buildCaveMessage, "buildCaveMessage");
 async function cleanupPendingDeletions(ctx, fileManager, logger2) {
   try {
     const cavesToDelete = await ctx.database.get("cave", { status: "delete" });
-    if (cavesToDelete.length === 0) return;
+    if (!cavesToDelete.length) return;
     for (const cave of cavesToDelete) {
       const deletePromises = cave.elements.filter((el) => el.file).map((el) => fileManager.deleteFile(el.file));
       await Promise.all(deletePromises);
@@ -349,15 +282,12 @@ async function cleanupPendingDeletions(ctx, fileManager, logger2) {
 __name(cleanupPendingDeletions, "cleanupPendingDeletions");
 function getScopeQuery(session, config) {
   const baseQuery = { status: "active" };
-  if (config.perChannel && session.channelId) {
-    return { ...baseQuery, channelId: session.channelId };
-  }
-  return baseQuery;
+  return config.perChannel && session.channelId ? { ...baseQuery, channelId: session.channelId } : 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));
+  const allCaveIds = (await ctx.database.get("cave", query, { fields: ["id"] })).map((c) => c.id);
+  const existingIds = new Set(allCaveIds);
   let newId = 1;
   while (existingIds.has(newId)) {
     newId++;
@@ -365,19 +295,8 @@ async function getNextCaveId(ctx, query = {}) {
   return newId;
 }
 __name(getNextCaveId, "getNextCaveId");
-async function downloadMedia(ctx, fileManager, url, originalName, type, caveId, index, channelId, userId) {
-  const defaultExtMap = { "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;
-  }
+  if (config.coolDown <= 0 || !session.channelId) return null;
   const now = Date.now();
   const lastTime = lastUsed.get(session.channelId) || 0;
   if (now - lastTime < config.coolDown * 1e3) {
@@ -397,11 +316,11 @@ __name(updateCooldownTimestamp, "updateCooldownTimestamp");
 // src/DataManager.ts
 var DataManager = class {
   /**
-   * 创建一个 DataManager 实例。
-   * @param ctx - Koishi 上下文，用于数据库操作。
-   * @param config - 插件配置。
-   * @param fileManager - 文件管理器实例，用于读写导入/导出文件。
-   * @param logger - 日志记录器实例。
+   * @constructor
+   * @param ctx Koishi 上下文，用于数据库操作。
+   * @param config 插件配置。
+   * @param fileManager 文件管理器实例。
+   * @param logger 日志记录器实例。
    */
   constructor(ctx, config, fileManager, logger2) {
     this.ctx = ctx;
@@ -413,27 +332,25 @@ var DataManager = class {
     __name(this, "DataManager");
   }
   /**
-   * 注册与数据导入导出相关的 `.export` 和 `.import` 子命令。
-   * @param cave - 主 `cave` 命令的实例，用于挂载子命令。
+   * @description 注册 `.export` 和 `.import` 子命令。
+   * @param cave - 主 `cave` 命令实例。
    */
   registerCommands(cave) {
     cave.subcommand(".export", "导出回声洞数据").usage("将所有回声洞数据导出到 cave_export.json。").action(async ({ session }) => {
-      if (!this.config.adminUsers.includes(session.userId)) return "抱歉，你没有权限导出数据";
+      if (session.channelId !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
       try {
         await session.send("正在导出数据，请稍候...");
-        const resultMessage = await this.exportData();
-        return resultMessage;
+        return await this.exportData();
       } catch (error) {
         this.logger.error("导出数据时发生错误:", error);
         return `导出失败: ${error.message}`;
       }
     });
     cave.subcommand(".import", "导入回声洞数据").usage("从 cave_import.json 中导入回声洞数据。").action(async ({ session }) => {
-      if (!this.config.adminUsers.includes(session.userId)) return "抱歉，你没有权限导入数据";
+      if (session.channelId !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
       try {
         await session.send("正在导入数据，请稍候...");
-        const resultMessage = await this.importData();
-        return resultMessage;
+        return await this.importData();
       } catch (error) {
         this.logger.error("导入数据时发生错误:", error);
         return `导入失败: ${error.message}`;
@@ -441,9 +358,8 @@ var DataManager = class {
     });
   }
   /**
-   * 导出所有状态为 'active' 的回声洞数据。
-   * 数据将被序列化为 JSON 并保存到 `cave_export.json` 文件中。
-   * @returns 一个描述导出结果的字符串消息。
+   * @description 导出所有 'active' 状态的回声洞数据到 `cave_export.json`。
+   * @returns 描述导出结果的消息字符串。
    */
   async exportData() {
     const fileName = "cave_export.json";
@@ -454,8 +370,8 @@ var DataManager = class {
     return `成功导出 ${portableCaves.length} 条数据`;
   }
   /**
-   * 从 `cave_import.json` 文件导入回声洞数据。
-   * @returns 一个描述导入结果的字符串消息。
+   * @description 从 `cave_import.json` 文件导入回声洞数据。
+   * @returns 描述导入结果的消息字符串。
    */
   async importData() {
     const fileName = "cave_import.json";
@@ -463,9 +379,7 @@ var DataManager = class {
     try {
       const fileContent = await this.fileManager.readFile(fileName);
       importedCaves = JSON.parse(fileContent.toString("utf-8"));
-      if (!Array.isArray(importedCaves)) {
-        throw new Error("导入文件格式无效");
-      }
+      if (!Array.isArray(importedCaves)) throw new Error("导入文件格式无效");
     } catch (error) {
       this.logger.error(`读取导入文件失败:`, error);
       return `读取导入文件失败: ${error.message || "未知错误"}`;
@@ -477,9 +391,8 @@ var DataManager = class {
         ...cave,
         id: newId,
         channelId: cave.channelId || null,
-        // 确保 channelId 存在，若无则为 null。
+        // 保证 channelId 存在
         status: "active"
-        // 导入的数据直接设为 active 状态。
       };
       await this.ctx.database.create("cave", newCave);
       successCount++;
@@ -489,13 +402,14 @@ var DataManager = class {
 };
 
 // src/ReviewManager.ts
+var import_koishi2 = require("koishi");
 var ReviewManager = class {
   /**
-   * 创建一个 ReviewManager 实例。
-   * @param ctx - Koishi 上下文。
-   * @param config - 插件配置。
-   * @param fileManager - 文件管理器实例。
-   * @param logger - 日志记录器实例。
+   * @constructor
+   * @param ctx Koishi 上下文。
+   * @param config 插件配置。
+   * @param fileManager 文件管理器实例。
+   * @param logger 日志记录器实例。
    */
   constructor(ctx, config, fileManager, logger2) {
     this.ctx = ctx;
@@ -507,111 +421,68 @@ var ReviewManager = class {
     __name(this, "ReviewManager");
   }
   /**
-   * 注册与审核相关的 `.review` 子命令。
-   * @param cave - 主 `cave` 命令的实例，用于挂载子命令。
+   * @description 注册与审核相关的 `.review` 子命令。
+   * @param cave - 主 `cave` 命令实例。
    */
   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 "抱歉，你没有权限执行审核";
-      }
+      if (session.channelId !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
       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(", ");
+        if (pendingCaves.length === 0) return "当前没有需要审核的回声洞";
         return `当前共有 ${pendingCaves.length} 条待审核回声洞，序号为：
-${pendingIds}`;
+${pendingCaves.map((c) => c.id).join(", ")}`;
       }
       const [targetCave] = await this.ctx.database.get("cave", { id });
-      if (!targetCave) {
-        return `回声洞（${id}）不存在`;
-      }
-      if (targetCave.status !== "pending") {
-        return `回声洞（${id}）无需审核`;
-      }
+      if (!targetCave) return `回声洞（${id}）不存在`;
+      if (targetCave.status !== "pending") return `回声洞（${id}）无需审核`;
       if (id && !action) {
-        return this.buildReviewMessage(targetCave);
+        return [`待审核：`, ...await buildCaveMessage(targetCave, this.config, this.fileManager, this.logger)];
       }
       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}"
+      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" (拒绝)`;
-      }
-      return this.processReview(reviewAction, id, session.username);
+      return this.processReview(reviewAction, id);
     });
   }
   /**
-   * 将一条新的回声洞提交给所有管理员进行审核。
-   * @param cave - 新创建的、状态为 'pending' 的回声洞对象。
+   * @description 将新回声洞提交到管理群组以供审核。
+   * @param cave 新创建的、状态为 'pending' 的回声洞对象。
    */
   async sendForReview(cave) {
-    if (!this.config.adminUsers?.length) {
-      this.logger.warn(`未配置管理员，回声洞（${cave.id}）已自动通过审核`);
+    if (!this.config.adminChannel) {
+      this.logger.warn(`未配置管理群组，已自动通过回声洞（${cave.id}）`);
       await this.ctx.database.upsert("cave", [{ id: cave.id, status: "active" }]);
       return;
     }
-    const reviewMessage = await this.buildReviewMessage(cave);
+    const reviewMessage = [`待审核：`, ...await buildCaveMessage(cave, this.config, this.fileManager, this.logger)];
     try {
-      await this.ctx.broadcast(this.config.adminUsers, reviewMessage);
+      await this.ctx.broadcast([this.config.adminChannel], import_koishi2.h.normalize(reviewMessage));
     } catch (error) {
-      this.logger.error(`广播回声洞（${cave.id}）审核请求失败:`, error);
+      this.logger.error(`发送回声洞（${cave.id}）审核消息失败:`, error);
     }
   }
   /**
-   * 构建一条用于发送给管理员的、包含审核信息的消息。
-   * @param cave - 待审核的回声洞对象。
-   * @returns 一个可直接发送的消息数组。
-   * @private
-   */
-  async buildReviewMessage(cave) {
-    const caveContent = await buildCaveMessage(cave, this.config, this.fileManager, this.logger);
-    return [
-      `以下内容待审核：`,
-      ...caveContent
-    ];
-  }
-  /**
-   * 处理管理员的审核决定（通过或拒绝）。
-   * @param action - 'approve' (通过) 或 'reject' (拒绝)。
-   * @param caveId - 被审核的回声洞 ID。
-   * @param adminUserName - 执行操作的管理员的昵称。
+   * @description 处理管理员的审核决定（通过或拒绝）。
+   * @param action 'approve' (通过) 或 'reject' (拒绝)。
+   * @param caveId 被审核的回声洞 ID。
    * @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}）无需审核`;
+  async processReview(action, caveId) {
+    const [cave] = await this.ctx.database.get("cave", { id: caveId, status: "pending" });
+    if (!cave) 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" }]);
-      const caveContent = await buildCaveMessage(cave, this.config, this.fileManager, this.logger);
-      resultMessage = [
-        `回声洞（${caveId}）已拒绝`,
-        ...caveContent
-      ];
-      broadcastMessage = [
-        `回声洞（${caveId}）已由管理员 "${adminUserName}" 拒绝`,
-        ...caveContent
-      ];
+      resultMessage = `回声洞（${caveId}）已拒绝`;
       cleanupPendingDeletions(this.ctx, this.fileManager, this.logger);
     }
-    if (broadcastMessage && this.config.adminUsers?.length) {
-      await this.ctx.broadcast(this.config.adminUsers, broadcastMessage).catch((err) => {
-        this.logger.error(`广播回声洞（${cave.id}）审核结果失败:`, err);
-      });
-    }
     return resultMessage;
   }
 };
@@ -625,57 +496,46 @@ var usage = `
   <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_koishi2.Logger("best-cave");
-var Config = import_koishi2.Schema.intersect([
-  import_koishi2.Schema.object({
-    coolDown: import_koishi2.Schema.number().default(10).description("冷却时间（秒）"),
-    perChannel: import_koishi2.Schema.boolean().default(false).description("启用分群模式"),
-    enableProfile: import_koishi2.Schema.boolean().default(false).description("启用自定义昵称"),
-    enableIO: import_koishi2.Schema.boolean().default(false).description("启用导入导出"),
-    caveFormat: import_koishi2.Schema.string().default("回声洞 ——（{id}）|—— {name}").description("自定义文本"),
-    adminUsers: import_koishi2.Schema.array(import_koishi2.Schema.string()).default([]).description("管理员 ID 列表")
+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("启用自定义昵称"),
+    enableIO: import_koishi3.Schema.boolean().default(false).description("启用导入导出"),
+    adminChannel: import_koishi3.Schema.string().description("管理群组 ID"),
+    caveFormat: import_koishi3.Schema.string().default("回声洞 ——（{id}）|—— {name}").description("自定义文本")
   }).description("基础配置"),
-  import_koishi2.Schema.object({
-    enableReview: import_koishi2.Schema.boolean().default(false).description("启用审核")
+  import_koishi3.Schema.object({
+    enableReview: import_koishi3.Schema.boolean().default(false).description("启用审核")
   }).description("审核配置"),
-  import_koishi2.Schema.object({
-    localPath: import_koishi2.Schema.string().description("文件映射路径"),
-    enableS3: import_koishi2.Schema.boolean().default(false).description("启用 S3 存储"),
-    publicUrl: import_koishi2.Schema.string().description("公共访问 URL").role("link"),
-    endpoint: import_koishi2.Schema.string().description("端点 (Endpoint)").role("link"),
-    bucket: import_koishi2.Schema.string().description("存储桶 (Bucket)"),
-    region: import_koishi2.Schema.string().default("auto").description("区域 (Region)"),
-    accessKeyId: import_koishi2.Schema.string().description("Access Key ID").role("secret"),
-    secretAccessKey: import_koishi2.Schema.string().description("Secret Access Key").role("secret")
+  import_koishi3.Schema.object({
+    localPath: import_koishi3.Schema.string().description("文件映射路径"),
+    enableS3: import_koishi3.Schema.boolean().default(false).description("启用 S3 存储"),
+    publicUrl: import_koishi3.Schema.string().description("公共访问 URL").role("link"),
+    endpoint: import_koishi3.Schema.string().description("端点 (Endpoint)").role("link"),
+    bucket: import_koishi3.Schema.string().description("存储桶 (Bucket)"),
+    region: import_koishi3.Schema.string().default("auto").description("区域 (Region)"),
+    accessKeyId: import_koishi3.Schema.string().description("Access Key ID").role("secret"),
+    secretAccessKey: import_koishi3.Schema.string().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' 字段设置为主键。
-  });
+  }, { primary: "id" });
   const fileManager = new FileManager(ctx.baseDir, config, logger);
   const lastUsed = /* @__PURE__ */ new Map();
   let profileManager;
@@ -704,59 +564,85 @@ function apply(ctx, config) {
     }
   });
   cave.subcommand(".add [content:text]", "添加回声洞").usage("添加一条回声洞。可以直接发送内容，也可以回复或引用一条消息。").action(async ({ session }, content) => {
-    const savedFileIdentifiers = [];
     try {
       let sourceElements;
       if (session.quote?.elements) {
         sourceElements = session.quote.elements;
       } else if (content?.trim()) {
-        sourceElements = import_koishi2.h.parse(content);
+        sourceElements = import_koishi3.h.parse(content);
       } else {
         await session.send("请在一分钟内发送你要添加的内容");
         const reply = await session.prompt(6e4);
         if (!reply) return "操作超时，已取消添加";
-        sourceElements = import_koishi2.h.parse(reply);
+        sourceElements = import_koishi3.h.parse(reply);
       }
-      const scopeQuery = getScopeQuery(session, config);
-      const newId = await getNextCaveId(ctx, scopeQuery);
+      const idScopeQuery = {};
+      if (config.perChannel && session.channelId) {
+        idScopeQuery["channelId"] = session.channelId;
+      }
+      const newId = await getNextCaveId(ctx, idScopeQuery);
       const finalElementsForDb = [];
+      const mediaToSave = [];
       let mediaIndex = 0;
+      const typeMap = {
+        "img": "image",
+        "image": "image",
+        "video": "video",
+        "audio": "audio",
+        "file": "file",
+        "text": "text"
+      };
       async function traverseAndProcess(elements) {
         for (const el of elements) {
-          const elementType = el.type;
-          if (["image", "video", "audio", "file"].includes(elementType) && el.attrs.src) {
+          const normalizedType = typeMap[el.type];
+          if (!normalizedType) {
+            if (el.children) await traverseAndProcess(el.children);
+            continue;
+          }
+          if (["image", "video", "audio", "file"].includes(normalizedType) && 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;
+              const defaultExtMap = { "image": ".jpg", "video": ".mp4", "audio": ".mp3", "file": ".dat" };
+              const ext = el.attrs.file && path3.extname(el.attrs.file) ? path3.extname(el.attrs.file) : defaultExtMap[normalizedType] || ".dat";
+              const channelIdentifier = session.channelId || "private";
+              const fileName = `${newId}_${mediaIndex}_${channelIdentifier}_${session.userId}${ext}`;
+              mediaToSave.push({ sourceUrl: fileIdentifier, fileName });
+              fileIdentifier = fileName;
             }
-            finalElementsForDb.push({ type: elementType, file: fileIdentifier });
-          } else if (elementType === "text" && el.attrs.content?.trim()) {
+            finalElementsForDb.push({ type: normalizedType, file: fileIdentifier });
+          } else if (normalizedType === "text" && el.attrs.content?.trim()) {
             finalElementsForDb.push({ type: "text", content: el.attrs.content.trim() });
           }
-          if (el.children) await traverseAndProcess(el.children);
+          if (el.children) {
+            await traverseAndProcess(el.children);
+          }
         }
       }
       __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 customNickname = config.enableProfile ? await profileManager.getNickname(session.userId) : null;
       const newCave = {
         id: newId,
         elements: finalElementsForDb,
         channelId: session.channelId,
         userId: session.userId,
-        userName,
+        userName: customNickname || session.username,
         status: config.enableReview ? "pending" : "active",
         time: /* @__PURE__ */ new Date()
       };
       await ctx.database.create("cave", newCave);
+      try {
+        await Promise.all(mediaToSave.map(async (media) => {
+          const response = await ctx.http.get(media.sourceUrl, { responseType: "arraybuffer", timeout: 3e4 });
+          await fileManager.saveFile(media.fileName, Buffer.from(response));
+        }));
+      } catch (fileSaveError) {
+        logger.error(`文件保存失败:`, fileSaveError);
+        await ctx.database.remove("cave", { id: newId });
+        throw fileSaveError;
+      }
       if (newCave.status === "pending") {
         reviewManager.sendForReview(newCave);
         return `提交成功，序号为（${newCave.id}）`;
@@ -764,10 +650,6 @@ function apply(ctx, config) {
       return `添加成功，序号为（${newId}）`;
     } catch (error) {
       logger.error("添加回声洞失败:", error);
-      if (savedFileIdentifiers.length > 0) {
-        logger.info(`添加失败，回滚并删除 ${savedFileIdentifiers.length} 个文件...`);
-        await Promise.all(savedFileIdentifiers.map((fileId) => fileManager.deleteFile(fileId)));
-      }
       return "添加失败，请稍后再试";
     }
   });
@@ -778,9 +660,7 @@ function apply(ctx, config) {
     try {
       const query = { ...getScopeQuery(session, config), id };
       const [targetCave] = await ctx.database.get("cave", query);
-      if (!targetCave) {
-        return `回声洞（${id}）不存在`;
-      }
+      if (!targetCave) return `回声洞（${id}）不存在`;
       updateCooldownTimestamp(session, config, lastUsed);
       return buildCaveMessage(targetCave, config, fileManager, logger);
     } catch (error) {
@@ -793,18 +673,13 @@ function apply(ctx, config) {
     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 "抱歉，你没有权限删除这条回声洞";
+      if (targetCave.userId !== session.userId && session.channelId !== config.adminChannel) {
+        return "你没有权限删除这条回声洞";
       }
       await ctx.database.upsert("cave", [{ id, status: "delete" }]);
       const caveMessage = await buildCaveMessage(targetCave, config, fileManager, logger);
       cleanupPendingDeletions(ctx, fileManager, logger);
-      return [
-        `以下内容已删除`,
-        ...caveMessage
-      ];
+      return [`已删除`, ...caveMessage];
     } catch (error) {
       logger.error(`标记回声洞（${id}）失败:`, error);
       return "删除失败，请稍后再试";