@becrafter/prompt-manager 0.1.14 → 0.1.16

package/packages/server/tests/integration/terminal-websocket.test.js

@@ -0,0 +1,372 @@
+/**
+ * 终端和WebSocket服务集成测试
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { WebSocket } from 'ws';
+import { terminalService } from '../../services/TerminalService.js';
+import { webSocketService } from '../../services/WebSocketService.js';
+import { startServer, stopServer } from '../../server.js';
+
+// Mock WebSocket客户端
+vi.mock('ws', () => ({
+  WebSocket: vi.fn().mockImplementation(() => ({
+    readyState: 1,
+    send: vi.fn(),
+    close: vi.fn(),
+    on: vi.fn(),
+    addEventListener: vi.fn()
+  }))
+}));
+
+describe('Terminal and WebSocket Integration', () => {
+  let server;
+  let wsPort;
+  let mockWebSocketClient;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    
+    // 启动测试服务器
+    server = await startServer({
+      configOverrides: {
+        port: 0, // 使用随机端口
+        adminEnable: true
+      }
+    });
+
+    // 获取服务器端口
+    const address = server.address();
+    wsPort = 8081; // WebSocket固定端口
+
+    // 创建Mock WebSocket客户端
+    mockWebSocketClient = new WebSocket();
+  });
+
+  afterEach(async () => {
+    // 清理终端会话
+    await terminalService.shutdown();
+    
+    // 停止WebSocket服务
+    await webSocketService.stop();
+    
+    // 停止服务器
+    if (server) {
+      await stopServer();
+    }
+  });
+
+  describe('完整终端会话流程', () => {
+    it('应该完成完整的终端会话生命周期', async () => {
+      // 启动WebSocket服务
+      await webSocketService.start();
+      
+      // 模拟WebSocket连接
+      const mockConnection = {
+        clientId: 'test-client-1',
+        sessionId: null,
+        ws: {
+          readyState: 1,
+          send: vi.fn(),
+          close: vi.fn(),
+          on: vi.fn()
+        },
+        send: vi.fn(),
+        sendError: vi.fn()
+      };
+
+      // 添加连接到服务
+      webSocketService.connections.set(mockConnection.clientId, mockConnection);
+
+      // 1. 创建终端会话
+      const createMessage = {
+        type: 'terminal.create',
+        sessionId: 'integration-test-session',
+        size: { cols: 80, rows: 24 },
+        workingDirectory: process.cwd()
+      };
+
+      // 处理创建会话消息
+      await mockConnection.handleMessage?.(JSON.stringify(createMessage));
+      
+      // 验证会话创建
+      expect(terminalService.hasSession('integration-test-session')).toBe(true);
+      const session = terminalService.getSession('integration-test-session');
+      expect(session).toBeDefined();
+      expect(session.size).toEqual({ cols: 80, rows: 24 });
+
+      // 2. 发送命令到终端
+      const dataMessage = {
+        type: 'terminal.data',
+        data: 'echo "Hello, World!"\n'
+      };
+
+      await mockConnection.handleMessage?.(JSON.stringify(dataMessage));
+      
+      // 验证数据发送
+      expect(session.write).toHaveBeenCalledWith('echo "Hello, World!"\n');
+
+      // 3. 调整终端大小
+      const resizeMessage = {
+        type: 'terminal.resize',
+        cols: 120,
+        rows: 30
+      };
+
+      await mockConnection.handleMessage?.(JSON.stringify(resizeMessage));
+      
+      // 验证大小调整
+      expect(session.resize).toHaveBeenCalledWith(120, 30);
+
+      // 4. 关闭终端会话
+      const closeMessage = {
+        type: 'terminal.close'
+      };
+
+      await mockConnection.handleMessage?.(JSON.stringify(closeMessage));
+      
+      // 验证会话关闭
+      expect(terminalService.hasSession('integration-test-session')).toBe(false);
+    }, 15000);
+
+    it('应该处理多个并发终端会话', async () => {
+      await webSocketService.start();
+      
+      // 创建多个客户端连接
+      const clients = [];
+      for (let i = 0; i < 3; i++) {
+        const client = {
+          clientId: `test-client-${i}`,
+          sessionId: null,
+          ws: {
+            readyState: 1,
+            send: vi.fn(),
+            close: vi.fn(),
+            on: vi.fn()
+          },
+          send: vi.fn(),
+          sendError: vi.fn()
+        };
+        clients.push(client);
+        webSocketService.connections.set(client.clientId, client);
+      }
+
+      // 为每个客户端创建会话
+      const sessions = [];
+      for (let i = 0; i < clients.length; i++) {
+        const createMessage = {
+          type: 'terminal.create',
+          sessionId: `session-${i}`,
+          size: { cols: 80, rows: 24 }
+        };
+
+        await clients[i].handleMessage?.(JSON.stringify(createMessage));
+        sessions.push(`session-${i}`);
+      }
+
+      // 验证所有会话都已创建
+      expect(terminalService.getAllSessions()).toHaveLength(3);
+      
+      // 并发发送命令
+      const commands = ['echo "test1"', 'echo "test2"', 'echo "test3"'];
+      const promises = clients.map((client, index) => {
+        const dataMessage = {
+          type: 'terminal.data',
+          data: `${commands[index]}\n`
+        };
+        return client.handleMessage?.(JSON.stringify(dataMessage));
+      });
+
+      await Promise.all(promises);
+
+      // 验证所有命令都已发送
+      for (const sessionId of sessions) {
+        const session = terminalService.getSession(sessionId);
+        expect(session.write).toHaveBeenCalled();
+      }
+
+      // 清理所有会话
+      for (const client of clients) {
+        const closeMessage = { type: 'terminal.close' };
+        await client.handleMessage?.(JSON.stringify(closeMessage));
+      }
+
+      expect(terminalService.getAllSessions()).toHaveLength(0);
+    }, 20000);
+  });
+
+  describe('错误处理和恢复', () => {
+    it('应该处理终端会话创建失败', async () => {
+      await webSocketService.start();
+      
+      const mockConnection = {
+        clientId: 'error-test-client',
+        ws: {
+          readyState: 1,
+          send: vi.fn(),
+          close: vi.fn(),
+          on: vi.fn()
+        },
+        send: vi.fn(),
+        sendError: vi.fn()
+      };
+
+      webSocketService.connections.set(mockConnection.clientId, mockConnection);
+
+      // 尝试创建无效的会话（使用无效的工作目录）
+      const createMessage = {
+        type: 'terminal.create',
+        sessionId: 'invalid-session',
+        workingDirectory: '/invalid/directory/that/does/not/exist'
+      };
+
+      await mockConnection.handleMessage?.(JSON.stringify(createMessage));
+      
+      // 验证错误消息已发送
+      expect(mockConnection.sendError).toHaveBeenCalled();
+    });
+
+    it('应该处理WebSocket连接中断', async () => {
+      await webSocketService.start();
+      
+      // 创建一个会话
+      const session = await terminalService.createSession();
+      expect(session).toBeDefined();
+
+      // 模拟连接断开
+      const mockConnection = {
+        clientId: 'disconnect-test-client',
+        sessionId: session.id,
+        ws: {
+          readyState: 1,
+          send: vi.fn(),
+          close: vi.fn(),
+          on: vi.fn()
+        }
+      };
+
+      webSocketService.connections.set(mockConnection.clientId, mockConnection);
+
+      // 触发连接关闭处理
+      mockConnection.ws.readyState = 3; // WebSocket.CLOSED
+      mockConnection.handleClose?.(1000, 'Normal closure');
+
+      // 验证会话已被清理
+      setTimeout(() => {
+        expect(terminalService.hasSession(session.id)).toBe(false);
+      }, 100);
+    });
+  });
+
+  describe('性能和资源管理', () => {
+    it('应该限制最大并发会话数', async () => {
+      // 创建有限制配置的服务
+      const limitedService = new (await import('../../services/TerminalService.js')).TerminalService({
+        maxSessions: 2
+      });
+
+      // 创建最大数量的会话
+      await limitedService.createSession();
+      await limitedService.createSession();
+
+      // 尝试创建超出限制的会话
+      await expect(limitedService.createSession()).rejects.toThrow('Maximum sessions limit reached');
+
+      await limitedService.shutdown();
+    });
+
+    it('应该清理超时的会话', async () => {
+      const timeoutService = new (await import('../../services/TerminalService.js')).TerminalService({
+        timeout: 100 // 100ms超时
+      });
+
+      // 创建会话
+      const session = await timeoutService.createSession();
+      expect(session).toBeDefined();
+
+      // 手动设置会话为非活跃状态
+      session.lastActivity = new Date(Date.now() - 200); // 超过超时时间
+
+      // 手动触发清理
+      timeoutService.cleanupInactiveSessions();
+
+      // 验证会话已被清理
+      expect(timeoutService.getAllSessions()).toHaveLength(0);
+
+      await timeoutService.shutdown();
+    });
+  });
+
+  describe('跨平台兼容性', () => {
+    it('应该在不同平台上创建正确的Shell命令', async () => {
+      const platform = process.platform;
+      
+      // 创建会话
+      const session = await terminalService.createSession();
+      
+      // 验证Shell命令
+      const expectedShell = platform === 'win32' 
+        ? process.env.COMSPEC || 'cmd.exe'
+        : process.env.SHELL || '/bin/bash';
+      
+      expect(session.shell).toContain(expectedShell.split('/').pop() || expectedShell.split('\\').pop());
+      
+      await terminalService.removeSession(session.id);
+    });
+
+    it('应该执行跨平台命令', async () => {
+      // 测试基本命令
+      const result = await terminalService.executeCommand('echo "cross-platform test"');
+      
+      expect(result).toBeDefined();
+      expect(typeof result.exitCode).toBe('number');
+      expect(result.stdout).toContain('cross-platform test');
+    });
+  });
+
+  describe('安全性', () => {
+    it('应该限制命令执行权限', async () => {
+      // 尝试执行危险命令（应该被限制或失败）
+      const dangerousCommands = [
+        'rm -rf /',
+        'format c:',
+        'sudo rm -rf /'
+      ];
+
+      for (const command of dangerousCommands) {
+        // 这些命令应该失败或被阻止
+        try {
+          const result = await terminalService.executeCommand(command);
+          // 如果没有抛出错误，至少应该有非零退出码
+          expect(result.exitCode).not.toBe(0);
+        } catch (error) {
+          // 或者应该抛出权限错误
+          expect(error.message).toContain('permission') || 
+                   expect(error.message).toContain('denied') ||
+                   expect(error.message).toContain('forbidden');
+        }
+      }
+    });
+
+    it('应该限制文件系统访问', async () => {
+      // 尝试访问系统敏感目录
+      const sensitivePaths = [
+        '/etc/passwd',
+        'C:\\Windows\\System32\\config',
+        '/etc/shadow'
+      ];
+
+      for (const path of sensitivePaths) {
+        try {
+          const result = await terminalService.executeCommand(`cat ${path}`);
+          // 如果成功访问，应该返回空或权限错误
+          expect(result.exitCode).not.toBe(0);
+        } catch (error) {
+          // 应该抛出权限错误
+          expect(error.message).toContain('permission') || 
+                   expect(error.message).toContain('denied');
+        }
+      }
+    });
+  });
+});

package/packages/server/tests/integration/tools.test.js

@@ -0,0 +1,264 @@
+/**
+ * 工具系统测试文件
+ * 
+ * 用于验证工具加载、工具管理等功能是否正常工作
+ */
+
+import { toolLoaderService } from './tool-loader.service.js';
+import { handleToolM } from './tool-manager.handler.js';
+import { logger } from '../utils/logger.js';
+
+// 测试工具加载服务
+async function testToolLoader() {
+  console.log('\n========== 测试工具加载服务 ==========\n');
+  
+  try {
+    // 初始化工具加载器
+    console.log('1. 初始化工具加载器...');
+    await toolLoaderService.initialize();
+    console.log('✓ 工具加载器初始化成功');
+    
+    // 获取所有工具列表
+    console.log('\n2. 获取所有工具列表...');
+    const tools = toolLoaderService.getAllTools();
+    console.log(`✓ 共加载 ${tools.length} 个工具:`);
+    tools.forEach(tool => {
+      console.log(`  - ${tool.name}: ${tool.metadata.description || '无描述'}`);
+    });
+    
+    // 检查 filesystem 工具是否存在
+    console.log('\n3. 检查 filesystem 工具是否存在...');
+    const hasFilesystem = toolLoaderService.hasTool('filesystem');
+    if (hasFilesystem) {
+      console.log('✓ filesystem 工具已加载');
+      
+      // 获取 filesystem 工具详情
+      const filesystemTool = toolLoaderService.getTool('filesystem');
+      console.log(`  - 元数据:`, filesystemTool.metadata);
+    } else {
+      console.log('✗ filesystem 工具未找到');
+    }
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 测试手册模式
+async function testManualMode() {
+  console.log('\n========== 测试手册模式 (manual) ==========\n');
+  
+  try {
+    const yamlInput = `tool: tool://filesystem
+mode: manual`;
+    
+    console.log('YAML 输入:');
+    console.log(yamlInput);
+    console.log('\n执行 handleToolM...');
+    
+    const result = await handleToolM({ yaml: yamlInput });
+    
+    console.log('\n✓ 手册模式执行成功');
+    console.log('返回结果类型:', result.content[0].type);
+    console.log('手册内容长度:', result.content[0].text.length, '字符');
+    console.log('\n手册内容预览（前 500 字符）:');
+    console.log(result.content[0].text.substring(0, 500));
+    console.log('...\n');
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 测试执行模式
+async function testExecuteMode() {
+  console.log('\n========== 测试执行模式 (execute) ==========\n');
+  
+  try {
+    const yamlInput = `tool: tool://filesystem
+mode: execute
+parameters:
+  method: list_allowed_directories`;
+    
+    console.log('YAML 输入:');
+    console.log(yamlInput);
+    console.log('\n执行 handleToolM...');
+    
+    const result = await handleToolM({ yaml: yamlInput });
+    
+    console.log('\n✓ 执行模式测试成功');
+    console.log('返回结果:');
+    console.log(result.content[0].text);
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 测试配置模式
+async function testConfigureMode() {
+  console.log('\n========== 测试配置模式 (configure) ==========\n');
+  
+  try {
+    const yamlInput = `tool: tool://filesystem
+mode: configure
+parameters:
+  ALLOWED_DIRECTORIES: '["~/.prompt-manager", "/tmp"]'`;
+    
+    console.log('YAML 输入:');
+    console.log(yamlInput);
+    console.log('\n执行 handleToolM...');
+    
+    const result = await handleToolM({ yaml: yamlInput });
+    
+    console.log('\n✓ 配置模式测试成功');
+    console.log('返回结果:');
+    console.log(result.content[0].text);
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 测试日志模式
+async function testLogMode() {
+  console.log('\n========== 测试日志模式 (log) ==========\n');
+  
+  try {
+    const yamlInput = `tool: tool://filesystem
+mode: log
+parameters:
+  action: tail
+  lines: 50`;
+    
+    console.log('YAML 输入:');
+    console.log(yamlInput);
+    console.log('\n执行 handleToolM...');
+    
+    const result = await handleToolM({ yaml: yamlInput });
+    
+    console.log('\n✓ 日志模式测试成功');
+    console.log('返回结果:');
+    console.log(result.content[0].text);
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 测试错误处理
+async function testErrorHandling() {
+  console.log('\n========== 测试错误处理 ==========\n');
+  
+  try {
+    console.log('1. 测试不存在的工具...');
+    try {
+      const yamlInput = `tool: tool://nonexistent
+mode: execute`;
+      await handleToolM({ yaml: yamlInput });
+      console.log('✗ 应该抛出错误但没有');
+      return false;
+    } catch (error) {
+      console.log('✓ 正确抛出错误:', error.message.split('\n')[0]);
+    }
+    
+    console.log('\n2. 测试缺少必需参数...');
+    try {
+      await handleToolM({});
+      console.log('✗ 应该抛出错误但没有');
+      return false;
+    } catch (error) {
+      console.log('✓ 正确抛出错误:', error.message);
+    }
+    
+    console.log('\n3. 测试无效的工具格式...');
+    try {
+      const yamlInput = `tool: filesystem
+mode: execute`;
+      await handleToolM({ yaml: yamlInput });
+      console.log('✗ 应该抛出错误但没有');
+      return false;
+    } catch (error) {
+      console.log('✓ 正确抛出错误:', error.message.split('\n')[0]);
+    }
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 主测试函数
+async function runAllTests() {
+  console.log('\n');
+  console.log('╔════════════════════════════════════════════════╗');
+  console.log('║     Prompt Manager 工具系统测试套件           ║');
+  console.log('╚════════════════════════════════════════════════╝');
+  
+  const results = [];
+  
+  // 运行所有测试
+  results.push({ name: '工具加载服务', passed: await testToolLoader() });
+  results.push({ name: '手册模式', passed: await testManualMode() });
+  results.push({ name: '执行模式', passed: await testExecuteMode() });
+  results.push({ name: '配置模式', passed: await testConfigureMode() });
+  results.push({ name: '日志模式', passed: await testLogMode() });
+  results.push({ name: '错误处理', passed: await testErrorHandling() });
+  
+  // 输出测试总结
+  console.log('\n');
+  console.log('╔════════════════════════════════════════════════╗');
+  console.log('║              测试结果总结                      ║');
+  console.log('╚════════════════════════════════════════════════╝');
+  console.log('\n');
+  
+  const passed = results.filter(r => r.passed).length;
+  const failed = results.filter(r => !r.passed).length;
+  
+  results.forEach(result => {
+    const status = result.passed ? '✓ PASS' : '✗ FAIL';
+    console.log(`${status} - ${result.name}`);
+  });
+  
+  console.log('\n');
+  console.log(`总计: ${results.length} 个测试`);
+  console.log(`通过: ${passed} 个`);
+  console.log(`失败: ${failed} 个`);
+  console.log('\n');
+  
+  if (failed === 0) {
+    console.log('🎉 所有测试通过！工具系统运行正常。');
+  } else {
+    console.log('⚠️  部分测试失败，请检查错误信息。');
+  }
+  
+  return failed === 0;
+}
+
+// 运行测试
+runAllTests()
+  .then(success => {
+    process.exit(success ? 0 : 1);
+  })
+  .catch(error => {
+    console.error('测试运行失败:', error);
+    process.exit(1);
+  });
+

package/packages/server/tests/setup.js

@@ -0,0 +1,45 @@
+/**
+ * Vitest 测试设置文件
+ */
+
+import { vi } from 'vitest';
+
+// Mock node-pty 模块
+vi.mock('node-pty', () => {
+  const mockPty = {
+    on: vi.fn(),
+    write: vi.fn(),
+    resize: vi.fn(),
+    kill: vi.fn(),
+    pid: 12345,
+    cols: 80,
+    rows: 24
+  };
+
+  return {
+    default: {
+      spawn: vi.fn(() => mockPty)
+    },
+    spawn: vi.fn(() => mockPty)
+  };
+});
+
+// Mock fs-extra 的某些方法（如果需要）
+vi.mock('fs-extra', async () => {
+  const actual = await vi.importActual('fs-extra');
+  return {
+    ...actual,
+    // 可以在这里添加特定的mock
+  };
+});
+
+// 全局测试设置
+global.console = {
+  ...console,
+  // 在测试中减少日志输出
+  log: vi.fn(),
+  debug: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+};