cd-aichat 1.0.0

package/src/services/burn-after-read-service.test.js

@@ -0,0 +1,325 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import {
+  createBurnAfterReadService,
+  getBurnAfterReadService,
+  resetBurnAfterReadService,
+  validateBurnDelay
+} from './burn-after-read-service';
+
+describe('Burn After Read Service', () => {
+  let service;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    resetBurnAfterReadService();
+    service = createBurnAfterReadService();
+  });
+
+  afterEach(() => {
+    service.cleanup();
+    vi.useRealTimers();
+  });
+
+  describe('消息标记', () => {
+    it('应该标记消息为阅后即焚', () => {
+      const message = {
+        id: 'msg1',
+        burnDelay: 10
+      };
+      const burnMessage = service.markMessageForBurn(message);
+      expect(burnMessage).toBeDefined();
+      expect(burnMessage.id).toBe('msg1');
+      expect(burnMessage.burnDelay).toBe(10);
+      expect(burnMessage.status).toBe('pending');
+    });
+
+    it('应该验证销毁延迟', () => {
+      const message = {
+        id: 'msg1',
+        burnDelay: -1 // 无效的延迟
+      };
+      expect(() => {
+        service.markMessageForBurn(message);
+      }).toThrow();
+    });
+
+    it('应该检查消息是否标记为阅后即焚', () => {
+      const message = {
+        id: 'msg1',
+        burnDelay: 10
+      };
+      expect(service.isMarkedForBurn('msg1')).toBe(false);
+      service.markMessageForBurn(message);
+      expect(service.isMarkedForBurn('msg1')).toBe(true);
+    });
+  });
+
+  describe('消息阅读', () => {
+    it('应该标记消息为已读', () => {
+      const message = {
+        id: 'msg1',
+        burnDelay: 10
+      };
+      service.markMessageForBurn(message);
+      const readTime = new Date();
+      service.markMessageAsRead('msg1', readTime);
+      const burnStatus = service.getBurnStatus('msg1');
+      expect(burnStatus.status).toBe('read');
+      expect(burnStatus.readTime).toEqual(readTime);
+    });
+
+    it('应该在标记为已读时开始倒计时', () => {
+      const callback = vi.fn();
+      service.on('burn-countdown-started', callback);
+      const message = {
+        id: 'msg1',
+        burnDelay: 10
+      };
+      service.markMessageForBurn(message);
+      service.markMessageAsRead('msg1');
+      expect(callback).toHaveBeenCalled();
+    });
+
+    it('应该在创建时如果已读立即开始倒计时', () => {
+      const callback = vi.fn();
+      service.on('burn-countdown-started', callback);
+      const message = {
+        id: 'msg1',
+        burnDelay: 10,
+        readTime: new Date()
+      };
+      service.markMessageForBurn(message);
+      expect(callback).toHaveBeenCalled();
+    });
+  });
+
+  describe('消息销毁', () => {
+    it('应该在延迟时间后销毁消息', () => {
+      const callback = vi.fn();
+      service.on('message-burned', callback);
+      const message = {
+        id: 'msg1',
+        burnDelay: 5 // 5秒
+      };
+      service.markMessageForBurn(message);
+      service.markMessageAsRead('msg1');
+      // 快进时间
+      vi.advanceTimersByTime(5000);
+      expect(callback).toHaveBeenCalled();
+      expect(service.isBurned('msg1')).toBe(true);
+    });
+
+    it('应该计算剩余销毁时间', () => {
+      const message = {
+        id: 'msg1',
+        burnDelay: 10
+      };
+      service.markMessageForBurn(message);
+      service.markMessageAsRead('msg1');
+      const remaining = service.getRemainingTime('msg1');
+      expect(remaining).toBe(10);
+      // 快进3秒
+      vi.advanceTimersByTime(3000);
+      const remainingAfter = service.getRemainingTime('msg1');
+      expect(remainingAfter).toBe(7);
+    });
+
+    it('应该在消息不存在时返回null剩余时间', () => {
+      const remaining = service.getRemainingTime('nonexistent');
+      expect(remaining).toBeNull();
+    });
+  });
+
+  describe('消息取消', () => {
+    it('应该取消消息销毁', () => {
+      const message = {
+        id: 'msg1',
+        burnDelay: 10
+      };
+      service.markMessageForBurn(message);
+      service.markMessageAsRead('msg1');
+      expect(service.isMarkedForBurn('msg1')).toBe(true);
+      service.cancelBurn('msg1');
+      expect(service.isMarkedForBurn('msg1')).toBe(false);
+    });
+
+    it('应该在取消时清除定时器', () => {
+      const burnCallback = vi.fn();
+      service.on('message-burned', burnCallback);
+      const message = {
+        id: 'msg1',
+        burnDelay: 5
+      };
+      service.markMessageForBurn(message);
+      service.markMessageAsRead('msg1');
+      service.cancelBurn('msg1');
+      // 快进时间，消息不应该被销毁
+      vi.advanceTimersByTime(5000);
+      expect(burnCallback).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('状态查询', () => {
+    it('应该获取消息的销毁状态', () => {
+      const message = {
+        id: 'msg1',
+        burnDelay: 10
+      };
+      service.markMessageForBurn(message);
+      const status = service.getBurnStatus('msg1');
+      expect(status).toBeDefined();
+      expect(status.id).toBe('msg1');
+      expect(status.status).toBe('pending');
+    });
+
+    it('应该获取所有待销毁消息', () => {
+      const message1 = { id: 'msg1', burnDelay: 10 };
+      const message2 = { id: 'msg2', burnDelay: 20 };
+      service.markMessageForBurn(message1);
+      service.markMessageForBurn(message2);
+      const messages = service.getBurnMessages();
+      expect(messages).toHaveLength(2);
+    });
+
+    it('应该检查消息是否已销毁', () => {
+      const message = {
+        id: 'msg1',
+        burnDelay: 1
+      };
+      service.markMessageForBurn(message);
+      service.markMessageAsRead('msg1');
+      expect(service.isBurned('msg1')).toBe(false);
+      // 快进时间
+      vi.advanceTimersByTime(1000);
+      expect(service.isBurned('msg1')).toBe(true);
+    });
+  });
+
+  describe('事件系统', () => {
+    it('应该在标记消息时触发事件', () => {
+      const callback = vi.fn();
+      service.on('message-marked', callback);
+      const message = {
+        id: 'msg1',
+        burnDelay: 10
+      };
+      service.markMessageForBurn(message);
+      expect(callback).toHaveBeenCalled();
+    });
+
+    it('应该在消息被读时触发事件', () => {
+      const callback = vi.fn();
+      service.on('message-read', callback);
+      const message = {
+        id: 'msg1',
+        burnDelay: 10
+      };
+      service.markMessageForBurn(message);
+      service.markMessageAsRead('msg1');
+      expect(callback).toHaveBeenCalled();
+    });
+
+    it('应该在消息销毁时触发事件', () => {
+      const callback = vi.fn();
+      service.on('message-burned', callback);
+      const message = {
+        id: 'msg1',
+        burnDelay: 1
+      };
+      service.markMessageForBurn(message);
+      service.markMessageAsRead('msg1');
+      vi.advanceTimersByTime(1000);
+      expect(callback).toHaveBeenCalled();
+    });
+
+    it('应该支持取消监听', () => {
+      const callback = vi.fn();
+      const unsubscribe = service.on('message-marked', callback);
+      const message1 = { id: 'msg1', burnDelay: 10 };
+      service.markMessageForBurn(message1);
+      expect(callback).toHaveBeenCalledTimes(1);
+      unsubscribe();
+      const message2 = { id: 'msg2', burnDelay: 10 };
+      service.markMessageForBurn(message2);
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('统计信息', () => {
+    it('应该返回正确的统计信息', () => {
+      const message1 = { id: 'msg1', burnDelay: 10 };
+      const message2 = { id: 'msg2', burnDelay: 20 };
+      service.markMessageForBurn(message1);
+      service.markMessageForBurn(message2);
+      service.markMessageAsRead('msg1');
+      const stats = service.getStats();
+      expect(stats.total).toBe(2);
+      expect(stats.pending).toBe(1);
+      expect(stats.read).toBe(1);
+      expect(stats.burned).toBe(0);
+      expect(stats.activeTimers).toBe(1);
+    });
+
+    it('应该在消息销毁后更新统计', () => {
+      const message = {
+        id: 'msg1',
+        burnDelay: 1
+      };
+      service.markMessageForBurn(message);
+      service.markMessageAsRead('msg1');
+      vi.advanceTimersByTime(1000);
+      const stats = service.getStats();
+      expect(stats.burned).toBe(1);
+      expect(stats.activeTimers).toBe(0);
+    });
+  });
+
+  describe('清理', () => {
+    it('应该清理所有定时器和数据', () => {
+      const message1 = { id: 'msg1', burnDelay: 10 };
+      const message2 = { id: 'msg2', burnDelay: 20 };
+      service.markMessageForBurn(message1);
+      service.markMessageForBurn(message2);
+      service.markMessageAsRead('msg1');
+      service.markMessageAsRead('msg2');
+      expect(service.getStats().activeTimers).toBe(2);
+      service.cleanup();
+      expect(service.getStats().total).toBe(0);
+      expect(service.getStats().activeTimers).toBe(0);
+    });
+  });
+
+  describe('全局服务', () => {
+    it('应该返回相同的全局实例', () => {
+      const service1 = getBurnAfterReadService();
+      const service2 = getBurnAfterReadService();
+      expect(service1).toBe(service2);
+    });
+
+    it('应该在重置后创建新实例', () => {
+      const service1 = getBurnAfterReadService();
+      resetBurnAfterReadService();
+      const service2 = getBurnAfterReadService();
+      expect(service1).not.toBe(service2);
+    });
+  });
+
+  describe('验证函数', () => {
+    it('应该验证有效的销毁延迟', () => {
+      const result = validateBurnDelay(10);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('应该拒绝无效的销毁延迟', () => {
+      const result = validateBurnDelay(-1);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('应该拒绝超出范围的销毁延迟', () => {
+      const result = validateBurnDelay(3601);
+      expect(result.valid).toBe(false);
+    });
+  });
+});

package/src/services/dify-api.js

@@ -0,0 +1,338 @@
+import axios from 'axios';
+
+class DifyApiService {
+  constructor(config) {
+    // 支持旧的构造函数签名 (baseURL, agentId) 和新的配置对象
+    if (typeof config === 'string') {
+      // 旧的签名：constructor(baseURL, agentId)
+      this.baseURL = config || (import.meta.env ? import.meta.env.VITE_AICHAT_API_URL : '');
+      this.agentId = arguments[1];
+      this.apiKey = '';
+      this.platform = '';
+      this.scene = '';
+      this.knowledgeBase = null;
+      this.inputVariables = {};
+      this.conversationConfig = {
+        id: '',
+        autoCreate: true,
+        timeout: 1800000 // 30 minutes
+      };
+      this.responseConfig = {
+        mode: 'blocking',
+        timeout: 30000,
+        maxRetries: 3
+      };
+    } else {
+      // 新的签名：constructor(config)
+      this.baseURL = config.url || (import.meta.env ? import.meta.env.VITE_AICHAT_API_URL : '');
+      this.agentId = config.agentId;
+      this.apiKey = config.apiKey || '';
+      this.platform = config.platform || '';
+      this.scene = config.scene || '';
+      this.knowledgeBase = config.knowledgeBase || null;
+      this.inputVariables = config.inputVariables || {};
+      this.conversationConfig = {
+        id: config.conversation?.id || '',
+        autoCreate: config.conversation?.autoCreate !== false,
+        timeout: config.conversation?.timeout || 1800000
+      };
+      this.responseConfig = {
+        mode: config.response?.mode || 'blocking',
+        timeout: config.response?.timeout || 30000,
+        maxRetries: config.response?.maxRetries || 3
+      };
+    }
+    
+    // 验证必填字段
+    this._validateConfig();
+    
+    // 创建 axios 客户端
+    this.client = axios.create({
+      baseURL: this.baseURL,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      timeout: this.responseConfig.timeout
+    });
+    
+    // 会话状态
+    this.currentConversationId = this.conversationConfig.id;
+    this.conversationCreatedAt = null;
+  }
+  
+  /**
+   * 验证配置
+   * @private
+   */
+  _validateConfig() {
+    if (!this.baseURL) {
+      throw new Error('API URL is required. Please provide it via url prop or VITE_AICHAT_API_URL environment variable.');
+    }
+    
+    if (!this.agentId) {
+      throw new Error('Agent ID is required');
+    }
+  }
+
+  /**
+   * 更新配置
+   * @param {Object} config - 新的配置对象
+   */
+  updateConfig(config) {
+    if (config.url) {
+      this.baseURL = config.url;
+    }
+    if (config.agentId) {
+      this.agentId = config.agentId;
+    }
+    if (config.apiKey !== undefined) {
+      this.apiKey = config.apiKey;
+    }
+    if (config.platform !== undefined) {
+      this.platform = config.platform;
+    }
+    if (config.scene !== undefined) {
+      this.scene = config.scene;
+    }
+    if (config.knowledgeBase !== undefined) {
+      this.knowledgeBase = config.knowledgeBase;
+    }
+    if (config.inputVariables !== undefined) {
+      this.inputVariables = config.inputVariables;
+    }
+    if (config.conversation) {
+      this.conversationConfig = {
+        ...this.conversationConfig,
+        ...config.conversation
+      };
+      if (config.conversation.id) {
+        this.currentConversationId = config.conversation.id;
+      }
+    }
+    if (config.response) {
+      this.responseConfig = {
+        ...this.responseConfig,
+        ...config.response
+      };
+    }
+    
+    // 验证更新后的配置
+    this._validateConfig();
+    
+    // 重新创建 axios 客户端
+    this.client = axios.create({
+      baseURL: this.baseURL,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      timeout: this.responseConfig.timeout
+    });
+  }
+
+  setBaseURL(baseURL) {
+    if (baseURL) {
+      this.baseURL = baseURL;
+      this.client = axios.create({
+        baseURL: this.baseURL,
+        headers: {
+          'Content-Type': 'application/json',
+        }
+      });
+    }
+  }
+
+  setAgentId(agentId) {
+    this.agentId = agentId;
+  }
+
+  /**
+   * 构建输入变量
+   * @private
+   * @param {Object} runtimeVariables - 运行时传入的变量
+   * @returns {Object} 合并后的输入变量
+   */
+  _buildInputVariables(runtimeVariables = {}) {
+    const inputs = {
+      ...this.inputVariables,
+      ...runtimeVariables
+    };
+    
+    // 添加平台和场景信息
+    if (this.platform) {
+      inputs._platform = this.platform;
+    }
+    if (this.scene) {
+      inputs._scene = this.scene;
+    }
+    
+    // 添加知识库数据
+    if (this.knowledgeBase && this.knowledgeBase.data) {
+      inputs._knowledgeBase = this.knowledgeBase.data;
+    }
+    
+    return inputs;
+  }
+
+  async sendMessage(message, userId, options = {}) {
+    try {
+      if (!this.baseURL) {
+        throw new Error('API URL is required. Please provide it via url prop or VITE_AICHAT_API_URL environment variable.');
+      }
+
+      if (!this.agentId) {
+        throw new Error('Agent ID is required');
+      }
+
+      if (!userId) {
+        throw new Error('User ID is required');
+      }
+
+      // 构建输入变量
+      const inputs = this._buildInputVariables(options.inputVariables);
+      
+      // 使用传入的会话 ID 或当前会话 ID
+      const conversationId = options.conversationId || this.currentConversationId;
+
+      const payload = {
+        inputs,
+        query: message,
+        user: userId,
+        response_mode: this.responseConfig.mode
+      };
+      
+      // 如果有会话 ID，添加到请求中
+      if (conversationId) {
+        payload.conversation_id = conversationId;
+      }
+
+      const response = await this.client.post(`/chat-messages`, payload, {
+        headers: {
+          'X-Agent-Id': this.agentId
+        }
+      });
+
+      // 更新当前会话 ID
+      if (response.data.conversation_id) {
+        this.currentConversationId = response.data.conversation_id;
+        if (!this.conversationCreatedAt) {
+          this.conversationCreatedAt = Date.now();
+        }
+      }
+
+      return response.data;
+    } catch (error) {
+      console.error('Error sending message to Dify API:', error);
+      throw error;
+    }
+  }
+
+  async getConversationHistory(userId, limit = 20) {
+    try {
+      if (!this.baseURL) {
+        throw new Error('API URL is required. Please provide it via url prop or VITE_AICHAT_API_URL environment variable.');
+      }
+
+      if (!this.agentId) {
+        throw new Error('Agent ID is required');
+      }
+
+      if (!userId) {
+        throw new Error('User ID is required');
+      }
+
+      const response = await this.client.get(`/conversations`, {
+        params: {
+          user: userId,
+          limit
+        },
+        headers: {
+          'X-Agent-Id': this.agentId
+        }
+      });
+
+      return response.data;
+    } catch (error) {
+      console.error('Error fetching conversation history:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * 创建新会话
+   * @param {string} userId - 用户 ID
+   * @returns {Promise<string>} 会话 ID
+   */
+  async createConversation(userId) {
+    try {
+      if (!userId) {
+        throw new Error('User ID is required');
+      }
+      
+      // Dify 会在第一次发送消息时自动创建会话
+      // 这里我们只是重置本地状态
+      this.currentConversationId = '';
+      this.conversationCreatedAt = null;
+      
+      return '';
+    } catch (error) {
+      console.error('Error creating conversation:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * 获取会话信息
+   * @param {string} conversationId - 会话 ID
+   * @returns {Promise<Object>} 会话信息
+   */
+  async getConversation(conversationId) {
+    try {
+      if (!conversationId) {
+        throw new Error('Conversation ID is required');
+      }
+      
+      // 返回当前会话信息
+      return {
+        id: this.currentConversationId,
+        createdAt: this.conversationCreatedAt,
+        platform: this.platform,
+        scene: this.scene
+      };
+    } catch (error) {
+      console.error('Error getting conversation:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * 更新知识库
+   * @param {Object} knowledgeBase - 知识库配置
+   */
+  updateKnowledgeBase(knowledgeBase) {
+    this.knowledgeBase = knowledgeBase;
+  }
+  
+  /**
+   * 检查会话是否超时
+   * @returns {boolean} 是否超时
+   */
+  isConversationExpired() {
+    if (!this.conversationCreatedAt) {
+      return false;
+    }
+    
+    const now = Date.now();
+    const elapsed = now - this.conversationCreatedAt;
+    return elapsed > this.conversationConfig.timeout;
+  }
+  
+  /**
+   * 重置会话
+   */
+  resetConversation() {
+    this.currentConversationId = '';
+    this.conversationCreatedAt = null;
+  }
+}
+
+export default DifyApiService;