koishi-plugin-chat-patch 3.0.2 → 5.0.0

package/client/vue/composables/useChatActions.ts

@@ -1,61 +0,0 @@
-import { ref } from 'vue'
-import { send } from '@koishijs/client'
-import type { MessageInfo } from '../types'
-
-export function useChatActions() {
-  const isSending = ref(false)
-
-  async function sendMessage(botId: string, channelId: string, content: string, images: any[]) {
-    if (isSending.value) return
-    isSending.value = true
-    try {
-      const result = await (send as any)('send-message', {
-        selfId: botId,
-        channelId: channelId,
-        content: content,
-        images: images.map(img => ({
-          tempId: img.tempId,
-          filename: img.filename
-        }))
-      })
-      return result
-    } finally {
-      isSending.value = false
-    }
-  }
-
-  async function deleteBotData(botId: string) {
-    return await (send as any)('delete-bot-data', { selfId: botId })
-  }
-
-  async function deleteChannelData(botId: string, channelId: string) {
-    return await (send as any)('delete-channel-data', { selfId: botId, channelId: channelId })
-  }
-
-  async function clearHistory(botId: string, channelId: string) {
-    return await (send as any)('clear-channel-history', { selfId: botId, channelId: channelId })
-  }
-
-  async function togglePinBot(botId: string, pinned: boolean, pinnedBots: Set<string>) {
-    if (pinned) pinnedBots.delete(botId)
-    else pinnedBots.add(botId)
-    await (send as any)('set-pinned-bots', { pinnedBots: Array.from(pinnedBots) })
-  }
-
-  async function togglePinChannel(botId: string, channelId: string, pinned: boolean, pinnedChannels: Set<string>) {
-    const key = `${botId}:${channelId}`
-    if (pinned) pinnedChannels.delete(key)
-    else pinnedChannels.add(key)
-    await (send as any)('set-pinned-channels', { pinnedChannels: Array.from(pinnedChannels) })
-  }
-
-  return {
-    isSending,
-    sendMessage,
-    deleteBotData,
-    deleteChannelData,
-    clearHistory,
-    togglePinBot,
-    togglePinChannel
-  }
-}

package/client/vue/composables/useChatData.ts

