koishi-plugin-custom-image 0.2.7 → 0.2.9

package/lib/index.js

@@ -20,7 +20,7 @@ const locales = {
         'messages.fetchSuccess': '图片获取成功！',
         'messages.fetchWaiting': '正在获取图片，请稍候...',
         'messages.inputError': '输入内容不能为空！',
-        'messages.cacheCleared': '✅ 图片缓存已清空',
+        'messages.cacheCleared': '图片缓存已清空',
         'commands.random-image': '随机获取图片',
         'commands.random-image.options.api': '指定图片API地址',
         'commands.hsjp': '生成黑丝举牌图片',
@@ -28,29 +28,21 @@ const locales = {
         'commands.clear-image-cache': '清空图片缓存'
     }
 };
-const currentFilePath = worker_threads_1.isMainThread
-    ? __filename
-    : path_1.default.join(process.cwd(), worker_threads_1.isMainThread ? 'src/index.ts' : 'lib/index.js');
-exports.name = 'custom-image';
-exports.Config = koishi_1.Schema.object({
-    enable: koishi_1.Schema.boolean().default(true).description('启用插件'),
-    showWaitingTip: koishi_1.Schema.boolean().default(true).description('请求图片时显示等待提示'),
-    timeout: koishi_1.Schema.number().default(10000).min(0).description('API请求超时时间（毫秒）'),
-    customImageApis: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).role('textarea').description('自定义图片API列表'),
-    customImageEnabled: koishi_1.Schema.boolean().default(true).description('启用自定义图片API功能'),
-    hsjpEnabled: koishi_1.Schema.boolean().default(true).description('启用黑丝举牌功能'),
-    dmjpEnabled: koishi_1.Schema.boolean().default(true).description('启用动漫举牌功能'),
-    imageSendTimeout: koishi_1.Schema.number().default(15000).min(0).description('图片发送超时（毫秒）'),
-    autoClearCacheInterval: koishi_1.Schema.number().default(60).min(0).description('自动清理缓存间隔（分钟）'),
-    tempDir: koishi_1.Schema.string().default(path_1.default.join(process.cwd(), 'temp_images')).description('临时图片保存目录'),
-    showSuccessTip: koishi_1.Schema.boolean().default(true).description('请求图片成功时显示提示'),
-    showTimeoutTip: koishi_1.Schema.boolean().default(true).description('API请求超时后给用户提示')
-});
 if (!worker_threads_1.isMainThread) {
     const { url, filePath } = worker_threads_1.workerData;
     (async () => {
         try {
-            const response = await (0, axios_1.default)({ url, method: 'GET', responseType: 'stream', timeout: 60000, headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36' } });
+            const response = await (0, axios_1.default)({
+                url,
+                method: 'GET',
+                responseType: 'stream',
+                timeout: 60000,
+                maxRedirects: 5,
+                maxContentLength: 50 * 1024 * 1024,
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+                }
+            });
             await (0, promises_1.pipeline)(response.data, fs_1.default.createWriteStream(filePath));
             worker_threads_1.parentPort?.postMessage({ success: true, filePath });
         }
@@ -59,51 +51,117 @@ if (!worker_threads_1.isMainThread) {
         }
     })();
 }
+const httpClient = axios_1.default.create({
+    timeout: 30000,
+    maxRedirects: 5,
+    maxContentLength: 50 * 1024 * 1024,
+    headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+    }
+});
+const rateLimitMap = new Map();
+const RATE_LIMIT_MS = 3000;
+function checkRateLimit(userId) {
+    const now = Date.now();
+    const last = rateLimitMap.get(userId);
+    if (last && now - last < RATE_LIMIT_MS)
+        return false;
+    rateLimitMap.set(userId, now);
+    if (rateLimitMap.size > 10000) {
+        for (const [key, time] of rateLimitMap) {
+            if (now - time > RATE_LIMIT_MS * 2)
+                rateLimitMap.delete(key);
+        }
+    }
+    return true;
+}
+function isValidUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (!['http:', 'https:'].includes(parsed.protocol))
+            return false;
+        if (parsed.username || parsed.password)
+            return false;
+        if (!parsed.hostname)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 const delay = (ms) => new Promise(r => setTimeout(r, ms));
 function getI18nText(session, key) {
     if (session?.text)
         return session.text(key);
     const lang = 'zh-CN';
-    return locales[lang][key] || key;
+    return locales[lang]?.[key] ?? key;
 }
 async function sendTimeout(session, content, config) {
     const text = typeof content === 'string' ? getI18nText(session, content) : content;
-    if (config.imageSendTimeout <= 0)
-        return session.send(text).catch(() => null);
-    return Promise.race([session.send(text), new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), config.imageSendTimeout))]).catch(() => null);
+    const timeoutMs = config.imageSendTimeout;
+    if (timeoutMs <= 0) {
+        await session.send(text).catch(() => { });
+        return;
+    }
+    let timerId;
+    const timeout = new Promise(resolve => { timerId = setTimeout(() => resolve('timeout'), timeoutMs); });
+    await Promise.race([session.send(text).then(() => 'sent', () => 'error'), timeout]);
+    clearTimeout(timerId);
 }
