koishi-plugin-best-cave 2.7.2 → 2.7.4

package/lib/Utils.d.ts

@@ -2,8 +2,6 @@ import { Context, h, Logger, Session } from 'koishi';
 import { CaveObject, Config, StoredElement } from './index';
 import { FileManager } from './FileManager';
 import { HashManager, CaveHashObject } from './HashManager';
-import { PendManager } from './PendManager';
-import { AIManager } from './AIManager';
 /**
  * @description 构建一条用于发送的完整回声洞消息，处理不同存储后端的资源链接。
  * @param cave 回声洞对象。
@@ -69,22 +67,25 @@ export declare function performSimilarityChecks(ctx: Context, config: Config, ha
     imageHashesToStore?: Omit<CaveHashObject, 'cave'>[];
 }>;
 /**
- * @description 异步处理文件上传和状态更新的后台任务。
+ * @description 异步处理文件上传，并在成功后更新回声洞状态。
  * @param ctx - Koishi 上下文。
  * @param config - 插件配置。
  * @param fileManager - FileManager 实例，用于保存文件。
  * @param logger - 日志记录器实例。
- * @param reviewManager - ReviewManager 实例，用于提交审核。
  * @param cave - 刚刚在数据库中创建的 `preload` 状态的回声洞对象。
  * @param downloadedMedia - 需要保存的媒体文件及其 Buffer。
  * @param reusableIds - 可复用 ID 的内存缓存。
- * @param session - 触发此操作的用户会话，用于发送反馈。
- * @param hashManager - HashManager 实例，如果启用则用于哈希计算和比较。
- * @param textHashesToStore - 已预先计算好的、待存入数据库的文本哈希对象数组。
- * @param imageHashesToStore - 已预先计算好的、待存入数据库的图片哈希对象数组。
- * @param aiManager - AIManager 实例，如果启用则用于 AI 分析。
+ * @param session - 触发此操作的用户会话。
+ * @returns 成功则返回最终状态 ('pending' or 'active')，失败则返回 'delete'。
  */
-export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reviewManager: PendManager, cave: CaveObject, downloadedMedia: {
+export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, cave: CaveObject, downloadedMedia: {
     fileName: string;
     buffer: Buffer;
-}[], reusableIds: Set<number>, session: Session, hashManager: HashManager, textHashesToStore: Omit<CaveHashObject, 'cave'>[], imageHashesToStore: Omit<CaveHashObject, 'cave'>[], aiManager: AIManager | null): Promise<void>;
+}[], reusableIds: Set<number>, session: Session): Promise<'pending' | 'active' | 'delete'>;
+/**
+ * @description 校验会话是否来自指定的管理群组。
+ * @param session 当前会话。
+ * @param config 插件配置。
+ * @returns 如果校验不通过，返回错误信息字符串；如果通过，返回 null。
+ */
+export declare function requireAdmin(session: Session, config: Config): string | null;

package/lib/index.js

@@ -206,100 +206,6 @@ var NameManager = class {
   }
 };
 
