koishi-plugin-best-cave 2.3.3 → 2.3.5

package/lib/DataManager.d.ts

@@ -0,0 +1,39 @@
+import { Context, Logger } from 'koishi';
+import { FileManager } from './FileManager';
+import { HashManager } from './HashManager';
+import { Config } from './index';
+/**
+ * @class DataManager
+ * @description 负责处理回声洞数据的导入和导出功能。
+ */
+export declare class DataManager {
+    private ctx;
+    private config;
+    private fileManager;
+    private logger;
+    private hashManager;
+    /**
+     * @constructor
+     * @param ctx Koishi 上下文，用于数据库操作。
+     * @param config 插件配置。
+     * @param fileManager 文件管理器实例。
+     * @param logger 日志记录器实例。
+     * @param hashManager 哈希管理器实例，用于增量更新哈希。
+     */
+    constructor(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, hashManager: HashManager | null);
+    /**
+     * @description 注册 `.export` 和 `.import` 子命令。
+     * @param cave - 主 `cave` 命令实例。
+     */
+    registerCommands(cave: any): void;
+    /**
+     * @description 导出所有 'active' 状态的回声洞数据到 `cave_export.json`。
+     * @returns 描述导出结果的消息字符串。
+     */
+    exportData(): Promise<string>;
+    /**
+     * @description 从 `cave_import.json` 文件导入回声洞数据。
+     * @returns 描述导入结果的消息字符串。
+     */
+    importData(): Promise<string>;
+}

package/lib/FileManager.d.ts

@@ -0,0 +1,48 @@
+import { Logger } from 'koishi';
+import { Config } from './index';
+/**
+ * @class FileManager
+ * @description 封装了对文件的存储、读取和删除操作。
+ * 能根据配置自动选择使用本地文件系统或 AWS S3 作为存储后端。
+ * 内置 Promise 文件锁，防止本地文件的并发写入冲突。
+ */
+export declare class FileManager {
+    private logger;
+    private resourceDir;
+    private locks;
+    private s3Client?;
+    private s3Bucket?;
+    /**
+     * @constructor
+     * @param baseDir Koishi 应用的基础数据目录 (ctx.baseDir)。
+     * @param config 插件的配置对象。
+     * @param logger 日志记录器实例。
+     */
+    constructor(baseDir: string, config: Config, logger: Logger);
+    /**
+     * @description 使用文件锁安全地执行异步文件操作，防止并发读写冲突。
+     * @template T 异步操作的返回类型。
+     * @param fullPath 需要加锁的文件的完整路径。
+     * @param operation 要执行的异步函数。
+     * @returns 异步操作的结果。
+     */
+    private withLock;
+    /**
+     * @description 保存文件，自动选择 S3 或本地存储。
+     * @param fileName 用作 S3 Key 或本地文件名。
+     * @param data 要写入的 Buffer 数据。
+     * @returns 保存时使用的文件名。
+     */
+    saveFile(fileName: string, data: Buffer): Promise<string>;
+    /**
+     * @description 读取文件，自动从 S3 或本地存储读取。
+     * @param fileName 要读取的文件名/标识符。
+     * @returns 文件的 Buffer 数据。
+     */
+    readFile(fileName: string): Promise<Buffer>;
+    /**
+     * @description 删除文件，自动从 S3 或本地删除。
+     * @param fileIdentifier 要删除的文件名/标识符。
+     */
+    deleteFile(fileIdentifier: string): Promise<void>;
+}

package/lib/Utils.d.ts

@@ -3,12 +3,6 @@ import { CaveObject, Config, StoredElement } from './index';
 import { FileManager } from './FileManager';
 import { HashManager, CaveHashObject } from './HashManager';
 import { PendManager } from './PendManager';
-/**
- * @description 将数据库存储的 StoredElement[] 转换为 Koishi 的 h() 元素数组。
- * @param elements 从数据库读取的元素数组。
- * @returns 转换后的 h() 元素数组。
- */
-export declare function storedFormatToHElements(elements: StoredElement[]): h[];
 /**
  * @description 构建一条用于发送的完整回声洞消息，处理不同存储后端的资源链接。
  * @param cave 回声洞对象。

package/lib/index.d.ts

@@ -7,7 +7,7 @@ export declare const usage = "\n<div style=\"border-radius: 10px; border: 1px so
  * @description 存储在数据库中的单个消息元素。
  */
 export interface StoredElement {
-    type: 'text' | 'image' | 'video' | 'audio' | 'file';
+    type: 'text' | 'image' | 'video' | 'audio' | 'file' | 'at' | 'forward';
     content?: string;
     file?: string;
 }

package/lib/index.js

@@ -28,15 +28,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   Config: () => Config,
   apply: () => apply,
   inject: () => inject,
   name: () => name,
   usage: () => usage
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 var import_koishi3 = require("koishi");
 
 // src/FileManager.ts
