koishi-plugin-kkk 1.0.0

package/src/karin/module/utils/Network/ImageDownloader.ts

@@ -0,0 +1,291 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { logger } from 'node-karin'
+import type { AxiosInstance } from 'node-karin/axios'
+
+import { Config } from '../Config'
+import { sanitizeFilename } from './helpers'
+
+/**
+ * 图片下载结果
+ */
+export interface ImageDownloadResult {
+  /**
+   * 本地文件路径（使用 file:// 协议）
+   */
+  filePath: string
+  /**
+   * 是否需要自动删除
+   */
+  shouldDelete: boolean
+}
+
+/**
+ * 图片下载管理器
+ * 根据配置决定是否本地下载图片，并管理临时文件的生命周期
+ */
+export class ImageDownloader {
+  private axiosInstance: AxiosInstance
+  private tempDir: string
+  private readonly maxRetries: number = 3
+  private readonly retryDelay: number = 1000 // 初始重试延迟（毫秒）
+
+  /**
+   * 创建图片下载管理器实例
+   * @param axiosInstance - Axios 实例
+   * @param tempDir - 临时文件目录
+   */
+  constructor(axiosInstance: AxiosInstance, tempDir: string) {
+    this.axiosInstance = axiosInstance
+    this.tempDir = tempDir
+
+    // 确保临时目录存在
+    if (!fs.existsSync(this.tempDir)) {
+      fs.mkdirSync(this.tempDir, { recursive: true })
+    }
+  }
+
+  /**
+   * 处理图片 URL，根据配置决定返回格式
+   * @param imageUrl - 图片 URL
+   * @param title - 作品标题（用于文件命名）
+   * @param index - 图片索引（用于多图场景）
+   * @returns 处理后的图片路径（HTTP URL / file:// 协议 / base64://）
+   */
+  async processImage(imageUrl: string, title?: string, index?: number): Promise<string> {
+    if (!/^https?:\/\//i.test(imageUrl)) {
+      return imageUrl
+    }
+
+    const mode = Config.app.imageSendMode
+
+    switch (mode) {
+      case 'base64':
+        // base64 模式：下载并转换为 base64
+        try {
+          return await this.downloadAndConvertToBase64(imageUrl)
+        } catch (error) {
+          logger.error(`图片转换 base64 失败，回退到原始 URL: ${imageUrl}`, error)
+          return imageUrl
+        }
+
+      case 'file':
+        // file 协议模式：下载到本地并返回 file:// 协议
+        try {
+          const result = await this.downloadImage(imageUrl, title, index)
+
+          // 如果需要自动删除，设置延迟删除任务
+          if (result.shouldDelete) {
+            this.scheduleDelete(result.filePath)
+          }
+
+          return result.filePath
+        } catch (error) {
+          logger.error(`图片下载失败，回退到原始 URL: ${imageUrl}`, error)
+          return imageUrl
+        }
+
+      case 'url':
+      default:
+        // URL 模式：直接返回原始 HTTP URL
+        return imageUrl
+    }
+  }
+
+  /**
+   * 下载图片并转换为 base64
+   * @param imageUrl - 图片 URL
+   * @returns base64 格式的图片数据
+   */
+  private async downloadAndConvertToBase64(imageUrl: string): Promise<string> {
+    // 生成临时文件名
+    const filename = this.generateFilename(imageUrl)
+    const filePath = path.join(this.tempDir, filename)
+
+    try {
+      // 下载图片到本地（带重试）
+      const response = await this.downloadWithRetry(imageUrl)
+
+      // 保存到本地
+      fs.writeFileSync(filePath, response.data)
+
+      // 从本地文件读取并转换为 base64
+      const fileBuffer = fs.readFileSync(filePath)
+      const base64 = fileBuffer.toString('base64')
+
+      logger.debug(`图片已下载并转换为 base64: ${imageUrl.substring(0, 50)}...`)
+
+      return `base64://${base64}`
+    } finally {
+      // 如果配置了自动删除缓存，立即删除临时文件
+      if (Config.app.removeCache && fs.existsSync(filePath)) {
+        try {
+          fs.unlinkSync(filePath)
+          logger.debug(`临时文件已删除: ${filePath}`)
+        } catch (error) {
+          logger.error(`删除临时文件失败: ${filePath}`, error)
+        }
+      }
+    }
+  }
+
+  /**
+   * 下载图片到本地
+   * @param imageUrl - 图片 URL
+   * @param title - 作品标题
+   * @param index - 图片索引
+   * @returns 下载结果
+   */
+  private async downloadImage(imageUrl: string, title?: string, index?: number): Promise<ImageDownloadResult> {
+    // 生成文件名
+    const filename = this.generateFilename(imageUrl, title, index)
+    const filePath = path.join(this.tempDir, filename)
+
+    // 下载图片（带重试）
+    const response = await this.downloadWithRetry(imageUrl)
+
+    // 保存到本地
+    fs.writeFileSync(filePath, response.data)
+
+    logger.debug(`图片已下载: ${filePath}`)
+
+    return {
+      filePath: `file://${filePath}`,
+      shouldDelete: true
+    }
+  }
+
+  /**
+   * 带重试机制的图片下载
+   * @param imageUrl - 图片 URL
+   * @param retryCount - 当前重试次数
+   * @returns Axios 响应
+   */
+  private async downloadWithRetry(imageUrl: string, retryCount: number = 0): Promise<any> {
+    try {
+      const response = await this.axiosInstance.get(imageUrl, {
+        responseType: 'arraybuffer',
+        timeout: 30000
+      })
+
+      if (retryCount > 0) {
+        logger.info(`图片下载成功（重试 ${retryCount} 次后）: ${imageUrl.substring(0, 50)}...`)
+      }
+
+      return response
+    } catch (error) {
+      if (retryCount < this.maxRetries) {
+        const delay = this.retryDelay * Math.pow(2, retryCount) // 指数退避
+        logger.warn(`图片下载失败，${delay}ms 后进行第 ${retryCount + 1}/${this.maxRetries} 次重试: ${imageUrl.substring(0, 50)}...`, error)
+
+        // 等待后重试
+        await this.sleep(delay)
+        return this.downloadWithRetry(imageUrl, retryCount + 1)
+      }
+
+      // 重试次数用尽，抛出错误
+      logger.error(`图片下载失败，已重试 ${this.maxRetries} 次: ${imageUrl}`, error)
+      throw error
+    }
+  }
+
+  /**
+   * 延迟函数
+   * @param ms - 延迟毫秒数
+   */
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  }
+
+  /**
+   * 生成文件名
+   * @param imageUrl - 图片 URL
+   * @param title - 作品标题
+   * @param index - 图片索引
+   * @returns 文件名
+   */
+  private generateFilename(imageUrl: string, title?: string, index?: number): string {
+    // 获取文件扩展名
+    const ext = this.getExtension(imageUrl)
+
+    // 根据 removeCache 配置决定文件名
+    if (Config.app.removeCache) {
+      // 使用时间戳
+      const timestamp = Date.now()
+      const indexSuffix = index !== undefined ? `_${index}` : ''
+      return `tmp_${timestamp}${indexSuffix}${ext}`
+    } else {
+      // 使用作品标题
+      const safeTitle = title ? sanitizeFilename(title) : `image_${Date.now()}`
+      const indexSuffix = index !== undefined ? `_${index}` : ''
+      return `${safeTitle}${indexSuffix}${ext}`
+    }
+  }
+
+  /**
+   * 从 URL 中提取文件扩展名
+   * @param url - 图片 URL
+   * @returns 文件扩展名（包含点号）
+   */
+  private getExtension(url: string): string {
+    try {
+      const urlObj = new URL(url)
+      const pathname = urlObj.pathname
+      const ext = path.extname(pathname)
+
+      // 如果有扩展名且是常见图片格式，使用它
+      if (ext && /^\.(jpg|jpeg|png|gif|webp|bmp)$/i.test(ext)) {
+        return ext
+      }
+    } catch {
+      // URL 解析失败，继续使用默认扩展名
+    }
+
+    // 默认使用 .jpg
+    return '.jpg'
+  }
+
+  /**
+   * 安排文件删除任务
+   * @param filePath - 文件路径（file:// 协议）
+   */
+  private scheduleDelete(filePath: string): void {
+    // 移除 file:// 协议前缀
+    const actualPath = filePath.replace(/^file:\/\//, '')
+
+    // 10 分钟后删除文件
+    setTimeout(
+      () => {
+        this.deleteFile(actualPath)
+      },
+      10 * 60 * 1000
+    )
+  }
+
+  /**
+   * 删除文件
+   * @param filePath - 文件路径
+   */
+  private deleteFile(filePath: string): void {
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath)
+        logger.debug(`临时图片已删除: ${filePath}`)
+      }
+    } catch (error) {
+      logger.error(`删除临时图片失败: ${filePath}`, error)
+    }
+  }
+
+  /**
+   * 批量处理图片
+   * @param imageUrls - 图片 URL 数组
+   * @param title - 作品标题
+   * @returns 处理后的图片路径数组
+   */
+  async processImages(imageUrls: string[], title?: string): Promise<string[]> {
+    const results = await Promise.all(imageUrls.map((url, index) => this.processImage(url, title, index)))
+    return results
+  }
+}

