@becrafter/prompt-manager 0.1.14 → 0.1.16

package/packages/server/services/TerminalService.js

@@ -7,6 +7,7 @@
 
 import { spawn } from 'child_process';
 import { randomUUID } from 'crypto';
+import fs from 'fs';
 import { logger } from '../utils/logger.js';
 import path from 'path';
 import os from 'os';
@@ -68,7 +69,7 @@ class TerminalSession {
       case 'win32':
         return process.env.COMSPEC || 'cmd.exe';
       case 'darwin':
-        return process.env.SHELL || '/bin/bash';
+        return process.env.SHELL || '/bin/zsh';
       case 'linux':
         return process.env.SHELL || '/bin/bash';
       default:
@@ -82,15 +83,34 @@ class TerminalSession {
   setupPtyEvents() {
     if (!this.pty) return;
 
-    this.pty.on('data', (data) => {
-      this.lastActivity = new Date();
-      this.emit('data', data);
-    });
+    // 对于正常的PTY进程
+    if (!this.pty.isFallback) {
+      this.pty.on('data', (data) => {
+        this.lastActivity = new Date();
+        this.emit('data', data);
+      });
 
-    this.pty.on('exit', (exitCode, signal) => {
-      this.isActive = false;
-      this.emit('exit', { exitCode, signal });
-    });
+      this.pty.on('exit', (exitCode, signal) => {
+        this.isActive = false;
+        this.emit('exit', { exitCode, signal });
+      });
+    } else {
+      // 对于fallback PTY进程（child_process.spawn）
+      this.pty.process.stdout?.on('data', (data) => {
+        this.lastActivity = new Date();
+        this.emit('data', data);
+      });
+
+      this.pty.process.stderr?.on('data', (data) => {
+        this.lastActivity = new Date();
+        this.emit('data', data);
+      });
+
+      this.pty.process.on('exit', (exitCode, signal) => {
+        this.isActive = false;
+        this.emit('exit', { exitCode, signal });
+      });
+    }
   }
 
   /**
@@ -100,7 +120,14 @@ class TerminalSession {
     if (!this.isActive || !this.pty) {
       throw new Error('Terminal session is not active');
     }
-    this.pty.write(data);
+
+    if (this.pty.isFallback) {
+      // fallback PTY使用child_process
+      this.pty.process.stdin?.write(data);
+    } else {
+      // 正常PTY
+      this.pty.write(data);
+    }
     this.lastActivity = new Date();
   }
 
@@ -111,7 +138,14 @@ class TerminalSession {
     if (!this.isActive || !this.pty) {
       throw new Error('Terminal session is not active');
     }
-    this.pty.resize(cols, rows);
+
+    if (this.pty.isFallback) {
+      // fallback PTY不支持resize，记录日志
+      logger.debug(`Fallback PTY resize requested: ${cols}x${rows} (not supported)`);
+    } else {
+      // 正常PTY支持resize
+      this.pty.resize(cols, rows);
+    }
     this.size = { cols, rows };
   }
 
@@ -120,7 +154,13 @@ class TerminalSession {
    */
   terminate() {
     if (this.pty) {
-      this.pty.kill();
+      if (this.pty.isFallback) {
+        // fallback PTY使用child_process
+        this.pty.process.kill();
+      } else {
+        // 正常PTY
+        this.pty.kill();
+      }
     }
     this.isActive = false;
   }
@@ -249,20 +289,122 @@ export class TerminalService {
    * 创建PTY进程
    */
   async createPtyProcess(options) {
-    const shell = options.shell || this.getDefaultShellForPlatform();
-    const args = this.getShellArgs(shell);
     const cwd = options.workingDirectory || os.homedir();
     const env = { ...process.env, ...options.environment };
+    const shells = this.getShellCandidates(options.shell);
+    let lastError = null;
+
+    // 在macOS上确保PATH包含常用目录
+    if (process.platform === 'darwin') {
+      const defaultPath = '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin';
+      if (!env.PATH || env.PATH === '') {
+        env.PATH = defaultPath;
+      } else if (!env.PATH.includes('/usr/local/bin')) {
+        env.PATH = `${env.PATH}:${defaultPath}`;
+      }
+      logger.debug(`macOS PATH configured: ${env.PATH}`);
+    }
+
+    for (const candidate of shells) {
+      if (!candidate) continue;
+      const resolvedShell = this.resolveShellPath(candidate);
+      if (!resolvedShell) {
+        logger.debug(`Shell not found on system: ${candidate}`);
+        continue;
+      }
+
+      const args = this.getShellArgs(resolvedShell);
+      logger.debug(`Creating PTY with shell: ${resolvedShell}, args: ${args.join(' ')}, cwd: ${cwd}`);
 
-    logger.debug(`Creating PTY with shell: ${shell}, args: ${args.join(' ')}, cwd: ${cwd}`);
+      try {
+        const ptyProcess = pty.default.spawn(resolvedShell, args, {
+          name: 'xterm-color',
+          cols: options.size.cols,
+          rows: options.size.rows,
+          cwd: cwd,
+          env: env
+        });
 
-    return pty.default.spawn(shell, args, {
-      name: 'xterm-color',
+        // 添加PTY进程的事件监听，用于调试
+        ptyProcess.on('data', (data) => {
+          logger.debug(`PTY data received: ${data.length} bytes`);
+        });
+
+        ptyProcess.on('exit', (code, signal) => {
+          logger.debug(`PTY process exited: code=${code}, signal=${signal}`);
+        });
+
+        return ptyProcess;
+      } catch (error) {
+        lastError = error;
+        logger.warn(`Failed to spawn shell ${resolvedShell}: ${error.message}`);
+
+        // 如果是posix_spawnp失败，尝试备用方案
+        if (error.message.includes('posix_spawnp')) {
+          logger.warn('posix_spawnp failed, trying alternative approach...');
+          try {
+            // 尝试使用child_process.spawn作为备用方案
+            const { spawn } = await import('child_process');
+            const child = spawn(resolvedShell, args, {
+              cwd: cwd,
+              env: env,
+              stdio: ['pipe', 'pipe', 'pipe'],
+              shell: false
+            });
+
+            // 包装child_process.spawn的结果以兼容PTY接口
+            return this.createFallbackPtyProcess(child, options);
+          } catch (fallbackError) {
+            logger.warn(`Fallback spawn also failed: ${fallbackError.message}`);
+          }
+        }
+      }
+    }
+
+    throw lastError || new Error('Unable to create PTY session: no suitable shell found');
+  }
+
+  /**
+   * 创建备用PTY进程（使用child_process.spawn）
+   */
+  createFallbackPtyProcess(childProcess, options) {
+    // 创建一个兼容PTY接口的对象
+    const fallbackPty = {
+      pid: childProcess.pid,
       cols: options.size.cols,
       rows: options.size.rows,
-      cwd: cwd,
-      env: env
-    });
+      process: childProcess,
+      isFallback: true,
+
+      write(data) {
+        if (childProcess.stdin) {
+          childProcess.stdin.write(data);
+        }
+      },
+
+      resize(cols, rows) {
+        this.cols = cols;
+        this.rows = rows;
+        // child_process不支持resize，记录日志
+        logger.debug(`Fallback PTY resize requested: ${cols}x${rows} (not supported)`);
+      },
+
+      kill(signal = 'SIGTERM') {
+        childProcess.kill(signal);
+      },
+
+      on(event, callback) {
+        if (event === 'data') {
+          childProcess.stdout?.on('data', callback);
+          childProcess.stderr?.on('data', callback);
+        } else if (event === 'exit') {
+          childProcess.on('exit', callback);
+        }
+      }
+    };
+
+    logger.info('Created fallback PTY process (limited functionality)');
+    return fallbackPty;
   }
 
   /**
@@ -273,7 +415,8 @@ export class TerminalService {
       case 'win32':
         return process.env.COMSPEC || 'cmd.exe';
       case 'darwin':
-        return process.env.SHELL || '/bin/bash';
+        // 在 macOS 上优先使用用户的 SHELL 环境变量
+        return process.env.SHELL || '/bin/zsh';
       case 'linux':
         return process.env.SHELL || '/bin/bash';
       default:
@@ -291,9 +434,63 @@ export class TerminalService {
       }
       return ['/c'];
     }
+
+    // 某些精简 shell（如 /bin/sh）不支持 -l
+    if (shell.endsWith('/sh')) {
+      return ['-i'];
+    }
+
     return ['-l'];
   }
 
+  /**
+   * 获取 shell 候选列表（按优先级）
+   */
+  getShellCandidates(preferredShell) {
+    const candidates = [];
+
+    if (preferredShell) candidates.push(preferredShell);
+    if (process.env.SHELL) candidates.push(process.env.SHELL);
+
+    if (process.platform === 'darwin') {
+      candidates.push('/bin/zsh', '/bin/bash', '/bin/sh');
+    } else if (process.platform === 'linux') {
+      candidates.push('/bin/bash', '/bin/sh');
+    } else if (process.platform === 'win32') {
+      candidates.push(process.env.COMSPEC || 'cmd.exe');
+    } else {
+      candidates.push('/bin/sh');
+    }
+
+    return [...new Set(candidates)];
+  }
+
+  /**
+   * 确保 shell 路径在当前系统存在
+   */
+  resolveShellPath(shellPath) {
+    // 绝对路径直接检查
+    if (shellPath.startsWith('/')) {
+      return fs.existsSync(shellPath) ? shellPath : null;
+    }
+
+    // Windows 可执行文件
+    if (process.platform === 'win32') {
+      return shellPath;
+    }
+
+    // 如果是相对路径，尝试在常见目录查找
+    const searchPaths = ['/bin', '/usr/bin', '/usr/local/bin'];
+    for (const base of searchPaths) {
+      const fullPath = path.join(base, shellPath);
+      if (fs.existsSync(fullPath)) {
+        return fullPath;
+      }
+    }
+
+    return null;
+  }
+
   /**
    * 获取会话
    */

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

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