koishi-plugin-maple-drift-bottle 0.1.0 → 0.1.2

package/lib/index.js

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -37,34 +27,25 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_koishi = require("koishi");
-var import_promises = require("fs/promises");
-var import_path = require("path");
-var import_crypto = require("crypto");
-var import_fs = require("fs");
-var import_sharp = __toESM(require("sharp"));
+var import_koishi2 = require("koishi");
 var name = "maple-drift-bottle";
-var using = ["database"];
+var using = ["database", "http"];
 var Config = import_koishi.Schema.object({
   anonymousByDefault: import_koishi.Schema.boolean().default(false).description("默认是否匿名（true: 匿名，false: 不匿名）"),
-  maxContentLength: import_koishi.Schema.number().default(500).min(50).max(2e3).description("漂流瓶文本内容最大长度（字符）"),
-  maxPreviewLength: import_koishi.Schema.number().default(8).min(3).max(50).description('指令"我的漂流瓶"最大预览字数'),
-  maxImages: import_koishi.Schema.number().default(3).min(0).max(10).description("每一条漂流瓶最多可包含的图片数量（0为不允许发送图片）"),
-  saveImagesLocally: import_koishi.Schema.boolean().default(true).description("是否本地保存图片（启用后图片永久保存，不依赖外部URL）"),
-  imageSavePath: import_koishi.Schema.string().default("./data/maple-drift-bottle/images").description("图片本地保存路径（相对Koishi根目录）"),
-  compressImages: import_koishi.Schema.boolean().default(true).description("是否压缩图片以节省空间"),
-  maxImageWidth: import_koishi.Schema.number().default(1200).min(100).max(3840).description("图片最大宽度（像素）"),
-  maxImageHeight: import_koishi.Schema.number().default(1200).min(100).max(3840).description("图片最大高度（像素）"),
-  imageQuality: import_koishi.Schema.number().default(85).min(10).max(100).description("图片质量 (0-100，越高图片质量越好但文件越大)"),
+  maxContentLength: import_koishi.Schema.number().default(500).min(50).max(2e3).description("漂流瓶内容最大长度（字）（50-2000）"),
+  maxPreviewLength: import_koishi.Schema.number().default(8).min(3).max(50).description('指令"我的漂流瓶"最大预览字数（3-50）'),
+  maxCommentLength: import_koishi.Schema.number().default(50).min(10).max(500).description("漂流瓶评论最大长度（字）（10-500）"),
+  maxImageSize: import_koishi.Schema.number().default(1e3).min(0).max(1e4).description("漂流瓶图片大小限制（KB）（0-10000，0表示不允许图片）"),
   adminQQ: import_koishi.Schema.array(String).role("table").default([]).description("管理人QQ号（可添加多个）")
 });
 function getSenderDisplay(bottle) {
-  if (bottle.anonymous) {
-    return "匿名";
-  } else {
-    return `${bottle.authorName} (${bottle.author})`;
-  }
+  return bottle.anonymous ? "匿名" : bottle.authorName;
 }
 __name(getSenderDisplay, "getSenderDisplay");