package/src/karin/module/utils/Network/Network.ts

@@ -0,0 +1,344 @@
+import { logger } from 'node-karin'
+import type { AxiosInstance, AxiosRequestConfig, AxiosResponse, ResponseType } from 'node-karin/axios'
+import axios, { AxiosError } from 'node-karin/axios'
+
+import { NetworksConfigType } from '@/types'
+
+import { BASE_HEADERS } from './constants'
+import { Downloader } from './Downloader'
+import { extractTotalBytesFromHeaders, getErrorDescription, isRecoverableNetworkError, sanitizeHeaders } from './helpers'
+import type { CustomAxiosRequestConfig, DownloadResult, ProgressCallback, ThrottleConfig } from './types'
+
+/**
+ * 网络请求类
+ * 支持常规请求、文件下载（带限速和断点续传）、重定向跟踪等功能
+ */
+export class Network {
+  private url: string
+  private method: string
+  private headers: Record<string, string>
+  private type: ResponseType
+  private body?: any
+  private axiosInstance: AxiosInstance
+  private timeout: number
+  private filepath: string
+  private maxRetries: number
+  private throttleConfig?: Partial<ThrottleConfig>
+
+  /**
+   * 创建网络请求实例
+   *
+   * @remarks
+   * 实例会自动处理可恢复的网络错误（如连接超时、重置等），并进行指数退避重试。
+   * 默认重试 3 次，可通过 `maxRetries` 配置。
+   * 支持限速下载，避免触发服务器风控。
+   *
+   * @param data - 配置对象
+   */
+  constructor(data: NetworksConfigType & { throttle?: Partial<ThrottleConfig> }) {
+    this.headers = data.headers ? Object.fromEntries(Object.entries(data.headers).map(([key, value]) => [key, String(value)])) : {}
+
+    // 合并默认头
+    this.headers = {
+      ...Object.fromEntries(Object.entries(BASE_HEADERS ?? {}).map(([key, value]) => [key, String(value)])),
+      ...this.headers
+    }
+
+    this.url = data.url ?? ''
+    this.type = data.type ?? 'json'
+    this.method = data.method ?? 'GET'
+    this.body = data.body ?? null
+    this.timeout = data.timeout ?? 15000
+    this.filepath = data.filepath ?? ''
+    this.maxRetries = data.maxRetries ?? 3
+    this.throttleConfig = data.throttle
+
+    // 创建 axios 实例
+    this.axiosInstance = axios.create({
+      timeout: this.timeout,
+      headers: this.headers,
+      maxRedirects: 5,
+      validateStatus: () => true
+    })
+
+    // 添加响应拦截器处理重试
+    this.axiosInstance.interceptors.response.use(undefined, async (error) => {
+      const config = error.config as CustomAxiosRequestConfig
+      if (!config || config.skipRetry) {
+        return Promise.reject(error)
+      }
+
+      config.__retryCount = config.__retryCount || 0
+
+      if (config.__retryCount >= this.maxRetries) {
+        return Promise.reject(error)
+      }
+
+      if (!isRecoverableNetworkError(error)) {
+        return Promise.reject(error)
+      }
+
+      config.__retryCount += 1
+
+      const nextDelay = Math.max(1000, Math.min(2 ** (config.__retryCount - 1) * 1000, 8000))
+      logger.warn(
+        `[koishi-plugin-kkk] axios 实例请求失败，正在重试... (${config.__retryCount}/${this.maxRetries})，将在 ${nextDelay / 1000} 秒后重试`
+      )
+
+      await new Promise((resolve) => setTimeout(resolve, nextDelay))
+      return this.axiosInstance(config)
+    })
+  }
+
+  get config(): AxiosRequestConfig {
+    const config: AxiosRequestConfig = {
+      url: this.url,
+      method: this.method,
+      headers: this.headers,
+      responseType: this.type
+    }
+
+    if (this.method === 'POST' && this.body) {
+      config.data = this.body
+    }
+
+    return config
+  }
+
+  /**
+   * 下载文件流
+   * 支持断点续传、限速下载、自动重试
+   *
+   * @param progressCallback 进度回调函数
+   * @param retryCount 重试次数（内部使用）
+   */
+  async downloadStream(progressCallback: ProgressCallback, retryCount = 0): Promise<DownloadResult> {
+    const downloader = new Downloader(
+      this.axiosInstance,
+      this.url,
+      this.filepath,
+      this.headers,
+      this.timeout,
+      this.maxRetries,
+      this.throttleConfig
+    )
+
+    return downloader.download(progressCallback, retryCount)
+  }
+
+  async getfetch(): Promise<AxiosResponse | boolean> {
+    try {
+      return await this.returnResult()
+    } catch (error) {
+      logger.info(error)
+      return false
+    }
+  }
+
+  async returnResult(): Promise<AxiosResponse> {
+    let response = {} as AxiosResponse
+    try {
+      response = await this.axiosInstance(this.config)
+    } catch (error) {
+      logger.error(error)
+    }
+    return response
+  }
+
+  /** 获取最终地址（跟随重定向） */
+  async getLongLink(url = '', depth = 0): Promise<string> {
+    const MAX_REDIRECTS = 10
+
+    if (depth > MAX_REDIRECTS) {
+      throw new Error(`重定向次数超过限制 (${MAX_REDIRECTS})`)
+    }
+
+    const targetUrl = this.url || url
+    try {
+      new URL(targetUrl)
+    } catch {
+      const sanitized = sanitizeHeaders(this.headers)
+      throw new Error(`Invalid URL: ${targetUrl || '(empty)'}, Headers: ${JSON.stringify(sanitized)}`)
+    }
+
+    const methods = ['head', 'get'] as const
+    let lastError: Error | null = null
+
+    for (const method of methods) {
+      try {
+        const response = await this.axiosInstance.request({
+          url: targetUrl,
+          method,
+          maxRedirects: 5,
+          validateStatus: (status) => status >= 200 && status < 400,
+          headers: method === 'get' ? { ...this.headers, Range: 'bytes=0-0' } : this.headers,
+          skipRetry: true
+        } as CustomAxiosRequestConfig)
+
+        const finalUrl = (response.request as any)?.res?.responseUrl ?? (response.config as any)?.url ?? targetUrl
+        return finalUrl
+      } catch (error) {
+        const axiosError = error as AxiosError
+
+        // 处理所有重定向状态码
+        const redirectStatuses = [301, 302, 303, 307, 308]
+        if (axiosError.response?.status && redirectStatuses.includes(axiosError.response.status) && axiosError.response.headers?.location) {
+          const location = axiosError.response.headers.location
+
+          // 处理相对路径重定向
+          const redirectUrl = location.startsWith('http') ? location : new URL(location, targetUrl).href
+
+          logger.info(`检测到${axiosError.response.status}重定向 (深度: ${depth + 1}), 目标: ${redirectUrl}`)
+          return await this.getLongLink(redirectUrl, depth + 1)
+        }
+
+        if (method === 'head') {
+          logger.debug(`HEAD 请求失败 (${axiosError.code || axiosError.message})，尝试 GET 请求`)
+          lastError = axiosError
+          continue
+        }
+
+        lastError = axiosError
+      }
+    }
+
+    const sanitized = sanitizeHeaders(this.headers)
+    const errorDesc = getErrorDescription(lastError)
+    const msg = `获取链接重定向失败: ${targetUrl} - ${errorDesc}, Headers: ${JSON.stringify(sanitized)}`
+    logger.error(msg)
+    throw new Error(msg)
+  }
+
+  /** 获取首个302链接 */
+  async getLocation(): Promise<AxiosResponse['headers']['location']> {
+    try {
+      const response = await this.axiosInstance({
+        method: 'GET',
+        url: this.url,
+        maxRedirects: 0,
+        validateStatus: (status: number) => status >= 300 && status < 400
+      })
+      return response.headers.location as string
+    } catch (error: unknown) {
+      if (error instanceof AxiosError) {
+        const sanitized = sanitizeHeaders(this.headers)
+        logger.error(`获取 ${this.url} 重定向地址失败，接口响应状态码: ${error.response?.status}, Headers: ${JSON.stringify(sanitized)}`)
+        throw new Error(error.stack)
+      }
+    }
+  }
+
+  /** 获取数据并处理格式化，默认 json */
+  async getData(): Promise<AxiosResponse['data'] | boolean> {
+    try {
+      const result = await this.returnResult()
+      if (result.status === 504) {
+        return result
+      }
+      if (result.status === 429) {
+        logger.error('HTTP 响应状态码: 429')
+        throw new Error('ratelimit triggered, 触发 https://www.douyin.com/ 的速率限制！！！')
+      }
+      return result.data
+    } catch (error: unknown) {
+      if (error instanceof AxiosError) {
+        const sanitized = sanitizeHeaders(this.headers)
+        const errorDesc = getErrorDescription(error)
+        throw new Error(`${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`)
+      }
+      return false
+    }
+  }
+
+  /**
+   * 获取响应头信息（仅首个字节）
+   * 适用于获取视频流的完整大小
+   */
+  async getHeaders(): Promise<AxiosResponse['headers']> {
+    const tryRequest = async (method: 'HEAD' | 'GET', extraHeaders?: Record<string, string>): Promise<AxiosResponse | null> => {
+      const response = await this.axiosInstance.request({
+        ...this.config,
+        method,
+        responseType: 'stream',
+        maxRedirects: 5,
+        headers: {
+          ...this.config.headers,
+          ...extraHeaders
+        },
+        skipRetry: true,
+        validateStatus: () => true
+      } as CustomAxiosRequestConfig)
+
+      const stream = response.data as { on?: (event: string, listener: (...args: any[]) => void) => void; destroy?: () => void } | undefined
+      if (stream && typeof stream.destroy === 'function') {
+        stream.on?.('error', () => {})
+        stream.destroy()
+      }
+
+      if (response.status >= 200 && response.status < 400) {
+        return response
+      }
+
+      logger.debug(`获取响应头时 ${method} 探测返回 HTTP ${response.status}，继续尝试其他策略`)
+      return null
+    }
+
+    try {
+      const headResponse = await tryRequest('HEAD')
+      if (headResponse) {
+        const totalBytes = extractTotalBytesFromHeaders(headResponse.headers)
+        if (totalBytes > 0 || headResponse.headers['content-type']) {
+          return headResponse.headers
+        }
+      }
+
+      const rangedResponse = await tryRequest('GET', {
+        Range: 'bytes=0-0'
+      })
+      if (rangedResponse) {
+        return rangedResponse.headers
+      }
+
+      const fallbackResponse = await tryRequest('GET')
+      if (fallbackResponse) {
+        return fallbackResponse.headers
+      }
+
+      const sanitized = sanitizeHeaders(this.headers)
+      throw new Error(`获取响应头失败: 所有探测方式均未返回有效响应, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`)
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        const sanitized = sanitizeHeaders(this.headers)
+        const errorDesc = getErrorDescription(error)
+        const errorMsg = `获取响应头失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`
+        logger.error(errorMsg)
+        throw new Error(errorMsg)
+      }
+      logger.error(error)
+      throw error
+    }
+  }
+
+  /**
+   * 获取响应头信息（完整）
+   */
+  async getHeadersFull(): Promise<AxiosResponse['headers']> {
+    try {
+      const response = await this.axiosInstance({
+        ...this.config,
+        method: 'GET'
+      })
+      return response.headers
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        const sanitized = sanitizeHeaders(this.headers)
+        const errorDesc = getErrorDescription(error)
+        const errorMsg = `获取完整响应头失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`
+        logger.error(errorMsg)
+        throw new Error(errorMsg)
+      }
+      logger.error(error)
+      throw error
+    }
+  }
+}

