koishi-plugin-best-cave 2.0.7 → 2.0.9

package/lib/DataManager.d.ts

@@ -3,8 +3,7 @@ import { FileManager } from './FileManager';
 import { Config } from './index';
 /**
  * @class DataManager
- * @description
- * 负责处理回声洞数据的导入和导出功能。
+ * @description 负责处理回声洞数据的导入和导出功能。
  */
 export declare class DataManager {
     private ctx;

package/lib/FileManager.d.ts

@@ -2,8 +2,7 @@ import { Logger } from 'koishi';
 import { Config } from './index';
 /**
  * @class FileManager
- * @description
- * 封装了对文件的存储、读取和删除操作。
+ * @description 封装了对文件的存储、读取和删除操作。
  * 能根据配置自动选择使用本地文件系统或 AWS S3 作为存储后端。
  * 内置 Promise 文件锁，防止本地文件的并发写入冲突。
  */

package/lib/ProfileManager.d.ts

@@ -15,8 +15,7 @@ declare module 'koishi' {
 }
 /**
  * @class ProfileManager
- * @description
- * 负责管理用户在回声洞中的自定义昵称。
+ * @description 负责管理用户在回声洞中的自定义昵称。
  * 当插件配置 `enableProfile` 为 true 时实例化。
  */
 export declare class ProfileManager {

package/lib/ReviewManager.d.ts

@@ -1,11 +1,9 @@
-import { Context, h, Logger } from 'koishi';
+import { Context, Logger } from 'koishi';
 import { CaveObject, Config } from './index';
 import { FileManager } from './FileManager';
 /**
  * @class ReviewManager
- * @description
- * 负责处理回声洞的审核流程。当 `enableReview` 配置开启时，
- * 此管理器将被激活，处理新洞的提交、审核通知和审核操作。
+ * @description 负责处理回声洞的审核流程，处理新洞的提交、审核通知和审核操作。
  */
 export declare class ReviewManager {
     private ctx;
@@ -26,7 +24,7 @@ export declare class ReviewManager {
      */
     registerCommands(cave: any): void;
     /**
-     * @description 将新回声洞提交给管理员审核。
+     * @description 将新回声洞提交到管理群组以供审核。
      * @param cave 新创建的、状态为 'pending' 的回声洞对象。
      */
     sendForReview(cave: CaveObject): Promise<void>;
@@ -34,8 +32,7 @@ export declare class ReviewManager {
      * @description 处理管理员的审核决定（通过或拒绝）。
      * @param action 'approve' (通过) 或 'reject' (拒绝)。
      * @param caveId 被审核的回声洞 ID。
-     * @param adminUserName 操作管理员的昵称。
      * @returns 返回给操作者的确认消息。
      */
-    processReview(action: 'approve' | 'reject', caveId: number, adminUserName: string): Promise<string | (string | h)[]>;
+    processReview(action: 'approve' | 'reject', caveId: number): Promise<string>;
 }

package/lib/Utils.d.ts

@@ -53,3 +53,32 @@ export declare function checkCooldown(session: Session, config: Config, lastUsed
  * @description 更新指定频道的指令使用时间戳。
  */
 export declare function updateCooldownTimestamp(session: Session, config: Config, lastUsed: Map<string, number>): void;
+/**
+ * @description 解析消息元素，分离出文本和待下载的媒体文件。
+ * @param sourceElements - 原始的 Koishi 消息元素数组。
+ * @param newId - 这条回声洞的新 ID。
+ * @param channelId - 频道 ID。
+ * @param userId - 用户 ID。
+ * @returns 一个包含数据库元素和待保存媒体列表的对象。
+ */
+export declare function processMessageElements(sourceElements: h[], newId: number, channelId: string, userId: string): Promise<{
+    finalElementsForDb: StoredElement[];
+    mediaToSave: {
+        sourceUrl: string;
+        fileName: string;
+    }[];
+}>;
+/**
+ * @description 异步处理文件上传和状态更新的后台任务。
+ * @param ctx - Koishi 上下文。
+ * @param config - 插件配置。
+ * @param fileManager - 文件管理器实例。
+ * @param logger - 日志记录器实例。
+ * @param reviewManager - 审核管理器实例 (可能为 null)。
+ * @param cave - 已创建的、状态为 'preload' 的回声洞对象。
+ * @param mediaToSave - 需要下载和保存的媒体文件列表。
+ */
+export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reviewManager: any, cave: CaveObject, mediaToSave: {
+    sourceUrl: string;
+    fileName: string;
+}[]): Promise<void>;

package/lib/index.d.ts

@@ -19,7 +19,7 @@ export interface CaveObject {
     channelId: string;
     userId: string;
     userName: string;
-    status: 'active' | 'delete' | 'pending';
+    status: 'active' | 'delete' | 'pending' | 'preload';
     time: Date;
 }
 declare module 'koishi' {
@@ -30,7 +30,7 @@ declare module 'koishi' {
 export interface Config {
     coolDown: number;
     perChannel: boolean;
-    adminUsers: string[];
+    adminChannel: string;
     enableProfile: boolean;
     enableIO: boolean;
     enableReview: boolean;

package/lib/index.js

@@ -37,8 +37,7 @@ __export(index_exports, {
   usage: () => usage
 });
 module.exports = __toCommonJS(index_exports);
-var import_koishi2 = require("koishi");
-var path3 = __toESM(require("path"));
+var import_koishi3 = require("koishi");
 
 // src/FileManager.ts
 var import_client_s3 = require("@aws-sdk/client-s3");
@@ -259,10 +258,14 @@ async function buildCaveMessage(cave, config, fileManager, logger2) {
   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);
+  if (headerText.trim()) {
+    finalMessage.push(headerText.trim() + "\n");
+  }
   finalMessage.push(...processedElements);
   const footerText = footerFormat.replace(/\{id\}|\{name\}/g, (match) => replacements[match.slice(1, -1)]);
-  if (footerText.trim()) finalMessage.push(footerText);
+  if (footerText.trim()) {
+    finalMessage.push("\n" + footerText.trim());
+  }
   return finalMessage;
 }
 __name(buildCaveMessage, "buildCaveMessage");
@@ -296,7 +299,7 @@ async function getNextCaveId(ctx, query = {}) {
 }
 __name(getNextCaveId, "getNextCaveId");
 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) {
@@ -312,6 +315,69 @@ function updateCooldownTimestamp(session, config, lastUsed) {
   }
 }
 __name(updateCooldownTimestamp, "updateCooldownTimestamp");
+async function processMessageElements(sourceElements, newId, channelId, userId) {
+  const finalElementsForDb = [];
+  const mediaToSave = [];
+  let mediaIndex = 0;
+  const typeMap = {
+    "img": "image",
+    "image": "image",
+    "video": "video",
+    "audio": "audio",
+    "file": "file",
+    "text": "text"
+  };
+  async function traverse(elements) {
+    for (const el of elements) {
+      const normalizedType = typeMap[el.type];
+      if (!normalizedType) {
+        if (el.children) await traverse(el.children);
+        continue;
+      }
+      if (["image", "video", "audio", "file"].includes(normalizedType) && el.attrs.src) {
+        let fileIdentifier = el.attrs.src;
+        if (fileIdentifier.startsWith("http")) {
+          mediaIndex++;
+          const defaultExtMap = { "image": ".jpg", "video": ".mp4", "audio": ".mp3", "file": ".dat" };
+          const ext = el.attrs.file && path2.extname(el.attrs.file) ? path2.extname(el.attrs.file) : defaultExtMap[normalizedType] || ".dat";
+          const channelIdentifier = channelId || "private";
+          const fileName = `${newId}_${mediaIndex}_${channelIdentifier}_${userId}${ext}`;
+          mediaToSave.push({ sourceUrl: fileIdentifier, fileName });
+          fileIdentifier = fileName;
+        }
+        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 traverse(el.children);
+      }
+    }
+  }
+  __name(traverse, "traverse");
+  await traverse(sourceElements);
+  return { finalElementsForDb, mediaToSave };
+}
+__name(processMessageElements, "processMessageElements");
+async function handleFileUploads(ctx, config, fileManager, logger2, reviewManager, cave, mediaToSave) {
+  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));
+    }));
+    const finalStatus = config.enableReview ? "pending" : "active";
+    await ctx.database.upsert("cave", [{ id: cave.id, status: finalStatus }]);
+    if (finalStatus === "pending" && reviewManager) {
+      const [finalCave] = await ctx.database.get("cave", { id: cave.id });
+      if (finalCave) reviewManager.sendForReview(finalCave);
+    }
+  } catch (fileSaveError) {
+    logger2.error(`回声洞（${cave.id}）文件保存失败:`, fileSaveError);
+    await ctx.database.upsert("cave", [{ id: cave.id, status: "delete" }]);
+    await cleanupPendingDeletions(ctx, fileManager, logger2);
+  }
+}
+__name(handleFileUploads, "handleFileUploads");
 
 // src/DataManager.ts
 var DataManager = class {
@@ -337,7 +403,8 @@ var DataManager = class {
    */
   registerCommands(cave) {
     cave.subcommand(".export", "导出回声洞数据").usage("将所有回声洞数据导出到 cave_export.json。").action(async ({ session }) => {
-      if (!this.config.adminUsers.includes(session.userId)) return "抱歉，你没有权限导出数据";
+      const adminChannelId = this.config.adminChannel ? this.config.adminChannel.split(":")[1] : null;
+      if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
       try {
         await session.send("正在导出数据，请稍候...");
         return await this.exportData();
@@ -347,7 +414,8 @@ var DataManager = class {
       }
     });
     cave.subcommand(".import", "导入回声洞数据").usage("从 cave_import.json 中导入回声洞数据。").action(async ({ session }) => {
-      if (!this.config.adminUsers.includes(session.userId)) return "抱歉，你没有权限导入数据";
+      const adminChannelId = this.config.adminChannel ? this.config.adminChannel.split(":")[1] : null;
+      if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
       try {
         await session.send("正在导入数据，请稍候...");
         return await this.importData();
@@ -390,10 +458,8 @@ var DataManager = class {
       const newCave = {
         ...cave,
         id: newId,
-        channelId: cave.channelId || null,
-        // 保证 channelId 存在
+        channelId: cave.channelId,
         status: "active"
-        // 导入的数据直接设为活跃状态
       };
       await this.ctx.database.create("cave", newCave);
       successCount++;
@@ -403,6 +469,7 @@ var DataManager = class {
 };
 
 // src/ReviewManager.ts
+var import_koishi2 = require("koishi");
 var ReviewManager = class {
   /**
    * @constructor
@@ -426,7 +493,8 @@ var ReviewManager = class {
    */
   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 "抱歉，你没有权限执行审核";
+      const adminChannelId = this.config.adminChannel ? this.config.adminChannel.split(":")[1] : null;
+      if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
       if (!id) {
         const pendingCaves = await this.ctx.database.get("cave", { status: "pending" });
         if (pendingCaves.length === 0) return "当前没有需要审核的回声洞";
@@ -445,53 +513,45 @@ ${pendingCaves.map((c) => c.id).join(", ")}`;
       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);
     });
   }
   /**
-   * @description 将新回声洞提交给管理员审核。
+   * @description 将新回声洞提交到管理群组以供审核。
    * @param cave 新创建的、状态为 'pending' 的回声洞对象。
    */
   async sendForReview(cave) {
-    if (!this.config.adminUsers?.length) {
-      this.logger.warn(`未配置管理员，回声洞（${cave.id}）已自动通过审核`);
+    const channelParts = this.config.adminChannel?.split(":");
+    if (!channelParts || channelParts.length < 2 || !channelParts[1]) {
+      this.logger.warn(`管理群组配置无效，已自动通过回声洞（${cave.id}）`);
       await this.ctx.database.upsert("cave", [{ id: cave.id, status: "active" }]);
       return;
     }
     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);
     }
   }
   /**
    * @description 处理管理员的审核决定（通过或拒绝）。
    * @param action 'approve' (通过) 或 'reject' (拒绝)。
    * @param caveId 被审核的回声洞 ID。
-   * @param adminUserName 操作管理员的昵称。
    * @returns 返回给操作者的确认消息。
    */
-  async processReview(action, caveId, adminUserName) {
+  async processReview(action, caveId) {
     const [cave] = await this.ctx.database.get("cave", { id: caveId, status: "pending" });
-    if (!cave) return `回声洞（${caveId}）不存在或无需审核`;
+    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" }]);
       resultMessage = `回声洞（${caveId}）已拒绝`;
-      broadcastMessage = `回声洞（${caveId}）已由管理员 "${adminUserName}" 拒绝`;
       cleanupPendingDeletions(this.ctx, this.fileManager, this.logger);
     }
-    if (this.config.adminUsers?.length) {
-      this.ctx.broadcast(this.config.adminUsers, broadcastMessage).catch((err) => {
-        this.logger.error(`广播回声洞（${cave.id}）审核结果失败:`, err);
-      });
-    }
     return resultMessage;
   }
 };
@@ -511,28 +571,28 @@ var usage = `
   <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().default("onebot:").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) {
@@ -578,85 +638,58 @@ function apply(ctx, config) {
       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 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 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 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: 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);
-          }
-        }
-      }
-      __name(traverseAndProcess, "traverseAndProcess");
-      await traverseAndProcess(sourceElements);
+      const { finalElementsForDb, mediaToSave } = await processMessageElements(
+        sourceElements,
+        newId,
+        session.channelId,
+        session.userId
+      );
       if (finalElementsForDb.length === 0) return "内容为空，已取消添加";
       const customNickname = config.enableProfile ? await profileManager.getNickname(session.userId) : null;
-      const newCave = {
-        id: newId,
-        elements: finalElementsForDb,
-        channelId: session.channelId,
-        userId: session.userId,
-        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}）`;
+      const userName = customNickname || session.username;
+      if (mediaToSave.length > 0) {
+        const newCave = {
+          id: newId,
+          elements: finalElementsForDb,
+          channelId: session.channelId,
+          userId: session.userId,
+          userName,
+          status: "preload",
+          time: /* @__PURE__ */ new Date()
+        };
+        await ctx.database.create("cave", newCave);
+        handleFileUploads(ctx, config, fileManager, logger, reviewManager, newCave, mediaToSave);
+        return config.enableReview ? `提交成功，序号为（${newId}）` : `添加成功，序号为（${newId}）`;
+      } else {
+        const finalStatus = config.enableReview ? "pending" : "active";
+        const newCave = {
+          id: newId,
+          elements: finalElementsForDb,
+          channelId: session.channelId,
+          userId: session.userId,
+          userName,
+          status: finalStatus,
+          time: /* @__PURE__ */ new Date()
+        };
+        await ctx.database.create("cave", newCave);
+        if (finalStatus === "pending") {
+          reviewManager.sendForReview(newCave);
+          return `提交成功，序号为（${newId}）`;
+        }
+        return `添加成功，序号为（${newId}）`;
       }
-      return `添加成功，序号为（${newId}）`;
     } catch (error) {
       logger.error("添加回声洞失败:", error);
       return "添加失败，请稍后再试";
@@ -682,8 +715,9 @@ function apply(ctx, config) {
     try {
       const [targetCave] = await ctx.database.get("cave", { id, status: "active" });
       if (!targetCave) return `回声洞（${id}）不存在`;
-      if (targetCave.userId !== session.userId && !config.adminUsers.includes(session.userId)) {
-        return "抱歉，你没有权限删除这条回声洞";
+      const adminChannelId = config.adminChannel ? config.adminChannel.split(":")[1] : null;
+      if (targetCave.userId !== session.userId && session.channelId !== adminChannelId) {
+        return "你没有权限删除这条回声洞";
       }
       await ctx.database.upsert("cave", [{ id, status: "delete" }]);
       const caveMessage = await buildCaveMessage(targetCave, config, fileManager, logger);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "最强大的回声洞现已重构完成啦！注意数据格式需要使用脚本转换哦~",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],