Upload 4 files

src/lib/imageProcessor.js

@@ -0,0 +1,208 @@
+const sharp = require('sharp')
+
+/**
+ * 图片处理工具类
+ * 专门处理长图检测、智能切割和重叠处理
+ */
+class ImageProcessor {
+  constructor() {
+    // 长图阈值：高度超过宽度*4倍
+    this.LONG_IMAGE_RATIO = 4
+    // 重叠像素范围
+    this.OVERLAP_MIN = 50
+    this.OVERLAP_MAX = 100
+    // 默认重叠像素
+    this.DEFAULT_OVERLAP = 75
+  }
+
+  /**
+   * 检测是否为长图
+   * @param {Buffer} imageBuffer - 图片缓冲区
+   * @returns {Promise<{isLongImage: boolean, width: number, height: number}>}
+   */
+  async detectLongImage(imageBuffer) {
+    try {
+      const metadata = await sharp(imageBuffer).metadata()
+      const { width, height } = metadata
+      
+      if (!width || !height) {
+        throw new Error('无法获取图片尺寸信息')
+      }
+
+      const isLongImage = height > width * this.LONG_IMAGE_RATIO
+      
+      return {
+        isLongImage,
+        width,
+        height,
+        ratio: height / width
+      }
+    } catch (error) {
+      throw new Error(`图片尺寸检测失败: ${error.message}`)
+    }
+  }
+
+  /**
+   * 计算切割参数
+   * @param {number} width - 图片宽度
+   * @param {number} height - 图片高度
+   * @param {number} overlap - 重叠像素数
+   * @returns {Array<{top: number, left: number, width: number, height: number}>}
+   */
+  calculateCropRegions(width, height, overlap = this.DEFAULT_OVERLAP) {
+    const regions = []
+    const maxHeight = width * this.LONG_IMAGE_RATIO // 每个片段的最大高度
+    
+    let currentTop = 0
+    let segmentIndex = 0
+    
+    while (currentTop < height) {
+      const remainingHeight = height - currentTop
+      let segmentHeight = Math.min(maxHeight, remainingHeight)
+      
+      // 如果不是第一个片段，需要向上扩展重叠区域
+      if (segmentIndex > 0) {
+        currentTop = Math.max(0, currentTop - overlap)
+        segmentHeight = Math.min(maxHeight + overlap, height - currentTop)
+      }
+      
+      // 如果不是最后一个片段，需要向下扩展重叠区域
+      if (currentTop + segmentHeight < height) {
+        segmentHeight = Math.min(segmentHeight + overlap, height - currentTop)
+      }
+      
+      regions.push({
+        top: currentTop,
+        left: 0,
+        width: width,
+        height: segmentHeight,
+        segmentIndex: segmentIndex,
+        isFirst: segmentIndex === 0,
+        isLast: currentTop + segmentHeight >= height
+      })
+      
+      // 移动到下一个片段的起始位置（考虑重叠）
+      currentTop += (segmentIndex === 0 ? maxHeight : maxHeight - overlap)
+      segmentIndex++
+    }
+    
+    return regions
+  }
+
+  /**
+   * 切割长图为多个片段
+   * @param {Buffer} imageBuffer - 原始图片缓冲区
+   * @param {number} overlap - 重叠像素数
+   * @returns {Promise<Array<{buffer: Buffer, metadata: Object}>>}
+   */
+  async cropLongImage(imageBuffer, overlap = this.DEFAULT_OVERLAP) {
+    try {
+      const detection = await this.detectLongImage(imageBuffer)
+      
+      if (!detection.isLongImage) {
+        // 不是长图，返回原图
+        return [{
+          buffer: imageBuffer,
+          metadata: {
+            segmentIndex: 0,
+            totalSegments: 1,
+            isFirst: true,
+            isLast: true,
+            originalWidth: detection.width,
+            originalHeight: detection.height,
+            segmentWidth: detection.width,
+            segmentHeight: detection.height
+          }
+        }]
+      }
+
+      const { width, height } = detection
+      const regions = this.calculateCropRegions(width, height, overlap)
+      const segments = []
+
+      console.log(`检测到长图 ${width}x${height}，将切割为 ${regions.length} 个片段`)
+
+      for (const region of regions) {
+        const segmentBuffer = await sharp(imageBuffer)
+          .extract({
+            left: region.left,
+            top: region.top,
+            width: region.width,
+            height: region.height
+          })
+          .png() // 统一输出为PNG格式
+          .toBuffer()
+
+        segments.push({
+          buffer: segmentBuffer,
+          metadata: {
+            segmentIndex: region.segmentIndex,
+            totalSegments: regions.length,
+            isFirst: region.isFirst,
+            isLast: region.isLast,
+            originalWidth: width,
+            originalHeight: height,
+            segmentWidth: region.width,
+            segmentHeight: region.height,
+            cropRegion: {
+              top: region.top,
+              left: region.left,
+              width: region.width,
+              height: region.height
+            }
+          }
+        })
+
+        console.log(`生成片段 ${region.segmentIndex + 1}/${regions.length}: ${region.width}x${region.height} (top: ${region.top})`)
+      }
+
+      return segments
+    } catch (error) {
+      throw new Error(`长图切割失败: ${error.message}`)
+    }
+  }
+
+  /**
+   * 生成片段文件名
+   * @param {string} originalName - 原始文件名
+   * @param {number} segmentIndex - 片段索引
+   * @param {number} totalSegments - 总片段数
+   * @returns {string}
+   */
+  generateSegmentName(originalName, segmentIndex, totalSegments) {
+    const nameWithoutExt = originalName.replace(/\.[^/.]+$/, '')
+    const ext = originalName.includes('.') ? originalName.split('.').pop() : 'png'
+    
+    return `${nameWithoutExt}_part${segmentIndex + 1}of${totalSegments}.${ext}`
+  }
+
+  /**
+   * 获取处理统计信息
+   * @param {Array} segments - 切割后的片段数组
+   * @returns {Object}
+   */
+  getProcessingStats(segments) {
+    if (!segments || segments.length === 0) {
+      return { totalSegments: 0, isLongImage: false }
+    }
+
+    const firstSegment = segments[0]
+    const metadata = firstSegment.metadata
+
+    return {
+      totalSegments: segments.length,
+      isLongImage: segments.length > 1,
+      originalDimensions: {
+        width: metadata.originalWidth,
+        height: metadata.originalHeight
+      },
+      segmentDimensions: segments.map(segment => ({
+        width: segment.metadata.segmentWidth,
+        height: segment.metadata.segmentHeight,
+        index: segment.metadata.segmentIndex
+      }))
+    }
+  }
+}
+
+module.exports = new ImageProcessor()