package/src/karin/module/utils/Network/ThrottleStream.ts

@@ -0,0 +1,76 @@
+import { Transform, TransformCallback } from 'node:stream'
+
+/**
+ * 限速流转换器
+ * 用于控制下载速度，避免触发服务器风控
+ */
+export class ThrottleStream extends Transform {
+  private bytesPerSecond: number
+  private startTime: number
+  private totalBytes: number
+
+  /**
+   * 创建限速流
+   * @param bytesPerSecond 每秒允许通过的字节数
+   */
+  constructor(bytesPerSecond: number) {
+    super()
+    this.bytesPerSecond = bytesPerSecond
+    this.startTime = Date.now()
+    this.totalBytes = 0
+  }
+
+  /**
+   * 动态调整速度限制
+   * @param newSpeed 新的速度限制 (bytes/s)
+   */
+  setSpeed(newSpeed: number): void {
+    this.bytesPerSecond = newSpeed
+    // 重置计时，避免突然的速度变化导致长时间等待
+    this.startTime = Date.now()
+    this.totalBytes = 0
+  }
+
+  /**
+   * 获取当前速度限制
+   */
+  getSpeed(): number {
+    return this.bytesPerSecond
+  }
+
+  /**
+   * 获取当前实际速度
+   */
+  getCurrentSpeed(): number {
+    const elapsed = (Date.now() - this.startTime) / 1000
+    if (elapsed <= 0) return 0
+    return this.totalBytes / elapsed
+  }
+
+  _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void {
+    this.totalBytes += chunk.length
+
+    // 计算已经过的时间
+    const elapsed = (Date.now() - this.startTime) / 1000
+
+    // 计算按当前速度限制应该花费的时间
+    const expectedTime = this.totalBytes / this.bytesPerSecond
+
+    // 如果实际时间小于预期时间，需要等待
+    const delay = Math.max(0, (expectedTime - elapsed) * 1000)
+
+    if (delay > 0) {
+      setTimeout(() => {
+        this.push(chunk)
+        callback()
+      }, delay)
+    } else {
+      this.push(chunk)
+      callback()
+    }
+  }
+
+  _flush(callback: TransformCallback): void {
+    callback()
+  }
+}