-// src/DataManager.ts
-var DataManager = class {
-  /**
-   * @constructor
-   * @param ctx Koishi 上下文，用于数据库操作。
-   * @param config 插件配置。
-   * @param fileManager 文件管理器实例。
-   * @param logger 日志记录器实例。
-   */
-  constructor(ctx, config, fileManager, logger2) {
-    this.ctx = ctx;
-    this.config = config;
-    this.fileManager = fileManager;
-    this.logger = logger2;
-  }
-  static {
-    __name(this, "DataManager");
-  }
-  /**
-   * @description 注册 `.export` 和 `.import` 子命令。
-   * @param cave - 主 `cave` 命令实例。
-   */
-  registerCommands(cave) {
-    const requireAdmin = /* @__PURE__ */ __name((action) => async ({ session }) => {
-      if (session.channelId !== this.config.adminChannel?.split(":")[1]) return "此指令仅限在管理群组中使用";
-      try {
-        await session.send("正在处理，请稍候...");
-        return await action();
-      } catch (error) {
-        this.logger.error("数据操作时发生错误:", error);
-        return `操作失败: ${error.message}`;
-      }
-    }, "requireAdmin");
-    cave.subcommand(".export", "导出回声洞数据", { hidden: true, authority: 4 }).usage("将所有回声洞数据导出到 cave.json 中。").action(requireAdmin(() => this.exportData()));
-    cave.subcommand(".import", "导入回声洞数据", { hidden: true, authority: 4 }).usage("从 cave.json 中导入回声洞数据。").action(requireAdmin(() => this.importData()));
-  }
-  /**
-   * @description 导出所有 'active' 状态的回声洞数据到 `cave.json`。
-   * @returns 描述导出结果的消息字符串。
-   */
-  async exportData() {
-    const fileName = "cave.json";
-    const cavesToExport = await this.ctx.database.get("cave", { status: "active" });
-    await this.fileManager.saveFile(fileName, Buffer.from(JSON.stringify(cavesToExport, null, 2)));
-    return `成功导出 ${cavesToExport.length} 条数据`;
-  }
-  /**
-   * @description 从 `cave.json` 文件导入回声洞数据。
-   * @returns 描述导入结果的消息字符串。
-   */
-  async importData() {
-    const fileName = "cave.json";
-    let importedCaves;
-    try {
-      const fileContent = await this.fileManager.readFile(fileName);
-      importedCaves = JSON.parse(fileContent.toString("utf-8"));
-      if (!Array.isArray(importedCaves) || !importedCaves.length) throw new Error("导入文件格式无效或为空");
-    } catch (error) {
-      throw new Error(`读取导入文件失败: ${error.message}`);
-    }
-    const allDbCaves = await this.ctx.database.get("cave", {}, { fields: ["id"] });
-    const existingIds = new Set(allDbCaves.map((c) => c.id));
-    let maxId = allDbCaves.length > 0 ? Math.max(...allDbCaves.map((c) => c.id)) : 0;
-    const nonConflictingCaves = [];
-    const conflictingCaves = [];
-    let invalidCount = 0;
-    for (const importedCave of importedCaves) {
-      if (typeof importedCave.id !== "number" || !Array.isArray(importedCave.elements)) {
-        this.logger.warn(`回声洞（${importedCave.id}）无效: ${JSON.stringify(importedCave)}`);
-        invalidCount++;
-        continue;
-      }
-      if (existingIds.has(importedCave.id)) {
-        conflictingCaves.push(importedCave);
-      } else {
-        nonConflictingCaves.push({ ...importedCave, status: "active" });
-        existingIds.add(importedCave.id);
-        maxId = Math.max(maxId, importedCave.id);
-      }
-    }
-    const newCavesFromConflicts = conflictingCaves.map((cave) => {
-      maxId++;
-      this.logger.info(`回声洞（${cave.id}）已转移至（${maxId}）`);
-      return { ...cave, id: maxId, status: "active" };
-    });
-    const finalCavesToUpsert = [...nonConflictingCaves, ...newCavesFromConflicts];
-    if (finalCavesToUpsert.length > 0) await this.ctx.database.upsert("cave", finalCavesToUpsert);
-    return `成功导入 ${finalCavesToUpsert.length} 条数据`;
-  }
-};
-
-// src/PendManager.ts
-var import_koishi2 = require("koishi");
-
 // src/Utils.ts
 var import_koishi = require("koishi");
 var path2 = __toESM(require("path"));
@@ -576,30 +482,121 @@ async function performSimilarityChecks(ctx, config, hashManager, finalElementsFo
   return { duplicate: false, textHashesToStore, imageHashesToStore };
 }
 __name(performSimilarityChecks, "performSimilarityChecks");
