koishi-plugin-best-cave 0.0.1 → 1.0.1

package/lib/index.d.ts

@@ -1,6 +1,8 @@
 import { Context, Schema } from 'koishi';
 export declare const name = "cave";
 export declare const inject: string[];
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): Promise<void>;
 export interface User {
     userId: string;
     username: string;
@@ -14,6 +16,19 @@ export interface Config {
     manager: string[];
     number: number;
     enableAudit: boolean;
+    allowVideo: boolean;
+    videoMaxSize: number;
+    imageMaxSize: number;
+    blacklist: string[];
+    whitelist: string[];
+    enablePagination: boolean;
+    itemsPerPage: number;
 }
-export declare const Config: Schema<Config>;
-export declare function apply(ctx: Context, config: Config): Promise<void>;
+export declare function initCavePaths(ctx: Context): Promise<{
+    dataDir: string;
+    caveDir: string;
+    caveFilePath: string;
+    resourceDir: string;
+    pendingFilePath: string;
+}>;
+export declare function handleCaveAction(ctx: Context, config: Config, session: any, options: any, content: string[], lastUsed: Map<string, number>): Promise<string | void>;

package/lib/index.js

@@ -32,6 +32,8 @@ var src_exports = {};
 __export(src_exports, {
   Config: () => Config,
   apply: () => apply,
+  handleCaveAction: () => handleCaveAction,
+  initCavePaths: () => initCavePaths,
   inject: () => inject,
   name: () => name
 });
@@ -39,96 +41,134 @@ 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("是否开启审核功能")
+  manager: import_koishi.Schema.array(import_koishi.Schema.string()).required().description("管理员"),
+  blacklist: import_koishi.Schema.array(import_koishi.Schema.string()).default([]).description("黑名单"),
+  number: import_koishi.Schema.number().default(60).description("调用冷却时间（秒）"),
+  enableAudit: import_koishi.Schema.boolean().default(false).description("审核功能"),
+  allowVideo: import_koishi.Schema.boolean().default(true).description("允许添加视频"),
+  videoMaxSize: import_koishi.Schema.number().default(10).description("视频最大大小（MB）"),
+  imageMaxSize: import_koishi.Schema.number().default(5).description("图片最大大小（MB）")
 });
-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 [];
-  }
+async function apply(ctx, config) {
+  const { caveFilePath, resourceDir, pendingFilePath } = await initCavePaths(ctx);
+  const lastUsed = /* @__PURE__ */ new Map();
+  ctx.command("cave [message:text]", "回声洞").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 (config.blacklist.includes(session.userId)) return "你已被列入黑名单";
+    if (session.content && session.content.includes("-help")) return;
+    if ((options.l || options.p || options.d) && !config.manager.includes(session.userId)) {
+      return "此操作仅管理员可用";
+    }
+  }).action(async ({ session, options }, ...content) => {
+    return await handleCaveAction(ctx, config, session, options, content, lastUsed);
+  });
 }
