@becrafter/prompt-manager 0.1.17 → 0.1.20

package/packages/server/tests/e2e/terminal-e2e.test.js

@@ -1,315 +0,0 @@
-/**
- * 终端E2E测试
- */
-
-import { test, expect } from '@playwright/test';
-
-test.describe('终端功能E2E测试', () => {
-  test.beforeEach(async ({ page }) => {
-    // 导航到管理员界面
-    await page.goto('/admin/');
-    
-    // 等待页面加载完成
-    await page.waitForLoadState('networkidle');
-    
-    // 点击终端导航
-    await page.click('[data-nav="terminal"]');
-    
-    // 等待终端区域显示
-    await page.waitForSelector('#terminalArea', { state: 'visible' });
-  });
-
-  test('应该显示终端界面', async ({ page }) => {
-    // 验证终端区域存在
-    await expect(page.locator('#terminalArea')).toBeVisible();
-    
-    // 验证终端标题
-    await expect(page.locator('.terminal-title')).toContainText('终端');
-    
-    // 验证终端内容区域
-    await expect(page.locator('.terminal-content')).toBeVisible();
-  });
-
-  test('应该建立WebSocket连接', async ({ page }) => {
-    // 等待WebSocket连接建立
-    await page.waitForSelector('.status-indicator.connected', { timeout: 10000 });
-    
-    // 验证连接状态显示
-    await expect(page.locator('.status-text')).toContainText('已连接');
-  });
-
-  test('应该支持基本命令执行', async ({ page }) => {
-    // 等待终端初始化
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 10000 });
-    
-    // 模拟输入命令
-    await page.keyboard.type('echo "Hello, E2E Test!"');
-    await page.keyboard.press('Enter');
-    
-    // 等待命令执行结果
-    await page.waitForTimeout(2000);
-    
-    // 验证命令输出（这里需要根据实际终端实现调整）
-    // 由于使用xterm.js，我们需要检查终端内容
-    const terminalContent = await page.locator('.xterm-screen').textContent();
-    expect(terminalContent).toContain('Hello, E2E Test!');
-  });
-
-  test('应该支持多个命令执行', async ({ page }) => {
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 10000 });
-    
-    // 执行多个命令
-    const commands = [
-      'pwd',
-      'ls -la',
-      'whoami'
-    ];
-    
-    for (const command of commands) {
-      await page.keyboard.type(command);
-      await page.keyboard.press('Enter');
-      await page.waitForTimeout(1000);
-    }
-    
-    // 验证所有命令都已执行
-    const terminalContent = await page.locator('.xterm-screen').textContent();
-    
-    // 验证命令历史
-    for (const command of commands) {
-      expect(terminalContent).toContain(command);
-    }
-  });
-
-  test('应该支持终端大小调整', async ({ page }) => {
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 10000 });
-    
-    // 获取初始终端大小
-    const initialTerminal = page.locator('.xterm-screen');
-    const initialBounds = await initialTerminal.boundingBox();
-    
-    // 调整浏览器窗口大小
-    await page.setViewportSize({ width: 1200, height: 800 });
-    
-    // 等待终端适应新大小
-    await page.waitForTimeout(1000);
-    
-    // 验证终端已调整大小
-    const adjustedTerminal = page.locator('.xterm-screen');
-    const adjustedBounds = await adjustedTerminal.boundingBox();
-    
-    // 终端应该适应新的窗口大小
-    expect(adjustedBounds.width).toBeGreaterThan(initialBounds.width);
-  });
-
-  test('应该支持主题切换', async ({ page }) => {
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 10000 });
-    
-    // 获取初始主题
-    const terminal = page.locator('.xterm');
-    const initialBackground = await terminal.evaluate(el => 
-      getComputedStyle(el).getPropertyValue('background-color')
-    );
-    
-    // 点击主题切换按钮
-    await page.click('#themeBtn');
-    
-    // 等待主题切换
-    await page.waitForTimeout(500);
-    
-    // 验证主题已改变
-    const newBackground = await terminal.evaluate(el => 
-      getComputedStyle(el).getPropertyValue('background-color')
-    );
-    
-    expect(newBackground).not.toBe(initialBackground);
-  });
-
-  test('应该支持搜索功能', async ({ page }) => {
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 10000 });
-    
-    // 输入一些文本
-    await page.keyboard.type('echo "search test"');
-    await page.keyboard.press('Enter');
-    await page.waitForTimeout(1000);
-    
-    // 点击搜索按钮
-    await page.click('#searchBtn');
-    
-    // 输入搜索词
-    const searchInput = await page.locator('.xterm-search input');
-    await searchInput.fill('search test');
-    
-    // 验证搜索功能（这里需要根据实际搜索实现调整）
-    expect(searchInput).toHaveValue('search test');
-  });
-
-  test('应该支持清除功能', async ({ page }) => {
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 10000 });
-    
-    // 输入一些内容
-    await page.keyboard.type('echo "clear test"');
-    await page.keyboard.press('Enter');
-    await page.waitForTimeout(1000);
-    
-    // 获取清除前的内容
-    const contentBefore = await page.locator('.xterm-screen').textContent();
-    expect(contentBefore).toContain('clear test');
-    
-    // 点击清除按钮
-    await page.click('#clearBtn');
-    
-    // 等待清除完成
-    await page.waitForTimeout(500);
-    
-    // 验证内容已清除（xterm.js清除后可能只保留提示符）
-    const contentAfter = await page.locator('.xterm-screen').textContent();
-    expect(contentAfter).not.toContain('clear test');
-  });
-
-  test('应该支持重连功能', async ({ page }) => {
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 10000 });
-    
-    // 等待连接建立
-    await page.waitForSelector('.status-indicator.connected');
-    
-    // 点击重连按钮
-    await page.click('#reconnectBtn');
-    
-    // 等待重连完成
-    await page.waitForSelector('.status-indicator.connected', { timeout: 10000 });
-    
-    // 验证连接状态
-    await expect(page.locator('.status-text')).toContainText('已连接');
-  });
-
-  test('应该处理连接断开', async ({ page }) => {
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 10000 });
-    
-    // 模拟WebSocket断开（通过页面上下文）
-    await page.evaluate(() => {
-      // 查找WebSocket连接并关闭
-      const ws = window.terminalComponent?.websocket;
-      if (ws) {
-        ws.close();
-      }
-    });
-    
-    // 等待断开状态
-    await page.waitForSelector('.status-indicator.disconnected', { timeout: 5000 });
-    
-    // 验证断开状态显示
-    await expect(page.locator('.status-text')).toContainText('未连接');
-    
-    // 等待自动重连
-    await page.waitForSelector('.status-indicator.connected', { timeout: 15000 });
-    
-    // 验证重连成功
-    await expect(page.locator('.status-text')).toContainText('已连接');
-  });
-
-  test('应该支持键盘快捷键', async ({ page }) => {
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 10000 });
-    
-    // 测试Ctrl+C中断
-    await page.keyboard.type('sleep 10');
-    await page.keyboard.press('Enter');
-    await page.waitForTimeout(500);
-    
-    // 发送中断信号
-    await page.keyboard.press('Control+c');
-    await page.waitForTimeout(1000);
-    
-    // 验证命令被中断（终端应该回到提示符状态）
-    // 这里需要根据实际终端实现来验证
-    
-    // 测试Ctrl+V粘贴
-    await page.evaluate(() => {
-      navigator.clipboard.writeText('echo "paste test"');
-    });
-    
-    await page.keyboard.press('Control+v');
-    await page.keyboard.press('Enter');
-    await page.waitForTimeout(1000);
-    
-    // 验证粘贴内容被执行
-    const terminalContent = await page.locator('.xterm-screen').textContent();
-    expect(terminalContent).toContain('paste test');
-  });
-});
-
-test.describe('终端性能测试', () => {
-  test('应该在合理时间内建立连接', async ({ page }) => {
-    const startTime = Date.now();
-    
-    await page.goto('/admin/');
-    await page.click('[data-nav="terminal"]');
-    await page.waitForSelector('.status-indicator.connected', { timeout: 10000 });
-    
-    const connectionTime = Date.now() - startTime;
-    expect(connectionTime).toBeLessThan(5000); // 应该在5秒内连接
-  });
-
-  test('应该处理大量输出', async ({ page }) => {
-    await page.goto('/admin/');
-    await page.click('[data-nav="terminal"]');
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 10000 });
-    
-    // 生成大量输出的命令
-    await page.keyboard.type('for i in {1..100}; do echo "Line $i"; done');
-    await page.keyboard.press('Enter');
-    
-    // 等待命令执行完成
-    await page.waitForTimeout(5000);
-    
-    // 验证终端仍然响应
-    await page.keyboard.type('echo "Still responsive"');
-    await page.keyboard.press('Enter');
-    await page.waitForTimeout(1000);
-    
-    const terminalContent = await page.locator('.xterm-screen').textContent();
-    expect(terminalContent).toContain('Still responsive');
-  });
-});
-
-test.describe('跨浏览器兼容性', () => {
-  ['chromium', 'firefox', 'webkit'].forEach(browserName => {
-    test(`${browserName}: 应该正常工作`, async ({ page, browserName: currentBrowser }) => {
-      test.skip(currentBrowser !== browserName, '跳过其他浏览器');
-      
-      await page.goto('/admin/');
-      await page.click('[data-nav="terminal"]');
-      await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 15000 });
-      
-      // 基本功能测试
-      await page.keyboard.type('echo "Browser: $browserName"'.replace('$browserName', browserName));
-      await page.keyboard.press('Enter');
-      await page.waitForTimeout(2000);
-      
-      const terminalContent = await page.locator('.xterm-screen').textContent();
-      expect(terminalContent).toContain(browserName);
-    });
-  });
-});
-
-test.describe('移动端适配', () => {
-  test('应该在移动设备上正常显示', async ({ page }) => {
-    // 设置移动设备视口
-    await page.setViewportSize({ width: 375, height: 667 });
-    
-    await page.goto('/admin/');
-    await page.click('[data-nav="terminal"]');
-    await page.waitForSelector('.xterm-container', { state: 'visible', timeout: 15000 });
-    
-    // 验证移动端样式
-    const toolbar = page.locator('.terminal-toolbar');
-    await expect(toolbar).toBeVisible();
-    
-    // 验证终端仍然可用
-    await page.keyboard.type('echo "Mobile test"');
-    await page.keyboard.press('Enter');
-    await page.waitForTimeout(2000);
-    
-    const terminalContent = await page.locator('.xterm-screen').textContent();
-    expect(terminalContent).toContain('Mobile test');
-  });
-});

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

@@ -1,372 +0,0 @@
-/**
- * 终端和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');
-        }
-      }
-    });
-  });
-});