koishi-plugin-best-cave 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 shangxue
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/index.d.ts

@@ -0,0 +1,19 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "cave";
+export declare const inject: string[];
+export interface User {
+    userId: string;
+    username: string;
+    nickname?: string;
+}
+export interface getStrangerInfo {
+    user_id: string;
+    nickname: string;
+}
+export interface Config {
+    manager: string[];
+    number: number;
+    enableAudit: boolean;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): Promise<void>;

package/lib/index.js

@@ -0,0 +1,502 @@
+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) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var logger = new import_koishi.Logger("cave");
+var name = "cave";
+var inject = ["database"];
+var Config = import_koishi.Schema.object({
+  manager: import_koishi.Schema.array(import_koishi.Schema.string()).required().description("管理员账号"),
+  number: import_koishi.Schema.number().default(60).description("群内调用冷却时间（秒）"),
+  enableAudit: import_koishi.Schema.boolean().default(false).description("是否开启审核功能")
+});
+function readJsonData(filePath, validator) {
+  try {
+    const data = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(data || "[]");
+    if (!Array.isArray(parsed)) return [];
+    return validator ? parsed.filter(validator) : parsed;
+  } catch (error) {
+    logger.error(`读取文件失败 ${filePath}: ${error.message}`);
+    return [];
+  }
+}
+__name(readJsonData, "readJsonData");
+function writeJsonData(filePath, data) {
+  try {
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+  } catch (error) {
+    logger.error(`写入文件失败: ${error.message}`);
+    throw error;
+  }
+}
+__name(writeJsonData, "writeJsonData");
+async function ensureDirectory(dir) {
+  try {
+    if (!fs.existsSync(dir)) {
+      await fs.promises.mkdir(dir, { recursive: true });
+    }
+  } catch (error) {
+    logger.error(`创建目录失败 ${dir}: ${error.message}`);
+    throw error;
+  }
+}
+__name(ensureDirectory, "ensureDirectory");
+async function ensureJsonFile(filePath, defaultContent = "[]") {
+  try {
+    if (!fs.existsSync(filePath)) {
+      await fs.promises.writeFile(filePath, defaultContent, "utf8");
+    }
+  } catch (error) {
+    logger.error(`创建文件失败 ${filePath}: ${error.message}`);
+    throw error;
+  }
+}
+__name(ensureJsonFile, "ensureJsonFile");
+async function saveImages(urls, imageDir, caveId, config, ctx) {
+  const savedFiles = [];
+  for (let i = 0; i < urls.length; i++) {
+    try {
+      const url = urls[i];
+      const processedUrl = (() => {
+        try {
+          const decodedUrl = decodeURIComponent(url);
+          if (decodedUrl.includes("multimedia.nt.qq.com.cn")) {
+            return decodedUrl.replace(/&amp;/g, "&");
+          }
+          return url;
+        } catch {
+          return url;
+        }
+      })();
+      const ext = url.match(/\.([^./?]+)(?:[?#]|$)/)?.[1] || "png";
+      const filename = `${caveId}_${i + 1}.${ext}`;
+      const targetPath = path.join(imageDir, filename);
+      const buffer = await ctx.http.get(processedUrl, {
+        responseType: "arraybuffer",
+        timeout: 3e4,
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+          "Accept": "image/*",
+          "Referer": "https://qq.com"
+        }
+      });
+      if (buffer && buffer.byteLength > 0) {
+        await fs.promises.writeFile(targetPath, Buffer.from(buffer));
+        savedFiles.push(filename);
+      }
+    } catch (error) {
+      logger.error(`保存图片失败: ${error.message}`);
+    }
+  }
+  return savedFiles;
+}
+__name(saveImages, "saveImages");
+async function sendAuditMessage(ctx, config, cave, content) {
+  const auditMessage = `待审核回声洞：
+${content}
+来自：${cave.contributor_number}`;
+  for (const managerId of config.manager) {
+    try {
+      await ctx.bots[0]?.sendPrivateMessage(managerId, auditMessage);
+    } catch (error) {
+      logger.error(`发送审核消息 ${managerId} 失败: ${error.message}`);
+    }
+  }
+}
+__name(sendAuditMessage, "sendAuditMessage");
+async function handleSingleCaveAudit(ctx, cave, isApprove, imageDir, data) {
+  try {
+    if (isApprove && data) {
+      const caveWithoutIndex = {
+        ...cave,
+        elements: cleanElementsForSave(cave.elements, false)
+      };
+      data.push(caveWithoutIndex);
+      logger.info(`审核通过回声洞（${cave.cave_id}）`);
+    } else if (!isApprove && cave.elements) {
+      for (const element of cave.elements) {
+        if (element.type === "img" && element.file) {
+          const fullPath = path.join(imageDir, element.file);
+          if (fs.existsSync(fullPath)) fs.unlinkSync(fullPath);
+        }
+      }
+      logger.info(`审核失败回声洞（${cave.cave_id}）`);
+    }
+    return true;
+  } catch (error) {
+    logger.error(`处理回声洞（${cave.cave_id}）失败: ${error.message}`);
+    return false;
+  }
+}
+__name(handleSingleCaveAudit, "handleSingleCaveAudit");
+async function handleAudit(ctx, pendingData, isApprove, caveFilePath, imageDir, pendingFilePath, targetId) {
+  if (pendingData.length === 0) return "没有待审核回声洞";
+  if (typeof targetId === "number") {
+    const pendingIndex = pendingData.findIndex((item) => item.cave_id === targetId);
+    if (pendingIndex === -1) return "未找到该待审核回声洞";
+    const cave = pendingData[pendingIndex];
+    const data2 = isApprove ? readJsonData(caveFilePath) : null;
+    const success = await handleSingleCaveAudit(ctx, cave, isApprove, imageDir, data2);
+    if (!success) return "处理失败，请稍后重试";
+    if (isApprove && data2) writeJsonData(caveFilePath, data2);
+    pendingData.splice(pendingIndex, 1);
+    writeJsonData(pendingFilePath, pendingData);
+    const remainingCount = pendingData.length;
+    if (remainingCount > 0) {
+      const remainingIds = pendingData.map((c) => c.cave_id).join(", ");
+      return `${isApprove ? "审核通过" : "拒绝"}成功，还有 ${remainingCount} 条待审核：[${remainingIds}]`;
+    }
+    return isApprove ? "已通过该回声洞" : "已拒绝该回声洞";
+  }
+  const data = isApprove ? readJsonData(caveFilePath) : null;
+  let processedCount = 0;
+  for (const cave of pendingData) {
+    const success = await handleSingleCaveAudit(ctx, cave, isApprove, imageDir, data);
+    if (success) processedCount++;
+  }
+  if (isApprove && data) writeJsonData(caveFilePath, data);
+  writeJsonData(pendingFilePath, []);
+  return isApprove ? `✅ 已通过 ${processedCount}/${pendingData.length} 条回声洞` : `❌ 已拒绝 ${processedCount}/${pendingData.length} 条回声洞`;
+}
+__name(handleAudit, "handleAudit");
+function buildMessage(cave, imageDir) {
+  let content = `回声洞 ——（${cave.cave_id}）
+`;
+  for (const element of cave.elements) {
+    if (element.type === "text") {
+      content += element.content + "\n";
+    } else if (element.type === "img" && element.file) {
+      try {
+        const fullImagePath = path.join(imageDir, element.file);
+        if (fs.existsSync(fullImagePath)) {
+          const imageBuffer = fs.readFileSync(fullImagePath);
+          const base64Image = imageBuffer.toString("base64");
+          content += (0, import_koishi.h)("image", { src: `data:image/png;base64,${base64Image}` }) + "\n";
+        }
+      } catch (error) {
+        logger.error(`读取图片失败: ${error.message}`);
+      }
+    }
+  }
+  return content + `—— ${cave.contributor_name}`;
+}
+__name(buildMessage, "buildMessage");
+function cleanElementsForSave(elements, keepIndex = false) {
+  const sorted = elements.sort((a, b) => a.index - b.index);
+  return sorted.map(({ type, content, file, index }) => ({
+    type,
+    ...keepIndex && { index },
+    ...content && { content },
+    ...file && { file }
+  }));
+}
+__name(cleanElementsForSave, "cleanElementsForSave");
+async function apply(ctx, config) {
+  const dataDir = path.join(ctx.baseDir, "data");
+  const caveDir = path.join(dataDir, "cave");
+  const caveFilePath = path.join(caveDir, "cave.json");
+  const imageDir = path.join(caveDir, "images");
+  const pendingFilePath = path.join(caveDir, "pending.json");
+  try {
+    await ensureDirectory(dataDir);
+    await ensureDirectory(caveDir);
+    await ensureDirectory(imageDir);
+    await ensureJsonFile(caveFilePath);
+    await ensureJsonFile(pendingFilePath);
+  } catch (error) {
+    logger.error("初始化目录结构失败:", error);
+    throw error;
+  }
+  const lastUsed = /* @__PURE__ */ new Map();
+  ctx.command("cave", "回声洞").usage("支持添加、抽取、查看、查询回声洞").example("cave           随机抽取回声洞").example("cave -a 内容   添加新回声洞").example("cave -g/r x      查看/删除指定回声洞").example("cave -p/d x/all  通过/拒绝待审回声洞").example("cave -l x      查询投稿者投稿列表").option("a", "添加回声洞").option("g", "查看回声洞", { type: "string" }).option("r", "删除回声洞", { type: "string" }).option("p", "通过审核", { type: "string" }).option("d", "拒绝审核", { type: "string" }).option("l", "查询投稿统计", { type: "string" }).before(async ({ session, options }) => {
+    if ((options.l || options.p || options.d) && !config.manager.includes(session.userId)) {
+      return "只有管理员才能执行此操作";
+    }
+  }).action(async ({ session, options }, ...content) => {
+    if (options.l !== void 0) {
+      let formatIds = function(ids) {
+        const lines = [];
+        for (let i = 0; i < ids.length; i += 10) {
+          lines.push(ids.slice(i, i + 10).join(", "));
+        }
+        return lines.join("\n");
+      };
+      __name(formatIds, "formatIds");
+      const caveFilePath2 = path.join(ctx.baseDir, "data", "cave", "cave.json");
+      const caveDir2 = path.join(ctx.baseDir, "data", "cave");
+      const caveData = readJsonData(caveFilePath2);
+      const stats = {};
+      for (const cave of caveData) {
+        if (cave.contributor_number === "10000") continue;
+        if (!stats[cave.contributor_number]) stats[cave.contributor_number] = [];
+        stats[cave.contributor_number].push(cave.cave_id);
+      }
+      const statFilePath = path.join(caveDir2, "stat.json");
+      try {
+        fs.writeFileSync(statFilePath, JSON.stringify(stats, null, 2), "utf8");
+      } catch (error) {
+        logger.error(`写入投稿统计失败: ${error.message}`);
+      }
+      let queryId = null;
+      if (typeof options.l === "string") {
+        const match = String(options.l).match(/\d+/);
+        if (match) queryId = match[0];
+      } else if (!queryId && content.length > 0) {
+        const numberMatch = content.join(" ").match(/\d+/);
+        if (numberMatch) {
+          queryId = numberMatch[0];
+        }
+      }
+      if (queryId) {
+        if (stats[queryId]) {
+          const count = stats[queryId].length;
+          return `${queryId} 共计投稿 ${count} 项回声洞:
+` + formatIds(stats[queryId]);
+        } else {
+          return `未找到投稿者 ${queryId}`;
+        }
+      } else {
+        let total = 0;
+        const lines = Object.entries(stats).map(([cid, ids]) => {
+          total += ids.length;
+          return `${cid} 共计投稿 ${ids.length} 项回声洞:
+` + formatIds(ids);
+        });
+        return `共计投稿 ${total} 项回声洞:
+` + lines.join("\n");
+      }
+    }
+    try {
+      if (options.p || options.d) {
+        const pendingData = readJsonData(pendingFilePath);
+        const isApprove = Boolean(options.p);
+        if (options.p === true && content[0] === "all" || options.d === true && content[0] === "all") {
+          return await handleAudit(ctx, pendingData, isApprove, caveFilePath, imageDir, pendingFilePath);
+        }
+        const id = parseInt(content[0] || (typeof options.p === "string" ? options.p : "") || (typeof options.d === "string" ? options.d : ""));
+        if (isNaN(id)) return "请输入正确的回声洞序号";
+        return await handleAudit(ctx, pendingData, isApprove, caveFilePath, imageDir, pendingFilePath, id);
+      }
+      const data = readJsonData(
+        caveFilePath,
+        (item) => item && typeof item.cave_id === "number" && Array.isArray(item.elements) && item.elements.every(
+          (el) => el.type === "text" && typeof el.content === "string" || el.type === "img" && typeof el.file === "string"
+        ) && typeof item.contributor_number === "string" && typeof item.contributor_name === "string"
+      );
+      if (options.a) {
+        const originalContent = session.quote?.content || session.content;
+        const elements = [];
+        const imageUrls = [];
+        const prefixes = Array.isArray(session.app.config.prefix) ? session.app.config.prefix : [session.app.config.prefix];
+        const nicknames = Array.isArray(session.app.config.nickname) ? session.app.config.nickname : session.app.config.nickname ? [session.app.config.nickname] : [];
+        const allTriggers = [...prefixes, ...nicknames];
+        const triggerPattern = allTriggers.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+        const commandPattern = new RegExp(`^(?:${triggerPattern})?\\s*cave -a\\s*`);
+        const textParts = originalContent.replace(commandPattern, "").split(/<img[^>]+>/g).map((text) => text.trim()).filter((text) => text).map((text, idx) => ({
+          type: "text",
+          content: text,
+          index: idx * 2
+          // 文本使用偶数索引
+        }));
+        const imgMatches = originalContent.match(/<img[^>]+src="([^"]+)"[^>]*>/g) || [];
+        const imageElements = imgMatches.map((img, idx) => {
+          const match = img.match(/src="([^"]+)"/);
+          if (match?.[1]) {
+            imageUrls.push(match[1]);
+            return {
+              type: "img",
+              index: idx * 2 + 1
+              // 图片使用奇数索引
+            };
+          }
+          return null;
+        }).filter((el) => el !== null);
+        const pendingData = readJsonData(pendingFilePath);
+        const maxDataId = data.length > 0 ? Math.max(...data.map((item) => item.cave_id)) : 0;
+        const maxPendingId = pendingData.length > 0 ? Math.max(...pendingData.map((item) => item.cave_id)) : 0;
+        const caveId = Math.max(maxDataId, maxPendingId) + 1;
+        let savedImages = [];
+        if (imageUrls.length > 0) {
+          try {
+            savedImages = await saveImages(imageUrls, imageDir, caveId, config, ctx);
+          } catch (error) {
+            logger.error(`保存图片失败: ${error.message}`);
+          }
+        }
+        elements.push(...textParts);
+        savedImages.forEach((file, idx) => {
+          if (imageElements[idx]) {
+            elements.push({
+              ...imageElements[idx],
+              type: "img",
+              file
+            });
+          }
+        });
+        elements.sort((a, b) => a.index - b.index);
+        if (elements.length === 0) {
+          return "添加失败：无内容，请尝试重新发送";
+        }
+        let contributorName = session.username;
+        if (ctx.database) {
+          try {
+            const userInfo = await ctx.database.getUser(session.platform, session.userId);
+            contributorName = userInfo?.nickname || session.username;
+          } catch (error) {
+            logger.error(`获取用户昵称失败: ${error.message}`);
+          }
+        }
+        const newCave = {
+          cave_id: caveId,
+          elements: cleanElementsForSave(elements, true),
+          contributor_number: session.userId,
+          contributor_name: contributorName
+        };
+        if (config.enableAudit) {
+          pendingData.push({
+            ...newCave,
+            elements: cleanElementsForSave(elements, true)
+          });
+          writeJsonData(pendingFilePath, pendingData);
+          await sendAuditMessage(ctx, config, newCave, buildMessage(newCave, imageDir));
+          return `✨ 已提交审核，序号为 (${caveId})`;
+        }
+        const caveWithoutIndex = {
+          ...newCave,
+          elements: cleanElementsForSave(elements, false)
+        };
+        data.push(caveWithoutIndex);
+        writeJsonData(caveFilePath, data);
+        return `✨ 添加成功！序号为 (${caveId})`;
+      }
+      if (options.g) {
+        const caveId = parseInt(content[0] || (typeof options.g === "string" ? options.g : ""));
+        if (isNaN(caveId)) {
+          return "请输入正确的回声洞序号";
+        }
+        const cave = data.find((item) => item.cave_id === caveId);
+        if (!cave) {
+          return "未找到该序号的回声洞";
+        }
+        return buildMessage(cave, imageDir);
+      }
+      if (!options.a && !options.g && !options.r) {
+        if (data.length === 0) return "暂无回声洞可用";
+        const guildId = session.guildId;
+        const now = Date.now();
+        const lastCall = lastUsed.get(guildId) || 0;
+        const isManager = config.manager.includes(session.userId);
+        if (!isManager && now - lastCall < config.number * 1e3) {
+          const waitTime = Math.ceil((config.number * 1e3 - (now - lastCall)) / 1e3);
+          return `群聊冷却中...请${waitTime}秒后再试`;
+        }
+        if (!isManager) {
+          lastUsed.set(guildId, now);
+        }
+        const cave = (() => {
+          const validCaves = data.filter((cave2) => cave2.elements && cave2.elements.length > 0);
+          if (!validCaves.length) return void 0;
+          const randomIndex = Math.floor(Math.random() * validCaves.length);
+          return validCaves[randomIndex];
+        })();
+        if (!cave) return "获取回声洞失败";
+        return buildMessage(cave, imageDir);
+      }
+      if (options.r) {
+        const caveId = parseInt(content[0] || (typeof options.r === "string" ? options.r : ""));
+        if (isNaN(caveId)) {
+          return "请输入正确的回声洞序号";
+        }
+        const index = data.findIndex((item) => item.cave_id === caveId);
+        const pendingData = readJsonData(pendingFilePath);
+        const pendingIndex = pendingData.findIndex((item) => item.cave_id === caveId);
+        if (index === -1 && pendingIndex === -1) {
+          return "未找到该序号的回声洞";
+        }
+        let targetCave;
+        let isPending = false;
+        if (index !== -1) {
+          targetCave = data[index];
+        } else {
+          targetCave = pendingData[pendingIndex];
+          isPending = true;
+        }
+        if (targetCave.contributor_number !== session.userId && !config.manager.includes(session.userId)) {
+          return "你不是这条回声洞的添加者！";
+        }
+        if (targetCave.elements) {
+          try {
+            for (const element of targetCave.elements) {
+              if (element.type === "img" && element.file) {
+                const fullPath = path.join(imageDir, element.file);
+                if (fs.existsSync(fullPath)) {
+                  fs.unlinkSync(fullPath);
+                }
+              }
+            }
+          } catch (error) {
+            logger.error(`删除图片失败: ${error.message}`);
+          }
+        }
+        if (isPending) {
+          pendingData.splice(pendingIndex, 1);
+          writeJsonData(pendingFilePath, pendingData);
+          return `✅ 已删除待审核回声洞 （${caveId}）`;
+        } else {
+          data.splice(index, 1);
+          writeJsonData(caveFilePath, data);
+          return `✅ 已删除回声洞 （${caveId}）`;
+        }
+      }
+    } catch (error) {
+      logger.error(`操作失败: ${error.message}`);
+      return "操作失败，请稍后重试";
+    }
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "koishi-plugin-best-cave",
+  "description": "最好的 cave 插件，可开关的审核系统，可引用添加，支持图文混合内容，可查阅投稿列表，完美复刻你的 .cave 体验！",
+  "version": "0.0.1",
+  "contributors": [
+    "Yis_Rime <yis_rime@outlook.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YisRime/koishi-plugin-best-cave.git"
+  },
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {},
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin",
+    "cave"
+  ],
+  "devDependencies": {},
+  "peerDependencies": {
+    "koishi": "^4.18.3"
+  }
+}

package/readme.md

@@ -0,0 +1,39 @@
+# koishi-plugin-best-cave
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-best-cave?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-best-cave)
+
+## 简介
+
+最好的 cave 插件，可开关的审核系统，可引用添加，支持图文混合内容，可查阅投稿列表，完美复刻你的 .cave 体验！
+
+## 核心功能
+
+- 支持文字与图片混合保存
+- 智能处理各类图片链接
+- 完整的权限管理系统
+- 可选的内容审核流程
+- 群组调用冷却机制
+
+## 基础指令
+
+| 指令 | 说明 | 权限 |
+|------|------|------|
+| `cave` | 随机展示一条回声洞 | 所有人 |
+| `cave -a <内容>` | 添加新回声洞 | 所有人 |
+| `cave -g <编号>` | 查看指定回声洞 | 所有人 |
+| `cave -r <编号>` | 删除指定回声洞 | 内容贡献者/管理员 |
+
+## 管理指令
+
+| 指令 | 说明 | 权限 |
+|------|------|------|
+| `cave -l [用户ID]` | 查看投稿统计 | 管理员 |
+| `cave -p <编号/all>` | 通过待审核内容 | 管理员 |
+| `cave -d <编号/all>` | 拒绝待审核内容 | 管理员 |
+
+## 注意事项
+
+1. 图片会自动保存到本地，请确保存储空间充足
+2. 管理员不受群组冷却时间限制
+3. 开启审核模式后，新内容需要审核才能生效
+4. 引用消息添加支持保留原消息格式