-async function handleFileUploads(ctx, config, fileManager, logger2, reviewManager, cave, downloadedMedia, reusableIds, session, hashManager, textHashesToStore, imageHashesToStore, aiManager) {
+async function handleFileUploads(ctx, config, fileManager, logger2, cave, downloadedMedia, reusableIds, session) {
   try {
-    if (aiManager) await aiManager.analyzeAndStore(cave, downloadedMedia);
     await Promise.all(downloadedMedia.map((item) => fileManager.saveFile(item.fileName, item.buffer)));
     const needsReview = config.enablePend && session.channelId !== config.adminChannel?.split(":")[1];
     const finalStatus = needsReview ? "pending" : "active";
     await ctx.database.upsert("cave", [{ id: cave.id, status: finalStatus }]);
-    if (hashManager) {
-      const allHashesToInsert = [...textHashesToStore, ...imageHashesToStore].map((h5) => ({ ...h5, cave: cave.id }));
-      if (allHashesToInsert.length > 0) await ctx.database.upsert("cave_hash", allHashesToInsert);
-    }
-    if (finalStatus === "pending" && reviewManager) {
-      const [finalCave] = await ctx.database.get("cave", { id: cave.id });
-      if (finalCave) reviewManager.sendForPend(finalCave);
-    }
+    return finalStatus;
   } catch (fileProcessingError) {
     logger2.error(`回声洞（${cave.id}）文件处理失败:`, fileProcessingError);
     await ctx.database.upsert("cave", [{ id: cave.id, status: "delete" }]);
     cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds);
+    return "delete";
   }
 }
 __name(handleFileUploads, "handleFileUploads");
+function requireAdmin(session, config) {
+  if (session.cid !== config.adminChannel) return "此指令仅限在管理群组中使用";
+  return null;
+}
+__name(requireAdmin, "requireAdmin");
+
+// src/DataManager.ts
+var DataManager = class {
+  /**
+   * @constructor
+   * @param ctx Koishi 上下文，用于数据库操作。
+   * @param config 插件配置。
+   * @param fileManager 文件管理器实例。
+   * @param logger 日志记录器实例。
+   */
+  constructor(ctx, config, fileManager, logger2) {
+    this.ctx = ctx;
+    this.config = config;
+    this.fileManager = fileManager;
+    this.logger = logger2;
+  }
+  static {
+    __name(this, "DataManager");
+  }
+  /**
+   * @description 注册 `.export` 和 `.import` 子命令。
+   * @param cave - 主 `cave` 命令实例。
+   */
+  registerCommands(cave) {
+    const commandAction = /* @__PURE__ */ __name((action) => async ({ session }) => {
+      const adminError = requireAdmin(session, this.config);
+      if (adminError) return adminError;
+      try {
+        await session.send("正在处理，请稍候...");
+        return await action();
+      } catch (error) {
+        this.logger.error("数据操作时发生错误:", error);
+        return `操作失败: ${error.message}`;
+      }
+    }, "commandAction");
+    cave.subcommand(".export", "导出回声洞数据", { hidden: true, authority: 4 }).usage("将所有回声洞数据导出到 cave.json 中。").action(commandAction(() => this.exportData()));
+    cave.subcommand(".import", "导入回声洞数据", { hidden: true, authority: 4 }).usage("从 cave.json 中导入回声洞数据。").action(commandAction(() => this.importData()));
+  }
+  /**
+   * @description 导出所有 'active' 状态的回声洞数据到 `cave.json`。
+   * @returns 描述导出结果的消息字符串。
+   */
+  async exportData() {
+    const fileName = "cave.json";
+    const cavesToExport = await this.ctx.database.get("cave", { status: "active" });
+    await this.fileManager.saveFile(fileName, Buffer.from(JSON.stringify(cavesToExport, null, 2)));
+    return `成功导出 ${cavesToExport.length} 条数据`;
+  }
+  /**
+   * @description 从 `cave.json` 文件导入回声洞数据。
+   * @returns 描述导入结果的消息字符串。
+   */
+  async importData() {
+    const fileName = "cave.json";
+    let importedCaves;
+    try {
+      const fileContent = await this.fileManager.readFile(fileName);
+      importedCaves = JSON.parse(fileContent.toString("utf-8"));
+      if (!Array.isArray(importedCaves) || !importedCaves.length) throw new Error("导入文件格式无效或为空");
+    } catch (error) {
+      throw new Error(`读取导入文件失败: ${error.message}`);
+    }
+    const allDbCaves = await this.ctx.database.get("cave", {}, { fields: ["id"] });
+    const existingIds = new Set(allDbCaves.map((c) => c.id));
+    let maxId = allDbCaves.length > 0 ? Math.max(...allDbCaves.map((c) => c.id)) : 0;
+    const nonConflictingCaves = [];
+    const conflictingCaves = [];
+    let invalidCount = 0;
+    for (const importedCave of importedCaves) {
+      if (typeof importedCave.id !== "number" || !Array.isArray(importedCave.elements)) {
+        this.logger.warn(`回声洞（${importedCave.id}）无效: ${JSON.stringify(importedCave)}`);
+        invalidCount++;
+        continue;
+      }
+      if (existingIds.has(importedCave.id)) {
+        conflictingCaves.push(importedCave);
+      } else {
+        nonConflictingCaves.push({ ...importedCave, status: "active" });
+        existingIds.add(importedCave.id);
+        maxId = Math.max(maxId, importedCave.id);
+      }
+    }
+    const newCavesFromConflicts = conflictingCaves.map((cave) => {
+      maxId++;
+      this.logger.info(`回声洞（${cave.id}）已转移至（${maxId}）`);
+      return { ...cave, id: maxId, status: "active" };
+    });
+    const finalCavesToUpsert = [...nonConflictingCaves, ...newCavesFromConflicts];
+    if (finalCavesToUpsert.length > 0) await this.ctx.database.upsert("cave", finalCavesToUpsert);
+    return `成功导入 ${finalCavesToUpsert.length} 条数据`;
+  }
+};
 
 // src/PendManager.ts
