koishi-plugin-custom-image 0.1.7 → 0.1.9

package/lib/index.d.ts

@@ -16,6 +16,8 @@ export interface Config {
     imageSendTimeout: number;
     autoClearCacheInterval: number;
     imageParseFormat: string;
+    downloadImageBeforeSend: boolean;
+    messageBufferDelay: number;
     tempDir: string;
 }
 export declare const Config: Schema<Config>;

package/lib/index.js

@@ -10,7 +10,9 @@ const axios_1 = __importDefault(require("axios"));
 const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
+const promises_1 = require("stream/promises");
+const worker_threads_1 = require("worker_threads");
+const currentFilePath = path_1.default.join(process.cwd(), 'src', 'index.ts');
 exports.name = 'custom-image';
 exports.Config = koishi_1.Schema.object({
     enable: koishi_1.Schema.boolean()
@@ -65,13 +67,40 @@ exports.Config = koishi_1.Schema.object({
     imageParseFormat: koishi_1.Schema.string()
         .default('✅ 图片获取成功')
         .description('【格式设置】图片发送前的提示文本'),
+    downloadImageBeforeSend: koishi_1.Schema.boolean()
+        .default(true)
+        .description('【展示设置】发送前下载图片：发送前先下载图片到本地，再发送文件（仅OneBot）'),
+    messageBufferDelay: koishi_1.Schema.number()
+        .default(0)
+        .min(0)
+        .description('【性能设置】消息缓冲延迟：合并短时间内的多个图片请求（秒）'),
     tempDir: koishi_1.Schema.string()
-        .default(path_1.default.join(os_1.default.tmpdir(), 'koishi-custom-image'))
+        .default(path_1.default.join(process.cwd(), 'temp_images'))
         .description('【文件设置】临时图片保存目录')
 });
+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'
+                }
+            });
+            await (0, promises_1.pipeline)(response.data, fs_1.default.createWriteStream(filePath));
+            worker_threads_1.parentPort?.postMessage({ success: true, filePath });
+        }
+        catch (error) {
+            worker_threads_1.parentPort?.postMessage({ success: false, error: error.message });
+        }
+    })();
+}
 const processedApi = new Map();
 const imageBuffer = new Map();
-const tempFiles = new Set();
 const delay = (ms) => new Promise(r => setTimeout(r, ms));
 async function sendTimeout(session, content, config) {
     if (config.imageSendTimeout <= 0) {
@@ -79,37 +108,54 @@ async function sendTimeout(session, content, config) {
     }
     return Promise.race([
         session.send(content),
-        new Promise((_, reject) => setTimeout(() => reject(new Error()), config.imageSendTimeout))
+        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), config.imageSendTimeout))
     ]).catch(() => null);
 }