@@ -1,185 +0,0 @@
-import { ref, computed } from 'vue'
-import { receive, send } from '@koishijs/client'
-import type { ChatData, BotInfo, ChannelInfo, MessageInfo, PluginConfig } from '../types'
-
-export function useChatData() {
-  const chatData = ref<ChatData>({
-    bots: {},
-    channels: {},
-    messages: {}
-  })
-
-  const pluginConfig = ref<PluginConfig>({
-    maxMessagesPerChannel: 1000,
-    loggerinfo: false,
-    blockedPlatforms: [],
-    chatContainerHeight: 80,
-    clearIndexedDBOnStart: true
-  })
-
-  const pinnedBots = ref<Set<string>>(new Set())
-  const pinnedChannels = ref<Set<string>>(new Set())
-
-  // 记录每个频道的分页状态
-  const channelPagination = ref<Record<string, { offset: number, hasMore: boolean }>>({})
-
-  // 计算属性
-  const bots = computed(() => {
-    return Object.values(chatData.value.bots).sort((a, b) => {
-      const aPinned = pinnedBots.value.has(a.selfId)
-      const bPinned = pinnedBots.value.has(b.selfId)
-      return aPinned === bPinned ? 0 : aPinned ? -1 : 1
-    })
-  })
-
-  const getChannels = (botId: string) => {
-    if (!botId || !chatData.value.channels[botId]) return []
-    return Object.values(chatData.value.channels[botId]).sort((a, b) => {
-      const aPinned = pinnedChannels.value.has(`${botId}:${a.id}`)
-      const bPinned = pinnedChannels.value.has(`${botId}:${b.id}`)
-      return aPinned === bPinned ? 0 : aPinned ? -1 : 1
-    })
-  }
-
-  const getMessages = (botId: string, channelId: string) => {
-    const key = `${botId}:${channelId}`
-    return chatData.value.messages[key] || []
-  }
-
-  const getPagination = (botId: string, channelId: string) => {
-    const key = `${botId}:${channelId}`
-    return channelPagination.value[key] || { offset: 0, hasMore: true }
-  }
-
-  // 加载数据
-  async function loadInitialData() {
-    const result = await (send as any)('get-chat-data')
-    if (result.success && result.data) {
-      chatData.value = {
-        bots: result.data.bots || {},
-        channels: result.data.channels || {},
-        messages: result.data.messages || {}
-      }
-      pinnedBots.value = new Set(result.data.pinnedBots || [])
-      pinnedChannels.value = new Set(result.data.pinnedChannels || [])
-    }
-  }
-
-  async function loadConfig() {
-    const result = await (send as any)('get-plugin-config')
-    if (result.success && result.config) {
-      pluginConfig.value = result.config
-    }
-  }
-
-  // 消息处理
-  function addMessage(msg: any) {
-    const selfId = msg.selfId
-    const channelId = msg.channelId
-    const key = `${selfId}:${channelId}`
-
-    // 1. 确保机器人存在
-    if (!chatData.value.bots[selfId]) {
-      chatData.value.bots[selfId] = {
-        selfId,
-        platform: msg.platform || 'unknown',
-        username: msg.bot?.name || `Bot-${selfId}`,
-        avatar: msg.bot?.avatar,
-        status: 'online'
-      }
-    }
-
-    // 2. 确保频道存在
-    if (!chatData.value.channels[selfId]) {
-      chatData.value.channels[selfId] = {}
-    }
-    if (!chatData.value.channels[selfId][channelId]) {
-      const isDirect = msg.isDirect || channelId.includes('private')
-      chatData.value.channels[selfId][channelId] = {
-        id: channelId,
-        name: isDirect ? `私聊（${msg.username || channelId}）` : (msg.guildName || channelId),
-        type: msg.channelType || 0,
-        isDirect
-      }
-    }
-
-    // 3. 消息去重与添加
-    if (!chatData.value.messages[key]) chatData.value.messages[key] = []
-
-    const messages = chatData.value.messages[key]
-    // 严格去重：检查 ID，如果是机器人发送的临时消息，则通过内容和时间戳近似匹配
-    const isDuplicate = messages.some(m => {
-      if (m.id === msg.messageId || m.id === msg.id) return true
-      // 针对机器人发送消息的特殊去重逻辑
-      if ((msg.type === 'bot-message' || msg.type === 'bot-message-sent' || msg.type === 'bot') && m.isBot && Math.abs(m.timestamp - msg.timestamp) < 2000 && m.content === msg.content) return true
-      return false
-    })
-
-    if (!isDuplicate) {
-      const newMsg: MessageInfo = {
-        id: msg.messageId || msg.id,
-        content: msg.content,
-        userId: msg.userId,
-        username: msg.username,
-        avatar: msg.avatar,
-        timestamp: msg.timestamp,
-        channelId: channelId,
-        selfId: selfId,
-        elements: msg.elements,
-        isBot: msg.isBot || msg.type === 'bot-message' || msg.type === 'bot',
-        quote: msg.quote
-      }
-      messages.push(newMsg)
-      messages.sort((a, b) => a.timestamp - b.timestamp)
-    }
-
-    // 强制触发响应式更新，确保列表实时刷新
-    chatData.value = { ...chatData.value }
-  }
-
-  async function loadHistory(botId: string, channelId: string, limit = 50) {
-    const key = `${botId}:${channelId}`
-    const pagination = getPagination(botId, channelId)
-    if (!pagination.hasMore) return
-
-    const result = await (send as any)('get-history-messages', {
-      selfId: botId,
-      channelId: channelId,
-      limit,
-      offset: pagination.offset
-    })
-
-    if (result.success && result.messages) {
-      if (!chatData.value.messages[key]) chatData.value.messages[key] = []
-      const existing = chatData.value.messages[key]
-
-      // 合并并去重
-      const newMsgs = result.messages.filter((m: any) => !existing.find(e => e.id === m.id))
-      chatData.value.messages[key] = [...newMsgs, ...existing].sort((a, b) => a.timestamp - b.timestamp)
-
-      channelPagination.value[key] = {
-        offset: pagination.offset + result.messages.length,
-        hasMore: result.messages.length >= limit && result.total > (pagination.offset + result.messages.length)
-      }
-
-      chatData.value = { ...chatData.value }
-      return result.messages.length
-    }
-    return 0
-  }
-
-  return {
-    chatData,
-    pluginConfig,
-    pinnedBots,
-    pinnedChannels,
-    bots,
-    getChannels,
-    getMessages,
-    getPagination,
-    loadInitialData,
-    loadConfig,
-    addMessage,
-    loadHistory
-  }
-}