src/lib/logger.js

@@ -0,0 +1,296 @@
+/**
+ * 日志系统模块
+ * 提供完整的请求追踪、性能监控和错误记录功能
+ */
+class Logger {
+  constructor() {
+    this.requestCounter = 0
+    this.activeRequests = new Map()
+  }
+
+  /**
+   * 生成请求ID
+   * @returns {string}
+   */
+  generateRequestId() {
+    this.requestCounter++
+    return `req_${Date.now()}_${this.requestCounter.toString().padStart(4, '0')}`
+  }
+
+  /**
+   * 格式化时间戳
+   * @returns {string}
+   */
+  getTimestamp() {
+    return new Date().toISOString()
+  }
+
+  /**
+   * 记录请求开始
+   * @param {string} method - HTTP方法
+   * @param {string} url - 请求URL
+   * @param {Object} headers - 请求头
+   * @param {Object} body - 请求体（部分信息）
+   * @returns {string} requestId
+   */
+  logRequestStart(method, url, headers = {}, body = {}) {
+    const requestId = this.generateRequestId()
+    const timestamp = this.getTimestamp()
+    
+    // 提取关键信息，避免记录敏感数据
+    const logData = {
+      requestId,
+      timestamp,
+      method,
+      url,
+      userAgent: headers['user-agent'] || 'unknown',
+      contentType: headers['content-type'] || 'unknown',
+      contentLength: headers['content-length'] || 'unknown',
+      model: body.model || 'unknown',
+      messageCount: Array.isArray(body.messages) ? body.messages.length : 0,
+      hasImages: this.detectImages(body.messages),
+      isStream: body.stream === true
+    }
+
+    // 记录到活跃请求映射
+    this.activeRequests.set(requestId, {
+      startTime: Date.now(),
+      ...logData
+    })
+
+    console.log(`[REQUEST_START] ${JSON.stringify(logData)}`)
+    return requestId
+  }
+
+  /**
+   * 记录请求结束
+   * @param {string} requestId - 请求ID
+   * @param {number} statusCode - 响应状态码
+   * @param {Object} responseInfo - 响应信息
+   */
+  logRequestEnd(requestId, statusCode, responseInfo = {}) {
+    const timestamp = this.getTimestamp()
+    const activeRequest = this.activeRequests.get(requestId)
+    
+    if (!activeRequest) {
+      console.warn(`[REQUEST_END] 未找到请求ID: ${requestId}`)
+      return
+    }
+
+    const duration = Date.now() - activeRequest.startTime
+    
+    const logData = {
+      requestId,
+      timestamp,
+      duration: `${duration}ms`,
+      statusCode,
+      success: statusCode >= 200 && statusCode < 300,
+      model: activeRequest.model,
+      isStream: activeRequest.isStream,
+      ...responseInfo
+    }
+
+    console.log(`[REQUEST_END] ${JSON.stringify(logData)}`)
+    
+    // 清理活跃请求
+    this.activeRequests.delete(requestId)
+  }
+
+  /**
+   * 记录图片处理开始
+   * @param {string} requestId - 请求ID
+   * @param {number} imageCount - 图片数量
+   */
+  logImageProcessingStart(requestId, imageCount) {
+    const timestamp = this.getTimestamp()
+    const logData = {
+      requestId,
+      timestamp,
+      event: 'IMAGE_PROCESSING_START',
+      imageCount
+    }
+    
+    console.log(`[IMAGE_PROCESSING] ${JSON.stringify(logData)}`)
+  }
+
+  /**
+   * 记录长图检测结果
+   * @param {string} requestId - 请求ID
+   * @param {number} imageIndex - 图片索引
+   * @param {Object} detection - 检测结果
+   */
+  logLongImageDetection(requestId, imageIndex, detection) {
+    const timestamp = this.getTimestamp()
+    const logData = {
+      requestId,
+      timestamp,
+      event: 'LONG_IMAGE_DETECTION',
+      imageIndex,
+      isLongImage: detection.isLongImage,
+      dimensions: `${detection.width}x${detection.height}`,
+      ratio: detection.ratio?.toFixed(2)
+    }
+    
+    console.log(`[IMAGE_PROCESSING] ${JSON.stringify(logData)}`)
+  }
+
+  /**
+   * 记录图片切割结果
+   * @param {string} requestId - 请求ID
+   * @param {number} imageIndex - 图片索引
+   * @param {Object} cropResult - 切割结果
+   */
+  logImageCropping(requestId, imageIndex, cropResult) {
+    const timestamp = this.getTimestamp()
+    const stats = cropResult.stats || {}
+    
+    const logData = {
+      requestId,
+      timestamp,
+      event: 'IMAGE_CROPPING',
+      imageIndex,
+      totalSegments: stats.totalSegments || 0,
+      originalDimensions: stats.originalDimensions,
+      segmentCount: cropResult.segments?.length || 0
+    }
+    
+    console.log(`[IMAGE_PROCESSING] ${JSON.stringify(logData)}`)
+  }
+
+  /**
+   * 记录图片上传结果
+   * @param {string} requestId - 请求ID
+   * @param {number} imageIndex - 图片索引
+   * @param {number} segmentIndex - 片段索引（如果是长图）
+   * @param {boolean} success - 是否成功
+   * @param {string} url - 上传后的URL
+   * @param {string} error - 错误信息
+   */
+  logImageUpload(requestId, imageIndex, segmentIndex, success, url = null, error = null) {
+    const timestamp = this.getTimestamp()
+    const logData = {
+      requestId,
+      timestamp,
+      event: 'IMAGE_UPLOAD',
+      imageIndex,
+      segmentIndex,
+      success,
+      url: success ? url : null,
+      error: success ? null : error
+    }
+    
+    console.log(`[IMAGE_PROCESSING] ${JSON.stringify(logData)}`)
+  }
+
+  /**
+   * 记录模型调用开始
+   * @param {string} requestId - 请求ID
+   * @param {string} model - 模型名称
+   * @param {string} mammouthModel - Mammouth平台模型名称
+   */
+  logModelCallStart(requestId, model, mammouthModel) {
+    const timestamp = this.getTimestamp()
+    const logData = {
+      requestId,
+      timestamp,
+      event: 'MODEL_CALL_START',
+      requestedModel: model,
+      mammouthModel,
+    }
+    
+    console.log(`[MODEL_CALL] ${JSON.stringify(logData)}`)
+  }
+
+  /**
+   * 记录模型调用结果
+   * @param {string} requestId - 请求ID
+   * @param {boolean} success - 是否成功
+   * @param {string} error - 错误信息
+   * @param {number} duration - 调用耗时
+   */
+  logModelCallEnd(requestId, success, error = null, duration = null) {
+    const timestamp = this.getTimestamp()
+    const logData = {
+      requestId,
+      timestamp,
+      event: 'MODEL_CALL_END',
+      success,
+      error: success ? null : error,
+      duration: duration ? `${duration}ms` : null
+    }
+    
+    console.log(`[MODEL_CALL] ${JSON.stringify(logData)}`)
+  }
+
+  /**
+   * 记录错误信息
+   * @param {string} requestId - 请求ID
+   * @param {string} errorType - 错误类型
+   * @param {string} errorMessage - 错误消息
+   * @param {Object} errorDetails - 错误详情
+   */
+  logError(requestId, errorType, errorMessage, errorDetails = {}) {
+    const timestamp = this.getTimestamp()
+    const logData = {
+      requestId,
+      timestamp,
+      event: 'ERROR',
+      errorType,
+      errorMessage,
+      ...errorDetails
+    }
+    
+    console.error(`[ERROR] ${JSON.stringify(logData)}`)
+  }
+
+  /**
+   * 记录性能指标
+   * @param {string} requestId - 请求ID
+   * @param {Object} metrics - 性能指标
+   */
+  logPerformanceMetrics(requestId, metrics) {
+    const timestamp = this.getTimestamp()
+    const logData = {
+      requestId,
+      timestamp,
+      event: 'PERFORMANCE_METRICS',
+      ...metrics
+    }
+    
+    console.log(`[PERFORMANCE] ${JSON.stringify(logData)}`)
+  }
+
+  /**
+   * 检测消息中是否包含图片
+   * @param {Array} messages - 消息数组
+   * @returns {boolean}
+   */
+  detectImages(messages) {
+    if (!Array.isArray(messages)) return false
+    
+    return messages.some(message => {
+      if (Array.isArray(message.content)) {
+        return message.content.some(part => part.type === 'image_url')
+      }
+      return false
+    })
+  }
+
+  /**
+   * 获取活跃请求统计
+   * @returns {Object}
+   */
+  getActiveRequestsStats() {
+    return {
+      count: this.activeRequests.size,
+      requests: Array.from(this.activeRequests.entries()).map(([id, req]) => ({
+        requestId: id,
+        duration: Date.now() - req.startTime,
+        model: req.model,
+        isStream: req.isStream
+      }))
+    }
+  }
+}
+
+module.exports = new Logger()