+var import_koishi2 = require("koishi");
 var PendManager = class {
   /**
    * @param ctx Koishi 上下文。
@@ -623,12 +620,8 @@ var PendManager = class {
    * @param cave - 主 `cave` 命令实例。
    */
   registerCommands(cave) {
-    const requireAdmin = /* @__PURE__ */ __name((session) => {
-      if (session.channelId !== this.config.adminChannel?.split(":")[1]) return "此指令仅限在管理群组中使用";
-      return null;
-    }, "requireAdmin");
     const pend = cave.subcommand(".pend [id:posint]", "审核回声洞", { hidden: true }).usage("查询待审核的回声洞列表，或指定 ID 查看对应待审核的回声洞。").action(async ({ session }, id) => {
-      const adminError = requireAdmin(session);
+      const adminError = requireAdmin(session, this.config);
       if (adminError) return adminError;
       if (id) {
         const [targetCave] = await this.ctx.database.get("cave", { id });
@@ -644,7 +637,7 @@ var PendManager = class {
 ${pendingCaves.map((c) => c.id).join("|")}`;
     });
     const createPendAction = /* @__PURE__ */ __name((actionType) => async ({ session }, ...ids) => {
-      const adminError = requireAdmin(session);
+      const adminError = requireAdmin(session, this.config);
       if (adminError) return adminError;
       let idsToProcess = ids;
       if (idsToProcess.length === 0) {
@@ -1015,7 +1008,8 @@ var AIManager = class {
    */
   registerCommands(cave) {
     cave.subcommand(".ai", "分析回声洞", { hidden: true, authority: 4 }).usage("分析尚未分析的回声洞，补全回声洞记录。").action(async ({ session }) => {
-      if (session.channelId !== this.config.adminChannel?.split(":")[1]) return "此指令仅限在管理群组中使用";
+      const adminError = requireAdmin(session, this.config);
+      if (adminError) return adminError;
       try {
         const allCaves = await this.ctx.database.get("cave", { status: "active" });
         const analyzedCaveIds = new Set((await this.ctx.database.get("cave_meta", {})).map((meta) => meta.cave));
@@ -1078,7 +1072,8 @@ var AIManager = class {
       }
       if (potentialDuplicates.length === 0) return { duplicate: false };
       const { payload } = await this.prepareDedupePayload(newElements, potentialDuplicates);
-      const response = await this.http.post(`${this.config.aiEndpoint}:generateContent?key=${this.config.aiApiKey}`, payload, { headers: { "Content-Type": "application/json" }, timeout: 9e4 });
+      const fullUrl = `${this.config.aiEndpoint}/models/${this.config.aiModel}:generateContent?key=${this.config.aiApiKey}`;
+      const response = await this.http.post(fullUrl, payload, { headers: { "Content-Type": "application/json" }, timeout: 9e4 });
       return this.parseDedupeResponse(response);
     } catch (error) {
       this.logger.error("查重回声洞出错:", error);
@@ -1097,6 +1092,7 @@ var AIManager = class {
       if (analysisResult) await this.ctx.database.upsert("cave_meta", [{ cave: cave.id, ...analysisResult }]);
     } catch (error) {
       this.logger.error(`分析回声洞（${cave.id}）失败:`, error);
+      throw error;
     }
   }
   /**
@@ -1109,7 +1105,8 @@ var AIManager = class {
   async getAnalysis(elements, mediaToSave, mediaBuffers) {
     const { payload } = await this.preparePayload(this.config.AnalysePrompt, this.config.aiAnalyseSchema, elements, mediaToSave, mediaBuffers);
     if (!payload.contents) return null;
-    const response = await this.http.post(`${this.config.aiEndpoint}:generateContent?key=${this.config.aiApiKey}`, payload, { headers: { "Content-Type": "application/json" }, timeout: 6e4 });
+    const fullUrl = `${this.config.aiEndpoint}/models/${this.config.aiModel}:generateContent?key=${this.config.aiApiKey}`;
+    const response = await this.http.post(fullUrl, payload, { headers: { "Content-Type": "application/json" }, timeout: 6e4 });
     return this.parseAnalysisResponse(response);
   }
   /**
@@ -1160,9 +1157,17 @@ var AIManager = class {
     if (parts.length <= 1) return { payload: {} };
     try {
       const schema = JSON.parse(schemaString);
-      return { payload: { contents: [{ parts }], generationConfig: { response_schema: schema } } };
+      return {
+        payload: {
+          contents: [{ parts }],
+          generationConfig: {
+            responseMimeType: "application/json",
+            responseSchema: schema
+          }
+        }
+      };
     } catch (error) {
-      this.logger.error("解析JSON Schema失败:", error);
+      this.logger.error("分析 JSON Schema 解析失败:", error);
       return { payload: {} };
     }
   }
@@ -1178,15 +1183,20 @@ var AIManager = class {
       new_content: { text: formatContent(newElements) },
       existing_contents: existingCaves.map((cave) => ({ id: cave.id, text: formatContent(cave.elements) }))
     });
-    const fullPrompt = `${this.config.aiCheckPrompt}
-
-以下是需要处理的数据:
-${payloadContent}`;
+    const parts = [{ text: this.config.aiCheckPrompt }, { text: payloadContent }];
     try {
       const schema = JSON.parse(this.config.aiCheckSchema);
-      return { payload: { contents: [{ parts: [{ text: fullPrompt }] }], generationConfig: { response_schema: schema } } };
+      return {
+        payload: {
+          contents: [{ parts }],
+          generationConfig: {
+            responseMimeType: "application/json",
+            responseSchema: schema
+          }
+        }
+      };
     } catch (error) {
-      this.logger.error("解析查重JSON Schema失败:", error);
+      this.logger.error("查重 JSON Schema 解析失败:", error);
       return { payload: {} };
     }
   }
@@ -1197,7 +1207,8 @@ ${payloadContent}`;
    */
   parseAnalysisResponse(response) {
     try {
-      const content = response.candidates.content.parts.text;
+      if (!response?.candidates?.[0]?.content?.parts?.[0]?.text) throw new Error("分析响应解析失败");
+      const content = response.candidates[0].content.parts[0].text;
       const parsed = JSON.parse(content);
       const keywords = Array.isArray(parsed.keywords) ? parsed.keywords : [];
       return {
@@ -1207,7 +1218,7 @@ ${payloadContent}`;
       };
     } catch (error) {
       this.logger.error("分析响应解析失败:", error, "原始响应:", JSON.stringify(response));
-      return { keywords: [], description: "解析失败", rating: 0 };
+      throw error;
     }
   }
   /**
@@ -1217,13 +1228,14 @@ ${payloadContent}`;
    */
   parseDedupeResponse(response) {
     try {
-      const content = response.candidates.content.parts.text;
+      if (!response?.candidates?.[0]?.content?.parts?.[0]?.text) throw new Error("查重响应解析失败");
+      const content = response.candidates[0].content.parts[0].text;
       const parsed = JSON.parse(content);
       if (parsed.duplicate === true && parsed.id) return { duplicate: true, id: Number(parsed.id) };
       return { duplicate: false };
     } catch (error) {
       this.logger.error("查重响应解析失败:", error, "原始响应:", JSON.stringify(response));
-      return { duplicate: false };
+      throw error;
     }
   }
 };
@@ -1405,22 +1417,25 @@ function apply(ctx, config) {
       }
       const userName = (config.enableName ? await profileManager.getNickname(session.userId) : null) || session.username;
       const needsReview = config.enablePend && session.channelId !== config.adminChannel?.split(":")[1];
-      const initialStatus = hasMedia ? "preload" : needsReview ? "pending" : "active";
+      let finalStatus = hasMedia ? "preload" : needsReview ? "pending" : "active";
       const newCave = await ctx.database.create("cave", {
         id: newId,
         elements: finalElementsForDb,
         channelId: session.channelId,
         userId: session.userId,
         userName,
-        status: initialStatus,
+        status: finalStatus,
         time: creationTime
       });
-      if (hasMedia) {
-        handleFileUploads(ctx, config, fileManager, logger, reviewManager, newCave, downloadedMedia, reusableIds, session, hashManager, textHashesToStore, imageHashesToStore, aiManager);
-      } else {
-        if (aiManager) await aiManager.analyzeAndStore(newCave);
-        if (hashManager && textHashesToStore.length > 0) await ctx.database.upsert("cave_hash", textHashesToStore.map((h5) => ({ ...h5, cave: newCave.id })));
-        if (initialStatus === "pending") reviewManager.sendForPend(newCave);
+      if (hasMedia) finalStatus = await handleFileUploads(ctx, config, fileManager, logger, newCave, downloadedMedia, reusableIds, session);
+      if (finalStatus !== "preload" && finalStatus !== "delete") {
+        newCave.status = finalStatus;
+        if (aiManager) await aiManager.analyzeAndStore(newCave, downloadedMedia);
+        if (hashManager) {
+          const allHashesToInsert = [...textHashesToStore, ...imageHashesToStore].map((h5) => ({ ...h5, cave: newCave.id }));
+          if (allHashesToInsert.length > 0) await ctx.database.upsert("cave_hash", allHashesToInsert);
+        }
+        if (finalStatus === "pending" && reviewManager) reviewManager.sendForPend(newCave);
       }
       return needsReview ? `提交成功，序号为（${newCave.id}）` : `添加成功，序号为（${newCave.id}）`;
     } catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "功能强大、高度可定制的回声洞。支持丰富的媒体类型、内容查重、人工审核、用户昵称、数据迁移以及本地/S3 双重文件存储后端。",
-  "version": "2.7.2",
+  "version": "2.7.4",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],