package/client/vue/composables/useImageCache.ts

@@ -1,281 +0,0 @@
-import { ref, onMounted, onUnmounted } from 'vue'
-import { send } from '@koishijs/client'
-
-// 图片缓存 - IndexedDB
-interface ImageCacheItem {
-  url: string
-  blob: Blob
-  timestamp: number
-  size: number
-  channelKey: string
-}
-
-export function useImageCache() {
-  const imageBlobUrls = ref<Record<string, string>>({})
-  const loadingImages = new Map<string, Promise<string | null>>()
-
-  // 内存管理配置 - 减少内存占用
-  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
-  const DB_NAME = 'ChatImageCache'
-  const DB_VERSION = 2
-  const STORE_NAME = 'images'
-  const MAX_DB_SIZE = 50 * 1024 * 1024 // 50MB
-  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(shouldClear: boolean = false): Promise<boolean> {
-    // 如果需要清空，先删除数据库
-    if (shouldClear) {
-      await clearIndexedDB()
-    }
-
-    return new Promise((resolve) => {
-      const request = indexedDB.open(DB_NAME, DB_VERSION)
-      request.onupgradeneeded = (event) => {
-        const db = (event.target as IDBOpenDBRequest).result
-        if (!db.objectStoreNames.contains(STORE_NAME)) {
-          const store = db.createObjectStore(STORE_NAME, { keyPath: 'url' })
-          store.createIndex('channelKey', 'channelKey', { unique: false })
-          store.createIndex('timestamp', 'timestamp', { unique: false })
-        }
-      }
-      request.onsuccess = () => {
-        imageDB = request.result
-        resolve(true)
-      }
-      request.onerror = () => resolve(false)
-    })
-  }
-
-  // 清理内存中的 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)!
-
-    const promise = (async () => {
-      try {
-        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
-      } finally {
-        loadingImages.delete(url)
-      }
-    })()
-
-    loadingImages.set(url, promise)
-    return promise
-  }
-
-  async function getImageFromDB(url: string): Promise<ImageCacheItem | null> {
-    if (!imageDB) return null
-    return new Promise((resolve) => {
-      const transaction = imageDB!.transaction([STORE_NAME], 'readonly')
-      const store = transaction.objectStore(STORE_NAME)
-      const request = store.get(url)
-      request.onsuccess = () => resolve(request.result || null)
-      request.onerror = () => resolve(null)
-    })
-  }
-
-  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
-
-      // 如果后端返回 Vite @fs 路径，直接使用，不需要缓存到 IndexedDB
-      if (result.viteUrl) {
-        // 将 Vite 路径缓存到内存中，避免重复请求后端
-        imageBlobUrls.value[url] = result.viteUrl
-        return result.viteUrl
-      }
-
-      // 兼容旧的 base64 返回格式（如果有的话）
-      if (result.dataUrl) {
-        const response = await fetch(result.dataUrl)
-        const blob = await response.blob()
-
-        // 检查图片大小
-        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
-      }
-
-      return null
-    } catch (e) {
-      console.error('[ImageCache] 缓存图片失败:', e)
-      return null
-    }
-  }
-
-  async function saveToDB(item: ImageCacheItem) {
-    if (!imageDB) return
-
-    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()
-  })
-
-  return {
-    getCachedImageUrl,
-    cacheImage,
-    clearChannelCache,
-    clearIndexedDB // 导出清理函数供外部使用
-  }
-}

