koishi-plugin-echo-cave 1.10.4 → 1.12.0

package/lib/forward-helper.d.ts

@@ -1,4 +1,5 @@
+import { Config } from './index';
 import { CQCode } from '@pynickle/koishi-plugin-adapter-onebot';
 import { Message } from '@pynickle/koishi-plugin-adapter-onebot/lib/types';
 import { Context } from 'koishi';
-export declare function reconstructForwardMsg(ctx: Context, message: Message[]): Promise<CQCode[]>;
+export declare function reconstructForwardMsg(ctx: Context, message: Message[], cfg: Config): Promise<CQCode[]>;

package/lib/image-helper.d.ts

@@ -1,2 +1,5 @@
+import { Config } from './index';
 import { Context } from 'koishi';
-export declare function saveImages(ctx: Context, imgElement: Record<string, any>): Promise<string>;
+export declare function saveMedia(ctx: Context, mediaElement: Record<string, any>, type: 'image' | 'video' | 'file', cfg: Config): Promise<string>;
+export declare function processMediaElement(ctx: Context, element: any, cfg: Config): Promise<any>;
+export declare function checkAndCleanMediaFiles(ctx: Context, cfg: Config, type: 'image' | 'video' | 'file'): Promise<void>;

package/lib/index.cjs

@@ -36,7 +36,11 @@ var require_zh_CN = __commonJS({
       _config: {
         adminMessageProtection: "\u5F00\u542F\u7BA1\u7406\u5458\u6D88\u606F\u4FDD\u62A4\uFF0C\u5F00\u542F\u540E\u7BA1\u7406\u5458\u53D1\u5E03\u7684\u6D88\u606F\u53EA\u80FD\u7531\u7BA1\u7406\u5458\u5220\u9664",
         allowContributorDelete: "\u5141\u8BB8\u6295\u7A3F\u8005\u5220\u9664\u81EA\u5DF1\u6295\u7A3F\u7684\u56DE\u58F0\u6D1E",
-        allowSenderDelete: "\u5141\u8BB8\u539F\u59CB\u53D1\u9001\u8005\u5220\u9664\u88AB\u6295\u7A3F\u7684\u56DE\u58F0\u6D1E"
+        allowSenderDelete: "\u5141\u8BB8\u539F\u59CB\u53D1\u9001\u8005\u5220\u9664\u88AB\u6295\u7A3F\u7684\u56DE\u58F0\u6D1E",
+        enableSizeLimit: "\u662F\u5426\u542F\u7528\u5A92\u4F53\u6587\u4EF6\u5927\u5C0F\u9650\u5236",
+        maxImageSize: "\u6700\u5927\u56FE\u7247\u5927\u5C0F (MB)",
+        maxVideoSize: "\u6700\u5927\u89C6\u9891\u5927\u5C0F (MB)",
+        maxFileSize: "\u6700\u5927\u6587\u4EF6\u5927\u5C0F (MB)"
       },
       "echo-cave": {
         general: {
@@ -219,51 +223,143 @@ function formatDate(date) {
 var import_axios = __toESM(require("axios"), 1);
 var import_node_fs = require("node:fs");
 var import_node_path = __toESM(require("node:path"), 1);
-async function saveImages(ctx, imgElement) {
-  const imgUrl = imgElement.url;
-  const originalImgName = imgElement.file;
+async function saveMedia(ctx, mediaElement, type, cfg) {
+  const mediaUrl = mediaElement.url;
+  const originalMediaName = mediaElement.file;
   const ext = (() => {
-    const i = originalImgName.lastIndexOf(".");
-    return i === -1 ? "png" : originalImgName.slice(i + 1).toLowerCase();
+    const i = originalMediaName.lastIndexOf(".");
+    return i === -1 ? type === "image" ? "png" : type === "video" ? "mp4" : "bin" : originalMediaName.slice(i + 1).toLowerCase();
   })();
-  const imgDir = import_node_path.default.join(ctx.baseDir, "data", "cave", "images");
-  const imgName = Date.now().toString();
-  const fullImgPath = import_node_path.default.join(imgDir, `${imgName}.${ext}`);
-  ctx.logger.info(`Saving image from ${imgUrl} -> ${fullImgPath}`);
+  const mediaDir = import_node_path.default.join(ctx.baseDir, "data", "cave", type + "s");
+  const mediaName = Date.now().toString();
+  const fullMediaPath = import_node_path.default.join(mediaDir, `${mediaName}.${ext}`);
+  ctx.logger.info(`Saving ${type} from ${mediaUrl} -> ${fullMediaPath}`);
   try {
-    await import_node_fs.promises.mkdir(imgDir, { recursive: true });
-    const res = await import_axios.default.get(imgUrl, {
+    await import_node_fs.promises.mkdir(mediaDir, { recursive: true });
+    const res = await import_axios.default.get(mediaUrl, {
       responseType: "arraybuffer",
       validateStatus: () => true
     });
     if (res.status < 200 || res.status >= 300) {
-      ctx.logger.warn(`Image download failed: HTTP ${res.status}`);
-      return imgUrl;
+      ctx.logger.warn(
+        `${type.charAt(0).toUpperCase() + type.slice(1)} download failed: HTTP ${res.status}`
+      );
+      return mediaUrl;
     }
-    const type = res.headers["content-type"];
-    if (!type || !type.startsWith("image/")) {
-      ctx.logger.warn(`Invalid image content-type: ${type}`);
-      return imgUrl;
+    const contentType = res.headers["content-type"];
+    if (contentType) {
+      if (type === "image" && !contentType.startsWith("image/")) {
+        ctx.logger.warn(`Invalid image content-type: ${contentType}`);
+        return mediaUrl;
+      }
+      if (type === "video" && !contentType.startsWith("video/")) {
+        ctx.logger.warn(`Invalid video content-type: ${contentType}`);
+        return mediaUrl;
+      }
     }
     const buffer = Buffer.from(res.data);
     if (!buffer || buffer.length === 0) {
-      ctx.logger.warn("Downloaded image buffer is empty");
-      return imgUrl;
+      ctx.logger.warn(`Downloaded ${type} buffer is empty`);
+      return mediaUrl;
+    }
+    await import_node_fs.promises.writeFile(fullMediaPath, buffer);
+    ctx.logger.info(
+      `${type.charAt(0).toUpperCase() + type.slice(1)} saved successfully: ${fullMediaPath}`
+    );
+    await checkAndCleanMediaFiles(ctx, cfg, type);
+    return fullMediaPath;
+  } catch (err) {
+    ctx.logger.error(`Failed to save ${type}: ${err}`);
+    return mediaUrl;
+  }
+}
+async function processMediaElement(ctx, element, cfg) {
+  if (element.type === "image" || element.type === "video" || element.type === "file") {
+    return {
+      ...element,
+      data: {
+        ...element.data,
+        url: await saveMedia(
+          ctx,
+          element.data,
+          element.type,
+          cfg
+        )
+      }
+    };
+  }
+  return element;
+}
+async function checkAndCleanMediaFiles(ctx, cfg, type) {
+  if (!cfg.enableSizeLimit) {
+    return;
+  }
+  const mediaDir = import_node_path.default.join(ctx.baseDir, "data", "cave", type + "s");
+  const maxSize = (() => {
+    switch (type) {
+      case "image":
+        return (cfg.maxImageSize || 100) * 1024 * 1024;
+      // 转换为字节
+      case "video":
+        return (cfg.maxVideoSize || 500) * 1024 * 1024;
+      case "file":
+        return (cfg.maxFileSize || 1e3) * 1024 * 1024;
+    }
+  })();
+  try {
+    const files = await import_node_fs.promises.readdir(mediaDir);
+    if (files.length === 0) {
+      return;
+    }
+    const fileInfos = await Promise.all(
+      files.map(async (file) => {
+        const filePath = import_node_path.default.join(mediaDir, file);
+        const stats = await import_node_fs.promises.stat(filePath);
+        return {
+          path: filePath,
+          size: stats.size,
+          mtime: stats.mtimeMs
+        };
+      })
+    );
+    const totalSize = fileInfos.reduce((sum, file) => sum + file.size, 0);
+    ctx.logger.info(
+      `${type} directory total size: ${(totalSize / (1024 * 1024)).toFixed(2)} MB, max allowed: ${(maxSize / (1024 * 1024)).toFixed(2)} MB`
+    );
+    if (totalSize > maxSize) {
+      ctx.logger.warn(
+        `${type} directory size exceeds limit! Total: ${(totalSize / (1024 * 1024)).toFixed(2)} MB, Max: ${(maxSize / (1024 * 1024)).toFixed(2)} MB`
+      );
+      fileInfos.sort((a, b) => a.mtime - b.mtime);
+      let currentSize = totalSize;
+      let filesToDelete = [];
+      for (const file of fileInfos) {
+        if (currentSize <= maxSize) {
+          break;
+        }
+        filesToDelete.push(file);
+        currentSize -= file.size;
+      }
+      for (const file of filesToDelete) {
+        await import_node_fs.promises.unlink(file.path);
+        ctx.logger.info(
+          `Deleted oldest ${type} file: ${import_node_path.default.basename(file.path)} (${(file.size / (1024 * 1024)).toFixed(2)} MB)`
+        );
+      }
+      ctx.logger.info(
+        `Cleanup completed. ${type} directory new size: ${(currentSize / (1024 * 1024)).toFixed(2)} MB`
+      );
     }
-    await import_node_fs.promises.writeFile(fullImgPath, buffer);
-    ctx.logger.info(`Image saved successfully: ${fullImgPath}`);
-    return fullImgPath;
   } catch (err) {
-    ctx.logger.error(`Failed to save image: ${err}`);
-    return imgUrl;
+    ctx.logger.error(`Failed to check and clean ${type} files: ${err}`);
   }
 }
 
 // src/forward-helper.ts
-async function reconstructForwardMsg(ctx, message) {
+async function reconstructForwardMsg(ctx, message, cfg) {
   return Promise.all(
     message.map(async (msg) => {
-      const content = await processForwardMessageContent(ctx, msg);
+      const content = await processForwardMessageContent(ctx, msg, cfg);
       return {
         type: "node",
         data: {
@@ -275,51 +371,31 @@ async function reconstructForwardMsg(ctx, message) {
     })
   );
 }
-async function processForwardMessageContent(ctx, msg) {
+async function processForwardMessageContent(ctx, msg, cfg) {
   if (typeof msg.message === "string") {
     return msg.message;
   }
   const firstElement = msg.message[0];
   if (firstElement?.type === "forward") {
-    return reconstructForwardMsg(ctx, firstElement.data.content);
+    return reconstructForwardMsg(ctx, firstElement.data.content, cfg);
   }
   return Promise.all(
     msg.message.map(async (element) => {
-      if (element.type === "image") {
-        return {
-          ...element,
-          data: {
-            ...element.data,
-            url: await saveImages(ctx, element.data)
-          }
-        };
-      }
-      return element;
+      return processMediaElement(ctx, element, cfg);
     })
   );
 }
 
 // src/msg-helper.ts
-async function processMessageContent(ctx, msg) {
-  const result = [];
-  for (const element of msg) {
-    if (element.type === "reply") {
-      continue;
-    }
-    if (element.type === "image") {
-      const newUrl = await saveImages(ctx, element.data);
-      result.push({
-        ...element,
-        data: {
-          ...element.data,
-          url: newUrl
-        }
-      });
-    } else {
-      result.push(element);
-    }
-  }
-  return result;
+async function processMessageContent(ctx, msg, cfg) {
+  return Promise.all(
+    msg.map(async (element) => {
+      if (element.type === "reply") {
+        return element;
+      }
+      return processMediaElement(ctx, element, cfg);
+    })
+  );
 }
 
 // src/index.ts
@@ -332,7 +408,11 @@ var inject = ["database"];
 var Config = import_koishi.Schema.object({
   adminMessageProtection: import_koishi.Schema.boolean().default(false),
   allowContributorDelete: import_koishi.Schema.boolean().default(true),
-  allowSenderDelete: import_koishi.Schema.boolean().default(true)
+  allowSenderDelete: import_koishi.Schema.boolean().default(true),
+  enableSizeLimit: import_koishi.Schema.boolean().default(false),
+  maxImageSize: import_koishi.Schema.number().default(2048),
+  maxVideoSize: import_koishi.Schema.number().default(512),
+  maxFileSize: import_koishi.Schema.number().default(512)
 }).i18n({
   "zh-CN": require_zh_CN()._config
 });
@@ -361,7 +441,7 @@ function apply(ctx, cfg) {
   ctx.command("cave [id:number]").action(
     async ({ session }, id) => await getCave(ctx, session, id)
   );
-  ctx.command("cave.echo").action(async ({ session }) => await addCave(ctx, session));
+  ctx.command("cave.echo").action(async ({ session }) => await addCave(ctx, session, cfg));
   ctx.command("cave.wipe <id:number>").action(
     async ({ session }, id) => await deleteCave(ctx, session, cfg, id)
   );
@@ -471,7 +551,7 @@ async function deleteCave(ctx, session, cfg, id) {
   await ctx.database.remove("echo_cave", id);
   return session.text(".msgDeleted", [id]);
 }
-async function addCave(ctx, session) {
+async function addCave(ctx, session, cfg) {
   if (!session.guildId) {
     return session.text("echo-cave.general.privateChatReminder");
   }
@@ -486,7 +566,8 @@ async function addCave(ctx, session) {
     type = "forward";
     const message = await reconstructForwardMsg(
       ctx,
-      await session.onebot.getForwardMsg(messageId)
+      await session.onebot.getForwardMsg(messageId),
+      cfg
     );
     content = JSON.stringify(message);
   } else {
@@ -496,9 +577,12 @@ async function addCave(ctx, session) {
     if (typeof message === "string") {
       msgJson = import_koishi_plugin_adapter_onebot2.CQCode.parse(message);
     } else {
+      if (message[0].type === "video" || message[0].type === "file") {
+        type = "forward";
+      }
       msgJson = message;
     }
-    content = JSON.stringify(await processMessageContent(ctx, msgJson));
+    content = JSON.stringify(await processMessageContent(ctx, msgJson, cfg));
   }
   await ctx.database.get("echo_cave", { content }).then((existing) => {
     if (existing) {

package/lib/index.d.ts

@@ -6,6 +6,10 @@ export interface Config {
     adminMessageProtection?: boolean;
     allowContributorDelete?: boolean;
     allowSenderDelete?: boolean;
+    enableSizeLimit?: boolean;
+    maxImageSize?: number;
+    maxVideoSize?: number;
+    maxFileSize?: number;
 }
 export declare const Config: Schema<Config>;
 export interface EchoCave {

package/lib/msg-helper.d.ts

@@ -1,3 +1,4 @@
+import { Config } from './index';
 import { CQCode } from '@pynickle/koishi-plugin-adapter-onebot';
 import { Context } from 'koishi';
-export declare function processMessageContent(ctx: Context, msg: CQCode[]): Promise<CQCode[]>;
+export declare function processMessageContent(ctx: Context, msg: CQCode[], cfg: Config): Promise<CQCode[]>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-echo-cave",
   "description": "Group echo cave",
-  "version": "1.10.4",
+  "version": "1.12.0",
   "main": "lib/index.cjs",
   "typings": "lib/index.d.ts",
   "type": "module",