koishi-plugin-custom-image 0.1.6 → 0.1.7

package/lib/index.d.ts

@@ -16,6 +16,7 @@ export interface Config {
     imageSendTimeout: number;
     autoClearCacheInterval: number;
     imageParseFormat: string;
+    tempDir: string;
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -6,13 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.using = exports.inject = exports.Config = exports.name = void 0;
 exports.apply = apply;
 const koishi_1 = require("koishi");
-const axios_1 = __importDefault(require("axios")); // 核心：直接导入axios包
+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"));
 exports.name = 'custom-image';
-// 移除冗余断言，符合Koishi配置规范
 exports.Config = koishi_1.Schema.object({
-    // 基础设置
     enable: koishi_1.Schema.boolean()
         .default(true)
         .description('【基础设置】启用插件'),
@@ -25,7 +25,7 @@ exports.Config = koishi_1.Schema.object({
     sameImageApiInterval: koishi_1.Schema.number()
         .default(60)
         .min(0)
-        .description('【基础设置】重复API调用间隔：相同API的最小调用间隔（秒）'),
+        .description('【基础设置】重复API调用间隔（秒）'),
     timeout: koishi_1.Schema.number()
         .default(10000)
         .min(0)
@@ -34,7 +34,6 @@ exports.Config = koishi_1.Schema.object({
         .default([])
         .role('textarea')
         .description('【基础设置】自定义图片API列表（每行一个地址）'),
-    // 功能开关
     customImageEnabled: koishi_1.Schema.boolean()
         .default(true)
         .description('【功能开关】启用自定义图片API功能'),
@@ -44,14 +43,13 @@ exports.Config = koishi_1.Schema.object({
     dmjpEnabled: koishi_1.Schema.boolean()
         .default(true)
         .description('【功能开关】启用动漫举牌功能'),
-    // 容错设置
     ignoreSendError: koishi_1.Schema.boolean()
         .default(true)
-        .description('【容错设置】忽略发送错误：避免插件因消息发送失败崩溃'),
+        .description('【容错设置】忽略发送错误'),
     retryTimes: koishi_1.Schema.number()
         .default(1)
         .min(0)
-        .description('【容错设置】API重试次数：请求失败时的重试次数'),
+        .description('【容错设置】API重试次数'),
     retryInterval: koishi_1.Schema.number()
         .default(500)
         .min(0)
@@ -59,89 +57,86 @@ exports.Config = koishi_1.Schema.object({
     imageSendTimeout: koishi_1.Schema.number()
         .default(15000)
         .min(0)
-        .description('【容错设置】图片发送超时（毫秒），0表示不限制'),
-    // 缓存设置
+        .description('【容错设置】图片发送超时（毫秒）'),
     autoClearCacheInterval: koishi_1.Schema.number()
         .default(60)
         .min(0)
-        .description('【缓存设置】自动清理缓存间隔（分钟），0表示不自动清理'),
-    // 格式设置
+        .description('【缓存设置】自动清理缓存间隔（分钟）'),
     imageParseFormat: koishi_1.Schema.string()
         .default('✅ 图片获取成功')
-        .description('【格式设置】图片发送前的提示文本')
+        .description('【格式设置】图片发送前的提示文本'),
+    tempDir: koishi_1.Schema.string()
+        .default(path_1.default.join(os_1.default.tmpdir(), 'koishi-custom-image'))
+        .description('【文件设置】临时图片保存目录')
 });
-// ==================== 全局缓存与工具函数 ====================
 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) {
-        return session.send(content).catch(err => {
-            if (config.ignoreSendError)
-                return null;
-            throw err;
-        });
+        return session.send(content).catch(() => null);
     }
     return Promise.race([
         session.send(content),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('发送超时')), config.imageSendTimeout))
-    ]).catch(err => {
-        if (config.ignoreSendError)
-            return null;
-        throw err;
-    });
+        new Promise((_, reject) => setTimeout(() => reject(new Error()), 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);
+        }
+        catch { }
+    });
+    tempFiles.clear();
     return true;
 }
-// ==================== 核心业务函数（关键：不再依赖ctx.axios） ====================
-/**
- * 随机选择自定义图片API
- */
-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 createTempDir(config) {
+    if (!fs_1.default.existsSync(config.tempDir)) {
+        fs_1.default.mkdirSync(config.tempDir, { recursive: 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);
 }
-/**
- * 调用图片API（核心修改：直接使用axios包，无需ctx）
- */
 async function fetchImage(url, config) {
-    // 直接创建axios实例，不再依赖ctx.axios
     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'
         }
     });
-    // 重试逻辑
     for (let retry = 0; retry <= config.retryTimes; retry++) {
         try {
+            if (isImageUrl(url)) {
+                return { success: true, type: 'url', data: url };
+            }
             const res = await http.get(url, { responseType: 'arraybuffer' });
             if (res.status === 200 && res.data) {
-                const imgBase64 = Buffer.from(res.data).toString('base64');
-                return { success: true, data: imgBase64, msg: '图片获取成功' };
+                const filepath = await saveImageToTemp(Buffer.from(res.data), config);
+                return { success: true, type: 'file', data: filepath };
             }
         }
-        catch (err) {
-            if (retry === config.retryTimes) {
-                return { success: false, data: null, msg: `请求失败：${err.message}` };
-            }
+        catch {
+            if (retry === config.retryTimes)
+                return { success: false, type: '', data: '' };
             await delay(config.retryInterval);
         }
     }
-    return { success: false, data: null, msg: '重试次数用尽，图片获取失败' };
+    return { success: false, type: '', data: '' };
 }
-/**
- * 处理黑丝举牌API请求
- */
 async function fetchHsjpImage(msg, msg1, msg2, config) {
     const encodedMsg = encodeURIComponent(msg);
     const encodedMsg1 = encodeURIComponent(msg1);
@@ -149,38 +144,26 @@ async function fetchHsjpImage(msg, msg1, msg2, config) {
     const url = `https://api.suyanw.cn/api/hsjp/?msg=${encodedMsg}&msg1=${encodedMsg1}&msg2=${encodedMsg2}`;
     return fetchImage(url, config);
 }
-/**
- * 处理动漫举牌API请求
- */
 async function fetchDmjpImage(text, config) {
     const encodedText = encodeURIComponent(text);
     const url = `https://api.suyanw.cn/api/dmjp.php?text=${encodedText}`;
     return fetchImage(url, config);
 }
-/**
- * 处理自定义图片API请求（带防重复逻辑）
- */
 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, msg: '请勿重复调用该API' };
+        return { success: false };
     }
     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, msg: result.msg };