package/client/vue/composables/useVideoCache.ts

@@ -1,125 +0,0 @@
-import { ref, onUnmounted } from 'vue'
-import { send } from '@koishijs/client'
-
-/**
- * 视频按需加载 composable
- * 只在用户点击播放时才加载视频，避免内存占用
- */
-export function useVideoCache() {
-  // 当前加载的视频 URL（原始 URL -> blob URL）
-  const loadedVideos = ref<Record<string, string>>({})
-  // 正在加载的视频
-  const loadingVideos = ref<Set<string>>(new Set())
-  // 当前的 blob URL，用于清理
-  const currentBlobUrl = ref<string | null>(null)
-
-  /**
-   * 按需加载视频
-   * @param url 原始视频 URL
-   * @returns blob URL 或 null
-   */
-  async function loadVideo(url: string): Promise<string | null> {
-    // 如果已经加载过，直接返回
-    if (loadedVideos.value[url]) {
-      return loadedVideos.value[url]
-    }
-
-    // 如果正在加载，等待加载完成
-    if (loadingVideos.value.has(url)) {
-      // 等待加载完成
-      return new Promise((resolve) => {
-        const checkInterval = setInterval(() => {
-          if (loadedVideos.value[url]) {
-            clearInterval(checkInterval)
-            resolve(loadedVideos.value[url])
-          }
-          if (!loadingVideos.value.has(url)) {
-            clearInterval(checkInterval)
-            resolve(null)
-          }
-        }, 100)
-      })
-    }
-
-    // 开始加载
-    loadingVideos.value.add(url)
-
-    try {
-      const result = await (send as any)('fetch-video-temp', { url })
-
-      if (result.success) {
-        // 如果返回 Vite @fs 路径，直接使用，不需要转换为 blob
-        if (result.viteUrl) {
-          loadedVideos.value[url] = result.viteUrl
-          return result.viteUrl
-        }
-
-        // 兼容旧的 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()
-          const blobUrl = URL.createObjectURL(blob)
-
-          currentBlobUrl.value = blobUrl
-          loadedVideos.value[url] = blobUrl
-          return blobUrl
-        }
-
-        return null
-      }
-
-      return null
-    } catch (error) {
-      console.error('加载视频失败:', error)
-      return null
-    } finally {
-      loadingVideos.value.delete(url)
-    }
-  }
-
-  /**
-   * 检查视频是否正在加载
-   */
-  function isVideoLoading(url: string): boolean {
-    return loadingVideos.value.has(url)
-  }
-
-  /**
-   * 检查视频是否已加载
-   */
-  function isVideoLoaded(url: string): boolean {
-    return !!loadedVideos.value[url]
-  }
-
-  /**
-   * 清空所有已加载的视频
-   */
-  function clearAllVideos() {
-    // 清理所有 blob URLs
-    Object.values(loadedVideos.value).forEach(blobUrl => {
-      if (blobUrl.startsWith('blob:')) {
-        URL.revokeObjectURL(blobUrl)
-      }
-    })
-    loadedVideos.value = {}
-    currentBlobUrl.value = null
-  }
-
-  // 组件卸载时清理
-  onUnmounted(() => {
-    clearAllVideos()
-  })
-
-  return {
-    loadVideo,
-    isVideoLoading,
-    isVideoLoaded,
-    clearAllVideos
-  }
-}