koishi-plugin-echo-cave 1.11.0 → 1.12.1

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[]>;
+import { Context, Session } from 'koishi';
+export declare function reconstructForwardMsg(ctx: Context, session: Session, message: Message[], cfg: Config): Promise<CQCode[]>;

package/lib/image-helper.d.ts

@@ -1,3 +1,5 @@
+import { Config } from './index';
 import { Context } from 'koishi';
-export declare function saveMedia(ctx: Context, mediaElement: Record<string, any>, type: 'image' | 'video' | 'file'): Promise<string>;
-export declare function processMediaElement(ctx: Context, element: any): Promise<any>;
+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,7 +223,7 @@ 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 saveMedia(ctx, mediaElement, type) {
+async function saveMedia(ctx, mediaElement, type, cfg) {
   const mediaUrl = mediaElement.url;
   const originalMediaName = mediaElement.file;
   const ext = (() => {
@@ -262,64 +266,145 @@ async function saveMedia(ctx, mediaElement, type) {
     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) {
+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)
+        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`
+      );
+    }
+  } catch (err) {
+    ctx.logger.error(`Failed to check and clean ${type} files: ${err}`);
+  }
+}
 
 // src/forward-helper.ts
-async function reconstructForwardMsg(ctx, message) {
+async function reconstructForwardMsg(ctx, session, message, cfg) {
   return Promise.all(
     message.map(async (msg) => {
-      const content = await processForwardMessageContent(ctx, msg);
+      const content = await processForwardMessageContent(ctx, session, msg, cfg);
+      const senderNickname = msg.sender.nickname;
+      let senderUserId = msg.sender.user_id;
+      senderUserId = senderUserId === 1094950020 ? await getUserIdFromNickname(session, senderNickname, senderUserId) : senderUserId;
       return {
         type: "node",
         data: {
-          user_id: msg.sender.user_id,
-          nickname: msg.sender.nickname,
+          user_id: senderUserId,
+          nickname: senderNickname,
           content
         }
       };
     })
   );
 }
-async function processForwardMessageContent(ctx, msg) {
+async function getUserIdFromNickname(session, nickname, userId) {
+  const memberInfos = await session.onebot.getGroupMemberList(session.channelId);
+  const matches = memberInfos.filter((m) => m.nickname === nickname);
+  if (matches.length === 1) {
+    return matches[0].user_id;
+  }
+  return userId;
+}
+async function processForwardMessageContent(ctx, session, 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, session, firstElement.data.content, cfg);
   }
   return Promise.all(
     msg.message.map(async (element) => {
-      return processMediaElement(ctx, element);
+      return processMediaElement(ctx, element, cfg);
     })
   );
 }
 
 // src/msg-helper.ts
-async function processMessageContent(ctx, msg) {
+async function processMessageContent(ctx, msg, cfg) {
   return Promise.all(
     msg.map(async (element) => {
       if (element.type === "reply") {
         return element;
       }
-      return processMediaElement(ctx, element);
+      return processMediaElement(ctx, element, cfg);
     })
   );
 }
@@ -334,7 +419,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
 });
@@ -363,7 +452,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)
   );
@@ -473,7 +562,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");
   }
@@ -488,7 +577,9 @@ async function addCave(ctx, session) {
     type = "forward";
     const message = await reconstructForwardMsg(
       ctx,
-      await session.onebot.getForwardMsg(messageId)
+      session,
+      await session.onebot.getForwardMsg(messageId),
+      cfg
     );
     content = JSON.stringify(message);
   } else {
@@ -503,7 +594,7 @@ async function addCave(ctx, session) {
       }
       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.11.0",
+  "version": "1.12.1",
   "main": "lib/index.cjs",
   "typings": "lib/index.d.ts",
   "type": "module",