-__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(apply, "apply");
+var logger = new import_koishi.Logger("cave");
+var FileHandler = class {
+  static {
+    __name(this, "FileHandler");
   }
-}
-__name(writeJsonData, "writeJsonData");
-async function ensureDirectory(dir) {
-  try {
-    if (!fs.existsSync(dir)) {
-      await fs.promises.mkdir(dir, { recursive: true });
+  static 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) {
+      throw new Error(`操作失败: ${error.message}`);
     }
-  } 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");
+  static writeJsonData(filePath, data) {
+    try {
+      fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+    } catch (error) {
+      throw new Error(`操作失败: ${error.message}`);
     }
-  } catch (error) {
-    logger.error(`创建文件失败 ${filePath}: ${error.message}`);
-    throw error;
   }
-}
-__name(ensureJsonFile, "ensureJsonFile");
-async function saveImages(urls, imageDir, caveId, config, ctx) {
+  static async ensureDirectory(dir) {
+    try {
+      if (!fs.existsSync(dir)) {
+        await fs.promises.mkdir(dir, { recursive: true });
+      }
+    } catch (error) {
+      throw new Error(`操作失败: ${error.message}`);
+    }
+  }
+  static async ensureJsonFile(filePath, defaultContent = "[]") {
+    try {
+      if (!fs.existsSync(filePath)) {
+        await fs.promises.writeFile(filePath, defaultContent, "utf8");
+      }
+    } catch (error) {
+      throw new Error(`操作失败: ${error.message}`);
+    }
+  }
+};
+async function saveMedia(urls, fileSuggestions, resourceDir, caveId, config, ctx, mediaType) {
   const savedFiles = [];
+  const defaults = mediaType === "img" ? { ext: "png", accept: "image/*", maxSize: config.imageMaxSize } : { ext: "mp4", accept: "video/*", maxSize: config.videoMaxSize };
+  const extPattern = /\.[a-zA-Z0-9]+$/;
   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;
+          return decodedUrl.includes("multimedia.nt.qq.com.cn") ? decodedUrl.replace(/&amp;/g, "&") : 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, {
+      let ext = defaults.ext;
+      const suggestion = fileSuggestions[i];
+      if (suggestion && suggestion.includes(";")) {
+        const parts = suggestion.split(";");
+        const filenameCandidate = parts[0];
+        const sizeCandidate = parseInt(parts[1]);
+        if (extPattern.test(filenameCandidate)) {
+          ext = filenameCandidate.match(extPattern)[0].slice(1);
+        }
+        if (sizeCandidate > defaults.maxSize * 1024 * 1024) {
+          throw new Error(`${mediaType === "img" ? "图片" : "视频"}超出大小限制 (${defaults.maxSize}MB)，实际大小为 ${(sizeCandidate / (1024 * 1024)).toFixed(2)}MB`);
+        }
+      } else if (suggestion && extPattern.test(suggestion)) {
+        ext = suggestion.match(extPattern)[0].slice(1);
+      }
+      let filename;
+      if (suggestion && suggestion.includes(";")) {
+        const parts = suggestion.split(";");
+        const srcFilename = path.basename(parts[0]);
+        filename = `${caveId}_${srcFilename}`;
+      } else if (suggestion && extPattern.test(suggestion)) {
+        const srcFilename = path.basename(suggestion);
+        filename = `${caveId}_${srcFilename}`;
+      } else {
+        filename = `${caveId}_${i + 1}.${ext}`;
+      }
+      const targetPath = path.join(resourceDir, filename);
+      const response = await ctx.http(processedUrl, {
+        method: "GET",
         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/*",
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+          "Accept": defaults.accept,
           "Referer": "https://qq.com"
         }
       });
-      if (buffer && buffer.byteLength > 0) {
-        await fs.promises.writeFile(targetPath, Buffer.from(buffer));
-        savedFiles.push(filename);
-      }
+      const fileBuffer = Buffer.from(response.data);
+      await fs.promises.writeFile(targetPath, fileBuffer);
+      savedFiles.push(filename);
     } catch (error) {
-      logger.error(`保存图片失败: ${error.message}`);
+      throw new Error(`操作失败: ${error.message}`);
     }
   }
   return savedFiles;
 }
-__name(saveImages, "saveImages");
+__name(saveMedia, "saveMedia");
 async function sendAuditMessage(ctx, config, cave, content) {
   const auditMessage = `待审核回声洞：
 ${content}
@@ -137,12 +177,12 @@ ${content}
     try {
       await ctx.bots[0]?.sendPrivateMessage(managerId, auditMessage);
     } catch (error) {
-      logger.error(`发送审核消息 ${managerId} 失败: ${error.message}`);
+      logger.error(`操作失败: ${error.message}`);
     }
   }
 }
 __name(sendAuditMessage, "sendAuditMessage");
-async function handleSingleCaveAudit(ctx, cave, isApprove, imageDir, data) {
+async function handleSingleCaveAudit(ctx, cave, isApprove, resourceDir, data) {
   try {
     if (isApprove && data) {
       const caveWithoutIndex = {
@@ -150,108 +190,159 @@ async function handleSingleCaveAudit(ctx, cave, isApprove, imageDir, data) {
         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);
+          const fullPath = path.join(resourceDir, 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;
+    throw new Error(`操作失败: ${error.message}`);
   }
 }
 __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}]`;
+async function handleAudit(ctx, pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, targetId) {
+  try {
+    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 ? FileHandler.readJsonData(caveFilePath) : null;
+      const success = await handleSingleCaveAudit(ctx, cave, isApprove, resourceDir, data2);
+      if (!success) return "处理失败，请稍后重试";
+      if (isApprove && data2) FileHandler.writeJsonData(caveFilePath, data2);
+      pendingData.splice(pendingIndex, 1);
+      FileHandler.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 ? "已通过该回声洞" : "已拒绝该回声洞";
     }
-    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++;
+    const data = isApprove ? FileHandler.readJsonData(caveFilePath) : null;
+    let processedCount = 0;
+    for (const cave of pendingData) {
+      const success = await handleSingleCaveAudit(ctx, cave, isApprove, resourceDir, data);
+      if (success) processedCount++;
+    }
+    if (isApprove && data) FileHandler.writeJsonData(caveFilePath, data);
+    FileHandler.writeJsonData(pendingFilePath, []);
+    return isApprove ? `已通过 ${processedCount}/${pendingData.length} 条回声洞` : `已拒绝 ${processedCount}/${pendingData.length} 条回声洞`;
+  } catch (error) {
+    throw new Error(`操作失败: ${error.message}`);
   }
-  if (isApprove && data) writeJsonData(caveFilePath, data);
-  writeJsonData(pendingFilePath, []);
-  return isApprove ? `✅ 已通过 ${processedCount}/${pendingData.length} 条回声洞` : `❌ 已拒绝 ${processedCount}/${pendingData.length} 条回声洞`;
 }
 __name(handleAudit, "handleAudit");
-function buildMessage(cave, imageDir) {
+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 extractMediaContent(originalContent) {
+  const parsedTexts = originalContent.split(/<img[^>]+>|<video[^>]+>/g).map((t) => t.trim()).filter((t) => t);
+  const textParts = [];
+  parsedTexts.forEach((text, idx) => {
+    textParts.push({ type: "text", content: text, index: idx * 3 });
+  });
+  const imageUrls = [];
+  const imageElements = [];
+  const videoUrls = [];
+  const videoElements = [];
+  const imgMatches = originalContent.match(/<img[^>]+src="([^"]+)"[^>]*>/g) || [];
+  imgMatches.forEach((img, idx) => {
+    const srcMatch = img.match(/src="([^"]+)"/);
+    const fileMatch = img.match(/file="([^"]+)"(?:\s+fileSize="([^"]+)")?/);
+    if (srcMatch?.[1]) {
+      imageUrls.push(srcMatch[1]);
+      const suggestion = fileMatch ? fileMatch[2] ? `${fileMatch[1]};${fileMatch[2]}` : fileMatch[1] : void 0;
+      imageElements.push({ type: "img", index: idx * 3 + 1, fileAttr: suggestion });
+    }
+  });
+  const videoMatches = originalContent.match(/<video[^>]+src="([^"]+)"[^>]*>/g) || [];
+  videoMatches.forEach((video, idx) => {
+    const srcMatch = video.match(/src="([^"]+)"/);
+    const fileMatch = video.match(/file="([^"]+)"(?:\s+fileSize="([^"]+)")?/);
+    if (srcMatch?.[1]) {
+      videoUrls.push(srcMatch[1]);
+      const suggestion = fileMatch ? fileMatch[2] ? `${fileMatch[1]};${fileMatch[2]}` : fileMatch[1] : void 0;
+      videoElements.push({ type: "video", index: idx * 3 + 2, fileAttr: suggestion });
+    }
+  });
+  return { imageUrls, imageElements, videoUrls, videoElements, textParts };
+}
+__name(extractMediaContent, "extractMediaContent");
+async function buildMessage(cave, resourceDir, session) {
   let content = `回声洞 ——（${cave.cave_id}）
 `;
+  const videoElements = [];
   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);
+        const fullImagePath = path.join(resourceDir, 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}`);
+        throw new Error(`操作失败: ${error.message}`);
       }
+    } else if (element.type === "video" && element.file) {
+      videoElements.push({ file: element.file });
     }
   }
-  return content + `—— ${cave.contributor_name}`;
+  if (videoElements.length > 0 && session) {
+    content += `[视频已发送]
+`;
+    for (const video of videoElements) {
+      try {
+        const fullVideoPath = path.join(resourceDir, video.file);
+        if (fs.existsSync(fullVideoPath)) {
+          const videoBuffer = fs.readFileSync(fullVideoPath);
+          const base64Video = videoBuffer.toString("base64");
+          session.send((0, import_koishi.h)("video", { src: `data:video/mp4;base64,${base64Video}` })).catch((error) => {
+            throw new Error(`操作失败: ${error.message}`);
+          });
+        }
+      } catch (error) {
+        throw new Error(`操作失败: ${error.message}`);
+      }
+    }
+  }
+  content += `—— ${cave.contributor_name}`;
+  return content;
 }
 __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) {
+async function initCavePaths(ctx) {
   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 resourceDir = path.join(caveDir, "resources");
   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) {
+  await FileHandler.ensureDirectory(dataDir);
+  await FileHandler.ensureDirectory(caveDir);
+  await FileHandler.ensureDirectory(resourceDir);
+  await FileHandler.ensureJsonFile(caveFilePath);
+  await FileHandler.ensureJsonFile(pendingFilePath);
+  return { dataDir, caveDir, caveFilePath, resourceDir, pendingFilePath };
+}
+__name(initCavePaths, "initCavePaths");
+async function handleCaveAction(ctx, config, session, options, content, lastUsed) {
+  const { caveFilePath, resourceDir, pendingFilePath } = await initCavePaths(ctx);
+  async function processList() {
+    try {
       let formatIds = function(ids) {
         const lines = [];
         for (let i = 0; i < ids.length; i += 10) {
@@ -260,30 +351,27 @@ async function apply(ctx, config) {
         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 caveData = FileHandler.readJsonData(caveFilePath);
+      const caveDir = path.dirname(caveFilePath);
       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");
+      const statFilePath = path.join(caveDir, "stat.json");
       try {
         fs.writeFileSync(statFilePath, JSON.stringify(stats, null, 2), "utf8");
       } catch (error) {
-        logger.error(`写入投稿统计失败: ${error.message}`);
+        throw new 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) {
+      } else if (content.length > 0) {
         const numberMatch = content.join(" ").match(/\d+/);
-        if (numberMatch) {
-          queryId = numberMatch[0];
-        }
+        if (numberMatch) queryId = numberMatch[0];
       }
       if (queryId) {
         if (stats[queryId]) {
@@ -300,203 +388,236 @@ async function apply(ctx, config) {
           return `${cid} 共计投稿 ${ids.length} 项回声洞:
 ` + formatIds(ids);
         });
-        return `共计投稿 ${total} 项回声洞:
+        return `==回声洞共计投稿 ${total} 项==
 ` + lines.join("\n");
       }
+    } catch (error) {
+      return `操作失败: ${error.message}`;
     }
+  }
+  __name(processList, "processList");
+  async function processAudit() {
     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 pendingData = FileHandler.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, resourceDir, pendingFilePath);
       }
-      const data = readJsonData(
+      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, resourceDir, pendingFilePath, id);
+    } catch (error) {
+      return `操作失败: ${error.message}`;
+    }
+  }
+  __name(processAudit, "processAudit");
+  async function processView() {
+    try {
+      const caveId = parseInt(content[0] || (typeof options.g === "string" ? options.g : ""));
+      if (isNaN(caveId)) return "请输入正确的回声洞序号";
+      const data = FileHandler.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"
+          (el) => el.type === "text" && typeof el.content === "string" || el.type === "img" && typeof el.file === "string" || el.type === "video" && 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 cave = data.find((item) => item.cave_id === caveId);
+      if (!cave) return "未找到该序号的回声洞";
+      const caveContent = await buildMessage(cave, resourceDir, session);
+      return caveContent;
+    } catch (error) {
+      return `操作失败: ${error.message}`;
+    }
+  }
+  __name(processView, "processView");
+  async function processRandom() {
+    const data = FileHandler.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 (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];
+    })();
+    return cave ? buildMessage(cave, resourceDir, session) : "获取回声洞失败";
+  }
+  __name(processRandom, "processRandom");
+  async function processDelete() {
+    try {
+      const caveId = parseInt(content[0] || (typeof options.r === "string" ? options.r : ""));
+      if (isNaN(caveId)) return "请输入正确的回声洞序号";
+      const data = FileHandler.readJsonData(
+        caveFilePath,
+        (item) => item && typeof item.cave_id === "number"
+      );
+      const pendingData = FileHandler.readJsonData(pendingFilePath);
+      const index = data.findIndex((item) => item.cave_id === caveId);
+      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 "不可删除他人添加的回声洞！";
+      }
+      const caveContent = await buildMessage(targetCave, resourceDir, session);
+      if (targetCave.elements) {
+        try {
+          for (const element of targetCave.elements) {
+            if ((element.type === "img" || element.type === "video") && element.file) {
+              const fullPath = path.join(resourceDir, element.file);
+              if (fs.existsSync(fullPath)) fs.unlinkSync(fullPath);
+            }
           }
+        } catch (error) {
+          return `操作失败: ${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 (isPending) {
+        pendingData.splice(pendingIndex, 1);
+        FileHandler.writeJsonData(pendingFilePath, pendingData);
+        return `已删除（待审核）
+${caveContent}`;
+      } else {
+        data.splice(index, 1);
+        FileHandler.writeJsonData(caveFilePath, data);
+        return `已删除
+${caveContent}`;
       }
-      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);
+    } catch (error) {
+      return `操作失败: ${error.message}`;
+    }
+  }
+  __name(processDelete, "processDelete");
+  async function processAdd() {
+    try {
+      let originalContent = session.quote?.content || session.content;
+      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}).*?-a\\s*`);
+      originalContent = originalContent.replace(commandPattern, "");
+      let { imageUrls, imageElements, videoUrls, videoElements, textParts } = await extractMediaContent(originalContent);
+      if (textParts.length === 0 && imageUrls.length === 0 && videoUrls.length === 0) {
+        await session.send("请在一分钟内发送你要添加的内容");
+        const reply = await session.prompt({ timeout: 6e4 });
+        if (!reply || reply.trim() === "") {
+          return "操作超时，放弃本次添加";
         }
-        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);
+        const replyResult = await extractMediaContent(reply);
+        imageUrls = replyResult.imageUrls;
+        imageElements = replyResult.imageElements;
+        videoUrls = replyResult.videoUrls;
+        videoElements = replyResult.videoElements;
+        textParts = replyResult.textParts;
       }
-      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 "未找到该序号的回声洞";
+      if (videoUrls.length > 0 && !config.allowVideo) {
+        return "已关闭上传视频功能";
+      }
+      const pendingData = FileHandler.readJsonData(pendingFilePath);
+      const data = FileHandler.readJsonData(caveFilePath, (item) => item && typeof item.cave_id === "number");
+      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 {
+          const fileSuggestions = imageElements.map((el) => el.fileAttr);
+          savedImages = await saveMedia(imageUrls, fileSuggestions, resourceDir, caveId, config, ctx, "img");
+        } catch (error) {
+          return `操作失败: ${error.message}`;
         }
-        let targetCave;
-        let isPending = false;
-        if (index !== -1) {
-          targetCave = data[index];
-        } else {
-          targetCave = pendingData[pendingIndex];
-          isPending = true;
+      }
+      let savedVideos = [];
+      if (videoUrls.length > 0) {
+        try {
+          const fileSuggestions = videoElements.map((el) => el.fileAttr);
+          savedVideos = await saveMedia(videoUrls, fileSuggestions, resourceDir, caveId, config, ctx, "video");
+        } catch (error) {
+          return `操作失败: ${error.message}`;
         }
-        if (targetCave.contributor_number !== session.userId && !config.manager.includes(session.userId)) {
-          return "你不是这条回声洞的添加者！";
+      }
+      const elements = [];
+      elements.push(...textParts);
+      savedImages.forEach((file, idx) => {
+        if (imageElements[idx]) {
+          elements.push({ ...imageElements[idx], type: "img", file });
         }
-        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}`);
-          }
+      });
+      savedVideos.forEach((file, idx) => {
+        if (videoElements[idx]) {
+          elements.push({ ...videoElements[idx], type: "video", file });
         }
-        if (isPending) {
-          pendingData.splice(pendingIndex, 1);
-          writeJsonData(pendingFilePath, pendingData);
-          return `✅ 已删除待审核回声洞 （${caveId}）`;
-        } else {
-          data.splice(index, 1);
-          writeJsonData(caveFilePath, data);
-          return `✅ 已删除回声洞 （${caveId}）`;
+      });
+      elements.sort((a, b) => a.index - b.index);
+      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) {
+          throw new 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) });
+        FileHandler.writeJsonData(pendingFilePath, pendingData);
+        await sendAuditMessage(ctx, config, newCave, await buildMessage(newCave, resourceDir, session));
+        return `已提交审核，序号为 (${caveId})`;
+      }
+      const caveWithoutIndex = { ...newCave, elements: cleanElementsForSave(elements, false) };
+      data.push(caveWithoutIndex);
+      FileHandler.writeJsonData(caveFilePath, data);
+      return `添加成功！序号为 (${caveId})`;
     } catch (error) {
-      logger.error(`操作失败: ${error.message}`);
-      return "操作失败，请稍后重试";
+      return `操作失败: ${error.message}`;
     }
-  });
+  }
+  __name(processAdd, "processAdd");
+  try {
+    if (options.l !== void 0) return await processList();
+    if (options.p || options.d) return await processAudit();
+    if (options.g) return await processView();
+    if (options.r) return await processDelete();
+    if (options.a) return await processAdd();
+    return await processRandom();
+  } catch (error) {
+    return `操作失败: ${error.message.replace(/^操作失败: /, "")}`;
+  }
 }
-__name(apply, "apply");
+__name(handleCaveAction, "handleCaveAction");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,
   apply,
+  handleCaveAction,
+  initCavePaths,
   inject,
   name
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "最好的 cave 插件，可开关的审核系统，可引用添加，支持图文混合内容，可查阅投稿列表，完美复刻你的 .cave 体验！",
-  "version": "0.0.1",
+  "version": "1.0.1",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],

package/readme.md

@@ -6,24 +6,25 @@
 
 最好的 cave 插件，可开关的审核系统，可引用添加，支持图文混合内容，可查阅投稿列表，完美复刻你的 .cave 体验！
 
-## 核心功能
+### 核心功能
 
 - 支持文字与图片混合保存
 - 智能处理各类图片链接
+- 可选的视频内容支持
 - 完整的权限管理系统
 - 可选的内容审核流程
 - 群组调用冷却机制
 
-## 基础指令
+### 指令
 
 | 指令 | 说明 | 权限 |
 |------|------|------|
 | `cave` | 随机展示一条回声洞 | 所有人 |
-| `cave -a <内容>` | 添加新回声洞 | 所有人 |
+| `cave -a <内容>` | 添加新回声洞（支持文字、图片与视频） | 所有人 |
 | `cave -g <编号>` | 查看指定回声洞 | 所有人 |
 | `cave -r <编号>` | 删除指定回声洞 | 内容贡献者/管理员 |
 
-## 管理指令
+#### 管理指令
 
 | 指令 | 说明 | 权限 |
 |------|------|------|
@@ -31,9 +32,10 @@
 | `cave -p <编号/all>` | 通过待审核内容 | 管理员 |
 | `cave -d <编号/all>` | 拒绝待审核内容 | 管理员 |
 
-## 注意事项
+### 注意事项
 
-1. 图片会自动保存到本地，请确保存储空间充足
-2. 管理员不受群组冷却时间限制
-3. 开启审核模式后，新内容需要审核才能生效
-4. 引用消息添加支持保留原消息格式
+1. 图片以及视频会自动保存到本地，请确保存储空间充足。
+2. 管理员不受群组冷却时间限制。
+3. 开启审核模式后，新内容需要审核才能生效。
+4. 引用消息添加支持保留原消息格式。
+5. 配置文件中可分别调整是否允许添加视频，以及各自的文件大小限制。