-function clearAllCache() {
-    processedApi.clear();
-    imageBuffer.forEach(buf => clearTimeout(buf.timer));
-    imageBuffer.clear();
-    tempFiles.forEach(file => {
-        try {
-            fs_1.default.unlinkSync(file);
+async function downloadImageWithThreads(url, filename, config) {
+    return new Promise((resolve, reject) => {
+        if (!fs_1.default.existsSync(config.tempDir)) {
+            fs_1.default.mkdirSync(config.tempDir, { recursive: true });
         }
-        catch { }
+        const filePath = path_1.default.join(config.tempDir, `${filename}.jpg`);
+        const worker = new worker_threads_1.Worker(currentFilePath, { workerData: { url, filePath } });
+        worker.on('message', (result) => {
+            if (result.success && result.filePath) {
+                resolve(result.filePath);
+            }
+            else {
+                reject(new Error(result.error || '图片下载失败'));
+            }
+        });
+        worker.on('error', reject);
+        worker.on('exit', (code) => {
+            if (code !== 0)
+                reject(new Error('图片下载线程异常'));
+        });
     });
-    tempFiles.clear();
-    return true;
 }
-function createTempDir(config) {
-    if (!fs_1.default.existsSync(config.tempDir)) {
-        fs_1.default.mkdirSync(config.tempDir, { recursive: true });
+function clearAllCache(config) {
+    processedApi.clear();
+    imageBuffer.forEach(buf => clearTimeout(buf.timer));
+    imageBuffer.clear();
+    if (fs_1.default.existsSync(config.tempDir)) {
+        fs_1.default.readdirSync(config.tempDir).forEach(file => {
+            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);
+                }
+            }
+            catch (error) { }
+        });
     }
+    return true;
 }
-async function saveImageToTemp(buffer, config) {
-    createTempDir(config);
-    const filename = `${crypto_1.default.randomUUID()}.jpg`;
-    const filepath = path_1.default.join(config.tempDir, filename);
-    await fs_1.default.promises.writeFile(filepath, buffer);
-    tempFiles.add(filepath);
-    return filepath;
-}
-function isImageUrl(url) {
-    return /^https?:\/\/.+\.(jpg|jpeg|png|gif|webp|bmp)/i.test(url);
+function randomSelectApi(customImageApis) {
+    const validApis = customImageApis.filter(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({
@@ -120,16 +166,15 @@ async function fetchImage(url, config) {
     });
     for (let retry = 0; retry <= config.retryTimes; retry++) {
         try {
-            if (isImageUrl(url)) {
+            if (/^https?:\/\/.+\.(jpg|jpeg|png|gif|webp|bmp)/i.test(url)) {
                 return { success: true, type: 'url', data: url };
             }
             const res = await http.get(url, { responseType: 'arraybuffer' });
             if (res.status === 200 && res.data) {
-                const filepath = await saveImageToTemp(Buffer.from(res.data), config);
-                return { success: true, type: 'file', data: filepath };
+                return { success: true, type: 'buffer', data: res.data };
             }
         }
-        catch {
+        catch (error) {
             if (retry === config.retryTimes)
                 return { success: false, type: '', data: '' };
             await delay(config.retryInterval);
@@ -153,16 +198,34 @@ async function processCustomImage(session, apiUrl, config) {
     const hash = crypto_1.default.createHash('md5').update(apiUrl).digest('hex');
     const now = Date.now();
     if (processedApi.get(hash) && now - processedApi.get(hash) < config.sameImageApiInterval * 1000) {
-        return { success: false };
+        return { success: false, msg: '请勿重复请求' };
     }
     processedApi.set(hash, now);
     const result = await fetchImage(apiUrl, config);
-    if (result.success && result.data) {
-        await sendTimeout(session, config.imageParseFormat, config);
-        await sendTimeout(session, koishi_1.h.image(result.data), config);
-        return { success: true };
+    if (!result.success) {
+        return { success: false, msg: '图片获取失败' };
+    }
+    let imageElem;
+    if (result.type === 'url' && config.downloadImageBeforeSend) {
+        try {
+            const filename = crypto_1.default.createHash('md5').update(result.data).digest('hex');
+            const filePath = await downloadImageWithThreads(result.data, filename, config);
+            imageElem = koishi_1.h.file(filePath);
+        }
+        catch (error) {
+            imageElem = koishi_1.h.image(result.data);
+        }
     }
-    return { success: false };
+    else if (result.type === 'buffer') {
+        const filename = crypto_1.default.randomUUID();
+        const filePath = path_1.default.join(config.tempDir, `${filename}.jpg`);
+        fs_1.default.writeFileSync(filePath, result.data);
+        imageElem = koishi_1.h.file(filePath);
+    }
+    else {
+        imageElem = koishi_1.h.image(result.data);
+    }
+    return { success: true, msg: 'ok', data: { text: config.imageParseFormat, image: imageElem } };
 }
 async function flush(session, config, manualApi) {
     const key = `${session.platform}:${session.userId}:${session.channelId}`;
@@ -172,21 +235,42 @@ async function flush(session, config, manualApi) {
         clearTimeout(buf.timer);
         imageBuffer.delete(key);
     }
-    if (config.customImageEnabled && apis.length) {
-        const apiUrl = randomSelectApi(apis);
-        if (apiUrl)
-            await processCustomImage(session, apiUrl, config);
+    if (!config.customImageEnabled || !apis.length)
+        return;
+    const items = [];
+    const errs = [];
+    for (const apiUrl of apis) {
+        const result = await processCustomImage(session, apiUrl, config);
+        if (result.success && result.data) {
+            items.push(result.data);
+        }
+        else {
+            errs.push(`【${apiUrl.slice(0, 22)}...】：${result.msg}`);
+        }
+    }
+    if (errs.length && !config.ignoreSendError) {
+        const errorMsg = `⚠️ 部分图片获取失败\n${errs.join('\n')}`;
+        await sendTimeout(session, errorMsg, config);
+        await delay(600);
+    }
+    if (items.length === 0) {
+        const failMsg = `❌ 所有图片获取失败\n${errs.join('\n')}`;
+        if (!config.ignoreSendError) {
+            await sendTimeout(session, failMsg, config);
+        }
+        return;
+    }
+    for (const item of items) {
+        await sendTimeout(session, item.text, config);
+        await delay(300);
+        await sendTimeout(session, item.image, config);
+        await delay(1000);
     }
-}
-function randomSelectApi(customImageApis) {
-    const validApis = customImageApis.filter(api => api.trim());
-    if (validApis.length === 0)
-        return null;
-    return validApis[Math.floor(Math.random() * validApis.length)];
 }
 function apply(ctx, config) {
-    clearAllCache();
-    createTempDir(config);
+    if (!worker_threads_1.isMainThread)
+        return;
+    clearAllCache(config);
     ctx.logger.info('[custom-image] 插件已加载');
     ctx.command('random-image [apis...]', '随机获取自定义图片')
         .option('api', '-a <api> 指定单个API地址')
@@ -207,12 +291,12 @@ function apply(ctx, config) {
             if (imageBuffer.has(key)) {
                 const b = imageBuffer.get(key);
                 clearTimeout(b.timer);
-                b.timer = setTimeout(() => flush(session, config), 1000);
+                b.timer = setTimeout(() => flush(session, config), config.messageBufferDelay * 1000);
             }
             else {
                 imageBuffer.set(key, {
                     apis: config.customImageApis,
-                    timer: setTimeout(() => flush(session, config), 1000),
+                    timer: setTimeout(() => flush(session, config), config.messageBufferDelay * 1000),
                     tipMsgId: tipId
                 });
             }
@@ -226,9 +310,29 @@ function apply(ctx, config) {
             await sendTimeout(session, config.waitingTipText, config);
         }
         const result = await fetchHsjpImage(msg, msg1, msg2, config);
-        if (result.success && result.data) {
+        if (result.success) {
+            let imageElem;
+            if (result.type === 'url' && config.downloadImageBeforeSend) {
+                try {
+                    const filename = crypto_1.default.createHash('md5').update(result.data).digest('hex');
+                    const filePath = await downloadImageWithThreads(result.data, filename, config);
+                    imageElem = koishi_1.h.file(filePath);
+                }
+                catch (error) {
+                    imageElem = koishi_1.h.image(result.data);
+                }
+            }
+            else if (result.type === 'buffer') {
+                const filename = crypto_1.default.randomUUID();
+                const filePath = path_1.default.join(config.tempDir, `${filename}.jpg`);
+                fs_1.default.writeFileSync(filePath, result.data);
+                imageElem = koishi_1.h.file(filePath);
+            }
+            else {
+                imageElem = koishi_1.h.image(result.data);
+            }
             await sendTimeout(session, config.imageParseFormat, config);
-            await sendTimeout(session, koishi_1.h.image(result.data), config);
+            await sendTimeout(session, imageElem, config);
         }
     });
     ctx.command('dmjp <text>', '生成动漫举牌图片')
@@ -239,31 +343,65 @@ function apply(ctx, config) {
             await sendTimeout(session, config.waitingTipText, config);
         }
         const result = await fetchDmjpImage(text, config);
-        if (result.success && result.data) {
+        if (result.success) {
+            let imageElem;
+            if (result.type === 'url' && config.downloadImageBeforeSend) {
+                try {
+                    const filename = crypto_1.default.createHash('md5').update(result.data).digest('hex');
+                    const filePath = await downloadImageWithThreads(result.data, filename, config);
+                    imageElem = koishi_1.h.file(filePath);
+                }
+                catch (error) {
+                    imageElem = koishi_1.h.image(result.data);
+                }
+            }
+            else if (result.type === 'buffer') {
+                const filename = crypto_1.default.randomUUID();
+                const filePath = path_1.default.join(config.tempDir, `${filename}.jpg`);
+                fs_1.default.writeFileSync(filePath, result.data);
+                imageElem = koishi_1.h.file(filePath);
+            }
+            else {
+                imageElem = koishi_1.h.image(result.data);
+            }
             await sendTimeout(session, config.imageParseFormat, config);
-            await sendTimeout(session, koishi_1.h.image(result.data), config);
+            await sendTimeout(session, imageElem, config);
         }
     });
     ctx.command('clear-image-cache', '清空图片缓存')
         .action(() => {
-        clearAllCache();
+        clearAllCache(config);
+        return '✅ 图片缓存已清空';
     });
     setInterval(() => {
         const now = Date.now();
-        processedApi.forEach((time, hash) => {
-            if (now - time > 86400000) {
+        processedApi.forEach((timestamp, hash) => {
+            if (now - timestamp > 86400000)
                 processedApi.delete(hash);
-            }
         });
     }, 3600000);
+    setInterval(() => {
+        if (!fs_1.default.existsSync(config.tempDir))
+            return;
+        const now = Date.now();
+        fs_1.default.readdirSync(config.tempDir).forEach(file => {
+            try {
+                const stat = fs_1.default.statSync(path_1.default.join(config.tempDir, file));
+                if (now - stat.mtimeMs > 3600000) {
+                    fs_1.default.unlinkSync(path_1.default.join(config.tempDir, file));
+                }
+            }
+            catch (error) { }
+        });
+    }, 1800000);
     if (config.autoClearCacheInterval > 0) {
         setInterval(() => {
-            clearAllCache();
+            clearAllCache(config);
             ctx.logger.info('[custom-image] 缓存已自动清理');
         }, config.autoClearCacheInterval * 60000);
     }
     process.on('exit', () => {
-        clearAllCache();
+        clearAllCache(config);
         ctx.logger.info('[custom-image] 插件缓存已清理');
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-custom-image",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Koishi自定义图片API插件（支持黑丝/动漫举牌）",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/index.ts

@@ -1,9 +1,12 @@
 import { Context, Schema, h, Session } from 'koishi'
-import axios, { AxiosInstance } from 'axios'
+import axios from 'axios'
 import crypto from 'crypto'
 import fs from 'fs'
 import path from 'path'
-import os from 'os'
+import { pipeline } from 'stream/promises'
+import { isMainThread, Worker, workerData, parentPort } from 'worker_threads'
+
+const currentFilePath = path.join(process.cwd(), 'src', 'index.ts');
 
 export const name = 'custom-image'
 
@@ -23,6 +26,8 @@ export interface Config {
   imageSendTimeout: number
   autoClearCacheInterval: number
   imageParseFormat: string
+  downloadImageBeforeSend: boolean
+  messageBufferDelay: number
   tempDir: string
 }
 
@@ -79,232 +84,362 @@ export const Config: Schema<Config> = Schema.object({
   imageParseFormat: Schema.string()
     .default('✅ 图片获取成功')
     .description('【格式设置】图片发送前的提示文本'),
+  downloadImageBeforeSend: Schema.boolean()
+    .default(true)
+    .description('【展示设置】发送前下载图片：发送前先下载图片到本地，再发送文件（仅OneBot）'),
+  messageBufferDelay: Schema.number()
+    .default(0)
+    .min(0)
+    .description('【性能设置】消息缓冲延迟：合并短时间内的多个图片请求（秒）'),
   tempDir: Schema.string()
-    .default(path.join(os.tmpdir(), 'koishi-custom-image'))
+    .default(path.join(process.cwd(), 'temp_images'))
     .description('【文件设置】临时图片保存目录')
 })
 
+if (!isMainThread) {
+  const { url, filePath } = workerData;
+  (async () => {
+    try {
+      const response = await axios({
+        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'
+        }
+      });
+
+      await pipeline(response.data, fs.createWriteStream(filePath));
+      parentPort?.postMessage({ success: true, filePath });
+    } catch (error) {
+      parentPort?.postMessage({ success: false, error: (error as Error).message });
+    }
+  })();
+}
+
 const processedApi = new Map<string, number>()
 const imageBuffer = new Map<string, { apis: string[], timer: NodeJS.Timeout, tipMsgId?: string | number }>()
-const tempFiles = new Set<string>()
-
 const delay = (ms: number) => new Promise(r => setTimeout(r, ms))
 
 async function sendTimeout(session: Session, content: any, config: Config) {
   if (config.imageSendTimeout <= 0) {
-    return session.send(content).catch(() => null)
+    return session.send(content).catch(() => null);
   }
   return Promise.race([
     session.send(content),
-    new Promise((_, reject) => setTimeout(() => reject(new Error()), config.imageSendTimeout))
-  ]).catch(() => null)
+    new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), config.imageSendTimeout))
+  ]).catch(() => null);
 }
 
-function clearAllCache() {
-  processedApi.clear()
-  imageBuffer.forEach(buf => clearTimeout(buf.timer))
-  imageBuffer.clear()
-  tempFiles.forEach(file => {
-    try {
-      fs.unlinkSync(file)
-    } catch {}
-  })
-  tempFiles.clear()
-  return true
-}
+async function downloadImageWithThreads(url: string, filename: string, config: Config): Promise<string> {
+  return new Promise((resolve, reject) => {
+    if (!fs.existsSync(config.tempDir)) {
+      fs.mkdirSync(config.tempDir, { recursive: true });
+    }
+    const filePath = path.join(config.tempDir, `${filename}.jpg`);
 
-function createTempDir(config: Config) {
-  if (!fs.existsSync(config.tempDir)) {
-    fs.mkdirSync(config.tempDir, { recursive: true })
-  }
+    const worker = new Worker(currentFilePath, { workerData: { url, filePath } });
+    worker.on('message', (result: { success: boolean, filePath?: string, error?: string }) => {
+      if (result.success && result.filePath) {
+        resolve(result.filePath);
+      } else {
+        reject(new Error(result.error || '图片下载失败'));
+      }
+    });
+    worker.on('error', reject);
+    worker.on('exit', (code: number) => {
+      if (code !== 0) reject(new Error('图片下载线程异常'));
+    });
+  });
 }
 
-async function saveImageToTemp(buffer: Buffer, config: Config) {
-  createTempDir(config)
-  const filename = `${crypto.randomUUID()}.jpg`
-  const filepath = path.join(config.tempDir, filename)
-  await fs.promises.writeFile(filepath, buffer)
-  tempFiles.add(filepath)
-  return filepath
+function clearAllCache(config: Config) {
+  processedApi.clear();
+  imageBuffer.forEach(buf => clearTimeout(buf.timer));
+  imageBuffer.clear();
+
+  if (fs.existsSync(config.tempDir)) {
+    fs.readdirSync(config.tempDir).forEach(file => {
+      try {
+        const filePath = path.join(config.tempDir, file);
+        const stat = fs.statSync(filePath);
+        if (Date.now() - stat.mtimeMs > 3600000) {
+          fs.unlinkSync(filePath);
+        }
+      } catch (error) {}
+    });
+  }
+  return true;
 }
 
-function isImageUrl(url: string) {
-  return /^https?:\/\/.+\.(jpg|jpeg|png|gif|webp|bmp)/i.test(url)
+function randomSelectApi(customImageApis: string[]): string | null {
+  const validApis = customImageApis.filter(api => api.trim());
+  if (validApis.length === 0) return null;
+  return validApis[Math.floor(Math.random() * validApis.length)];
 }
 
 async function fetchImage(url: string, config: Config) {
-  const http: AxiosInstance = axios.create({
+  const http = axios.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'
     }
-  })
+  });
 
   for (let retry = 0; retry <= config.retryTimes; retry++) {
     try {
-      if (isImageUrl(url)) {
-        return { success: true, type: 'url', data: url }
+      if (/^https?:\/\/.+\.(jpg|jpeg|png|gif|webp|bmp)/i.test(url)) {
+        return { success: true, type: 'url', data: url };
       }
 
-      const res = await http.get(url, { responseType: 'arraybuffer' })
+      const res = await http.get(url, { responseType: 'arraybuffer' });
       if (res.status === 200 && res.data) {
-        const filepath = await saveImageToTemp(Buffer.from(res.data), config)
-        return { success: true, type: 'file', data: filepath }
+        return { success: true, type: 'buffer', data: res.data };
       }
-    } catch {
-      if (retry === config.retryTimes) return { success: false, type: '', data: '' }
-      await delay(config.retryInterval)
+    } catch (error) {
+      if (retry === config.retryTimes) return { success: false, type: '', data: '' };
+      await delay(config.retryInterval);
     }
   }
 
-  return { success: false, type: '', data: '' }
+  return { success: false, type: '', data: '' };
 }
 
 async function fetchHsjpImage(msg: string, msg1: string, msg2: string, config: Config) {
-  const encodedMsg = encodeURIComponent(msg)
-  const encodedMsg1 = encodeURIComponent(msg1)
-  const encodedMsg2 = encodeURIComponent(msg2)
-  const url = `https://api.suyanw.cn/api/hsjp/?msg=${encodedMsg}&msg1=${encodedMsg1}&msg2=${encodedMsg2}`
-  return fetchImage(url, config)
+  const encodedMsg = encodeURIComponent(msg);
+  const encodedMsg1 = encodeURIComponent(msg1);
+  const encodedMsg2 = encodeURIComponent(msg2);
+  const url = `https://api.suyanw.cn/api/hsjp/?msg=${encodedMsg}&msg1=${encodedMsg1}&msg2=${encodedMsg2}`;
+  return fetchImage(url, config);
 }
 
 async function fetchDmjpImage(text: string, config: Config) {
-  const encodedText = encodeURIComponent(text)
-  const url = `https://api.suyanw.cn/api/dmjp.php?text=${encodedText}`
-  return fetchImage(url, config)
+  const encodedText = encodeURIComponent(text);
+  const url = `https://api.suyanw.cn/api/dmjp.php?text=${encodedText}`;
+  return fetchImage(url, config);
 }
 
 async function processCustomImage(session: Session, apiUrl: string, config: Config) {
-  const hash = crypto.createHash('md5').update(apiUrl).digest('hex')
-  const now = Date.now()
+  const hash = crypto.createHash('md5').update(apiUrl).digest('hex');
+  const now = Date.now();
   
   if (processedApi.get(hash) && now - processedApi.get(hash)! < config.sameImageApiInterval * 1000) {
-    return { success: false }
+    return { success: false, msg: '请勿重复请求' };
   }
-  processedApi.set(hash, now)
+  processedApi.set(hash, now);
 
-  const result = await fetchImage(apiUrl, config)
-  if (result.success && result.data) {
-    await sendTimeout(session, config.imageParseFormat, config)
-    await sendTimeout(session, h.image(result.data), config)
-    return { success: true }
+  const result = await fetchImage(apiUrl, config);
+  if (!result.success) {
+    return { success: false, msg: '图片获取失败' };
+  }
+
+  let imageElem: any;
+  if (result.type === 'url' && config.downloadImageBeforeSend) {
+    try {
+      const filename = crypto.createHash('md5').update(result.data as string).digest('hex');
+      const filePath = await downloadImageWithThreads(result.data as string, filename, config);
+      imageElem = h.file(filePath);
+    } catch (error) {
+      imageElem = h.image(result.data as string);
+    }
+  } else if (result.type === 'buffer') {
+    const filename = crypto.randomUUID();
+    const filePath = path.join(config.tempDir, `${filename}.jpg`);
+    fs.writeFileSync(filePath, result.data as Buffer);
+    imageElem = h.file(filePath);
+  } else {
+    imageElem = h.image(result.data as string);
   }
-  return { success: false }
+
+  return { success: true, msg: 'ok', data: { text: config.imageParseFormat, image: imageElem } };
 }
 
 async function flush(session: Session, config: Config, manualApi?: string) {
-  const key = `${session.platform}:${session.userId}:${session.channelId}`
-  const buf = imageBuffer.get(key)
-  const apis = manualApi ? [manualApi] : buf?.apis || []
+  const key = `${session.platform}:${session.userId}:${session.channelId}`;
+  const buf = imageBuffer.get(key);
+  const apis = manualApi ? [manualApi] : buf?.apis || [];
 
   if (buf) {
-    clearTimeout(buf.timer)
-    imageBuffer.delete(key)
+    clearTimeout(buf.timer);
+    imageBuffer.delete(key);
   }
 
-  if (config.customImageEnabled && apis.length) {
-    const apiUrl = randomSelectApi(apis)
-    if (apiUrl) await processCustomImage(session, apiUrl, config)
+  if (!config.customImageEnabled || !apis.length) return;
+
+  const items: any[] = [];
+  const errs: string[] = [];
+
+  for (const apiUrl of apis) {
+    const result = await processCustomImage(session, apiUrl, config);
+    if (result.success && result.data) {
+      items.push(result.data);
+    } else {
+      errs.push(`【${apiUrl.slice(0, 22)}...】：${result.msg}`);
+    }
   }
-}
 
-function randomSelectApi(customImageApis: string[]): string | null {
-  const validApis = customImageApis.filter(api => api.trim())
-  if (validApis.length === 0) return null
-  return validApis[Math.floor(Math.random() * validApis.length)]
+  if (errs.length && !config.ignoreSendError) {
+    const errorMsg = `⚠️ 部分图片获取失败\n${errs.join('\n')}`;
+    await sendTimeout(session, errorMsg, config);
+    await delay(600);
+  }
+
+  if (items.length === 0) {
+    const failMsg = `❌ 所有图片获取失败\n${errs.join('\n')}`;
+    if (!config.ignoreSendError) {
+      await sendTimeout(session, failMsg, config);
+    }
+    return;
+  }
+
+  for (const item of items) {
+    await sendTimeout(session, item.text, config);
+    await delay(300);
+    await sendTimeout(session, item.image, config);
+    await delay(1000);
+  }
 }
 
 export function apply(ctx: Context, config: Config) {
-  clearAllCache()
-  createTempDir(config)
-  ctx.logger.info('[custom-image] 插件已加载')
+  if (!isMainThread) return;
+
+  clearAllCache(config);
+  ctx.logger.info('[custom-image] 插件已加载');
 
   ctx.command('random-image [apis...]', '随机获取自定义图片')
     .option('api', '-a <api> 指定单个API地址')
     .action(async ({ session, options = {} }, ...apis) => {
-      if (!config.enable || !config.customImageEnabled || !session) return
+      if (!config.enable || !config.customImageEnabled || !session) return;
 
-      const targetApi = options.api || (apis.length ? apis.join(' ') : null)
+      const targetApi = options.api || (apis.length ? apis.join(' ') : null);
       if (targetApi) {
-        await flush(session, config, targetApi)
+        await flush(session, config, targetApi);
       } else {
-        const key = `${session.platform}:${session.userId}:${session.channelId}`
+        const key = `${session.platform}:${session.userId}:${session.channelId}`;
         
-        let tipId
+        let tipId;
         if (config.showWaitingTip) {
-          const tip = await sendTimeout(session, config.waitingTipText, config)
-          tipId = (tip as any)?.messageId || (tip as any)?.id || tip
+          const tip = await sendTimeout(session, config.waitingTipText, config);
+          tipId = (tip as any)?.messageId || (tip as any)?.id || tip;
         }
 
         if (imageBuffer.has(key)) {
-          const b = imageBuffer.get(key)!
-          clearTimeout(b.timer)
-          b.timer = setTimeout(() => flush(session, config), 1000)
+          const b = imageBuffer.get(key)!;
+          clearTimeout(b.timer);
+          b.timer = setTimeout(() => flush(session, config), config.messageBufferDelay * 1000);
         } else {
           imageBuffer.set(key, {
             apis: config.customImageApis,
-            timer: setTimeout(() => flush(session, config), 1000),
+            timer: setTimeout(() => flush(session, config), config.messageBufferDelay * 1000),
             tipMsgId: tipId
-          })
+          });
         }
       }
-    })
+    });
 
   ctx.command('hsjp <msg> [msg1] [msg2]', '生成黑丝举牌图片')
     .action(async ({ session }, msg, msg1 = '', msg2 = '') => {
-      if (!config.enable || !config.hsjpEnabled || !session || !msg) return
+      if (!config.enable || !config.hsjpEnabled || !session || !msg) return;
 
       if (config.showWaitingTip) {
-        await sendTimeout(session, config.waitingTipText, config)
+        await sendTimeout(session, config.waitingTipText, config);
       }
 
-      const result = await fetchHsjpImage(msg, msg1, msg2, config)
-      if (result.success && result.data) {
-        await sendTimeout(session, config.imageParseFormat, config)
-        await sendTimeout(session, h.image(result.data), config)
+      const result = await fetchHsjpImage(msg, msg1, msg2, config);
+      if (result.success) {
+        let imageElem: any;
+        if (result.type === 'url' && config.downloadImageBeforeSend) {
+          try {
+            const filename = crypto.createHash('md5').update(result.data as string).digest('hex');
+            const filePath = await downloadImageWithThreads(result.data as string, filename, config);
+            imageElem = h.file(filePath);
+          } catch (error) {
+            imageElem = h.image(result.data as string);
+          }
+        } else if (result.type === 'buffer') {
+          const filename = crypto.randomUUID();
+          const filePath = path.join(config.tempDir, `${filename}.jpg`);
+          fs.writeFileSync(filePath, result.data as Buffer);
+          imageElem = h.file(filePath);
+        } else {
+          imageElem = h.image(result.data as string);
+        }
+        await sendTimeout(session, config.imageParseFormat, config);
+        await sendTimeout(session, imageElem, config);
       }
-    })
+    });
 
   ctx.command('dmjp <text>', '生成动漫举牌图片')
     .action(async ({ session }, text) => {
-      if (!config.enable || !config.dmjpEnabled || !session || !text) return
+      if (!config.enable || !config.dmjpEnabled || !session || !text) return;
 
       if (config.showWaitingTip) {
-        await sendTimeout(session, config.waitingTipText, config)
+        await sendTimeout(session, config.waitingTipText, config);
       }
 
-      const result = await fetchDmjpImage(text, config)
-      if (result.success && result.data) {
-        await sendTimeout(session, config.imageParseFormat, config)
-        await sendTimeout(session, h.image(result.data), config)
+      const result = await fetchDmjpImage(text, config);
+      if (result.success) {
+        let imageElem: any;
+        if (result.type === 'url' && config.downloadImageBeforeSend) {
+          try {
+            const filename = crypto.createHash('md5').update(result.data as string).digest('hex');
+            const filePath = await downloadImageWithThreads(result.data as string, filename, config);
+            imageElem = h.file(filePath);
+          } catch (error) {
+            imageElem = h.image(result.data as string);
+          }
+        } else if (result.type === 'buffer') {
+          const filename = crypto.randomUUID();
+          const filePath = path.join(config.tempDir, `${filename}.jpg`);
+          fs.writeFileSync(filePath, result.data as Buffer);
+          imageElem = h.file(filePath);
+        } else {
+          imageElem = h.image(result.data as string);
+        }
+        await sendTimeout(session, config.imageParseFormat, config);
+        await sendTimeout(session, imageElem, config);
       }
-    })
+    });
 
   ctx.command('clear-image-cache', '清空图片缓存')
     .action(() => {
-      clearAllCache()
-    })
+      clearAllCache(config);
+      return '✅ 图片缓存已清空';
+    });
 
   setInterval(() => {
-    const now = Date.now()
-    processedApi.forEach((time, hash) => {
-      if (now - time > 86400000) {
-        processedApi.delete(hash)
-      }
-    })
-  }, 3600000)
+    const now = Date.now();
+    processedApi.forEach((timestamp, hash) => {
+      if (now - timestamp > 86400000) processedApi.delete(hash);
+    });
+  }, 3600000);
+
+  setInterval(() => {
+    if (!fs.existsSync(config.tempDir)) return;
+
+    const now = Date.now();
+    fs.readdirSync(config.tempDir).forEach(file => {
+      try {
+        const stat = fs.statSync(path.join(config.tempDir, file));
+        if (now - stat.mtimeMs > 3600000) {
+          fs.unlinkSync(path.join(config.tempDir, file));
+        }
+      } catch (error) {}
+    });
+  }, 1800000);
 
   if (config.autoClearCacheInterval > 0) {
     setInterval(() => {
-      clearAllCache()
-      ctx.logger.info('[custom-image] 缓存已自动清理')
-    }, config.autoClearCacheInterval * 60000)
+      clearAllCache(config);
+      ctx.logger.info('[custom-image] 缓存已自动清理');
+    }, config.autoClearCacheInterval * 60000);
   }
 
   process.on('exit', () => {
-    clearAllCache()
-    ctx.logger.info('[custom-image] 插件缓存已清理')
-  })
+    clearAllCache(config);
+    ctx.logger.info('[custom-image] 插件缓存已清理');
+  });
 }
 
 export const inject = {