zen-gitsync 2.9.8 → 2.9.10

package/src/ui/server/routes/process.js

@@ -0,0 +1,68 @@
+export function registerProcessRoutes({
+  app,
+  runningProcesses,
+  exec
+}) {
+  // 停止正在运行的进程
+  app.post('/api/kill-process', async (req, res) => {
+    try {
+      const { processId } = req.body || {};
+      if (!processId || typeof processId !== 'number') {
+        return res.status(400).json({ success: false, error: 'processId 必须是数字' });
+      }
+
+      const processInfo = runningProcesses.get(processId);
+      if (!processInfo) {
+        return res.status(404).json({
+          success: false,
+          error: `进程 #${processId} 不存在或已结束`
+        });
+      }
+
+      console.log(`[进程管理] 尝试停止进程 #${processId}: ${processInfo.command}`);
+
+      try {
+        // 在 Windows 上需要使用 taskkill 来杀死整个进程树
+        if (process.platform === 'win32') {
+          // 使用已导入的 exec
+          // /F 强制终止, /T 终止进程树
+          exec(`taskkill /pid ${processInfo.childProcess.pid} /T /F`, (error) => {
+            if (error) {
+              console.error(`[进程管理] taskkill 失败:`, error);
+            }
+          });
+        } else {
+          // Unix/Linux/Mac 使用 SIGTERM
+          processInfo.childProcess.kill('SIGTERM');
+
+          // 如果 2 秒后还没结束，使用 SIGKILL 强制终止
+          setTimeout(() => {
+            if (runningProcesses.has(processId)) {
+              console.log(`[进程管理] 进程 #${processId} 未响应 SIGTERM，使用 SIGKILL 强制终止`);
+              processInfo.childProcess.kill('SIGKILL');
+            }
+          }, 2000);
+        }
+
+        res.json({
+          success: true,
+          message: `已发送停止信号到进程 #${processId}`,
+          processId,
+          command: processInfo.command
+        });
+      } catch (killError) {
+        console.error(`[进程管理] 停止进程失败:`, killError);
+        res.status(500).json({
+          success: false,
+          error: `停止进程失败: ${killError.message}`
+        });
+      }
+    } catch (error) {
+      console.error('停止进程接口失败:', error);
+      res.status(500).json({
+        success: false,
+        error: `停止进程失败: ${error.message}`
+      });
+    }
+  });
+}

package/src/ui/server/routes/status.js

