koishi-plugin-chat-patch 2.3.0 → 2.4.4

package/client/vue/composables/useChatData.ts

@@ -11,7 +11,6 @@ export function useChatData() {
 
   const pluginConfig = ref<PluginConfig>({
     maxMessagesPerChannel: 1000,
-    keepMessagesOnClear: 50,
     loggerinfo: false,
     blockedPlatforms: [],
     chatContainerHeight: 80,

package/client/vue/composables/useImageCache.ts

@@ -14,10 +14,11 @@ export function useImageCache() {
   const imageBlobUrls = ref<Record<string, string>>({})
   const loadingImages = new Map<string, Promise<string | null>>()
 
-  // 内存管理配置
-  const MAX_MEMORY_USAGE = 100 * 1024 * 1024 // 100MB
-  const MAX_BLOB_COUNT = 50
+  // 内存管理配置 - 减少内存占用
+  const MAX_MEMORY_USAGE = 50 * 1024 * 1024 // 50MB（从100MB降低）
+  const MAX_BLOB_COUNT = 30 // 从50降低到30
   let currentMemoryUsage = 0
+  let blobCount = 0
 
   // IndexedDB 配置
   let imageDB: IDBDatabase | null = null
@@ -28,8 +29,28 @@ export function useImageCache() {
   const MAX_TOTAL_IMAGES = 500
   const MAX_IMAGE_SIZE = 12 * 1024 * 1024 // 12MB
 
+  // 清理 IndexedDB
+  async function clearIndexedDB(): Promise<boolean> {
+    return new Promise((resolve) => {
+      const request = indexedDB.deleteDatabase(DB_NAME)
+      request.onsuccess = () => {
+        console.log('[ImageCache] IndexedDB 已清空')
+        resolve(true)
+      }
+      request.onerror = () => {
+        console.error('[ImageCache] 清空 IndexedDB 失败')
+        resolve(false)
+      }
+    })
+  }
+
   // 初始化数据库
-  async function initDB(): Promise<boolean> {
+  async function initDB(shouldClear: boolean = false): Promise<boolean> {
+    // 如果需要清空，先删除数据库
+    if (shouldClear) {
+      await clearIndexedDB()
+    }
+
     return new Promise((resolve) => {
       const request = indexedDB.open(DB_NAME, DB_VERSION)
       request.onupgradeneeded = (event) => {
@@ -48,8 +69,28 @@ export function useImageCache() {
     })
   }
 
+  // 清理内存中的 Blob URLs
+  function cleanupMemoryBlobs() {
+    if (blobCount > MAX_BLOB_COUNT || currentMemoryUsage > MAX_MEMORY_USAGE) {
+      // 按时间戳排序，删除最旧的
+      const entries = Object.entries(imageBlobUrls.value)
+      const toRemove = Math.ceil(entries.length * 0.3) // 删除30%最旧的
+
+      for (let i = 0; i < toRemove && entries.length > 0; i++) {
+        const [url, blobUrl] = entries[i]
+        URL.revokeObjectURL(blobUrl)
+        delete imageBlobUrls.value[url]
+        blobCount--
+      }
+
+      currentMemoryUsage = Math.floor(currentMemoryUsage * 0.7)
+      console.log(`[ImageCache] 清理内存，剩余 ${blobCount} 个图片`)
+    }
+  }
+
   // 获取缓存图片
   async function getCachedImageUrl(channelKey: string, url: string): Promise<string | null> {
+    // 先检查内存缓存
     if (imageBlobUrls.value[url]) return imageBlobUrls.value[url]
     if (loadingImages.has(url)) return loadingImages.get(url)!
 
@@ -58,8 +99,12 @@ export function useImageCache() {
         if (!imageDB) await initDB()
         const item = await getImageFromDB(url)
         if (item) {
+          // 从 IndexedDB 加载到内存
           const blobUrl = URL.createObjectURL(item.blob)
           imageBlobUrls.value[url] = blobUrl
+          currentMemoryUsage += item.size
+          blobCount++
+          cleanupMemoryBlobs() // 检查是否需要清理
           return blobUrl
         }
         return null
@@ -84,50 +129,145 @@ export function useImageCache() {
   }
 
   async function cacheImage(channelKey: string, url: string): Promise<string | null> {
+    // 先检查是否已缓存
     const existing = await getCachedImageUrl(channelKey, url)
     if (existing) return existing
 
     try {
+      // 通过后端获取图片（现在返回 Vite @fs 路径）
       const result = await (send as any)('fetch-image', { url })
       if (!result.success) return null
 
-      const response = await fetch(result.dataUrl)
-      const blob = await response.blob()
+      // 如果后端返回 Vite @fs 路径，直接使用，不需要缓存到 IndexedDB
+      if (result.viteUrl) {
+        // 将 Vite 路径缓存到内存中，避免重复请求后端
+        imageBlobUrls.value[url] = result.viteUrl
+        return result.viteUrl
+      }
 
-      if (blob.size > MAX_IMAGE_SIZE) return null
+      // 兼容旧的 base64 返回格式（如果有的话）
+      if (result.dataUrl) {
+        const response = await fetch(result.dataUrl)
+        const blob = await response.blob()
 
-      const item: ImageCacheItem = {
-        url,
-        blob,
-        timestamp: Date.now(),
-        size: blob.size,
-        channelKey
+        // 检查图片大小
+        if (blob.size > MAX_IMAGE_SIZE) {
+          console.warn(`[ImageCache] 图片过大 (${blob.size} bytes)，不缓存`)
+          return result.dataUrl
+        }
+
+        const item: ImageCacheItem = {
+          url,
+          blob,
+          timestamp: Date.now(),
+          size: blob.size,
+          channelKey
+        }
+
+        await saveToDB(item)
+
+        const blobUrl = URL.createObjectURL(blob)
+        imageBlobUrls.value[url] = blobUrl
+        currentMemoryUsage += blob.size
+        blobCount++
+        cleanupMemoryBlobs()
+
+        return blobUrl
       }
 
-      await saveToDB(item)
-      const blobUrl = URL.createObjectURL(blob)
-      imageBlobUrls.value[url] = blobUrl
-      return blobUrl
+      return null
     } catch (e) {
+      console.error('[ImageCache] 缓存图片失败:', e)
       return null
     }
   }
 
   async function saveToDB(item: ImageCacheItem) {
     if (!imageDB) return
-    const transaction = imageDB.transaction([STORE_NAME], 'readwrite')
-    transaction.objectStore(STORE_NAME).put(item)
+
+    try {
+      // 检查数据库大小，如果超过限制则清理旧数据
+      const count = await getDBCount()
+      if (count >= MAX_TOTAL_IMAGES) {
+        await cleanupOldestImages(Math.floor(MAX_TOTAL_IMAGES * 0.2)) // 清理20%最旧的
+      }
+
+      const transaction = imageDB.transaction([STORE_NAME], 'readwrite')
+      transaction.objectStore(STORE_NAME).put(item)
+    } catch (e) {
+      console.error('[ImageCache] 保存到 IndexedDB 失败:', e)
+    }
+  }
+
+  // 获取数据库中的图片数量
+  async function getDBCount(): Promise<number> {
+    if (!imageDB) return 0
+    return new Promise((resolve) => {
+      const transaction = imageDB!.transaction([STORE_NAME], 'readonly')
+      const store = transaction.objectStore(STORE_NAME)
+      const request = store.count()
+      request.onsuccess = () => resolve(request.result)
+      request.onerror = () => resolve(0)
+    })
+  }
+
+  // 清理最旧的图片
+  async function cleanupOldestImages(count: number) {
+    if (!imageDB) return
+
+    return new Promise<void>((resolve) => {
+      const transaction = imageDB!.transaction([STORE_NAME], 'readwrite')
+      const store = transaction.objectStore(STORE_NAME)
+      const index = store.index('timestamp')
+      const request = index.openCursor()
+
+      let deleted = 0
+      request.onsuccess = (event) => {
+        const cursor = (event.target as IDBRequest).result
+        if (cursor && deleted < count) {
+          cursor.delete()
+          deleted++
+          cursor.continue()
+        } else {
+          console.log(`[ImageCache] 清理了 ${deleted} 张旧图片`)
+          resolve()
+        }
+      }
+      request.onerror = () => resolve()
+    })
   }
 
   async function clearChannelCache(channelKey: string) {
-    // 简化实现
+    // 清理内存中的 Blob URLs
     Object.keys(imageBlobUrls.value).forEach(url => {
       URL.revokeObjectURL(imageBlobUrls.value[url])
       delete imageBlobUrls.value[url]
     })
+    blobCount = 0
+    currentMemoryUsage = 0
   }
 
+  // 初始化时检查是否需要清空 IndexedDB
+  onMounted(async () => {
+    try {
+      // 获取插件配置
+      const configResult = await (send as any)('get-plugin-config')
+      const shouldClear = configResult?.success && configResult?.config?.clearIndexedDBOnStart
+
+      if (shouldClear) {
+        console.log('[ImageCache] 配置要求清空 IndexedDB，正在清理...')
+        await initDB(true) // 清空并重新初始化
+      } else {
+        await initDB(false) // 正常初始化
+      }
+    } catch (e) {
+      console.error('[ImageCache] 初始化失败:', e)
+      await initDB(false)
+    }
+  })
+
   onUnmounted(() => {
+    // 清理所有内存中的 Blob URLs
     Object.values(imageBlobUrls.value).forEach(URL.revokeObjectURL)
     if (imageDB) imageDB.close()
   })
@@ -135,6 +275,7 @@ export function useImageCache() {
   return {
     getCachedImageUrl,
     cacheImage,
-    clearChannelCache
+    clearChannelCache,
+    clearIndexedDB // 导出清理函数供外部使用
   }
 }

package/client/vue/composables/useVideoCache.ts

@@ -48,35 +48,30 @@ export function useVideoCache() {
       const result = await (send as any)('fetch-video-temp', { url })
 
       if (result.success) {
-        // 清理上一个 blob URL
-        if (currentBlobUrl.value) {
-          URL.revokeObjectURL(currentBlobUrl.value)
+        // 如果返回 Vite @fs 路径，直接使用，不需要转换为 blob
+        if (result.viteUrl) {
+          loadedVideos.value[url] = result.viteUrl
+          return result.viteUrl
         }
 
-        // 如果返回的是 dataUrl，转换为 blob
-        let blobUrl: string
+        // 兼容旧的 dataUrl 格式（如果有的话）
         if (result.dataUrl) {
+          // 清理上一个 blob URL
+          if (currentBlobUrl.value) {
+            URL.revokeObjectURL(currentBlobUrl.value)
+          }
+
           // 从 data URL 创建 blob
           const response = await fetch(result.dataUrl)
           const blob = await response.blob()
-          blobUrl = URL.createObjectURL(blob)
-        } else if (result.fileUrl) {
-          // 如果是文件 URL，也尝试转换为 blob
-          try {
-            const response = await fetch(result.fileUrl)
-            const blob = await response.blob()
-            blobUrl = URL.createObjectURL(blob)
-          } catch (e) {
-            // 如果转换失败，直接使用文件 URL
-            blobUrl = result.fileUrl
-          }
-        } else {
-          return null
+          const blobUrl = URL.createObjectURL(blob)
+
+          currentBlobUrl.value = blobUrl
+          loadedVideos.value[url] = blobUrl
+          return blobUrl
         }
 
-        currentBlobUrl.value = blobUrl
-        loadedVideos.value[url] = blobUrl
-        return blobUrl
+        return null
       }
 
       return null

package/client/vue/types.ts

@@ -62,7 +62,6 @@ export interface ChatData {
 
 export interface PluginConfig {
   maxMessagesPerChannel: number
-  keepMessagesOnClear: number
   loggerinfo: boolean
   blockedPlatforms: Array<{
     platformName: string