src/lib/uploader.js

@@ -2,31 +2,13 @@ const axios = require('axios')
 const FormData = require('form-data')
 const crypto = require('crypto')
 const accountManager = require('./manager')
-const imageSlicer = require('./imageSlicer')
-const imgbbUploader = require('./imgbbUploader')
-const { IMAGE_CONFIG, IMGBB_API_KEY } = require('../config')
+const imageProcessor = require('./imageProcessor')
+const logger = require('./logger')
 
 class ImageUploader {
   constructor() {
     this.uploadUrl = 'https://mammouth.ai/api/attachments/saveFile'
     this.imageCache = new Map()
-
-    // 初始化配置
-    this.useImgbb = IMAGE_CONFIG.USE_IMGBB
-    this.uploadStrategy = IMAGE_CONFIG.UPLOAD_STRATEGY
-
-    // 设置图片裁切配置
-    imageSlicer.setConfig({
-      maxSize: IMAGE_CONFIG.MAX_SIZE,
-      overlapPixels: IMAGE_CONFIG.OVERLAP_PIXELS
-    })
-
-    // 设置Imgbb API密钥
-    if (IMGBB_API_KEY) {
-      imgbbUploader.setApiKey(IMGBB_API_KEY)
-    }
-
-    console.log(`图片上传器初始化: 策略=${this.uploadStrategy}, Imgbb=${this.useImgbb}`)
   }
 
 
@@ -34,122 +16,7 @@ class ImageUploader {
     return crypto.createHash('sha256').update(buffer).digest('hex')
   }
 
-  /**
-   * 智能处理图片：裁切大图并上传到图床
-   * @param {Buffer} imageBuffer - 图片缓冲区
-   * @param {string} imageName - 图片名称
-   * @returns {Promise<Array>} 图片URL数组（按顺序）
-   */
-  async processImageIntelligently(imageBuffer, imageName) {
-    const timestamp = new Date().toISOString()
-    const imageId = imageName.substring(0, 8) + '...'
-
-    try {
-      console.log(`[${timestamp}] 🖼️ [${imageId}] 开始智能处理图片: ${imageName}`)
-      console.log(`[${timestamp}] 📏 [${imageId}] 图片大小: ${(imageBuffer.length / 1024 / 1024).toFixed(2)} MB`)
-
-      // 1. 检查并裁切图片
-      const slices = await imageSlicer.sliceImage(imageBuffer, imageName)
-      console.log(`[${timestamp}] ✂️ [${imageId}] 图片裁切完成，共 ${slices.length} 片`)
-
-      // 检查是否为长图并记录特殊信息
-      if (slices.length > 0 && slices[0].isLongImage) {
-        console.log(`[${timestamp}] 📏 [${imageId}] 检测到长图，使用优化裁切策略`)
-        console.log(`[${timestamp}] 📊 [${imageId}] 长图信息: ${slices[0].size?.width}x${slices[0].size?.height}`)
-      }
-
-      // 2. 根据配置选择上传方式
-      // 优先尝试Mammouth原生上传，失败时使用Imgbb
-      if (this.useImgbb) {
-        // 先尝试Mammouth原生上传
-        try {
-          console.log(`[${timestamp}] 🏠 [${imageId}] 尝试Mammouth原生上传`)
-          const mammouthUrls = []
-          for (const slice of slices) {
-            try {
-              const url = await this.uploadImageToMammouth(slice.buffer, slice.name)
-              mammouthUrls.push(url)
-              console.log(`[${timestamp}] ✅ [${imageId}] 切片 ${slice.name} Mammouth上传成功`)
-            } catch (error) {
-              console.error(`[${timestamp}] ❌ [${imageId}] 切片 ${slice.name} Mammouth上传失败:`, error.message)
-              throw error // 如果Mammouth失败，抛出错误以尝试Imgbb
-            }
-          }
-
-          if (mammouthUrls.length === slices.length) {
-            console.log(`[${timestamp}] ✅ [${imageId}] Mammouth原生上传完成，成功 ${mammouthUrls.length} 片`)
-            return mammouthUrls
-          }
-        } catch (error) {
-          console.log(`[${timestamp}] ⚠️ [${imageId}] Mammouth原生上传失败，尝试Imgbb备用方案`)
-        }
-        // 使用Imgbb图床作为备用方案
-        console.log(`[${timestamp}] 🌐 [${imageId}] 使用Imgbb图床备用方案`)
-        const uploadResults = await imgbbUploader.uploadSlices(slices)
-
-        // 提取成功上传的URL，保持顺序
-        const imageUrls = uploadResults
-          .filter(result => result.uploadSuccess)
-          .map(result => result.url)
-
-        if (imageUrls.length === 0) {
-          console.error(`[${timestamp}] ❌ [${imageId}] 所有图片切片上传失败`)
-          throw new Error('所有图片切片上传失败')
-        }
-
-        if (imageUrls.length < slices.length) {
-          console.warn(`[${timestamp}] ⚠️ [${imageId}] 部分切片上传失败: ${imageUrls.length}/${slices.length}`)
-        }
-
-        console.log(`[${timestamp}] ✅ [${imageId}] Imgbb上传完成，成功 ${imageUrls.length} 片`)
-
-        // 验证上传的图片URL是否可访问
-        if (imageUrls.length > 0) {
-          console.log(`[${timestamp}] 🔍 [${imageId}] 验证图片URL可访问性`)
-          for (let i = 0; i < Math.min(imageUrls.length, 3); i++) { // 最多验证前3个
-            try {
-              const testResponse = await axios.head(imageUrls[i], { timeout: 5000 })
-              console.log(`[${timestamp}] ✅ [${imageId}] 图片${i+1}可访问: ${testResponse.status}`)
-            } catch (error) {
-              console.error(`[${timestamp}] ❌ [${imageId}] 图片${i+1}不可访问: ${error.message}`)
-            }
-          }
-        }
-
-        return imageUrls
-
-      } else {
-        // 使用原有的Mammouth平台上传
-        console.log(`[${timestamp}] 🏠 [${imageId}] 开始上传到Mammouth平台`)
-        const imageUrls = []
-        for (const slice of slices) {
-          try {
-            const url = await this.uploadImageToMammouth(slice.buffer, slice.name)
-            imageUrls.push(url)
-            console.log(`[${timestamp}] ✅ [${imageId}] 切片 ${slice.name} 上传成功`)
-          } catch (error) {
-            console.error(`[${timestamp}] ❌ [${imageId}] 切片 ${slice.name} 上传到Mammouth失败:`, error.message)
-            // 继续处理其他切片
-          }
-        }
-
-        if (imageUrls.length === 0) {
-          console.error(`[${timestamp}] ❌ [${imageId}] 所有图片切片上传失败`)
-          throw new Error('所有图片切片上传失败')
-        }
-
-        console.log(`[${timestamp}] ✅ [${imageId}] Mammouth上传完成，成功 ${imageUrls.length} 片`)
-        return imageUrls
-      }
-
-    } catch (error) {
-      console.error(`[${timestamp}] ❌ [${imageId}] 智能图片处理失败:`, error.message)
-      console.error(`[${timestamp}] 🔍 [${imageId}] 错误堆栈:`, error.stack?.split('\n')[0] || 'No stack trace')
-      throw error
-    }
-  }
-
-  async uploadImageToMammouth(imageBuffer, imageName) {
+  async uploadImage(imageBuffer, imageName) {
     // 确保参数有效
     if (!imageBuffer || !Buffer.isBuffer(imageBuffer)) {
       throw new Error('无效的图片数据')
@@ -213,7 +80,7 @@ class ImageUploader {
       if (error.response && error.response.status === 403) {
         accountManager.markAsUnavailable(cookieValue)
         // 递归尝试使用新账号
-        return this.uploadImageToMammouth(imageBuffer, imageName)
+        return this.uploadImage(imageBuffer, imageName)
       }
       
       throw new Error(`图片上传失败: ${error.message}`)
@@ -224,21 +91,21 @@ class ImageUploader {
     // 处理base64字符串，移除可能的前缀
     const base64Data = base64String.replace(/^data:image\/\w+;base64,/, '')
     const buffer = Buffer.from(base64Data, 'base64')
-
+    
     // 如果提供了前缀，则从中提取图片类型
     let fileExt = 'png'
     const mimeMatch = base64String.match(/^data:image\/(\w+);base64,/)
     if (mimeMatch && mimeMatch[1]) {
       fileExt = mimeMatch[1]
     }
-
+    
     // 如果没有提供文件名，则使用哈希值的前8位和时间戳生成
     if (!imageName) {
       const hash = this.generateHash(buffer).substring(0, 8)
       imageName = `image_${hash}_${Date.now()}.${fileExt}`
     }
-
-    return this.processImageIntelligently(buffer, imageName)
+    
+    return this.uploadImage(buffer, imageName)
   }
 
   async uploadFromUrl(imageUrl, imageName) {
@@ -247,24 +114,24 @@ class ImageUploader {
       const response = await axios.get(imageUrl, {
         responseType: 'arraybuffer'
       })
-
+      
       // 从URL中提取文件扩展名
       let fileExt = 'png'
       const urlMatch = imageUrl.match(/\.([a-zA-Z0-9]+)(?:\?.*)?$/)
       if (urlMatch && urlMatch[1]) {
         fileExt = urlMatch[1].toLowerCase()
       }
-
+      
       // 生成buffer并计算哈希
       const buffer = Buffer.from(response.data)
-
+      
       // 如果没有提供文件名，则使用哈希值的前8位和时间戳生成
       if (!imageName) {
         const hash = this.generateHash(buffer).substring(0, 8)
         imageName = `image_${hash}_${Date.now()}.${fileExt}`
       }
-
-      return this.processImageIntelligently(buffer, imageName)
+      
+      return this.uploadImage(buffer, imageName)
     } catch (error) {
       throw new Error(`从URL获取图片失败: ${error.message}`)
     }
@@ -282,6 +149,152 @@ class ImageUploader {
     this.imageCache.clear()
     return { cleared: oldSize }
   }
+
+  /**
+   * 智能上传图片（支持长图处理）
+   * @param {Buffer} imageBuffer - 图片缓冲区
+   * @param {string} imageName - 图片名称
+   * @param {string} requestId - 请求ID（用于日志）
+   * @param {number} imageIndex - 图片索引（用于日志）
+   * @returns {Promise<Array<string>>} 上传后的URL数组
+   */
+  async uploadImageSmart(imageBuffer, imageName, requestId = null, imageIndex = 0) {
+    try {
+      // 检测是否为长图
+      const detection = await imageProcessor.detectLongImage(imageBuffer)
+
+      if (requestId) {
+        logger.logLongImageDetection(requestId, imageIndex, detection)
+      }
+
+      if (!detection.isLongImage) {
+        // 不是长图，使用原有方式上传
+        const url = await this.uploadImage(imageBuffer, imageName)
+
+        if (requestId) {
+          logger.logImageUpload(requestId, imageIndex, 0, true, url)
+        }
+
+        return [url]
+      }
+
+      // 是长图，进行切割处理
+      console.log(`检测到长图 ${detection.width}x${detection.height}，开始切割处理`)
+
+      const segments = await imageProcessor.cropLongImage(imageBuffer)
+      const uploadedUrls = []
+
+      if (requestId) {
+        logger.logImageCropping(requestId, imageIndex, {
+          segments,
+          stats: imageProcessor.getProcessingStats(segments)
+        })
+      }
+
+      // 逐个上传切割后的片段
+      for (const segment of segments) {
+        const segmentName = imageProcessor.generateSegmentName(
+          imageName,
+          segment.metadata.segmentIndex,
+          segment.metadata.totalSegments
+        )
+
+        try {
+          const url = await this.uploadImage(segment.buffer, segmentName)
+          uploadedUrls.push(url)
+
+          if (requestId) {
+            logger.logImageUpload(requestId, imageIndex, segment.metadata.segmentIndex, true, url)
+          }
+
+          console.log(`片段 ${segment.metadata.segmentIndex + 1}/${segment.metadata.totalSegments} 上传成功: ${url}`)
+        } catch (error) {
+          if (requestId) {
+            logger.logImageUpload(requestId, imageIndex, segment.metadata.segmentIndex, false, null, error.message)
+          }
+          throw new Error(`片段 ${segment.metadata.segmentIndex + 1} 上传失败: ${error.message}`)
+        }
+      }
+
+      console.log(`长图切割上传完成，共 ${uploadedUrls.length} 个片段`)
+      return uploadedUrls
+
+    } catch (error) {
+      if (requestId) {
+        logger.logError(requestId, 'IMAGE_UPLOAD_ERROR', error.message, {
+          imageIndex,
+          imageName
+        })
+      }
+      throw error
+    }
+  }
+
+  /**
+   * 智能上传Base64图片（支持长图处理）
+   * @param {string} base64String - Base64字符串
+   * @param {string} imageName - 图片名称
+   * @param {string} requestId - 请求ID（用于日志）
+   * @param {number} imageIndex - 图片索引（用于日志）
+   * @returns {Promise<Array<string>>} 上传后的URL数组
+   */
+  async uploadFromBase64Smart(base64String, imageName, requestId = null, imageIndex = 0) {
+    // 处理base64字符串，移除可能的前缀
+    const base64Data = base64String.replace(/^data:image\/\w+;base64,/, '')
+    const buffer = Buffer.from(base64Data, 'base64')
+
+    // 如果提供了前缀，则从中提取图片类型
+    let fileExt = 'png'
+    const mimeMatch = base64String.match(/^data:image\/(\w+);base64,/)
+    if (mimeMatch && mimeMatch[1]) {
+      fileExt = mimeMatch[1]
+    }
+
+    // 如果没有提供文件名，则使用哈希值的前8位和时间戳生成
+    if (!imageName) {
+      const hash = this.generateHash(buffer).substring(0, 8)
+      imageName = `image_${hash}_${Date.now()}.${fileExt}`
+    }
+
+    return this.uploadImageSmart(buffer, imageName, requestId, imageIndex)
+  }
+
+  /**
+   * 智能上传URL图片（支持长图处理）
+   * @param {string} imageUrl - 图片URL
+   * @param {string} imageName - 图片名称
+   * @param {string} requestId - 请求ID（用于日志）
+   * @param {number} imageIndex - 图片索引（用于日志）
+   * @returns {Promise<Array<string>>} 上传后的URL数组
+   */
+  async uploadFromUrlSmart(imageUrl, imageName, requestId = null, imageIndex = 0) {
+    try {
+      // 下载图片
+      const response = await axios.get(imageUrl, {
+        responseType: 'arraybuffer'
+      })
+
+      // 从URL中提取文件扩展名
+      let fileExt = 'png'
+      const urlMatch = imageUrl.match(/\.([a-zA-Z0-9]+)(?:\?.*)?$/)
+      if (urlMatch && urlMatch[1]) {
+        fileExt = urlMatch[1].toLowerCase()
+      }
+
+      // 生成buffer并计算哈希
+      const buffer = Buffer.from(response.data)
+
+      // 如果没有提供文件名，则使用哈希值的前8位和时间戳生成
+      if (!imageName) {
+        const hash = this.generateHash(buffer).substring(0, 8)
+        imageName = `image_${hash}_${Date.now()}.${fileExt}`
+      }
+
+      return this.uploadImageSmart(buffer, imageName, requestId, imageIndex)
+    } catch (error) {
+      throw new Error(`从URL获取图片失败: ${error.message}`)
+    }
+  }
 }