@@ -294,40 +294,48 @@ var import_koishi2 = require("koishi");
 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) => {
-    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 buildCaveMessage(cave, config, fileManager, logger2) {
-  const caveHElements = storedFormatToHElements(cave.elements);
-  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 element;
-    if (config.enableS3 && config.publicUrl) {
-      return (0, import_koishi.h)(element.type, { ...element.attrs, src: new URL(fileName, config.publicUrl).href });
-    }
-    if (config.localPath) {
-      return (0, import_koishi.h)(element.type, { ...element.attrs, src: `file://${path2.join(config.localPath, fileName)}` });
-    }
-    try {
-      const data = await fileManager.readFile(fileName);
-      const mimeType = mimeTypeMap[path2.extname(fileName).toLowerCase()] || "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}]`);
-    }
-  }));
+  async function transformToH(elements) {
+    return Promise.all(elements.map(async (el) => {
+      if (el.type === "text") return import_koishi.h.text(el.content);
+      if (el.type === "at") return (0, import_koishi.h)("at", { id: el.content });
+      if (el.type === "forward") {
+        try {
+          const children = JSON.parse(el.content || "[]");
+          return (0, import_koishi.h)("forward", {}, await transformToH(children));
+        } catch (error) {
+          logger2.warn(`解析回声洞（${cave.id}）合并转发内容失败:`, error);
+          return import_koishi.h.text("[合并转发]");
+        }
+      }
+      if (["image", "video", "audio", "file"].includes(el.type)) {
+        const fileName = el.file;
+        if (!fileName) return (0, import_koishi.h)("p", {}, `[${el.type}]`);
+        if (config.enableS3 && config.publicUrl) {
+          return (0, import_koishi.h)(el.type, { ...el, src: new URL(fileName, config.publicUrl).href });
+        }
+        if (config.localPath) {
+          return (0, import_koishi.h)(el.type, { ...el, src: `file://${path2.join(config.localPath, fileName)}` });
+        }
+        try {
+          const data = await fileManager.readFile(fileName);
+          const mimeType = mimeTypeMap[path2.extname(fileName).toLowerCase()] || "application/octet-stream";
+          return (0, import_koishi.h)(el.type, { ...el, src: `data:${mimeType};base64,${data.toString("base64")}` });
+        } catch (error) {
+          logger2.warn(`转换文件 ${fileName} 为 Base64 失败:`, error);
+          return (0, import_koishi.h)("p", {}, `[${el.type}]`);
+        }
+      }
+      return null;
+    })).then((hElements) => hElements.filter(Boolean));
+  }
+  __name(transformToH, "transformToH");
+  const caveHElements = await transformToH(cave.elements);
   const replacements = { id: cave.id.toString(), name: cave.userName };
   const [header, footer] = config.caveFormat.split("|", 2).map((part) => part.replace(/\{id\}|\{name\}/g, (match) => replacements[match.slice(1, -1)]).trim());
   const finalMessage = [];
   if (header) finalMessage.push(header + "\n");
-  finalMessage.push(...processedElements);
+  finalMessage.push(...caveHElements);
   if (footer) finalMessage.push("\n" + footer);
   return finalMessage;
 }
@@ -399,35 +407,55 @@ function updateCooldownTimestamp(session, config, lastUsed) {
 }
 __name(updateCooldownTimestamp, "updateCooldownTimestamp");
 async function processMessageElements(sourceElements, newId, session) {
-  const finalElementsForDb = [];
   const mediaToSave = [];
   let mediaIndex = 0;
-  const typeMap = { "img": "image", "image": "image", "video": "video", "audio": "audio", "file": "file", "text": "text" };
-  const defaultExtMap = { "image": ".jpg", "video": ".mp4", "audio": ".mp3", "file": ".dat" };
-  async function traverse(elements) {
+  async function transform(elements) {
+    const result = [];
+    const typeMap = { "img": "image", "image": "image", "video": "video", "audio": "audio", "file": "file", "text": "text", "at": "at", "forward": "forward" };
+    const defaultExtMap = { "image": ".jpg", "video": ".mp4", "audio": ".mp3", "file": ".dat" };
     for (const el of elements) {
       const type = typeMap[el.type];
       if (!type) {
-        if (el.children) await traverse(el.children);
+        if (el.children) result.push(...await transform(el.children));
         continue;
       }
       if (type === "text" && el.attrs.content?.trim()) {
-        finalElementsForDb.push({ type: "text", content: el.attrs.content.trim() });
-      } else if (type !== "text" && el.attrs.src) {
+        result.push({ type: "text", content: el.attrs.content.trim() });
+      } else if (type === "at" && el.attrs.id) {
+        result.push({ type: "at", content: el.attrs.id });
+      } else if (type === "forward") {
+        const childrenToProcess = [...el.children || []];
+        if (Array.isArray(el.attrs.content)) {
+          for (const rawMessage of el.attrs.content) {
+            if (rawMessage && rawMessage.message) {
+              childrenToProcess.push(...import_koishi.h.parse(rawMessage.message));
+            }
+          }
+        }
+        if (childrenToProcess.length > 0) {
+          const transformedChildren = await transform(childrenToProcess);
+          if (transformedChildren.length > 0) {
+            result.push({ type: "forward", content: JSON.stringify(transformedChildren) });
+          }
+        }
+      } else if (["image", "video", "audio", "file"].includes(type) && el.attrs.src) {
         let fileIdentifier = el.attrs.src;
         if (fileIdentifier.startsWith("http")) {
           const ext = path2.extname(el.attrs.file || "") || defaultExtMap[type];
-          const fileName = `${newId}_${++mediaIndex}_${session.channelId || "private"}_${session.userId}${ext}`;
+          const currentMediaIndex = ++mediaIndex;
+          const fileName = `${newId}_${currentMediaIndex}_${session.channelId || "private"}_${session.userId}${ext}`;
           mediaToSave.push({ sourceUrl: fileIdentifier, fileName });
           fileIdentifier = fileName;
         }
-        finalElementsForDb.push({ type, file: fileIdentifier });
+        result.push({ type, file: fileIdentifier });
+      } else if (el.children) {
+        result.push(...await transform(el.children));
       }
-      if (el.children) await traverse(el.children);
     }
+    return result;
   }
-  __name(traverse, "traverse");
-  await traverse(sourceElements);
+  __name(transform, "transform");
+  const finalElementsForDb = await transform(sourceElements);
   return { finalElementsForDb, mediaToSave };
 }
 __name(processMessageElements, "processMessageElements");

package/package.json

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