-    }
-    else {
-        await sendTimeout(session, `❌ ${result.msg}`, config);
-        return { success: false, msg: result.msg };
+        return { success: true };
     }
+    return { success: false };
 }
-/**
- * 刷新消息缓冲
- */
 async function flush(session, config, manualApi) {
     const key = `${session.platform}:${session.userId}:${session.channelId}`;
     const buf = imageBuffer.get(key);
@@ -191,27 +174,24 @@ async function flush(session, config, manualApi) {
     }
     if (config.customImageEnabled && apis.length) {
         const apiUrl = randomSelectApi(apis);
-        if (!apiUrl) {
-            await sendTimeout(session, '❌ 自定义图片API列表为空', config);
-            return;
-        }
-        await processCustomImage(session, apiUrl, config);
+        if (apiUrl)
+            await processCustomImage(session, apiUrl, config);
     }
 }
-// ==================== 插件主逻辑 ====================
+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();
-    ctx.logger.info('[custom-image] 自定义图片插件已加载');
-    // 🔥 关键：删除所有ctx.axios相关的代码，无需加载axios服务
-    // 随机图片指令
-    ctx.command('random-image [apis...]', '随机获取自定义图片API的图片')
+    createTempDir(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) {
-            return '❌ 自定义图片功能已禁用';
-        }
-        if (!session)
+        if (!config.enable || !config.customImageEnabled || !session)
             return;
         const targetApi = options.api || (apis.length ? apis.join(' ') : null);
         if (targetApi) {
@@ -219,13 +199,11 @@ function apply(ctx, config) {
         }
         else {
             const key = `${session.platform}:${session.userId}:${session.channelId}`;
-            // 显示等待提示
             let tipId;
             if (config.showWaitingTip) {
-                const m = await sendTimeout(session, config.waitingTipText, config);
-                tipId = m?.messageId || m?.id || m;
+                const tip = await sendTimeout(session, config.waitingTipText, config);
+                tipId = tip?.messageId || tip?.id || tip;
             }
-            // 消息缓冲
             if (imageBuffer.has(key)) {
                 const b = imageBuffer.get(key);
                 clearTimeout(b.timer);
@@ -240,15 +218,10 @@ function apply(ctx, config) {
             }
         }
     });