-function clearAllCache(config) {
-    if (fs_1.default.existsSync(config.tempDir)) {
-        fs_1.default.readdirSync(config.tempDir).forEach(file => {
+async function clearAllCache(config) {
+    let count = 0;
+    try {
+        const resolvedDir = path_1.default.resolve(config.tempDir);
+        const entries = await fs_1.default.promises.readdir(resolvedDir);
+        const now = Date.now();
+        for (const entry of entries) {
             try {
-                const filePath = path_1.default.join(config.tempDir, file);
-                const stat = fs_1.default.statSync(filePath);
-                if (Date.now() - stat.mtimeMs > 3600000)
-                    fs_1.default.unlinkSync(filePath);
+                const filePath = path_1.default.join(resolvedDir, entry);
+                const realPath = await fs_1.default.promises.realpath(filePath);
+                if (!realPath.startsWith(resolvedDir + path_1.default.sep))
+                    continue;
+                const stat = await fs_1.default.promises.stat(filePath);
+                if (!stat.isFile())
+                    continue;
+                if (now - stat.mtimeMs > 3600000) {
+                    await fs_1.default.promises.unlink(filePath);
+                    count++;
+                }
             }
-            catch (error) { }
-        });
+            catch { }
+        }
     }
-    return true;
+    catch { }
+    return count;
 }
 function randomSelectApi(customImageApis) {
-    const validApis = customImageApis.filter(api => api.trim());
+    const validApis = customImageApis.filter(api => api && api.trim());
     if (validApis.length === 0)
         return null;
     return validApis[Math.floor(Math.random() * validApis.length)];
 }
 async function fetchImage(url, config) {
-    const http = axios_1.default.create({ timeout: config.timeout, headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36' } });
+    if (!isValidUrl(url)) {
+        return { success: false, type: '', data: '', timeout: false };
+    }
+    const imageUrlPattern = /^https?:\/\/.+\.(jpg|jpeg|png|gif|webp|bmp)(\?.*)?$/i;
+    if (imageUrlPattern.test(url)) {
+        return { success: true, type: 'url', data: url, timeout: false };
+    }
     try {
-        if (/^https?:\/\/.+\.(jpg|jpeg|png|gif|webp|bmp)/i.test(url))
-            return { success: true, type: 'url', data: url, timeout: false };
-        const res = await http.get(url, { responseType: 'arraybuffer' });
-        if (res.status === 200 && res.data)
-            return { success: true, type: 'buffer', data: res.data, timeout: false };
+        const res = await httpClient.get(url, {
+            responseType: 'arraybuffer',
+            timeout: config.timeout
+        });
+        if (res.status >= 200 && res.status < 300 && res.data) {
+            const contentType = res.headers['content-type'];
+            return { success: true, type: 'buffer', data: res.data, timeout: false, contentType };
+        }
     }
     catch (error) {
-        const isTimeout = error.message.includes('timeout');
-        return { success: false, type: '', data: '', timeout: isTimeout };
+        const isTimeout = error.message?.toLowerCase().includes('timeout');
+        return { success: false, type: '', data: '', timeout: !!isTimeout };
     }
     return { success: false, type: '', data: '', timeout: false };
 }
@@ -119,27 +177,76 @@ async function fetchDmjpImage(text, config) {
     const url = `https://api.suyanw.cn/api/dmjp.php?text=${encodedText}`;
     return fetchImage(url, config);
 }
+function buildImageElement(result) {
+    if (result.type === 'url') {
+        return koishi_1.h.image(result.data);
+    }
+    const mime = result.contentType || 'image/jpeg';
+    return koishi_1.h.image(`data:${mime};base64,${Buffer.from(result.data).toString('base64')}`);
+}
 async function processCustomImage(session, apiUrl, config) {
     const result = await fetchImage(apiUrl, config);
     if (result.timeout && config.showTimeoutTip)
         return { success: false, msg: '图片请求超时，请稍后再试' };
     if (!result.success)
         return { success: false, msg: getI18nText(session, 'messages.fetchFailed') };
-    const imageElem = koishi_1.h.image(result.type === 'url' ? result.data : `data:image/jpeg;base64,${Buffer.from(result.data).toString('base64')}`);
+    const imageElem = buildImageElement(result);
     const successText = config.showSuccessTip ? getI18nText(session, 'messages.fetchSuccess') : '';
     return { success: true, msg: 'ok', data: { text: successText, image: imageElem } };
 }
+async function processFunImage(session, config, fetchFn) {
+    const result = await fetchFn();
+    if (result.timeout && config.showTimeoutTip) {
+        await sendTimeout(session, '图片请求超时，请稍后再试', config);
+        return;
+    }
+    if (result.success) {
+        const imageElem = buildImageElement(result);
+        if (config.showSuccessTip) {
+            await sendTimeout(session, 'messages.fetchSuccess', config);
+            await delay(300);
+        }
+        await sendTimeout(session, imageElem, config);
+    }
+    else {
+        await sendTimeout(session, 'messages.fetchFailed', config);
+    }
+}
+exports.name = 'custom-image';
+exports.Config = koishi_1.Schema.object({
+    enable: koishi_1.Schema.boolean().default(true).description('启用插件'),
+    showWaitingTip: koishi_1.Schema.boolean().default(true).description('请求图片时显示等待提示'),
+    timeout: koishi_1.Schema.number().default(10000).min(0).description('API请求超时时间（毫秒）'),
+    customImageApis: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).role('textarea').description('自定义图片API列表'),
+    customImageEnabled: koishi_1.Schema.boolean().default(true).description('启用自定义图片API功能'),
+    hsjpEnabled: koishi_1.Schema.boolean().default(true).description('启用黑丝举牌功能'),
+    dmjpEnabled: koishi_1.Schema.boolean().default(true).description('启用动漫举牌功能'),
+    imageSendTimeout: koishi_1.Schema.number().default(15000).min(0).description('图片发送超时（毫秒）'),
+    autoClearCacheInterval: koishi_1.Schema.number().default(60).min(0).description('自动清理缓存间隔（分钟）'),
+    tempDir: koishi_1.Schema.string().default(path_1.default.join(process.cwd(), 'temp_images')).description('临时图片保存目录'),
+    showSuccessTip: koishi_1.Schema.boolean().default(true).description('请求图片成功时显示提示'),
+    showTimeoutTip: koishi_1.Schema.boolean().default(true).description('API请求超时后给用户提示')
+});
 function apply(ctx, config) {
     if (!worker_threads_1.isMainThread)
         return;
-    Object.keys(locales).forEach(lang => { ctx.i18n.define(lang, locales[lang]); });
-    clearAllCache(config);
+    if (ctx.i18n) {
+        Object.keys(locales).forEach(lang => {
+            ctx.i18n.define(lang, locales[lang]);
+        });
+    }
+    clearAllCache(config).catch(() => { });
     ctx.logger.info('[custom-image] 插件已加载');
     ctx.command('random-image [apis...]', locales['zh-CN']['commands.random-image'])
         .option('api', `-a <api> ${locales['zh-CN']['commands.random-image.options.api']}`)
         .action(async ({ session, options = {} }, ...apis) => {
         if (!config.enable || !config.customImageEnabled || !session)
             return;
+        const userId = session.userId || session.uid || 'unknown';
+        if (!checkRateLimit(userId)) {
+            await sendTimeout(session, 'messages.repeatRequest', config);
+            return;
+        }
         const targetApi = options.api || (apis.length ? apis.join(' ') : null);
         if (config.showWaitingTip)
             await sendTimeout(session, 'messages.fetchWaiting', config);
@@ -162,65 +269,56 @@ function apply(ctx, config) {
         .action(async ({ session }, msg, msg1 = '', msg2 = '') => {
         if (!config.enable || !config.hsjpEnabled || !session)
             return;
-        if (!msg || msg.trim().length === 0) {
+        if (!msg || !msg.trim()) {
             await sendTimeout(session, 'messages.inputError', config);
             return;
         }
-        if (config.showWaitingTip)
-            await sendTimeout(session, 'messages.fetchWaiting', config);
-        const result = await fetchHsjpImage(msg, msg1, msg2, config);
-        if (result.timeout && config.showTimeoutTip) {
-            await sendTimeout(session, '图片请求超时，请稍后再试', config);
+        if (!checkRateLimit(session.userId || session.uid || 'unknown')) {
+            await sendTimeout(session, 'messages.repeatRequest', config);
             return;
         }
-        if (result.success) {
-            const imageElem = koishi_1.h.image(result.type === 'url' ? result.data : `data:image/jpeg;base64,${Buffer.from(result.data).toString('base64')}`);
-            if (config.showSuccessTip) {
-                await sendTimeout(session, 'messages.fetchSuccess', config);
-                await delay(300);
-            }
-            await sendTimeout(session, imageElem, config);
-        }
-        else {
-            await sendTimeout(session, 'messages.fetchFailed', config);
-        }
+        if (config.showWaitingTip)
+            await sendTimeout(session, 'messages.fetchWaiting', config);
+        await processFunImage(session, config, () => fetchHsjpImage(msg, msg1, msg2, config));
     });
     ctx.command('dmjp <text>', locales['zh-CN']['commands.dmjp'])
         .action(async ({ session }, text) => {
         if (!config.enable || !config.dmjpEnabled || !session)
             return;
-        if (!text || text.trim().length === 0) {
+        if (!text || !text.trim()) {
             await sendTimeout(session, 'messages.inputError', config);
             return;
         }
-        if (config.showWaitingTip)
-            await sendTimeout(session, 'messages.fetchWaiting', config);
-        const result = await fetchDmjpImage(text, config);
-        if (result.timeout && config.showTimeoutTip) {
-            await sendTimeout(session, '图片请求超时，请稍后再试', config);
+        if (!checkRateLimit(session.userId || session.uid || 'unknown')) {
+            await sendTimeout(session, 'messages.repeatRequest', config);
             return;
         }
-        if (result.success) {
-            const imageElem = koishi_1.h.image(result.type === 'url' ? result.data : `data:image/jpeg;base64,${Buffer.from(result.data).toString('base64')}`);
-            if (config.showSuccessTip) {
-                await sendTimeout(session, 'messages.fetchSuccess', config);
-                await delay(300);
-            }
-            await sendTimeout(session, imageElem, config);
-        }
-        else {
-            await sendTimeout(session, 'messages.fetchFailed', config);
-        }
+        if (config.showWaitingTip)
+            await sendTimeout(session, 'messages.fetchWaiting', config);
+        await processFunImage(session, config, () => fetchDmjpImage(text, config));
     });
     ctx.command('clear-image-cache', locales['zh-CN']['commands.clear-image-cache'])
-        .action(({ session }) => {
-        clearAllCache(config);
-        return session ? getI18nText(session, 'messages.cacheCleared') : '✅ 图片缓存已清空';
+        .action(async ({ session }) => {
+        const count = await clearAllCache(config);
+        const base = session ? getI18nText(session, 'messages.cacheCleared') : '图片缓存已清空';
+        return `${base}（已清理 ${count} 个文件）`;
     });
     if (config.autoClearCacheInterval > 0) {
-        setInterval(() => { clearAllCache(config); ctx.logger.info('[custom-image] 缓存已自动清理'); }, config.autoClearCacheInterval * 60000);
+        setInterval(() => {
+            clearAllCache(config).then(() => {
+                ctx.logger.info('[custom-image] 缓存已自动清理');
+            }).catch(() => { });
+        }, config.autoClearCacheInterval * 60000);
     }
-    process.on('exit', () => { clearAllCache(config); ctx.logger.info('[custom-image] 插件缓存已清理'); });
+    process.on('exit', () => {
+        fs_1.default.existsSync(config.tempDir) && fs_1.default.readdirSync(config.tempDir).forEach(file => {
+            try {
+                fs_1.default.unlinkSync(path_1.default.join(config.tempDir, file));
+            }
+            catch { }
+        });
+        ctx.logger.info('[custom-image] 插件缓存已清理');
+    });
 }
 exports.inject = { optional: ['i18n'] };
 exports.using = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-custom-image",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Koishi自定义图片API插件（內置支持黑丝/动漫举牌）",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -36,5 +36,13 @@
     "dmjp"
   ],
   "author": "",
-  "license": "MIT"
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Minecraft-1314/koishi-plugin-custom-image.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Minecraft-1314/koishi-plugin-custom-image/issues"
+  },
+  "homepage": "https://github.com/Minecraft-1314/koishi-plugin-custom-image#readme"
 }

package/readme.md

@@ -1,71 +1,71 @@
-# koishi-plugin-custom-image
-
-## 项目介绍 (Project Introduction)
-
-### 中文
-这是一个为 Koishi 机器人框架开发的**随机图片获取插件**，支持从自定义 API 列表中随机选取接口获取图片，同时内置黑丝举牌、动漫举牌等趣味图片功能。核心特性：
-- 🚀 从自定义 API 列表中**随机单张选取**，不批量、不轮询
-- 🖼️ 强制使用图片 URL 直连发送
-- 💡 可配置等待提示、成功提示、超时提示
-- ⚙️ 简单易用的指令与配置项，开箱即用
-- 🧹 支持自动清理缓存与手动清理指令
-- 🎭 内置 `hsjp`、`dmjp` 等趣味图片接口
-
-### English
-A random image plugin for the Koishi bot framework. It randomly selects one API from your custom API list to fetch images, with built-in fun image APIs such as haisi and dongman. Core features:
-- 🚀 Randomly select **one API** from the custom list, no batch / loop requests
-- 🖼️ Force the use of image URLs for direct connection sending
-- 💡 Configurable waiting, success, and timeout tips
-- ⚙️ Simple commands and configurations, ready to use
-- 🧹 Auto cache cleanup & manual clear command
-- 🎭 Built-in fun image APIs: `hsjp`, `dmjp`
-
-## 项目仓库 (Repository)
-- GitHub: https://github.com/yourname/koishi-plugin-custom-image
-- Issues: https://github.com/yourname/koishi-plugin-custom-image/issues
-
-## 核心指令 (Core Commands)
-
-| 指令 (Command) | 说明 (Description) | 示例 (Example) |
-|----------------|--------------------|----------------|
-| `random-image` | 从自定义 API 列表随机获取一张图片 | `random-image` |
-| `hsjp <msg> [msg1] [msg2]` | 生成黑丝举牌图片 | `hsjp 我喜欢你` |
-| `dmjp <text>` | 生成动漫举牌图片 | `dmjp Koishi 真棒` |
-| `clear-image-cache` | 清空图片缓存 | `clear-image-cache` |
-
-## 配置项说明 (Configuration)
-
-| 配置项 (Config Item) | 类型 (Type) | 默认值 (Default) | 说明 (Description) |
-|----------------------|-------------|------------------|--------------------|
-| `enable` | boolean | true | 是否启用插件 |
-| `showWaitingTip` | boolean | true | 请求图片时是否显示等待提示 |
-| `timeout` | number | 10000 | API 请求超时时间（毫秒） |
-| `customImageApis` | string[] | [] | 自定义图片 API 列表 |
-| `customImageEnabled` | boolean | true | 是否启用自定义图片功能 |
-| `hsjpEnabled` | boolean | true | 是否启用黑丝举牌功能 |
-| `dmjpEnabled` | boolean | true | 是否启用动漫举牌功能 |
-| `imageSendTimeout` | number | 15000 | 图片发送超时（毫秒） |
-| `autoClearCacheInterval` | number | 60 | 自动清理缓存间隔（分钟） |
-| `tempDir` | string | ./temp_images | 临时图片保存目录 |
-| `showSuccessTip` | boolean | true | 请求图片成功时是否显示提示 |
-| `showTimeoutTip` | boolean | true | API 请求超时后是否给用户提示 |
-
-## 项目贡献者 (Contributors)
-
-| 贡献者 (Contributor) | 贡献内容 (Contribution) |
-|----------------------|-------------------------|
-| Minecraft-1314 | 插件完整开发 (Complete plugin development) |
-| 素颜API | 提供 API 接口支持 |
-| （欢迎提交 PR 加入贡献者列表） | （Welcome to submit PR to join the contributor list） |
-
-## 许可协议 (License)
-
-本项目采用 MIT 许可证，详情参见 [LICENSE](LICENSE) 文件。
-
-This project is licensed under the MIT License, see the [LICENSE](LICENSE) file for details.
-
-## 支持我们 (Support Us)
-
-如果这个项目对您有帮助，欢迎点亮右上角的 Star ⭐ 支持我们，这将是对所有贡献者最大的鼓励！
-
+# koishi-plugin-custom-image
+
+## 项目介绍 (Project Introduction)
+
+### 中文
+这是一个为 Koishi 机器人框架开发的**随机图片获取插件**，支持从自定义 API 列表中随机选取接口获取图片，同时内置黑丝举牌、动漫举牌等趣味图片功能。核心特性：
+- 🚀 从自定义 API 列表中**随机单张选取**，不批量、不轮询
+- 🖼️ 强制使用图片 URL 直连发送
+- 💡 可配置等待提示、成功提示、超时提示
+- ⚙️ 简单易用的指令与配置项，开箱即用
+- 🧹 支持自动清理缓存与手动清理指令
+- 🎭 内置 `hsjp`、`dmjp` 等趣味图片接口
+
+### English
+A random image plugin for the Koishi bot framework. It randomly selects one API from your custom API list to fetch images, with built-in fun image APIs such as haisi and dongman. Core features:
+- 🚀 Randomly select **one API** from the custom list, no batch / loop requests
+- 🖼️ Force the use of image URLs for direct connection sending
+- 💡 Configurable waiting, success, and timeout tips
+- ⚙️ Simple commands and configurations, ready to use
+- 🧹 Auto cache cleanup & manual clear command
+- 🎭 Built-in fun image APIs: `hsjp`, `dmjp`
+
+## 项目仓库 (Repository)
+- GitHub: https://github.com/Minecraft-1314/koishi-plugin-custom-image
+- Issues: https://github.com/Minecraft-1314/koishi-plugin-custom-image/issues
+
+## 核心指令 (Core Commands)
+
+| 指令 (Command) | 说明 (Description) | 示例 (Example) |
+|----------------|--------------------|----------------|
+| `random-image` | 从自定义 API 列表随机获取一张图片 | `random-image` |
+| `hsjp <msg> [msg1] [msg2]` | 生成黑丝举牌图片 | `hsjp 我喜欢你` |
+| `dmjp <text>` | 生成动漫举牌图片 | `dmjp Koishi 真棒` |
+| `clear-image-cache` | 清空图片缓存 | `clear-image-cache` |
+
+## 配置项说明 (Configuration)
+
+| 配置项 (Config Item) | 类型 (Type) | 默认值 (Default) | 说明 (Description) |
+|----------------------|-------------|------------------|--------------------|
+| `enable` | boolean | true | 是否启用插件 |
+| `showWaitingTip` | boolean | true | 请求图片时是否显示等待提示 |
+| `timeout` | number | 10000 | API 请求超时时间（毫秒） |
+| `customImageApis` | string[] | [] | 自定义图片 API 列表 |
+| `customImageEnabled` | boolean | true | 是否启用自定义图片功能 |
+| `hsjpEnabled` | boolean | true | 是否启用黑丝举牌功能 |
+| `dmjpEnabled` | boolean | true | 是否启用动漫举牌功能 |
+| `imageSendTimeout` | number | 15000 | 图片发送超时（毫秒） |
+| `autoClearCacheInterval` | number | 60 | 自动清理缓存间隔（分钟） |
+| `tempDir` | string | ./temp_images | 临时图片保存目录 |
+| `showSuccessTip` | boolean | true | 请求图片成功时是否显示提示 |
+| `showTimeoutTip` | boolean | true | API 请求超时后是否给用户提示 |
+
+## 项目贡献者 (Contributors)
+
+| 贡献者 (Contributor) | 贡献内容 (Contribution) |
+|----------------------|-------------------------|
+| Minecraft-1314 | 插件完整开发 (Complete plugin development) |
+| 素颜API | 提供 API 接口支持 |
+| （欢迎提交 PR 加入贡献者列表） | （Welcome to submit PR to join the contributor list） |
+
+## 许可协议 (License)
+
+本项目采用 MIT 许可证，详情参见 [LICENSE](LICENSE) 文件。
+
+This project is licensed under the MIT License, see the [LICENSE](LICENSE) file for details.
+
+## 支持我们 (Support Us)
+
+如果这个项目对您有帮助，欢迎点亮右上角的 Star ⭐ 支持我们，这将是对所有贡献者最大的鼓励！
+
 If this project is helpful to you, please feel free to star it in the upper right corner ⭐ to support us, which will be the greatest encouragement to all contributors!