Upload 2 files

src/lib/imageProcessor.js

@@ -6,8 +6,8 @@ const sharp = require('sharp')
  */
 class ImageProcessor {
   constructor() {
-    // 长图阈值：高度超过宽度*3倍（更合理的阈值）
-    this.LONG_IMAGE_RATIO = 3
+    // 长图阈值：高度超过宽度*2.5倍（更合理的阈值，确保1080x4000等图片能被识别）
+    this.LONG_IMAGE_RATIO = 2.5
     // 重叠像素范围
     this.OVERLAP_MIN = 50
     this.OVERLAP_MAX = 100

src/lib/uploader.js

@@ -16,7 +16,7 @@ class ImageUploader {
     return crypto.createHash('sha256').update(buffer).digest('hex')
   }
 
-  async uploadImage(imageBuffer, imageName, forceUpload = false) {
+  async uploadImage(imageBuffer, imageName) {
     // 确保参数有效
     if (!imageBuffer || !Buffer.isBuffer(imageBuffer)) {
       throw new Error('无效的图片数据')
@@ -29,15 +29,13 @@ class ImageUploader {
     // 生成图片数据的哈希值作为缓存key
     const imageHash = this.generateHash(imageBuffer)
 
-    // 检查缓存中是否已存在该图片的上传结果（除非强制上传）
-    if (!forceUpload && this.imageCache.has(imageHash)) {
-      console.log(`[缓存命中] 图片哈希: ${imageHash.substring(0, 8)}...`)
-      const cachedUrl = this.imageCache.get(imageHash)
-      console.log(`[缓存返回] URL: ${cachedUrl}`)
-      return cachedUrl
+    // 检查缓存中是否已存在该图片的上传结果
+    if (this.imageCache.has(imageHash)) {
+      console.log(`图片缓存命中: ${imageHash.substring(0, 8)}...`)
+      return this.imageCache.get(imageHash)
     }
 
-    console.log(`[开始上传] 图片哈希: ${imageHash.substring(0, 8)}... ${forceUpload ? '(强制上传)' : '(缓存未命中)'}`)
+    console.log(`图片缓存未命中，开始上传: ${imageHash.substring(0, 8)}...`)
 
     // 获取一个可用的cookie
     const cookieValue = accountManager.getNextAvailableCookie()
@@ -71,7 +69,7 @@ class ImageUploader {
 
         // 将结果保存到缓存
         this.imageCache.set(imageHash, imageUrl)
-        console.log(`[上传成功] 图片哈希: ${imageHash.substring(0, 8)}... -> ${imageUrl}`)
+        console.log(`图片上传成功并缓存: ${imageHash.substring(0, 8)}... -> ${imageUrl}`)
 
         return imageUrl
       } else {
@@ -82,7 +80,7 @@ class ImageUploader {
       if (error.response && error.response.status === 403) {
         accountManager.markAsUnavailable(cookieValue)
         // 递归尝试使用新账号
-        return this.uploadImage(imageBuffer, imageName, forceUpload)
+        return this.uploadImage(imageBuffer, imageName)
       }
 
       throw new Error(`图片上传失败: ${error.message}`)
@@ -158,13 +156,10 @@ class ImageUploader {
    * @param {string} imageName - 图片名称
    * @param {string} requestId - 请求ID（用于日志）
    * @param {number} imageIndex - 图片索引（用于日志）
-   * @param {boolean} preserveOrder - 是否保持顺序（禁用缓存优化）
    * @returns {Promise<Array<string>>} 上传后的URL数组
    */
-  async uploadImageSmart(imageBuffer, imageName, requestId = null, imageIndex = 0, preserveOrder = false) {
+  async uploadImageSmart(imageBuffer, imageName, requestId = null, imageIndex = 0) {
     try {
-      console.log(`[智能上传] 开始处理图片${imageIndex + 1}，保持顺序: ${preserveOrder}`)
-
       // 检测是否为长图
       const detection = await imageProcessor.detectLongImage(imageBuffer)
 
@@ -174,85 +169,110 @@ class ImageUploader {
 
       if (!detection.isLongImage) {
         // 不是长图，使用原有方式上传
-        console.log(`[智能上传] 图片${imageIndex + 1}为普通图片，开始上传`)
-
-        // 如果需要保持顺序，则禁用缓存优化
-        const url = await this.uploadImage(imageBuffer, imageName, preserveOrder)
+        const url = await this.uploadImage(imageBuffer, imageName)
 
         if (requestId) {
           logger.logImageUpload(requestId, imageIndex, 0, true, url)
         }
 
-        console.log(`[智能上传] 图片${imageIndex + 1}上传完成: ${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)
-        })
-      }
+      try {
+        const segments = await imageProcessor.cropLongImage(imageBuffer)
 
-      // 并行上传切割后的片段
-      const uploadPromises = segments.map(async (segment) => {
-        const segmentName = imageProcessor.generateSegmentName(
-          imageName,
-          segment.metadata.segmentIndex,
-          segment.metadata.totalSegments
-        )
+        if (!segments || segments.length === 0) {
+          throw new Error('长图切割失败：未生成任何片段')
+        }
 
-        try {
-          const url = await this.uploadImage(segment.buffer, segmentName)
+        if (requestId) {
+          logger.logImageCropping(requestId, imageIndex, {
+            segments,
+            stats: imageProcessor.getProcessingStats(segments)
+          })
+        }
 
-          if (requestId) {
-            logger.logImageUpload(requestId, imageIndex, segment.metadata.segmentIndex, true, url)
+        // 并行上传切割后的片段
+        const uploadPromises = segments.map(async (segment) => {
+          const segmentName = imageProcessor.generateSegmentName(
+            imageName,
+            segment.metadata.segmentIndex,
+            segment.metadata.totalSegments
+          )
+
+          try {
+            const url = await this.uploadImage(segment.buffer, segmentName)
+
+            if (requestId) {
+              logger.logImageUpload(requestId, imageIndex, segment.metadata.segmentIndex, true, url)
+            }
+
+            console.log(`片段 ${segment.metadata.segmentIndex + 1}/${segment.metadata.totalSegments} 上传成功: ${url}`)
+            return {
+              url,
+              segmentIndex: segment.metadata.segmentIndex,
+              success: true
+            }
+          } catch (error) {
+            if (requestId) {
+              logger.logImageUpload(requestId, imageIndex, segment.metadata.segmentIndex, false, null, error.message)
+            }
+
+            console.error(`片段 ${segment.metadata.segmentIndex + 1} 上传失败: ${error.message}`)
+            return {
+              error: error.message,
+              segmentIndex: segment.metadata.segmentIndex,
+              success: false
+            }
           }
+        })
 
-          console.log(`片段 ${segment.metadata.segmentIndex + 1}/${segment.metadata.totalSegments} 上传成功: ${url}`)
-          return {
-            url,
-            segmentIndex: segment.metadata.segmentIndex,
-            success: true
-          }
-        } catch (error) {
-          if (requestId) {
-            logger.logImageUpload(requestId, imageIndex, segment.metadata.segmentIndex, false, null, error.message)
-          }
+        // 等待所有上传完成
+        const uploadResults = await Promise.all(uploadPromises)
 
-          console.error(`片段 ${segment.metadata.segmentIndex + 1} 上传失败: ${error.message}`)
-          return {
-            error: error.message,
-            segmentIndex: segment.metadata.segmentIndex,
-            success: false
-          }
+        // 检查是否有失败的上传
+        const failedUploads = uploadResults.filter(result => !result.success)
+        if (failedUploads.length > 0) {
+          const failedIndexes = failedUploads.map(result => result.segmentIndex + 1).join(', ')
+          throw new Error(`片段 ${failedIndexes} 上传失败`)
         }
-      })
 
-      // 等待所有上传完成
-      const uploadResults = await Promise.all(uploadPromises)
+        // 按照片段顺序排序并提取URL
+        const sortedResults = uploadResults
+          .filter(result => result.success)
+          .sort((a, b) => a.segmentIndex - b.segmentIndex)
+          .map(result => result.url)
 
-      // 检查是否有失败的上传
-      const failedUploads = uploadResults.filter(result => !result.success)
-      if (failedUploads.length > 0) {
-        const failedIndexes = failedUploads.map(result => result.segmentIndex + 1).join(', ')
-        throw new Error(`片段 ${failedIndexes} 上传失败`)
-      }
+        console.log(`长图切割并行上传完成，共 ${sortedResults.length} 个片段`)
+        return sortedResults
+
+      } catch (longImageError) {
+        // 长图处理失败，回退到原图上传
+        console.warn(`长图处理失败: ${longImageError.message}，回退到原图上传`)
+
+        if (requestId) {
+          logger.logError(requestId, 'LONG_IMAGE_FALLBACK', `长图处理失败，回退到原图: ${longImageError.message}`, {
+            imageIndex,
+            originalSize: `${detection.width}x${detection.height}`
+          })
+        }
 
-      // 按照片段顺序排序并提取URL
-      const sortedResults = uploadResults
-        .filter(result => result.success)
-        .sort((a, b) => a.segmentIndex - b.segmentIndex)
-        .map(result => result.url)
+        try {
+          const fallbackUrl = await this.uploadImage(imageBuffer, imageName)
 
-      console.log(`长图切割并行上传完成，共 ${sortedResults.length} 个片段`)
-      return sortedResults
+          if (requestId) {
+            logger.logImageUpload(requestId, imageIndex, 0, true, fallbackUrl, '长图回退上传')
+          }
+
+          console.log(`长图回退上传成功: ${fallbackUrl}`)
+          return [fallbackUrl]
+        } catch (fallbackError) {
+          throw new Error(`长图处理和回退上传均失败: ${longImageError.message} | ${fallbackError.message}`)
+        }
+      }
 
     } catch (error) {
       if (requestId) {