-    // 黑丝举牌指令
     ctx.command('hsjp <msg> [msg1] [msg2]', '生成黑丝举牌图片')
         .action(async ({ session }, msg, msg1 = '', msg2 = '') => {
-        if (!config.enable || !config.hsjpEnabled) {
-            return '❌ 黑丝举牌功能已禁用';
-        }
-        if (!session || !msg) {
-            return '❌ 请输入举牌文字！格式：hsjp <第一行> [第二行] [第三行]';
-        }
+        if (!config.enable || !config.hsjpEnabled || !session || !msg)
+            return;
         if (config.showWaitingTip) {
             await sendTimeout(session, config.waitingTipText, config);
         }
@@ -257,19 +230,11 @@ function apply(ctx, config) {
             await sendTimeout(session, config.imageParseFormat, config);
             await sendTimeout(session, koishi_1.h.image(result.data), config);
         }
-        else {
-            await sendTimeout(session, `❌ ${result.msg}`, config);
-        }
     });
-    // 动漫举牌指令
     ctx.command('dmjp <text>', '生成动漫举牌图片')
         .action(async ({ session }, text) => {
-        if (!config.enable || !config.dmjpEnabled) {
-            return '❌ 动漫举牌功能已禁用';
-        }
-        if (!session || !text) {
-            return '❌ 请输入举牌文字！格式：dmjp <文本>';
-        }
+        if (!config.enable || !config.dmjpEnabled || !session || !text)
+            return;
         if (config.showWaitingTip) {
             await sendTimeout(session, config.waitingTipText, config);
         }
@@ -278,40 +243,31 @@ function apply(ctx, config) {
             await sendTimeout(session, config.imageParseFormat, config);
             await sendTimeout(session, koishi_1.h.image(result.data), config);
         }
-        else {
-            await sendTimeout(session, `❌ ${result.msg}`, config);
-        }
     });
-    // 清空缓存指令
-    ctx.command('clear-image-cache', '清空图片插件缓存')
+    ctx.command('clear-image-cache', '清空图片缓存')
         .action(() => {
         clearAllCache();
-        return '✅ 图片插件缓存已清空';
     });
-    // 定时清理过期缓存（每小时）
     setInterval(() => {
         const now = Date.now();
         processedApi.forEach((time, hash) => {
-            if (now - time > 86400000) { // 24小时过期
+            if (now - time > 86400000) {
                 processedApi.delete(hash);
             }
         });
     }, 3600000);
-    // 自动清理缓存（按配置）
     if (config.autoClearCacheInterval > 0) {
         setInterval(() => {
             clearAllCache();
-            ctx.logger.info('[custom-image] 自动清理缓存完成');
+            ctx.logger.info('[custom-image] 缓存已自动清理');
         }, config.autoClearCacheInterval * 60000);
     }
-    // 进程退出清理
     process.on('exit', () => {
         clearAllCache();
-        ctx.logger.info('[custom-image] 插件缓存已清理，进程退出');
+        ctx.logger.info('[custom-image] 插件缓存已清理');
     });
 }
-// ==================== 插件元信息（移除axios依赖声明） ====================
 exports.inject = {
-    optional: ['i18n'] // 仅保留可选的i18n，移除axios
+    optional: ['i18n']
 };
-exports.using = []; // 清空using，无需依赖任何服务
+exports.using = [];

package/package.json

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

package/src/index.ts

@@ -1,39 +1,32 @@
 import { Context, Schema, h, Session } from 'koishi'
-import axios, { AxiosInstance } from 'axios' // 核心：直接导入axios包
+import axios, { AxiosInstance } from 'axios'
 import crypto from 'crypto'
 import fs from 'fs'
 import path from 'path'
+import os from 'os'
 
-// 插件名称
 export const name = 'custom-image'
 
