koishi-plugin-chat-patch 2.3.0 → 2.4.4

package/src/api-handlers.ts

@@ -35,10 +35,10 @@ export class ApiHandlers {
 
     this.ctx.console.addListener('get-chat-data' as any, async () => {
       try {
+        // 只读取元数据，不加载消息到内存
+        const data = this.fileManager.readMetadataOnly()
 
-        const data = this.fileManager.readChatDataFromFile()
-
-        this.logInfo('获取基础聊天数据')
+        this.logInfo('获取基础聊天数据（仅元数据）')
 
         return {
           success: true,
@@ -47,7 +47,7 @@ export class ApiHandlers {
             channels: data.channels || {},
             pinnedBots: data.pinnedBots || [],
             pinnedChannels: data.pinnedChannels || [],
-
+            // 不返回消息数据，由前端按需加载
             messages: {}
           }
         }
@@ -64,9 +64,8 @@ export class ApiHandlers {
       offset?: number
     }) => {
       try {
-        const data = this.fileManager.readChatDataFromFile()
-        const channelKey = `${requestData.selfId}:${requestData.channelId}`
-        let messages = data.messages[channelKey] || []
+        // 直接从文件读取该频道的消息，不加载所有消息到内存
+        let messages = this.fileManager.readChannelMessages(requestData.selfId, requestData.channelId)
 
         const sortedMessages = messages.sort((a, b) => b.timestamp - a.timestamp)
 
@@ -77,11 +76,11 @@ export class ApiHandlers {
 
           messages = messages.sort((a, b) => a.timestamp - b.timestamp)
         } else {
-
+          // 如果没有指定limit，返回所有消息（按时间正序）
           messages = sortedMessages.sort((a, b) => a.timestamp - b.timestamp)
         }
 
-        this.logInfo('获取历史消息:', channelKey, '共', messages.length, '条消息')
+        this.logInfo('获取历史消息:', `${requestData.selfId}:${requestData.channelId}`, '共', messages.length, '条消息')
 
         return {
           success: true,
@@ -120,45 +119,75 @@ export class ApiHandlers {
 
     this.ctx.console.addListener('fetch-image' as any, async (data: { url: string }) => {
       try {
+        // 如果已经是 Vite @fs 路径，直接返回
+        if (data.url.includes('/vite/@fs/')) {
+          return {
+            success: true,
+            viteUrl: data.url
+          }
+        }
 
+        // 如果是本地文件 URL，转换为 Vite @fs 路径
         if (this.isFileUrl(data.url)) {
           this.logInfo('处理本地文件请求:', data.url)
-          return await this.handleLocalFileRequest(data.url)
+          const filePath = require('node:url').fileURLToPath(data.url)
+          const normalizedPath = filePath.replace(/\\/g, '/')
+          return {
+            success: true,
+            viteUrl: `/vite/@fs/${normalizedPath}`
+          }
+        }
+
+        // 网络图片：下载并缓存到本地，返回 Vite @fs 路径
+        const dir = require('node:path').join(this.ctx.baseDir, 'data', 'chat-patch', 'persist-media', 'images')
+        if (!require('node:fs').existsSync(dir)) {
+          require('node:fs').mkdirSync(dir, { recursive: true })
         }
 
-        const response = await fetch(data.url, {
-          headers: {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
-            'Referer': ''
+        const crypto = require('node:crypto')
+        const hash = crypto.createHash('md5').update(data.url).digest('hex')
+        const ext = require('node:path').extname(new URL(data.url).pathname) || '.jpg'
+        const filename = `${hash}${ext}`
+        const filePath = require('node:path').join(dir, filename)
+
+        // 如果文件不存在，下载并保存
+        if (!require('node:fs').existsSync(filePath)) {
+          const response = await fetch(data.url, {
+            headers: {
+              'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+              'Referer': ''
+            }
+          })
+
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`)
           }
-        })
 
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+          const buffer = await response.arrayBuffer()
+          require('node:fs').writeFileSync(filePath, Buffer.from(buffer))
         }
 
-        const buffer = await response.arrayBuffer()
-        const base64 = Buffer.from(buffer).toString('base64')
-        const contentType = response.headers.get('content-type') || 'image/jpeg'
+        // 返回 Vite @fs 路径
+        const normalizedPath = filePath.replace(/\\/g, '/')
         return {
           success: true,
-          base64: base64,
-          contentType: contentType,
-          dataUrl: `data:${contentType};base64,${base64}`
+          viteUrl: `/vite/@fs/${normalizedPath}`
         }
       } catch (error: any) {
+        this.logger.error('获取图片失败:', error)
         return { success: false, error: error?.message || String(error) }
       }
     })
 
+    // 清理历史记录 API 已废弃，现在直接通过右键删除频道数据
     this.ctx.console.addListener('clear-channel-history' as any, async (data: {
       selfId: string
       channelId: string
-      keepCount?: number
     }) => {
       try {
-        this.logInfo('收到清理历史记录请求:', data)
+        this.logInfo('收到清理历史记录请求（已废弃，建议使用删除频道数据）:', data)
 
+        // 直接删除该频道的所有消息
         const chatData = this.fileManager.readChatDataFromFile()
         const channelKey = `${data.selfId}:${data.channelId}`
 
@@ -166,33 +195,19 @@ export class ApiHandlers {
           return { success: true, message: '频道没有历史消息' }
         }
 
-        const messages = chatData.messages[channelKey]
-        const originalCount = messages.length
-
-        const keepCount = data.keepCount || this.config.keepMessagesOnClear
-
-        if (keepCount > 0 && originalCount <= keepCount) {
-          return { success: true, message: `消息数量(${originalCount})未超过保留数量(${keepCount})，无需清理` }
-        }
-
-        const sortedMessages = [...messages].sort((a, b) => a.timestamp - b.timestamp)
-        const keptMessages = keepCount > 0 ? sortedMessages.slice(-keepCount) : []
-        const clearedCount = originalCount - keptMessages.length
-
-        chatData.messages[channelKey] = keptMessages
+        const originalCount = chatData.messages[channelKey].length
+        delete chatData.messages[channelKey]
         this.fileManager.writeChatDataToFile(chatData)
 
-        this.logInfo(`频道 ${channelKey} 历史记录清理完成:`, {
-          原始消息数: originalCount,
-          保留消息数: keptMessages.length,
-          清理消息数: clearedCount
+        this.logInfo(`频道 ${channelKey} 历史记录已清空:`, {
+          清理消息数: originalCount
         })
 
         return {
           success: true,
-          message: `成功清理 ${clearedCount} 条历史消息，保留最新 ${keptMessages.length} 条`,
-          clearedCount: clearedCount,
-          keptCount: keptMessages.length
+          message: `成功清理 ${originalCount} 条历史消息`,
+          clearedCount: originalCount,
+          keptCount: 0
         }
       } catch (error: any) {
         this.logger.error('清理频道历史记录失败:', error)
@@ -478,7 +493,6 @@ export class ApiHandlers {
           success: true,
           config: {
             maxMessagesPerChannel: this.config.maxMessagesPerChannel,
-            keepMessagesOnClear: this.config.keepMessagesOnClear,
             maxPersistImages: this.config.maxPersistImages,
             loggerinfo: this.config.loggerinfo,
             blockedPlatforms: this.config.blockedPlatforms || [],
@@ -579,35 +593,59 @@ export class ApiHandlers {
       try {
         this.logInfo('收到视频临时加载请求:', data.url)
 
-        if (this.isFileUrl(data.url)) {
-          const result = await this.handleLocalFileRequest(data.url)
-          return result
+        // 如果已经是 Vite @fs 路径，直接返回
+        if (data.url.includes('/vite/@fs/')) {
+          return {
+            success: true,
+            viteUrl: data.url
+          }
         }
 
-        const response = await fetch(data.url, {
-          headers: {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
-            'Referer': ''
+        // 如果是本地文件 URL，转换为 Vite @fs 路径
+        if (this.isFileUrl(data.url)) {
+          const filePath = require('node:url').fileURLToPath(data.url)
+          const normalizedPath = filePath.replace(/\\/g, '/')
+          return {
+            success: true,
+            viteUrl: `/vite/@fs/${normalizedPath}`
           }
-        })
+        }
 
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+        // 网络视频：下载并缓存到本地，返回 Vite @fs 路径
+        const dir = require('node:path').join(this.ctx.baseDir, 'data', 'chat-patch', 'persist-media', 'media')
+        if (!require('node:fs').existsSync(dir)) {
+          require('node:fs').mkdirSync(dir, { recursive: true })
         }
 
-        const buffer = await response.arrayBuffer()
-        const base64 = Buffer.from(buffer).toString('base64')
+        const crypto = require('node:crypto')
+        const hash = crypto.createHash('md5').update(data.url).digest('hex')
+        const ext = require('node:path').extname(new URL(data.url).pathname) || '.mp4'
+        const filename = `${hash}${ext}`
+        const filePath = require('node:path').join(dir, filename)
 
-        const contentType = response.headers.get('content-type') || 'video/mp4'
+        // 如果文件不存在，下载并保存
+        if (!require('node:fs').existsSync(filePath)) {
+          const response = await fetch(data.url, {
+            headers: {
+              'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+              'Referer': ''
+            }
+          })
 
-        this.logInfo('视频下载成功:', { size: buffer.byteLength, contentType })
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+          }
+
+          const buffer = await response.arrayBuffer()
+          require('node:fs').writeFileSync(filePath, Buffer.from(buffer))
+          this.logInfo('视频下载成功:', { size: buffer.byteLength, path: filePath })
+        }
 
+        // 返回 Vite @fs 路径
+        const normalizedPath = filePath.replace(/\\/g, '/')
         return {
           success: true,
-          base64: base64,
-          contentType: contentType,
-          dataUrl: `data:${contentType};base64,${base64}`,
-          size: buffer.byteLength
+          viteUrl: `/vite/@fs/${normalizedPath}`
         }
       } catch (error: any) {
         this.logger.error('视频临时加载失败:', error)

package/src/config.ts

@@ -4,7 +4,6 @@ export interface Config {
   loggerinfo: boolean
   clearIndexedDBOnStart: boolean
   maxMessagesPerChannel: number
-  keepMessagesOnClear: number
   maxPersistImages: number
   blockedPlatforms: Array<{
     platformName: string
@@ -15,7 +14,6 @@ export interface Config {
 export const Config: Schema<Config> = Schema.intersect([
   Schema.object({
     maxMessagesPerChannel: Schema.number().default(500).description('每个群组最大保存消息数量').min(50).max(1500).step(1),
-    keepMessagesOnClear: Schema.number().default(50).description('手动清理历史记录时保留的消息数量').min(0).max(1000).step(1),
     maxPersistImages: Schema.number().default(100).description('持久化存储的图片缓存数量').min(10).max(500).step(1),
     blockedPlatforms: Schema.array(Schema.object({
       platformName: Schema.string().description('平台名称或关键词'),

package/src/file-manager.ts

@@ -7,16 +7,16 @@ import path from 'node:path'
 import fs from 'node:fs'
 
 export class FileManager {
-  private dataFilePath: string
-  private fileOperationLock = Promise.resolve()
+  private chatHistoryDir: string // 聊天记录根目录
+  private metadataFilePath: string // 元数据文件路径（存储bots、channels、pinned等信息）
   private logger: Logger
   private utils: Utils
 
   private memoryCache: ChatData | null = null
 
-  private pendingMessages: MessageInfo[] = []
+  private pendingMessages: Map<string, MessageInfo[]> = new Map() // 按channelKey分组的待写入消息
 
-  private writeTimer: (() => void) | null = null
+  private writeTimers: Map<string, (() => void)> = new Map() // 每个频道独立的写入定时器
 
   private readonly WRITE_DEBOUNCE_MS = 1000
 
@@ -24,45 +24,180 @@ export class FileManager {
     private ctx: Context,
     private config: Config
   ) {
-    this.dataFilePath = path.resolve(ctx.baseDir, 'data', 'chat-patch', 'chat-data.json')
+    const baseDir = path.resolve(ctx.baseDir, 'data', 'chat-patch')
+    this.chatHistoryDir = path.join(baseDir, 'chat-history')
+    this.metadataFilePath = path.join(baseDir, 'metadata.json')
     this.logger = ctx.logger('chat-patch')
     this.utils = new Utils(config)
 
+    // 清理旧版本的单文件存储
+    this.cleanupOldDataFiles(baseDir)
+
     this.memoryCache = this.readChatDataFromFile()
   }
 
-  private ensureDataDir() {
-    const dir = path.dirname(this.dataFilePath)
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true })
+  // 清理旧版本的JSON文件
+  private cleanupOldDataFiles(baseDir: string) {
+    const oldFiles = ['chat-data.json', 'data.json', 'messages.json']
+    for (const fileName of oldFiles) {
+      const filePath = path.join(baseDir, fileName)
+      if (fs.existsSync(filePath)) {
+        try {
+          fs.unlinkSync(filePath)
+          this.logger.info(`已删除旧版本数据文件: ${fileName}`)
+        } catch (error) {
+          this.logger.warn(`删除旧版本数据文件失败: ${fileName}`, error)
+        }
+      }
     }
   }
 
-  readChatDataFromFile(): ChatData {
+  // 确保目录存在
+  private ensureDir(dirPath: string) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true })
+    }
+  }
+
+  // 获取频道消息文件路径
+  private getChannelFilePath(selfId: string, channelId: string): string {
+    const botDir = path.join(this.chatHistoryDir, selfId)
+    this.ensureDir(botDir)
+    return path.join(botDir, `${channelId}.json`)
+  }
+
+  // 读取单个频道的消息（公共方法）
+  readChannelMessages(selfId: string, channelId: string): MessageInfo[] {
+    const filePath = this.getChannelFilePath(selfId, channelId)
+    if (!fs.existsSync(filePath)) {
+      return []
+    }
+
+    try {
+      const jsonData = fs.readFileSync(filePath, 'utf8')
+      const messages = JSON.parse(jsonData)
+      return Array.isArray(messages) ? messages : []
+    } catch (error) {
+      this.logger.error(`读取频道消息失败 [${selfId}:${channelId}]:`, error)
+      return []
+    }
+  }
+
+  // 写入单个频道的消息
+  private writeChannelMessages(selfId: string, channelId: string, messages: MessageInfo[]) {
+    const filePath = this.getChannelFilePath(selfId, channelId)
+    try {
+      const jsonData = JSON.stringify(messages, null, 2)
+      fs.writeFileSync(filePath, jsonData, 'utf8')
+    } catch (error) {
+      this.logger.error(`写入频道消息失败 [${selfId}:${channelId}]:`, error)
+    }
+  }
+
+  // 读取元数据（bots、channels、pinned等）
+  private readMetadata(): Omit<ChatData, 'messages'> {
+    if (!fs.existsSync(this.metadataFilePath)) {
+      return {
+        bots: {},
+        channels: {},
+        pinnedBots: [],
+        pinnedChannels: []
+      }
+    }
+
+    try {
+      const jsonData = fs.readFileSync(this.metadataFilePath, 'utf8')
+      const data = JSON.parse(jsonData)
+      return {
+        bots: data.bots || {},
+        channels: data.channels || {},
+        pinnedBots: data.pinnedBots || [],
+        pinnedChannels: data.pinnedChannels || [],
+        lastSaveTime: data.lastSaveTime
+      }
+    } catch (error) {
+      this.logger.error('读取元数据失败:', error)
+      return {
+        bots: {},
+        channels: {},
+        pinnedBots: [],
+        pinnedChannels: []
+      }
+    }
+  }
+
+  // 只读取元数据，不加载消息（公共方法）
+  readMetadataOnly(): Omit<ChatData, 'messages'> {
+    return this.readMetadata()
+  }
+
+  // 写入元数据
+  private writeMetadata(metadata: Omit<ChatData, 'messages'>) {
+    try {
+      this.ensureDir(path.dirname(this.metadataFilePath))
+      const dataToWrite = {
+        ...metadata,
+        lastSaveTime: Date.now()
+      }
+      const jsonData = JSON.stringify(dataToWrite, null, 2)
+      fs.writeFileSync(this.metadataFilePath, jsonData, 'utf8')
+    } catch (error) {
+      this.logger.error('写入元数据失败:', error)
+    }
+  }
+
+  // 扫描所有频道消息文件并加载到内存
+  private loadAllChannelMessages(): Record<string, MessageInfo[]> {
+    const messages: Record<string, MessageInfo[]> = {}
+
+    if (!fs.existsSync(this.chatHistoryDir)) {
+      return messages
+    }
 
+    try {
+      const botDirs = fs.readdirSync(this.chatHistoryDir)
+      for (const botId of botDirs) {
+        const botDir = path.join(this.chatHistoryDir, botId)
+        const stat = fs.statSync(botDir)
+        if (!stat.isDirectory()) continue
+
+        const channelFiles = fs.readdirSync(botDir)
+        for (const fileName of channelFiles) {
+          if (!fileName.endsWith('.json')) continue
+
+          const channelId = fileName.replace('.json', '')
+          const channelKey = `${botId}:${channelId}`
+          messages[channelKey] = this.readChannelMessages(botId, channelId)
+        }
+      }
+    } catch (error) {
+      this.logger.error('加载频道消息失败:', error)
+    }
+
+    return messages
+  }
+
+  readChatDataFromFile(): ChatData {
+    // 如果已有缓存，直接返回
     if (this.memoryCache) {
       return this.memoryCache
     }
 
+    // 异步加载数据
     process.nextTick(() => {
       try {
-        if (fs.existsSync(this.dataFilePath)) {
-          const jsonData = fs.readFileSync(this.dataFilePath, 'utf8')
-          const data = JSON.parse(jsonData)
-          this.memoryCache = {
-            bots: data.bots || {},
-            channels: data.channels || {},
-            messages: data.messages || {},
-            pinnedBots: data.pinnedBots || [],
-            pinnedChannels: data.pinnedChannels || [],
-            lastSaveTime: data.lastSaveTime
-          }
+        const metadata = this.readMetadata()
+        const messages = this.loadAllChannelMessages()
+        this.memoryCache = {
+          ...metadata,
+          messages
         }
       } catch (error) {
         this.logger.error('读取聊天数据失败:', error)
       }
     })
 
+    // 先返回空数据
     this.memoryCache = {
       bots: {},
       channels: {},
@@ -74,52 +209,64 @@ export class FileManager {
   }
 
   writeChatDataToFile(data: ChatData) {
-
     data.lastSaveTime = Date.now()
     this.memoryCache = data
 
     process.nextTick(() => {
       try {
-        this.ensureDataDir()
-        const jsonData = JSON.stringify(data, null, 2)
-        fs.writeFileSync(this.dataFilePath, jsonData, 'utf8')
+        // 写入元数据
+        const { messages, ...metadata } = data
+        this.writeMetadata(metadata)
+
+        // 写入各个频道的消息
+        for (const [channelKey, channelMessages] of Object.entries(messages)) {
+          const [selfId, channelId] = channelKey.split(':')
+          if (selfId && channelId) {
+            this.writeChannelMessages(selfId, channelId, channelMessages)
+          }
+        }
       } catch (error) {
         this.logger.error('写入聊天数据失败:', error)
       }
     })
   }
 
-  private scheduleWrite() {
-
-    if (this.writeTimer) {
-      this.writeTimer()
-      this.writeTimer = null
+  // 为特定频道安排写入
+  private scheduleWrite(channelKey: string) {
+    // 取消之前的定时器
+    const existingTimer = this.writeTimers.get(channelKey)
+    if (existingTimer) {
+      existingTimer()
     }
 
-    this.writeTimer = this.ctx.setTimeout(() => {
-
+    // 创建新的定时器
+    const timer = this.ctx.setTimeout(() => {
       process.nextTick(() => {
-        this.flushPendingMessages()
+        this.flushPendingMessages(channelKey)
       })
-      this.writeTimer = null
+      this.writeTimers.delete(channelKey)
     }, this.WRITE_DEBOUNCE_MS)
+
+    this.writeTimers.set(channelKey, timer)
   }
 
-  private flushPendingMessages() {
-    if (this.pendingMessages.length === 0) return
+  // 刷新特定频道的待写入消息
+  private flushPendingMessages(channelKey: string) {
+    const messagesToWrite = this.pendingMessages.get(channelKey)
+    if (!messagesToWrite || messagesToWrite.length === 0) return
 
-    const messagesToWrite = [...this.pendingMessages]
-    this.pendingMessages = []
+    this.pendingMessages.delete(channelKey)
 
     const data = this.memoryCache || this.readChatDataFromFile()
+    const [selfId, channelId] = channelKey.split(':')
 
-    for (const messageInfo of messagesToWrite) {
-      const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`
+    if (!selfId || !channelId) return
 
-      if (!data.messages[channelKey]) {
-        data.messages[channelKey] = []
-      }
+    if (!data.messages[channelKey]) {
+      data.messages[channelKey] = []
+    }
 
+    for (const messageInfo of messagesToWrite) {
       const existingMessage = data.messages[channelKey].find(m => m.id === messageInfo.id)
       if (existingMessage) {
         continue
@@ -131,15 +278,19 @@ export class FileManager {
 
       const cleanedMessageInfo = this.utils.cleanBase64Content(messageInfo) as MessageInfo
       data.messages[channelKey].push(cleanedMessageInfo)
+    }
 
-      if (data.messages[channelKey].length > this.config.maxMessagesPerChannel) {
-        data.messages[channelKey].sort((a, b) => a.timestamp - b.timestamp)
-        data.messages[channelKey] = data.messages[channelKey].slice(-this.config.maxMessagesPerChannel)
-      }
+    // 限制消息数量
+    if (data.messages[channelKey].length > this.config.maxMessagesPerChannel) {
+      data.messages[channelKey].sort((a, b) => a.timestamp - b.timestamp)
+      data.messages[channelKey] = data.messages[channelKey].slice(-this.config.maxMessagesPerChannel)
     }
 
-    this.writeChatDataToFile(data)
-    this.logInfo(`批量写入 ${messagesToWrite.length} 条消息`)
+    // 只写入这个频道的消息文件
+    this.writeChannelMessages(selfId, channelId, data.messages[channelKey])
+    this.memoryCache = data
+
+    this.logInfo(`批量写入 ${messagesToWrite.length} 条消息到频道 ${channelKey}`)
   }
 
   cleanExcessMessages(data: ChatData): ChatData {
@@ -169,11 +320,16 @@ export class FileManager {
   }
 
   async addMessageToFile(messageInfo: MessageInfo) {
+    const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`
 
-    this.pendingMessages.push(messageInfo)
+    // 添加到待写入队列
+    if (!this.pendingMessages.has(channelKey)) {
+      this.pendingMessages.set(channelKey, [])
+    }
+    this.pendingMessages.get(channelKey)!.push(messageInfo)
 
+    // 更新内存缓存
     const data = this.memoryCache || this.readChatDataFromFile()
-    const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`
 
     if (!data.messages[channelKey]) {
       data.messages[channelKey] = []
@@ -195,16 +351,17 @@ export class FileManager {
       this.memoryCache = data
     }
 
-    this.scheduleWrite()
+    // 安排写入
+    this.scheduleWrite(channelKey)
   }
 
   dispose() {
-    if (this.writeTimer) {
-      this.writeTimer()
-      this.writeTimer = null
+    // 取消所有定时器
+    for (const [channelKey, timer] of this.writeTimers.entries()) {
+      timer()
+      this.flushPendingMessages(channelKey)
     }
-
-    this.flushPendingMessages()
+    this.writeTimers.clear()
   }
 
   private logInfo(...args: any[]) {