+function getCommenterDisplay(comment) {
+  return comment.anonymous ? "匿名" : comment.authorName;
+}
+__name(getCommenterDisplay, "getCommenterDisplay");
 function formatTime(date) {
   return date.toLocaleString("zh-CN", {
     year: "numeric",
@@ -76,91 +57,109 @@ function formatTime(date) {
   });
 }
 __name(formatTime, "formatTime");
-function getContentPreview(content, maxLength) {
-  if (!content || content.length === 0) {
-    return "[无文本内容]";
+function getContentPreview(content, hasImage, maxLength) {
+  let preview = content;
+  if (hasImage) {
+    preview += "[图片]";
   }
-  if (content.length <= maxLength) {
-    return content;
+  if (preview.length <= maxLength) {
+    return preview;
   }
-  return content.substring(0, maxLength) + "...";
+  return preview.substring(0, maxLength) + "...";
 }
 __name(getContentPreview, "getContentPreview");
-function extractContentAndImages(elements) {
-  let text = "";
-  const images = [];
-  for (const element of elements) {
-    if (element.type === "text") {
-      text += element.attrs?.content || "";
-    } else if (element.type === "image" || element.type === "img") {
-      const url = element.attrs?.url || element.attrs?.src;
-      if (url) {
-        images.push(url);
-      }
-    } else if (element.type === "at") {
-      continue;
-    } else if (element.type === "face") {
-      continue;
-    } else {
-      text += `[${element.type}]`;
+function getBase64ImageSize(base64) {
+  const stringLength = base64.length;
+  const sizeInBytes = 4 * Math.ceil(stringLength / 3) * 0.5624896334383812;
+  const sizeInKB = sizeInBytes / 1024;
+  return sizeInKB;
+}
+__name(getBase64ImageSize, "getBase64ImageSize");
+function extractImageUrlFromCQCode(cqCode) {
+  const srcMatch = cqCode.match(/src="([^"]+)"/);
+  if (srcMatch && srcMatch[1]) {
+    const url = srcMatch[1];
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return url;
     }
   }
-  return { text: text.trim(), images };
+  return null;
 }
-__name(extractContentAndImages, "extractContentAndImages");
-async function downloadAndSaveImage(ctx, url, savePath, compress, maxWidth, maxHeight, quality) {
+__name(extractImageUrlFromCQCode, "extractImageUrlFromCQCode");
+async function downloadImageToBase64(url, maxSizeKB, ctx) {
   try {
-    if (!(0, import_fs.existsSync)(savePath)) {
-      await (0, import_promises.mkdir)(savePath, { recursive: true });
-    }
-    const hash = (0, import_crypto.createHash)("md5").update(url + Date.now()).digest("hex");
-    const originalExt = (0, import_path.extname)(new URL(url).pathname) || ".jpg";
-    const fileName = `${hash}${originalExt}`;
-    const filePath = (0, import_path.join)(savePath, fileName);
     const response = await ctx.http.get(url, { responseType: "arraybuffer" });
-    const imageBuffer = Buffer.from(response);
-    if (compress) {
-      try {
-        let sharpInstance = (0, import_sharp.default)(imageBuffer);
-        const metadata = await sharpInstance.metadata();
-        if (metadata.width > maxWidth || metadata.height > maxHeight) {
-          sharpInstance = sharpInstance.resize({
-            width: maxWidth,
-            height: maxHeight,
-            fit: "inside",
-            // 保持宽高比，不超过指定尺寸
-            withoutEnlargement: true
-            // 不放大比指定尺寸小的图片
-          });
-        }
-        await sharpInstance.jpeg({ quality }).toFile(filePath);
-        ctx.logger("maple-drift-bottle").info(`图片压缩保存: ${fileName} (${imageBuffer.length}字节 -> ${(await (0, import_promises.readFile)(filePath)).length}字节)`);
-      } catch (sharpError) {
-        ctx.logger("maple-drift-bottle").warn("sharp压缩失败，保存原始图片:", sharpError);
-        await (0, import_promises.writeFile)(filePath, imageBuffer);
-      }
-    } else {
-      await (0, import_promises.writeFile)(filePath, imageBuffer);
+    const buffer = Buffer.from(response);
+    const sizeKB = buffer.length / 1024;
+    if (sizeKB > maxSizeKB) {
+      throw new Error(`图片太大: ${sizeKB.toFixed(2)}KB (最大允许: ${maxSizeKB}KB)`);
+    }
+    const base64 = buffer.toString("base64");
+    const base64SizeKB = base64.length * 3 / (4 * 1024);
+    if (base64SizeKB > maxSizeKB) {
+      throw new Error(`转换后图片太大: ${base64SizeKB.toFixed(2)}KB (最大允许: ${maxSizeKB}KB)`);
     }
-    return fileName;
+    return base64;
   } catch (error) {
-    ctx.logger("maple-drift-bottle").error("下载或保存图片失败:", error);
-    throw new Error(`图片保存失败: ${error.message}`);
+    ctx.logger("maple-drift-bottle").error("下载或转换图片失败:", error);
+    throw new Error(`图片处理失败: ${error.message}`);
   }
 }
-__name(downloadAndSaveImage, "downloadAndSaveImage");
-function getLocalImagePath(fileName, ctx, config) {
-  if (!fileName || !config.saveImagesLocally) {
-    return fileName;
+__name(downloadImageToBase64, "downloadImageToBase64");
+async function processImages(session, content, config, ctx) {
+  let processedContent = content || "";
+  let imageBase64 = null;
+  if (content && content.includes("<img")) {
+    const imgMatches = content.match(/<img[^>]+>/g);
+    if (imgMatches && imgMatches.length > 0) {
+      if (imgMatches.length > 1) {
+        throw new Error("最多只能发送一张图片！");
+      }
+      if (config.maxImageSize === 0) {
+        throw new Error("当前配置不允许发送图片！");
+      }
+      const imgTag = imgMatches[0];
+      const imageUrl = extractImageUrlFromCQCode(imgTag);
+      if (imageUrl) {
+        try {
+          imageBase64 = await downloadImageToBase64(imageUrl, config.maxImageSize, ctx);
+        } catch (error) {
+          ctx.logger("maple-drift-bottle").error("处理CQ码图片失败:", error);
+          throw new Error(`图片处理失败: ${error.message}`);
+        }
+      } else {
+        throw new Error("无法从图片消息中提取有效的图片URL，请尝试直接发送图片而不是复制图片链接。");
+      }
+      processedContent = content.replace(/<img[^>]*>/g, "").trim();
+    }
   }
-  const fullPath = (0, import_path.join)(config.imageSavePath, fileName);
-  if (!(0, import_fs.existsSync)(fullPath)) {
-    ctx.logger("maple-drift-bottle").warn(`图片文件不存在: ${fullPath}`);
-    return fileName;
+  const hasImageInElements = session.elements?.some((el) => el.type === "image");
+  if (hasImageInElements) {
+    const images = session.elements.filter((el) => el.type === "image");
+    if (images.length > 1) {
+      throw new Error("最多只能发送一张图片！");
+    }
+    if (config.maxImageSize === 0) {
+      throw new Error("当前配置不允许发送图片！");
+    }
+    const imageElement = images[0];
+    let imageUrl = imageElement.attrs.url || imageElement.attrs.file;
+    if (imageUrl && imageUrl.startsWith("base64://")) {
+      const base64Data = imageUrl.substring(9);
+      const imageSize = getBase64ImageSize(base64Data);
+      if (imageSize > config.maxImageSize) {
+        throw new Error(`图片太大了！最大允许 ${config.maxImageSize}KB（当前: ${imageSize.toFixed(2)}KB）。`);
+      }
+      imageBase64 = base64Data;
+    } else if (imageUrl) {
+      imageBase64 = await downloadImageToBase64(imageUrl, config.maxImageSize, ctx);
+    }
+  }
+  if (hasImageInElements && processedContent !== content) {
   }
-  return fullPath;
+  return { content: processedContent, imageBase64 };
 }
-__name(getLocalImagePath, "getLocalImagePath");
+__name(processImages, "processImages");
 function apply(ctx, config) {
   console.log("maple-drift-bottle 漂流瓶插件加载中...");
   ctx.model.extend("maple-drift-bottles", {
@@ -172,15 +171,36 @@ function apply(ctx, config) {
     anonymous: "boolean",
     // 是否匿名
     content: "text",
-    // 文本内容
-    images: "json",
-    // 图片本地文件名数组（JSON格式存储）
+    // 漂流瓶内容（text类型，支持长文本）
+    image: "text",
+    // 图片base64数据
     created: "timestamp"
     // 创建时间
   }, {
     primary: "id",
     autoInc: true
   });
+  ctx.model.extend("maple-drift-bottle-comments", {
+    id: "unsigned",
+    bottleId: "unsigned",
+    // 关联的漂流瓶ID
+    author: "string",
+    // 评论者ID
+    authorName: "string",
+    // 评论者昵称
+    anonymous: "boolean",
+    // 是否匿名评论
+    content: "text",
+    // 评论内容
+    created: "timestamp"
+    // 评论时间
+  }, {
+    primary: "id",
+    autoInc: true,
+    foreign: {
+      bottleId: ["maple-drift-bottles", "id"]
+    }
+  });
   ctx.command("漂流瓶", "漂流瓶相关指令").action(({ session }) => {
     return session.execute("help 漂流瓶");
   });
@@ -192,55 +212,65 @@ function apply(ctx, config) {
       }
       const randomIndex = Math.floor(Math.random() * allBottles.length);
       const bottle = allBottles[randomIndex];
+      const comments = await ctx.database.get("maple-drift-bottle-comments", {
+        bottleId: bottle.id
+      });
+      comments.sort((a, b) => b.created.getTime() - a.created.getTime());
       const senderDisplay = getSenderDisplay(bottle);
       const timeDisplay = formatTime(bottle.created);
-      const message = [
-        `【漂流瓶 #${bottle.id}】`,
-        `发送者：${senderDisplay}`,
-        `时间：${timeDisplay}`
-      ];
-      if (bottle.content) {
-        message.push(`内容：
-${bottle.content}`);
-      }
-      if (bottle.images && bottle.images.length > 0) {
-        await session.send(message.join("\n"));
-        for (const imageName of bottle.images) {
-          try {
-            const imagePath = getLocalImagePath(imageName, ctx, config);
-            await session.send(import_koishi.h.image(imagePath));
-          } catch (error) {
-            ctx.logger("maple-drift-bottle").warn(`发送图片失败: ${imageName}`, error);
-            await session.send(`[图片加载失败]`);
-          }
+      let textContent = bottle.content;
+      if (bottle.image) {
+        textContent += textContent ? "\n[图片]" : "[图片]";
+      }
+      let output = `【漂流瓶 #${bottle.id}】
+发送者：${senderDisplay}
+时间：${timeDisplay}
+内容：
+${textContent}`;
+      if (comments.length > 0) {
+        output += "\n──────────\n最新评论：\n";
+        const recentComments = comments.slice(0, 3);
+        recentComments.forEach((comment, index) => {
+          const commenterDisplay = getCommenterDisplay(comment);
+          output += `${index + 1}. ${commenterDisplay}：${comment.content}
+`;
+        });
+      }
+      await session.send(output);
+      if (bottle.image) {
+        try {
+          await session.send(import_koishi2.segment.image(`base64://${bottle.image}`));
+        } catch (error) {
+          ctx.logger("maple-drift-bottle").error("发送图片时出错:", error);
+          await session.send("（图片发送失败）");
         }
-        return "";
-      } else {
-        return message.join("\n");
       }
+      return "";
     } catch (error) {
       ctx.logger("maple-drift-bottle").error("捞漂流瓶时出错:", error);
       return "捞取漂流瓶时出错了，请稍后再试。";
     }
   });
-  ctx.command("漂流瓶/扔漂流瓶", "扔一个漂流瓶到海里（支持文本和图片）").alias("扔漂流瓶").alias("丢漂流瓶").option("invisible", "-i  匿名发送（不显示发送者）").option("visible", "-v  公开发送（显示发送者）").example("扔漂流瓶 这是一条漂流瓶内容").example("扔漂流瓶 -i 这是一条匿名漂流瓶内容").action(async ({ session, options }) => {
+  ctx.command("漂流瓶/扔漂流瓶 <content:text>", "扔一个漂流瓶到海里（可附带一张图片）").alias("扔漂流瓶").alias("丢漂流瓶").option("invisible", "-i  匿名发送（不显示发送者）").option("visible", "-v  公开发送（显示发送者）").example("扔漂流瓶 这是一条漂流瓶内容").example("扔漂流瓶 -i 这是一条匿名漂流瓶内容").action(async ({ session, options }, content) => {
     try {
-      const elements = session.elements;
-      if (elements.length === 0) {
-        return "漂流瓶内容不能为空！请发送文本或图片。";
-      }
-      const { text, images: imageUrls } = extractContentAndImages(elements);
-      if (!text && imageUrls.length === 0) {
-        return "漂流瓶内容不能为空！请发送文本或图片。";
+      if (options.invisible && options.visible) {
+        return "选项冲突：-i（匿名）和-v（公开）不能同时使用";
       }
-      if (text.length > config.maxContentLength) {
-        return `漂流瓶文本内容太长了！最多只能输入${config.maxContentLength}个字符（当前: ${text.length}）。`;
+      let processedContent = content || "";
+      let imageBase64 = null;
+      try {
+        const result = await processImages(session, content || "", config, ctx);
+        processedContent = result.content;
+        imageBase64 = result.imageBase64;
+      } catch (error) {
+        return error.message;
       }
-      if (imageUrls.length > config.maxImages) {
-        return `图片数量太多了！最多只能发送${config.maxImages}张图片（当前: ${imageUrls.length}）。`;
+      if (!imageBase64 && (!processedContent || processedContent.trim().length === 0)) {
+        return "漂流瓶内容不能为空！\n格式：扔漂流瓶 [-i|-v] 内容\n示例：扔漂流瓶 -i 这是一条匿名漂流瓶";
       }
-      if (options.invisible && options.visible) {
-        return "选项冲突：-i（匿名）和-v（公开）不能同时使用";
+      const trimmedContent = processedContent.trim();
+      if (trimmedContent.length > config.maxContentLength) {
+        return `漂流瓶内容太长了！最多只能输入${config.maxContentLength}个字（当前: ${trimmedContent.length}）。`;
       }
       let anonymous = config.anonymousByDefault;
       if (options.invisible) {
@@ -250,40 +280,19 @@ ${bottle.content}`);
       }
       const userInfo = await session.getUser(session.userId);
       const authorName = userInfo?.name || session.username || `用户${session.userId}`;
-      const savedImageNames = [];
-      if (config.saveImagesLocally && imageUrls.length > 0) {
-        for (const imageUrl of imageUrls) {
-          try {
-            const savedName = await downloadAndSaveImage(
-              ctx,
-              imageUrl,
-              config.imageSavePath,
-              config.compressImages,
-              config.maxImageWidth,
-              config.maxImageHeight,
-              config.imageQuality
-            );
-            savedImageNames.push(savedName);
-          } catch (error) {
-            ctx.logger("maple-drift-bottle").error("图片处理失败:", error);
-            return `图片处理失败: ${error.message}`;
-          }
-        }
-      }
       const newBottle = await ctx.database.create("maple-drift-bottles", {
         author: session.userId,
         authorName,
         anonymous,
-        content: text,
-        images: config.saveImagesLocally ? savedImageNames : imageUrls,
+        content: trimmedContent,
+        image: imageBase64,
         created: /* @__PURE__ */ new Date()
       });
       const anonymousText = anonymous ? "匿名" : "不匿名";
-      const imageText = savedImageNames.length > 0 ? `，包含${savedImageNames.length}张图片` : "";
-      const saveText = config.saveImagesLocally ? "（已本地保存）" : "";
+      const imageText = imageBase64 ? "（含图片）" : "";
       return `成功扔出一个漂流瓶！
 ID: #${newBottle.id}
-状态: ${anonymousText}${imageText}${saveText}
+状态: ${anonymousText}${imageText}
 内容已保存到海中，等待有缘人捞取。`;
     } catch (error) {
       ctx.logger("maple-drift-bottle").error("扔漂流瓶时出错:", error);
@@ -317,10 +326,9 @@ ID: #${newBottle.id}
         const displayIndex = startIndex + index + 1;
         const timeDisplay = formatTime(bottle.created);
         const anonymousText = bottle.anonymous ? "（匿名）" : "";
-        const contentPreview = getContentPreview(bottle.content, config.maxPreviewLength);
-        const imageText = bottle.images && bottle.images.length > 0 ? ` [${bottle.images.length}图]` : "";
+        const contentPreview = getContentPreview(bottle.content, !!bottle.image, config.maxPreviewLength);
         output += `${displayIndex}. 漂流瓶 #${bottle.id} ${anonymousText} - ${timeDisplay}
-   预览: ${contentPreview}${imageText}
+   预览: ${contentPreview}
 `;
       });
       output += "\n──────────\n";
@@ -354,33 +362,41 @@ ID: #${newBottle.id}
         return `仅可查看由你自己发送的漂流瓶。
 可以发送"我的漂流瓶"查看你发送的所有漂流瓶序号。`;
       }
+      const comments = await ctx.database.get("maple-drift-bottle-comments", {
+        bottleId: bottle.id
+      });
+      comments.sort((a, b) => b.created.getTime() - a.created.getTime());
       const senderDisplay = getSenderDisplay(bottle);
       const timeDisplay = formatTime(bottle.created);
-      const message = [
-        `【漂流瓶 #${bottle.id}】`,
-        `发送者：${senderDisplay}`,
-        `时间：${timeDisplay}`,
-        `状态：${bottle.anonymous ? "匿名" : "公开"}`
-      ];
-      if (bottle.content) {
-        message.push(`内容：
-${bottle.content}`);
-      }
-      if (bottle.images && bottle.images.length > 0) {
-        await session.send(message.join("\n"));
-        for (const imageName of bottle.images) {
-          try {
-            const imagePath = getLocalImagePath(imageName, ctx, config);
-            await session.send(import_koishi.h.image(imagePath));
-          } catch (error) {
-            ctx.logger("maple-drift-bottle").warn(`发送图片失败: ${imageName}`, error);
-            await session.send(`[图片加载失败]`);
-          }
+      let textContent = bottle.content;
+      if (bottle.image) {
+        textContent += textContent ? "\n[图片]" : "[图片]";
+      }
+      let output = `【漂流瓶 #${bottle.id}】
+发送者：${senderDisplay}
+时间：${timeDisplay}
+状态：${bottle.anonymous ? "匿名" : "公开"}
+内容：
+${textContent}`;
+      if (comments.length > 0) {
+        output += "\n──────────\n最新评论：\n";
+        const recentComments = comments.slice(0, 3);
+        recentComments.forEach((comment, index) => {
+          const commenterDisplay = getCommenterDisplay(comment);
+          output += `${index + 1}. ${commenterDisplay}：${comment.content}
+`;
+        });
+      }
+      await session.send(output);
+      if (bottle.image) {
+        try {
+          await session.send(import_koishi2.segment.image(`base64://${bottle.image}`));
+        } catch (error) {
+          ctx.logger("maple-drift-bottle").error("发送图片时出错:", error);
+          await session.send("（图片发送失败）");
         }
-        return "";
-      } else {
-        return message.join("\n");
       }
+      return "";
     } catch (error) {
       ctx.logger("maple-drift-bottle").error("查看漂流瓶时出错:", error);
       return "查看漂流瓶时出错了，请稍后再试。";
@@ -401,33 +417,130 @@ ${bottle.content}`);
         return `仅可删除由你自己发送的漂流瓶。
 可以发送"我的漂流瓶"查看你发送的所有漂流瓶序号。`;
       }
-      const senderDisplay = getSenderDisplay(bottle);
-      const timeDisplay = formatTime(bottle.created);
-      const contentPreview = bottle.content ? bottle.content.length > 50 ? bottle.content.substring(0, 50) + "..." : bottle.content : "[无文本内容]";
-      const imageText = bottle.images && bottle.images.length > 0 ? ` (${bottle.images.length}张图片)` : "";
-      if (config.saveImagesLocally && bottle.images && bottle.images.length > 0) {
-        for (const imageName of bottle.images) {
-          try {
-            const imagePath = (0, import_path.join)(config.imageSavePath, imageName);
-            if ((0, import_fs.existsSync)(imagePath)) {
-              await (0, import_promises.rm)(imagePath);
-              ctx.logger("maple-drift-bottle").info(`删除图片文件: ${imagePath}`);
-            }
-          } catch (error) {
-            ctx.logger("maple-drift-bottle").warn(`删除图片文件失败: ${imageName}`, error);
-          }
-        }
-      }
+      await ctx.database.remove("maple-drift-bottle-comments", {
+        bottleId: id
+      });
       await ctx.database.remove("maple-drift-bottles", { id });
-      return `已成功删除漂流瓶 #${id}
-发送者：${senderDisplay}
-时间：${timeDisplay}
-预览：${contentPreview}${imageText}`;
+      return `已成功删除漂流瓶 #${id}，并同时删除了该漂流瓶的所有评论。`;
     } catch (error) {
       ctx.logger("maple-drift-bottle").error("删除漂流瓶时出错:", error);
       return "删除漂流瓶时出错了，请稍后再试。";
     }
   });
+  ctx.command("漂流瓶/评论漂流瓶 <bottleId:number> <content:text>", "对指定的漂流瓶进行评论").alias("评论漂流瓶").option("invisible", "-i  匿名评论（不显示评论者）").option("visible", "-v  公开评论（显示评论者）").example("评论漂流瓶 1 这是一条评论").example("评论漂流瓶 2 -i 这是一条匿名评论").action(async ({ session, options }, bottleId, content) => {
+    try {
+      const bottles = await ctx.database.get("maple-drift-bottles", { id: bottleId });
+      if (bottles.length === 0) {
+        return `没有找到ID为 #${bottleId} 的漂流瓶。`;
+      }
+      if (!content || content.trim().length === 0) {
+        return "评论内容不能为空！";
+      }
+      const trimmedContent = content.trim();
+      if (trimmedContent.length > config.maxCommentLength) {
+        return `评论内容太长了！最多只能输入${config.maxCommentLength}个字（当前: ${trimmedContent.length}）。`;
+      }
+      if (options.invisible && options.visible) {
+        return "选项冲突：-i（匿名）和-v（公开）不能同时使用";
+      }
+      let anonymous = config.anonymousByDefault;
+      if (options.invisible) {
+        anonymous = true;
+      } else if (options.visible) {
+        anonymous = false;
+      }
+      const userInfo = await session.getUser(session.userId);
+      const authorName = userInfo?.name || session.username || `用户${session.userId}`;
+      await ctx.database.create("maple-drift-bottle-comments", {
+        bottleId,
+        author: session.userId,
+        authorName,
+        anonymous,
+        content: trimmedContent,
+        created: /* @__PURE__ */ new Date()
+      });
+      const comments = await ctx.database.get("maple-drift-bottle-comments", {
+        bottleId
+      });
+      if (comments.length > 3) {
+        comments.sort((a, b) => a.created.getTime() - b.created.getTime());
+        const commentsToDelete = comments.slice(0, comments.length - 3);
+        for (const comment of commentsToDelete) {
+          await ctx.database.remove("maple-drift-bottle-comments", { id: comment.id });
+        }
+      }
+      const anonymousText = anonymous ? "匿名" : "公开";
+      return `成功评论漂流瓶 #${bottleId}！
+状态: ${anonymousText}
+评论已保存。`;
+    } catch (error) {
+      ctx.logger("maple-drift-bottle").error("评论漂流瓶时出错:", error);
+      return "评论漂流瓶时出错了，请稍后再试。";
+    }
+  });
+  ctx.command("漂流瓶/删除漂流瓶评论 <bottleId:number>", "删除指定漂流瓶的所有评论").alias("删除漂流瓶评论").option("all", "-a  无视权限限制删除评论").example("删除漂流瓶评论 1").action(async ({ session, options }, bottleId) => {
+    try {
+      const bottles = await ctx.database.get("maple-drift-bottles", { id: bottleId });
+      if (bottles.length === 0) {
+        return `没有找到ID为 #${bottleId} 的漂流瓶。`;
+      }
+      const bottle = bottles[0];
+      const comments = await ctx.database.get("maple-drift-bottle-comments", {
+        bottleId
+      });
+      if (comments.length === 0) {
+        return `漂流瓶 #${bottleId} 还没有任何评论。`;
+      }
+      if (!options.all) {
+        const userId = session.userId;
+        const isBottleAuthor = bottle.author === userId;
+        const userComments = comments.filter((comment) => comment.author === userId);
+        const isCommentAuthor = userComments.length > 0;
+        if (!isBottleAuthor && !isCommentAuthor) {
+          return `仅可由漂流瓶发送者或评论发送者删除该漂流瓶的评论。
+可以发送"我的漂流瓶"查看你发送的漂流瓶序号。`;
+        }
+        if (!isBottleAuthor && isCommentAuthor) {
+          await ctx.database.remove("maple-drift-bottle-comments", {
+            bottleId,
+            author: userId
+          });
+          const deletedCount = userComments.length;
+          return `已成功删除你在漂流瓶 #${bottleId} 的评论（共 ${deletedCount} 条）。`;
+        }
+      }
+      await ctx.database.remove("maple-drift-bottle-comments", {
+        bottleId
+      });
+      return `已成功删除漂流瓶 #${bottleId} 的所有评论（共 ${comments.length} 条）。`;
+    } catch (error) {
+      ctx.logger("maple-drift-bottle").error("删除漂流瓶评论时出错:", error);
+      return "删除漂流瓶评论时出错了，请稍后再试。";
+    }
+  });
+  ctx.command("漂流瓶/清空漂流瓶评论 [options]", "清空漂流瓶评论").alias("清空漂流瓶评论").option("all", "-a  清空所有漂流瓶评论（默认）").option("user", "-u <userId:string>  清空指定用户的所有漂流瓶评论").example("清空漂流瓶评论").example("清空漂流瓶评论 -u 123456").action(async ({ session, options }) => {
+    try {
+      const query = {};
+      let description = "";
+      if (options.user) {
+        query.author = options.user;
+        description += `用户 ${options.user} 的`;
+      }
+      if (!options.user) {
+        description = "所有";
+      }
+      const comments = await ctx.database.get("maple-drift-bottle-comments", query);
+      const count = comments.length;
+      if (count === 0) {
+        return `没有找到${description}漂流瓶评论。`;
+      }
+      await ctx.database.remove("maple-drift-bottle-comments", query);
+      return `已成功清空 ${count} 条${description}漂流瓶评论。`;
+    } catch (error) {
+      ctx.logger("maple-drift-bottle").error("清空漂流瓶评论时出错:", error);
+      return "清空漂流瓶评论时出错了，请稍后再试。";
+    }
+  });
   ctx.command("漂流瓶/清空漂流瓶 [options]", "清空漂流瓶").alias("清空漂流瓶").alias("清空瓶子").option("all", "-a  清空所有漂流瓶（默认）").option("user", "-u <userId:string>  清空指定用户的所有漂流瓶").option("date", "-d <date:string>  清空指定日期之前的漂流瓶（格式: yyyy-mm-dd）").example("清空漂流瓶").example("清空漂流瓶 -d 2023-12-31").action(async ({ session, options }) => {
     try {
       const query = {};
@@ -458,29 +571,13 @@ ${bottle.content}`);
       if (count === 0) {
         return `没有找到${description}漂流瓶。`;
       }
-      if (config.saveImagesLocally) {
-        let deletedImages = 0;
-        for (const bottle of bottles) {
-          if (bottle.images && bottle.images.length > 0) {
-            for (const imageName of bottle.images) {
-              try {
-                const imagePath = (0, import_path.join)(config.imageSavePath, imageName);
-                if ((0, import_fs.existsSync)(imagePath)) {
-                  await (0, import_promises.rm)(imagePath);
-                  deletedImages++;
-                }
-              } catch (error) {
-                ctx.logger("maple-drift-bottle").warn(`删除图片文件失败: ${imageName}`, error);
-              }
-            }
-          }
-        }
-        if (deletedImages > 0) {
-          ctx.logger("maple-drift-bottle").info(`清空漂流瓶时删除了 ${deletedImages} 张图片文件`);
-        }
+      for (const bottle of bottles) {
+        await ctx.database.remove("maple-drift-bottle-comments", {
+          bottleId: bottle.id
+        });
       }
       await ctx.database.remove("maple-drift-bottles", query);
-      return `已成功清空 ${count} 条${description}漂流瓶记录。`;
+      return `已成功清空 ${count} 条${description}漂流瓶记录，并同时删除了相关评论。`;
     } catch (error) {
       ctx.logger("maple-drift-bottle").error("清空漂流瓶时出错:", error);
       return "清空漂流瓶时出错了，请稍后再试。";
@@ -533,27 +630,13 @@ ${failDetails.join("\n")}`;
       return "联系漂流瓶管理人时出错了，请稍后再试。";
     }
   });
-  ctx.on("ready", async () => {
+  ctx.on("ready", () => {
     console.log("maple-drift-bottle 漂流瓶插件已加载完成");
-    if (config.saveImagesLocally) {
-      if (!(0, import_fs.existsSync)(config.imageSavePath)) {
-        await (0, import_promises.mkdir)(config.imageSavePath, { recursive: true });
-        ctx.logger("maple-drift-bottle").info(`创建图片保存目录: ${config.imageSavePath}`);
-      }
-    }
     ctx.logger("maple-drift-bottle").info(`默认匿名设置: ${config.anonymousByDefault ? "是" : "否"}`);
-    ctx.logger("maple-drift-bottle").info(`内容最大长度: ${config.maxContentLength} 字符`);
+    ctx.logger("maple-drift-bottle").info(`内容最大长度: ${config.maxContentLength} 字`);
     ctx.logger("maple-drift-bottle").info(`我的漂流瓶最大预览字数: ${config.maxPreviewLength} 字`);
-    ctx.logger("maple-drift-bottle").info(`最大图片数量: ${config.maxImages} 张`);
-    ctx.logger("maple-drift-bottle").info(`本地保存图片: ${config.saveImagesLocally ? "是" : "否"}`);
-    if (config.saveImagesLocally) {
-      ctx.logger("maple-drift-bottle").info(`图片保存路径: ${config.imageSavePath}`);
-      ctx.logger("maple-drift-bottle").info(`压缩图片: ${config.compressImages ? "是" : "否"}`);
-      if (config.compressImages) {
-        ctx.logger("maple-drift-bottle").info(`图片最大尺寸: ${config.maxImageWidth}x${config.maxImageHeight} 像素`);
-        ctx.logger("maple-drift-bottle").info(`图片质量: ${config.imageQuality}%`);
-      }
-    }
+    ctx.logger("maple-drift-bottle").info(`漂流瓶评论最大长度: ${config.maxCommentLength} 字`);
+    ctx.logger("maple-drift-bottle").info(`漂流瓶图片大小限制: ${config.maxImageSize} KB`);
     ctx.logger("maple-drift-bottle").info(`管理人QQ: ${config.adminQQ.length > 0 ? config.adminQQ.join(", ") : "未配置"}`);
   });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-maple-drift-bottle",
   "description": "-",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -14,8 +14,5 @@
   ],
   "peerDependencies": {
     "koishi": "^4.18.7"
-  },
-  "dependencies": {
-    "sharp": "^0.33.0"
   }
 }

package/lib/index.d.ts

@@ -1,33 +0,0 @@
-import { Context, Schema } from 'koishi';
-export declare const name = "maple-drift-bottle";
-export declare const using: readonly ["database"];
-interface DriftBottle {
-    id: number;
-    author: string;
-    authorName: string;
-    anonymous: boolean;
-    content: string;
-    images: string[];
-    created: Date;
-}
-declare module 'koishi' {
-    interface Tables {
-        'maple-drift-bottles': DriftBottle;
-    }
-}
-export interface Config {
-    anonymousByDefault: boolean;
-    maxContentLength: number;
-    maxPreviewLength: number;
-    maxImages: number;
-    saveImagesLocally: boolean;
-    imageSavePath: string;
-    compressImages: boolean;
-    maxImageWidth: number;
-    maxImageHeight: number;
-    imageQuality: number;
-    adminQQ: string[];
-}
-export declare const Config: Schema<Config>;
-export declare function apply(ctx: Context, config: Config): void;
-export {};