-// ==================== 配置接口与 Schema ====================
 export interface Config {
-  // 基础设置
   enable: boolean
   showWaitingTip: boolean
   waitingTipText: string
   sameImageApiInterval: number
   timeout: number
-  customImageApis: string[] // 自定义图片API列表
-  // 功能开关
+  customImageApis: string[]
   customImageEnabled: boolean
   hsjpEnabled: boolean
   dmjpEnabled: boolean
-  // 容错设置
   ignoreSendError: boolean
   retryTimes: number
   retryInterval: number
   imageSendTimeout: number
-  // 缓存设置
   autoClearCacheInterval: number
-  // 格式设置
   imageParseFormat: string
+  tempDir: string
 }
 
-// 移除冗余断言，符合Koishi配置规范
 export const Config: Schema<Config> = Schema.object({
-  // 基础设置
   enable: Schema.boolean()
     .default(true)
     .description('【基础设置】启用插件'),
@@ -46,7 +39,7 @@ export const Config: Schema<Config> = Schema.object({
   sameImageApiInterval: Schema.number()
     .default(60)
     .min(0)
-    .description('【基础设置】重复API调用间隔：相同API的最小调用间隔（秒）'),
+    .description('【基础设置】重复API调用间隔（秒）'),
   timeout: Schema.number()
     .default(10000)
     .min(0)
@@ -55,7 +48,6 @@ export const Config: Schema<Config> = Schema.object({
     .default([])
     .role('textarea')
     .description('【基础设置】自定义图片API列表（每行一个地址）'),
-  // 功能开关
   customImageEnabled: Schema.boolean()
     .default(true)
     .description('【功能开关】启用自定义图片API功能'),
@@ -65,14 +57,13 @@ export const Config: Schema<Config> = Schema.object({
   dmjpEnabled: Schema.boolean()
     .default(true)
     .description('【功能开关】启用动漫举牌功能'),
-  // 容错设置
   ignoreSendError: Schema.boolean()
     .default(true)
-    .description('【容错设置】忽略发送错误：避免插件因消息发送失败崩溃'),
+    .description('【容错设置】忽略发送错误'),
   retryTimes: Schema.number()
     .default(1)
     .min(0)
-    .description('【容错设置】API重试次数：请求失败时的重试次数'),
+    .description('【容错设置】API重试次数'),
   retryInterval: Schema.number()
     .default(500)
     .min(0)
@@ -80,65 +71,68 @@ export const Config: Schema<Config> = Schema.object({
   imageSendTimeout: Schema.number()
     .default(15000)
     .min(0)
-    .description('【容错设置】图片发送超时（毫秒），0表示不限制'),
-  // 缓存设置
+    .description('【容错设置】图片发送超时（毫秒）'),
   autoClearCacheInterval: Schema.number()
     .default(60)
     .min(0)
-    .description('【缓存设置】自动清理缓存间隔（分钟），0表示不自动清理'),
-  // 格式设置
+    .description('【缓存设置】自动清理缓存间隔（分钟）'),
   imageParseFormat: Schema.string()
     .default('✅ 图片获取成功')
-    .description('【格式设置】图片发送前的提示文本')
+    .description('【格式设置】图片发送前的提示文本'),
+  tempDir: Schema.string()
+    .default(path.join(os.tmpdir(), 'koishi-custom-image'))
+    .description('【文件设置】临时图片保存目录')
 })
 
-// ==================== 全局缓存与工具函数 ====================
 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(err => {
-      if (config.ignoreSendError) return null
-      throw err
-    })
+    return session.send(content).catch(() => null)
   }
   return Promise.race([
     session.send(content),
-    new Promise((_, reject) => setTimeout(() => reject(new Error('发送超时')), config.imageSendTimeout))
-  ]).catch(err => {
-    if (config.ignoreSendError) return null
-    throw err
-  })
+    new Promise((_, reject) => setTimeout(() => reject(new Error()), 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
 }
 
-// ==================== 核心业务函数（关键：不再依赖ctx.axios） ====================
-/**
- * 随机选择自定义图片API
- */
-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)]
+function createTempDir(config: Config) {
+  if (!fs.existsSync(config.tempDir)) {
+    fs.mkdirSync(config.tempDir, { recursive: true })
+  }
+}
+
+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 isImageUrl(url: string) {
+  return /^https?:\/\/.+\.(jpg|jpeg|png|gif|webp|bmp)/i.test(url)
 }
 
-/**
- * 调用图片API（核心修改：直接使用axios包，无需ctx）
- */
 async function fetchImage(url: string, config: Config) {
-  // 直接创建axios实例，不再依赖ctx.axios
   const http: AxiosInstance = axios.create({
     timeout: config.timeout,
     headers: {
@@ -146,56 +140,46 @@ async function fetchImage(url: string, config: Config) {
     }
   })
 
-  // 重试逻辑
   for (let retry = 0; retry <= config.retryTimes; retry++) {
     try {
+      if (isImageUrl(url)) {
+        return { success: true, type: 'url', data: url }
+      }
+
       const res = await http.get(url, { responseType: 'arraybuffer' })
       if (res.status === 200 && res.data) {
-        const imgBase64 = Buffer.from(res.data).toString('base64')
-        return { success: true, data: imgBase64, msg: '图片获取成功' }
-      }
-    } catch (err) {
-      if (retry === config.retryTimes) {
-        return { success: false, data: null, msg: `请求失败：${(err as Error).message}` }
+        const filepath = await saveImageToTemp(Buffer.from(res.data), config)
+        return { success: true, type: 'file', data: filepath }
       }
+    } catch {
+      if (retry === config.retryTimes) return { success: false, type: '', data: '' }
       await delay(config.retryInterval)
     }
   }
 
-  return { success: false, data: null, msg: '重试次数用尽，图片获取失败' }
+  return { success: false, type: '', data: '' }
 }
 
-/**
- * 处理黑丝举牌API请求
- */
 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)
 }
 
-/**
- * 处理动漫举牌API请求
- */
 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)
 }
 
-/**
- * 处理自定义图片API请求（带防重复逻辑）
- */
 async function processCustomImage(session: Session, apiUrl: string, config: Config) {
   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, msg: '请勿重复调用该API' }
+    return { success: false }
   }
   processedApi.set(hash, now)
 
@@ -203,16 +187,11 @@ async function processCustomImage(session: Session, apiUrl: string, config: Conf
   if (result.success && result.data) {
     await sendTimeout(session, config.imageParseFormat, config)
     await sendTimeout(session, h.image(result.data), config)
-    return { success: true, msg: result.msg }
-  } else {
-    await sendTimeout(session, `❌ ${result.msg}`, config)
-    return { success: false, msg: result.msg }
+    return { success: true }
   }
+  return { success: false }
 }
 
-/**
- * 刷新消息缓冲
- */
 async function flush(session: Session, config: Config, manualApi?: string) {
   const key = `${session.platform}:${session.userId}:${session.channelId}`
   const buf = imageBuffer.get(key)
@@ -225,30 +204,25 @@ async function flush(session: Session, config: Config, manualApi?: string) {
 
   if (config.customImageEnabled && apis.length) {
     const apiUrl = randomSelectApi(apis)
-    if (!apiUrl) {
-      await sendTimeout(session, '❌ 自定义图片API列表为空', config)
-      return
-    }
-    await processCustomImage(session, apiUrl, config)
+    if (apiUrl) await processCustomImage(session, apiUrl, config)
   }
 }
 
-// ==================== 插件主逻辑 ====================
+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)]
+}
+
 export function apply(ctx: Context, config: Config) {
-  // 初始化：清空缓存
   clearAllCache()
-  ctx.logger.info('[custom-image] 自定义图片插件已加载')
+  createTempDir(config)
+  ctx.logger.info('[custom-image] 插件已加载')
 
-  // 🔥 关键：删除所有ctx.axios相关的代码，无需加载axios服务
-
-  // 随机图片指令
-  ctx.command('random-image [apis...]', '随机获取自定义图片API的图片')
+  ctx.command('random-image [apis...]', '随机获取自定义图片')
     .option('api', '-a <api> 指定单个API地址')
     .action(async ({ session, options = {} }, ...apis) => {
-      if (!config.enable || !config.customImageEnabled) {
-        return '❌ 自定义图片功能已禁用'
-      }
-      if (!session) return
+      if (!config.enable || !config.customImageEnabled || !session) return
 
       const targetApi = options.api || (apis.length ? apis.join(' ') : null)
       if (targetApi) {
@@ -256,14 +230,12 @@ export function apply(ctx: Context, config: Config) {
       } else {
         const key = `${session.platform}:${session.userId}:${session.channelId}`
         
-        // 显示等待提示
         let tipId
         if (config.showWaitingTip) {
-          const m = await sendTimeout(session, config.waitingTipText, config)
-          tipId = (m as any)?.messageId || (m as any)?.id || m
+          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)
@@ -278,15 +250,9 @@ export function apply(ctx: Context, config: Config) {
       }
     })
 
-  // 黑丝举牌指令
   ctx.command('hsjp <msg> [msg1] [msg2]', '生成黑丝举牌图片')
     .action(async ({ session }, msg, msg1 = '', msg2 = '') => {
-      if (!config.enable || !config.hsjpEnabled) {
-        return '❌ 黑丝举牌功能已禁用'
-      }
-      if (!session || !msg) {
-        return '❌ 请输入举牌文字！格式：hsjp <第一行> [第二行] [第三行]'
-      }
+      if (!config.enable || !config.hsjpEnabled || !session || !msg) return
 
       if (config.showWaitingTip) {
         await sendTimeout(session, config.waitingTipText, config)
@@ -296,20 +262,12 @@ export function apply(ctx: Context, config: Config) {
       if (result.success && result.data) {
         await sendTimeout(session, config.imageParseFormat, config)
         await sendTimeout(session, h.image(result.data), config)
-      } else {
-        await sendTimeout(session, `❌ ${result.msg}`, config)
       }
     })
 
-  // 动漫举牌指令
   ctx.command('dmjp <text>', '生成动漫举牌图片')
     .action(async ({ session }, text) => {
-      if (!config.enable || !config.dmjpEnabled) {
-        return '❌ 动漫举牌功能已禁用'
-      }
-      if (!session || !text) {
-        return '❌ 请输入举牌文字！格式：dmjp <文本>'
-      }
+      if (!config.enable || !config.dmjpEnabled || !session || !text) return
 
       if (config.showWaitingTip) {
         await sendTimeout(session, config.waitingTipText, config)
@@ -319,46 +277,38 @@ export function apply(ctx: Context, config: Config) {
       if (result.success && result.data) {
         await sendTimeout(session, config.imageParseFormat, config)
         await sendTimeout(session, h.image(result.data), config)
-      } else {
-        await sendTimeout(session, `❌ ${result.msg}`, config)
       }
     })
 
-  // 清空缓存指令
-  ctx.command('clear-image-cache', '清空图片插件缓存')
+  ctx.command('clear-image-cache', '清空图片缓存')
     .action(() => {
       clearAllCache()
-      return '✅ 图片插件缓存已清空'
     })
 
-  // 定时清理过期缓存（每小时）
   setInterval(() => {
     const now = Date.now()
     processedApi.forEach((time, hash) => {
-      if (now - time > 86400000) { // 24小时过期
+      if (now - time > 86400000) {
         processedApi.delete(hash)
       }
     })
   }, 3600000)
 
-  // 自动清理缓存（按配置）
   if (config.autoClearCacheInterval > 0) {
     setInterval(() => {
       clearAllCache()
-      ctx.logger.info('[custom-image] 自动清理缓存完成')
+      ctx.logger.info('[custom-image] 缓存已自动清理')
     }, config.autoClearCacheInterval * 60000)
   }
 
-  // 进程退出清理
   process.on('exit', () => {
     clearAllCache()
-    ctx.logger.info('[custom-image] 插件缓存已清理，进程退出')
+    ctx.logger.info('[custom-image] 插件缓存已清理')
   })
 }
 
-// ==================== 插件元信息（移除axios依赖声明） ====================
 export const inject = {
-  optional: ['i18n'] // 仅保留可选的i18n，移除axios
+  optional: ['i18n']
 }
 
-export const using = [] as const // 清空using，无需依赖任何服务
+export const using = [] as const

package/src/locales/zh-CN.yml

@@ -1,9 +0,0 @@
-customImage:
-  noApi: 自定义图片API列表为空，请先在插件配置中添加！
-  error: 图片获取失败：{{msg}}
-  hsjpDisabled: 黑丝举牌功能已禁用，请联系管理员开启！
-  hsjpNoText: 请输入举牌文字！格式：hsjp <第一行> [第二行] [第三行]
-  hsjpError: 黑丝举牌生成失败：{{msg}}
-  dmjpDisabled: 动漫举牌功能已禁用，请联系管理员开启！
-  dmjpNoText: 请输入举牌文字！格式：dmjp <文本>
-  dmjpError: 动漫举牌生成失败：{{msg}}