zen-gitsync 2.6.4 → 2.6.7

package/src/ui/server/index.js

@@ -7,23 +7,16 @@ import open from 'open';
 import config from '../../config.js';
 import chalk from 'chalk';
 import fs from 'fs/promises';
+import fsSync from 'fs';
 import os from 'os';
 import { Server } from 'socket.io';
-import chokidar from 'chokidar';
 import { spawn } from 'child_process';
+import iconv from 'iconv-lite';
 // import { exec } from 'child_process';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const configManager = config; // 确保 configManager 可用
-
-// 文件系统变动监控器
-let watcher = null;
-// 防抖计时器
-let debounceTimer = null;
-// 防抖延迟时间 (毫秒)
-const DEBOUNCE_DELAY = 1000;
-
 // 分支状态缓存
 let branchStatusCache = {
   currentBranch: null,
@@ -156,6 +149,134 @@ async function startUIServer(noOpen = false, savePort = false) {
     }
   });
   
+  // 流式执行命令接口（支持实时输出）
+  app.post('/api/exec-stream', async (req, res) => {
+    try {
+      const { command, directory } = req.body || {};
+      if (!command || typeof command !== 'string' || !command.trim()) {
+        return res.status(400).json({ success: false, error: 'command 不能为空' });
+      }
+
+      // 确定执行目录
+      const execDirectory = directory && directory.trim() 
+        ? (path.isAbsolute(directory) ? directory : path.join(currentProjectPath, directory))
+        : currentProjectPath;
+
+      console.log(`流式执行命令: ${command}`);
+      console.log(`执行目录: ${execDirectory}`);
+
+      // 设置响应头为流式传输
+      res.setHeader('Content-Type', 'text/event-stream');
+      res.setHeader('Cache-Control', 'no-cache');
+      res.setHeader('Connection', 'keep-alive');
+      res.setHeader('X-Accel-Buffering', 'no'); // 禁用nginx缓冲
+
+      // 使用 spawn 执行命令，支持实时输出
+      console.log(`[流式输出] 准备执行命令: ${command}`);
+      console.log(`[流式输出] 当前平台: ${process.platform}`);
+      console.log(`[流式输出] 工作目录: ${execDirectory}`);
+      
+      // 使用 shell: true 来支持 Windows 内置命令（如 dir、cd 等）
+      const childProcess = spawn(command.trim(), [], {
+        cwd: execDirectory,
+        shell: true, // 通过 shell 执行，支持 Windows 内置命令
+        env: {
+          ...process.env,
+          GIT_CONFIG_PARAMETERS: "'core.quotepath=false'"
+        }
+      });
+
+      console.log(`[流式输出] childProcess.stdout 是否存在:`, !!childProcess.stdout);
+      console.log(`[流式输出] childProcess.stderr 是否存在:`, !!childProcess.stderr);
+
+      let outputReceived = false;
+
+      // 发送数据到客户端的辅助函数
+      const sendData = (type, data) => {
+        const message = `data: ${JSON.stringify({ type, data })}\n\n`;
+        console.log(`[流式输出] 发送数据 - 类型: ${type}, 长度: ${data?.length || 0}`);
+        res.write(message);
+      };
+
+      // 在 Windows 上，CMD 默认使用 GBK 编码
+      // 不设置 encoding，直接处理 Buffer，然后用 iconv-lite 转换
+      const isWindows = process.platform === 'win32';
+      console.log(`[流式输出] 平台: ${process.platform}, 使用编码转换: ${isWindows}`);
+
+      // 监听标准输出
+      childProcess.stdout?.on('data', (data) => {
+        // data 是 Buffer 对象
+        let output;
+        if (isWindows) {
+          // Windows 系统，从 GBK 转换为 UTF-8
+          output = iconv.decode(data, 'gbk');
+          console.log(`[流式输出] 收到stdout(GBK转UTF8):`, output.substring(0, 100));
+        } else {
+          // Unix 系统，直接使用 UTF-8
+          output = data.toString('utf8');
+          console.log(`[流式输出] 收到stdout(UTF8):`, output.substring(0, 100));
+        }
+        outputReceived = true;
+        sendData('stdout', output);
+      });
+
+      // 监听标准错误输出
+      childProcess.stderr?.on('data', (data) => {
+        // data 是 Buffer 对象
+        let output;
+        if (isWindows) {
+          // Windows 系统，从 GBK 转换为 UTF-8
+          output = iconv.decode(data, 'gbk');
+          console.log(`[流式输出] 收到stderr(GBK转UTF8):`, output.substring(0, 100));
+        } else {
+          // Unix 系统，直接使用 UTF-8
+          output = data.toString('utf8');
+          console.log(`[流式输出] 收到stderr(UTF8):`, output.substring(0, 100));
+        }
+        outputReceived = true;
+        // 不再自动标记为错误，只显示 stderr 输出
+        // Git 的警告信息会输出到 stderr 但退出码仍为 0
+        sendData('stderr', output);
+      });
+
+      // 监听进程退出（exit 在流关闭前触发）
+      childProcess.on('exit', (code, signal) => {
+        console.log(`[流式输出] 进程 exit 事件 - 代码: ${code}, 信号: ${signal}`);
+      });
+
+      // 监听进程关闭（close 在流关闭后触发）
+      childProcess.on('close', (code, signal) => {
+        console.log(`[流式输出] 进程 close 事件 - 代码: ${code}, 信号: ${signal}, 有输出: ${outputReceived}`);
+        // 只根据退出码判断成功与否，退出码为 0 表示成功
+        sendData('exit', { code, success: code === 0 });
+        res.end();
+      });
+
+      // 监听错误
+      childProcess.on('error', (error) => {
+        console.error(`[流式输出] 进程错误:`, error);
+        sendData('error', error.message);
+        res.end();
+      });
+      
+      // 添加spawn事件监听
+      childProcess.on('spawn', () => {
+        console.log(`[流式输出] 进程已启动 - PID: ${childProcess.pid}`);
+      });
+
+      // 注意：不监听req.on('close')，参考git push的实现
+      // 进程会自然结束，close事件会触发res.end()
+      // 如果监听req.on('close')可能会导致进程被提前kill
+
+    } catch (error) {
+      console.error('流式执行命令失败:', error);
+      res.status(500).json({ 
+        success: false, 
+        error: `流式执行命令失败: ${error.message}` 
+      });
+    }
+  });
+  
   // 在新终端中执行自定义命令
   app.post('/api/exec-in-terminal', async (req, res) => {
     try {
@@ -661,12 +782,6 @@ async function startUIServer(noOpen = false, savePort = false) {
                     console.warn('初始化项目配置失败:', e?.message || e);
                   }
                   
-                  // 关闭旧的文件监控
-                  if (watcher) {
-                    watcher.close().catch(err => console.error('关闭旧监控器失败:', err));
-                    watcher = null;
-                  }
-                  
                   // 通知所有旧房间的客户端项目已切换
                   io.to(projectRoomId).emit('project_changed', {
                     oldProjectPath: currentProjectPath,
@@ -694,11 +809,6 @@ async function startUIServer(noOpen = false, savePort = false) {
                   projectRoomId = newProjectRoomId;
                   isGitRepo = false;
                   
-                  if (watcher) {
-                    watcher.close().catch(err => console.error('关闭监控器失败:', err));
-                    watcher = null;
-                  }
-                  
                   // 通知所有旧房间的客户端项目已切换
                   io.to(projectRoomId).emit('project_changed', {
                     oldProjectPath: currentProjectPath,
@@ -1446,6 +1556,53 @@ async function startUIServer(noOpen = false, savePort = false) {
     }
   })
   
+  // 置顶模板
+  app.post('/api/config/pin-template', express.json(), async (req, res) => {
+    try {
+      const { template, type } = req.body
+      
+      if (!template || !type) {
+        return res.status(400).json({ success: false, error: '缺少必要参数' })
+      }
+      
+      const config = await configManager.loadConfig()
+      
+      if (type === 'description') {
+        if (config.descriptionTemplates) {
+          // 删除原位置的模板
+          config.descriptionTemplates = config.descriptionTemplates.filter(t => t !== template)
+          // 添加到第一位
+          config.descriptionTemplates.unshift(template)
+          await configManager.saveConfig(config)
+        } else {
+          return res.status(404).json({ success: false, error: '模板列表不存在' })
+        }
+      } else if (type === 'scope') {
+        if (config.scopeTemplates) {
+          config.scopeTemplates = config.scopeTemplates.filter(t => t !== template)
+          config.scopeTemplates.unshift(template)
+          await configManager.saveConfig(config)
+        } else {
+          return res.status(404).json({ success: false, error: '模板列表不存在' })
+        }
+      } else if (type === 'message') {
+        if (config.messageTemplates) {
+          config.messageTemplates = config.messageTemplates.filter(t => t !== template)
+          config.messageTemplates.unshift(template)
+          await configManager.saveConfig(config)
+        } else {
+          return res.status(404).json({ success: false, error: '模板列表不存在' })
+        }
+      } else {
+        return res.status(400).json({ success: false, error: '不支持的模板类型' })
+      }
+      
+      res.json({ success: true })
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message })
+    }
+  })
+  
   // 保存自定义命令
   app.post('/api/config/save-custom-command', express.json(), async (req, res) => {
     try {
@@ -1541,6 +1698,176 @@ async function startUIServer(noOpen = false, savePort = false) {
     }
   })
   
+  // 保存指令编排
+  app.post('/api/config/save-orchestration', express.json(), async (req, res) => {
+    try {
+      const { orchestration } = req.body
+      
+      if (!orchestration || !orchestration.name || !Array.isArray(orchestration.steps)) {
+        return res.status(400).json({ success: false, error: '缺少必要参数' })
+      }
+      
+      const config = await configManager.loadConfig()
+      
+      // 确保编排数组存在
+      if (!Array.isArray(config.orchestrations)) {
+        config.orchestrations = []
+      }
+      
+      // 生成唯一ID
+      const id = `orch_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+      const newOrchestration = {
+        id,
+        name: orchestration.name,
+        description: orchestration.description || '',
+        steps: orchestration.steps
+      }
+      
+      config.orchestrations.push(newOrchestration)
+      await configManager.saveConfig(config)
+      
+      res.json({ success: true, orchestration: newOrchestration })
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message })
+    }
+  })
+  
+  // 删除指令编排
+  app.post('/api/config/delete-orchestration', express.json(), async (req, res) => {
+    try {
+      const { id } = req.body
+      
+      if (!id) {
+        return res.status(400).json({ success: false, error: '缺少编排ID参数' })
+      }
+      
+      const config = await configManager.loadConfig()
+      
+      if (Array.isArray(config.orchestrations)) {
+        const index = config.orchestrations.findIndex(orch => orch.id === id)
+        if (index !== -1) {
+          config.orchestrations.splice(index, 1)
+          await configManager.saveConfig(config)
+        }
+      }
+      
+      res.json({ success: true })
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message })
+    }
+  })
+  
+  // 更新指令编排
+  app.post('/api/config/update-orchestration', express.json(), async (req, res) => {
+    try {
+      const { id, orchestration } = req.body
+      
+      if (!id || !orchestration || !orchestration.name || !Array.isArray(orchestration.steps)) {
+        return res.status(400).json({ success: false, error: '缺少必要参数' })
+      }
+      
+      const config = await configManager.loadConfig()
+      
+      if (Array.isArray(config.orchestrations)) {
+        const index = config.orchestrations.findIndex(orch => orch.id === id)
+        if (index !== -1) {
+          config.orchestrations[index] = {
+            id,
+            name: orchestration.name,
+            description: orchestration.description || '',
+            steps: orchestration.steps
+          }
+          await configManager.saveConfig(config)
+        } else {
+          return res.status(404).json({ success: false, error: '未找到指定编排' })
+        }
+      } else {
+        return res.status(404).json({ success: false, error: '编排列表不存在' })
+      }
+      
+      res.json({ success: true })
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message })
+    }
+  })
+  
+  // 版本号递增
+  app.post('/api/version-bump', express.json(), async (req, res) => {
+    try {
+      const { bumpType, packageJsonPath } = req.body
+      
+      // 确定 package.json 的路径
+      let pkgPath
+      if (packageJsonPath && packageJsonPath.trim()) {
+        pkgPath = path.isAbsolute(packageJsonPath) 
+          ? packageJsonPath 
+          : path.join(currentProjectPath, packageJsonPath)
+      } else {
+        pkgPath = path.join(currentProjectPath, 'package.json')
+      }
+      
+      // 检查文件是否存在（使用 Node.js 原生方法）
+      try {
+        await fs.access(pkgPath)
+      } catch (err) {
+        return res.status(404).json({ 
+          success: false, 
+          error: `未找到 package.json 文件: ${pkgPath}` 
+        })
+      }
+      
+      // 读取 package.json
+      const pkgContent = await fs.readFile(pkgPath, 'utf8')
+      const pkg = JSON.parse(pkgContent)
+      
+      if (!pkg.version) {
+        return res.status(400).json({ 
+          success: false, 
+          error: 'package.json 中未找到 version 字段' 
+        })
+      }
+      
+      const oldVersion = pkg.version
+      
+      // 解析版本号
+      const versionParts = oldVersion.split('.').map(Number)
+      if (versionParts.length !== 3 || versionParts.some(isNaN)) {
+        return res.status(400).json({ 
+          success: false, 
+          error: `无效的版本号格式: ${oldVersion}，应为 x.y.z 格式` 
+        })
+      }
+      
+      // 根据类型递增版本号
+      let [major, minor, patch] = versionParts
+      if (bumpType === 'major') {
+        major += 1
+        minor = 0
+        patch = 0
+      } else if (bumpType === 'minor') {
+        minor += 1
+        patch = 0
+      } else { // patch
+        patch += 1
+      }
+      
+      const newVersion = `${major}.${minor}.${patch}`
+      pkg.version = newVersion
+      
+      // 写回 package.json（保持格式化）
+      await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8')
+      
+      res.json({ 
+        success: true, 
+        oldVersion, 
+        newVersion,
+        filePath: pkgPath
+      })
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message })
+    }
+  })
+  
   // 提交更改
   app.post('/api/commit', express.json(), async (req, res) => {
     try {
@@ -3369,7 +3696,8 @@ async function startUIServer(noOpen = false, savePort = false) {
               path: dir,
               relativePath: relativePath || '.',
               name: packageData.name || path.basename(dir),
-              scripts: packageData.scripts
+              scripts: packageData.scripts,
+              version: packageData.version || '0.0.0'
             });
             return true;
           }
@@ -3555,6 +3883,340 @@ async function startUIServer(noOpen = false, savePort = false) {
       });
     }
   });
+
+  // API: 更新npm版本号
+  app.post('/api/update-npm-version', async (req, res) => {
+    try {
+      const { packagePath, versionType } = req.body;
+      
+      if (!packagePath || !versionType) {
+        return res.status(400).json({
+          success: false,
+          error: '缺少必要参数: packagePath, versionType'
+        });
+      }
+
+      // 确保路径指向package.json文件
+      let packageJsonPath = path.resolve(packagePath);
+      if (fsSync.existsSync(packageJsonPath) && fsSync.statSync(packageJsonPath).isDirectory()) {
+        packageJsonPath = path.join(packageJsonPath, 'package.json');
+      }
+      
+      // 检查文件是否存在
+      if (!fsSync.existsSync(packageJsonPath)) {
+        return res.status(404).json({
+          success: false,
+          error: '找不到package.json文件'
+        });
+      }
+
+      // 读取package.json
+      const packageJson = JSON.parse(fsSync.readFileSync(packageJsonPath, 'utf8'));
+      
+      if (!packageJson.version) {
+        return res.status(400).json({
+          success: false,
+          error: 'package.json中没有version字段'
+        });
+      }
+
+      const oldVersion = packageJson.version;
+      const versionParts = oldVersion.split('.').map(Number);
+      
+      // 根据类型增加版本号
+      switch (versionType) {
+        case 'major':
+          versionParts[0]++;
+          versionParts[1] = 0;
+          versionParts[2] = 0;
+          break;
+        case 'minor':
+          versionParts[1]++;
+          versionParts[2] = 0;
+          break;
+        case 'patch':
+          versionParts[2]++;
+          break;
+        default:
+          return res.status(400).json({
+            success: false,
+            error: '无效的版本类型，必须是 major, minor 或 patch'
+          });
+      }
+
+      const newVersion = versionParts.join('.');
+      packageJson.version = newVersion;
+      
+      // 写回文件
+      fsSync.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8');
+      
+      console.log(`已更新npm版本号: ${oldVersion} → ${newVersion} (${packagePath})`);
+      
+      res.json({
+        success: true,
+        oldVersion,
+        newVersion
+      });
+    } catch (error) {
+      console.error('更新版本号失败:', error);
+      res.status(500).json({
+        success: false,
+        error: `更新版本号失败: ${error.message}`
+      });
+    }
+  });
+
+  // API: 添加npm脚本
+  app.post('/api/add-npm-script', async (req, res) => {
+    try {
+      const { packagePath, scriptName, scriptCommand } = req.body;
+      
+      if (!packagePath || !scriptName || !scriptCommand) {
+        return res.status(400).json({
+          success: false,
+          error: '缺少必要参数: packagePath, scriptName, scriptCommand'
+        });
+      }
+
+      // 确保路径指向package.json文件
+      let packageJsonPath = path.resolve(packagePath);
+      if (fsSync.existsSync(packageJsonPath) && fsSync.statSync(packageJsonPath).isDirectory()) {
+        packageJsonPath = path.join(packageJsonPath, 'package.json');
+      }
+      
+      // 检查文件是否存在
+      if (!fsSync.existsSync(packageJsonPath)) {
+        return res.status(404).json({
+          success: false,
+          error: '找不到package.json文件'
+        });
+      }
+      
+      // 读取package.json
+      const packageJson = JSON.parse(fsSync.readFileSync(packageJsonPath, 'utf8'));
+      
+      // 确保scripts对象存在
+      if (!packageJson.scripts) {
+        packageJson.scripts = {};
+      }
+      
+      // 检查脚本是否已存在
+      if (packageJson.scripts[scriptName]) {
+        return res.status(400).json({
+          success: false,
+          error: `脚本 "${scriptName}" 已存在`
+        });
+      }
+      
+      // 添加脚本
+      packageJson.scripts[scriptName] = scriptCommand;
+      
+      // 写回文件（保持格式化）
+      fsSync.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8');
+      
+      console.log(`已添加npm脚本: ${scriptName} = ${scriptCommand} (${packagePath})`);
+      
+      res.json({
+        success: true,
+        scriptName,
+        scriptCommand
+      });
+    } catch (error) {
+      console.error('添加npm脚本失败:', error);
+      res.status(500).json({
+        success: false,
+        error: `添加npm脚本失败: ${error.message}`
+      });
+    }
+  });
+
+  // API: 更新npm脚本
+  app.post('/api/update-npm-script', async (req, res) => {
+    try {
+      const { packagePath, scriptName, scriptCommand, oldScriptName } = req.body;
+      
+      if (!packagePath || !scriptName || !scriptCommand) {
+        return res.status(400).json({
+          success: false,
+          error: '缺少必要参数: packagePath, scriptName, scriptCommand'
+        });
+      }
+
+      // 确保路径指向package.json文件
+      let packageJsonPath = path.resolve(packagePath);
+      if (fsSync.existsSync(packageJsonPath) && fsSync.statSync(packageJsonPath).isDirectory()) {
+        packageJsonPath = path.join(packageJsonPath, 'package.json');
+      }
+      
+      // 检查文件是否存在
+      if (!fsSync.existsSync(packageJsonPath)) {
+        return res.status(404).json({
+          success: false,
+          error: '找不到package.json文件'
+        });
+      }
+
+      // 读取package.json
+      const packageJson = JSON.parse(fsSync.readFileSync(packageJsonPath, 'utf8'));
+      
+      // 确保scripts对象存在
+      if (!packageJson.scripts) {
+        packageJson.scripts = {};
+      }
+
+      // 如果改了脚本名称，删除旧的
+      if (oldScriptName && oldScriptName !== scriptName) {
+        delete packageJson.scripts[oldScriptName];
+      }
+
+      // 更新脚本
+      packageJson.scripts[scriptName] = scriptCommand;
+      
+      // 写回文件
+      fsSync.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8');
+      
+      console.log(`已更新npm脚本: ${scriptName} = ${scriptCommand} (${packagePath})`);
+      
+      res.json({
+        success: true,
+        scriptName,
+        scriptCommand
+      });
+    } catch (error) {
+      console.error('更新npm脚本失败:', error);
+      res.status(500).json({
+        success: false,
+        error: `更新npm脚本失败: ${error.message}`
+      });
+    }
+  });
+
+  // API: 删除npm脚本
+  app.post('/api/delete-npm-script', async (req, res) => {
+    try {
+      const { packagePath, scriptName } = req.body;
+      
+      if (!packagePath || !scriptName) {
+        return res.status(400).json({
+          success: false,
+          error: '缺少必要参数: packagePath, scriptName'
+        });
+      }
+
+      // 确保路径指向package.json文件
+      let packageJsonPath = path.resolve(packagePath);
+      if (fsSync.existsSync(packageJsonPath) && fsSync.statSync(packageJsonPath).isDirectory()) {
+        packageJsonPath = path.join(packageJsonPath, 'package.json');
+      }
+      
+      // 检查文件是否存在
+      if (!fsSync.existsSync(packageJsonPath)) {
+        return res.status(404).json({
+          success: false,
+          error: '找不到package.json文件'
+        });
+      }
+
+      // 读取package.json
+      const packageJson = JSON.parse(fsSync.readFileSync(packageJsonPath, 'utf8'));
+      
+      // 检查scripts对象和脚本是否存在
+      if (!packageJson.scripts || !packageJson.scripts[scriptName]) {
+        return res.status(404).json({
+          success: false,
+          error: `脚本 "${scriptName}" 不存在`
+        });
+      }
+
+      // 删除脚本
+      delete packageJson.scripts[scriptName];
+      
+      // 写回文件
+      fsSync.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8');
+      
+      console.log(`已删除npm脚本: ${scriptName} (${packagePath})`);
+      
+      res.json({
+        success: true,
+        scriptName
+      });
+    } catch (error) {
+      console.error('删除npm脚本失败:', error);
+      res.status(500).json({
+        success: false,
+        error: `删除npm脚本失败: ${error.message}`
+      });
+    }
+  });
+
+  // API: 置顶npm脚本
+  app.post('/api/pin-npm-script', async (req, res) => {
+    try {
+      const { packagePath, scriptName } = req.body;
+      
+      if (!packagePath || !scriptName) {
+        return res.status(400).json({
+          success: false,
+          error: '缺少必要参数: packagePath, scriptName'
+        });
+      }
+
+      // 确保路径指向package.json文件
+      let packageJsonPath = path.resolve(packagePath);
+      if (fsSync.existsSync(packageJsonPath) && fsSync.statSync(packageJsonPath).isDirectory()) {
+        packageJsonPath = path.join(packageJsonPath, 'package.json');
+      }
+      
+      // 检查文件是否存在
+      if (!fsSync.existsSync(packageJsonPath)) {
+        return res.status(404).json({
+          success: false,
+          error: '找不到package.json文件'
+        });
+      }
+
+      // 读取package.json
+      const packageJson = JSON.parse(fsSync.readFileSync(packageJsonPath, 'utf8'));
+      
+      // 检查scripts对象和脚本是否存在
+      if (!packageJson.scripts || !packageJson.scripts[scriptName]) {
+        return res.status(404).json({
+          success: false,
+          error: `脚本 "${scriptName}" 不存在`
+        });
+      }
+
+      // 保存要置顶的脚本内容
+      const scriptCommand = packageJson.scripts[scriptName];
+      
+      // 删除该脚本
+      delete packageJson.scripts[scriptName];
+      
+      // 创建新的scripts对象，将置顶脚本放在最前面
+      const newScripts = {
+        [scriptName]: scriptCommand,
+        ...packageJson.scripts
+      };
+      
+      packageJson.scripts = newScripts;
+      
+      // 写回文件
+      fsSync.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8');
+      
+      console.log(`已置顶npm脚本: ${scriptName} (${packagePath})`);
+      
+      res.json({
+        success: true,
+        scriptName
+      });
+    } catch (error) {
+      console.error('置顶npm脚本失败:', error);
+      res.status(500).json({
+        success: false,
+        error: `置顶npm脚本失败: ${error.message}`
+      });
+    }
+  });
   
   // Socket.io 实时更新
   io.on('connection', (socket) => {
@@ -3571,34 +4233,6 @@ async function startUIServer(noOpen = false, savePort = false) {
     const history = getCommandHistory();
     socket.emit('initial_command_history', { history });
     
-    // 发送项目信息给客户端
-    socket.emit('project_info', {
-      projectPath: currentProjectPath,
-      projectRoomId: projectRoomId
-    });
-    
-    // 客户端可以请求开始/停止监控
-    socket.on('start_monitoring', () => {
-      if (!watcher) {
-        initFileSystemWatcher().catch(err => console.error('[文件监控] 初始化失败:', err));
-        socket.emit('monitoring_status', { active: true });
-      }
-    });
-    
-    // 处理客户端加入新房间的请求
-    socket.on('join_room', (roomId) => {
-      socket.join(roomId);
-      console.log(`客户端 ${socket.id} 已加入房间: ${roomId}`);
-    });
-    
-    socket.on('stop_monitoring', () => {
-      if (watcher) {
-        watcher.close().catch(err => console.error('关闭监控器失败:', err));
-        watcher = null;
-        socket.emit('monitoring_status', { active: false });
-      }
-    });
-    
     // 请求完整命令历史
     socket.on('request_full_history', () => {
       const fullHistory = getCommandHistory();
@@ -3618,158 +4252,6 @@ async function startUIServer(noOpen = false, savePort = false) {
     });
   });
   
-  // 读取并解析.gitignore文件
-  async function parseGitignore(projectPath) {
-    const gitignorePath = path.join(projectPath, '.gitignore');
-    const ignorePatterns = [
-      /(^|[\/\\])\../, // 始终忽略.开头的文件（除了.gitignore本身）
-      '**/.git/**', // 始终忽略.git目录
-      
-      // 额外排除常见的编译产物和大文件，减少监控开销
-      '**/*.umd.cjs',      // UMD打包文件
-      '**/*.min.js',       // 压缩JS文件
-      '**/*.bundle.js',    // Webpack打包文件
-      '**/*.dist.js',      // 构建产物
-      '**/*.prod.js',      // 生产环境文件
-      '**/lib/**',         // 通常是编译产物
-      '**/es/**',          // ES模块编译产物
-      '**/esm/**',         // ES模块编译产物
-      '**/*.map',          // Source map文件
-      '**/*.chunk.js',     // 代码分割chunk
-    ];
-    
-    try {
-      const gitignoreContent = await fs.readFile(gitignorePath, 'utf8');
-      const lines = gitignoreContent.split('\n');
-      let validRules = 0;
-      
-      for (let line of lines) {
-        line = line.trim();
-        
-        // 跳过空行和注释
-        if (!line || line.startsWith('#')) continue;
-        
-        // 移除行尾的空格
-        line = line.replace(/\s+$/, '');
-        
-        // 跳过否定规则（chokidar不支持否定规则，这些规则会被忽略）
-        if (line.startsWith('!')) {
-          continue;
-        }
-        
-        // 将gitignore规则转换为glob模式
-        let pattern;
-        
-        // 如果以/开头，表示从根目录开始匹配
-        if (line.startsWith('/')) {
-          pattern = line.substring(1);
-          // 如果是目录，添加/**后缀
-          if (!pattern.includes('*') && !pattern.includes('.')) {
-            ignorePatterns.push(pattern);
-            ignorePatterns.push(pattern + '/**');
-          } else {
-            ignorePatterns.push(pattern);
-          }
-        } else if (line.endsWith('/')) {
-          // 明确的目录规则
-          const dirName = line.slice(0, -1);
-          ignorePatterns.push('**/' + dirName);
-          ignorePatterns.push('**/' + dirName + '/**');
-        } else {
-          // 文件或目录规则
-          // 如果包含*通配符，直接使用
-          if (line.includes('*')) {
-            ignorePatterns.push('**/' + line);
-          } else {
-            // 既匹配文件也匹配目录
-            ignorePatterns.push('**/' + line);
-            ignorePatterns.push('**/' + line + '/**');
-          }
-        }
-        
-        validRules++;
-      }
-      
-      console.log(`[文件监控] 从.gitignore读取了 ${validRules} 条有效的忽略规则`);
-    } catch (error) {
-      // .gitignore不存在或读取失败，使用默认规则
-      console.log('[文件监控] 未找到.gitignore，使用默认忽略规则');
-      ignorePatterns.push(
-        '**/node_modules/**',
-        '**/dist/**',
-        '**/build/**',
-        '**/coverage/**',
-        '**/.nuxt/**',
-        '**/.next/**',
-        '**/out/**',
-        '**/*.log'
-      );
-    }
-    
-    return ignorePatterns;
-  }
-  
-  // 初始化文件系统监控
-  async function initFileSystemWatcher() {
-    // 停止已有的监控器
-    if (watcher) {
-      watcher.close().catch(err => console.error('关闭旧监控器失败:', err));
-    }
-    
-    try {
-      // 获取当前工作目录
-      const currentDir = process.cwd();
-      
-      console.log(`初始化文件系统监控器，路径: ${currentDir}`);
-      
-      // 检查是否是Git仓库
-      if (!isGitRepo) {
-        console.log('当前目录不是Git仓库，不启动监控');
-        return;
-      }
-      
-      const watcherStartTime = Date.now();
-      console.log('[文件监控] 开始初始化监控器...');
-      
-      // 从.gitignore读取忽略规则
-      const ignorePatterns = await parseGitignore(currentDir);
-      
-      // 使用chokidar监控文件变动
-      watcher = chokidar.watch(currentDir, {
-        ignored: ignorePatterns,
-        persistent: true,
-        ignoreInitial: true, // 忽略初始扫描时的文件
-        depth: 10, // 限制扫描深度，避免过深的目录结构
-        awaitWriteFinish: {
-          stabilityThreshold: 300, // 等待文件写入完成的时间
-          pollInterval: 100 // 轮询间隔
-        }
-      });
-      
-      // 合并所有变动事件到一个处理程序
-      const events = ['add', 'change', 'unlink'];
-      events.forEach(event => {
-        watcher.on(event, path => {
-          console.log(`检测到文件变动 [${event}]: ${path}`);
-          debouncedNotifyChanges();
-        });
-      });
-      
-      watcher.on('ready', () => {
-        const initTime = Date.now() - watcherStartTime;
-        console.log(`[文件监控] 监控器初始化完成，耗时 ${initTime}ms`);
-      });
-      
-      watcher.on('error', error => {
-        console.error('[文件监控] 监控错误:', error);
-      });
-      
-      console.log('[文件监控] 监控器已启动（异步初始化中...）');
-    } catch (error) {
-      console.error('启动文件监控失败:', error);
-    }
-  }
-  
   // 获取并广播Git状态 (优化版本 - 只获取porcelain格式)
   async function getAndBroadcastStatus() {
     try {
@@ -3801,17 +4283,6 @@ async function startUIServer(noOpen = false, savePort = false) {
     }
   }
   
-  // 防抖处理函数
-  function debouncedNotifyChanges() {
-    if (debounceTimer) {
-      clearTimeout(debounceTimer);
-    }
-    
-    debounceTimer = setTimeout(() => {
-      getAndBroadcastStatus();
-    }, DEBOUNCE_DELAY);
-  }
-  
   // 检查当前目录是否是Git仓库
   let isGitRepo = false;
   try {