zen-gitsync 2.1.26 → 2.1.29

package/src/ui/server/index.js

@@ -2,7 +2,7 @@ import express from 'express';
 import { createServer } from 'http';
 import { fileURLToPath } from 'url';
 import path from 'path';
-import { execGitCommand } from '../../utils/index.js';
+import { execGitCommand, getCommandHistory, clearCommandHistory, registerSocketIO } from '../../utils/index.js';
 import open from 'open';
 import config from '../../config.js';
 import chalk from 'chalk';
@@ -23,11 +23,45 @@ let debounceTimer = null;
 // 防抖延迟时间 (毫秒)
 const DEBOUNCE_DELAY = 1000;
 
+// 分支状态缓存
+let branchStatusCache = {
+  currentBranch: null,
+  upstreamBranch: null,
+  lastUpdate: 0,
+  cacheTimeout: 5000 // 5秒缓存
+};
+
+// 当前分支缓存 - 只在特定情况下更新
+let currentBranchCache = {
+  branchName: null,
+  lastUpdate: 0,
+  // 分支名缓存时间更长，因为分支切换不频繁
+  cacheTimeout: 300000 // 5分钟缓存，或者直到主动清除
+};
+
+// 上游分支缓存 - 只在特定情况下更新
+let upstreamBranchCache = {
+  upstreamBranch: null,
+  lastUpdate: 0,
+  // 上游分支缓存时间也较长，因为上游分支设置不频繁
+  cacheTimeout: 300000 // 5分钟缓存，或者直到主动清除
+};
+
+// 推送状态标记 - 用于优化推送后的分支状态查询
+let recentPushStatus = {
+  justPushed: false,
+  pushTime: 0,
+  validDuration: 10000 // 推送后10秒内认为分支状态是同步的
+};
+
 async function startUIServer(noOpen = false, savePort = false) {
   const app = express();
   const httpServer = createServer(app);
   const io = new Server(httpServer);
   
+  // 注册Socket.io实例，用于命令历史通知
+  registerSocketIO(io);
+  
   // 添加全局中间件来解析JSON请求体
   app.use(express.json());
   
@@ -42,14 +76,18 @@ async function startUIServer(noOpen = false, savePort = false) {
   app.use(express.static(path.join(__dirname, '../public')));
   
   // API路由
-  app.get('/api/status', async (req, res) => {
+  // 移除了 /api/status 端点，因为前端只使用 porcelain 格式
+  
+  // Add new endpoint for command history
+  app.get('/api/command-history', async (req, res) => {
     try {
-      const { stdout } = await execGitCommand('git status');
-      res.json({ status: stdout });
+      const history = getCommandHistory();
+      res.json({ success: true, history });
     } catch (error) {
-      res.status(500).json({ error: error.message });
+      res.status(500).json({ success: false, error: error.message });
     }
   });
+  
   app.get('/api/status_porcelain', async (req, res) => {
     try {
       const { stdout } = await execGitCommand('git status --porcelain --untracked-files=all');
@@ -59,42 +97,190 @@ async function startUIServer(noOpen = false, savePort = false) {
     }
   });
   
-  // 获取当前分支
+  // 获取当前分支的优化函数
+  async function getCurrentBranchOptimized(forceRefresh = false) {
+    const now = Date.now();
+
+    // 如果不是强制刷新且缓存有效，使用缓存
+    if (!forceRefresh &&
+        currentBranchCache.branchName &&
+        (now - currentBranchCache.lastUpdate) < currentBranchCache.cacheTimeout) {
+      console.log(`使用缓存的分支名: ${currentBranchCache.branchName}`);
+      return currentBranchCache.branchName;
+    }
+
+    // 缓存失效或强制刷新，重新获取
+    console.log('重新获取当前分支名...');
+    const { stdout } = await execGitCommand('git symbolic-ref --short HEAD');
+    const branchName = stdout.trim();
+
+    // 更新缓存
+    currentBranchCache = {
+      branchName,
+      lastUpdate: now,
+      cacheTimeout: 300000 // 5分钟缓存
+    };
+
+    return branchName;
+  }
+
+  // 获取上游分支的优化函数
+  async function getUpstreamBranchOptimized(forceRefresh = false) {
+    const now = Date.now();
+
+    // 如果不是强制刷新且缓存有效，使用缓存
+    if (!forceRefresh &&
+        upstreamBranchCache.upstreamBranch !== null &&
+        (now - upstreamBranchCache.lastUpdate) < upstreamBranchCache.cacheTimeout) {
+      console.log(`使用缓存的上游分支: ${upstreamBranchCache.upstreamBranch}`);
+      return upstreamBranchCache.upstreamBranch;
+    }
+
+    // 缓存失效或强制刷新，重新获取
+    console.log('重新获取上游分支...');
+    const { stdout: upstreamOutput } = await execGitCommand('git rev-parse --abbrev-ref --symbolic-full-name @{u}', { ignoreError: true });
+    const upstreamBranch = upstreamOutput.trim() || null;
+
+    // 更新缓存
+    upstreamBranchCache = {
+      upstreamBranch,
+      lastUpdate: now,
+      cacheTimeout: 300000 // 5分钟缓存
+    };
+
+    return upstreamBranch;
+  }
+
+  // 清除分支缓存的函数（在分支切换时调用）
+  function clearBranchCache() {
+    console.log('清除分支缓存');
+    currentBranchCache = {
+      branchName: null,
+      lastUpdate: 0,
+      cacheTimeout: 300000
+    };
+    // 清除上游分支缓存
+    upstreamBranchCache = {
+      upstreamBranch: null,
+      lastUpdate: 0,
+      cacheTimeout: 300000
+    };
+    // 同时清除分支状态缓存
+    branchStatusCache = {
+      currentBranch: null,
+      upstreamBranch: null,
+      lastUpdate: 0,
+      cacheTimeout: 5000
+    };
+    // 清除推送状态标记
+    recentPushStatus = {
+      justPushed: false,
+      pushTime: 0,
+      validDuration: 10000
+    };
+  }
+
+  // 获取当前分支 - 使用缓存优化
   app.get('/api/branch', async (req, res) => {
     try {
-      const { stdout } = await execGitCommand('git rev-parse --abbrev-ref HEAD');
-      res.json({ branch: stdout.trim() });
+      const forceRefresh = req.query.force === 'true';
+      const branch = await getCurrentBranchOptimized(forceRefresh);
+      res.json({ branch });
     } catch (error) {
       res.status(500).json({ error: error.message });
     }
   });
 
-  // 获取分支与远程的差异状态（领先/落后提交数）
+  // 获取分支与远程的差异状态（领先/落后提交数）- 优化版本
   app.get('/api/branch-status', async (req, res) => {
     try {
       // 检查当前目录是否是Git仓库
       if (!isGitRepo) {
         return res.json({ hasUpstream: false, ahead: 0, behind: 0 });
       }
-      
-      // 获取当前分支
-      const { stdout: branchOutput } = await execGitCommand('git symbolic-ref --short HEAD');
-      const currentBranch = branchOutput.trim();
-      
-      // 获取上游分支
-      const { stdout: upstreamOutput } = await execGitCommand('git rev-parse --abbrev-ref --symbolic-full-name @{u}', { ignoreError: true });
-      
-      if (!upstreamOutput.trim()) {
-        // 没有上游分支
+
+      const now = Date.now();
+      const forceRefresh = req.query.force === 'true';
+      const refreshCountOnly = req.query.countOnly === 'true'; // 新增：只刷新计数
+
+      // 检查是否刚刚推送过，如果是则直接返回同步状态
+      if (recentPushStatus.justPushed &&
+          (now - recentPushStatus.pushTime) < recentPushStatus.validDuration) {
+        console.log('检测到最近推送过，直接返回同步状态');
+        return res.json({
+          hasUpstream: true,
+          upstreamBranch: branchStatusCache.upstreamBranch || 'origin/main',
+          ahead: 0,
+          behind: 0
+        });
+      }
+
+      // 检查分支信息缓存是否有效
+      const branchInfoCacheValid = branchStatusCache.currentBranch &&
+                                   branchStatusCache.upstreamBranch &&
+                                   (now - branchStatusCache.lastUpdate) < branchStatusCache.cacheTimeout;
+
+      // 如果只需要刷新计数，或者缓存有效且不是强制刷新
+      if ((refreshCountOnly && branchInfoCacheValid) || (!forceRefresh && branchInfoCacheValid)) {
+
+        // 使用缓存的分支信息，只重新计算领先/落后状态
+        const { stdout: aheadBehindOutput } = await execGitCommand(
+          `git rev-list --left-right --count ${branchStatusCache.currentBranch}...${branchStatusCache.upstreamBranch}`
+        );
+        const [ahead, behind] = aheadBehindOutput.trim().split('\t').map(Number);
+
+        console.log(`使用缓存的分支信息: ${branchStatusCache.currentBranch} -> ${branchStatusCache.upstreamBranch} (${refreshCountOnly ? '只刷新计数' : '缓存有效'})`);
+
+        return res.json({
+          hasUpstream: true,
+          upstreamBranch: branchStatusCache.upstreamBranch,
+          ahead,
+          behind
+        });
+      }
+
+      // 缓存失效或强制刷新，重新获取分支信息
+      console.log('重新获取分支信息...');
+
+      // 分支名缓存和分支状态缓存独立工作
+      // 只有在分支状态强制刷新且分支名缓存也失效时，才强制刷新分支名
+      const shouldForceRefreshBranch = forceRefresh &&
+        (!currentBranchCache.branchName ||
+         (Date.now() - currentBranchCache.lastUpdate) >= currentBranchCache.cacheTimeout);
+
+      const currentBranch = await getCurrentBranchOptimized(shouldForceRefreshBranch);
+
+      // 使用优化后的上游分支获取函数
+      // 只有在分支状态强制刷新且上游分支缓存也失效时，才强制刷新上游分支
+      const shouldForceRefreshUpstream = forceRefresh &&
+        (upstreamBranchCache.upstreamBranch === null ||
+         (Date.now() - upstreamBranchCache.lastUpdate) >= upstreamBranchCache.cacheTimeout);
+
+      const upstreamBranch = await getUpstreamBranchOptimized(shouldForceRefreshUpstream);
+
+      if (!upstreamBranch) {
+        // 没有上游分支，清空缓存
+        branchStatusCache = {
+          currentBranch: null,
+          upstreamBranch: null,
+          lastUpdate: 0,
+          cacheTimeout: 5000
+        };
         return res.json({ hasUpstream: false, ahead: 0, behind: 0 });
       }
-      
-      const upstreamBranch = upstreamOutput.trim();
-      
+
+      // 更新缓存
+      branchStatusCache = {
+        currentBranch,
+        upstreamBranch,
+        lastUpdate: now,
+        cacheTimeout: 5000
+      };
+
       // 获取领先/落后提交数
       const { stdout: aheadBehindOutput } = await execGitCommand(`git rev-list --left-right --count ${currentBranch}...${upstreamBranch}`);
       const [ahead, behind] = aheadBehindOutput.trim().split('\t').map(Number);
-      
+
       res.json({
         hasUpstream: true,
         upstreamBranch,
@@ -167,7 +353,10 @@ async function startUIServer(noOpen = false, savePort = false) {
       
       // 切换到新创建的分支
       await execGitCommand(`git checkout ${newBranchName}`);
-      
+
+      // 清除分支缓存，因为分支已切换
+      clearBranchCache();
+
       res.json({ success: true, branch: newBranchName });
     } catch (error) {
       console.error('创建分支失败:', error);
@@ -185,7 +374,10 @@ async function startUIServer(noOpen = false, savePort = false) {
       
       // 执行分支切换
       await execGitCommand(`git checkout ${branch}`);
-      
+
+      // 清除分支缓存，因为分支已切换
+      clearBranchCache();
+
       res.json({ success: true });
     } catch (error) {
       console.error('切换分支失败:', error);
@@ -819,6 +1011,15 @@ async function startUIServer(noOpen = false, savePort = false) {
   app.post('/api/push', async (req, res) => {
     try {
       const { stdout } = await execGitCommand('git push');
+
+      // 推送成功后，设置推送状态标记
+      recentPushStatus = {
+        justPushed: true,
+        pushTime: Date.now(),
+        validDuration: 10000 // 10秒内认为分支状态是同步的
+      };
+
+      console.log('推送成功，已设置推送状态标记');
       res.json({ success: true, message: stdout });
     } catch (error) {
       res.status(500).json({ success: false, error: error.message });
@@ -865,7 +1066,7 @@ async function startUIServer(noOpen = false, savePort = false) {
     try {
       // 获取分页参数
       const page = parseInt(req.query.page) || 1;
-      const limit = parseInt(req.query.limit) || 100;
+      const limit = parseInt(req.query.limit) || 20;
       const skip = (page - 1) * limit;
       
       // 获取筛选参数
@@ -939,40 +1140,16 @@ async function startUIServer(noOpen = false, savePort = false) {
         formatString = '%H%x1E%an%x1E%ae%x1E%ad%x1E%B%x1E%D%x1E%P';
       }
       
-      console.log(`执行Git命令: git log --all --pretty=format:"${formatString}" --date=short ${options}`);
-      
+      console.log(`执行Git命令: git log --all --pretty=format:"${formatString}" --date=format:"%Y-%m-%d %H:%M" ${options}`);
+
       // 使用 git log 命令获取提交历史
       let { stdout: logOutput } = await execGitCommand(
-        `git log --all --pretty=format:"${formatString}" --date=short ${options}`
+        `git log --all --pretty=format:"${formatString}" --date=format:"%Y-%m-%d %H:%M" ${options}`
       );
       
-      // 获取总提交数量（考虑筛选条件）
-      let totalCommits = 0;
-      try {
-        // 构建计数命令，包含相同的筛选条件
-        // 对于作者筛选，使用 rev-list 并手动计数，避免 --count 与复杂作者筛选结合可能的问题
-        if (author.length > 1) {
-          // 多作者情况，使用 wc -l 手动计数
-          const countCommand = `git rev-list --all ${commandOptions.join(' ')}`;
-          console.log(`执行计数命令(多作者): ${countCommand}`);
-          
-          const { stdout: countOutput } = await execGitCommand(countCommand);
-          // 计算行数作为提交数
-          totalCommits = countOutput.trim().split('\n').filter(line => line.trim() !== '').length;
-        } else {
-          // 单作者或无作者筛选，可以直接使用 --count
-          const countCommand = `git rev-list --all --count ${commandOptions.join(' ')}`;
-          console.log(`执行计数命令(单作者): ${countCommand}`);
-          
-          const { stdout: countOutput } = await execGitCommand(countCommand);
-          totalCommits = parseInt(countOutput.trim());
-        }
-      } catch (error) {
-        console.error('获取提交总数失败:', error);
-        totalCommits = 0;
-      }
-      
-      processAndSendLogOutput(res, logOutput, totalCommits, page, limit, withParents);
+      // 分页加载优化：不需要获取总数，通过实际返回的数据量判断是否还有更多
+      // 这里直接处理已获取的数据，通过返回数据量判断是否还有更多
+      processAndSendLogOutput(res, logOutput, page, limit, withParents);
     } catch (error) {
       console.error('获取Git日志失败:', error);
       res.status(500).json({ error: '获取日志失败: ' + error.message });
@@ -1038,35 +1215,22 @@ async function startUIServer(noOpen = false, savePort = false) {
       }
       
       // 构建执行的命令
-      const command = `git log ${formattedBranchRefs} --pretty=format:"${formatString}" --date=short ${options}`;
+      const command = `git log ${formattedBranchRefs} --pretty=format:"${formatString}" --date=format:"%Y-%m-%d %H:%M" ${options}`;
       console.log(`执行Git命令(带分支引用): ${command}`);
       
       // 执行命令
       const { stdout: logOutput } = await execGitCommand(command);
       
-      // 获取总提交数
-      let totalCommits = 0;
-      try {
-        // 构建计数命令
-        const countCommand = `git rev-list ${formattedBranchRefs} --count ${commandOptions.join(' ')}`;
-        console.log(`执行计数命令(分支): ${countCommand}`);
-        
-        const { stdout: countOutput } = await execGitCommand(countCommand);
-        totalCommits = parseInt(countOutput.trim());
-      } catch (error) {
-        console.error('获取提交总数失败:', error);
-        totalCommits = 0;
-      }
-      
-      processAndSendLogOutput(res, logOutput, totalCommits, skip / limit + 1, limit, withParents);
+      // 分页加载优化：不需要获取总数，通过实际返回的数据量判断是否还有更多
+      processAndSendLogOutput(res, logOutput, skip / limit + 1, limit, withParents);
     } catch (error) {
       console.error('执行Git日志命令失败:', error);
       res.status(500).json({ error: '获取日志失败: ' + error.message });
     }
   }
   
-  // 抽取处理输出并发送响应的函数
-  function processAndSendLogOutput(res, logOutput, totalCommits, page, limit, withParents = false) {
+  // 抽取处理输出并发送响应的函数（优化版本：不再依赖总数计算）
+  function processAndSendLogOutput(res, logOutput, page, limit, withParents = false) {
     // 替换提交记录之间的换行符 - 使用 ASCII 控制字符 \x1E 匹配
     logOutput = logOutput.replace(/\n(?=[a-f0-9]{40}\x1E)/g, "<<<RECORD_SEPARATOR>>>");
   
@@ -1097,15 +1261,17 @@ async function startUIServer(noOpen = false, savePort = false) {
       return null;
     }).filter(item => item !== null);
     
-    // 计算是否有更多数据
-    const hasMore = page * limit < totalCommits;
-    
-    console.log(`分页查询 - 页码: ${page}, 每页数量: ${limit}, 总数: ${totalCommits}, 返回数量: ${data.length}, 是否有更多: ${hasMore}`);
-    
+    // 优化：通过返回的数据量判断是否有更多数据，而不依赖总数计算
+    // 如果返回的数据量等于请求的limit，说明可能还有更多数据
+    // 如果返回的数据量小于limit，说明已经到底了
+    const hasMore = data.length === limit;
+
+    console.log(`分页查询 - 页码: ${page}, 每页数量: ${limit}, 返回数量: ${data.length}, 是否有更多: ${hasMore} (优化版本，不计算总数)`);
+
     // 返回提交历史数据，包括是否有更多数据的标志
     res.json({
       data: data,
-      total: totalCommits,
+      total: -1, // 不再提供总数，前端不应依赖此字段
       page: page,
       limit: limit,
       hasMore: hasMore
@@ -1715,6 +1881,10 @@ async function startUIServer(noOpen = false, savePort = false) {
     // 当客户端连接时，立即发送一次Git状态
     getAndBroadcastStatus();
     
+    // 发送当前命令历史
+    const history = getCommandHistory();
+    socket.emit('initial_command_history', { history });
+    
     // 客户端可以请求开始/停止监控
     socket.on('start_monitoring', () => {
       if (!watcher) {
@@ -1731,6 +1901,18 @@ async function startUIServer(noOpen = false, savePort = false) {
       }
     });
     
+    // 请求完整命令历史
+    socket.on('request_full_history', () => {
+      const fullHistory = getCommandHistory();
+      socket.emit('full_command_history', { history: fullHistory });
+    });
+    
+    // 清空命令历史
+    socket.on('clear_command_history', () => {
+      const result = clearCommandHistory();
+      socket.emit('command_history_cleared', { success: result });
+    });
+    
     // 客户端断开连接
     socket.on('disconnect', () => {
       console.log('客户端已断开连接:', socket.id);
@@ -1790,34 +1972,29 @@ async function startUIServer(noOpen = false, savePort = false) {
     }
   }
   
-  // 获取并广播Git状态
+  // 获取并广播Git状态 (优化版本 - 只获取porcelain格式)
   async function getAndBroadcastStatus() {
     try {
       // 如果不是Git仓库，发送特殊状态
       if (!isGitRepo) {
-        io.emit('git_status_update', { 
+        io.emit('git_status_update', {
           isGitRepo: false,
-          status: '当前目录不是Git仓库',
           porcelain: '',
           timestamp: new Date().toISOString()
         });
         return;
       }
-      
-      // 获取常规状态
-      const { stdout: statusOutput } = await execGitCommand('git status');
-      
-      // 获取porcelain格式状态
+
+      // 只获取porcelain格式状态，不再获取完整的git status
       const { stdout: porcelainOutput } = await execGitCommand('git status --porcelain --untracked-files=all');
-      
+
       // 广播到所有连接的客户端
-      io.emit('git_status_update', { 
+      io.emit('git_status_update', {
         isGitRepo: true,
-        status: statusOutput,
         porcelain: porcelainOutput,
         timestamp: new Date().toISOString()
       });
-      
+
       console.log('已广播Git状态更新');
     } catch (error) {
       console.error('获取或广播Git状态失败:', error);
@@ -1851,70 +2028,138 @@ async function startUIServer(noOpen = false, savePort = false) {
   // 启动服务器
   const PORT = 3000;
   
-  // 创建一个函数来保存端口号到文件
-  async function savePortToFile(port) {
-    try {
-      // 只有当savePort为true时才保存端口号
-      if (savePort) {
-        // 保存到项目根目录的.port文件
-        const portFilePath = path.join(process.cwd(), '.port');
-        await fs.writeFile(portFilePath, port.toString(), 'utf8');
-        console.log(`端口号 ${port} 已保存到 ${portFilePath}`);
+  // 创建一个函数来保存端口号到文件和环境变量
+  // 使用闭包保存端口状态，防止多次写入相同端口
+  const savePortToFile = (function() {
+    let savedPort = null;
+    
+    return async function(port) {
+      try {
+        // 只有当savePort为true且端口没有保存过时才保存端口号
+        if (savePort && savedPort !== port) {
+          savedPort = port;
+          
+          // 保存到项目根目录的.port文件
+          const portFilePath = path.join(process.cwd(), '.port');
+          await fs.writeFile(portFilePath, port.toString(), 'utf8');
+          console.log(`端口号 ${port} 已保存到 ${portFilePath}`);
+          
+          // 同时保存到前端Vite项目的.env.local文件
+          try {
+            const clientPath = path.join(process.cwd(), 'src', 'ui', 'client');
+            const envPath = path.join(clientPath, '.env.local');
+            
+            // 检查目录是否存在
+            await fs.access(clientPath).catch(() => {
+              console.log(`客户端目录 ${clientPath} 不存在，跳过环境变量设置`);
+              return Promise.reject(new Error('Client directory not found'));
+            });
+            
+            // 写入环境变量
+            await fs.writeFile(envPath, `VITE_BACKEND_PORT=${port}\n`, 'utf8');
+            console.log(`端口号环境变量已保存到 ${envPath}`);
+          } catch (envError) {
+            console.error('保存端口号到环境变量失败，但不影响主要功能:', envError);
+          }
+        }
+      } catch (error) {
+        console.error('保存端口号到文件失败:', error);
       }
-    } catch (error) {
-      console.error('保存端口号到文件失败:', error);
-    }
-  }
+    };
+  })();
   
-  httpServer.listen(PORT, () => {
-    console.log(chalk.green('======================================'));
-    console.log(chalk.green(`  Zen GitSync 服务器已启动`));
-    console.log(chalk.green(`  访问地址: http://localhost:${PORT}`));
-    console.log(chalk.green(`  启动时间: ${new Date().toLocaleString()}`));
-    if (isGitRepo) {
-      console.log(chalk.green(`  当前目录是Git仓库，文件监控已启动`));
-      // 启动文件监控
-      initFileSystemWatcher();
-    } else {
-      console.log(chalk.yellow(`  当前目录不是Git仓库，文件监控未启动`));
-    }
-    console.log(chalk.green('======================================'));
-    
-    // 保存端口号到文件
-    savePortToFile(PORT);
+  // 尝试在可用端口上启动服务器
+  await startServerOnAvailablePort(PORT);
+  
+  // 启动服务器函数
+  async function startServerOnAvailablePort(startPort) {
+    let currentPort = startPort;
+    const maxPort = startPort + 100; // 最多尝试100个端口
     
-    // 只有在noOpen为false时才打开浏览器
-    if (!noOpen) {
-      open(`http://localhost:${PORT}`);
-    }
-  }).on('error', async (err) => {
-    if (err.code === 'EADDRINUSE') {
-      console.log(`端口 ${PORT} 被占用，尝试其他端口...`);
-      let newPort = PORT + 1;
-      while (newPort < PORT + 100) {
-        try {
-          await new Promise((resolve, reject) => {
-            httpServer.listen(newPort, () => {
-              console.log(chalk.green('======================================'));
-              console.log(chalk.green(`  Zen GitSync 服务器已启动`));
-              console.log(chalk.green(`  访问地址: http://localhost:${newPort}`));
-              console.log(chalk.green(`  启动时间: ${new Date().toLocaleString()}`));
-              console.log(chalk.green('======================================'));
-              
-              // 保存新端口号到文件
-              savePortToFile(newPort);
-              
-              resolve();
-            });
+    while (currentPort < maxPort) {
+      try {
+        // 等待1秒，避免快速尝试多个端口
+        if (currentPort > startPort) {
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          console.log(`尝试端口 ${currentPort}...`);
+        }
+        
+        // 尝试在当前端口启动服务器
+        await new Promise((resolve, reject) => {
+          // 仅监听一次error事件
+          const errorHandler = (err) => {
+            httpServer.removeListener('error', errorHandler);
+            reject(err);
+          };
+          
+          // 使用变量标记回调是否已执行，防止多次触发
+          let callbackExecuted = false;
+          
+          httpServer.once('error', errorHandler);
+          
+          httpServer.listen(currentPort, () => {
+            // 确保回调只执行一次
+            if (callbackExecuted) return;
+            callbackExecuted = true;
+            
+            // 成功监听，移除错误处理器
+            httpServer.removeListener('error', errorHandler);
+            
+            // 输出服务器信息
+            console.log(chalk.green('======================================'));
+            console.log(chalk.green(`  Zen GitSync 服务器已启动`));
+            console.log(chalk.green(`  访问地址: http://localhost:${currentPort}`));
+            console.log(chalk.green(`  启动时间: ${new Date().toLocaleString()}`));
+            
+            if (isGitRepo) {
+              console.log(chalk.green(`  当前目录是Git仓库，文件监控已启动`));
+              // 启动文件监控
+              initFileSystemWatcher();
+            } else {
+              console.log(chalk.yellow(`  当前目录不是Git仓库，文件监控未启动`));
+            }
+            
+            console.log(chalk.green('======================================'));
+            
+            // 保存端口号到文件
+            savePortToFile(currentPort);
+            
+            // 只有在noOpen为false时才打开浏览器
+            if (!noOpen) {
+              open(`http://localhost:${currentPort}`);
+            }
+            
+            resolve();
           });
-          break;
-        } catch (error) {
-          newPort++;
+        });
+        
+        // 如果成功启动，退出循环
+        return;
+      } catch (err) {
+        // 处理端口被占用的情况
+        if (err.code === 'EADDRINUSE') {
+          console.log(`端口 ${currentPort} 被占用，尝试下一个端口...`);
+          currentPort++;
+        } else {
+          // 其他错误，直接抛出
+          console.error('启动服务器失败:', err);
+          process.exit(1);
         }
       }
-    } else {
-      console.error('启动服务器失败:', err);
-      process.exit(1);
+    }
+    
+    // 如果尝试了所有端口都失败
+    console.error(`无法找到可用端口 (尝试范围: ${startPort}-${maxPort-1})`);
+    process.exit(1);
+  }
+  
+  // 添加命令历史的清空API
+  app.post('/api/clear-command-history', async (req, res) => {
+    try {
+      const result = clearCommandHistory();
+      res.json({ success: result });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
     }
   });
 }