koishi-plugin-echo-cave 1.10.4 → 1.11.0

package/lib/image-helper.d.ts

@@ -1,2 +1,3 @@
 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'): Promise<string>;
+export declare function processMediaElement(ctx: Context, element: any): Promise<any>;

package/lib/index.cjs

@@ -219,44 +219,66 @@ 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) {
+  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(fullImgPath, buffer);
-    ctx.logger.info(`Image saved successfully: ${fullImgPath}`);
-    return fullImgPath;
+    await import_node_fs.promises.writeFile(fullMediaPath, buffer);
+    ctx.logger.info(
+      `${type.charAt(0).toUpperCase() + type.slice(1)} saved successfully: ${fullMediaPath}`
+    );
+    return fullMediaPath;
   } catch (err) {
-    ctx.logger.error(`Failed to save image: ${err}`);
-    return imgUrl;
+    ctx.logger.error(`Failed to save ${type}: ${err}`);
+    return mediaUrl;
+  }
+}
+async function processMediaElement(ctx, element) {
+  if (element.type === "image" || element.type === "video" || element.type === "file") {
+    return {
+      ...element,
+      data: {
+        ...element.data,
+        url: await saveMedia(ctx, element.data, element.type)
+      }
+    };
   }
+  return element;
 }
 
 // src/forward-helper.ts
@@ -285,41 +307,21 @@ async function processForwardMessageContent(ctx, msg) {
   }
   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);
     })
   );
 }
 
 // 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;
+  return Promise.all(
+    msg.map(async (element) => {
+      if (element.type === "reply") {
+        return element;
+      }
+      return processMediaElement(ctx, element);
+    })
+  );
 }
 
 // src/index.ts
@@ -496,6 +498,9 @@ 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));

package/package.json

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