@@ -0,0 +1,24 @@
+export function registerStatusRoutes({
+  app,
+  getCommandHistory,
+  execGitCommand
+}) {
+  // Add new endpoint for command history
+  app.get('/api/command-history', async (req, res) => {
+    try {
+      const history = getCommandHistory();
+      res.json({ success: true, history });
+    } catch (error) {
+      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');
+      res.json({ status: stdout });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+}

package/src/ui/server/routes/terminal.js

@@ -0,0 +1,244 @@
+import { spawn, exec } from 'child_process';
+
+export function registerTerminalRoutes({
+  app,
+  getCurrentProjectPath,
+  nextTerminalSessionId,
+  terminalSessions
+}) {
+  async function startTerminalProcess({ command, workingDirectory }) {
+    const targetDir = workingDirectory || getCurrentProjectPath();
+
+    if (process.platform === 'win32') {
+      const cmdToRun = command.trim();
+      const safeWorkingDir = String(targetDir).replace(/"/g, '""');
+      const safeCmd = String(cmdToRun).replace(/"/g, '""');
+
+      const psScript = `$p = Start-Process -FilePath "cmd.exe" -ArgumentList "/K", "${safeCmd}" -WorkingDirectory "${safeWorkingDir}" -PassThru; Write-Output $p.Id`;
+
+      return await new Promise((resolve, reject) => {
+        const child = spawn('powershell.exe', ['-NoProfile', '-Command', psScript], {
+          windowsHide: true
+        });
+
+        let out = '';
+        let err = '';
+
+        child.stdout?.on('data', (d) => {
+          out += d.toString('utf8');
+        });
+
+        child.stderr?.on('data', (d) => {
+          err += d.toString('utf8');
+        });
+
+        child.on('error', (e) => reject(e));
+
+        child.on('close', (code) => {
+          if (code !== 0) {
+            return reject(new Error(err || `Start-Process 失败，退出码: ${code}`));
+          }
+
+          const pid = parseInt(String(out).trim(), 10);
+          if (!Number.isFinite(pid)) {
+            return reject(new Error(`无法获取终端 PID: ${out || err || 'unknown'}`));
+          }
+
+          resolve({ pid });
+        });
+      });
+    }
+
+    if (process.platform === 'darwin') {
+      const script = `tell application "Terminal" to do script "cd ${targetDir} && ${command.trim()}"`;
+      exec(`osascript -e '${script}'`, (error) => {
+        if (error) {
+          console.error('打开终端失败:', error);
+        }
+      });
+      return { pid: null };
+    }
+
+    const terminalCommand = `gnome-terminal -- bash -c "cd ${targetDir} && ${command.trim()}; exec bash" || xterm -e "cd ${targetDir} && ${command.trim()}; bash"`;
+    exec(terminalCommand, (error) => {
+      if (error) {
+        console.error('打开终端失败:', error);
+      }
+    });
+    return { pid: null };
+  }
+
+  // 在新终端中执行自定义命令
+  app.post('/api/exec-in-terminal', async (req, res) => {
+    try {
+      const { command, workingDirectory } = req.body || {};
+      if (!command || typeof command !== 'string' || !command.trim()) {
+        return res.status(400).json({ success: false, error: 'command 不能为空' });
+      }
+
+      const targetDir = workingDirectory || getCurrentProjectPath();
+      console.log(`在终端中执行命令: ${command}`);
+      console.log(`工作目录: ${targetDir}`);
+
+      const terminalSessionId = nextTerminalSessionId();
+      const now = Date.now();
+      terminalSessions.set(terminalSessionId, {
+        id: terminalSessionId,
+        command: command.trim(),
+        workingDirectory: targetDir,
+        pid: null,
+        createdAt: now,
+        lastStartedAt: now
+      });
+
+      const { pid } = await startTerminalProcess({ command, workingDirectory: targetDir });
+      const session = terminalSessions.get(terminalSessionId);
+      if (session) {
+        session.pid = pid;
+        session.lastStartedAt = Date.now();
+        terminalSessions.set(terminalSessionId, session);
+      }
+
+      res.json({
+        success: true,
+        message: `已在新终端中执行命令`,
+        session: terminalSessions.get(terminalSessionId)
+      });
+    } catch (error) {
+      console.error('在终端中执行命令失败:', error);
+      res.status(500).json({
+        success: false,
+        error: `在终端中执行命令失败: ${error.message}`
+      });
+    }
+  });
+
+  app.get('/api/terminal-sessions', async (req, res) => {
+    try {
+      const sessions = Array.from(terminalSessions.values()).sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0));
+      res.json({ success: true, sessions });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  function killTerminalPid(pid) {
+    if (!pid) return;
+
+    if (process.platform === 'win32') {
+      exec(`taskkill /pid ${pid} /T /F`, (error) => {
+        if (error) {
+          console.warn(`[终端会话] taskkill 失败(可忽略): ${error?.message || error}`);
+        }
+      });
+      return;
+    }
+
+    try {
+      process.kill(pid, 'SIGTERM');
+    } catch (e) {
+      // ignore
+    }
+  }
+
+  async function isPidAlive(pid) {
+    if (!pid) return false;
+
+    if (process.platform === 'win32') {
+      const script = `Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Out-Null; if ($?) { exit 0 } else { exit 1 }`;
+      return await new Promise((resolve) => {
+        const child = spawn('powershell.exe', ['-NoProfile', '-Command', script], { windowsHide: true });
+        child.on('error', () => resolve(false));
+        child.on('close', (code) => resolve(code === 0));
+      });
+    }
+
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  app.post('/api/terminal-sessions/:id/restart', async (req, res) => {
+    try {
+      const id = parseInt(req.params.id, 10);
+      if (!Number.isFinite(id)) {
+        return res.status(400).json({ success: false, error: 'id 非法' });
+      }
+
+      const session = terminalSessions.get(id);
+      if (!session) {
+        return res.status(404).json({ success: false, error: `终端会话 #${id} 不存在` });
+      }
+
+      const oldPid = session.pid;
+      if (oldPid) {
+        killTerminalPid(oldPid);
+      }
+
+      const { pid } = await startTerminalProcess({ command: session.command, workingDirectory: session.workingDirectory });
+      session.pid = pid;
+      session.lastStartedAt = Date.now();
+      terminalSessions.set(id, session);
+
+      res.json({ success: true, session });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/terminal-sessions/status', async (req, res) => {
+    try {
+      const cleanup = String(req.query.cleanup || 'false') === 'true';
+      const sessions = Array.from(terminalSessions.values());
+      const results = await Promise.all(sessions.map(async (s) => {
+        const alive = s?.pid ? await isPidAlive(s.pid) : false;
+        return { ...s, alive };
+      }));
+
+      if (cleanup) {
+        for (const s of results) {
+          if (s.pid && !s.alive) {
+            terminalSessions.delete(s.id);
+          }
+        }
+      }
+
+      const output = cleanup
+        ? Array.from(terminalSessions.values()).map((s) => {
+            const found = results.find(r => r.id === s.id);
+            return { ...s, alive: found?.alive ?? false };
+          }).sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0))
+        : results.sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0));
+
+      res.json({ success: true, sessions: output });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  app.delete('/api/terminal-sessions/:id', async (req, res) => {
+    try {
+      const id = parseInt(req.params.id, 10);
+      if (!Number.isFinite(id)) {
+        return res.status(400).json({ success: false, error: 'id 非法' });
+      }
+
+      const session = terminalSessions.get(id);
+      if (!session) {
+        return res.status(404).json({ success: false, error: `终端会话 #${id} 不存在` });
+      }
+
+      if (session.pid) {
+        killTerminalPid(session.pid);
+      }
+
+      terminalSessions.delete(id);
+      res.json({ success: true, removedId: id });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+}

package/src/ui/server/socket/registerUiSocketHandlers.js

@@ -0,0 +1,212 @@
+export function registerUiSocketHandlers({
+  io,
+  getProjectRoomId,
+  getCurrentProjectPath,
+  getAndBroadcastStatus,
+  getCommandHistory,
+  clearCommandHistory,
+  addCommandToHistory,
+  runningProcesses,
+  nextProcessId,
+  spawn,
+  exec,
+  path,
+  iconv
+}) {
+  io.on('connection', (socket) => {
+    console.log('客户端已连接:', socket.id);
+
+    const projectRoomId = getProjectRoomId();
+    socket.join(projectRoomId);
+    console.log(`客户端 ${socket.id} 已加入房间: ${projectRoomId}`);
+
+    getAndBroadcastStatus();
+
+    const history = getCommandHistory();
+    socket.emit('initial_command_history', { history });
+
+    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('exec_interactive', async (data) => {
+      const { command, directory, sessionId } = data;
+
+      if (!command || typeof command !== 'string' || !command.trim()) {
+        socket.emit('interactive_error', {
+          sessionId,
+          error: 'command 不能为空'
+        });
+        return;
+      }
+
+      const currentProjectPath = getCurrentProjectPath();
+      const execDirectory = directory && directory.trim()
+        ? (path.isAbsolute(directory) ? directory : path.join(currentProjectPath, directory))
+        : currentProjectPath;
+
+      console.log(`[交互式命令] ${sessionId}: ${command} (目录: ${execDirectory})`);
+
+      const processId = nextProcessId();
+      const startTime = Date.now();
+
+      let collectedStdout = '';
+      let collectedStderr = '';
+
+      const childProcess = spawn(command.trim(), [], {
+        cwd: execDirectory,
+        shell: true,
+        env: {
+          ...process.env,
+          GIT_CONFIG_PARAMETERS: "'color.ui=always' 'color.status=always' 'core.quotepath=false'",
+          FORCE_COLOR: '3',
+          NPM_CONFIG_COLOR: 'always',
+          TERM: 'xterm-256color',
+          COLORTERM: 'truecolor',
+          CLICOLOR_FORCE: '1',
+          PYTHONUNBUFFERED: '1'
+        }
+      });
+
+      runningProcesses.set(processId, {
+        childProcess,
+        command: command.trim(),
+        startTime,
+        directory: execDirectory,
+        sessionId
+      });
+
+      console.log(`[交互式命令] 创建进程 #${processId}: ${command.substring(0, 50)}`);
+
+      socket.emit('interactive_process_id', { sessionId, processId });
+
+      const isWindows = process.platform === 'win32';
+      const cmdBuiltins = ['dir', 'type', 'echo', 'set', 'path', 'cd', 'md', 'rd', 'del', 'copy', 'move', 'ren'];
+      const needsGbkConversion = isWindows && cmdBuiltins.some(builtin =>
+        command.trim().toLowerCase().startsWith(builtin + ' ') ||
+        command.trim().toLowerCase() === builtin
+      );
+
+      childProcess.stdout?.on('data', (stdoutData) => {
+        const output = needsGbkConversion ? iconv.decode(stdoutData, 'gbk') : stdoutData.toString('utf8');
+        collectedStdout += output;
+        socket.emit('interactive_stdout', { sessionId, data: output });
+      });
+
+      childProcess.stderr?.on('data', (stderrData) => {
+        let output;
+
+        if (isWindows) {
+          const utf8Output = stderrData.toString('utf8');
+
+          if (!utf8Output.includes('�') || utf8Output.match(/[\u4e00-\u9fa5]/)) {
+            output = utf8Output;
+          } else {
+            try {
+              output = iconv.decode(stderrData, 'gbk');
+            } catch (e) {
+              output = utf8Output;
+            }
+          }
+        } else {
+          output = stderrData.toString('utf8');
+        }
+
+        collectedStderr += output;
+        socket.emit('interactive_stderr', { sessionId, data: output });
+      });
+
+      childProcess.on('close', (code, signal) => {
+        runningProcesses.delete(processId);
+        console.log(`[交互式命令] 进程 #${processId} 已结束`);
+
+        const executionTime = Date.now() - startTime;
+        const error = code !== 0 ? `Command exited with code ${code}` : null;
+        addCommandToHistory(
+          command.trim(),
+          collectedStdout,
+          collectedStderr,
+          error,
+          executionTime
+        );
+
+        socket.emit('interactive_exit', {
+          sessionId,
+          code,
+          success: code === 0
+        });
+      });
+
+      childProcess.on('error', (error) => {
+        runningProcesses.delete(processId);
+        console.error(`[交互式命令] 进程 #${processId} 出错:`, error);
+
+        const executionTime = Date.now() - startTime;
+        addCommandToHistory(
+          command.trim(),
+          collectedStdout,
+          collectedStderr,
+          error.message,
+          executionTime
+        );
+
+        socket.emit('interactive_error', {
+          sessionId,
+          error: error.message
+        });
+      });
+
+      socket.on(`interactive_stdin_${sessionId}`, (inputData) => {
+        const { input } = inputData;
+        console.log(`[交互式命令] 收到 stdin 输入 (${sessionId}):`, input);
+
+        if (childProcess.stdin && !childProcess.stdin.destroyed) {
+          try {
+            childProcess.stdin.write(input + '\n');
+          } catch (err) {
+            console.error(`[交互式命令] 写入 stdin 失败:`, err);
+            socket.emit('interactive_error', {
+              sessionId,
+              error: `写入输入失败: ${err.message}`
+            });
+          }
+        }
+      });
+
+      socket.on(`interactive_stop_${sessionId}`, () => {
+        console.log(`[交互式命令] 收到停止请求 (${sessionId})`);
+
+        if (childProcess && !childProcess.killed) {
+          try {
+            if (process.platform === 'win32') {
+              exec(`taskkill /pid ${childProcess.pid} /T /F`, (error) => {
+                if (error) {
+                  console.error(`[交互式命令] taskkill 失败:`, error);
+                }
+              });
+            } else {
+              childProcess.kill('SIGTERM');
+              setTimeout(() => {
+                if (!childProcess.killed) {
+                  childProcess.kill('SIGKILL');
+                }
+              }, 2000);
+            }
+          } catch (err) {
+            console.error(`[交互式命令] 停止进程失败:`, err);
+          }
+        }
+      });
+    });
+
+    socket.on('disconnect', () => {
+      console.log(`客户端已断开连接: ${socket.id} (房间: ${getProjectRoomId()})`);
+    });
+  });
+}

package/src/ui/server/utils/createSavePortToFile.js

@@ -0,0 +1,32 @@
+export function createSavePortToFile({ savePort, fs, path, cwdFn = process.cwd }) {
+  let savedPort = null;
+
+  return async function savePortToFile(port) {
+    try {
+      if (savePort && savedPort !== port) {
+        savedPort = port;
+
+        const portFilePath = path.join(cwdFn(), '.port');
+        await fs.writeFile(portFilePath, port.toString(), 'utf8');
+        console.log(`端口号 ${port} 已保存到 ${portFilePath}`);
+
+        try {
+          const clientPath = path.join(cwdFn(), '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);
+    }
+  };
+}

package/src/ui/server/utils/startServerOnAvailablePort.js

@@ -0,0 +1,87 @@
+export async function startServerOnAvailablePort({
+  httpServer,
+  startPort,
+  chalk,
+  open,
+  noOpen,
+  isGitRepo,
+  savePortToFile,
+  maxTries = 100,
+  callbackExecutedRef
+}) {
+  let currentPort = startPort;
+  const maxPort = startPort + maxTries;
+  const getCallbackExecuted = () => {
+    if (callbackExecutedRef && typeof callbackExecutedRef === 'object' && 'value' in callbackExecutedRef) {
+      return Boolean(callbackExecutedRef.value);
+    }
+    return false;
+  };
+
+  const setCallbackExecuted = (value) => {
+    if (callbackExecutedRef && typeof callbackExecutedRef === 'object' && 'value' in callbackExecutedRef) {
+      callbackExecutedRef.value = Boolean(value);
+    }
+  };
+
+  while (currentPort < maxPort) {
+    try {
+      if (currentPort > startPort) {
+        await new Promise(resolve => setTimeout(resolve, 800));
+        console.log(`尝试端口 ${currentPort}...`);
+      }
+
+      await new Promise((resolve, reject) => {
+        const errorHandler = (err) => {
+          httpServer.removeListener('error', errorHandler);
+          reject(err);
+        };
+
+        httpServer.once('error', errorHandler);
+
+        httpServer.listen(currentPort, () => {
+          if (getCallbackExecuted()) return;
+          setCallbackExecuted(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仓库`));
+          } else {
+            console.log(chalk.yellow(`  当前目录不是Git仓库，文件监控未启动`));
+          }
+
+          console.log(chalk.green('======================================'));
+
+          savePortToFile(currentPort);
+
+          if (!noOpen) {
+            setTimeout(() => {
+              open(`http://localhost:${currentPort}`);
+            }, 0);
+          }
+
+          resolve();
+        });
+      });
+
+      return currentPort;
+    } catch (err) {
+      if (err.code === 'EADDRINUSE') {
+        console.log(`端口 ${currentPort} 被占用，尝试下一个端口...`);
+        currentPort++;
+      } else {
+        console.error('启动服务器失败:', err);
+        process.exit(1);
+      }
+    }
+  }
+
+  console.error(`无法找到可用端口 (尝试范围: ${startPort}-${maxPort - 1})`);
+  process.exit(1);
+}